@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/hotfix-YA3DGLOM.js

@@ -0,0 +1,1477 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import './chunk-ZZOXM6Q4.js';
+import { createError } from './chunk-JQXOVCOP.js';
+import { tryResolveDatabaseUrl } from './chunk-KWX3JHCY.js';
+import './chunk-NPSRD26F.js';
+import { loadEnvFiles } from './chunk-644FVGIQ.js';
+import { isPathContained } from './chunk-DRSUEMAK.js';
+import './chunk-II7VYQEM.js';
+import './chunk-VM3IWOT5.js';
+import './chunk-JMJP4A47.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { Command } from 'commander';
+import { CLIError, createCLILogger, createDbSnapshot } from '@runa-ai/runa';
+import { execa } from 'execa';
+import { fromPromise, setup, assign, createActor } from 'xstate';
+import { existsSync } from 'fs';
+import { writeFile, rm, readFile, mkdir, readdir } from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+
+createRequire(import.meta.url);
+
+// src/commands/hotfix/index.ts
+init_esm_shims();
+
+// src/commands/hotfix/commands/hotfix-complete.ts
+init_esm_shims();
+
+// src/commands/hotfix/utils/hotfix-machine-helper.ts
+init_esm_shims();
+
+// src/commands/hotfix/machine.ts
+init_esm_shims();
+
+// src/commands/hotfix/actors.ts
+init_esm_shims();
+
+// src/commands/hotfix/metadata.ts
+init_esm_shims();
+
+// src/commands/hotfix/contract.ts
+init_esm_shims();
+var HotfixStatusSchema = z.enum(["in_progress", "deployed", "completed", "cancelled"]);
+var HotfixMetadataSchema = z.object({
+  branch: z.string(),
+  base: z.string(),
+  snapshot: z.string().optional(),
+  createdAt: z.string(),
+  createdBy: z.string(),
+  status: HotfixStatusSchema,
+  deployedAt: z.string().optional(),
+  completedAt: z.string().optional()
+}).strict();
+z.object({
+  /** Hotfix name (will be prefixed with hotfix/) */
+  name: z.string().min(1, "Hotfix name is required"),
+  /** Base commit/tag to branch from */
+  base: z.string().optional(),
+  /** Skip pre-hotfix database snapshot */
+  skipSnapshot: z.boolean().default(false),
+  /** Target directory (defaults to cwd) */
+  targetDir: z.string().optional()
+}).strict();
+var CreateHotfixMetadataInputSchema = z.object({
+  /** Validated branch name (e.g., hotfix/fix-auth-bug) */
+  branch: z.string().min(1),
+  /** Base commit/tag to branch from */
+  base: z.string().min(1),
+  /** Skip pre-hotfix database snapshot */
+  skipSnapshot: z.boolean().optional(),
+  /** Target directory (defaults to cwd) */
+  targetDir: z.string().optional()
+}).strict();
+z.object({
+  /** Skip confirmation prompts */
+  autoApprove: z.boolean().default(false),
+  /** Skip type check and build */
+  skipChecks: z.boolean().default(false),
+  /** Preview without applying */
+  dryRun: z.boolean().default(false),
+  /** Target directory (defaults to cwd) */
+  targetDir: z.string().optional()
+}).strict();
+z.object({
+  /** Direct merge without PR (dangerous) */
+  noPr: z.boolean().default(false),
+  /** Skip confirmation prompts */
+  autoApprove: z.boolean().default(false),
+  /** Preview without applying */
+  dryRun: z.boolean().default(false),
+  /** Keep hotfix branch after merge */
+  deleteBranch: z.boolean().default(true),
+  /** Target directory (defaults to cwd) */
+  targetDir: z.string().optional()
+}).strict();
+var GetHotfixInputSchema = z.object({
+  targetDir: z.string().optional()
+}).strict();
+var UpdateHotfixInputSchema = z.object({
+  status: HotfixStatusSchema,
+  deployedAt: z.string().optional(),
+  completedAt: z.string().optional(),
+  targetDir: z.string().optional()
+}).strict();
+var ListArchivedHotfixesInputSchema = z.object({
+  limit: z.number().optional(),
+  targetDir: z.string().optional()
+}).strict();
+var ListArchivedHotfixesOutputSchema = z.object({
+  hotfixes: z.array(HotfixMetadataSchema)
+}).strict();
+z.object({
+  metadata: HotfixMetadataSchema,
+  snapshotFile: z.string().optional()
+});
+z.object({
+  deployedAt: z.string()
+});
+z.object({
+  prUrl: z.string(),
+  completedAt: z.string()
+});
+z.object({
+  targetDir: z.string().optional(),
+  existingMetadata: HotfixMetadataSchema.nullable().optional()
+});
+z.object({
+  success: z.boolean(),
+  exitCode: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+  finalState: z.string(),
+  metadata: HotfixMetadataSchema.nullable(),
+  prUrl: z.string().optional(),
+  error: z.string().optional()
+});
+
+// src/commands/hotfix/metadata.ts
+function getHotfixDir(targetDir) {
+  return path.join(targetDir, ".runa", "hotfix");
+}
+function getCurrentFile(targetDir) {
+  return path.join(getHotfixDir(targetDir), "current.json");
+}
+function getArchiveDir(targetDir) {
+  return path.join(getHotfixDir(targetDir), "archive");
+}
+async function ensureHotfixDir(targetDir) {
+  await mkdir(getHotfixDir(targetDir), { recursive: true });
+}
+async function ensureArchiveDir(targetDir) {
+  await mkdir(getArchiveDir(targetDir), { recursive: true });
+}
+async function getHotfixMetadata(input = {}) {
+  const parsed = GetHotfixInputSchema.parse(input);
+  const targetDir = parsed.targetDir ? path.resolve(parsed.targetDir) : process.cwd();
+  const currentFile = getCurrentFile(targetDir);
+  if (!existsSync(currentFile)) {
+    return null;
+  }
+  const content = await readFile(currentFile, "utf-8");
+  return HotfixMetadataSchema.parse(JSON.parse(content));
+}
+async function createHotfixMetadata(input) {
+  const parsed = CreateHotfixMetadataInputSchema.parse(input);
+  const targetDir = parsed.targetDir ? path.resolve(parsed.targetDir) : process.cwd();
+  await ensureHotfixDir(targetDir);
+  const metadata = {
+    branch: parsed.branch,
+    base: parsed.base,
+    snapshot: parsed.skipSnapshot ? void 0 : `snapshot-${Date.now()}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdBy: process.env.USER || process.env.GITHUB_ACTOR || "unknown",
+    status: "in_progress"
+  };
+  const currentFile = getCurrentFile(targetDir);
+  await writeFile(currentFile, `${JSON.stringify(metadata, null, 2)}
+`, "utf-8");
+  return metadata;
+}
+async function updateHotfixStatus(input) {
+  const parsed = UpdateHotfixInputSchema.parse(input);
+  const targetDir = parsed.targetDir ? path.resolve(parsed.targetDir) : process.cwd();
+  const current = await getHotfixMetadata({ targetDir });
+  if (!current) {
+    throw createError("HOTFIX_NOT_FOUND");
+  }
+  const updated = {
+    ...current,
+    status: parsed.status,
+    deployedAt: parsed.deployedAt || current.deployedAt,
+    completedAt: parsed.completedAt || current.completedAt
+  };
+  const currentFile = getCurrentFile(targetDir);
+  await writeFile(currentFile, `${JSON.stringify(updated, null, 2)}
+`, "utf-8");
+  return updated;
+}
+async function archiveHotfix(targetDir) {
+  const dir = targetDir ? path.resolve(targetDir) : process.cwd();
+  const current = await getHotfixMetadata({ targetDir: dir });
+  if (!current) {
+    throw createError("HOTFIX_NOT_FOUND");
+  }
+  await ensureArchiveDir(dir);
+  const archiveFile = path.join(
+    getArchiveDir(dir),
+    `${current.branch.replace(/\//g, "-")}-${Date.now()}.json`
+  );
+  const archived = {
+    ...current,
+    status: current.status === "in_progress" ? "completed" : current.status,
+    completedAt: current.completedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeFile(archiveFile, `${JSON.stringify(archived, null, 2)}
+`, "utf-8");
+  const currentFile = getCurrentFile(dir);
+  await rm(currentFile, { force: true });
+  return archived;
+}
+async function cancelHotfix(targetDir) {
+  const dir = targetDir ? path.resolve(targetDir) : process.cwd();
+  await updateHotfixStatus({
+    status: "cancelled",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    targetDir: dir
+  });
+  return archiveHotfix(dir);
+}
+async function listArchivedHotfixes(input = {}) {
+  const parsed = ListArchivedHotfixesInputSchema.parse(input);
+  const targetDir = parsed.targetDir ? path.resolve(parsed.targetDir) : process.cwd();
+  const archiveDir = getArchiveDir(targetDir);
+  if (!existsSync(archiveDir)) {
+    return { hotfixes: [] };
+  }
+  const files = await readdir(archiveDir);
+  const hotfixes = [];
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    try {
+      const filePath = path.join(archiveDir, file);
+      if (!isPathContained(archiveDir, filePath)) {
+        continue;
+      }
+      const content = await readFile(filePath, "utf-8");
+      hotfixes.push(HotfixMetadataSchema.parse(JSON.parse(content)));
+    } catch {
+    }
+  }
+  hotfixes.sort((a, b) => {
+    const dateA = new Date(a.completedAt || a.createdAt);
+    const dateB = new Date(b.completedAt || b.createdAt);
+    return dateB.getTime() - dateA.getTime();
+  });
+  const limited = parsed.limit ? hotfixes.slice(0, parsed.limit) : hotfixes;
+  return ListArchivedHotfixesOutputSchema.parse({ hotfixes: limited });
+}
+function validateHotfixName(name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!sanitized) {
+    throw createError("HOTFIX_INVALID_NAME", { name });
+  }
+  return `hotfix/${sanitized}`;
+}
+
+// src/commands/hotfix/actors.ts
+var createHotfix = fromPromise(
+  async ({ input }) => {
+    const branchName = validateHotfixName(input.name);
+    const metadata = await createHotfixMetadata({
+      branch: branchName,
+      base: input.base || "origin/main",
+      targetDir: input.targetDir
+    });
+    return { metadata };
+  }
+);
+var deployHotfix = fromPromise(
+  async ({ input }) => {
+    const deployedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await updateHotfixStatus({
+      status: "deployed",
+      deployedAt,
+      targetDir: input.targetDir
+    });
+    return { deployedAt };
+  }
+);
+var completeHotfix = fromPromise(
+  async ({ input }) => {
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await archiveHotfix(input.targetDir);
+    return { prUrl: "", completedAt };
+  }
+);
+var cancelHotfix2 = fromPromise(
+  async ({ input }) => {
+    await cancelHotfix(input.targetDir);
+  }
+);
+var loadMetadata = fromPromise(
+  async ({ input }) => {
+    return getHotfixMetadata({ targetDir: input.targetDir });
+  }
+);
+
+// src/commands/hotfix/machine.ts
+var e2eMeta = {
+  loading: {
+    description: "Load existing hotfix metadata to determine current state",
+    severity: "blocking",
+    observables: {
+      log: "Loading hotfix metadata",
+      fs: ".hotfix/metadata.json (read)"
+    },
+    assertions: [
+      "expect(log).toContain('Loading hotfix metadata')",
+      "expect(ctx.metadata).toBeDefined().or.toBeNull()"
+    ],
+    nextStates: ["idle", "inProgress", "deployed"]
+  },
+  idle: {
+    description: "No active hotfix - ready to create new one",
+    severity: "non-critical",
+    observables: {
+      log: "No active hotfix"
+    },
+    assertions: ["expect(log).toContain('No active hotfix')", "expect(ctx.metadata).toBeNull()"],
+    nextStates: ["creating"]
+  },
+  creating: {
+    description: "Create hotfix branch and metadata",
+    severity: "blocking",
+    observables: {
+      log: "Creating hotfix branch",
+      fs: ".hotfix/metadata.json (created)",
+      git: "hotfix/* branch created"
+    },
+    assertions: [
+      "expect(log).toContain('Creating hotfix branch')",
+      "expect(file('.hotfix/metadata.json')).toExist()"
+    ],
+    nextStates: ["inProgress", "idle"]
+  },
+  inProgress: {
+    description: "Hotfix created and being worked on",
+    severity: "non-critical",
+    observables: {
+      log: "Hotfix in progress"
+    },
+    assertions: [
+      "expect(log).toContain('Hotfix in progress')",
+      "expect(ctx.metadata.status).toBe('in_progress')"
+    ],
+    nextStates: ["deploying", "cancelling"]
+  },
+  deploying: {
+    description: "Deploy hotfix to production",
+    severity: "blocking",
+    observables: {
+      log: "Deploying hotfix to production",
+      api: "Vercel deployment triggered"
+    },
+    assertions: ["expect(log).toContain('Deploying hotfix to production')"],
+    nextStates: ["deployed", "inProgress"]
+  },
+  deployed: {
+    description: "Hotfix successfully deployed to production",
+    severity: "non-critical",
+    observables: {
+      log: "Hotfix deployed successfully"
+    },
+    assertions: [
+      "expect(log).toContain('Hotfix deployed successfully')",
+      "expect(ctx.metadata.status).toBe('deployed')"
+    ],
+    nextStates: ["completing", "cancelling"]
+  },
+  completing: {
+    description: "Complete hotfix by merging back to main",
+    severity: "blocking",
+    observables: {
+      log: "Completing hotfix",
+      git: "PR created or direct merge"
+    },
+    assertions: ["expect(log).toContain('Completing hotfix')"],
+    nextStates: ["completed", "deployed"]
+  },
+  cancelling: {
+    description: "Cancel hotfix and restore original state",
+    severity: "blocking",
+    observables: {
+      log: "Cancelling hotfix",
+      git: "Branch deleted, snapshot restored"
+    },
+    assertions: ["expect(log).toContain('Cancelling hotfix')"],
+    nextStates: ["cancelled", "inProgress"]
+  },
+  completed: {
+    description: "Hotfix workflow completed successfully",
+    severity: "final",
+    observables: {
+      log: "Hotfix completed successfully",
+      exit: 0
+    },
+    assertions: [
+      "expect(log).toContain('Hotfix completed successfully')",
+      "expect(exitCode).toBe(0)"
+    ],
+    nextStates: []
+  },
+  cancelled: {
+    description: "Hotfix workflow cancelled by user",
+    severity: "final",
+    observables: {
+      log: "Hotfix cancelled",
+      exit: 2
+    },
+    assertions: ["expect(log).toContain('Hotfix cancelled')", "expect(exitCode).toBe(2)"],
+    nextStates: []
+  }
+};
+var hotfixMachine = setup({
+  types: {
+    context: {},
+    input: {},
+    events: {},
+    output: {}
+  },
+  actors: {
+    createHotfix,
+    deployHotfix,
+    completeHotfix,
+    cancelHotfix: cancelHotfix2,
+    loadMetadata
+  },
+  guards: {
+    hasActiveHotfix: ({ context }) => context.metadata !== null,
+    isInProgress: ({ context }) => context.metadata?.status === "in_progress",
+    isDeployed: ({ context }) => context.metadata?.status === "deployed"
+  },
+  actions: {
+    setMetadata: assign({
+      metadata: (_, params) => params.metadata
+    }),
+    setError: assign({
+      error: (_, params) => params.error
+    }),
+    setPrUrl: assign({
+      prUrl: (_, params) => params.prUrl
+    }),
+    clearError: assign({
+      error: () => void 0
+    })
+  }
+}).createMachine({
+  id: "hotfix",
+  initial: "loading",
+  context: ({ input }) => ({
+    targetDir: input?.targetDir || process.cwd(),
+    metadata: input?.existingMetadata || null
+  }),
+  // Machine output (returned on completion)
+  output: ({ context, self }) => {
+    const state = self.getSnapshot().value;
+    const isCancelled = state === "cancelled";
+    const isSuccess = state === "completed";
+    return {
+      success: isSuccess,
+      exitCode: isCancelled ? 2 : isSuccess ? 0 : 1,
+      finalState: state,
+      metadata: context.metadata,
+      prUrl: context.prUrl,
+      error: context.error
+    };
+  },
+  states: {
+    // Initial state: Load existing metadata to determine current state
+    loading: {
+      meta: { e2e: e2eMeta.loading },
+      invoke: {
+        id: "loadMetadata",
+        src: "loadMetadata",
+        input: ({ context }) => ({ targetDir: context.targetDir }),
+        onDone: [
+          {
+            guard: ({ event }) => event.output?.status === "in_progress",
+            target: "inProgress",
+            actions: assign({ metadata: ({ event }) => event.output })
+          },
+          {
+            guard: ({ event }) => event.output?.status === "deployed",
+            target: "deployed",
+            actions: assign({ metadata: ({ event }) => event.output })
+          },
+          {
+            target: "idle",
+            actions: assign({ metadata: ({ event }) => event.output })
+          }
+        ],
+        onError: {
+          target: "idle",
+          actions: assign({ error: ({ event }) => String(event.error) })
+        }
+      }
+    },
+    // No active hotfix
+    idle: {
+      meta: { e2e: e2eMeta.idle },
+      on: {
+        CREATE: {
+          target: "creating"
+        }
+      }
+    },
+    // Creating hotfix branch and metadata
+    creating: {
+      meta: { e2e: e2eMeta.creating },
+      invoke: {
+        id: "createHotfix",
+        src: "createHotfix",
+        input: ({ context, event }) => {
+          if (event.type !== "CREATE") {
+            throw new Error("Invalid event type for creating state");
+          }
+          return {
+            targetDir: context.targetDir,
+            name: event.name,
+            base: event.base,
+            skipSnapshot: event.skipSnapshot
+          };
+        },
+        onDone: {
+          target: "inProgress",
+          actions: assign({ metadata: ({ event }) => event.output.metadata })
+        },
+        onError: {
+          target: "idle",
+          actions: assign({ error: ({ event }) => String(event.error) })
+        }
+      }
+    },
+    // Hotfix created, being worked on
+    inProgress: {
+      meta: { e2e: e2eMeta.inProgress },
+      on: {
+        DEPLOY: {
+          target: "deploying"
+        },
+        CANCEL: {
+          target: "cancelling"
+        }
+      }
+    },
+    // Deploying to production
+    deploying: {
+      meta: { e2e: e2eMeta.deploying },
+      invoke: {
+        id: "deployHotfix",
+        src: "deployHotfix",
+        input: ({ context, event }) => {
+          if (event.type !== "DEPLOY") {
+            throw new Error("Invalid event type for deploying state");
+          }
+          return {
+            targetDir: context.targetDir,
+            autoApprove: event.autoApprove,
+            skipChecks: event.skipChecks
+          };
+        },
+        onDone: {
+          target: "deployed",
+          actions: assign({
+            metadata: ({ context, event }) => context.metadata ? {
+              ...context.metadata,
+              status: "deployed",
+              deployedAt: event.output.deployedAt
+            } : null
+          })
+        },
+        onError: {
+          target: "inProgress",
+          actions: assign({ error: ({ event }) => String(event.error) })
+        }
+      }
+    },
+    // Deployed to production
+    deployed: {
+      meta: { e2e: e2eMeta.deployed },
+      on: {
+        COMPLETE: {
+          target: "completing"
+        },
+        CANCEL: {
+          target: "cancelling"
+        }
+      }
+    },
+    // Completing hotfix (merging back)
+    completing: {
+      meta: { e2e: e2eMeta.completing },
+      invoke: {
+        id: "completeHotfix",
+        src: "completeHotfix",
+        input: ({ context, event }) => {
+          if (event.type !== "COMPLETE") {
+            throw new Error("Invalid event type for completing state");
+          }
+          return {
+            targetDir: context.targetDir,
+            noPr: event.noPr,
+            autoApprove: event.autoApprove
+          };
+        },
+        onDone: {
+          target: "completed",
+          actions: assign({
+            prUrl: ({ event }) => event.output.prUrl,
+            metadata: ({ context, event }) => context.metadata ? {
+              ...context.metadata,
+              status: "completed",
+              completedAt: event.output.completedAt
+            } : null
+          })
+        },
+        onError: {
+          target: "deployed",
+          actions: assign({ error: ({ event }) => String(event.error) })
+        }
+      }
+    },
+    // Cancelling hotfix
+    cancelling: {
+      meta: { e2e: e2eMeta.cancelling },
+      invoke: {
+        id: "cancelHotfix",
+        src: "cancelHotfix",
+        input: ({ context }) => ({ targetDir: context.targetDir }),
+        onDone: {
+          target: "cancelled",
+          actions: assign({
+            metadata: ({ context }) => context.metadata ? {
+              ...context.metadata,
+              status: "cancelled",
+              completedAt: (/* @__PURE__ */ new Date()).toISOString()
+            } : null
+          })
+        },
+        onError: {
+          target: "inProgress",
+          actions: assign({ error: ({ event }) => String(event.error) })
+        }
+      }
+    },
+    // Final states
+    completed: {
+      meta: { e2e: e2eMeta.completed },
+      type: "final"
+    },
+    cancelled: {
+      meta: { e2e: e2eMeta.cancelled },
+      type: "final"
+    }
+  }
+});
+function getHotfixStateName(snapshot) {
+  return snapshot.value;
+}
+function isHotfixComplete(snapshot) {
+  return snapshot.status === "done";
+}
+function getAvailableHotfixEvents(snapshot) {
+  const state = snapshot.value;
+  switch (state) {
+    case "idle":
+      return ["CREATE"];
+    case "inProgress":
+      return ["DEPLOY", "CANCEL"];
+    case "deployed":
+      return ["COMPLETE", "CANCEL"];
+    default:
+      return [];
+  }
+}
+
+// src/commands/hotfix/utils/hotfix-machine-helper.ts
+async function createHotfixActor(targetDir = process.cwd(), options = {}) {
+  const { timeout = 1e4 } = options;
+  const actor = createActor(hotfixMachine, {
+    input: { targetDir }
+  });
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      actor.stop();
+      reject(new Error("Hotfix machine initialization timed out"));
+    }, timeout);
+    actor.subscribe((snapshot) => {
+      const state = snapshot.value;
+      if (state !== "loading") {
+        clearTimeout(timeoutId);
+        resolve(actor);
+      }
+    });
+    actor.start();
+  });
+}
+async function sendAndWait(actor, event, targetStates, options = {}) {
+  const { timeout = 6e4, transitionStates = [] } = options;
+  actor.send(event);
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`State transition timed out after sending ${event.type}`));
+    }, timeout);
+    const subscription = actor.subscribe((snapshot) => {
+      const state = snapshot.value;
+      const error = snapshot.context.error;
+      if (targetStates.includes(state)) {
+        clearTimeout(timeoutId);
+        subscription.unsubscribe();
+        resolve(snapshot);
+        return;
+      }
+      if (error && !transitionStates.includes(state) && !targetStates.includes(state)) {
+        clearTimeout(timeoutId);
+        subscription.unsubscribe();
+        reject(new Error(error));
+        return;
+      }
+      if (snapshot.status === "done") {
+        clearTimeout(timeoutId);
+        subscription.unsubscribe();
+        resolve(snapshot);
+      }
+    });
+  });
+}
+function getHotfixState(snapshot) {
+  return {
+    state: getHotfixStateName(snapshot),
+    isComplete: isHotfixComplete(snapshot),
+    availableEvents: getAvailableHotfixEvents(snapshot),
+    metadata: snapshot.context.metadata ? {
+      branch: snapshot.context.metadata.branch,
+      base: snapshot.context.metadata.base,
+      status: snapshot.context.metadata.status,
+      createdAt: snapshot.context.metadata.createdAt,
+      deployedAt: snapshot.context.metadata.deployedAt
+    } : null,
+    error: snapshot.context.error,
+    prUrl: snapshot.context.prUrl
+  };
+}
+function canSendEvent(snapshot, eventType) {
+  return getAvailableHotfixEvents(snapshot).includes(eventType);
+}
+
+// src/commands/hotfix/commands/hotfix-complete.ts
+var completeStateErrors = {
+  idle: {
+    code: "HOTFIX_NOT_FOUND",
+    hints: ["No hotfix in progress", "Check: runa hotfix status"]
+  },
+  inProgress: {
+    code: "HOTFIX_NOT_DEPLOYED",
+    hints: ["Deploy first: runa hotfix deploy --auto-approve"]
+  },
+  completed: {
+    code: "HOTFIX_ALREADY_COMPLETED",
+    hints: ["Run: runa hotfix status"]
+  },
+  cancelled: {
+    code: "HOTFIX_ALREADY_COMPLETED",
+    hints: ["Run: runa hotfix status"]
+  }
+};
+function validateCanComplete(actor) {
+  const snapshot = actor.getSnapshot();
+  const initialState = getHotfixState(snapshot);
+  if (!canSendEvent(snapshot, "COMPLETE")) {
+    const currentState = initialState.state;
+    const errorInfo = completeStateErrors[currentState];
+    if (errorInfo) {
+      const message = currentState === "idle" ? "No active hotfix found" : currentState === "inProgress" ? "Hotfix not deployed yet" : `Hotfix already ${currentState}`;
+      throw new CLIError(message, errorInfo.code, errorInfo.hints);
+    }
+    throw new CLIError(`Cannot complete in state: ${currentState}`, "HOTFIX_INVALID_STATE", [
+      "Run: runa hotfix status"
+    ]);
+  }
+  const metadata = initialState.metadata;
+  if (!metadata?.branch) {
+    throw new CLIError("Hotfix metadata is missing branch info", "HOTFIX_METADATA_INVALID");
+  }
+  return { branch: metadata.branch, mainBranch: getMainBranch() };
+}
+async function getMainBranch() {
+  try {
+    await execa("git", ["rev-parse", "--verify", "origin/main"], { stdio: "pipe" });
+    return "main";
+  } catch {
+    return "master";
+  }
+}
+async function createPullRequest(branchName, mainBranch, _logger) {
+  try {
+    await execa("gh", ["--version"], { stdio: "pipe" });
+  } catch {
+    throw new CLIError("GitHub CLI not found", "HOTFIX_GH_NOT_FOUND", [
+      "Install GitHub CLI: brew install gh",
+      "Or create PR manually on GitHub"
+    ]);
+  }
+  const prTitle = `Hotfix: ${branchName.replace("hotfix/", "")}`;
+  const prBody = `## Hotfix PR
+
+This PR contains emergency fixes deployed via \`runa hotfix\`.
+
+### Changes
+- See commits for details
+
+### Checklist
+- [x] Deployed to production
+- [ ] Verified in production
+- [ ] Ready to merge to ${mainBranch}
+`;
+  try {
+    const result = await execa(
+      "gh",
+      [
+        "pr",
+        "create",
+        "--base",
+        mainBranch,
+        "--head",
+        branchName,
+        "--title",
+        prTitle,
+        "--body",
+        prBody
+      ],
+      { stdio: "pipe" }
+    );
+    return result.stdout.trim();
+  } catch {
+    try {
+      const viewResult = await execa("gh", ["pr", "view", branchName, "--json", "url"], {
+        stdio: "pipe"
+      });
+      const prData = JSON.parse(viewResult.stdout);
+      return prData.url;
+    } catch {
+      throw new CLIError("Failed to create PR", "HOTFIX_PR_CREATE_FAILED", [
+        "Check gh CLI authentication",
+        "Create PR manually on GitHub"
+      ]);
+    }
+  }
+}
+async function mergePullRequest(branchName, _logger) {
+  try {
+    await execa("gh", ["pr", "merge", branchName, "--squash", "--delete-branch"], {
+      stdio: "inherit"
+    });
+  } catch {
+    throw new CLIError("Failed to merge PR", "HOTFIX_PR_MERGE_FAILED", [
+      "Merge manually on GitHub",
+      "Check for merge conflicts"
+    ]);
+  }
+}
+async function directMerge(branchName, mainBranch, logger) {
+  logger.warn("\u26A0\uFE0F  Direct merge without PR (not recommended)");
+  await execa("git", ["checkout", mainBranch], { stdio: "inherit" });
+  await execa("git", ["pull", "origin", mainBranch], { stdio: "inherit" });
+  try {
+    await execa("git", ["merge", branchName, "--no-ff", "-m", `Merge ${branchName}`], {
+      stdio: "inherit"
+    });
+  } catch {
+    throw new CLIError("Merge conflict detected", "HOTFIX_MERGE_CONFLICT", [
+      "Resolve conflicts manually",
+      "Then: git add . && git commit",
+      "Finally: runa hotfix complete"
+    ]);
+  }
+  await execa("git", ["push", "origin", mainBranch], { stdio: "inherit" });
+}
+async function deleteBranch(branchName, logger) {
+  try {
+    await execa("git", ["branch", "-D", branchName], { stdio: "pipe" });
+    logger.info(`Deleted local branch: ${branchName}`);
+  } catch {
+    logger.warn(`Could not delete local branch: ${branchName}`);
+  }
+  try {
+    await execa("git", ["push", "origin", "--delete", branchName], { stdio: "pipe" });
+    logger.info(`Deleted remote branch: ${branchName}`);
+  } catch {
+    logger.warn(`Could not delete remote branch: ${branchName}`);
+  }
+}
+async function runCompleteAction(options) {
+  const logger = createCLILogger("hotfix:complete");
+  logger.step("Initializing hotfix workflow", 1);
+  const actor = await createHotfixActor(process.cwd());
+  const { branch, mainBranch: mainBranchPromise } = validateCanComplete(actor);
+  const mainBranch = await mainBranchPromise;
+  logger.section("Hotfix Completion");
+  logger.info(`Branch: ${branch}`);
+  logger.info(`Target: ${mainBranch}`);
+  if (options.dryRun) {
+    logger.info("\n[DRY RUN] Would complete hotfix:");
+    logger.info(`  1. Create PR: ${branch} \u2192 ${mainBranch}`);
+    logger.info("  2. Merge PR (squash)");
+    if (options.deleteBranch !== false) {
+      logger.info(`  3. Delete branch: ${branch}`);
+    }
+    actor.stop();
+    return;
+  }
+  if (!options.autoApprove) {
+    throw new CLIError(
+      "Hotfix completion requires explicit confirmation",
+      "HOTFIX_COMPLETE_CONFIRM_REQUIRED",
+      ["Use --auto-approve to confirm", "Use --dry-run to preview"]
+    );
+  }
+  let prUrl;
+  if (options.noPr) {
+    await directMerge(branch, mainBranch, logger);
+  } else {
+    logger.step("Creating PR", 2);
+    prUrl = await createPullRequest(branch, mainBranch);
+    logger.success(`PR created: ${prUrl}`);
+    logger.step("Merging PR", 3);
+    await mergePullRequest(branch);
+    logger.success("PR merged");
+  }
+  if (options.noPr && options.deleteBranch !== false) {
+    logger.step("Cleaning up branch", 4);
+    await deleteBranch(branch, logger);
+  }
+  logger.step("Archiving hotfix metadata", 5);
+  try {
+    const snapshot = await sendAndWait(
+      actor,
+      { type: "COMPLETE", noPr: options.noPr, autoApprove: options.autoApprove },
+      ["completed"],
+      { transitionStates: ["completing"], timeout: 1e4 }
+    );
+    const finalState = getHotfixState(snapshot);
+    if (finalState.error) {
+      throw new Error(finalState.error);
+    }
+  } catch (error) {
+    throw new CLIError(
+      error instanceof Error ? error.message : "Failed to archive hotfix metadata",
+      "HOTFIX_ARCHIVE_FAILED",
+      ["Merge succeeded but archiving failed", "Run: runa hotfix status"]
+    );
+  }
+  try {
+    await execa("git", ["checkout", mainBranch], { stdio: "pipe" });
+    await execa("git", ["pull", "origin", mainBranch], { stdio: "pipe" });
+  } catch {
+  }
+  actor.stop();
+  logger.success("\n\u2705 Hotfix completed");
+  logger.info("\nSummary:");
+  logger.info(`  \u2713 Merged to ${mainBranch}`);
+  logger.info(`  \u2713 Branch ${branch} cleaned up`);
+  logger.info("  \u2713 Metadata archived");
+  if (prUrl) {
+    logger.info(`  \u2713 PR: ${prUrl}`);
+  }
+}
+var completeCommand = new Command("complete").description("Complete hotfix: merge to main and cleanup").option("--no-pr", "Direct merge without PR (dangerous)").option("--auto-approve", "Skip confirmation prompts").option("--dry-run", "Show what would happen without applying").option("--no-delete-branch", "Keep hotfix branch after merge").action(async (options) => {
+  try {
+    await runCompleteAction(options);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      error instanceof Error ? error.message : "Hotfix completion failed",
+      "HOTFIX_COMPLETE_FAILED",
+      ["Check git status", "Verify GitHub CLI authentication"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/hotfix/commands/hotfix-create.ts
+init_esm_shims();
+function validateCanCreate(actor) {
+  const snapshot = actor.getSnapshot();
+  const initialState = getHotfixState(snapshot);
+  if (canSendEvent(snapshot, "CREATE")) return;
+  const currentState = initialState.state;
+  if (currentState === "inProgress" || currentState === "deployed") {
+    throw new CLIError("A hotfix is already in progress", "HOTFIX_ALREADY_EXISTS", [
+      `Current state: ${currentState}`,
+      `Branch: ${initialState.metadata?.branch ?? "unknown"}`,
+      "Complete or cancel existing hotfix first",
+      "Run: runa hotfix status"
+    ]);
+  }
+  throw new CLIError(`Cannot create hotfix in state: ${currentState}`, "HOTFIX_INVALID_STATE", [
+    "Run: runa hotfix status"
+  ]);
+}
+async function createPreHotfixSnapshot(baseBranch, logger) {
+  logger.step("Creating pre-hotfix snapshot (safety)", 2);
+  try {
+    loadEnvFiles({ runaEnv: "production", silent: true });
+    const productionUrl = tryResolveDatabaseUrl("production");
+    if (!productionUrl) {
+      logger.warn("No production database URL found, skipping snapshot");
+      return void 0;
+    }
+    const result = await createDbSnapshot({
+      databaseUrl: productionUrl,
+      environment: "production",
+      commit: baseBranch,
+      targetDir: process.cwd()
+    });
+    logger.success(`Snapshot created: ${result.filename}`);
+    return result.filename;
+  } catch (error) {
+    logger.warn(`Snapshot failed: ${error instanceof Error ? error.message : "Unknown"}`);
+    logger.warn("Continuing without snapshot");
+    return void 0;
+  }
+}
+async function rollbackBranch(branchName, logger) {
+  logger.warn("Metadata save failed, rolling back branch...");
+  try {
+    await execa("git", ["checkout", "-"], { stdio: "pipe" });
+    await execa("git", ["branch", "-D", branchName], { stdio: "pipe" });
+  } catch {
+  }
+}
+async function getProductionBase(base) {
+  if (base) return base;
+  try {
+    const result = await execa("git", ["describe", "--tags", "--abbrev=0", "--match", "v*"], {
+      stdio: "pipe"
+    });
+    return result.stdout.trim();
+  } catch {
+    try {
+      await execa("git", ["rev-parse", "--verify", "origin/main"], { stdio: "pipe" });
+      return "origin/main";
+    } catch {
+      return "origin/master";
+    }
+  }
+}
+async function checkGitStatus() {
+  try {
+    const statusResult = await execa("git", ["status", "--porcelain"], { stdio: "pipe" });
+    if (statusResult.stdout.trim()) {
+      throw new CLIError("Uncommitted changes detected", "HOTFIX_DIRTY_WORKING_TREE", [
+        "Commit or stash changes before creating hotfix",
+        "Run: git stash"
+      ]);
+    }
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError("Failed to check git status", "HOTFIX_GIT_STATUS_FAILED");
+  }
+}
+async function runCreateAction(name, options) {
+  const logger = createCLILogger("hotfix:create");
+  logger.step("Initializing hotfix workflow", 1);
+  const actor = await createHotfixActor(process.cwd());
+  validateCanCreate(actor);
+  let branchName;
+  try {
+    branchName = validateHotfixName(name);
+  } catch {
+    throw new CLIError("Invalid hotfix name", "HOTFIX_INVALID_NAME", [
+      "Use alphanumeric characters and hyphens",
+      "Example: fix-payment-bug"
+    ]);
+  }
+  const baseBranch = await getProductionBase(options.base);
+  logger.section("Hotfix Creation");
+  logger.info(`Name: ${name}`);
+  logger.info(`Branch: ${branchName}`);
+  logger.info(`Base: ${baseBranch}`);
+  await checkGitStatus();
+  if (!options.skipSnapshot) {
+    await createPreHotfixSnapshot(baseBranch, logger);
+  }
+  logger.step("Fetching latest changes", 3);
+  await execa("git", ["fetch", "--all", "--tags"], { stdio: "inherit" });
+  logger.step(`Creating branch: ${branchName}`, 4);
+  try {
+    await execa("git", ["checkout", "-b", branchName, baseBranch], { stdio: "inherit" });
+  } catch {
+    throw new CLIError(`Failed to create branch: ${branchName}`, "HOTFIX_BRANCH_CREATE_FAILED", [
+      "Branch may already exist",
+      `Delete existing: git branch -D ${branchName}`,
+      "Or use different name"
+    ]);
+  }
+  logger.step("Saving hotfix metadata", 5);
+  try {
+    const snapshot = await sendAndWait(
+      actor,
+      { type: "CREATE", name, base: baseBranch, skipSnapshot: options.skipSnapshot },
+      ["inProgress"],
+      { transitionStates: ["creating"], timeout: 1e4 }
+    );
+    const finalState = getHotfixState(snapshot);
+    if (finalState.error) {
+      throw new Error(finalState.error);
+    }
+  } catch (error) {
+    await rollbackBranch(branchName, logger);
+    throw new CLIError(
+      error instanceof Error ? error.message : "Failed to save hotfix metadata",
+      "HOTFIX_METADATA_FAILED",
+      ["Check .runa/hotfix directory permissions"]
+    );
+  }
+  actor.stop();
+  logger.success("\n\u2705 Hotfix branch created");
+  logger.info("\nNext steps:");
+  logger.info("  1. Make your emergency fix");
+  logger.info('  2. Commit changes: git commit -m "hotfix: description"');
+  logger.info("  3. Deploy: runa hotfix deploy");
+  logger.info("  4. Complete: runa hotfix complete");
+}
+var createCommand = new Command("create").description("Create a hotfix branch from production").argument("<name>", 'Hotfix name (e.g., "fix-payment-bug")').option("--base <ref>", "Base commit/tag (default: latest production tag)").option("--skip-snapshot", "Skip pre-hotfix database snapshot").action(async (name, options) => {
+  try {
+    await runCreateAction(name, options);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      error instanceof Error ? error.message : "Hotfix creation failed",
+      "HOTFIX_CREATE_FAILED",
+      ["Check git repository state", "Ensure you have write access"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/hotfix/commands/hotfix-deploy.ts
+init_esm_shims();
+var deployStateErrors = {
+  idle: {
+    code: "HOTFIX_NOT_FOUND",
+    hints: ['Create hotfix first: runa hotfix create "fix-name"']
+  },
+  deployed: {
+    code: "HOTFIX_ALREADY_DEPLOYED",
+    hints: ["Complete hotfix: runa hotfix complete", "Or cancel: runa hotfix status"]
+  }
+};
+function validateCanDeploy(actor) {
+  const snapshot = actor.getSnapshot();
+  const initialState = getHotfixState(snapshot);
+  if (!canSendEvent(snapshot, "DEPLOY")) {
+    const currentState = initialState.state;
+    const errorInfo = deployStateErrors[currentState];
+    if (errorInfo) {
+      const message = currentState === "idle" ? "No active hotfix found" : "Hotfix already deployed";
+      throw new CLIError(message, errorInfo.code, errorInfo.hints);
+    }
+    throw new CLIError(`Cannot deploy in state: ${currentState}`, "HOTFIX_INVALID_STATE", [
+      "Run: runa hotfix status"
+    ]);
+  }
+  const metadata = initialState.metadata;
+  if (!metadata?.branch) {
+    throw new CLIError("Hotfix metadata is missing branch info", "HOTFIX_METADATA_INVALID");
+  }
+  return {
+    branch: metadata.branch,
+    base: metadata.base,
+    createdAt: metadata.createdAt
+  };
+}
+async function verifyHotfixBranch(expectedBranch) {
+  const result = await execa("git", ["branch", "--show-current"], { stdio: "pipe" });
+  const currentBranch = result.stdout.trim();
+  if (currentBranch !== expectedBranch) {
+    throw new CLIError(
+      `Not on hotfix branch. Current: ${currentBranch}, Expected: ${expectedBranch}`,
+      "HOTFIX_WRONG_BRANCH",
+      [`Checkout hotfix branch: git checkout ${expectedBranch}`]
+    );
+  }
+}
+async function runMinimalChecks(logger) {
+  logger.step("Running minimal CI checks", 2);
+  logger.info("  \u2192 Type checking...");
+  try {
+    await execa("pnpm", ["type-check"], { stdio: "pipe" });
+    logger.info("  \u2713 Type check passed");
+  } catch {
+    throw new CLIError("Type check failed", "HOTFIX_TYPECHECK_FAILED", [
+      "Fix type errors before deploying",
+      "Run: pnpm type-check"
+    ]);
+  }
+  logger.info("  \u2192 Building...");
+  try {
+    await execa("pnpm", ["build"], { stdio: "pipe" });
+    logger.info("  \u2713 Build passed");
+  } catch {
+    throw new CLIError("Build failed", "HOTFIX_BUILD_FAILED", [
+      "Fix build errors before deploying",
+      "Run: pnpm build"
+    ]);
+  }
+  logger.info("  \u2192 Linting...");
+  try {
+    await execa("pnpm", ["lint"], { stdio: "pipe" });
+    logger.info("  \u2713 Lint passed");
+  } catch {
+    logger.warn("  \u26A0 Lint warnings (non-blocking)");
+  }
+}
+async function deployToProduction(logger) {
+  logger.step("Deploying to production", 3);
+  try {
+    await execa("vercel", ["--version"], { stdio: "pipe" });
+  } catch {
+    throw new CLIError("Vercel CLI not found", "HOTFIX_VERCEL_NOT_FOUND", [
+      "Install Vercel CLI: npm i -g vercel",
+      "Or deploy manually through Vercel dashboard"
+    ]);
+  }
+  logger.info("  \u2192 Running vercel deploy --prod...");
+  try {
+    await execa("vercel", ["deploy", "--prod", "--yes"], {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        VERCEL_ORG_ID: process.env.VERCEL_ORG_ID,
+        VERCEL_PROJECT_ID: process.env.VERCEL_PROJECT_ID
+      }
+    });
+    logger.success("  \u2713 Deployed to production");
+  } catch {
+    throw new CLIError("Vercel deployment failed", "HOTFIX_DEPLOY_FAILED", [
+      "Check Vercel CLI authentication",
+      "Verify VERCEL_ORG_ID and VERCEL_PROJECT_ID are set",
+      "Try manual deploy: vercel deploy --prod"
+    ]);
+  }
+}
+async function runDeployAction(options) {
+  const logger = createCLILogger("hotfix:deploy");
+  logger.step("Initializing hotfix workflow", 1);
+  const actor = await createHotfixActor(process.cwd());
+  const metadata = validateCanDeploy(actor);
+  logger.section("Hotfix Deployment");
+  logger.info(`Branch: ${metadata.branch}`);
+  logger.info(`Base: ${metadata.base ?? "unknown"}`);
+  logger.info(`Created: ${metadata.createdAt ?? "unknown"}`);
+  logger.step("Verifying hotfix branch", 1);
+  await verifyHotfixBranch(metadata.branch);
+  logger.success("  \u2713 On correct branch");
+  const statusResult = await execa("git", ["status", "--porcelain"], { stdio: "pipe" });
+  if (statusResult.stdout.trim()) {
+    throw new CLIError("Uncommitted changes detected", "HOTFIX_UNCOMMITTED_CHANGES", [
+      "Commit all changes before deploying",
+      'Run: git commit -am "hotfix: description"'
+    ]);
+  }
+  if (!options.skipChecks) {
+    await runMinimalChecks(logger);
+  } else {
+    logger.warn("Skipping CI checks (--skip-checks)");
+  }
+  if (options.dryRun) {
+    logger.info("\n[DRY RUN] Would deploy to production");
+    logger.info("Re-run without --dry-run to apply");
+    actor.stop();
+    return;
+  }
+  if (!options.autoApprove) {
+    throw new CLIError(
+      "Production deployment requires explicit confirmation",
+      "HOTFIX_CONFIRM_REQUIRED",
+      [
+        "Use --auto-approve to confirm deployment",
+        "Use --dry-run to preview",
+        "\u26A0\uFE0F  This will deploy directly to production"
+      ]
+    );
+  }
+  logger.step("Pushing hotfix branch", 3);
+  try {
+    await execa("git", ["push", "-u", "origin", metadata.branch], { stdio: "inherit" });
+  } catch {
+    logger.warn("Push failed (may already exist)");
+  }
+  await deployToProduction(logger);
+  logger.step("Updating hotfix status", 4);
+  try {
+    const snapshot = await sendAndWait(
+      actor,
+      { type: "DEPLOY", autoApprove: options.autoApprove, skipChecks: options.skipChecks },
+      ["deployed"],
+      { transitionStates: ["deploying"], timeout: 1e4 }
+    );
+    const finalState = getHotfixState(snapshot);
+    if (finalState.error) {
+      throw new Error(finalState.error);
+    }
+  } catch (error) {
+    throw new CLIError(
+      error instanceof Error ? error.message : "Failed to update hotfix status",
+      "HOTFIX_STATUS_UPDATE_FAILED",
+      ["Deployment succeeded but status update failed", "Run: runa hotfix status"]
+    );
+  }
+  actor.stop();
+  logger.success("\n\u2705 Hotfix deployed to production");
+  logger.info("\nNext step:");
+  logger.info("  runa hotfix complete   # Merge back to main");
+}
+var deployCommand = new Command("deploy").description("Deploy hotfix to production (minimal CI)").option("--auto-approve", "Skip confirmation prompts").option("--dry-run", "Show what would be deployed without applying").option("--skip-checks", "Skip type check and build (dangerous)").action(async (options) => {
+  try {
+    await runDeployAction(options);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      error instanceof Error ? error.message : "Hotfix deployment failed",
+      "HOTFIX_DEPLOY_FAILED",
+      ["Check deployment logs", "Verify production credentials"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/hotfix/commands/hotfix-status.ts
+init_esm_shims();
+function formatDate(dateStr) {
+  const date = new Date(dateStr);
+  return date.toLocaleString();
+}
+function formatDuration(startStr, endStr) {
+  const start = new Date(startStr);
+  const end = endStr ? new Date(endStr) : /* @__PURE__ */ new Date();
+  const diffMs = end.getTime() - start.getTime();
+  const hours = Math.floor(diffMs / (1e3 * 60 * 60));
+  const minutes = Math.floor(diffMs % (1e3 * 60 * 60) / (1e3 * 60));
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+function getStateLabel(state) {
+  const labels = {
+    idle: "\u{1F4A4} No active hotfix",
+    loading: "\u23F3 Loading...",
+    creating: "\u{1F504} Creating...",
+    inProgress: "\u{1F527} In Progress",
+    deploying: "\u{1F680} Deploying...",
+    deployed: "\u2705 Deployed",
+    completing: "\u{1F504} Completing...",
+    completed: "\u2705 Completed",
+    cancelling: "\u{1F504} Cancelling...",
+    cancelled: "\u274C Cancelled"
+  };
+  return labels[state] ?? state;
+}
+var eventCommandMap = {
+  CREATE: '\u2022 runa hotfix create "fix-name"',
+  DEPLOY: "\u2022 runa hotfix deploy --auto-approve",
+  COMPLETE: "\u2022 runa hotfix complete --auto-approve",
+  CANCEL: "\u2022 (cancel not yet implemented)"
+};
+function displayAvailableActions(events, logger) {
+  if (events.length === 0) return;
+  logger.info("\n   Available actions:");
+  for (const event of events) {
+    const command = eventCommandMap[event];
+    if (command) {
+      logger.info(`     ${command}`);
+    }
+  }
+}
+function displayNextSteps(state, logger) {
+  const nextStepsMap = {
+    inProgress: [
+      "1. Make fixes and commit",
+      "2. runa hotfix deploy --auto-approve",
+      "3. runa hotfix complete --auto-approve"
+    ],
+    deployed: ["1. Verify production", "2. runa hotfix complete --auto-approve"]
+  };
+  const steps = nextStepsMap[state];
+  if (steps) {
+    logger.info("\n   Next steps:");
+    for (const step of steps) {
+      logger.info(`     ${step}`);
+    }
+  }
+}
+function displayActiveHotfix(stateInfo, logger) {
+  const { metadata, state, availableEvents } = stateInfo;
+  if (!metadata) {
+    logger.info("\n   No active hotfix");
+    logger.info('   Create one with: runa hotfix create "fix-name"');
+    return;
+  }
+  logger.info("\n\u{1F527} Active Hotfix:");
+  logger.info(`   Branch: ${metadata.branch ?? "unknown"}`);
+  logger.info(`   Base: ${metadata.base ?? "unknown"}`);
+  if (metadata.createdAt) {
+    logger.info(`   Created: ${formatDate(metadata.createdAt)}`);
+    logger.info(`   Duration: ${formatDuration(metadata.createdAt, metadata.deployedAt)}`);
+  }
+  logger.info(`   Status: ${metadata.status ?? state}`);
+  if (metadata.deployedAt) {
+    logger.info(`   Deployed: ${formatDate(metadata.deployedAt)}`);
+  }
+  displayAvailableActions(availableEvents, logger);
+  displayNextSteps(state, logger);
+}
+async function displayArchivedHotfixes(logger) {
+  try {
+    const { hotfixes: archived } = await listArchivedHotfixes({ limit: 5 });
+    if (archived.length === 0) return;
+    logger.info("\n\u{1F4C1} Recent Hotfixes:");
+    for (const hotfix of archived) {
+      const duration = formatDuration(hotfix.createdAt, hotfix.completedAt);
+      logger.info(`   \u2022 ${hotfix.branch}`);
+      logger.info(`     Completed: ${formatDate(hotfix.completedAt || hotfix.createdAt)}`);
+      logger.info(`     Duration: ${duration}`);
+    }
+  } catch {
+  }
+}
+async function runStatusAction() {
+  const logger = createCLILogger("hotfix:status");
+  const actor = await createHotfixActor(process.cwd());
+  const stateInfo = getHotfixState(actor.getSnapshot());
+  actor.stop();
+  logger.section("Hotfix Status");
+  logger.info(`
+   State: ${getStateLabel(stateInfo.state)}`);
+  displayActiveHotfix(stateInfo, logger);
+  if (stateInfo.error) {
+    logger.warn(`
+   \u26A0\uFE0F  Error: ${stateInfo.error}`);
+  }
+  await displayArchivedHotfixes(logger);
+}
+var statusCommand = new Command("status").description("Show current hotfix status").action(async () => {
+  try {
+    await runStatusAction();
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      error instanceof Error ? error.message : "Status check failed",
+      "HOTFIX_STATUS_FAILED",
+      ["Check .runa/hotfix directory"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/hotfix/index.ts
+var hotfixCommand = new Command("hotfix").description(
+  "Emergency production fix workflow (create \u2192 deploy \u2192 complete)"
+);
+hotfixCommand.addCommand(createCommand);
+hotfixCommand.addCommand(deployCommand);
+hotfixCommand.addCommand(completeCommand);
+hotfixCommand.addCommand(statusCommand);
+
+export { hotfixCommand };