whipped 0.0.1 → 0.1.0

package/dist/mcp-server.js

@@ -0,0 +1,2552 @@
+#!/usr/bin/env node
+import { createRequire as __ovrCreateRequire } from "node:module";
+import { fileURLToPath as __ovrFileURLToPath } from "node:url";
+const require = __ovrCreateRequire(import.meta.url);
+const __filename = __ovrFileURLToPath(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/api-contract.ts
+import { z } from "zod";
+function resolveWorkflowForCard(workflows, card) {
+  const isStory = card.type === "story";
+  return workflows.find((w) => w.id === card.workflowId) ?? workflows.find((w) => w.isDefault && w.forStory === isStory) ?? workflows.find((w) => w.forStory === isStory) ?? workflows[0];
+}
+function snapshotModelConfig(workflow) {
+  const config = {};
+  for (const slot of workflow?.slots ?? []) {
+    config[slot.id] = { pairs: slot.pairs, mode: slot.mode };
+  }
+  return config;
+}
+function highestWorkflowLevel(workflow) {
+  let bestIdx = -1;
+  for (const slot of workflow?.slots ?? []) {
+    for (const p of slot.pairs) bestIdx = Math.max(bestIdx, LEVEL_ORDER.indexOf(p.level));
+  }
+  return LEVEL_ORDER[bestIdx] ?? "medium";
+}
+var runtimeAgentIdSchema, effortLevelSchema, agentModelChoiceSchema, workflowSlotTypeSchema, tierLevelSchema, LEVEL_ORDER, modelPairSchema, pairSelectionModeSchema, SLOT_TOOL_IDS, slotToolSchema, slotModelConfigSchema, cardModelConfigSchema, promptValueSchema, EMPTY_INLINE_PROMPT, workflowSlotSchema, DEFAULT_MODEL_PAIR, DEFAULT_SLOT_MODEL_FIELDS, workflowSchema, DEFAULT_WORKFLOW, DEFAULT_STORY_WORKFLOW, DEFAULT_GIT_INSTRUCTIONS, runtimeBoardColumnIdSchema, BOARD_COLUMNS, reviewActorSchema, reviewIssueSchema, reviewAttachmentSchema, runtimeReviewCommentSchema, runtimeActivityEntrySchema, runtimeTaskSessionStateSchema, runtimeTerminalSessionEntrySchema, runtimeCardPrioritySchema, cardTypeSchema, runtimePrMetaSchema, runtimeBoardCardSchema, runtimeBoardColumnSchema, runtimeBoardDataSchema, runtimeGlobalConfigSchema, runtimeGithubConfigSchema, runtimeWorktreeSetupSchema, runtimeProjectSecretSchema, runtimeProjectConfigSchema, runtimeWorkspaceStateResponseSchema, runtimeWorkspaceStateSaveRequestSchema, runtimeVisualElementSchema, runtimeVisualCommentSchema, runtimeCardCreateRequestSchema, runtimeCardMoveRequestSchema, runtimeCardUpdateRequestSchema, memoryScopeSchema, memoryTypeSchema, memorySourceTypeSchema, memoryStatusSchema, runtimeMemoryOriginAgentSchema, runtimeMemorySchema, recurringScheduleKindSchema, recurringScheduleSchema, recurringRunStatusSchema, recurringRunTriggerSchema, recurringAgentRunSchema, recurringAgentSchema, recurringAgentCreateRequestSchema, recurringAgentUpdateRequestSchema, projectFolderSchema, topLevelItemSchema, projectsLayoutSchema, runtimeProjectSchema;
+var init_api_contract = __esm({
+  "src/core/api-contract.ts"() {
+    "use strict";
+    runtimeAgentIdSchema = z.enum(["claude", "codex", "opencode", "cursor"]);
+    effortLevelSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
+    agentModelChoiceSchema = z.object({
+      agentId: runtimeAgentIdSchema.default("claude"),
+      model: z.string().nullable().optional(),
+      effort: effortLevelSchema.nullable().optional()
+    });
+    workflowSlotTypeSchema = z.enum(["dev", "review", "plan", "orch"]);
+    tierLevelSchema = z.enum(["minimal", "low", "medium", "high", "max"]);
+    LEVEL_ORDER = ["minimal", "low", "medium", "high", "max"];
+    modelPairSchema = z.object({
+      id: z.string(),
+      level: tierLevelSchema,
+      isFree: z.boolean().default(false),
+      binary: runtimeAgentIdSchema,
+      model: z.string().nullable().optional(),
+      effort: effortLevelSchema.nullable().optional()
+    });
+    pairSelectionModeSchema = z.enum(["auto", "preferFree", "freeOnly", "paidOnly"]);
+    SLOT_TOOL_IDS = ["browser"];
+    slotToolSchema = z.enum(SLOT_TOOL_IDS);
+    slotModelConfigSchema = z.object({
+      pairs: z.array(modelPairSchema).min(1),
+      mode: pairSelectionModeSchema.default("auto"),
+      pinnedPairId: z.string().optional()
+    });
+    cardModelConfigSchema = z.record(z.string(), slotModelConfigSchema);
+    promptValueSchema = z.preprocess(
+      (v) => {
+        if (typeof v === "string") return { source: "inline", text: v };
+        return v;
+      },
+      z.discriminatedUnion("source", [
+        z.object({ source: z.literal("inline"), text: z.string() }),
+        z.object({ source: z.literal("file"), path: z.string() })
+      ])
+    );
+    EMPTY_INLINE_PROMPT = { source: "inline", text: "" };
+    workflowSlotSchema = z.object({
+      id: z.string(),
+      type: workflowSlotTypeSchema,
+      name: z.string(),
+      order: z.number().int().nonnegative(),
+      enabled: z.boolean(),
+      prompt: promptValueSchema.default(EMPTY_INLINE_PROMPT),
+      // Model tiers for this slot, in priority order (top = highest). Copied to the
+      // card at creation; the card's active level + mode select which pair runs.
+      pairs: z.array(modelPairSchema).min(1),
+      mode: pairSelectionModeSchema.default("auto"),
+      // Tools this slot may use (e.g. "browser"). Workflow-only, not ticket-editable.
+      tools: z.array(slotToolSchema).default([]),
+      // review slots only: may set the card's active level on reopen.
+      canAdjustLevel: z.boolean().default(false),
+      // plan slots only: re-run even if a plan already exists on the card.
+      rerun: z.boolean().default(false)
+    });
+    DEFAULT_MODEL_PAIR = {
+      id: "default",
+      level: "medium",
+      isFree: false,
+      binary: "claude",
+      model: null,
+      effort: null
+    };
+    DEFAULT_SLOT_MODEL_FIELDS = {
+      pairs: [DEFAULT_MODEL_PAIR],
+      mode: "auto"
+    };
+    workflowSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      isDefault: z.boolean().default(false),
+      forStory: z.boolean().default(false),
+      slots: z.array(workflowSlotSchema)
+    });
+    DEFAULT_WORKFLOW = {
+      id: "wf_default",
+      name: "Default",
+      isDefault: true,
+      forStory: false,
+      slots: [
+        {
+          id: "plan",
+          type: "plan",
+          name: "Plan",
+          order: 0,
+          enabled: false,
+          prompt: EMPTY_INLINE_PROMPT,
+          ...DEFAULT_SLOT_MODEL_FIELDS,
+          tools: [],
+          canAdjustLevel: false,
+          rerun: false
+        },
+        {
+          id: "dev",
+          type: "dev",
+          name: "Dev",
+          order: 1,
+          enabled: true,
+          prompt: EMPTY_INLINE_PROMPT,
+          ...DEFAULT_SLOT_MODEL_FIELDS,
+          tools: [],
+          canAdjustLevel: false,
+          rerun: false
+        },
+        {
+          id: "code_review",
+          type: "review",
+          name: "Code Review",
+          order: 2,
+          enabled: true,
+          prompt: EMPTY_INLINE_PROMPT,
+          ...DEFAULT_SLOT_MODEL_FIELDS,
+          tools: [],
+          canAdjustLevel: false,
+          rerun: false
+        },
+        {
+          id: "qa",
+          type: "review",
+          name: "QA",
+          order: 3,
+          enabled: false,
+          prompt: EMPTY_INLINE_PROMPT,
+          ...DEFAULT_SLOT_MODEL_FIELDS,
+          tools: ["browser"],
+          canAdjustLevel: false,
+          rerun: false
+        }
+      ]
+    };
+    DEFAULT_STORY_WORKFLOW = {
+      id: "wf_story_default",
+      name: "Story Default",
+      isDefault: true,
+      forStory: true,
+      slots: [
+        {
+          id: "orch",
+          type: "orch",
+          name: "Orchestrator",
+          order: 0,
+          enabled: true,
+          prompt: EMPTY_INLINE_PROMPT,
+          ...DEFAULT_SLOT_MODEL_FIELDS,
+          tools: [],
+          canAdjustLevel: false,
+          rerun: false
+        }
+      ]
+    };
+    DEFAULT_GIT_INSTRUCTIONS = `# Git conventions
+
+These rules govern how to write commit messages, PR titles, and PR
+descriptions.
+
+## PR title
+- Imperative, present tense: "Add board view", "Fix race in poller".
+  Not past tense, not gerund.
+- \u226470 characters; aim for 50.
+- Describe what shipped, not the task. "Add board view" beats
+  "Implement board view feature".
+- No prefixes like \`feat:\` / \`[FEAT]\` / \`fix:\`.
+- No ticket IDs in the title (put them in the description if needed).
+- No trailing period.
+
+## PR description
+Keep it focused. Two sections, nothing more unless genuinely useful:
+
+    ## Summary
+    - What changed and why. Use as many bullets as the scope warrants \u2014
+      a one-line fix is one bullet; a refactor touching 20 files may
+      need ten. Don't pad, don't truncate.
+
+    ## Test plan
+    - What you actually ran or clicked, and the outcome.
+    - Type-check and lint passing are not a test plan on their own.
+    - If something couldn't be verified, say so in one line.
+
+Do NOT include:
+- Iteration narration ("Round N", "addressed feedback", "after review").
+- Commit SHAs or branch names \u2014 GitHub already shows both.
+- Paths to internal planning docs, scratch files, or task tracker URLs.
+- "Verification:" sections that only list a passing type-check or lint.
+- Self-congratulation ("clean", "all checks pass", "ready to merge").
+- Restating the task description verbatim.
+
+## Commit messages
+- Short imperative subject line, \u226472 chars. That's usually enough.
+- Skip the body unless a reviewer reading the diff alone would be
+  confused about *why* the change exists.
+- Reference an issue only if a concrete one exists to close
+  (\`Closes #123\`). Never invent issue numbers.
+`;
+    runtimeBoardColumnIdSchema = z.enum([
+      "todo",
+      "in_progress",
+      "reopened",
+      "ready_for_review",
+      "blocked",
+      "done"
+    ]);
+    BOARD_COLUMNS = [
+      { id: "todo", title: "Todo" },
+      { id: "in_progress", title: "In Progress" },
+      { id: "reopened", title: "Reopened" },
+      { id: "ready_for_review", title: "Ready for Review" },
+      { id: "blocked", title: "Blocked" },
+      { id: "done", title: "Done" }
+    ];
+    reviewActorSchema = z.object({
+      type: z.enum(["ai", "human", "external"]),
+      id: z.string(),
+      source: z.string().optional()
+    });
+    reviewIssueSchema = z.object({
+      file: z.string().optional(),
+      line: z.number().optional(),
+      severity: z.enum(["blocking", "warning", "info"]),
+      message: z.string()
+    });
+    reviewAttachmentSchema = z.object({
+      type: z.string(),
+      // "image" | "file" | any mime category
+      name: z.string(),
+      mimeType: z.string(),
+      path: z.string()
+      // absolute path in ~/.whipped/attachments/
+    });
+    runtimeReviewCommentSchema = z.object({
+      id: z.string(),
+      type: z.string(),
+      actor: reviewActorSchema,
+      status: z.enum(["pass", "fail", "warning", "skipped"]).optional(),
+      createdAt: z.number(),
+      streamId: z.string().optional(),
+      summary: z.string(),
+      issues: z.array(reviewIssueSchema).optional(),
+      attachments: z.array(reviewAttachmentSchema).optional(),
+      metadata: z.record(z.string(), z.unknown()).optional()
+    });
+    runtimeActivityEntrySchema = z.object({
+      timestamp: z.number(),
+      message: z.string()
+    });
+    runtimeTaskSessionStateSchema = z.enum(["running", "stopped", "completed", "failed", "killed"]);
+    runtimeTerminalSessionEntrySchema = z.object({
+      streamId: z.string(),
+      type: z.string(),
+      startedAt: z.number(),
+      endedAt: z.number().optional(),
+      agentId: runtimeAgentIdSchema.optional(),
+      state: runtimeTaskSessionStateSchema.optional()
+    });
+    runtimeCardPrioritySchema = z.enum(["urgent", "high", "medium", "low"]);
+    cardTypeSchema = z.enum(["task", "story", "subtask"]);
+    runtimePrMetaSchema = z.object({
+      url: z.string().optional(),
+      title: z.string().optional(),
+      description: z.string().optional(),
+      updatedAt: z.number().optional(),
+      updatedBy: z.string().optional()
+    });
+    runtimeBoardCardSchema = z.object({
+      id: z.string(),
+      description: z.string(),
+      descriptionAttachments: z.array(reviewAttachmentSchema).optional().default([]),
+      columnId: runtimeBoardColumnIdSchema,
+      type: cardTypeSchema.default("task"),
+      readyForDev: z.boolean().default(false),
+      agentId: runtimeAgentIdSchema.optional(),
+      priority: runtimeCardPrioritySchema.optional(),
+      // Single-parent stacking: this card continues in the parent's worktree/branch
+      // and starts once the parent reaches ready_for_review. Mutually exclusive with waitsFor.
+      dependsOn: z.string().optional(),
+      // Many-parent gate (tasks only): this card starts only once ALL listed cards are
+      // done (merged), in a fresh worktree branched from baseRef. Mutually exclusive with dependsOn.
+      waitsFor: z.array(z.string()).default([]),
+      // Story-only: the IDs of this story's subtasks. The story triggers its orchestrator
+      // workflow once every subtask reaches ready_for_review.
+      subtaskIds: z.array(z.string()).default([]),
+      autoFixAttempts: z.number().int().nonnegative().default(0),
+      baseRef: z.string(),
+      createdAt: z.number(),
+      updatedAt: z.number(),
+      githubIssueUrl: z.string().optional(),
+      pr: runtimePrMetaSchema.optional(),
+      workflowId: z.string().optional(),
+      // Plan written by the one-shot plan agent; injected into the dev agent's prompt.
+      plan: z.string().optional(),
+      // Workflow-wide capability level; every slot resolves it to its own pair.
+      activeLevel: tierLevelSchema.default("medium"),
+      // Per-slot model config, snapshotted from the workflow at creation and editable
+      // per ticket (slotId → {pairs, mode, pinnedPairId}).
+      modelConfig: cardModelConfigSchema.optional(),
+      reviewComments: z.array(runtimeReviewCommentSchema).default([]),
+      activityLog: z.array(runtimeActivityEntrySchema).default([]),
+      terminalSessions: z.array(runtimeTerminalSessionEntrySchema).default([]),
+      githubCommentIds: z.array(z.string()).default([]),
+      worktreePath: z.string().optional(),
+      branchName: z.string().optional(),
+      slackMessageTs: z.string().optional(),
+      slackChannelId: z.string().optional()
+    });
+    runtimeBoardColumnSchema = z.object({
+      id: runtimeBoardColumnIdSchema,
+      title: z.string(),
+      taskIds: z.array(z.string())
+    });
+    runtimeBoardDataSchema = z.object({
+      columns: z.array(runtimeBoardColumnSchema),
+      cards: z.record(z.string(), runtimeBoardCardSchema)
+    });
+    runtimeGlobalConfigSchema = z.object({
+      defaultAgent: runtimeAgentIdSchema.default("claude"),
+      maxParallelTasks: z.number().int().positive().default(4),
+      maxParallelQA: z.number().int().positive().default(1),
+      maxAutoFixAttempts: z.number().int().nonnegative().default(3),
+      pollingIntervalSeconds: z.number().int().positive().default(30),
+      prPollingIntervalSeconds: z.number().int().positive().default(60),
+      terminalApp: z.string().optional(),
+      slackEnabled: z.boolean().default(true),
+      slackBotToken: z.string().optional(),
+      slackSigningSecret: z.string().optional(),
+      slackAppConfigToken: z.string().optional(),
+      slackClientId: z.string().optional(),
+      slackClientSecret: z.string().optional(),
+      slackAppId: z.string().optional(),
+      slackOauthAuthorizeUrl: z.string().optional(),
+      slackPublicUrl: z.string().optional(),
+      slackBotName: z.string().default("Whipped"),
+      slackInstallerUserId: z.string().optional(),
+      autoStartTunnel: z.boolean().default(false),
+      tunnelId: z.string().optional(),
+      tunnelDomain: z.string().optional(),
+      tunnelName: z.string().default("whipped"),
+      // Auth: single shared password (scrypt hash) + HMAC secret for signed session
+      // cookies + machine token for local agent machinery (MCP/hooks). Never expose
+      // these over the API — see configController's response.
+      authPasswordHash: z.string().optional(),
+      authSessionSecret: z.string().optional(),
+      authMachineToken: z.string().optional()
+    });
+    runtimeGithubConfigSchema = z.object({
+      token: z.string()
+    });
+    runtimeWorktreeSetupSchema = z.object({
+      filesToCopy: z.array(z.string()).default([]),
+      installCommand: z.string().default("")
+    });
+    runtimeProjectSecretSchema = z.object({
+      key: z.string().min(1),
+      value: z.string()
+    });
+    runtimeProjectConfigSchema = z.object({
+      name: z.string().optional(),
+      defaultAgent: runtimeAgentIdSchema.optional(),
+      maxParallelTasks: z.number().int().positive().optional(),
+      maxAutoFixAttempts: z.number().int().nonnegative().optional(),
+      pollingIntervalSeconds: z.number().int().positive().optional(),
+      // What happens when a card passes review (polling/dispatch is always on; per-ticket
+      // readyForDev gates pickup). "off" parks it in ready_for_review, "pr" auto-creates a
+      // GitHub PR, "yolo" merges the branch straight into the local baseRef and pushes.
+      deliveryMode: z.enum(["off", "pr", "yolo"]).default("off"),
+      autoCommit: z.boolean().default(true),
+      defaultBaseBranch: z.string().optional(),
+      github: runtimeGithubConfigSchema.optional(),
+      worktreeSetup: runtimeWorktreeSetupSchema.optional(),
+      startCommand: z.string().default(""),
+      workflows: z.array(workflowSchema).default([]),
+      secrets: z.array(runtimeProjectSecretSchema).default([]),
+      systemPrompt: z.string().optional(),
+      // Freeform instructions injected into the dev agent's prompt to shape PR
+      // titles, descriptions, and commit messages. Empty/absent → daemon falls
+      // back to DEFAULT_GIT_INSTRUCTIONS.
+      gitInstructions: z.string().optional(),
+      // Which agent binary/model/effort the assistant agent runs as. Absent → claude.
+      assistantModel: agentModelChoiceSchema.optional()
+    });
+    runtimeWorkspaceStateResponseSchema = z.object({
+      workspaceId: z.string(),
+      repoPath: z.string(),
+      board: runtimeBoardDataSchema,
+      revision: z.number(),
+      projectConfig: runtimeProjectConfigSchema
+    });
+    runtimeWorkspaceStateSaveRequestSchema = z.object({
+      board: runtimeBoardDataSchema,
+      revision: z.number()
+    });
+    runtimeVisualElementSchema = z.object({
+      elementSelector: z.string().optional(),
+      elementText: z.string().optional(),
+      componentName: z.string().optional(),
+      componentChain: z.array(z.string()).optional(),
+      sourceFile: z.string().optional(),
+      sourceLine: z.number().optional(),
+      // The page the element was captured on. Selections can span pages, so this is
+      // per-element rather than relying on the visualComment-level pageUrl.
+      pageUrl: z.string().optional()
+    });
+    runtimeVisualCommentSchema = z.object({
+      pageUrl: z.string().optional(),
+      elements: z.array(runtimeVisualElementSchema).default([])
+    });
+    runtimeCardCreateRequestSchema = z.object({
+      description: z.string(),
+      type: cardTypeSchema.optional(),
+      // Browser-extension element references; folded into the description server-side.
+      visualComment: runtimeVisualCommentSchema.optional(),
+      agentId: runtimeAgentIdSchema.optional(),
+      priority: runtimeCardPrioritySchema.optional(),
+      readyForDev: z.boolean().optional(),
+      dependsOn: z.string().optional(),
+      waitsFor: z.array(z.string()).optional(),
+      subtaskIds: z.array(z.string()).optional(),
+      columnId: runtimeBoardColumnIdSchema.optional(),
+      baseRef: z.string().optional(),
+      githubIssueUrl: z.string().optional(),
+      workflowId: z.string().optional(),
+      descriptionAttachments: z.array(reviewAttachmentSchema).optional(),
+      branchName: z.string().optional(),
+      // Optional per-ticket overrides edited before creation. When omitted, the card
+      // snapshots the resolved workflow's pairs and defaults the active level to the
+      // workflow's highest configured tier.
+      modelConfig: cardModelConfigSchema.optional(),
+      activeLevel: tierLevelSchema.optional()
+    });
+    runtimeCardMoveRequestSchema = z.object({
+      cardId: z.string(),
+      targetColumnId: runtimeBoardColumnIdSchema,
+      targetIndex: z.number().int().nonnegative().optional(),
+      revision: z.number()
+    });
+    runtimeCardUpdateRequestSchema = z.object({
+      cardId: z.string(),
+      description: z.string().optional(),
+      descriptionAttachments: z.array(reviewAttachmentSchema).optional(),
+      type: cardTypeSchema.optional(),
+      agentId: runtimeAgentIdSchema.optional(),
+      priority: runtimeCardPrioritySchema.optional(),
+      readyForDev: z.boolean().optional(),
+      dependsOn: z.string().optional(),
+      waitsFor: z.array(z.string()).optional(),
+      subtaskIds: z.array(z.string()).optional(),
+      workflowId: z.string().optional(),
+      branchName: z.string().optional(),
+      plan: z.string().optional(),
+      activeLevel: tierLevelSchema.optional(),
+      modelConfig: cardModelConfigSchema.optional(),
+      revision: z.number()
+    });
+    memoryScopeSchema = z.enum(["global", "project"]);
+    memoryTypeSchema = z.enum([
+      "fact",
+      "convention",
+      "decision",
+      "preference",
+      "rule",
+      "lesson",
+      "sharp_edge"
+    ]);
+    memorySourceTypeSchema = z.enum(["user_correction", "explicit_save", "task_lesson", "manual_human"]);
+    memoryStatusSchema = z.enum(["pending", "approved"]);
+    runtimeMemoryOriginAgentSchema = z.object({
+      agent: z.string(),
+      model: z.string().optional()
+    });
+    runtimeMemorySchema = z.object({
+      id: z.string(),
+      scope: memoryScopeSchema,
+      workspaceId: z.string().nullable(),
+      originWorkspaceId: z.string().nullable().optional(),
+      type: memoryTypeSchema,
+      title: z.string(),
+      content: z.string(),
+      sourceType: memorySourceTypeSchema,
+      importance: z.number().int().min(1).max(3).default(1),
+      tags: z.array(z.string()).default([]),
+      boundWorkspaceIds: z.array(z.string()).default([]),
+      originCardId: z.string().nullable().optional(),
+      originAgent: runtimeMemoryOriginAgentSchema.nullable().optional(),
+      status: memoryStatusSchema.default("approved"),
+      createdAt: z.number(),
+      updatedAt: z.number()
+    });
+    recurringScheduleKindSchema = z.enum(["interval", "calendar"]);
+    recurringScheduleSchema = z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("interval"), intervalSeconds: z.number().int().positive() }),
+      z.object({ kind: z.literal("calendar"), cronExpr: z.string().min(1), timezone: z.string().min(1) })
+    ]);
+    recurringRunStatusSchema = z.enum(["running", "ok", "error", "killed"]);
+    recurringRunTriggerSchema = z.enum(["schedule", "manual"]);
+    recurringAgentRunSchema = z.object({
+      id: z.string(),
+      startedAt: z.number(),
+      endedAt: z.number().optional(),
+      status: recurringRunStatusSchema,
+      summary: z.string().optional(),
+      tokens: z.number().optional(),
+      trigger: recurringRunTriggerSchema.default("schedule"),
+      streamId: z.string().optional()
+    });
+    recurringAgentSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      instructions: z.string().default(""),
+      schedule: recurringScheduleSchema,
+      model: agentModelChoiceSchema,
+      enabled: z.boolean().default(true),
+      lastRunAt: z.number().optional(),
+      nextRunAt: z.number().optional(),
+      journal: z.string().default(""),
+      createdAt: z.number(),
+      updatedAt: z.number(),
+      recentRuns: z.array(recurringAgentRunSchema).default([])
+    });
+    recurringAgentCreateRequestSchema = z.object({
+      name: z.string().min(1),
+      instructions: z.string().optional(),
+      schedule: recurringScheduleSchema,
+      model: agentModelChoiceSchema.optional(),
+      enabled: z.boolean().optional()
+    });
+    recurringAgentUpdateRequestSchema = z.object({
+      id: z.string(),
+      name: z.string().min(1).optional(),
+      instructions: z.string().optional(),
+      schedule: recurringScheduleSchema.optional(),
+      model: agentModelChoiceSchema.optional(),
+      enabled: z.boolean().optional(),
+      journal: z.string().optional()
+    });
+    projectFolderSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      collapsed: z.boolean().default(false),
+      projectIds: z.array(z.string())
+    });
+    topLevelItemSchema = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("folder"), id: z.string() }),
+      z.object({ type: z.literal("project"), workspaceId: z.string() })
+    ]);
+    projectsLayoutSchema = z.object({
+      version: z.literal(1),
+      topLevel: z.array(topLevelItemSchema),
+      folders: z.record(z.string(), projectFolderSchema)
+    });
+    runtimeProjectSchema = z.object({
+      workspaceId: z.string(),
+      repoPath: z.string(),
+      name: z.string(),
+      lastUpdated: z.number()
+    });
+  }
+});
+
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var WHIPPED_HOME_DIR;
+var init_paths = __esm({
+  "src/config/paths.ts"() {
+    "use strict";
+    WHIPPED_HOME_DIR = process.env.WHIPPED_HOME_DIR ?? join(homedir(), ".whipped");
+  }
+});
+
+// src/core/logger.ts
+import { mkdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import pino from "pino";
+var LOGS_DIR, date, streams, logger;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    init_paths();
+    LOGS_DIR = join2(WHIPPED_HOME_DIR, "logs");
+    date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    streams = [
+      {
+        stream: pino.transport({
+          target: "pino-pretty",
+          options: {
+            colorize: true,
+            translateTime: "HH:MM:ss",
+            ignore: "pid,hostname",
+            messageFormat: "{msg}",
+            errorLikeObjectKeys: ["err"]
+          }
+        })
+      }
+    ];
+    try {
+      mkdirSync(LOGS_DIR, { recursive: true });
+      streams.push({
+        stream: pino.destination({
+          dest: join2(LOGS_DIR, `whipped-${date}.log`),
+          sync: false
+        })
+      });
+    } catch {
+    }
+    logger = pino(
+      {
+        level: "debug",
+        base: null,
+        timestamp: pino.stdTimeFunctions.isoTime,
+        formatters: {
+          level: (label) => ({ level: label })
+        }
+      },
+      pino.multistream(streams)
+    );
+  }
+});
+
+// src/state/secrets-crypto.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync as mkdirSync2, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+function generateAndWriteKey() {
+  const key = randomBytes(KEY_LENGTH);
+  mkdirSync2(dirname(KEY_PATH), { recursive: true });
+  writeFileSync(KEY_PATH, key.toString("base64"), { mode: 384 });
+  chmodSync(KEY_PATH, 384);
+  logger.warn({ path: KEY_PATH }, "Generated new secret key \u2014 any previously-encrypted secrets are now unreadable");
+  return key;
+}
+function loadOrGenerateKey() {
+  if (cachedKey) return cachedKey;
+  if (existsSync(KEY_PATH)) {
+    try {
+      const raw = readFileSync(KEY_PATH, "utf-8").trim();
+      const key = Buffer.from(raw, "base64");
+      if (key.length === KEY_LENGTH) {
+        cachedKey = key;
+        return key;
+      }
+      logger.error(
+        { path: KEY_PATH, gotLength: key.length, expectedLength: KEY_LENGTH },
+        "Secret key file has wrong length; regenerating"
+      );
+      unlinkSync(KEY_PATH);
+    } catch (err) {
+      logger.error({ err, path: KEY_PATH }, "Secret key file unreadable; regenerating");
+      try {
+        unlinkSync(KEY_PATH);
+      } catch {
+      }
+    }
+  }
+  cachedKey = generateAndWriteKey();
+  return cachedKey;
+}
+function encrypt(plaintext) {
+  const key = loadOrGenerateKey();
+  const nonce = randomBytes(NONCE_LENGTH);
+  const cipher = createCipheriv("aes-256-gcm", key, nonce);
+  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return PREFIX + Buffer.concat([nonce, ciphertext, tag]).toString("base64");
+}
+function decrypt(value) {
+  try {
+    const key = loadOrGenerateKey();
+    const combined = Buffer.from(value.slice(PREFIX.length), "base64");
+    if (combined.length < NONCE_LENGTH + TAG_LENGTH) {
+      throw new Error(`ciphertext too short (${combined.length} bytes)`);
+    }
+    const nonce = combined.subarray(0, NONCE_LENGTH);
+    const tag = combined.subarray(combined.length - TAG_LENGTH);
+    const ciphertext = combined.subarray(NONCE_LENGTH, combined.length - TAG_LENGTH);
+    const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf-8");
+  } catch (err) {
+    logger.error(
+      { err: err.message },
+      "Failed to decrypt secret \u2014 returning empty. Update the value via the UI to re-encrypt with the current key."
+    );
+    return "";
+  }
+}
+var KEY_PATH, KEY_LENGTH, NONCE_LENGTH, TAG_LENGTH, PREFIX, cachedKey;
+var init_secrets_crypto = __esm({
+  "src/state/secrets-crypto.ts"() {
+    "use strict";
+    init_paths();
+    init_logger();
+    KEY_PATH = join3(WHIPPED_HOME_DIR, ".secret_key");
+    KEY_LENGTH = 32;
+    NONCE_LENGTH = 12;
+    TAG_LENGTH = 16;
+    PREFIX = "enc:v1:";
+    cachedKey = null;
+  }
+});
+
+// src/state/db.ts
+import { dirname as dirname2, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+import Database from "better-sqlite3";
+function getDb() {
+  if (!cachedDb) {
+    throw new Error("Database not initialised. Call openDb() at startup before getDb().");
+  }
+  return cachedDb;
+}
+var MIGRATIONS_DIR, DEFAULT_DB_PATH, cachedDb;
+var init_db = __esm({
+  "src/state/db.ts"() {
+    "use strict";
+    init_paths();
+    init_logger();
+    init_secrets_crypto();
+    MIGRATIONS_DIR = join4(dirname2(fileURLToPath(import.meta.url)), "migrations");
+    DEFAULT_DB_PATH = join4(WHIPPED_HOME_DIR, "whipped.db");
+    cachedDb = null;
+  }
+});
+
+// src/config/runtime-config.ts
+import { join as join5 } from "node:path";
+var WORKSPACES_DIR, ATTACHMENTS_DIR;
+var init_runtime_config = __esm({
+  "src/config/runtime-config.ts"() {
+    "use strict";
+    init_api_contract();
+    init_db();
+    init_secrets_crypto();
+    init_paths();
+    WORKSPACES_DIR = join5(WHIPPED_HOME_DIR, "workspaces");
+    ATTACHMENTS_DIR = join5(WHIPPED_HOME_DIR, "attachments");
+  }
+});
+
+// src/core/task-id.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+function generateTaskId() {
+  return randomBytes2(8).toString("hex");
+}
+var init_task_id = __esm({
+  "src/core/task-id.ts"() {
+    "use strict";
+  }
+});
+
+// src/state/workspace-state.ts
+var workspace_state_exports = {};
+__export(workspace_state_exports, {
+  appendActivityLog: () => appendActivityLog,
+  appendTerminalSession: () => appendTerminalSession,
+  clearCardSession: () => clearCardSession,
+  closeAllOpenTerminalSessions: () => closeAllOpenTerminalSessions,
+  createCard: () => createCard,
+  deleteCard: () => deleteCard,
+  downloadGithubImages: () => downloadGithubImages,
+  endTerminalSession: () => endTerminalSession,
+  extractSignedImageUrls: () => extractSignedImageUrls,
+  linkCommentToSession: () => linkCommentToSession,
+  listWorkspaces: () => listWorkspaces,
+  loadBoard: () => loadBoard,
+  loadProjectConfig: () => loadProjectConfig,
+  loadTerminalBuffer: () => loadTerminalBuffer,
+  loadWorkspaceContext: () => loadWorkspaceContext,
+  loadWorkspaceState: () => loadWorkspaceState,
+  moveCard: () => moveCard,
+  removeWorkspace: () => removeWorkspace,
+  saveAttachment: () => saveAttachment,
+  saveProjectConfig: () => saveProjectConfig,
+  saveTerminalBuffer: () => saveTerminalBuffer,
+  saveWorkspaceState: () => saveWorkspaceState,
+  stampReviewCommentMetadata: () => stampReviewCommentMetadata,
+  updateCard: () => updateCard,
+  updateProjectConfig: () => updateProjectConfig
+});
+import { createHash, randomBytes as randomBytes3 } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join as join6 } from "node:path";
+function workspaceDirPath(workspaceId2) {
+  return join6(WORKSPACES_DIR, workspaceId2);
+}
+function bufferFilePath(workspaceId2, streamId) {
+  const safe = streamId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join6(workspaceDirPath(workspaceId2), "buffers", `${safe}.ansi`);
+}
+function safeJsonParse(raw, fallback) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function cardFromRow(row, children) {
+  const pr = row.pr_json ? safeJsonParse(row.pr_json, void 0) : void 0;
+  const card = {
+    id: row.id,
+    description: row.description,
+    descriptionAttachments: safeJsonParse(row.description_attachments_json, []),
+    columnId: row.column_id,
+    type: row.type,
+    readyForDev: row.ready_for_dev === 1,
+    waitsFor: children.waitsFor,
+    subtaskIds: children.subtaskIds,
+    autoFixAttempts: row.auto_fix_attempts,
+    activeLevel: row.active_level ?? "medium",
+    baseRef: row.base_ref,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    githubCommentIds: safeJsonParse(row.github_comment_ids_json, []),
+    reviewComments: children.reviewComments,
+    activityLog: children.activityLog,
+    terminalSessions: children.terminalSessions
+  };
+  if (row.agent_id) card.agentId = row.agent_id;
+  if (row.priority) card.priority = row.priority;
+  if (row.workflow_id) card.workflowId = row.workflow_id;
+  if (row.github_issue_url) card.githubIssueUrl = row.github_issue_url;
+  if (pr) card.pr = pr;
+  if (row.worktree_path) card.worktreePath = row.worktree_path;
+  if (row.branch_name) card.branchName = row.branch_name;
+  if (row.depends_on_id) card.dependsOn = row.depends_on_id;
+  if (row.slack_message_ts) card.slackMessageTs = row.slack_message_ts;
+  if (row.slack_channel_id) card.slackChannelId = row.slack_channel_id;
+  if (row.plan) card.plan = row.plan;
+  if (row.model_config_json) {
+    card.modelConfig = safeJsonParse(row.model_config_json, void 0);
+  }
+  return card;
+}
+function loadCardChildren(db, cardId) {
+  const waitsFor = db.prepare("SELECT waits_for_id FROM card_waits_for WHERE card_id = ?").all(cardId).map((r) => r.waits_for_id);
+  const subtaskIds = db.prepare("SELECT subtask_id FROM card_subtasks WHERE story_id = ?").all(cardId).map((r) => r.subtask_id);
+  const activityLog = db.prepare("SELECT timestamp, message FROM activity_log WHERE card_id = ? ORDER BY timestamp, id").all(cardId).map((r) => ({ timestamp: r.timestamp, message: r.message }));
+  const reviewRows = db.prepare(
+    "SELECT comment_id, created_at, type, actor_type, actor_id, actor_source, status, stream_id, summary, issues_json, attachments_json, metadata_json FROM review_comments WHERE card_id = ? ORDER BY created_at"
+  ).all(cardId);
+  const reviewComments = reviewRows.map((r) => {
+    const comment = {
+      id: r.comment_id,
+      type: r.type,
+      actor: {
+        type: r.actor_type,
+        id: r.actor_id,
+        ...r.actor_source ? { source: r.actor_source } : {}
+      },
+      createdAt: r.created_at,
+      summary: r.summary
+    };
+    if (r.status) comment.status = r.status;
+    if (r.stream_id) comment.streamId = r.stream_id;
+    const issues = safeJsonParse(r.issues_json, []);
+    if (issues && issues.length > 0) comment.issues = issues;
+    const attachments = safeJsonParse(r.attachments_json, []);
+    if (attachments && attachments.length > 0) comment.attachments = attachments;
+    const metadata = safeJsonParse(r.metadata_json, {});
+    if (metadata && Object.keys(metadata).length > 0) comment.metadata = metadata;
+    return comment;
+  });
+  const sessionRows = db.prepare(
+    "SELECT stream_id, type, started_at, ended_at, agent_id, state FROM terminal_sessions WHERE card_id = ? ORDER BY started_at"
+  ).all(cardId);
+  const terminalSessions = sessionRows.map((r) => {
+    const entry = {
+      streamId: r.stream_id,
+      type: r.type,
+      startedAt: r.started_at
+    };
+    if (r.ended_at != null) entry.endedAt = r.ended_at;
+    if (r.agent_id) entry.agentId = r.agent_id;
+    if (r.state) entry.state = r.state;
+    return entry;
+  });
+  return { waitsFor, subtaskIds, activityLog, reviewComments, terminalSessions };
+}
+function upsertCardRow(db, workspaceId2, card, columnPosition) {
+  db.prepare(
+    `INSERT INTO cards (
+			id, workspace_id, description, description_attachments_json,
+			column_id, column_position, type, ready_for_dev,
+			agent_id, priority, auto_fix_attempts, base_ref, workflow_id,
+			github_issue_url, pr_json, github_comment_ids_json,
+			worktree_path, branch_name, depends_on_id,
+			slack_message_ts, slack_channel_id,
+			plan, active_level, model_config_json, created_at, updated_at
+		) VALUES (
+			?, ?, ?, ?,
+			?, ?, ?, ?,
+			?, ?, ?, ?, ?,
+			?, ?, ?,
+			?, ?, ?,
+			?, ?,
+			?, ?, ?, ?, ?
+		) ON CONFLICT(id) DO UPDATE SET
+			description = excluded.description,
+			description_attachments_json = excluded.description_attachments_json,
+			column_id = excluded.column_id,
+			column_position = excluded.column_position,
+			type = excluded.type,
+			ready_for_dev = excluded.ready_for_dev,
+			agent_id = excluded.agent_id,
+			priority = excluded.priority,
+			auto_fix_attempts = excluded.auto_fix_attempts,
+			base_ref = excluded.base_ref,
+			workflow_id = excluded.workflow_id,
+			github_issue_url = excluded.github_issue_url,
+			pr_json = excluded.pr_json,
+			github_comment_ids_json = excluded.github_comment_ids_json,
+			worktree_path = excluded.worktree_path,
+			branch_name = excluded.branch_name,
+			depends_on_id = excluded.depends_on_id,
+			slack_message_ts = excluded.slack_message_ts,
+			slack_channel_id = excluded.slack_channel_id,
+			plan = excluded.plan,
+			active_level = excluded.active_level,
+			model_config_json = excluded.model_config_json,
+			updated_at = excluded.updated_at`
+  ).run(
+    card.id,
+    workspaceId2,
+    card.description,
+    JSON.stringify(card.descriptionAttachments ?? []),
+    card.columnId,
+    columnPosition,
+    card.type,
+    card.readyForDev ? 1 : 0,
+    card.agentId ?? null,
+    card.priority ?? null,
+    card.autoFixAttempts,
+    card.baseRef,
+    card.workflowId ?? null,
+    card.githubIssueUrl ?? null,
+    card.pr ? JSON.stringify(card.pr) : null,
+    JSON.stringify(card.githubCommentIds ?? []),
+    card.worktreePath ?? null,
+    card.branchName ?? null,
+    card.dependsOn ?? null,
+    card.slackMessageTs ?? null,
+    card.slackChannelId ?? null,
+    card.plan ?? null,
+    card.activeLevel ?? "medium",
+    card.modelConfig ? JSON.stringify(card.modelConfig) : null,
+    card.createdAt,
+    card.updatedAt
+  );
+}
+function replaceCardWaitsFor(db, cardId, waitsFor) {
+  db.prepare("DELETE FROM card_waits_for WHERE card_id = ?").run(cardId);
+  const insert = db.prepare(INSERT_CARD_WAITS_FOR_IF_EXISTS);
+  for (const targetId of waitsFor) insert.run(cardId, targetId, targetId, cardId, targetId);
+}
+function replaceCardSubtasks(db, storyId, subtaskIds) {
+  db.prepare("DELETE FROM card_subtasks WHERE story_id = ?").run(storyId);
+  const insert = db.prepare(INSERT_CARD_SUBTASK_IF_EXISTS);
+  for (const subtaskId of subtaskIds) insert.run(storyId, subtaskId, subtaskId, storyId, subtaskId);
+}
+function replaceCardChildren(db, card) {
+  replaceCardWaitsFor(db, card.id, card.waitsFor ?? []);
+  replaceCardSubtasks(db, card.id, card.subtaskIds ?? []);
+  db.prepare("DELETE FROM activity_log WHERE card_id = ?").run(card.id);
+  const insertActivity = db.prepare("INSERT INTO activity_log (card_id, timestamp, message) VALUES (?, ?, ?)");
+  for (const entry of card.activityLog ?? []) insertActivity.run(card.id, entry.timestamp, entry.message);
+  db.prepare("DELETE FROM review_comments WHERE card_id = ?").run(card.id);
+  const insertReview = db.prepare(
+    `INSERT INTO review_comments (
+			comment_id, card_id, created_at, type, actor_type, actor_id, actor_source,
+			status, stream_id, summary, issues_json, attachments_json, metadata_json
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const c of card.reviewComments ?? []) {
+    insertReview.run(
+      c.id,
+      card.id,
+      c.createdAt,
+      c.type,
+      c.actor.type,
+      c.actor.id,
+      c.actor.source ?? null,
+      c.status ?? null,
+      c.streamId ?? null,
+      c.summary,
+      JSON.stringify(c.issues ?? []),
+      JSON.stringify(c.attachments ?? []),
+      JSON.stringify(c.metadata ?? {})
+    );
+  }
+  db.prepare("DELETE FROM terminal_sessions WHERE card_id = ?").run(card.id);
+  const insertSession = db.prepare(
+    `INSERT INTO terminal_sessions (card_id, stream_id, type, started_at, ended_at, agent_id, state)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  for (const s of card.terminalSessions ?? []) {
+    insertSession.run(card.id, s.streamId, s.type, s.startedAt, s.endedAt ?? null, s.agentId ?? null, s.state ?? null);
+  }
+}
+function bumpBoardRevision(db, workspaceId2) {
+  const row = db.prepare("UPDATE workspaces SET board_revision = board_revision + 1 WHERE id = ? RETURNING board_revision").get(workspaceId2);
+  return row?.board_revision ?? 0;
+}
+function loadBoardInternal(workspaceId2) {
+  const db = getDb();
+  const cardRows = db.prepare("SELECT * FROM cards WHERE workspace_id = ? ORDER BY column_id, column_position").all(workspaceId2);
+  const taskIdsByColumn = {
+    todo: [],
+    in_progress: [],
+    reopened: [],
+    ready_for_review: [],
+    blocked: [],
+    done: []
+  };
+  const cards = {};
+  for (const row of cardRows) {
+    const card = cardFromRow(row, loadCardChildren(db, row.id));
+    cards[card.id] = card;
+    taskIdsByColumn[row.column_id].push(row.id);
+  }
+  const columns = BOARD_COLUMNS.map((col) => ({
+    id: col.id,
+    title: col.title,
+    taskIds: taskIdsByColumn[col.id]
+  }));
+  return { columns, cards };
+}
+function saveBoardInternal(workspaceId2, board) {
+  const db = getDb();
+  db.pragma("defer_foreign_keys = ON");
+  const positionFor = /* @__PURE__ */ new Map();
+  for (const col of board.columns) {
+    col.taskIds.forEach((cardId, idx) => {
+      positionFor.set(cardId, { columnId: col.id, position: idx });
+    });
+  }
+  const existing = db.prepare("SELECT id FROM cards WHERE workspace_id = ?").all(workspaceId2);
+  const requestIds = new Set(Object.keys(board.cards));
+  const toDelete = existing.filter((r) => !requestIds.has(r.id)).map((r) => r.id);
+  if (toDelete.length > 0) {
+    const placeholders = toDelete.map(() => "?").join(",");
+    db.prepare(`DELETE FROM cards WHERE id IN (${placeholders})`).run(...toDelete);
+  }
+  for (const card of Object.values(board.cards)) {
+    const pos = positionFor.get(card.id);
+    const column = pos?.columnId ?? card.columnId;
+    const position = pos?.position ?? 0;
+    const sanitizedDependsOn = card.dependsOn && board.cards[card.dependsOn] ? card.dependsOn : void 0;
+    const cardForRow = column === card.columnId && sanitizedDependsOn === card.dependsOn ? card : { ...card, columnId: column, dependsOn: sanitizedDependsOn };
+    upsertCardRow(db, workspaceId2, cardForRow, position);
+    replaceCardChildren(db, cardForRow);
+  }
+}
+async function loadBoard(workspaceId2) {
+  return loadBoardInternal(workspaceId2);
+}
+function loadProjectConfigInternal(workspaceId2) {
+  const db = getDb();
+  const wsRow = db.prepare("SELECT settings_json FROM workspaces WHERE id = ?").get(workspaceId2);
+  if (!wsRow) return runtimeProjectConfigSchema.parse({});
+  let settings = {};
+  try {
+    const parsed2 = JSON.parse(wsRow.settings_json);
+    if (parsed2 && typeof parsed2 === "object") settings = parsed2;
+  } catch {
+  }
+  const workflowRows = db.prepare("SELECT id, name, is_default, for_story, slots_json FROM workflows WHERE workspace_id = ?").all(workspaceId2);
+  const workflows = workflowRows.map((row) => {
+    let slots = [];
+    try {
+      slots = JSON.parse(row.slots_json);
+    } catch {
+      slots = [];
+    }
+    return {
+      id: row.id,
+      name: row.name,
+      isDefault: row.is_default === 1,
+      forStory: row.for_story === 1,
+      slots
+    };
+  });
+  const secretRows = db.prepare("SELECT key, value FROM workspace_secrets WHERE workspace_id = ?").all(workspaceId2);
+  const secrets = secretRows.map((r) => ({ key: r.key, value: decrypt(r.value) }));
+  const integrationRows = db.prepare("SELECT type, config_json FROM workspace_integrations WHERE workspace_id = ? AND enabled = 1").all(workspaceId2);
+  let github;
+  for (const row of integrationRows) {
+    try {
+      const cfg = JSON.parse(decrypt(row.config_json));
+      if (row.type === "github") github = cfg;
+    } catch {
+    }
+  }
+  const merged = {
+    ...settings,
+    workflows,
+    secrets
+  };
+  if (github) merged.github = github;
+  if (merged.deliveryMode === void 0) {
+    merged.deliveryMode = merged.autoPR === true ? "pr" : "off";
+  }
+  const parsed = runtimeProjectConfigSchema.safeParse(merged);
+  return parsed.success ? parsed.data : runtimeProjectConfigSchema.parse({});
+}
+function saveProjectConfigInternal(workspaceId2, config) {
+  const db = getDb();
+  const now = Date.now();
+  const { workflows, secrets, github, ...rest } = config;
+  db.prepare("UPDATE workspaces SET settings_json = ?, updated_at = ? WHERE id = ?").run(
+    JSON.stringify(rest),
+    now,
+    workspaceId2
+  );
+  const workflowsById = /* @__PURE__ */ new Map();
+  for (const wf of workflows) workflowsById.set(wf.id, wf);
+  const workflowsByName = /* @__PURE__ */ new Map();
+  for (const wf of workflowsById.values()) workflowsByName.set(wf.name, wf);
+  db.prepare("DELETE FROM workflows WHERE workspace_id = ?").run(workspaceId2);
+  const insertWf = db.prepare(
+    "INSERT INTO workflows (id, workspace_id, name, is_default, for_story, slots_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+  );
+  for (const wf of workflowsByName.values()) {
+    insertWf.run(
+      wf.id,
+      workspaceId2,
+      wf.name,
+      wf.isDefault ? 1 : 0,
+      wf.forStory ? 1 : 0,
+      JSON.stringify(wf.slots),
+      now,
+      now
+    );
+  }
+  const secretsByKey = /* @__PURE__ */ new Map();
+  for (const s of secrets) secretsByKey.set(s.key, s);
+  db.prepare("DELETE FROM workspace_secrets WHERE workspace_id = ?").run(workspaceId2);
+  const insertSec = db.prepare("INSERT INTO workspace_secrets (workspace_id, key, value) VALUES (?, ?, ?)");
+  for (const s of secretsByKey.values()) {
+    insertSec.run(workspaceId2, s.key, encrypt(s.value));
+  }
+  db.prepare("DELETE FROM workspace_integrations WHERE workspace_id = ?").run(workspaceId2);
+  const insertInt = db.prepare(
+    "INSERT INTO workspace_integrations (workspace_id, type, enabled, config_json, updated_at) VALUES (?, ?, 1, ?, ?)"
+  );
+  if (github) insertInt.run(workspaceId2, "github", encrypt(JSON.stringify(github)), now);
+}
+async function loadProjectConfig(workspaceId2) {
+  return loadProjectConfigInternal(workspaceId2);
+}
+async function saveProjectConfig(workspaceId2, config) {
+  const db = getDb();
+  const tx = db.transaction(() => saveProjectConfigInternal(workspaceId2, config));
+  tx();
+}
+async function updateProjectConfig(workspaceId2, mutator) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const current = loadProjectConfigInternal(workspaceId2);
+    const next = mutator(current);
+    saveProjectConfigInternal(workspaceId2, next);
+    return next;
+  });
+  return tx();
+}
+async function loadWorkspaceContext(repoPath) {
+  const db = getDb();
+  const existing = db.prepare("SELECT id, name FROM workspaces WHERE repo_path = ?").get(repoPath);
+  if (existing) {
+    return { workspaceId: existing.id, repoPath, name: existing.name, lastUpdated: 0 };
+  }
+  const workspaceId2 = randomBytes3(4).toString("hex");
+  const name = repoPath.split("/").pop() ?? repoPath;
+  const now = Date.now();
+  db.prepare(
+    "INSERT INTO workspaces (id, repo_path, name, settings_json, created_at, updated_at) VALUES (?, ?, ?, '{}', ?, ?)"
+  ).run(workspaceId2, repoPath, name, now, now);
+  return { workspaceId: workspaceId2, repoPath, name, lastUpdated: 0 };
+}
+async function listWorkspaces() {
+  const db = getDb();
+  const rows = db.prepare("SELECT id, repo_path, name FROM workspaces WHERE archived_at IS NULL").all();
+  return rows.map((r) => ({
+    workspaceId: r.id,
+    repoPath: r.repo_path,
+    name: r.name,
+    lastUpdated: 0
+  }));
+}
+async function loadWorkspaceState(workspaceId2, repoPath) {
+  const db = getDb();
+  const wsRow = db.prepare("SELECT board_revision FROM workspaces WHERE id = ?").get(workspaceId2);
+  const revision = wsRow?.board_revision ?? 0;
+  const board = loadBoardInternal(workspaceId2);
+  const projectConfig = loadProjectConfigInternal(workspaceId2);
+  return {
+    workspaceId: workspaceId2,
+    repoPath,
+    board,
+    revision,
+    projectConfig
+  };
+}
+async function saveWorkspaceState(workspaceId2, request) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const wsRow = db.prepare("SELECT board_revision FROM workspaces WHERE id = ?").get(workspaceId2);
+    const currentRevision = wsRow?.board_revision ?? 0;
+    if (request.revision !== currentRevision) {
+      throw new Error(`Revision conflict: expected ${currentRevision}, got ${request.revision}`);
+    }
+    saveBoardInternal(workspaceId2, request.board);
+    const newRevision = currentRevision + 1;
+    db.prepare("UPDATE workspaces SET board_revision = ?, updated_at = ? WHERE id = ?").run(
+      newRevision,
+      Date.now(),
+      workspaceId2
+    );
+    return { revision: newRevision };
+  });
+  return tx();
+}
+async function clearCardSession(workspaceId2, cardId) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const result = db.prepare("UPDATE cards SET worktree_path = NULL, updated_at = ? WHERE id = ? AND workspace_id = ?").run(Date.now(), cardId, workspaceId2);
+    if (result.changes > 0) bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+}
+async function moveCard(workspaceId2, cardId, targetColumnId, targetIndex) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const cardRow = db.prepare("SELECT column_id FROM cards WHERE id = ? AND workspace_id = ?").get(cardId, workspaceId2);
+    if (!cardRow) return;
+    const sourceColumnId = cardRow.column_id;
+    const sameColumn = sourceColumnId === targetColumnId;
+    const sourceCards = db.prepare("SELECT id FROM cards WHERE workspace_id = ? AND column_id = ? AND id != ? ORDER BY column_position").all(workspaceId2, sourceColumnId, cardId);
+    const targetCards = sameColumn ? sourceCards : db.prepare("SELECT id FROM cards WHERE workspace_id = ? AND column_id = ? ORDER BY column_position").all(workspaceId2, targetColumnId);
+    const insertAt = typeof targetIndex === "number" ? targetIndex : targetCards.length;
+    const finalTarget = [...targetCards];
+    finalTarget.splice(insertAt, 0, { id: cardId });
+    const now = Date.now();
+    const updateTarget = db.prepare("UPDATE cards SET column_id = ?, column_position = ?, updated_at = ? WHERE id = ?");
+    for (let i = 0; i < finalTarget.length; i++) {
+      updateTarget.run(targetColumnId, i, now, finalTarget[i].id);
+    }
+    if (!sameColumn) {
+      const updateSource = db.prepare("UPDATE cards SET column_position = ?, updated_at = ? WHERE id = ?");
+      for (let i = 0; i < sourceCards.length; i++) {
+        updateSource.run(i, now, sourceCards[i].id);
+      }
+    }
+    bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+  return loadBoardInternal(workspaceId2);
+}
+async function createCard(workspaceId2, data, baseRef) {
+  const db = getDb();
+  const id = generateTaskId();
+  const now = Date.now();
+  const type = data.type ?? "task";
+  const columnId = data.columnId ?? "todo";
+  const projectConfig = loadProjectConfigInternal(workspaceId2);
+  const workflow = resolveWorkflowForCard(projectConfig.workflows, { workflowId: data.workflowId, type });
+  const modelConfig = data.modelConfig ?? snapshotModelConfig(workflow);
+  const card = {
+    id,
+    description: data.description,
+    columnId,
+    type,
+    readyForDev: data.readyForDev ?? type === "story",
+    agentId: data.agentId,
+    priority: data.priority,
+    dependsOn: data.dependsOn,
+    waitsFor: data.waitsFor ?? [],
+    subtaskIds: data.subtaskIds ?? [],
+    autoFixAttempts: 0,
+    activeLevel: data.activeLevel ?? highestWorkflowLevel(workflow),
+    modelConfig,
+    baseRef,
+    createdAt: now,
+    updatedAt: now,
+    githubIssueUrl: data.githubIssueUrl,
+    // Persist the resolved workflow id (not the raw input) so a card always records
+    // which workflow it runs — otherwise an omitted workflowId leaves the card unlinked.
+    workflowId: data.workflowId ?? workflow?.id,
+    descriptionAttachments: data.descriptionAttachments ?? [],
+    branchName: data.branchName,
+    reviewComments: [],
+    activityLog: [],
+    terminalSessions: [],
+    githubCommentIds: []
+  };
+  const tx = db.transaction(() => {
+    if (card.dependsOn && !db.prepare("SELECT 1 FROM cards WHERE id = ?").get(card.dependsOn)) {
+      card.dependsOn = void 0;
+    }
+    const countRow = db.prepare("SELECT COUNT(*) AS n FROM cards WHERE workspace_id = ? AND column_id = ?").get(workspaceId2, columnId);
+    upsertCardRow(db, workspaceId2, card, countRow.n);
+    replaceCardWaitsFor(db, card.id, card.waitsFor ?? []);
+    replaceCardSubtasks(db, card.id, card.subtaskIds ?? []);
+    bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+  return card;
+}
+async function appendActivityLog(workspaceId2, cardId, message) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const exists = db.prepare("SELECT 1 FROM cards WHERE id = ? AND workspace_id = ?").get(cardId, workspaceId2);
+    if (!exists) return;
+    const now = Date.now();
+    db.prepare("INSERT INTO activity_log (card_id, timestamp, message) VALUES (?, ?, ?)").run(cardId, now, message);
+    db.prepare("UPDATE cards SET updated_at = ? WHERE id = ?").run(now, cardId);
+  });
+  tx();
+}
+async function saveTerminalBuffer(workspaceId2, streamId, data) {
+  const filePath = bufferFilePath(workspaceId2, streamId);
+  await mkdir(join6(workspaceDirPath(workspaceId2), "buffers"), { recursive: true });
+  await writeFile(filePath, data, "utf-8");
+}
+async function loadTerminalBuffer(workspaceId2, streamId) {
+  try {
+    return await readFile(bufferFilePath(workspaceId2, streamId), "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function appendTerminalSession(workspaceId2, cardId, entry) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const exists = db.prepare("SELECT 1 FROM cards WHERE id = ? AND workspace_id = ?").get(cardId, workspaceId2);
+    if (!exists) return;
+    db.prepare(
+      `INSERT INTO terminal_sessions (card_id, stream_id, type, started_at, ended_at, agent_id, state)
+				 VALUES (?, ?, ?, ?, ?, ?, ?)
+				 ON CONFLICT(card_id, stream_id) DO UPDATE SET
+					 type = excluded.type,
+					 started_at = excluded.started_at,
+					 ended_at = excluded.ended_at,
+					 agent_id = excluded.agent_id,
+					 state = excluded.state`
+    ).run(
+      cardId,
+      entry.streamId,
+      entry.type,
+      entry.startedAt,
+      entry.endedAt ?? null,
+      entry.agentId ?? null,
+      entry.state ?? null
+    );
+    db.prepare("UPDATE cards SET updated_at = ? WHERE id = ?").run(Date.now(), cardId);
+  });
+  tx();
+}
+async function closeAllOpenTerminalSessions(workspaceId2, cardId, endedAt) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const result = db.prepare("UPDATE terminal_sessions SET ended_at = ?, state = 'killed' WHERE card_id = ? AND ended_at IS NULL").run(endedAt, cardId);
+    if (result.changes > 0) bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+}
+async function endTerminalSession(workspaceId2, cardId, streamId, endedAt, state) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const result = state ? db.prepare("UPDATE terminal_sessions SET ended_at = ?, state = ? WHERE card_id = ? AND stream_id = ?").run(endedAt, state, cardId, streamId) : db.prepare("UPDATE terminal_sessions SET ended_at = ? WHERE card_id = ? AND stream_id = ?").run(endedAt, cardId, streamId);
+    if (result.changes > 0) bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+}
+async function linkCommentToSession(workspaceId2, cardId, commentCreatedAt, streamId) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const result = db.prepare("UPDATE review_comments SET stream_id = ? WHERE card_id = ? AND created_at = ?").run(streamId, cardId, commentCreatedAt);
+    if (result.changes > 0) bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+}
+async function stampReviewCommentMetadata(workspaceId2, cardId, commentCreatedAt, patch) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const row = db.prepare("SELECT metadata_json FROM review_comments WHERE card_id = ? AND created_at = ?").get(cardId, commentCreatedAt);
+    if (!row) return;
+    const current = safeJsonParse(row.metadata_json, {});
+    const result = db.prepare("UPDATE review_comments SET metadata_json = ? WHERE card_id = ? AND created_at = ?").run(JSON.stringify({ ...current, ...patch }), cardId, commentCreatedAt);
+    if (result.changes > 0) bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+}
+function extractSignedImageUrls(bodyHtml) {
+  const map = /* @__PURE__ */ new Map();
+  const cdnPattern = /https:\/\/private-user-images\.githubusercontent\.com\/[^"'<>\s]+/g;
+  const uuidPattern = /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})\./i;
+  for (const cdnUrl of bodyHtml.match(cdnPattern) ?? []) {
+    const uuidMatch = cdnUrl.match(uuidPattern);
+    if (uuidMatch?.[1]) map.set(uuidMatch[1].toLowerCase(), cdnUrl);
+  }
+  return map;
+}
+async function downloadGithubImages(text, cardId, _workspaceId, fetchHtml) {
+  const assetPattern = /https:\/\/github\.com\/user-attachments\/assets\/[^\s"'<>\]]+/g;
+  const assetUrls = [...new Set(text.match(assetPattern) ?? [])];
+  if (assetUrls.length === 0) return text;
+  let signedUrlMap;
+  const tryDownload = async (url) => {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    return res;
+  };
+  let result = text;
+  for (const assetUrl of assetUrls) {
+    try {
+      let res = await tryDownload(assetUrl);
+      if (!res && fetchHtml) {
+        if (!signedUrlMap) {
+          const html = await fetchHtml();
+          signedUrlMap = html ? extractSignedImageUrls(html) : /* @__PURE__ */ new Map();
+        }
+        const assetUuid = assetUrl.split("/").pop()?.toLowerCase() ?? "";
+        const signedUrl = signedUrlMap.get(assetUuid);
+        if (signedUrl) res = await tryDownload(signedUrl);
+      }
+      if (!res) continue;
+      const contentType = res.headers.get("content-type") ?? "image/png";
+      const extMap = {
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/gif": "gif",
+        "image/webp": "webp"
+      };
+      const ext = extMap[contentType.split(";")[0]?.trim() ?? ""] ?? "png";
+      const buffer = Buffer.from(await res.arrayBuffer());
+      const localPath = await saveAttachment(buffer, ext, cardId);
+      const parts = localPath.replace(/\\/g, "/").split("/");
+      const filename = parts[parts.length - 1];
+      const localUrl = `/api/attachments/${encodeURIComponent(cardId)}/${encodeURIComponent(filename)}`;
+      result = result.replaceAll(assetUrl, localUrl);
+    } catch {
+    }
+  }
+  return result;
+}
+async function saveAttachment(data, ext, cardId) {
+  const dir = join6(ATTACHMENTS_DIR, cardId);
+  await mkdir(dir, { recursive: true });
+  const hash = createHash("sha256").update(data).digest("hex");
+  const filePath = join6(dir, `${hash}.${ext}`);
+  if (!existsSync2(filePath)) {
+    await writeFile(filePath, data);
+  }
+  return filePath;
+}
+async function updateCard(workspaceId2, cardId, update) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const row = db.prepare("SELECT * FROM cards WHERE id = ? AND workspace_id = ?").get(cardId, workspaceId2);
+    if (!row) return null;
+    const existing = cardFromRow(row, loadCardChildren(db, cardId));
+    const updated = { ...existing, ...update, updatedAt: Date.now() };
+    if (updated.dependsOn && !db.prepare("SELECT 1 FROM cards WHERE id = ?").get(updated.dependsOn)) {
+      updated.dependsOn = void 0;
+    }
+    upsertCardRow(db, workspaceId2, updated, row.column_position);
+    if (update.waitsFor !== void 0) replaceCardWaitsFor(db, cardId, update.waitsFor);
+    if (update.subtaskIds !== void 0) replaceCardSubtasks(db, cardId, update.subtaskIds);
+    if (update.reviewComments !== void 0) {
+      db.prepare("DELETE FROM review_comments WHERE card_id = ?").run(cardId);
+      const insertReview = db.prepare(
+        `INSERT INTO review_comments (
+					comment_id, card_id, created_at, type, actor_type, actor_id, actor_source,
+					status, stream_id, summary, issues_json, attachments_json, metadata_json
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const c of update.reviewComments ?? []) {
+        insertReview.run(
+          c.id,
+          cardId,
+          c.createdAt,
+          c.type,
+          c.actor.type,
+          c.actor.id,
+          c.actor.source ?? null,
+          c.status ?? null,
+          c.streamId ?? null,
+          c.summary,
+          JSON.stringify(c.issues ?? []),
+          JSON.stringify(c.attachments ?? []),
+          JSON.stringify(c.metadata ?? {})
+        );
+      }
+    }
+    bumpBoardRevision(db, workspaceId2);
+    return updated;
+  });
+  const result = tx();
+  return result;
+}
+async function deleteCard(workspaceId2, cardId) {
+  const db = getDb();
+  const tx = db.transaction(() => {
+    const cardRow = db.prepare("SELECT column_id FROM cards WHERE id = ? AND workspace_id = ?").get(cardId, workspaceId2);
+    if (!cardRow) return;
+    db.prepare("DELETE FROM memories WHERE origin_card_id = ? AND status = 'pending'").run(cardId);
+    db.prepare("DELETE FROM cards WHERE id = ?").run(cardId);
+    const remaining = db.prepare("SELECT id FROM cards WHERE workspace_id = ? AND column_id = ? ORDER BY column_position").all(workspaceId2, cardRow.column_id);
+    const updatePos = db.prepare("UPDATE cards SET column_position = ?, updated_at = ? WHERE id = ?");
+    const now = Date.now();
+    for (let i = 0; i < remaining.length; i++) {
+      updatePos.run(i, now, remaining[i].id);
+    }
+    bumpBoardRevision(db, workspaceId2);
+  });
+  tx();
+  try {
+    const { rm } = await import("node:fs/promises");
+    await rm(join6(ATTACHMENTS_DIR, cardId), { recursive: true, force: true });
+  } catch {
+  }
+}
+async function removeWorkspace(workspaceId2) {
+  const db = getDb();
+  db.prepare("DELETE FROM workspaces WHERE id = ?").run(workspaceId2);
+}
+var INSERT_CARD_WAITS_FOR_IF_EXISTS, INSERT_CARD_SUBTASK_IF_EXISTS;
+var init_workspace_state = __esm({
+  "src/state/workspace-state.ts"() {
+    "use strict";
+    init_runtime_config();
+    init_api_contract();
+    init_task_id();
+    init_db();
+    init_secrets_crypto();
+    INSERT_CARD_WAITS_FOR_IF_EXISTS = `
+	INSERT INTO card_waits_for (card_id, waits_for_id)
+	SELECT ?, ? WHERE EXISTS (SELECT 1 FROM cards WHERE id = ?) AND ? != ?
+`;
+    INSERT_CARD_SUBTASK_IF_EXISTS = `
+	INSERT INTO card_subtasks (story_id, subtask_id)
+	SELECT ?, ? WHERE EXISTS (SELECT 1 FROM cards WHERE id = ?) AND ? != ?
+`;
+  }
+});
+
+// src/mcp/kanban-mcp-server.ts
+init_api_contract();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+var serverUrl = process.argv[2] ?? process.env.WHIPPED_SERVER_URL ?? "http://127.0.0.1:3000";
+var workspaceId = process.argv[3] ?? process.env.WHIPPED_WORKSPACE_ID ?? "";
+var agentId = process.argv[4] && !process.argv[4].startsWith("--") ? process.argv[4] : "claude";
+function namedArg(flag) {
+  const hit = process.argv.find((a) => a.startsWith(`${flag}=`));
+  return hit ? hit.slice(flag.length + 1) : void 0;
+}
+var mcpRole = namedArg("--role") ?? "task";
+var recurringAgentId = namedArg("--recurring-agent-id") ?? "";
+var apiToken = process.env.WHIPPED_API_TOKEN ?? "";
+var authHeaders = apiToken ? { "x-whipped-token": apiToken } : {};
+var ROUTES = {
+  "workspace.state": { method: "GET", path: () => "workspace/state" },
+  "workflows.list": { method: "GET", path: () => "workflows" },
+  "projectConfig.get": { method: "GET", path: () => "project-config" },
+  "memory.search": { method: "GET", path: () => "memory/search" },
+  "memory.get": { method: "GET", path: (i) => `memory/${i.id}` },
+  "cards.create": { method: "POST", path: () => "cards" },
+  "cards.update": { method: "PATCH", path: (i) => `cards/${i.cardId}` },
+  "cards.move": { method: "POST", path: () => "cards/move" },
+  "cards.delete": { method: "DELETE", path: (i) => `cards/${i.cardId}` },
+  "cards.addReviewComment": { method: "POST", path: () => "cards/add-review-comment" },
+  "cards.interruptTask": { method: "POST", path: () => "cards/interrupt-task" },
+  "cards.setPrMeta": { method: "POST", path: () => "cards/set-pr-meta" },
+  "cards.setPlan": { method: "POST", path: () => "cards/set-plan" },
+  "workflows.upsert": { method: "POST", path: () => "workflows" },
+  "projectConfig.setGitInstructions": { method: "POST", path: () => "project-config/git-instructions" },
+  "projectConfig.setSystemPrompt": { method: "POST", path: () => "project-config/system-prompt" },
+  "memory.propose": { method: "POST", path: () => "memory/propose" },
+  "memory.proposeUpdate": { method: "POST", path: () => "memory/propose-update" },
+  "recurring.list": { method: "GET", path: () => "recurring-agents" },
+  "recurring.create": { method: "POST", path: () => "recurring-agents" },
+  "recurring.update": { method: "PATCH", path: (i) => `recurring-agents/${i.id}` },
+  "recurring.delete": { method: "DELETE", path: (i) => `recurring-agents/${i.id}` },
+  "recurring.setJournal": { method: "POST", path: (i) => `recurring-agents/${i.id}/journal` }
+};
+async function apiMutate(procedure, input) {
+  const route = ROUTES[procedure];
+  if (!route) throw new Error(`Unknown procedure: ${procedure}`);
+  const res = await fetch(`${serverUrl}/api/${route.path(input)}`, {
+    method: route.method,
+    headers: { "Content-Type": "application/json", ...authHeaders },
+    body: JSON.stringify(input),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) throw new Error(`${procedure} failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+async function apiQuery(procedure, input) {
+  const route = ROUTES[procedure];
+  if (!route) throw new Error(`Unknown procedure: ${procedure}`);
+  const qs = new URLSearchParams();
+  for (const [k, v] of Object.entries(input)) {
+    if (v !== void 0 && v !== null) qs.set(k, String(v));
+  }
+  const query = qs.toString();
+  const res = await fetch(`${serverUrl}/api/${route.path(input)}${query ? `?${query}` : ""}`, {
+    headers: authHeaders,
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) throw new Error(`${procedure} failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+var server = new McpServer({ name: "whipped", version: "1.0.0" });
+var RECURRING_OBSERVER_TOOLS = /* @__PURE__ */ new Set([
+  "kanban_get_board",
+  "kanban_create_card",
+  "kanban_add_comment",
+  "kanban_get_workflows",
+  "kanban_get_pr_meta",
+  "kanban_get_git_instructions",
+  "kanban_get_system_prompt",
+  "whipped_search_memory",
+  "whipped_get_memory",
+  "update_journal"
+]);
+var baseRegisterTool = server.registerTool;
+var registerTool = ((name, ...rest) => {
+  if (mcpRole === "recurring" && !RECURRING_OBSERVER_TOOLS.has(name)) return void 0;
+  return baseRegisterTool.call(server, name, ...rest);
+});
+var attachmentInputSchema = z2.object({
+  type: z2.string().describe("Attachment type \u2014 'image' for images, 'file' for other files"),
+  name: z2.string().describe("Human-readable name for the attachment"),
+  mimeType: z2.string().describe("MIME type, e.g. image/png, application/pdf"),
+  path: z2.string().describe("Absolute file path to read from")
+});
+async function processAttachments(attachments, cardId) {
+  const { readFile: readFile2 } = await import("node:fs/promises");
+  const { saveAttachment: saveAttachment2 } = await Promise.resolve().then(() => (init_workspace_state(), workspace_state_exports));
+  const results = [];
+  for (const att of attachments) {
+    try {
+      const data = await readFile2(att.path);
+      const ext = att.path.split(".").pop() ?? "bin";
+      const canonicalPath = await saveAttachment2(data, ext, cardId);
+      results.push({ type: att.type, name: att.name, mimeType: att.mimeType, path: canonicalPath });
+    } catch {
+    }
+  }
+  return results;
+}
+registerTool(
+  "kanban_get_board",
+  {
+    description: "Get the current Kanban board state including all cards and their columns.",
+    inputSchema: {}
+  },
+  async () => {
+    const state = await apiQuery("workspace.state", {
+      workspaceId
+    });
+    const board = state.board;
+    const lines = [];
+    for (const col of board.columns) {
+      if (col.taskIds.length === 0) continue;
+      lines.push(`## ${col.title}`);
+      for (const id of col.taskIds) {
+        const card = board.cards[id];
+        if (!card) continue;
+        const typeTag = card.type && card.type !== "task" ? ` [${card.type}]` : "";
+        const priorityTag = card.priority ? ` [${card.priority}]` : "";
+        const waitsTag = card.waitsFor && card.waitsFor.length > 0 ? ` (waits for: ${card.waitsFor.join(", ")})` : "";
+        const depsTag = card.dependsOn ? ` (depends on: ${card.dependsOn})` : waitsTag;
+        const cardDisplay = (card.description?.split("\n")[0] ?? "").slice(0, 80) || id;
+        lines.push(`- [${id}]${typeTag} ${cardDisplay}${priorityTag}${depsTag}`);
+        if (card.type === "story" && card.subtaskIds && card.subtaskIds.length > 0) {
+          const met = card.subtaskIds.filter((subId) => {
+            const sub = board.cards[subId];
+            return sub?.columnId === "ready_for_review" || sub?.columnId === "done";
+          });
+          lines.push(`  Progress: ${met.length}/${card.subtaskIds.length} subtasks complete`);
+        }
+      }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") || "Board is empty." }] };
+  }
+);
+registerTool(
+  "kanban_create_story",
+  {
+    description: `Create a story ticket with its subtasks in one atomic operation.
+
+Creates all subtasks first, then the story card that depends on them. The story triggers its orchestrator workflow automatically when all subtasks reach 'Ready for Review' or 'Done'.
+
+**Intra-batch dependencies:** If subtask B should run after subtask A (both in this batch), give subtask A a \`tempId\` (e.g. "auth") and list that tempId in subtask B's \`dependsOn\`. The real card IDs are wired up automatically after creation.`,
+    inputSchema: {
+      description: z2.string().describe(
+        "Story description \u2014 what this story accomplishes as a whole, including acceptance criteria. The first line serves as the story title."
+      ),
+      priority: z2.enum(["urgent", "high", "medium", "low"]).optional().describe("Story priority"),
+      workflowId: z2.string().min(1).describe(
+        "REQUIRED. ID of the story orchestrator workflow. Call kanban_get_workflows first and pick the story workflow that best matches this story's scope; fall back to the default story workflow only if none fits."
+      ),
+      baseRef: z2.string().optional().describe("Base branch for all cards in this story. Omit to use the repo default branch."),
+      activeLevel: z2.enum(["minimal", "low", "medium", "high", "max"]).optional().describe(
+        "Capability level for the story's orchestrator (orch) workflow. Each subtask sets its own level. Omit to default to the workflow's highest configured tier."
+      ),
+      attachments: z2.array(attachmentInputSchema).optional().describe(
+        "Files to attach (e.g. design docs, screenshots). Reference each one inline in the story description as [Attachment #N], where N is its 1-based position in this array."
+      ),
+      subtasks: z2.array(
+        z2.object({
+          tempId: z2.string().optional().describe(
+            "Short label to reference this subtask from other subtasks' dependsOn in this batch (e.g. 'auth', 'db-schema'). Not stored \u2014 only used for wiring up intra-batch deps."
+          ),
+          description: z2.string().describe("Subtask description with acceptance criteria. The first line serves as the subtask title."),
+          priority: z2.enum(["urgent", "high", "medium", "low"]).optional().describe("Subtask priority"),
+          workflowId: z2.string().min(1).describe(
+            "REQUIRED. Workflow ID for this subtask (from kanban_get_workflows). Pick the workflow matching the subtask's nature (e.g. frontend vs backend); fall back to the default task workflow only if none fits."
+          ),
+          baseRef: z2.string().optional().describe("Override base branch for this subtask only"),
+          branchName: z2.string().min(1).describe(
+            "REQUIRED. Git branch name for this subtask: '<type>/<slug>' (e.g. 'fix/user-auth-bug', 'feat/dark-mode'). All lowercase, dashes not underscores, \u226460 chars."
+          ),
+          dependsOn: z2.array(z2.string()).optional().describe(
+            "Dependencies for this subtask. Use real card IDs for existing cards on the board, or tempId values to reference other subtasks in this same batch."
+          ),
+          activeLevel: z2.enum(["minimal", "low", "medium", "high", "max"]).optional().describe(
+            "Capability level for this subtask's dev workflow. Omit to default to the workflow's highest configured tier; lower it for trivial subtasks."
+          ),
+          attachments: z2.array(attachmentInputSchema).optional().describe(
+            "Files to attach to this subtask. Reference each one inline in this subtask's description as [Attachment #N], where N is its 1-based position in this array."
+          )
+        })
+      ).min(1).describe(
+        "Subtasks to create. At least one required. Each subtask gets type: 'subtask' and readyForDev: true automatically."
+      )
+    }
+  },
+  async ({ description, priority, workflowId, baseRef, activeLevel, attachments, subtasks }) => {
+    const tempIdToRealId = /* @__PURE__ */ new Map();
+    const createdSubtasks = [];
+    for (const subtask of subtasks) {
+      const existingDeps = (subtask.dependsOn ?? []).filter((dep) => !subtasks.some((s) => s.tempId === dep));
+      const card = await apiMutate("cards.create", {
+        workspaceId,
+        description: subtask.description,
+        type: "subtask",
+        priority: subtask.priority,
+        readyForDev: true,
+        baseRef: subtask.baseRef || baseRef || void 0,
+        workflowId: subtask.workflowId || void 0,
+        branchName: subtask.branchName || void 0,
+        activeLevel: subtask.activeLevel,
+        dependsOn: existingDeps[0]
+      });
+      if (subtask.attachments?.length) {
+        const processed = await processAttachments(subtask.attachments, card.id);
+        if (processed.length) {
+          await apiMutate("cards.update", {
+            workspaceId,
+            cardId: card.id,
+            descriptionAttachments: processed,
+            revision: 0
+          });
+        }
+      }
+      if (subtask.tempId) tempIdToRealId.set(subtask.tempId, card.id);
+      createdSubtasks.push({
+        realId: card.id,
+        descFirst: subtask.description.split("\n")[0] ?? "",
+        rawDeps: subtask.dependsOn ?? []
+      });
+    }
+    for (const { realId, rawDeps } of createdSubtasks) {
+      const batchDeps = rawDeps.filter((dep) => tempIdToRealId.has(dep));
+      if (batchDeps.length === 0) continue;
+      const resolvedBatchDeps = batchDeps.map((dep) => tempIdToRealId.get(dep));
+      const existingDeps = rawDeps.filter((dep) => !tempIdToRealId.has(dep));
+      await apiMutate("cards.update", {
+        workspaceId,
+        cardId: realId,
+        dependsOn: [...existingDeps, ...resolvedBatchDeps][0],
+        revision: 0
+      });
+    }
+    const subtaskIds = createdSubtasks.map((s) => s.realId);
+    const storyCard = await apiMutate("cards.create", {
+      workspaceId,
+      description,
+      type: "story",
+      priority,
+      baseRef: baseRef || void 0,
+      workflowId: workflowId || void 0,
+      activeLevel,
+      subtaskIds
+    });
+    if (attachments?.length) {
+      const processed = await processAttachments(attachments, storyCard.id);
+      if (processed.length) {
+        await apiMutate("cards.update", {
+          workspaceId,
+          cardId: storyCard.id,
+          descriptionAttachments: processed,
+          revision: 0
+        });
+      }
+    }
+    const storyDisplay = description.split("\n")[0]?.slice(0, 80) ?? storyCard.id;
+    const lines = [`Created story [${storyCard.id}] "${storyDisplay}" with ${subtaskIds.length} subtask(s):`];
+    for (const { realId, descFirst } of createdSubtasks)
+      lines.push(`  Subtask [${realId}] "${descFirst.slice(0, 80)}"`);
+    lines.push(`The story will trigger its orchestrator workflow once all subtasks complete.`);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+registerTool(
+  "kanban_create_card",
+  {
+    description: "Create a new task card on the Kanban board.",
+    inputSchema: {
+      description: z2.string().describe("Full task description including acceptance criteria. The first line serves as the display title."),
+      type: z2.enum(["task", "story", "subtask"]).optional().describe(
+        "Card type \u2014 'task' (default), 'story' (orchestrator ticket with subtasks), or 'subtask' (child of a story)"
+      ),
+      priority: z2.enum(["urgent", "high", "medium", "low"]).optional().describe("Task priority \u2014 urgent cards are dispatched first in autonomous mode"),
+      readyForDev: z2.boolean().optional().describe(
+        "Mark the card as ready for the agent to pick up automatically. Defaults to false (true for story cards)."
+      ),
+      columnId: z2.enum(["todo", "blocked"]).optional().describe("Starting column \u2014 defaults to 'todo'"),
+      dependsOn: z2.string().optional().describe(
+        "Single parent card ID this card is stacked on \u2014 it continues in the parent's worktree and starts once the parent reaches ready_for_review. Mutually exclusive with waitsFor."
+      ),
+      waitsFor: z2.array(z2.string()).optional().describe(
+        "Card IDs this card waits for \u2014 it starts in a fresh worktree from the base branch only once ALL of them are done. Mutually exclusive with dependsOn."
+      ),
+      workflowId: z2.string().min(1).describe(
+        "REQUIRED. ID of the workflow this task runs. Call kanban_get_workflows first, then pick the workflow whose name/purpose best matches the task (e.g. a frontend workflow for UI-only work, a backend workflow for API work). Only fall back to the default task workflow if none is a good fit."
+      ),
+      activeLevel: z2.enum(["minimal", "low", "medium", "high", "max"]).optional().describe(
+        "Capability level the whole pipeline runs at (each slot maps it to its own model via the slot's pairs + mode). Higher = more capable/expensive. Omit to default to the workflow's highest configured tier; lower it for trivial work."
+      ),
+      attachments: z2.array(attachmentInputSchema).optional().describe(
+        "Files to attach (e.g. screenshots, design docs, PDFs). Reference each one inline in the description as [Attachment #N], where N is its 1-based position in this array (first \u2192 [Attachment #1])."
+      ),
+      branchName: z2.string().min(1).describe(
+        "REQUIRED. Git branch name for this card, derived from the title: '<type>/<slug>' (e.g. 'fix/user-auth-bug', 'feat/dark-mode'). All lowercase, dashes not underscores, \u226460 chars."
+      )
+    }
+  },
+  async ({
+    description,
+    type,
+    priority,
+    readyForDev,
+    columnId,
+    dependsOn,
+    waitsFor,
+    workflowId,
+    activeLevel,
+    attachments,
+    branchName
+  }) => {
+    const card = await apiMutate("cards.create", {
+      workspaceId,
+      description,
+      type,
+      priority,
+      readyForDev,
+      dependsOn,
+      waitsFor,
+      columnId: columnId ?? "todo",
+      workflowId,
+      activeLevel,
+      branchName: branchName || void 0
+    });
+    if (attachments?.length) {
+      const processed = await processAttachments(attachments, card.id);
+      if (processed.length) {
+        await apiMutate("cards.update", {
+          workspaceId,
+          cardId: card.id,
+          descriptionAttachments: processed,
+          revision: 0
+        });
+      }
+    }
+    const cardDisplay = description.split("\n")[0]?.slice(0, 80) || card.id;
+    return {
+      content: [{ type: "text", text: `Created card [${card.id}] "${cardDisplay}" in ${card.columnId}.` }]
+    };
+  }
+);
+registerTool(
+  "kanban_move_card",
+  {
+    description: "Move a card to a different column.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID (from kanban_get_board)"),
+      targetColumnId: z2.enum(["todo", "in_progress", "reopened", "ready_for_review", "blocked", "done"]).describe("Destination column")
+    }
+  },
+  async ({ cardId, targetColumnId }) => {
+    await apiMutate("cards.move", { workspaceId, cardId, targetColumnId, revision: 0 });
+    return { content: [{ type: "text", text: `Moved card ${cardId} to ${targetColumnId}.` }] };
+  }
+);
+registerTool(
+  "kanban_update_card",
+  {
+    description: "Update a card's description, priority, dependencies, workflow, readyForDev flag, or attachments.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID"),
+      description: z2.string().optional().describe("New description"),
+      priority: z2.enum(["urgent", "high", "medium", "low"]).optional().describe("New priority level"),
+      dependsOn: z2.string().optional().describe(
+        "Single parent card ID this card is stacked on (replaces existing). Mutually exclusive with waitsFor."
+      ),
+      waitsFor: z2.array(z2.string()).optional().describe(
+        "Card IDs this card waits for \u2014 starts only once all are done (replaces existing). Mutually exclusive with dependsOn."
+      ),
+      workflowId: z2.string().optional().describe("ID of the workflow to assign to this card"),
+      readyForDev: z2.boolean().optional().describe("Whether the card is ready for the agent to pick up automatically"),
+      activeLevel: z2.enum(["minimal", "low", "medium", "high", "max"]).optional().describe(
+        "Capability level the pipeline runs at (each slot maps it to its own model). Raise for bigger scope, lower for trivial work. Omit to leave unchanged."
+      ),
+      attachments: z2.array(attachmentInputSchema).optional().describe(
+        "New files to append to the card's existing description attachments. Reference each one inline in the description as [Attachment #N], continuing the numbering after the card's existing attachments."
+      )
+    }
+  },
+  async ({ cardId, description, priority, dependsOn, waitsFor, workflowId, readyForDev, activeLevel, attachments }) => {
+    let descriptionAttachments;
+    if (attachments?.length) {
+      const state = await apiQuery("workspace.state", { workspaceId });
+      const existing = state.board.cards[cardId]?.descriptionAttachments ?? [];
+      const processed = await processAttachments(attachments, cardId);
+      descriptionAttachments = [...existing, ...processed];
+    }
+    await apiMutate("cards.update", {
+      workspaceId,
+      cardId,
+      description,
+      priority,
+      dependsOn,
+      waitsFor,
+      workflowId,
+      readyForDev,
+      activeLevel,
+      descriptionAttachments,
+      revision: 0
+    });
+    return { content: [{ type: "text", text: `Updated card ${cardId}.` }] };
+  }
+);
+registerTool(
+  "kanban_add_comment",
+  {
+    description: "Record your analysis, findings, or summary as a comment on a Kanban card. Call this when you have finished your work so your output is cleanly stored.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID you are reviewing"),
+      type: z2.string().describe("Type of comment \u2014 use the slot id for review agents (e.g. 'security_review')"),
+      streamId: z2.string().optional().describe("The terminal session stream ID for this agent run"),
+      summary: z2.string().describe("Your summary \u2014 2-5 sentences describing what you did or found"),
+      status: z2.enum(["pass", "fail", "warning", "skipped"]).optional().describe("Result status of this review step"),
+      issues: z2.array(
+        z2.object({
+          file: z2.string().optional().describe("File path where the issue was found"),
+          line: z2.number().optional().describe("Line number of the issue"),
+          severity: z2.enum(["blocking", "warning", "info"]).describe("Severity level"),
+          message: z2.string().describe("Description of the issue")
+        })
+      ).optional().describe("Specific issues found during review"),
+      attachments: z2.array(attachmentInputSchema).optional().describe("File attachments (e.g. screenshots, PDFs)"),
+      metadata: z2.record(z2.string(), z2.unknown()).optional().describe("Additional metadata key-value pairs"),
+      suggestedLevel: z2.enum(["minimal", "low", "medium", "high", "max"]).optional().describe(
+        "Only for review slots allowed to adjust the tier: the capability level the rework should run at when you fail/reopen (applies to all agents). Omit to leave unchanged."
+      )
+    }
+  },
+  async ({ cardId, type, streamId, summary, status, issues, attachments, metadata, suggestedLevel }) => {
+    const processedAttachments = attachments?.length ? await processAttachments(attachments, cardId) : void 0;
+    const mergedMetadata = suggestedLevel ? { ...metadata ?? {}, suggestedLevel } : metadata;
+    await apiMutate("cards.addReviewComment", {
+      workspaceId,
+      cardId,
+      type,
+      streamId,
+      actor: { type: "ai", id: agentId },
+      status,
+      summary,
+      issues,
+      attachments: processedAttachments,
+      metadata: mergedMetadata
+    });
+    return { content: [{ type: "text", text: `Comment recorded on card ${cardId}.` }] };
+  }
+);
+registerTool(
+  "kanban_set_plan",
+  {
+    description: "Save an implementation plan onto a card. Called by the plan agent when it finishes; the dev agent then reads this plan to implement the task.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID to save the plan on"),
+      plan: z2.string().describe("The implementation plan \u2014 files to change, approach, edge cases, verification steps")
+    }
+  },
+  async ({ cardId, plan }) => {
+    await apiMutate("cards.setPlan", { workspaceId, cardId, plan });
+    return { content: [{ type: "text", text: `Plan saved on card ${cardId}.` }] };
+  }
+);
+registerTool(
+  "kanban_delete_card",
+  {
+    description: "Delete a card from the board permanently.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID to delete")
+    }
+  },
+  async ({ cardId }) => {
+    await apiMutate("cards.delete", { workspaceId, cardId });
+    return { content: [{ type: "text", text: `Deleted card ${cardId}.` }] };
+  }
+);
+registerTool(
+  "kanban_stop_task",
+  {
+    description: "Stop an in-progress agent task. The session is marked 'stopped' (preserving history) so the card can be restarted later. Use this before moving a child card to todo when its parent was reopened.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID of the in-progress task to stop")
+    }
+  },
+  async ({ cardId }) => {
+    await apiMutate("cards.interruptTask", { workspaceId, cardId });
+    return { content: [{ type: "text", text: `Task ${cardId} interrupted.` }] };
+  }
+);
+registerTool(
+  "kanban_get_workflows",
+  {
+    description: "Get all workflows configured for this project, including their agent slots, model tiers, tools, and prompts.",
+    inputSchema: {}
+  },
+  async () => {
+    const workflows = await apiQuery("workflows.list", { workspaceId });
+    const lines = [];
+    for (const wf of workflows) {
+      const kind = wf.forStory ? " [story/orch workflow]" : " [task workflow]";
+      lines.push(`## ${wf.name}${wf.isDefault ? " (default)" : ""}${kind} [id: ${wf.id}]`);
+      const sorted = [...wf.slots].sort((a, b) => a.order - b.order);
+      for (const slot of sorted) {
+        const status = slot.enabled ? "enabled" : "disabled";
+        const top = slot.pairs[0];
+        const topTag = top ? `, top: ${top.binary}${top.model ? `/${top.model}` : ""}@${top.level}${top.effort ? `/${top.effort}` : ""}` : "";
+        const pairsTag = `, ${slot.pairs.length} tier(s), mode: ${slot.mode}`;
+        const toolsTag = slot.tools.length ? `, tools: ${slot.tools.join("+")}` : "";
+        const flags = [slot.canAdjustLevel ? "canAdjustLevel" : "", slot.rerun ? "rerun" : ""].filter(Boolean).join(",");
+        const flagsTag = flags ? `, ${flags}` : "";
+        const promptText = slot.prompt && typeof slot.prompt === "object" ? slot.prompt.source === "inline" ? slot.prompt.text : `[file: ${slot.prompt.path}]` : "";
+        const prompt = promptText ? `
+    prompt: ${promptText}` : "";
+        lines.push(
+          `  - [${slot.id}] ${slot.name} (${slot.type}${topTag}${pairsTag}, ${status}${toolsTag}${flagsTag})${prompt}`
+        );
+      }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") || "No workflows configured." }] };
+  }
+);
+registerTool(
+  "kanban_upsert_workflow",
+  {
+    description: "Create or update a workflow. Pass the full workflow object including all slots. If a workflow with the given id already exists it will be replaced; otherwise a new one is created.",
+    inputSchema: {
+      id: z2.string().describe("Unique workflow ID. Use a short slug like 'wf_security' for new workflows."),
+      name: z2.string().describe("Human-readable workflow name, e.g. 'Security Review'"),
+      isDefault: z2.boolean().optional().describe("Whether this is the default workflow (only one can be default)"),
+      forStory: z2.boolean().optional().describe(
+        "True for story/orchestrator workflows (orch slots only). False for regular task workflows (plan/dev/review slots)."
+      ),
+      slots: z2.array(
+        z2.object({
+          id: z2.string().describe("Unique slot ID within this workflow"),
+          type: z2.enum(["dev", "review", "plan", "orch"]).describe(
+            "Slot type. 'dev' implements (only slot with write access). 'review' is a one-shot reviewer \u2014 chain several via order, grant tools as needed. 'plan' runs once before dev and saves a plan on the card. 'orch' is story-only."
+          ),
+          name: z2.string().describe("Display name for this slot"),
+          order: z2.number().int().nonnegative().describe("Execution order (0 = first)"),
+          enabled: z2.boolean().describe("Whether this slot is active in the pipeline"),
+          prompt: z2.string().describe("System prompt / instructions for this agent slot. Empty string for default behavior."),
+          pairs: z2.array(
+            z2.object({
+              id: z2.string().describe("Unique pair ID within this slot"),
+              level: z2.enum(["minimal", "low", "medium", "high", "max"]).describe("Capability level. The card's active level selects which pair runs."),
+              isFree: z2.boolean().describe("Whether this pair uses a zero-cost model"),
+              binary: z2.enum(["claude", "codex", "opencode", "cursor"]).describe("Agent binary: claude / codex / opencode / cursor."),
+              model: z2.string().nullable().optional().describe("Model override, or null for the agent default (e.g. 'claude-opus-4-6', 'gpt-5.5')."),
+              effort: z2.enum(["low", "medium", "high", "xhigh", "max"]).nullable().optional().describe("Reasoning effort override, or null for the agent default.")
+            })
+          ).min(1).describe(
+            "Model tiers for this slot, in priority order (first = highest). The card copies these and picks one by active level + mode."
+          ),
+          mode: z2.enum(["auto", "preferFree", "freeOnly", "paidOnly"]).optional().describe(
+            "Selection policy at the active level: auto = top priority; preferFree = top free else paid; freeOnly / paidOnly = restrict by cost. Defaults to auto."
+          ),
+          tools: z2.array(z2.enum(["browser"])).optional().describe("Tools granted to this slot, e.g. ['browser'] for Playwright UI control."),
+          canAdjustLevel: z2.boolean().optional().describe("review slots only: may set the card's active level on reopen via suggestedLevel."),
+          rerun: z2.boolean().optional().describe("plan slots only: re-run the plan even if the card already has one.")
+        })
+      ).describe(
+        "For task workflows: always include a dev slot (type: 'dev'). Add plan and/or review slots as needed. For story workflows: use only orch slots."
+      )
+    }
+  },
+  async ({ id, name, isDefault, forStory, slots }) => {
+    const workflow = await apiMutate("workflows.upsert", {
+      workspaceId,
+      workflow: { id, name, isDefault: isDefault ?? false, forStory: forStory ?? false, slots }
+    });
+    return { content: [{ type: "text", text: `Workflow "${workflow.name}" [${workflow.id}] saved successfully.` }] };
+  }
+);
+registerTool(
+  "kanban_get_pr_meta",
+  {
+    description: "Get the current PR metadata stored on a card \u2014 url (set by the daemon when the PR is created), title, description, and the updatedAt/updatedBy stamps from the last write. Use this when the dev prompt shows a truncated previous description and you need the full text to revise.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID to read PR metadata from")
+    }
+  },
+  async ({ cardId }) => {
+    const state = await apiQuery("workspace.state", { workspaceId });
+    const card = state.board.cards[cardId];
+    if (!card) {
+      return {
+        content: [
+          { type: "text", text: `Card ${cardId} not found on the board. Use kanban_get_board to list valid card IDs.` }
+        ]
+      };
+    }
+    const pr = card.pr;
+    if (!pr || !pr.url && !pr.title && !pr.description) {
+      return { content: [{ type: "text", text: `No PR metadata on card ${cardId} yet.` }] };
+    }
+    const lines = [
+      `url: ${pr.url ?? "(not yet created)"}`,
+      `title: ${pr.title ?? "(unset)"}`,
+      "",
+      "description:",
+      pr.description ?? "(unset)"
+    ];
+    if (pr.updatedAt) lines.push("", `last updated: ${new Date(pr.updatedAt).toISOString()} by ${pr.updatedBy ?? "?"}`);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+registerTool(
+  "kanban_set_pr_meta",
+  {
+    description: "Set the PR title and/or description for a card. Call this at the end of your work so the daemon uses your text when it creates the PR. The PR url is set by the daemon and never overwritten by this call. Subsequent calls overwrite previous values \u2014 revise rather than rewrite when prior values already reflect the change.",
+    inputSchema: {
+      cardId: z2.string().describe("The card ID this PR is for"),
+      title: z2.string().optional().describe("PR title. Follow the project's git instructions."),
+      description: z2.string().optional().describe("PR description body. Follow the project's git instructions."),
+      streamId: z2.string().optional().describe("Terminal session stream ID for this agent run, if available")
+    }
+  },
+  async ({ cardId, title, description, streamId }) => {
+    const result = await apiMutate("cards.setPrMeta", {
+      workspaceId,
+      cardId,
+      title,
+      description,
+      updatedBy: streamId ?? agentId
+    });
+    const parts = [];
+    if (result.pr.title) parts.push(`title="${result.pr.title}"`);
+    if (result.pr.description) parts.push(`description (${result.pr.description.length} chars)`);
+    return {
+      content: [{ type: "text", text: `PR meta updated on card ${cardId}: ${parts.join(", ") || "(empty)"}.` }]
+    };
+  }
+);
+registerTool(
+  "kanban_get_git_instructions",
+  {
+    description: "Get the project's git conventions for PR titles, PR descriptions, and commit messages. Returns the user's custom override (if any), the built-in default, and the effective text that the dev prompt actually injects. Read this before writing PR meta so you follow project conventions.",
+    inputSchema: {}
+  },
+  async () => {
+    const config = await apiQuery("projectConfig.get", { workspaceId });
+    const custom = config.gitInstructions?.trim() ? config.gitInstructions : null;
+    const effective = custom ?? DEFAULT_GIT_INSTRUCTIONS;
+    const lines = [];
+    lines.push(
+      custom ? "## Custom git instructions (project override)" : "## Custom git instructions: (none \u2014 using default)"
+    );
+    if (custom) lines.push(custom);
+    lines.push("");
+    lines.push("## Default git instructions");
+    lines.push(DEFAULT_GIT_INSTRUCTIONS);
+    lines.push("");
+    lines.push("## Effective (what dev agents actually see)");
+    lines.push(effective);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+registerTool(
+  "kanban_set_git_instructions",
+  {
+    description: "Replace the project's custom git conventions (PR title/description/commit rules). This is project-wide and affects all future PRs in this workspace \u2014 only call when explicitly asked to change conventions, not as part of regular task work. Pass an empty string to clear the override and revert to the built-in default.",
+    inputSchema: {
+      instructions: z2.string().describe(
+        "Full replacement text in markdown or freeform prose. Pass an empty string to clear the override and use the default."
+      )
+    }
+  },
+  async ({ instructions }) => {
+    const result = await apiMutate("projectConfig.setGitInstructions", {
+      workspaceId,
+      instructions
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.cleared ? "Custom git instructions cleared \u2014 using default." : "Custom git instructions updated."
+        }
+      ]
+    };
+  }
+);
+registerTool(
+  "kanban_get_system_prompt",
+  {
+    description: "Get the shared system prompt for this project. This prompt is appended to every agent \u2014 plan, dev, review, and the assistant chat.",
+    inputSchema: {}
+  },
+  async () => {
+    const config = await apiQuery("projectConfig.get", { workspaceId });
+    const prompt = config.systemPrompt?.trim();
+    return { content: [{ type: "text", text: prompt ? prompt : "(no shared system prompt set)" }] };
+  }
+);
+registerTool(
+  "kanban_set_system_prompt",
+  {
+    description: "Set or update the shared system prompt for this project. The prompt is appended to every agent \u2014 plan, dev, review, and the assistant chat. Pass an empty string to clear it.",
+    inputSchema: {
+      prompt: z2.string().describe("The new shared system prompt. Pass an empty string to clear the existing prompt.")
+    }
+  },
+  async ({ prompt }) => {
+    const result = await apiMutate("projectConfig.setSystemPrompt", {
+      workspaceId,
+      prompt
+    });
+    return {
+      content: [
+        { type: "text", text: result.cleared ? `Shared system prompt cleared.` : `Shared system prompt updated.` }
+      ]
+    };
+  }
+);
+registerTool(
+  "task_complete",
+  {
+    description: "Signal that you have finished all work on this task. Call this ONLY after you have completed all code changes, called kanban_set_pr_meta, and called kanban_add_comment with your final status. This terminates the agent session.",
+    inputSchema: {}
+  },
+  async () => {
+    const taskId = process.env.WHIPPED_HOOK_TASK_ID;
+    const wsId = process.env.WHIPPED_HOOK_WORKSPACE_ID;
+    if (taskId && wsId) {
+      await fetch(
+        `${serverUrl}/api/hook?event=stop&taskId=${encodeURIComponent(taskId)}&workspaceId=${encodeURIComponent(wsId)}`,
+        { headers: authHeaders }
+      ).catch(() => {
+      });
+    }
+    return { content: [{ type: "text", text: "Task completion signaled. Your session will now end." }] };
+  }
+);
+var agentSlot = process.env.WHIPPED_SLOT ?? "";
+var memoryCardId = process.env.WHIPPED_HOOK_TASK_ID ?? "";
+var memoryModel = process.env.WHIPPED_MODEL ?? "";
+registerTool(
+  "whipped_search_memory",
+  {
+    description: "Search durable project + global memory (conventions, decisions, lessons, sharp edges) for this workspace. Use before re-discovering how something works. Returns matching memories with their ids.",
+    inputSchema: {
+      query: z2.string().describe("Keywords to search memory titles and content")
+    }
+  },
+  async ({ query }) => {
+    try {
+      const results = await apiQuery("memory.search", { query, workspaceId });
+      if (!results || results.length === 0) {
+        return { content: [{ type: "text", text: "No matching memory." }] };
+      }
+      const text = results.map((m) => `- [${m.id}] (${m.scope}/${m.type}) ${m.title}
+  ${m.content}`).join("\n");
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Search failed: ${err.message}` }] };
+    }
+  }
+);
+registerTool(
+  "whipped_get_memory",
+  {
+    description: "Fetch the full content of a single memory by its id (from whipped_search_memory results).",
+    inputSchema: {
+      id: z2.string().describe("Memory id")
+    }
+  },
+  async ({ id }) => {
+    try {
+      const m = await apiQuery("memory.get", { id });
+      if (!m) return { content: [{ type: "text", text: "Memory not found." }] };
+      return { content: [{ type: "text", text: `(${m.scope}/${m.type}) ${m.title}
+
+${m.content}` }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: `Fetch failed: ${err.message}` }] };
+    }
+  }
+);
+if (agentSlot === "dev" || agentSlot === "assistant") {
+  registerTool(
+    "whipped_save_memory",
+    {
+      description: "Save a durable memory so future agents don't re-discover it. Use for conventions, architecture facts, decisions, gotchas, or user corrections worth remembering across tasks. Scope 'project' = specific to this repo; 'global' = a fact shareable across projects (e.g. a framework/library convention). Keep each memory to one focused fact. The user may review project task-lessons; global lessons go to a review queue.\n\nGlobal memory REQUIRES tags \u2014 it only reaches another project that subscribes to one of its tags. Tag with the framework-qualified form when the knowledge is ecosystem-specific, and the bare form only when the fact is truly tool-level and framework-agnostic: Spoosh used via its React bindings \u2192 'spoosh-react'; a fact about Spoosh itself \u2192 'spoosh'; React hooks \u2192 'react-hook' (not bare 'hook'). Reuse an existing tag from the injected memory's tag list before inventing a near-duplicate.",
+      inputSchema: {
+        scope: z2.enum(["project", "global"]).describe("'project' (this repo) or 'global' (shareable across projects)"),
+        type: z2.enum(["fact", "convention", "decision", "preference", "rule", "lesson", "sharp_edge"]).describe("Kind of memory"),
+        title: z2.string().describe("Short one-line summary"),
+        content: z2.string().describe("The durable fact, in 1-3 sentences"),
+        sourceType: z2.enum(["user_correction", "explicit_save", "task_lesson"]).default("task_lesson").describe("Why this is being saved \u2014 'user_correction' if the user explicitly told you, else 'task_lesson'"),
+        importance: z2.number().int().min(1).max(3).optional().describe("1 normal, 2 high, 3 critical"),
+        tags: z2.array(z2.string()).optional().describe(
+          "Required for 'global' scope (\u22651). Canonical kebab-case, framework-qualified when ecosystem-specific (e.g. 'spoosh-react', 'react-hook'). Reuse existing tags."
+        )
+      }
+    },
+    async ({ scope, type, title, content, sourceType, importance, tags }) => {
+      try {
+        const saved = await apiMutate("memory.propose", {
+          scope,
+          workspaceId: scope === "project" ? workspaceId : void 0,
+          originWorkspaceId: workspaceId,
+          type,
+          title,
+          content,
+          sourceType,
+          importance,
+          tags,
+          originCardId: memoryCardId || void 0,
+          originAgent: { agent: agentId, ...memoryModel ? { model: memoryModel } : {} }
+        });
+        const note = saved.status === "approved" ? "saved (approved)." : "submitted for the user's review (pending).";
+        return { content: [{ type: "text", text: `Memory ${note}` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Save failed: ${err.message}` }] };
+      }
+    }
+  );
+  registerTool(
+    "whipped_update_memory",
+    {
+      description: "Update an existing memory when it is now inaccurate or out of date (e.g. a convention changed). Get the memory's id from the injected memory list or whipped_search_memory. Prefer updating over saving a near-duplicate. Approval follows the same policy as saving.",
+      inputSchema: {
+        id: z2.string().describe("Memory id (from the memory list or whipped_search_memory)"),
+        title: z2.string().optional().describe("New title"),
+        content: z2.string().optional().describe("New content"),
+        type: z2.enum(["fact", "convention", "decision", "preference", "rule", "lesson", "sharp_edge"]).optional(),
+        importance: z2.number().int().min(1).max(3).optional(),
+        sourceType: z2.enum(["user_correction", "explicit_save", "task_lesson"]).default("task_lesson").describe("'user_correction' if the user told you to change it, else 'task_lesson'")
+      }
+    },
+    async ({ id, title, content, type, importance, sourceType }) => {
+      try {
+        const updated = await apiMutate("memory.proposeUpdate", {
+          id,
+          title,
+          content,
+          type,
+          importance,
+          sourceType
+        });
+        const note = updated.status === "approved" ? "updated (approved)." : "update submitted for the user's review (pending).";
+        return { content: [{ type: "text", text: `Memory ${note}` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Update failed: ${err.message}` }] };
+      }
+    }
+  );
+}
+var scheduleShape = {
+  scheduleKind: z2.enum(["interval", "calendar"]).describe("'interval' = every N seconds; 'calendar' = cron at a wall-clock time"),
+  intervalSeconds: z2.number().int().positive().optional().describe("Required when scheduleKind=interval (e.g. 3600 = hourly)"),
+  cronExpr: z2.string().optional().describe("Required when scheduleKind=calendar, e.g. '0 9 * * 1' = every Monday 09:00"),
+  timezone: z2.string().optional().describe("IANA timezone, required when scheduleKind=calendar (e.g. 'Asia/Yangon')"),
+  agentBinary: z2.enum(["claude", "codex", "opencode", "cursor"]).optional().describe("Which agent runs this; defaults to claude"),
+  model: z2.string().optional().describe("Model id, e.g. 'claude-opus-4-8' or 'gpt-5.5'"),
+  effort: z2.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
+  enabled: z2.boolean().optional()
+};
+function buildScheduleBody(input) {
+  const schedule = input.scheduleKind === "calendar" ? { kind: "calendar", cronExpr: input.cronExpr ?? "0 9 * * 1", timezone: input.timezone ?? "UTC" } : { kind: "interval", intervalSeconds: input.intervalSeconds ?? 3600 };
+  const model = input.agentBinary ? { agentId: input.agentBinary, model: input.model ?? null, effort: input.effort ?? null } : void 0;
+  return { schedule, model };
+}
+if (mcpRole === "assistant") {
+  registerTool(
+    "recurring_create",
+    {
+      description: "Create a scheduled recurring agent for this project (e.g. an hourly Jira checker or a weekly security sweep). Only you, the assistant, can create these \u2014 recurring agents cannot create others. They observe and report; they do not write code.",
+      inputSchema: {
+        name: z2.string().describe("Short name, e.g. 'Security sweep'"),
+        instructions: z2.string().describe("What the agent should do each run, and how to use its journal"),
+        ...scheduleShape
+      }
+    },
+    async (input) => {
+      try {
+        const { schedule, model } = buildScheduleBody(input);
+        const created = await apiMutate("recurring.create", {
+          workspaceId,
+          name: input.name,
+          instructions: input.instructions,
+          schedule,
+          model,
+          enabled: input.enabled
+        });
+        return { content: [{ type: "text", text: `Created recurring agent "${created.name}" [${created.id}].` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Create failed: ${err.message}` }] };
+      }
+    }
+  );
+  registerTool(
+    "recurring_list",
+    { description: "List the recurring agents configured for this project.", inputSchema: {} },
+    async () => {
+      const agents = await apiQuery("recurring.list", { workspaceId });
+      if (!agents.length) return { content: [{ type: "text", text: "No recurring agents configured." }] };
+      const lines = agents.map(
+        (a) => `[${a.id}] ${a.name} \u2014 ${a.enabled ? "enabled" : "disabled"}, ${a.schedule.kind}${a.nextRunAt ? `, next ${new Date(a.nextRunAt).toISOString()}` : ""}`
+      );
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  registerTool(
+    "recurring_update",
+    {
+      description: "Update a recurring agent (rename, re-schedule, change model, enable/disable).",
+      inputSchema: {
+        id: z2.string(),
+        name: z2.string().optional(),
+        instructions: z2.string().optional(),
+        ...scheduleShape
+      }
+    },
+    async (input) => {
+      try {
+        const body = { id: input.id, name: input.name, instructions: input.instructions };
+        if (input.scheduleKind) {
+          const { schedule, model } = buildScheduleBody(input);
+          body.schedule = schedule;
+          if (model) body.model = model;
+        }
+        if (input.enabled !== void 0) body.enabled = input.enabled;
+        await apiMutate("recurring.update", body);
+        return { content: [{ type: "text", text: `Updated recurring agent ${input.id}.` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Update failed: ${err.message}` }] };
+      }
+    }
+  );
+  registerTool(
+    "recurring_delete",
+    { description: "Delete a recurring agent.", inputSchema: { id: z2.string() } },
+    async ({ id }) => {
+      try {
+        await apiMutate("recurring.delete", { id });
+        return { content: [{ type: "text", text: `Deleted recurring agent ${id}.` }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Delete failed: ${err.message}` }] };
+      }
+    }
+  );
+}
+if (mcpRole === "recurring" && recurringAgentId) {
+  registerTool(
+    "update_journal",
+    {
+      description: "Rewrite your private journal \u2014 the notes you carry across runs (e.g. what you've already filed, what you're watching). Read it at the start of a run and rewrite the full updated text here at the end. This replaces the journal entirely, so include everything worth keeping.",
+      inputSchema: { journal: z2.string().describe("The full updated journal text") }
+    },
+    async ({ journal }) => {
+      try {
+        await apiMutate("recurring.setJournal", { id: recurringAgentId, journal });
+        return { content: [{ type: "text", text: "Journal saved." }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Journal save failed: ${err.message}` }] };
+      }
+    }
+  );
+}
+var transport = new StdioServerTransport();
+await server.connect(transport);