whipped 0.8.0 → 0.9.0

package/dist/cli.js

@@ -3529,7 +3529,7 @@ function isResumableSessionState(state) {
 function normalizeTag(raw2) {
   return raw2.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
-var ASSISTANT_AGENT_PREFIX, 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, notificationSoundsConfigSchema, runtimeGlobalConfigSchema, runtimeGithubConfigSchema, runtimeWorktreeCopyEntrySchema, runtimeWorktreeSetupSchema, runtimeProjectSecretSchema, runtimeProjectConfigSchema, runtimeWorkspaceStateResponseSchema, runtimeWorkspaceStateSaveRequestSchema, runtimeVisualElementSchema, runtimeVisualCommentSchema, runtimeCardCreateRequestSchema, runtimeBulkCardImportItemSchema, runtimeBulkCardsCreateRequestSchema, runtimeCardMoveRequestSchema, runtimeCardUpdateRequestSchema, memoryScopeSchema, memoryTypeSchema, memorySourceTypeSchema, memoryStatusSchema, runtimeMemoryOriginAgentSchema, runtimeMemorySchema, recurringScheduleKindSchema, recurringScheduleSchema, recurringRunStatusSchema, recurringRunTriggerSchema, recurringAgentRunSchema, recurringAgentSchema, recurringAgentCreateRequestSchema, recurringAgentUpdateRequestSchema, projectFolderSchema, topLevelItemSchema, projectsLayoutSchema, runtimeProjectSchema;
+var ASSISTANT_AGENT_PREFIX, runtimeAgentIdSchema, effortLevelSchema, agentModelChoiceSchema, DEFAULT_AGENT_MODEL_CHOICE, 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, notificationSoundsConfigSchema, runtimeGlobalConfigSchema, runtimeGithubConfigSchema, runtimeWorktreeCopyEntrySchema, runtimeWorktreeSetupSchema, runtimeProjectSecretSchema, runtimeProjectConfigSchema, runtimeWorkspaceStateResponseSchema, runtimeWorkspaceStateSaveRequestSchema, runtimeVisualElementSchema, runtimeVisualCommentSchema, runtimeCardCreateRequestSchema, runtimeBulkCardImportItemSchema, runtimeBulkCardsCreateRequestSchema, runtimeCardMoveRequestSchema, runtimeCardUpdateRequestSchema, memoryScopeSchema, memoryTypeSchema, memorySourceTypeSchema, memoryStatusSchema, runtimeMemoryOriginAgentSchema, runtimeMemorySchema, recurringScheduleKindSchema, recurringScheduleSchema, recurringRunStatusSchema, recurringRunTriggerSchema, recurringAgentRunSchema, recurringAgentSchema, recurringAgentCreateRequestSchema, recurringAgentUpdateRequestSchema, companionSessionStatusSchema, companionSessionSchema, companionSessionCreateRequestSchema, choiceOptionSchema, REQUIRED_FIELD_DESCRIPTION, questionLeafInputSchema, questionInputSchema, canvasBlockSchema, canvasDocumentSchema, companionSavedCanvasSchema, projectFolderSchema, topLevelItemSchema, projectsLayoutSchema, runtimeProjectSchema;
 var init_api_contract = __esm({
   "src/core/api-contract.ts"() {
     "use strict";
@@ -3541,6 +3541,7 @@ var init_api_contract = __esm({
       model: z.string().nullable().optional(),
       effort: effortLevelSchema.nullable().optional()
     });
+    DEFAULT_AGENT_MODEL_CHOICE = { agentId: "claude", model: null, effort: null };
     workflowSlotTypeSchema = z.enum(["dev", "review", "plan", "orch"]);
     tierLevelSchema = z.enum(["minimal", "low", "medium", "high", "max"]);
     LEVEL_ORDER = ["minimal", "low", "medium", "high", "max"];
@@ -4090,6 +4091,104 @@ Do NOT include:
       enabled: z.boolean().optional(),
       journal: z.string().optional()
     });
+    companionSessionStatusSchema = z.enum(["installing", "running", "stopped", "merged", "discarded"]);
+    companionSessionSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      useWorktree: z.boolean(),
+      baseRef: z.string(),
+      branchName: z.string().nullable(),
+      worktreePath: z.string().nullable(),
+      workflowId: z.string().nullable(),
+      seedPrompt: z.string().default(""),
+      agentId: runtimeAgentIdSchema,
+      model: z.string().nullable(),
+      effort: effortLevelSchema.nullable(),
+      status: companionSessionStatusSchema.default("stopped"),
+      savedCanvasId: z.string().nullable(),
+      createdAt: z.number(),
+      updatedAt: z.number()
+    });
+    companionSessionCreateRequestSchema = z.object({
+      name: z.string().optional(),
+      useWorktree: z.boolean().default(true),
+      baseRef: z.string().min(1),
+      branchName: z.string().optional(),
+      workflowId: z.string().optional(),
+      model: agentModelChoiceSchema.optional(),
+      savedCanvasId: z.string().optional()
+    });
+    choiceOptionSchema = z.object({
+      value: z.string(),
+      label: z.string(),
+      description: z.string().optional()
+    });
+    REQUIRED_FIELD_DESCRIPTION = 'Signal only \u2014 not enforced by the panel, the developer can send/approve without answering. If this comes back "(not answered)" and you still need it, ask again in your next canvas version.';
+    questionLeafInputSchema = z.discriminatedUnion("kind", [
+      z.object({
+        kind: z.literal("single_choice"),
+        name: z.string(),
+        label: z.string().optional(),
+        options: z.array(choiceOptionSchema),
+        allowOther: z.boolean().optional(),
+        required: z.boolean().optional().describe(REQUIRED_FIELD_DESCRIPTION)
+      }),
+      z.object({
+        kind: z.literal("multi_choice"),
+        name: z.string(),
+        label: z.string().optional(),
+        options: z.array(choiceOptionSchema),
+        allowOther: z.boolean().optional(),
+        required: z.boolean().optional().describe(REQUIRED_FIELD_DESCRIPTION)
+      }),
+      z.object({
+        kind: z.literal("text"),
+        name: z.string(),
+        label: z.string().optional(),
+        placeholder: z.string().optional(),
+        multiline: z.boolean().optional(),
+        required: z.boolean().optional().describe(REQUIRED_FIELD_DESCRIPTION)
+      })
+    ]);
+    questionInputSchema = z.discriminatedUnion("kind", [
+      ...questionLeafInputSchema.options,
+      z.object({ kind: z.literal("composite"), parts: z.array(questionLeafInputSchema) })
+    ]);
+    canvasBlockSchema = z.discriminatedUnion("type", [
+      z.object({ id: z.string(), type: z.literal("markdown"), body: z.string() }),
+      // Rendered via dangerouslySetInnerHTML, unsanitized — same trust boundary as
+      // the markdown block's rehype-raw pass-through (the agent is the user's own
+      // coding agent, not untrusted third-party input).
+      z.object({
+        id: z.string(),
+        type: z.literal("html"),
+        body: z.string().describe(
+          `Raw HTML rendered via dangerouslySetInnerHTML at runtime. Use this whenever the developer wants to see UI, layout, or visual design \u2014 a dashboard, a page structure, a component arrangement \u2014 since markdown can only describe that in prose while an actual html mockup shows it. It is NOT run through the app's build-time Tailwind compiler, so Tailwind utility classes (e.g. class="grid grid-cols-3 gap-4") produce no CSS and render unstyled \u2014 style the mockup with inline style="..." attributes, or a <style> block scoped to unique ids/classes you define within the same body.`
+        )
+      }),
+      z.object({
+        id: z.string(),
+        type: z.literal("diagram"),
+        format: z.literal("mermaid"),
+        source: z.string(),
+        caption: z.string().optional()
+      }),
+      z.object({ id: z.string(), type: z.literal("question"), prompt: z.string(), input: questionInputSchema })
+    ]);
+    canvasDocumentSchema = z.object({
+      version: z.number(),
+      createdAt: z.number(),
+      blocks: z.array(canvasBlockSchema)
+    });
+    companionSavedCanvasSchema = z.object({
+      id: z.string(),
+      workspaceId: z.string(),
+      title: z.string(),
+      blocks: z.array(canvasBlockSchema),
+      sourceSessionId: z.string().nullable(),
+      createdAt: z.number(),
+      updatedAt: z.number()
+    });
     projectFolderSchema = z.object({
       id: z.string(),
       name: z.string(),
@@ -13623,9 +13722,9 @@ function installGracefulShutdownHandlers(options) {
 init_logger();
 
 // src/server/runtime-server.ts
-import { existsSync as existsSync14, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync9 } from "node:fs";
 import { createServer } from "node:http";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import * as nodePty3 from "node-pty";
 
@@ -13670,6 +13769,7 @@ var HOOKS_DIR = join9(WHIPPED_HOME_DIR, "hooks");
 var CLAUDE_TASK_SETTINGS_PATH = join9(HOOKS_DIR, "claude-task-settings.json");
 var CLAUDE_ASSISTANT_MCP_CONFIG_PATH = join9(HOOKS_DIR, "claude-assistant-mcp-config.json");
 var CLAUDE_REVIEW_MCP_CONFIG_PATH = join9(HOOKS_DIR, "claude-review-mcp-config.json");
+var CLAUDE_COMPANION_SETTINGS_PATH = join9(HOOKS_DIR, "claude-companion-settings.json");
 var HOOK_TASK_ID_ENV = "WHIPPED_HOOK_TASK_ID";
 var HOOK_WORKSPACE_ID_ENV = "WHIPPED_HOOK_WORKSPACE_ID";
 function getServerPort(serverUrl) {
@@ -13696,10 +13796,18 @@ async function writeClaudeTaskHookSettings(serverPort) {
   await mkdir(HOOKS_DIR, { recursive: true });
   await writeFile(CLAUDE_TASK_SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
-function buildMcpRoleArgs(role, recurringAgentId) {
+async function writeClaudeCompanionSettings() {
+  const settings = {
+    permissions: { deny: ["EnterPlanMode", "ExitPlanMode"] }
+  };
+  await mkdir(HOOKS_DIR, { recursive: true });
+  await writeFile(CLAUDE_COMPANION_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+function buildMcpRoleArgs(role, recurringAgentId, companionSessionId) {
   const args = [];
   if (role) args.push(`--role=${role}`);
   if (recurringAgentId) args.push(`--recurring-agent-id=${recurringAgentId}`);
+  if (companionSessionId) args.push(`--companion-session-id=${companionSessionId}`);
   return args;
 }
 function buildWhippedMcpServerSpec(mcp, serverUrl, workspaceId, agentId, extraArgs = []) {
@@ -20484,7 +20592,7 @@ init_workspace_state();
 var import_tree_kill2 = __toESM(require_tree_kill(), 1);
 import { existsSync as existsSync10 } from "node:fs";
 import { cp, link, mkdir as mkdir3, stat as stat2, symlink, unlink as unlink2 } from "node:fs/promises";
-import { dirname as dirname6, join as join17, resolve as resolve2 } from "node:path";
+import { dirname as dirname6, join as join18, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import * as nodePty2 from "node-pty";
 init_api_contract();
@@ -20508,13 +20616,278 @@ function resolvePromptText(prompt, repoPath) {
 
 // src/daemon/scheduler.ts
 init_task_id();
+
+// src/state/companion-canvases-store.ts
+init_task_id();
+init_db();
+var RECENT_CANVASES_LIMIT = 20;
+function safeJsonParse2(raw2, fallback) {
+  try {
+    return JSON.parse(raw2);
+  } catch {
+    return fallback;
+  }
+}
+function canvasFromRow(row) {
+  return {
+    version: row.version,
+    createdAt: row.created_at,
+    blocks: safeJsonParse2(row.blocks_json, [])
+  };
+}
+function nextVersion(sessionId) {
+  const row = getDb().prepare("SELECT MAX(version) as max FROM companion_canvases WHERE session_id = ?").get(sessionId);
+  return (row?.max ?? 0) + 1;
+}
+function createCompanionCanvas(sessionId, workspaceId, blocks) {
+  const id = `cpv_${generateTaskId()}`;
+  const version = nextVersion(sessionId);
+  const createdAt = Date.now();
+  getDb().prepare(
+    "INSERT INTO companion_canvases (id, session_id, workspace_id, version, blocks_json, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(id, sessionId, workspaceId, version, JSON.stringify(blocks), createdAt);
+  return { version, createdAt, blocks };
+}
+function listCompanionCanvases(sessionId) {
+  const rows = getDb().prepare("SELECT * FROM companion_canvases WHERE session_id = ? ORDER BY version DESC LIMIT ?").all(sessionId, RECENT_CANVASES_LIMIT);
+  return rows.map(canvasFromRow);
+}
+function deleteCompanionCanvasesForSession(sessionId) {
+  getDb().prepare("DELETE FROM companion_canvases WHERE session_id = ?").run(sessionId);
+}
+
+// src/state/companion-saved-canvases-store.ts
+init_task_id();
+init_db();
+function safeJsonParse3(raw2, fallback) {
+  try {
+    return JSON.parse(raw2);
+  } catch {
+    return fallback;
+  }
+}
+function savedCanvasFromRow(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspace_id,
+    title: row.title,
+    blocks: safeJsonParse3(row.blocks_json, []),
+    sourceSessionId: row.source_session_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function listCompanionSavedCanvases(workspaceId) {
+  const rows = getDb().prepare("SELECT * FROM companion_saved_canvases WHERE workspace_id = ? ORDER BY updated_at DESC").all(workspaceId);
+  return rows.map(savedCanvasFromRow);
+}
+function getCompanionSavedCanvas(id) {
+  const row = getDb().prepare("SELECT * FROM companion_saved_canvases WHERE id = ?").get(id);
+  return row ? savedCanvasFromRow(row) : null;
+}
+function createCompanionSavedCanvas(workspaceId, input) {
+  const id = `csp_${generateTaskId()}`;
+  const now = Date.now();
+  getDb().prepare(
+    `INSERT INTO companion_saved_canvases
+				(id, workspace_id, title, blocks_json, source_session_id, created_at, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).run(id, workspaceId, input.title, JSON.stringify(input.blocks), input.sourceSessionId, now, now);
+  const created = getCompanionSavedCanvas(id);
+  if (!created) throw new Error("createCompanionSavedCanvas: row vanished after insert");
+  return created;
+}
+function updateCompanionSavedCanvas(id, input) {
+  getDb().prepare("UPDATE companion_saved_canvases SET title = ?, blocks_json = ?, updated_at = ? WHERE id = ?").run(input.title, JSON.stringify(input.blocks), Date.now(), id);
+  return getCompanionSavedCanvas(id);
+}
+function deleteCompanionSavedCanvas(id) {
+  getDb().prepare("DELETE FROM companion_saved_canvases WHERE id = ?").run(id);
+}
+function findCompanionSavedCanvasBySourceSession(sessionId) {
+  const row = getDb().prepare("SELECT * FROM companion_saved_canvases WHERE source_session_id = ? ORDER BY updated_at DESC LIMIT 1").get(sessionId);
+  return row ? savedCanvasFromRow(row) : null;
+}
+
+// src/state/companion-sessions-store.ts
+init_task_id();
+init_db();
+function sessionFromRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    useWorktree: row.use_worktree === 1,
+    baseRef: row.base_ref,
+    branchName: row.branch_name,
+    worktreePath: row.worktree_path,
+    workflowId: row.workflow_id,
+    seedPrompt: row.seed_prompt,
+    agentId: row.agent_id,
+    model: row.model,
+    effort: row.effort,
+    status: row.status,
+    savedCanvasId: row.saved_canvas_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function listCompanionSessions(workspaceId) {
+  const rows = getDb().prepare("SELECT * FROM companion_sessions WHERE workspace_id = ? ORDER BY created_at DESC").all(workspaceId);
+  return rows.map(sessionFromRow);
+}
+function getCompanionSession(id) {
+  const row = getDb().prepare("SELECT * FROM companion_sessions WHERE id = ?").get(id);
+  return row ? sessionFromRow(row) : null;
+}
+function createCompanionSession(workspaceId, input) {
+  const id = `cs_${generateTaskId()}`;
+  const now = Date.now();
+  getDb().prepare(
+    `INSERT INTO companion_sessions
+				(id, workspace_id, name, use_worktree, base_ref, branch_name, worktree_path, workflow_id, seed_prompt,
+				 agent_id, model, effort, status, saved_canvas_id, created_at, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, 'stopped', ?, ?, ?)`
+  ).run(
+    id,
+    workspaceId,
+    input.name,
+    input.useWorktree ? 1 : 0,
+    input.baseRef,
+    input.branchName,
+    input.workflowId,
+    input.seedPrompt,
+    input.agentId,
+    input.model,
+    input.effort,
+    input.savedCanvasId,
+    now,
+    now
+  );
+  const created = getCompanionSession(id);
+  if (!created) throw new Error("createCompanionSession: row vanished after insert");
+  return created;
+}
+function setCompanionSessionSavedCanvasId(id, savedCanvasId) {
+  getDb().prepare("UPDATE companion_sessions SET saved_canvas_id = ?, updated_at = ? WHERE id = ?").run(savedCanvasId, Date.now(), id);
+}
+function setCompanionSessionWorktreePath(id, worktreePath) {
+  getDb().prepare("UPDATE companion_sessions SET worktree_path = ?, updated_at = ? WHERE id = ?").run(worktreePath, Date.now(), id);
+}
+function setCompanionSessionStatus(id, status) {
+  getDb().prepare("UPDATE companion_sessions SET status = ?, updated_at = ? WHERE id = ?").run(status, Date.now(), id);
+}
+function deleteCompanionSession(id) {
+  getDb().prepare("DELETE FROM companion_sessions WHERE id = ?").run(id);
+}
+function resetStaleCompanionSessions(workspaceId) {
+  const res = getDb().prepare(
+    "UPDATE companion_sessions SET status = 'stopped', updated_at = ? WHERE workspace_id = ? AND status IN ('running', 'installing')"
+  ).run(Date.now(), workspaceId);
+  return res.changes;
+}
+
+// src/daemon/scheduler.ts
 init_workspace_state();
 
-// src/daemon/review-pipeline.ts
+// src/daemon/companion-agent.ts
+init_api_contract();
+
+// src/daemon/canvas-mode-prompt.ts
+function serializeCanvasBlocksForPrompt(blocks) {
+  return blocks.map((block) => {
+    if (block.type === "markdown") return block.body;
+    if (block.type === "html") return `\`\`\`html
+${block.body}
+\`\`\``;
+    if (block.type === "diagram") return `\`\`\`mermaid
+${block.source}
+\`\`\``;
+    const input = block.input;
+    const options = input.kind === "single_choice" || input.kind === "multi_choice" ? `
+Options: ${input.options.map((o) => o.label).join(", ")}` : "";
+    return `Q: ${block.prompt}${options}`;
+  }).join("\n\n");
+}
+function buildCanvasModeGuidance() {
+  return `Call \`whipped_show_canvas\` at most once per turn. Never call it twice in a row before the developer has replied \u2014 each call appends a new version to their canvas, so back-to-back calls show up as clutter, not a revision. If you want to reconsider before sending, do that thinking first and make one call with the version you're actually confident in.
+
+Pick the right block type for what you're conveying: markdown for reasoning, steps, findings, and options; an \`html\` block whenever the developer wants to see UI, layout, or visual design \u2014 a dashboard, a page structure, a component arrangement. Don't default to describing a layout in prose when they asked to see it \u2014 build an actual mockup (divs, flexbox/grid, realistic spacing and colors) so they're looking at an approximation of the real thing, not reading about it. \`html\` blocks are injected into the page at runtime via \`dangerouslySetInnerHTML\` \u2014 they are NOT compiled by the app's build-time Tailwind setup, so Tailwind utility classes in that HTML (e.g. \`class="grid grid-cols-3 gap-4"\`) produce no CSS and render unstyled. That's a styling detail, not a reason to avoid html blocks \u2014 style mockups with inline \`style="..."\` attributes, or a \`<style>\` block scoped to unique ids/classes you define in that same block's body.
+
+A question can be marked \`required\`, but that's a signal to you, not something the UI enforces \u2014 the developer can send feedback (or approve) without answering one, e.g. because they'd rather just leave a comment than pick from options that don't fit. The message you get back states every question explicitly, either with an answer or "(not answered)" \u2014 never silently omitted. If a required question comes back "(not answered)" and it's still something you need to know, ask it again in your next canvas version rather than assuming it's resolved. And if a comment on a question block says the options don't fit (wrong choices, missing one they want, etc.), revise, add, or remove options in your next version accordingly instead of re-asking the same broken question verbatim.
+
+When the developer approves a canvas, they'll be offered the option to save it to the project's reusable canvas library. If they do, you'll be asked to consolidate everything proposed across every version pushed in this session into ONE final, coherent canvas and save it via the \`whipped_save_canvas\` tool. Beyond that one prompted moment, also call \`whipped_save_canvas\` proactively whenever you finish a meaningful chunk of work \u2014 describe what's done explicitly in the blocks (not just what's left), so that if this session's canvas is ever resumed later, its state accurately reflects progress. If this session already has a saved canvas (you resumed from one, or already saved once), calling the tool again updates that same canvas in place rather than creating a duplicate \u2014 you don't need to track which case applies, the tool handles it.`;
+}
+
+// src/git/git-diff-utils.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
-import { readdir, readFile as readFile2, stat, unlink } from "node:fs/promises";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { join as join16 } from "node:path";
+function git4(args, cwd) {
+  return spawnSync5("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).stdout?.trim() ?? "";
+}
+function readFileSafe(filePath) {
+  try {
+    return readFileSync6(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function getGitStat(worktreePath, baseRef) {
+  const parts = [
+    git4(["diff", "--stat", `${baseRef}...HEAD`], worktreePath),
+    git4(["diff", "--stat", "--cached"], worktreePath),
+    git4(["diff", "--stat"], worktreePath)
+  ].filter(Boolean);
+  const newUntracked = git4(["ls-files", "--others", "--exclude-standard"], worktreePath).split("\n").map((f2) => f2.trim()).filter(Boolean);
+  if (newUntracked.length > 0) {
+    parts.push(`New files:
+${newUntracked.map((f2) => `  ${f2}`).join("\n")}`);
+  }
+  return parts.join("\n") || "(no changes detected \u2014 agent may not have committed yet)";
+}
+function getGitFullDiff(worktreePath, baseRef) {
+  const sections = [];
+  const diffParts = [
+    git4(["diff", "-U15", `${baseRef}...HEAD`], worktreePath),
+    git4(["diff", "-U15", "--cached"], worktreePath),
+    git4(["diff", "-U15"], worktreePath)
+  ].filter(Boolean);
+  if (diffParts.length > 0) {
+    sections.push(`\`\`\`diff
+${diffParts.join("\n")}
+\`\`\``);
+  }
+  const newUntracked = git4(["ls-files", "--others", "--exclude-standard"], worktreePath).split("\n").map((f2) => f2.trim()).filter(Boolean);
+  if (newUntracked.length > 0) {
+    const newFileContents = [];
+    for (const file of newUntracked) {
+      const content = readFileSafe(join16(worktreePath, file));
+      const ext = file.split(".").pop() ?? "";
+      newFileContents.push(content ? `### ${file}
+\`\`\`${ext}
+${content}
+\`\`\`` : `### ${file} (unreadable)`);
+    }
+    sections.push(`New files (full content):
+
+${newFileContents.join("\n\n")}`);
+  }
+  return sections.join("\n\n");
+}
+function getGitHeadSha(worktreePath) {
+  return git4(["rev-parse", "HEAD"], worktreePath);
+}
+var INLINE_DIFF_LIMIT = 8e3;
+function formatDiffBlock(fullDiff, baseRef, header = "Git diff") {
+  if (fullDiff.length <= INLINE_DIFF_LIMIT) return `${header}:
+${fullDiff}`;
+  return `Large changeset (${fullDiff.length.toLocaleString()} chars). Use \`git diff ${baseRef}...HEAD\` and read individual files to explore.`;
+}
+
+// src/daemon/review-pipeline.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { readdir, readFile as readFile2, stat, unlink } from "node:fs/promises";
+import { join as join17 } from "node:path";
 init_runtime_config();
 init_api_contract();
 init_logger();
@@ -20799,7 +21172,7 @@ function getSlotTriggerWord(type) {
 }
 var SCREENSHOT_EXTENSIONS = /* @__PURE__ */ new Set(["png", "jpg", "jpeg", "webp"]);
 async function attachBrowserArtifacts(workspaceId, card, result, since) {
-  const dir = join16(ATTACHMENTS_DIR, card.id);
+  const dir = join17(ATTACHMENTS_DIR, card.id);
   let entries;
   try {
     entries = await readdir(dir);
@@ -20812,7 +21185,7 @@ async function attachBrowserArtifacts(workspaceId, card, result, since) {
   for (const name of entries) {
     const ext = name.split(".").pop()?.toLowerCase() ?? "";
     if (!SCREENSHOT_EXTENSIONS.has(ext)) continue;
-    const filePath = join16(dir, name);
+    const filePath = join17(dir, name);
     try {
       const info2 = await stat(filePath);
       if (!info2.isFile() || info2.mtimeMs < since) continue;
@@ -21077,61 +21450,6 @@ function runAgentOnce(agentId, prompt, cwd, workspaceId, streamId, stateHub, reg
     unregisterProcess = registerLiveProcess(streamId, proc);
   });
 }
-function git4(args, cwd) {
-  return spawnSync5("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).stdout?.trim() ?? "";
-}
-function readFileSafe(filePath) {
-  try {
-    return readFileSync6(filePath, "utf-8");
-  } catch {
-    return "";
-  }
-}
-function getGitStat(worktreePath, baseRef) {
-  const parts = [
-    git4(["diff", "--stat", `${baseRef}...HEAD`], worktreePath),
-    git4(["diff", "--stat", "--cached"], worktreePath),
-    git4(["diff", "--stat"], worktreePath)
-  ].filter(Boolean);
-  const newUntracked = git4(["ls-files", "--others", "--exclude-standard"], worktreePath).split("\n").map((f2) => f2.trim()).filter(Boolean);
-  if (newUntracked.length > 0) {
-    parts.push(`New files:
-${newUntracked.map((f2) => `  ${f2}`).join("\n")}`);
-  }
-  return parts.join("\n") || "(no changes detected \u2014 agent may not have committed yet)";
-}
-function getGitFullDiff(worktreePath, baseRef) {
-  const sections = [];
-  const diffParts = [
-    git4(["diff", "-U15", `${baseRef}...HEAD`], worktreePath),
-    git4(["diff", "-U15", "--cached"], worktreePath),
-    git4(["diff", "-U15"], worktreePath)
-  ].filter(Boolean);
-  if (diffParts.length > 0) {
-    sections.push(`\`\`\`diff
-${diffParts.join("\n")}
-\`\`\``);
-  }
-  const newUntracked = git4(["ls-files", "--others", "--exclude-standard"], worktreePath).split("\n").map((f2) => f2.trim()).filter(Boolean);
-  if (newUntracked.length > 0) {
-    const newFileContents = [];
-    for (const file of newUntracked) {
-      const content = readFileSafe(join16(worktreePath, file));
-      const ext = file.split(".").pop() ?? "";
-      newFileContents.push(content ? `### ${file}
-\`\`\`${ext}
-${content}
-\`\`\`` : `### ${file} (unreadable)`);
-    }
-    sections.push(`New files (full content):
-
-${newFileContents.join("\n\n")}`);
-  }
-  return sections.join("\n\n");
-}
-function getGitHeadSha(worktreePath) {
-  return git4(["rev-parse", "HEAD"], worktreePath);
-}
 function attachmentLines(attachments) {
   return attachments.map((a, i) => `- [Attachment #${i + 1}] ${a.name}: ${a.path}`).join("\n");
 }
@@ -21257,12 +21575,6 @@ ${sections.join("\n\n---\n\n")}`,
     files: []
   };
 }
-var INLINE_DIFF_LIMIT = 8e3;
-function formatDiffBlock(fullDiff, baseRef, header = "Git diff") {
-  if (fullDiff.length <= INLINE_DIFF_LIMIT) return `${header}:
-${fullDiff}`;
-  return `Large changeset (${fullDiff.length.toLocaleString()} chars). Use \`git diff ${baseRef}...HEAD\` and read individual files to explore.`;
-}
 var FOLLOWUP_REVIEW_FOCUS = `**This is a follow-up review.** An earlier version of this work already passed review in a prior round \u2014 only the \`## New Feedback\` / \`## Current Iteration\` items triggered this run. Re-review ONLY: (1) whether those items were addressed in the changes below, and (2) whether the new changes introduced a regression or broke a caller (grep callers of anything touched to confirm). Do NOT re-litigate previously-approved code or raise issues unrelated to this round's feedback.`;
 function renderReviewDiff(stat3, fullDiff, baseRef, scope) {
   if (!scope.useIncremental) {
@@ -21764,16 +22076,75 @@ function tryParseAgentJson(output) {
   }
 }
 
-// src/daemon/scheduler.ts
-var FAST_EXIT_THRESHOLD_MS = 8e3;
-var MAX_RECENT_BUFFERS = 100;
-var TaskScheduler = class {
-  constructor(options) {
-    this.options = options;
+// src/daemon/companion-agent.ts
+function buildCompanionAgentSystemPrompt(workspaceId, repoPath, worktreePath, baseRef, secrets, systemPrompt, gitInstructions, seedPrompt, resumedCanvas) {
+  const effectiveGitInstructions = gitInstructions?.trim() || DEFAULT_GIT_INSTRUCTIONS;
+  const fullDiff = getGitFullDiff(worktreePath, baseRef);
+  const worktreeSection = fullDiff ? `## Current worktree state (vs ${baseRef})
+${getGitStat(worktreePath, baseRef)}
+
+## Diff (vs ${baseRef})
+${formatDiffBlock(fullDiff, baseRef, "Git diff")}` : `## Worktree state
+
+The worktree is clean and branched from \`${baseRef}\` \u2014 there is no diff yet. Skip \`git diff\` and start working.`;
+  const parts = [
+    `You are the Companion agent for the project at \`${repoPath}\`.
+
+You are a direct, chat-driven pairing session with a developer. Unlike the ticket pipeline's dev agent, you are not working through a queued task with an automated reviewer downstream \u2014 the developer is talking to you live and steering the work turn by turn. You have full write access to the code in your current working directory, which is an isolated git worktree branched from \`${baseRef}\`.
+
+Work incrementally and check in with the developer as you go rather than disappearing to complete a large scope autonomously. When you commit, follow the project's git conventions (see "## Git conventions" below) \u2014 do not commit until the developer asks you to, unless they've told you to commit as you go.`,
+    worktreeSection
+  ];
+  parts.push(`## Sharing a canvas with the developer
+
+When the developer asks you to "plan" something, wants to see a report, findings, or a set of questions answered \u2014 or you want to lay out an approach before starting \u2014 use the \`whipped_show_canvas\` MCP tool. That's what "plan" (and requests like it) means in this session: push it to the canvas, don't just describe it in chat. Do NOT use any other built-in planning mode you might have; always push through this tool instead, even for what would normally trigger that. Push markdown, raw HTML, mermaid diagrams, and interactive questions \u2014 instead of writing a long response as a chat message \u2014 whenever you want structured feedback. The developer's answers, comments, and notes come back as a normal follow-up message in this conversation \u2014 there is no separate response channel, so treat it exactly like something they typed.
+
+${buildCanvasModeGuidance()}`);
+  if (resumedCanvas) {
+    parts.push(`## Resuming a saved canvas
+
+This session was started from a previously saved canvas titled "${resumedCanvas.title}". Its content is shown in full below \u2014 the developer can already see this in their canvas as version 1, but you cannot read it back, so this is the only place you'll see it. Treat it as the current state of the work: continue from here rather than re-planning from scratch, and call \`whipped_save_canvas\` again as you make further progress so the saved canvas stays in sync with what's actually done.
+
+${serializeCanvasBlocksForPrompt(resumedCanvas.blocks)}`);
+  }
+  if (seedPrompt?.trim()) parts.push(`## Project-specific instructions
+
+${seedPrompt.trim()}`);
+  parts.push(`## Memory
+
+This project has its own persistent memory. The \`whipped_save_memory\` / \`whipped_update_memory\` MCP tools ARE this project's memory \u2014 do NOT use your own notes, scratch files, CLAUDE.md, or any other memory system for durable facts.
+
+When you are asked to "remember", "save to memory", "note for next time" \u2014 or you hit a cross-cutting convention, an architecture decision, a non-obvious repo-wide gotcha, or a correction the developer made \u2014 record it in memory. Do NOT record what is already in the code or schema (endpoint request/response shapes, query params, column lists, field names, colour classes, per-page layout): if your note would cite the file where the truth lives, the file is the memory \u2014 skip it. Keep each entry to one focused fact in 1-3 sentences.
+
+Before recording, check the memory list injected above (each entry shows its \`[id]\`) and \`whipped_search_memory\`. If what you're recording **contradicts, reverses, supersedes, corrects, or is a near-duplicate of** an existing memory, call \`whipped_update_memory\` with that memory's id and overwrite it \u2014 do NOT create a second, conflicting entry.
+
+Scope a memory \`project\` for facts specific to this repo, or \`global\` for things that apply across all the user's projects (style/preferences).`);
+  const secretsSection = buildSecretsSection(secrets);
+  if (secretsSection) parts.push(secretsSection);
+  if (systemPrompt?.trim()) parts.push(`## Project context
+
+${systemPrompt.trim()}`);
+  parts.push(`## Git conventions
+
+${effectiveGitInstructions}`);
+  const memContext = buildMemoryContext(workspaceId);
+  const text = parts.join("\n\n");
+  return memContext ? `${memContext}
+
+${text}` : text;
+}
+
+// src/daemon/scheduler.ts
+var FAST_EXIT_THRESHOLD_MS = 8e3;
+var MAX_RECENT_BUFFERS = 100;
+var TaskScheduler = class {
+  constructor(options) {
+    this.options = options;
   }
   options;
   running = /* @__PURE__ */ new Map();
   assistantSessions = /* @__PURE__ */ new Map();
+  companionSessions = /* @__PURE__ */ new Map();
   // Keep the last output buffer around after a task exits so the terminal
   // can still restore when the user opens it for a completed/awaiting-review task.
   recentBuffers = /* @__PURE__ */ new Map();
@@ -21829,7 +22200,7 @@ var TaskScheduler = class {
   get assistantAgentTaskId() {
     return `${ASSISTANT_AGENT_PREFIX}${this.options.workspaceId}`;
   }
-  async startAssistantAgent() {
+  async startAssistantAgent(override, savedCanvasId) {
     const { workspaceId, repoPath, serverUrl, stateHub, defaultAgent } = this.options;
     const taskId = this.assistantAgentTaskId;
     const existing = this.assistantSessions.get(taskId);
@@ -21841,11 +22212,18 @@ var TaskScheduler = class {
     stateHub.clearTerminalBuffer(workspaceId, taskId);
     const prompt = "";
     const projectConfig = await loadProjectConfig(workspaceId);
-    const assistantModel = projectConfig.assistantModel;
+    const assistantModel = override ?? projectConfig.assistantModel;
     const agentId = assistantModel?.agentId ?? defaultAgent;
     const secrets = projectConfig.secrets ?? [];
     const secretsEnv = buildSecretsEnv(secrets);
-    const assistantSystemPrompt = buildAssistantAgentSystemPrompt(repoPath, secrets, projectConfig.systemPrompt);
+    const savedCanvas = savedCanvasId ? getCompanionSavedCanvas(savedCanvasId) : null;
+    if (savedCanvas) createCompanionCanvas(taskId, workspaceId, savedCanvas.blocks);
+    const assistantSystemPrompt = buildAssistantAgentSystemPrompt(
+      repoPath,
+      secrets,
+      projectConfig.systemPrompt,
+      savedCanvas ? { title: savedCanvas.title, blocks: savedCanvas.blocks } : void 0
+    );
     const memContext = buildMemoryContext(workspaceId);
     const appendSystemPrompt = memContext ? `${memContext}
 
@@ -21896,6 +22274,9 @@ ${assistantSystemPrompt}` : assistantSystemPrompt;
           ...agentId === "cursor" ? { [CURSOR_CONFIG_DIR_ENV]: getCursorConfigDir(taskId) } : {}
         },
         mcpConfigPath: agentId === "claude" ? CLAUDE_ASSISTANT_MCP_CONFIG_PATH : void 0,
+        // Denies Claude's own native plan-mode tools — see writeClaudeCompanionSettings
+        // — so "plan" always means whipped_show_canvas, same as the companion agent.
+        hookSettingsPath: agentId === "claude" ? CLAUDE_COMPANION_SETTINGS_PATH : void 0,
         mcpServer: agentId === "codex" ? buildWhippedMcpServerSpec(
           getMcpServerPath(),
           serverUrl,
@@ -21932,6 +22313,234 @@ ${assistantSystemPrompt}` : assistantSystemPrompt;
   isAssistantAgentRunning() {
     return this.assistantSessions.has(this.assistantAgentTaskId);
   }
+  // Creates the worktree (or resolves the main-repo checkout) synchronously and
+  // returns quickly — install + agent spawn happen in the background via
+  // launchCompanionAgent so callers (the create-session API request) aren't
+  // blocked on a potentially long install command.
+  async startCompanionAgent(session) {
+    const { workspaceId, repoPath, stateHub } = this.options;
+    const taskId = session.id;
+    const existing = this.companionSessions.get(taskId);
+    if (existing) existing.process.kill();
+    this.recentBuffers.delete(taskId);
+    stateHub.clearTerminalBuffer(workspaceId, taskId);
+    if (session.useWorktree) {
+      const worktree = createWorktree(taskId, repoPath, session.baseRef, session.branchName ?? void 0);
+      setCompanionSessionWorktreePath(taskId, worktree.path);
+      setCompanionSessionStatus(taskId, worktree.isNew ? "installing" : "running");
+      void this.launchCompanionAgent(session, worktree.path, worktree.isNew);
+    } else {
+      setCompanionSessionWorktreePath(taskId, repoPath);
+      setCompanionSessionStatus(taskId, "running");
+      void this.launchCompanionAgent(session, repoPath, false);
+    }
+  }
+  async launchCompanionAgent(session, cwd, isNewWorktree) {
+    const { workspaceId, repoPath, serverUrl, stateHub } = this.options;
+    const taskId = session.id;
+    const agentId = session.agentId;
+    const projectConfig = await loadProjectConfig(workspaceId);
+    const secrets = projectConfig.secrets ?? [];
+    const secretsEnv = buildSecretsEnv(secrets);
+    if (isNewWorktree && projectConfig.worktreeSetup) {
+      await this.runCompanionInstall(taskId, workspaceId, repoPath, cwd, projectConfig.worktreeSetup);
+      if (this.isShuttingDown) return;
+      if (this.manuallyStoppedInstalls.delete(taskId)) {
+        await removeWorktreeAsync(taskId, repoPath, session.branchName ?? void 0);
+        setCompanionSessionWorktreePath(taskId, null);
+        setCompanionSessionStatus(taskId, "stopped");
+        return;
+      }
+    }
+    setCompanionSessionStatus(taskId, "running");
+    const resumedCanvas = session.savedCanvasId ? getCompanionSavedCanvas(session.savedCanvasId) : null;
+    const appendSystemPrompt = buildCompanionAgentSystemPrompt(
+      workspaceId,
+      repoPath,
+      cwd,
+      session.baseRef,
+      secrets,
+      projectConfig.systemPrompt,
+      projectConfig.gitInstructions,
+      session.seedPrompt,
+      resumedCanvas ? { title: resumedCanvas.title, blocks: resumedCanvas.blocks } : void 0
+    );
+    const mcpConfigPath = !isPluginConfigAgent(agentId) && agentId !== "cursor" ? getMcpConfigPath(taskId) : void 0;
+    if (agentId === "claude") {
+      await writeClaudeMcpConfig(
+        getMcpServerPath(),
+        serverUrl,
+        workspaceId,
+        agentId,
+        mcpConfigPath,
+        void 0,
+        buildMcpRoleArgs("companion", void 0, taskId)
+      ).catch((err) => {
+        logger.warn({ err }, "[scheduler] Failed to write companion agent MCP config");
+      });
+    } else if (isPluginConfigAgent(agentId)) {
+      const mcpSpec = buildWhippedMcpServerSpec(
+        getMcpServerPath(),
+        serverUrl,
+        workspaceId,
+        agentId,
+        buildMcpRoleArgs("companion", void 0, taskId)
+      );
+      await writePluginAgentFiles(agentId, taskId, getServerPort(serverUrl), mcpSpec, { appendSystemPrompt }).catch(
+        (err) => {
+          logger.warn({ err }, `[scheduler] Failed to write ${agentId} companion agent files`);
+        }
+      );
+    } else if (agentId === "cursor") {
+      const mcpSpec = buildWhippedMcpServerSpec(
+        getMcpServerPath(),
+        serverUrl,
+        workspaceId,
+        agentId,
+        buildMcpRoleArgs("companion", void 0, taskId)
+      );
+      await writeCursorConfigFiles(taskId, getServerPort(serverUrl), mcpSpec).catch((err) => {
+        logger.warn({ err }, "[scheduler] Failed to write cursor companion agent config");
+      });
+    }
+    let resolveExit;
+    const exitPromise = new Promise((resolve5) => {
+      resolveExit = resolve5;
+    });
+    const companionTask = {
+      taskId,
+      streamId: taskId,
+      // companion session uses taskId as its stream (single persistent session)
+      agentId,
+      exitPromise,
+      process: spawnAgent({
+        agentId,
+        prompt: "",
+        cwd,
+        env: {
+          ...secretsEnv,
+          ...buildTaskHookEnv(taskId, workspaceId),
+          WHIPPED_SLOT: "companion",
+          ...pluginAgentConfigDirEnv(agentId, taskId),
+          ...agentId === "cursor" ? { [CURSOR_CONFIG_DIR_ENV]: getCursorConfigDir(taskId) } : {}
+        },
+        mcpConfigPath: agentId === "claude" ? mcpConfigPath : void 0,
+        // Denies Claude's own native plan-mode tools for this session — see
+        // writeClaudeCompanionSettings — so "plan" always means whipped_show_canvas.
+        hookSettingsPath: agentId === "claude" ? CLAUDE_COMPANION_SETTINGS_PATH : void 0,
+        mcpServer: agentId === "codex" ? buildWhippedMcpServerSpec(
+          getMcpServerPath(),
+          serverUrl,
+          workspaceId,
+          agentId,
+          buildMcpRoleArgs("companion", void 0, taskId)
+        ) : void 0,
+        model: session.model ?? null,
+        effort: session.effort ?? null,
+        appendSystemPrompt: isPluginConfigAgent(agentId) ? void 0 : appendSystemPrompt,
+        onOutput: (data) => {
+          companionTask.outputBuffer += data;
+          stateHub.broadcastTerminalOutput(workspaceId, taskId, data);
+        },
+        onExit: () => {
+          this.setRecentBuffer(taskId, companionTask.outputBuffer);
+          this.companionSessions.delete(taskId);
+          setCompanionSessionStatus(taskId, "stopped");
+          resolveExit();
+        }
+      }),
+      startedAt: Date.now(),
+      outputBuffer: ""
+    };
+    this.companionSessions.set(taskId, companionTask);
+  }
+  // Copies/links worktreeSetup's configured files then runs its install command,
+  // mirroring the card dev-agent's worktree setup step (launchDevAgent above) but
+  // streamed straight into the companion session's own terminal (taskId) instead
+  // of a separate install stream row, since companion sessions have no such table.
+  async runCompanionInstall(taskId, workspaceId, repoPath, worktreePath, worktreeSetup) {
+    const { stateHub } = this.options;
+    const { filesToCopy, installCommand } = worktreeSetup;
+    for (const entry of filesToCopy) {
+      const src = join18(repoPath, entry.path);
+      if (!existsSync10(src)) continue;
+      const dst = join18(worktreePath, entry.path);
+      await mkdir3(dirname6(dst), { recursive: true });
+      try {
+        if (entry.symlink) {
+          await shareIntoWorktree(src, dst);
+        } else {
+          await cp(src, dst, { recursive: true, dereference: true });
+        }
+      } catch (err) {
+        logger.warn(
+          { err },
+          `[scheduler] companion worktree setup: failed to ${entry.symlink ? "link" : "copy"} ${entry.path}`
+        );
+      }
+    }
+    const installCmd = installCommand.trim();
+    if (!installCmd) return;
+    let buffer = "";
+    const emit = (data) => {
+      buffer += data;
+      this.recentBuffers.set(taskId, buffer);
+      stateHub.broadcastTerminalOutput(workspaceId, taskId, data);
+    };
+    emit(`\x1B[1;36m$ ${installCmd}\x1B[0m\r
+`);
+    const exitCode = await new Promise((resolveExit) => {
+      const [shell, shellArgs] = getShellInvocation(installCmd);
+      const proc = nodePty2.spawn(shell, shellArgs, {
+        name: "xterm-256color",
+        cols: 220,
+        rows: 50,
+        cwd: worktreePath,
+        env: { ...process.env, REPO_PATH: repoPath, TERM: "xterm-256color" }
+      });
+      this.runningInstalls.set(taskId, proc);
+      proc.onData(emit);
+      proc.onExit(({ exitCode: exitCode2 }) => resolveExit(exitCode2 ?? 0));
+    });
+    this.runningInstalls.delete(taskId);
+    if (this.isShuttingDown) return;
+    if (this.manuallyStoppedInstalls.has(taskId)) {
+      emit("\r\n\x1B[1;33mInstall stopped\x1B[0m\r\n");
+      return;
+    }
+    if (exitCode !== 0) {
+      logger.error(`[scheduler] Install command failed (code ${exitCode}) for companion session ${taskId}`);
+      emit(`\r
+\x1B[1;31mInstall command failed (code ${exitCode}) \u2014 proceeding anyway\x1B[0m\r
+`);
+    } else {
+      emit("\r\n\x1B[1;32mInstall complete\x1B[0m\r\n");
+    }
+  }
+  // Kills the session's process (or its still-running install command) and waits
+  // for it to actually exit (bounded by a timeout) before returning — callers
+  // that are about to delete or merge the worktree on disk must await this
+  // first, since attemptMerge/removeWorktreeAsync can otherwise race a still-live
+  // process whose cwd is inside that worktree.
+  async stopCompanionAgent(sessionId) {
+    const installProc = this.runningInstalls.get(sessionId);
+    if (installProc) {
+      this.manuallyStoppedInstalls.add(sessionId);
+      this.runningInstalls.delete(sessionId);
+      killInstallProcess(installProc);
+    }
+    const session = this.companionSessions.get(sessionId);
+    if (session) {
+      const exitPromise = session.exitPromise ?? Promise.resolve();
+      session.process.kill();
+      await Promise.race([exitPromise, new Promise((resolve5) => setTimeout(resolve5, 5e3))]);
+    }
+    this.companionSessions.delete(sessionId);
+    setCompanionSessionStatus(sessionId, "stopped");
+  }
+  isCompanionAgentRunning(sessionId) {
+    return this.companionSessions.has(sessionId);
+  }
   get activeCount() {
     return this.running.size;
   }
@@ -22120,9 +22729,9 @@ ${assistantSystemPrompt}` : assistantSystemPrompt;
           const copied = [];
           const linked = [];
           for (const entry of filesToCopy) {
-            const src = join17(repoPath, entry.path);
+            const src = join18(repoPath, entry.path);
             if (!existsSync10(src)) continue;
-            const dst = join17(worktree.path, entry.path);
+            const dst = join18(worktree.path, entry.path);
             await mkdir3(dirname6(dst), { recursive: true });
             try {
               if (entry.symlink) {
@@ -22542,6 +23151,8 @@ ${devSystemPromptResult.text}`;
     }
     const assistantSession = this.assistantSessions.get(streamId);
     if (assistantSession) return assistantSession.outputBuffer;
+    const companionSession = this.companionSessions.get(streamId);
+    if (companionSession) return companionSession.outputBuffer;
     return this.recentBuffers.get(streamId) ?? null;
   }
   resizeTerminal(streamId, cols, rows) {
@@ -22558,7 +23169,7 @@ ${devSystemPromptResult.text}`;
     for (const task of this.running.values()) {
       if (task.streamId === streamId) return task.process;
     }
-    return this.assistantSessions.get(streamId)?.process ?? this.liveProcesses.get(streamId);
+    return this.assistantSessions.get(streamId)?.process ?? this.companionSessions.get(streamId)?.process ?? this.liveProcesses.get(streamId);
   }
   async handleHookEvent(event, taskId) {
     const { workspaceId, stateHub } = this.options;
@@ -22744,6 +23355,10 @@ ${devSystemPromptResult.text}`;
     }
     this.runningInstalls.clear();
     this.stopAssistantAgent();
+    for (const [, task] of this.companionSessions) {
+      task.process.kill();
+    }
+    this.companionSessions.clear();
   }
   // Call before stopAll() during graceful shutdown so onExit handlers bail out
   // and do not overwrite the failed/todo state written by cleanupStaleTasks().
@@ -22789,8 +23404,15 @@ function getMcpServerPath() {
     args: [resolve2(thisDir, "mcp-server.js")]
   };
 }
-function buildAssistantAgentSystemPrompt(repoPath, secrets = [], systemPrompt) {
+function buildAssistantAgentSystemPrompt(repoPath, secrets = [], systemPrompt, resumedCanvas) {
   const secretsSection = buildSecretsSection(secrets);
+  const resumedCanvasSection = resumedCanvas ? `
+
+# Resuming a saved canvas
+
+This conversation was started from a previously saved canvas titled "${resumedCanvas.title}". Its content is shown in full below \u2014 the developer can already see this in their canvas as version 1, but you cannot read it back, so this is the only place you'll see it. Treat it as the current state of the discussion: continue from here rather than re-planning from scratch, and call \`whipped_save_canvas\` again as things progress so the saved canvas stays in sync.
+
+${serializeCanvasBlocksForPrompt(resumedCanvas.blocks)}` : "";
   return `You are the Assistant for the project at \`${repoPath}\`.
 
 You are a conversational project assistant. You can discuss the project, help plan work, answer questions about the codebase, workflows, and board state, and help the developer decide what to build. You also have full control over the Kanban board and workflows via MCP tools.
@@ -22824,6 +23446,10 @@ You are a conversational project assistant. You can discuss the project, help pl
 - \`kanban_get_workflows\` \u2014 list all workflows (task and story/orch) with their agent slots, model tiers, tools, and prompts
 - \`kanban_upsert_workflow\` \u2014 create or fully replace a workflow (pass complete workflow object)
 
+## Canvas
+- \`whipped_show_canvas\` \u2014 push a structured, interactive canvas (markdown, HTML mockups, mermaid diagrams, questions) \u2014 for a plan, a report, findings, or anything else worth showing rather than describing in chat
+- \`whipped_save_canvas\` \u2014 consolidate the conversation's canvas versions into one and save it to the reusable canvas library
+
 ## Memory
 - \`whipped_search_memory\` \u2014 search durable project + global memory before re-discovering how something works
 - \`whipped_get_memory\` \u2014 fetch one memory's full content by id
@@ -22832,6 +23458,12 @@ You are a conversational project assistant. You can discuss the project, help pl
 
 The Memory section injected above this prompt lists existing memories with their \`[id]\`. When the developer asks you to "remember" something, or states a durable preference/decision, save it. Before saving, check the injected list and \`whipped_search_memory\`; if it contradicts or supersedes an existing entry, \`whipped_update_memory\` that id instead of creating a duplicate.
 
+# Sharing a canvas
+
+When you want to lay out an approach, a UI mockup, or gather structured feedback before creating tickets \u2014 or the developer asks you to "plan" something, wants a report, or wants a set of questions answered \u2014 use the \`whipped_show_canvas\` MCP tool instead of writing a long response as a chat message. Do NOT use any other built-in planning mode you might have; always push it through this tool instead, even for what would normally trigger that. The developer's answers, comments, and notes come back as a normal follow-up message in this conversation \u2014 there is no separate response channel, so treat it exactly like something they typed.
+
+${buildCanvasModeGuidance()}${resumedCanvasSection}
+
 # Card types
 
 **task** \u2014 a normal development ticket. Runs an optional plan slot, then dev, then any number of review slots (based on workflow).
@@ -25379,6 +26011,7 @@ var errorHandler2 = (err, c) => {
 };
 
 // src/api/routes/agent.ts
+init_api_contract();
 import { z as z3 } from "zod";
 
 // node_modules/.pnpm/hono@4.12.23/node_modules/hono/dist/utils/cookie.js
@@ -25676,8 +26309,8 @@ var zv = (target, schema) => zValidator(target, schema, (result) => {
 });
 
 // src/api/services/agent-service.ts
-var startAgentSession = async (scheduler) => ({
-  taskId: await scheduler.startAssistantAgent()
+var startAgentSession = async (scheduler, override, savedCanvasId) => ({
+  taskId: await scheduler.startAssistantAgent(override, savedCanvasId)
 });
 var stopAgentSession = async (scheduler) => {
   scheduler?.stopAssistantAgent();
@@ -25691,21 +26324,26 @@ var getAgentSessionStatus = async (scheduler) => {
 };
 
 // src/api/routes/agent.ts
+var startSessionBodySchema = z3.object({
+  workspaceId: z3.string(),
+  override: agentModelChoiceSchema.optional(),
+  savedCanvasId: z3.string().optional()
+});
 var agentController = new Hono2().get("/session", zv("query", z3.object({ workspaceId: z3.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("query");
   return c.json(await getAgentSessionStatus(ctx.getScheduler(workspaceId)));
-}).post("/session", zv("json", z3.object({ workspaceId: z3.string() })), async (c) => {
+}).post("/session", zv("json", startSessionBodySchema), async (c) => {
   const ctx = c.var.ctx;
-  const { workspaceId } = c.req.valid("json");
+  const { workspaceId, override, savedCanvasId } = c.req.valid("json");
   const scheduler = ctx.getScheduler(workspaceId);
   if (!scheduler) {
     await ctx.ensureWorkspace(workspaceId);
     const retried = ctx.getScheduler(workspaceId);
     if (!retried) throw NotFoundError("Workspace");
-    return c.json(await startAgentSession(retried));
+    return c.json(await startAgentSession(retried, override, savedCanvasId));
   }
-  return c.json(await startAgentSession(scheduler));
+  return c.json(await startAgentSession(scheduler, override, savedCanvasId));
 }).delete("/session", zv("query", z3.object({ workspaceId: z3.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("query");
@@ -26251,8 +26889,8 @@ var getDiffService = async (workspaceId, cardId) => {
   const card = board.cards[cardId];
   if (!card) throw NotFoundError("Card");
   const worktreePath = getWorktreePath(resolveWorktreeOwnerId(cardId, board.cards));
-  const { existsSync: existsSync15 } = await import("node:fs");
-  if (!existsSync15(worktreePath)) {
+  const { existsSync: existsSync16 } = await import("node:fs");
+  if (!existsSync16(worktreePath)) {
     return { diff: null, error: "No worktree \u2014 agent has not started yet" };
   }
   const committedResult = spawnSync6("git", ["diff", `${card.baseRef}...HEAD`, "--no-color", "-U3"], {
@@ -26278,10 +26916,10 @@ var getDiffService = async (workspaceId, cardId) => {
     encoding: "utf-8"
   });
   const untrackedFiles = (untrackedResult.stdout ?? "").split("\n").map((f2) => f2.trim()).filter(Boolean);
-  const { readFileSync: readFileSync9 } = await import("node:fs");
+  const { readFileSync: readFileSync10 } = await import("node:fs");
   const untrackedDiffs = untrackedFiles.map((file) => {
     try {
-      const content = readFileSync9(`${worktreePath}/${file}`, "utf-8");
+      const content = readFileSync10(`${worktreePath}/${file}`, "utf-8");
       const lines = content.split("\n");
       const addedLines = lines.map((l, _i) => `+${l}`).join("\n");
       const hunkHeader = `@@ -0,0 +1,${lines.length} @@`;
@@ -26311,8 +26949,8 @@ var getCommitsService = async (workspaceId, cardId) => {
   const card = board.cards[cardId];
   if (!card) throw NotFoundError("Card");
   const worktreePath = getWorktreePath(resolveWorktreeOwnerId(cardId, board.cards));
-  const { existsSync: existsSync15 } = await import("node:fs");
-  if (!existsSync15(worktreePath)) return { commits: [] };
+  const { existsSync: existsSync16 } = await import("node:fs");
+  if (!existsSync16(worktreePath)) return { commits: [] };
   const result = spawnSync6("git", ["log", "--pretty=format:%H%x00%h%x00%s%x00%an%x00%ai", `${card.baseRef}..HEAD`], {
     cwd: worktreePath,
     encoding: "utf-8"
@@ -26333,8 +26971,8 @@ var getDiffForCommitService = async (workspaceId, cardId, commitHash) => {
   if (!card) throw NotFoundError("Card");
   if (!/^[0-9a-f]{4,64}$/i.test(commitHash)) return { diff: null, error: "Invalid commit hash" };
   const worktreePath = getWorktreePath(resolveWorktreeOwnerId(cardId, board.cards));
-  const { existsSync: existsSync15 } = await import("node:fs");
-  if (!existsSync15(worktreePath)) return { diff: null, error: "No worktree" };
+  const { existsSync: existsSync16 } = await import("node:fs");
+  if (!existsSync16(worktreePath)) return { diff: null, error: "No worktree" };
   const result = spawnSync6("git", ["show", commitHash, "--format=", "--patch", "--no-color", "-U3"], {
     cwd: worktreePath,
     encoding: "utf-8",
@@ -26582,6 +27220,376 @@ var cardsController = new Hono2().post("/", zv("json", runtimeCardCreateRequestS
   }
 );
 
+// src/api/routes/companion-saved-canvases.ts
+import { z as z6 } from "zod";
+
+// src/api/services/companion-saved-canvases-service.ts
+async function listCompanionSavedCanvasesEntry(workspaceId) {
+  return { canvases: listCompanionSavedCanvases(workspaceId) };
+}
+async function deleteCompanionSavedCanvasEntry(id) {
+  deleteCompanionSavedCanvas(id);
+}
+async function clearCompanionCanvasesEntry(sessionId) {
+  deleteCompanionCanvasesForSession(sessionId);
+}
+async function saveCompanionCanvasEntry(sessionId, workspaceId, title, blocks) {
+  const session = getCompanionSession(sessionId);
+  if (session) {
+    if (session.savedCanvasId) {
+      const updated = updateCompanionSavedCanvas(session.savedCanvasId, { title, blocks });
+      if (updated) return updated;
+    }
+    const created = createCompanionSavedCanvas(workspaceId, { title, blocks, sourceSessionId: sessionId });
+    setCompanionSessionSavedCanvasId(sessionId, created.id);
+    return created;
+  }
+  const existing = findCompanionSavedCanvasBySourceSession(sessionId);
+  if (existing) {
+    const updated = updateCompanionSavedCanvas(existing.id, { title, blocks });
+    if (updated) return updated;
+  }
+  return createCompanionSavedCanvas(workspaceId, { title, blocks, sourceSessionId: sessionId });
+}
+
+// src/api/routes/companion-saved-canvases.ts
+var companionSavedCanvasesController = new Hono2().get("/", zv("query", z6.object({ workspaceId: z6.string() })), async (c) => {
+  const { workspaceId } = c.req.valid("query");
+  return c.json(await listCompanionSavedCanvasesEntry(workspaceId));
+}).delete("/:id", zv("param", z6.object({ id: z6.string() })), async (c) => {
+  const { id } = c.req.valid("param");
+  await deleteCompanionSavedCanvasEntry(id);
+  return c.json({ ok: true });
+});
+
+// src/api/routes/companion-sessions.ts
+init_api_contract();
+import { z as z7 } from "zod";
+
+// src/api/services/companion-canvases-service.ts
+var createCompanionCanvasEntry = async (sessionId, workspaceId, blocks) => {
+  return createCompanionCanvas(sessionId, workspaceId, blocks);
+};
+var listCompanionCanvasesEntry = async (sessionId) => {
+  return { canvases: listCompanionCanvases(sessionId) };
+};
+
+// src/api/services/companion-diff-service.ts
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { spawnSync as spawnSync7 } from "node:child_process";
+var MAX_BUFFER = 4 * 1024 * 1024;
+var getCompanionDiffService = async (id) => {
+  const session = getCompanionSession(id);
+  if (!session) throw NotFoundError("Companion session");
+  if (!session.worktreePath || !existsSync11(session.worktreePath)) {
+    return { diff: null, error: "No worktree \u2014 agent has not started yet" };
+  }
+  const worktreePath = session.worktreePath;
+  const committedResult = spawnSync7("git", ["diff", `${session.baseRef}...HEAD`, "--no-color", "-U3"], {
+    cwd: worktreePath,
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+  if (committedResult.status !== 0 && committedResult.stderr) {
+    return { diff: null, error: committedResult.stderr.trim() };
+  }
+  const stagedResult = spawnSync7("git", ["diff", "--cached", "--no-color", "-U3"], {
+    cwd: worktreePath,
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+  const unstagedResult = spawnSync7("git", ["diff", "--no-color", "-U3"], {
+    cwd: worktreePath,
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+  const untrackedResult = spawnSync7("git", ["ls-files", "--others", "--exclude-standard"], {
+    cwd: worktreePath,
+    encoding: "utf-8"
+  });
+  const untrackedFiles = (untrackedResult.stdout ?? "").split("\n").map((f2) => f2.trim()).filter(Boolean);
+  const untrackedDiffs = untrackedFiles.map((file) => {
+    try {
+      const content = readFileSync7(`${worktreePath}/${file}`, "utf-8");
+      const lines = content.split("\n");
+      const addedLines = lines.map((l) => `+${l}`).join("\n");
+      const hunkHeader = `@@ -0,0 +1,${lines.length} @@`;
+      return `diff --git a/${file} b/${file}
+new file mode 100644
+--- /dev/null
++++ b/${file}
+${hunkHeader}
+${addedLines}`;
+    } catch {
+      return null;
+    }
+  }).filter((d) => d !== null);
+  const diff = [committedResult.stdout, stagedResult.stdout, unstagedResult.stdout, ...untrackedDiffs].filter((s2) => s2?.trim()).join("\n");
+  const behindResult = spawnSync7("git", ["rev-list", "--count", `HEAD..${session.baseRef}`], {
+    cwd: worktreePath,
+    encoding: "utf-8"
+  });
+  const baseBehindCount = parseInt(behindResult.stdout?.trim() ?? "0", 10) || 0;
+  return { diff, error: null, baseBehindCount };
+};
+var getCompanionCommitsService = async (id) => {
+  const session = getCompanionSession(id);
+  if (!session) throw NotFoundError("Companion session");
+  if (!session.worktreePath || !existsSync11(session.worktreePath)) return { commits: [] };
+  const result = spawnSync7("git", ["log", "--pretty=format:%H%x00%h%x00%s%x00%an%x00%ai", `${session.baseRef}..HEAD`], {
+    cwd: session.worktreePath,
+    encoding: "utf-8"
+  });
+  if (result.status !== 0 || !result.stdout?.trim()) return { commits: [] };
+  const commits = result.stdout.trim().split("\n").filter(Boolean).map((line) => {
+    const [hash = "", shortHash = "", message = "", author = "", date2 = ""] = line.split("\0");
+    return { hash, shortHash, message, author, date: date2 };
+  });
+  return { commits };
+};
+var getCompanionDiffForCommitService = async (id, commitHash) => {
+  const session = getCompanionSession(id);
+  if (!session) throw NotFoundError("Companion session");
+  if (!/^[0-9a-f]{4,64}$/i.test(commitHash)) return { diff: null, error: "Invalid commit hash" };
+  if (!session.worktreePath || !existsSync11(session.worktreePath)) return { diff: null, error: "No worktree" };
+  const result = spawnSync7("git", ["show", commitHash, "--format=", "--patch", "--no-color", "-U3"], {
+    cwd: session.worktreePath,
+    encoding: "utf-8",
+    maxBuffer: MAX_BUFFER
+  });
+  if (result.status !== 0) return { diff: null, error: result.stderr?.trim() || "git show failed" };
+  return { diff: result.stdout, error: null };
+};
+
+// src/api/services/companion-merge-service.ts
+init_workspace_state();
+async function commitAndMergeCompanionService(id, repoPath, commitMessage, scheduler) {
+  const session = getCompanionSession(id);
+  if (!session) throw NotFoundError("Companion session");
+  if (!session.useWorktree || !session.branchName) {
+    throw BadRequestError("This session works directly in the main repo \u2014 there's nothing to merge");
+  }
+  if (!session.worktreePath) throw BadRequestError("Session has no worktree to merge");
+  await scheduler?.stopCompanionAgent(id);
+  const dirty = await isWorktreeDirty(session.worktreePath);
+  if (dirty) {
+    if (!commitMessage) return { status: "needs_commit" };
+    await commitWorktree(session.worktreePath, commitMessage);
+  }
+  const result = attemptMerge(repoPath, id, session.branchName);
+  setCompanionSessionWorktreePath(id, null);
+  if (result.dirtyBase) {
+    setCompanionSessionStatus(id, "stopped");
+    return { status: "dirty_base" };
+  }
+  if (!result.ok) {
+    abortMerge(repoPath);
+    setCompanionSessionStatus(id, "stopped");
+    return { status: "conflict", conflictedFiles: result.conflictedFiles };
+  }
+  setCompanionSessionStatus(id, "merged");
+  return { status: "merged" };
+}
+async function commitAndPRCompanionService(id, workspaceId, commitMessage, title, description, baseRefOverride) {
+  const session = getCompanionSession(id);
+  if (!session) throw NotFoundError("Companion session");
+  if (!session.worktreePath) throw BadRequestError("Session has no worktree");
+  const projectConfig = await loadProjectConfig(workspaceId);
+  const token = projectConfig.secrets?.find((s2) => s2.key === "GITHUB_TOKEN")?.value;
+  if (!token) return { status: "no_token" };
+  const dirty = await isWorktreeDirty(session.worktreePath);
+  if (dirty) {
+    if (!commitMessage) return { status: "needs_commit" };
+    await commitWorktree(session.worktreePath, commitMessage);
+  }
+  const branch = session.branchName ?? getCurrentBranch(session.worktreePath);
+  if (!branch) throw BadRequestError("Could not determine the current branch to push");
+  await pushBranch(session.worktreePath, branch);
+  const prUrl = await createGithubPR(
+    session.worktreePath,
+    title,
+    description,
+    baseRefOverride || session.baseRef,
+    token
+  );
+  return { status: "pr_created", prUrl };
+}
+
+// src/api/services/companion-service.ts
+init_api_contract();
+init_workspace_state();
+async function listCompanionSessionsEntry(workspaceId) {
+  return listCompanionSessions(workspaceId);
+}
+function getCompanionSessionEntry(id) {
+  return getCompanionSession(id);
+}
+async function createCompanionSessionEntry(workspaceId, repoPath, req, scheduler) {
+  const useWorktree = req.useWorktree;
+  const branchName = req.branchName?.trim() || null;
+  if (useWorktree && !branchName) {
+    throw BadRequestError("Branch name is required when using an isolated worktree");
+  }
+  const projectConfig = await loadProjectConfig(workspaceId);
+  const workflow = req.workflowId ? projectConfig.workflows.find((w2) => w2.id === req.workflowId) : void 0;
+  const devSlot = workflow?.slots.find((s2) => s2.type === "dev");
+  const seedPrompt = devSlot ? resolvePromptText(devSlot.prompt, repoPath) : "";
+  const suggestedPair = devSlot?.pairs[0];
+  const model = req.model ?? (suggestedPair ? { agentId: suggestedPair.binary, model: suggestedPair.model, effort: suggestedPair.effort } : DEFAULT_AGENT_MODEL_CHOICE);
+  const savedCanvas = req.savedCanvasId ? getCompanionSavedCanvas(req.savedCanvasId) : null;
+  const name = req.name?.trim() || savedCanvas?.title || (useWorktree ? branchName : "Main repo session");
+  const session = createCompanionSession(workspaceId, {
+    name,
+    useWorktree,
+    baseRef: req.baseRef,
+    branchName: useWorktree ? branchName : null,
+    workflowId: workflow?.id ?? null,
+    seedPrompt,
+    agentId: model.agentId ?? "claude",
+    model: model.model ?? null,
+    effort: model.effort ?? null,
+    savedCanvasId: savedCanvas?.id ?? null
+  });
+  if (savedCanvas) createCompanionCanvas(session.id, workspaceId, savedCanvas.blocks);
+  await scheduler.startCompanionAgent(session);
+  return getCompanionSession(session.id) ?? session;
+}
+async function stopCompanionSessionEntry(id, scheduler) {
+  if (!getCompanionSession(id)) throw NotFoundError("Companion session");
+  await scheduler?.stopCompanionAgent(id);
+}
+async function discardCompanionSessionEntry(id, repoPath, scheduler) {
+  const session = getCompanionSession(id);
+  if (!session) throw NotFoundError("Companion session");
+  await scheduler?.stopCompanionAgent(id);
+  if (session.useWorktree && session.worktreePath) {
+    await removeWorktreeAsync(id, repoPath, session.branchName ?? void 0);
+  }
+  deleteCompanionSession(id);
+}
+
+// src/api/routes/companion-sessions.ts
+var companionSessionsController = new Hono2().get("/", zv("query", z7.object({ workspaceId: z7.string() })), async (c) => {
+  const { workspaceId } = c.req.valid("query");
+  return c.json(await listCompanionSessionsEntry(workspaceId));
+}).get("/:id", zv("param", z7.object({ id: z7.string() })), async (c) => {
+  const { id } = c.req.valid("param");
+  const session = getCompanionSessionEntry(id);
+  if (!session) throw NotFoundError("Companion session");
+  return c.json(session);
+}).post("/", zv("json", companionSessionCreateRequestSchema.extend({ workspaceId: z7.string() })), async (c) => {
+  const ctx = c.var.ctx;
+  const { workspaceId, ...req } = c.req.valid("json");
+  const ws = await ctx.ensureWorkspace(workspaceId);
+  const scheduler = ctx.getScheduler(workspaceId);
+  if (!scheduler) throw NotFoundError("Workspace");
+  const session = await createCompanionSessionEntry(workspaceId, ws.repoPath, req, scheduler);
+  return c.json(session);
+}).delete(
+  "/:id",
+  zv("param", z7.object({ id: z7.string() })),
+  zv("query", z7.object({ workspaceId: z7.string() })),
+  async (c) => {
+    const ctx = c.var.ctx;
+    const { id } = c.req.valid("param");
+    const { workspaceId } = c.req.valid("query");
+    await stopCompanionSessionEntry(id, ctx.getScheduler(workspaceId));
+    return c.json({ ok: true });
+  }
+).post(
+  "/:id/discard",
+  zv("param", z7.object({ id: z7.string() })),
+  zv("json", z7.object({ workspaceId: z7.string() })),
+  async (c) => {
+    const ctx = c.var.ctx;
+    const { id } = c.req.valid("param");
+    const { workspaceId } = c.req.valid("json");
+    const ws = await ctx.ensureWorkspace(workspaceId);
+    await discardCompanionSessionEntry(id, ws.repoPath, ctx.getScheduler(workspaceId));
+    return c.json({ ok: true });
+  }
+).get("/:id/diff", zv("param", z7.object({ id: z7.string() })), async (c) => {
+  const { id } = c.req.valid("param");
+  return c.json(await getCompanionDiffService(id));
+}).get("/:id/commits", zv("param", z7.object({ id: z7.string() })), async (c) => {
+  const { id } = c.req.valid("param");
+  return c.json(await getCompanionCommitsService(id));
+}).get(
+  "/:id/diff-for-commit",
+  zv("param", z7.object({ id: z7.string() })),
+  zv("query", z7.object({ commitHash: z7.string() })),
+  async (c) => {
+    const { id } = c.req.valid("param");
+    const { commitHash } = c.req.valid("query");
+    return c.json(await getCompanionDiffForCommitService(id, commitHash));
+  }
+).post(
+  "/:id/commit-and-merge",
+  zv("param", z7.object({ id: z7.string() })),
+  zv("json", z7.object({ workspaceId: z7.string(), commitMessage: z7.string().optional() })),
+  async (c) => {
+    const ctx = c.var.ctx;
+    const { id } = c.req.valid("param");
+    const { workspaceId, commitMessage } = c.req.valid("json");
+    const ws = await ctx.ensureWorkspace(workspaceId);
+    const result = await commitAndMergeCompanionService(
+      id,
+      ws.repoPath,
+      commitMessage,
+      ctx.getScheduler(workspaceId)
+    );
+    return c.json(result);
+  }
+).post(
+  "/:id/commit-and-pr",
+  zv("param", z7.object({ id: z7.string() })),
+  zv(
+    "json",
+    z7.object({
+      workspaceId: z7.string(),
+      commitMessage: z7.string().optional(),
+      title: z7.string(),
+      description: z7.string(),
+      baseRef: z7.string().optional()
+    })
+  ),
+  async (c) => {
+    const { id } = c.req.valid("param");
+    const { workspaceId, commitMessage, title, description, baseRef } = c.req.valid("json");
+    const result = await commitAndPRCompanionService(id, workspaceId, commitMessage, title, description, baseRef);
+    return c.json(result);
+  }
+).post(
+  "/:id/canvas",
+  zv("param", z7.object({ id: z7.string() })),
+  zv("json", z7.object({ workspaceId: z7.string(), blocks: z7.array(canvasBlockSchema) })),
+  async (c) => {
+    const ctx = c.var.ctx;
+    const { id } = c.req.valid("param");
+    const { workspaceId, blocks } = c.req.valid("json");
+    const canvas = await createCompanionCanvasEntry(id, workspaceId, blocks);
+    ctx.stateHub.broadcastCompanionCanvasUpdate(workspaceId, id, canvas);
+    return c.json(canvas);
+  }
+).get("/:id/canvases", zv("param", z7.object({ id: z7.string() })), async (c) => {
+  const { id } = c.req.valid("param");
+  return c.json(await listCompanionCanvasesEntry(id));
+}).delete("/:id/canvases", zv("param", z7.object({ id: z7.string() })), async (c) => {
+  const { id } = c.req.valid("param");
+  await clearCompanionCanvasesEntry(id);
+  return c.json({ ok: true });
+}).post(
+  "/:id/save-canvas",
+  zv("param", z7.object({ id: z7.string() })),
+  zv("json", z7.object({ workspaceId: z7.string(), title: z7.string(), blocks: z7.array(canvasBlockSchema) })),
+  async (c) => {
+    const { id } = c.req.valid("param");
+    const { workspaceId, title, blocks } = c.req.valid("json");
+    const saved = await saveCompanionCanvasEntry(id, workspaceId, title, blocks);
+    return c.json(saved);
+  }
+);
+
 // src/api/routes/config.ts
 init_api_contract();
 
@@ -26605,20 +27613,20 @@ var configController = new Hono2().get("/", async (c) => {
 });
 
 // src/api/routes/fs.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 
 // src/api/services/fs-service.ts
 init_runtime_config();
-import { spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync12, readdirSync as readdirSync2, statSync } from "node:fs";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import { existsSync as existsSync13, readdirSync as readdirSync2, statSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname7, join as join19, resolve as resolve3 } from "node:path";
+import { dirname as dirname7, join as join20, resolve as resolve3 } from "node:path";
 
 // src/core/terminal-apps.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync11 } from "node:fs";
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 var MACOS_TERMINALS = [
   { bundle: "Terminal", label: "Terminal" },
   { bundle: "iTerm", label: "iTerm" },
@@ -26650,13 +27658,13 @@ function appExists(bundle) {
     `/Applications/${bundle}.app`,
     `/System/Applications/${bundle}.app`,
     `/System/Applications/Utilities/${bundle}.app`,
-    join18(homedir3(), "Applications", `${bundle}.app`)
+    join19(homedir3(), "Applications", `${bundle}.app`)
   ];
-  return paths.some((p2) => existsSync11(p2));
+  return paths.some((p2) => existsSync12(p2));
 }
 function binaryExists(bin) {
   const finder = process.platform === "win32" ? "where" : "which";
-  const r = spawnSync7(finder, [bin], { stdio: ["ignore", "pipe", "ignore"], encoding: "utf-8" });
+  const r = spawnSync8(finder, [bin], { stdio: ["ignore", "pipe", "ignore"], encoding: "utf-8" });
   return r.status === 0 && r.stdout.trim().length > 0;
 }
 function listTerminalApps() {
@@ -26671,26 +27679,26 @@ function listTerminalApps() {
 function openTerminalAt(path2, preferredId) {
   if (process.platform === "darwin") {
     const bundle = preferredId && appExists(preferredId) ? preferredId : "Terminal";
-    spawnSync7("open", ["-a", bundle, path2], { stdio: "ignore" });
+    spawnSync8("open", ["-a", bundle, path2], { stdio: "ignore" });
     return;
   }
   if (process.platform === "win32") {
     const id = preferredId && WINDOWS_TERMINALS.some((t) => t.id === preferredId && binaryExists(t.check)) ? preferredId : "cmd";
     if (id === "wt") {
-      spawnSync7("wt", ["-d", path2], { stdio: "ignore" });
+      spawnSync8("wt", ["-d", path2], { stdio: "ignore" });
     } else if (id === "powershell") {
-      spawnSync7("cmd", ["/c", "start", "powershell", "-NoExit", "-Command", `Set-Location -Path '${path2}'`], {
+      spawnSync8("cmd", ["/c", "start", "powershell", "-NoExit", "-Command", `Set-Location -Path '${path2}'`], {
         stdio: "ignore"
       });
     } else {
-      spawnSync7("cmd", ["/c", "start", "cmd", "/K", `cd /D "${path2}"`], { stdio: "ignore" });
+      spawnSync8("cmd", ["/c", "start", "cmd", "/K", `cd /D "${path2}"`], { stdio: "ignore" });
     }
     return;
   }
   const bin = preferredId && binaryExists(preferredId) ? preferredId : LINUX_TERMINALS.find((t) => binaryExists(t.bin))?.bin;
   if (!bin) return;
   const args = linuxLaunchArgs(bin, path2);
-  spawnSync7(bin, args, { stdio: "ignore" });
+  spawnSync8(bin, args, { stdio: "ignore" });
 }
 function linuxLaunchArgs(bin, path2) {
   switch (bin) {
@@ -26716,7 +27724,7 @@ function linuxLaunchArgs(bin, path2) {
 // src/api/services/fs-service.ts
 var openPath = (path2) => {
   const cmd = process.platform === "win32" ? "explorer" : process.platform === "darwin" ? "open" : "xdg-open";
-  spawnSync8(cmd, [path2], { stdio: "ignore" });
+  spawnSync9(cmd, [path2], { stdio: "ignore" });
   return { ok: true };
 };
 var listTerminals = async () => listTerminalApps();
@@ -26727,15 +27735,15 @@ var openTerminal = async (path2) => {
 };
 var listDir = async (path2, includeFiles, showHidden) => {
   let target = resolve3(path2 || homedir4());
-  while (target !== dirname7(target) && !(existsSync12(target) && statSync(target).isDirectory())) {
+  while (target !== dirname7(target) && !(existsSync13(target) && statSync(target).isDirectory())) {
     target = dirname7(target);
   }
   const parent = dirname7(target);
   const visible = (name) => showHidden || !name.startsWith(".");
   try {
     const entries = readdirSync2(target, { withFileTypes: true });
-    const dirs = entries.filter((e) => e.isDirectory() && visible(e.name)).map((e) => ({ name: e.name, path: join19(target, e.name) })).sort((a, b2) => a.name.localeCompare(b2.name));
-    const files = includeFiles ? entries.filter((e) => e.isFile() && visible(e.name)).map((e) => ({ name: e.name, path: join19(target, e.name) })).sort((a, b2) => a.name.localeCompare(b2.name)) : [];
+    const dirs = entries.filter((e) => e.isDirectory() && visible(e.name)).map((e) => ({ name: e.name, path: join20(target, e.name) })).sort((a, b2) => a.name.localeCompare(b2.name));
+    const files = includeFiles ? entries.filter((e) => e.isFile() && visible(e.name)).map((e) => ({ name: e.name, path: join20(target, e.name) })).sort((a, b2) => a.name.localeCompare(b2.name)) : [];
     return { current: target, parent: parent !== target ? parent : null, dirs, files };
   } catch {
     return { current: target, parent: parent !== target ? parent : null, dirs: [], files: [] };
@@ -26743,22 +27751,22 @@ var listDir = async (path2, includeFiles, showHidden) => {
 };
 
 // src/api/routes/fs.ts
-var fsController = new Hono2().post("/open", zv("json", z6.object({ path: z6.string() })), async (c) => {
+var fsController = new Hono2().post("/open", zv("json", z8.object({ path: z8.string() })), async (c) => {
   const { path: path2 } = c.req.valid("json");
   return c.json(openPath(path2));
 }).get("/terminals", async (c) => {
   return c.json(await listTerminals());
-}).post("/open-terminal", zv("json", z6.object({ path: z6.string() })), async (c) => {
+}).post("/open-terminal", zv("json", z8.object({ path: z8.string() })), async (c) => {
   const { path: path2 } = c.req.valid("json");
   return c.json(await openTerminal(path2));
 }).get(
   "/list-dir",
   zv(
     "query",
-    z6.object({
-      path: z6.string().optional().default(""),
-      includeFiles: z6.coerce.boolean().optional(),
-      showHidden: z6.coerce.boolean().optional()
+    z8.object({
+      path: z8.string().optional().default(""),
+      includeFiles: z8.coerce.boolean().optional(),
+      showHidden: z8.coerce.boolean().optional()
     })
   ),
   async (c) => {
@@ -26769,7 +27777,7 @@ var fsController = new Hono2().post("/open", zv("json", z6.object({ path: z6.str
 
 // src/api/routes/memory.ts
 init_api_contract();
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // src/api/services/memory-service.ts
 var listMemoryEntries = async (filter) => listMemories(filter);
@@ -26801,9 +27809,9 @@ var memoryController = new Hono2().get(
   "/",
   zv(
     "query",
-    z7.object({
+    z9.object({
       scope: memoryScopeSchema,
-      workspaceId: z7.string().optional(),
+      workspaceId: z9.string().optional(),
       status: memoryStatusSchema.optional()
     })
   ),
@@ -26817,33 +27825,33 @@ var memoryController = new Hono2().get(
       })
     );
   }
-).get("/search", zv("query", z7.object({ query: z7.string(), workspaceId: z7.string().optional() })), async (c) => {
+).get("/search", zv("query", z9.object({ query: z9.string(), workspaceId: z9.string().optional() })), async (c) => {
   const input = c.req.valid("query");
   return c.json(await searchMemoryEntries(input.query, input.workspaceId ?? null));
-}).get("/for-card", zv("query", z7.object({ cardId: z7.string() })), async (c) => {
+}).get("/for-card", zv("query", z9.object({ cardId: z9.string() })), async (c) => {
   const input = c.req.valid("query");
   return c.json(await listMemoryEntriesForCard(input.cardId));
-}).get("/tags", async (c) => c.json(await listTagsEntries())).get("/workspace-tags", zv("query", z7.object({ workspaceId: z7.string() })), async (c) => {
+}).get("/tags", async (c) => c.json(await listTagsEntries())).get("/workspace-tags", zv("query", z9.object({ workspaceId: z9.string() })), async (c) => {
   const { workspaceId } = c.req.valid("query");
   return c.json(await getWorkspaceTagsEntry(workspaceId));
-}).get("/:id", zv("param", z7.object({ id: z7.string() })), async (c) => {
+}).get("/:id", zv("param", z9.object({ id: z9.string() })), async (c) => {
   const { id } = c.req.valid("param");
   return c.json(await getMemoryEntry(id));
 }).post(
   "/propose",
   zv(
     "json",
-    z7.object({
+    z9.object({
       scope: memoryScopeSchema,
-      workspaceId: z7.string().optional(),
-      originWorkspaceId: z7.string().optional(),
+      workspaceId: z9.string().optional(),
+      originWorkspaceId: z9.string().optional(),
       type: memoryTypeSchema,
-      title: z7.string().min(1),
-      content: z7.string().min(1),
+      title: z9.string().min(1),
+      content: z9.string().min(1),
       sourceType: memorySourceTypeSchema.default("task_lesson"),
-      importance: z7.number().int().min(1).max(3).optional(),
-      tags: z7.array(z7.string()).optional(),
-      originCardId: z7.string().optional(),
+      importance: z9.number().int().min(1).max(3).optional(),
+      tags: z9.array(z9.string()).optional(),
+      originCardId: z9.string().optional(),
       originAgent: runtimeMemoryOriginAgentSchema.optional()
     })
   ),
@@ -26875,12 +27883,12 @@ var memoryController = new Hono2().get(
   "/propose-update",
   zv(
     "json",
-    z7.object({
-      id: z7.string(),
+    z9.object({
+      id: z9.string(),
       type: memoryTypeSchema.optional(),
-      title: z7.string().min(1).optional(),
-      content: z7.string().min(1).optional(),
-      importance: z7.number().int().min(1).max(3).optional(),
+      title: z9.string().min(1).optional(),
+      content: z9.string().min(1).optional(),
+      importance: z9.number().int().min(1).max(3).optional(),
       sourceType: memorySourceTypeSchema.default("task_lesson")
     })
   ),
@@ -26894,16 +27902,16 @@ var memoryController = new Hono2().get(
   "/",
   zv(
     "json",
-    z7.object({
+    z9.object({
       scope: memoryScopeSchema,
-      workspaceId: z7.string().optional(),
-      originWorkspaceId: z7.string().optional(),
+      workspaceId: z9.string().optional(),
+      originWorkspaceId: z9.string().optional(),
       type: memoryTypeSchema,
-      title: z7.string().min(1),
-      content: z7.string().min(1),
-      importance: z7.number().int().min(1).max(3).optional(),
-      tags: z7.array(z7.string()).optional(),
-      boundWorkspaceIds: z7.array(z7.string()).optional()
+      title: z9.string().min(1),
+      content: z9.string().min(1),
+      importance: z9.number().int().min(1).max(3).optional(),
+      tags: z9.array(z9.string()).optional(),
+      boundWorkspaceIds: z9.array(z9.string()).optional()
     })
   ),
   async (c) => {
@@ -26932,14 +27940,14 @@ var memoryController = new Hono2().get(
   }
 ).patch(
   "/:id",
-  zv("param", z7.object({ id: z7.string() })),
+  zv("param", z9.object({ id: z9.string() })),
   zv(
     "json",
-    z7.object({
+    z9.object({
       type: memoryTypeSchema.optional(),
-      title: z7.string().min(1).optional(),
-      content: z7.string().min(1).optional(),
-      importance: z7.number().int().min(1).max(3).optional()
+      title: z9.string().min(1).optional(),
+      content: z9.string().min(1).optional(),
+      importance: z9.number().int().min(1).max(3).optional()
     })
   ),
   async (c) => {
@@ -26948,19 +27956,19 @@ var memoryController = new Hono2().get(
     if (!updated) throw NotFoundError("Memory");
     return c.json(updated);
   }
-).post("/:id/approve", zv("param", z7.object({ id: z7.string() })), async (c) => {
+).post("/:id/approve", zv("param", z9.object({ id: z9.string() })), async (c) => {
   const { id } = c.req.valid("param");
   const approved = await approveMemoryEntry(id);
   if (!approved) throw NotFoundError("Memory");
   return c.json(approved);
-}).delete("/:id", zv("param", z7.object({ id: z7.string() })), async (c) => {
+}).delete("/:id", zv("param", z9.object({ id: z9.string() })), async (c) => {
   const { id } = c.req.valid("param");
   await removeMemoryEntry(id);
   return c.json({ ok: true });
 }).patch(
   "/:id/tags",
-  zv("param", z7.object({ id: z7.string() })),
-  zv("json", z7.object({ tags: z7.array(z7.string()) })),
+  zv("param", z9.object({ id: z9.string() })),
+  zv("json", z9.object({ tags: z9.array(z9.string()) })),
   async (c) => {
     const { id } = c.req.valid("param");
     const { tags } = c.req.valid("json");
@@ -26970,8 +27978,8 @@ var memoryController = new Hono2().get(
   }
 ).patch(
   "/:id/bindings",
-  zv("param", z7.object({ id: z7.string() })),
-  zv("json", z7.object({ workspaceIds: z7.array(z7.string()) })),
+  zv("param", z9.object({ id: z9.string() })),
+  zv("json", z9.object({ workspaceIds: z9.array(z9.string()) })),
   async (c) => {
     const { id } = c.req.valid("param");
     const { workspaceIds } = c.req.valid("json");
@@ -26979,7 +27987,7 @@ var memoryController = new Hono2().get(
     if (!updated) throw NotFoundError("Memory");
     return c.json(updated);
   }
-).put("/workspace-tags", zv("json", z7.object({ workspaceId: z7.string(), tags: z7.array(z7.string()) })), async (c) => {
+).put("/workspace-tags", zv("json", z9.object({ workspaceId: z9.string(), tags: z9.array(z9.string()) })), async (c) => {
   const { workspaceId, tags } = c.req.valid("json");
   await setWorkspaceTagsEntry(workspaceId, tags);
   return c.json({ ok: true });
@@ -26987,7 +27995,7 @@ var memoryController = new Hono2().get(
 
 // src/api/routes/project-config.ts
 init_api_contract();
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 
 // src/api/services/project-config-service.ts
 init_workspace_state();
@@ -27007,21 +28015,21 @@ var setSystemPrompt = async (workspaceId, prompt) => {
 };
 
 // src/api/routes/project-config.ts
-var projectConfigController = new Hono2().get("/", zv("query", z8.object({ workspaceId: z8.string() })), async (c) => {
+var projectConfigController = new Hono2().get("/", zv("query", z10.object({ workspaceId: z10.string() })), async (c) => {
   return c.json(await getProjectConfig(c.req.valid("query").workspaceId));
-}).put("/", zv("json", z8.object({ workspaceId: z8.string(), config: runtimeProjectConfigSchema })), async (c) => {
+}).put("/", zv("json", z10.object({ workspaceId: z10.string(), config: runtimeProjectConfigSchema })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, config } = c.req.valid("json");
   await saveProjectConfig2(workspaceId, config);
   ctx.stateHub.broadcastWorkspaceUpdate(workspaceId);
   return c.json({ ok: true });
-}).post("/git-instructions", zv("json", z8.object({ workspaceId: z8.string(), instructions: z8.string() })), async (c) => {
+}).post("/git-instructions", zv("json", z10.object({ workspaceId: z10.string(), instructions: z10.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, instructions } = c.req.valid("json");
   const { cleared } = await setGitInstructions(workspaceId, instructions);
   ctx.stateHub.broadcastWorkspaceUpdate(workspaceId);
   return c.json({ ok: true, cleared });
-}).post("/system-prompt", zv("json", z8.object({ workspaceId: z8.string(), prompt: z8.string() })), async (c) => {
+}).post("/system-prompt", zv("json", z10.object({ workspaceId: z10.string(), prompt: z10.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, prompt } = c.req.valid("json");
   const { cleared } = await setSystemPrompt(workspaceId, prompt);
@@ -27031,12 +28039,12 @@ var projectConfigController = new Hono2().get("/", zv("query", z8.object({ works
 
 // src/api/routes/projects.ts
 init_api_contract();
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 
 // src/api/services/projects-service.ts
 init_runtime_config();
 init_api_contract();
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 init_logger();
 
 // src/state/projects-layout.ts
@@ -27119,7 +28127,7 @@ var checkProjectPath = async (repoPath) => {
       branches: []
     };
   }
-  const r = spawnSync9("git", ["rev-parse", "--git-dir"], {
+  const r = spawnSync10("git", ["rev-parse", "--git-dir"], {
     cwd: repoPath,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -27135,12 +28143,12 @@ var checkProjectPath = async (repoPath) => {
       remote: null,
       branches: []
     };
-  const branchR = spawnSync9("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  const branchR = spawnSync10("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     cwd: repoPath,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"]
   });
-  const remoteR = spawnSync9("git", ["remote", "get-url", "origin"], {
+  const remoteR = spawnSync10("git", ["remote", "get-url", "origin"], {
     cwd: repoPath,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -27159,7 +28167,7 @@ var addProject = async (repoPath, initialConfig) => {
   } catch {
     throw BadRequestError(`Path does not exist: ${repoPath}`);
   }
-  const r = spawnSync9("git", ["rev-parse", "--git-dir"], {
+  const r = spawnSync10("git", ["rev-parse", "--git-dir"], {
     cwd: repoPath,
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"]
@@ -27191,7 +28199,7 @@ var removeProject = async (workspaceId) => {
     const cards = boardCards;
     enqueueCleanup2(async () => {
       const { rm: rm3 } = await import("node:fs/promises");
-      const { join: join23 } = await import("node:path");
+      const { join: join24 } = await import("node:path");
       for (const [cardId, card] of Object.entries(cards)) {
         if (resolveWorktreeOwnerId(cardId, cards) === cardId) {
           await removeWorktreeAsync(cardId, repoPath, card.branchName).catch((err) => {
@@ -27199,11 +28207,11 @@ var removeProject = async (workspaceId) => {
           });
         }
       }
-      await rm3(join23(WORKSPACES_DIR, workspaceId), { recursive: true, force: true }).catch((err) => {
+      await rm3(join24(WORKSPACES_DIR, workspaceId), { recursive: true, force: true }).catch((err) => {
         logger.warn(`[cleanup:project:${workspaceId}] workspace dir failed: ${String(err)}`);
       });
       for (const cardId of Object.keys(cards)) {
-        await rm3(join23(ATTACHMENTS_DIR, cardId), { recursive: true, force: true }).catch(() => {
+        await rm3(join24(ATTACHMENTS_DIR, cardId), { recursive: true, force: true }).catch(() => {
         });
       }
       logger.info(`[cleanup:project:${workspaceId}] done`);
@@ -27217,14 +28225,14 @@ var projectsController = new Hono2().get("/", async (c) => {
   return c.json(await listProjects());
 }).get("/layout", (c) => {
   return c.json(getProjectsLayout());
-}).get("/check-path", zv("query", z9.object({ repoPath: z9.string() })), async (c) => {
+}).get("/check-path", zv("query", z11.object({ repoPath: z11.string() })), async (c) => {
   return c.json(await checkProjectPath(c.req.valid("query").repoPath));
 }).post(
   "/",
   zv(
     "json",
-    z9.object({
-      repoPath: z9.string().min(1),
+    z11.object({
+      repoPath: z11.string().min(1),
       initialConfig: runtimeProjectConfigSchema.partial().optional()
     })
   ),
@@ -27251,7 +28259,7 @@ var projectsController = new Hono2().get("/", async (c) => {
 
 // src/api/routes/recurring-agents.ts
 init_api_contract();
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 
 // src/api/services/recurring-agents-service.ts
 function listRecurringAgentsEntry(workspaceId) {
@@ -27276,20 +28284,20 @@ function setRecurringAgentJournalEntry(id, journal) {
 }
 
 // src/api/routes/recurring-agents.ts
-var recurringAgentsController = new Hono2().get("/", zv("query", z10.object({ workspaceId: z10.string() })), async (c) => {
+var recurringAgentsController = new Hono2().get("/", zv("query", z12.object({ workspaceId: z12.string() })), async (c) => {
   const { workspaceId } = c.req.valid("query");
   return c.json(listRecurringAgentsEntry(workspaceId));
-}).get("/:id", zv("param", z10.object({ id: z10.string() })), async (c) => {
+}).get("/:id", zv("param", z12.object({ id: z12.string() })), async (c) => {
   const { id } = c.req.valid("param");
   const agent = getRecurringAgentEntry(id);
   if (!agent) throw NotFoundError("Recurring agent");
   return c.json(agent);
-}).post("/", zv("json", recurringAgentCreateRequestSchema.extend({ workspaceId: z10.string() })), async (c) => {
+}).post("/", zv("json", recurringAgentCreateRequestSchema.extend({ workspaceId: z12.string() })), async (c) => {
   const { workspaceId, ...req } = c.req.valid("json");
   return c.json(createRecurringAgentEntry(workspaceId, req));
 }).patch(
   "/:id",
-  zv("param", z10.object({ id: z10.string() })),
+  zv("param", z12.object({ id: z12.string() })),
   zv("json", recurringAgentUpdateRequestSchema.omit({ id: true })),
   async (c) => {
     const { id } = c.req.valid("param");
@@ -27299,8 +28307,8 @@ var recurringAgentsController = new Hono2().get("/", zv("query", z10.object({ wo
   }
 ).post(
   "/:id/journal",
-  zv("param", z10.object({ id: z10.string() })),
-  zv("json", z10.object({ journal: z10.string() })),
+  zv("param", z12.object({ id: z12.string() })),
+  zv("json", z12.object({ journal: z12.string() })),
   async (c) => {
     const { id } = c.req.valid("param");
     const { journal } = c.req.valid("json");
@@ -27310,8 +28318,8 @@ var recurringAgentsController = new Hono2().get("/", zv("query", z10.object({ wo
   }
 ).post(
   "/:id/run",
-  zv("param", z10.object({ id: z10.string() })),
-  zv("query", z10.object({ workspaceId: z10.string() })),
+  zv("param", z12.object({ id: z12.string() })),
+  zv("query", z12.object({ workspaceId: z12.string() })),
   async (c) => {
     const { id } = c.req.valid("param");
     const { workspaceId } = c.req.valid("query");
@@ -27320,14 +28328,14 @@ var recurringAgentsController = new Hono2().get("/", zv("query", z10.object({ wo
     const started = await scheduler?.runNow(id) ?? false;
     return c.json({ started });
   }
-).delete("/:id", zv("param", z10.object({ id: z10.string() })), async (c) => {
+).delete("/:id", zv("param", z12.object({ id: z12.string() })), async (c) => {
   const { id } = c.req.valid("param");
   deleteRecurringAgentEntry(id);
   return c.json({ ok: true });
 });
 
 // src/api/routes/run.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // src/api/services/run-service.ts
 init_workspace_state();
@@ -27343,15 +28351,19 @@ var resolveCardCwd = async (workspaceId, cardId, repoPath) => {
   if (!card) return null;
   return card.worktreePath ?? repoPath;
 };
+var resolveCompanionSessionCwd = (sessionId) => {
+  const session = getCompanionSession(sessionId);
+  return session?.worktreePath ?? null;
+};
 
 // src/api/routes/run.ts
-var runController = new Hono2().get("/status", zv("query", z11.object({ workspaceId: z11.string() })), (c) => {
+var runController = new Hono2().get("/status", zv("query", z13.object({ workspaceId: z13.string() })), (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("query");
   const session = ctx.getRunSession(workspaceId);
   if (!session) return c.json({ cardId: null, status: "stopped", errorMessage: void 0 });
   return c.json({ cardId: session.cardId, status: session.status, errorMessage: session.errorMessage });
-}).post("/start", zv("json", z11.object({ workspaceId: z11.string(), cardId: z11.string() })), async (c) => {
+}).post("/start", zv("json", z13.object({ workspaceId: z13.string(), cardId: z13.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, cardId } = c.req.valid("json");
   const ws = await ctx.ensureWorkspace(workspaceId);
@@ -27363,7 +28375,18 @@ var runController = new Hono2().get("/status", zv("query", z11.object({ workspac
   if (cwd === null) throw NotFoundError("Card");
   ctx.startRun(workspaceId, cardId, command, cwd);
   return c.json({ ok: true });
-}).post("/start-base", zv("json", z11.object({ workspaceId: z11.string() })), async (c) => {
+}).post("/start-companion", zv("json", z13.object({ workspaceId: z13.string(), sessionId: z13.string() })), async (c) => {
+  const ctx = c.var.ctx;
+  const { workspaceId, sessionId } = c.req.valid("json");
+  const command = await resolveStartCommand(workspaceId);
+  if (!command) {
+    throw PreconditionFailedError("No start command configured. Add one in Settings \u2192 Environment.");
+  }
+  const cwd = resolveCompanionSessionCwd(sessionId);
+  if (cwd === null) throw NotFoundError("Companion session");
+  ctx.startRun(workspaceId, sessionId, command, cwd);
+  return c.json({ ok: true });
+}).post("/start-base", zv("json", z13.object({ workspaceId: z13.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("json");
   const ws = await ctx.ensureWorkspace(workspaceId);
@@ -27373,7 +28396,7 @@ var runController = new Hono2().get("/status", zv("query", z11.object({ workspac
   }
   ctx.startRun(workspaceId, null, command, ws.repoPath);
   return c.json({ ok: true });
-}).post("/stop", zv("json", z11.object({ workspaceId: z11.string() })), (c) => {
+}).post("/stop", zv("json", z13.object({ workspaceId: z13.string() })), (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("json");
   ctx.stopRun(workspaceId);
@@ -27381,7 +28404,7 @@ var runController = new Hono2().get("/status", zv("query", z11.object({ workspac
 });
 
 // src/api/routes/slack.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 
 // src/api/services/slack-service.ts
 init_runtime_config();
@@ -27428,20 +28451,20 @@ var createApp = async (appConfigToken, publicUrl, botName) => {
 var slackController = new Hono2().post("/resetApp", async (c) => {
   await resetApp();
   return c.json({ ok: true });
-}).post("/updateSigningSecret", zv("json", z12.object({ signingSecret: z12.string().min(1) })), async (c) => {
+}).post("/updateSigningSecret", zv("json", z14.object({ signingSecret: z14.string().min(1) })), async (c) => {
   await updateSigningSecret(c.req.valid("json").signingSecret);
   return c.json({ ok: true });
 }).post(
   "/importCredentials",
   zv(
     "json",
-    z12.object({
-      slackAppId: z12.string(),
-      slackClientId: z12.string(),
-      slackClientSecret: z12.string(),
-      slackSigningSecret: z12.string(),
-      slackOauthAuthorizeUrl: z12.string(),
-      slackPublicUrl: z12.string()
+    z14.object({
+      slackAppId: z14.string(),
+      slackClientId: z14.string(),
+      slackClientSecret: z14.string(),
+      slackSigningSecret: z14.string(),
+      slackOauthAuthorizeUrl: z14.string(),
+      slackPublicUrl: z14.string()
     })
   ),
   async (c) => {
@@ -27450,7 +28473,7 @@ var slackController = new Hono2().post("/resetApp", async (c) => {
   }
 ).post(
   "/createApp",
-  zv("json", z12.object({ appConfigToken: z12.string(), publicUrl: z12.string(), botName: z12.string().default("Whipped") })),
+  zv("json", z14.object({ appConfigToken: z14.string(), publicUrl: z14.string(), botName: z14.string().default("Whipped") })),
   async (c) => {
     const { appConfigToken, publicUrl, botName } = c.req.valid("json");
     return c.json(await createApp(appConfigToken, publicUrl, botName));
@@ -27458,27 +28481,27 @@ var slackController = new Hono2().post("/resetApp", async (c) => {
 );
 
 // src/api/routes/terminal.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/api/services/terminal-service.ts
 var toBufferResponse = (buffer) => ({ data: buffer ?? "" });
 
 // src/api/routes/terminal.ts
-var terminalController = new Hono2().get("/buffer", zv("query", z13.object({ workspaceId: z13.string(), taskId: z13.string() })), (c) => {
+var terminalController = new Hono2().get("/buffer", zv("query", z15.object({ workspaceId: z15.string(), taskId: z15.string() })), (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, taskId } = c.req.valid("query");
   const buf = ctx.getScheduler(workspaceId)?.getOutputBuffer(taskId);
   return c.json(toBufferResponse(buf));
 }).post(
   "/resize",
-  zv("json", z13.object({ workspaceId: z13.string(), taskId: z13.string(), cols: z13.number(), rows: z13.number() })),
+  zv("json", z15.object({ workspaceId: z15.string(), taskId: z15.string(), cols: z15.number(), rows: z15.number() })),
   (c) => {
     const ctx = c.var.ctx;
     const { workspaceId, taskId, cols, rows } = c.req.valid("json");
     ctx.getScheduler(workspaceId)?.resizeTerminal(taskId, cols, rows);
     return c.json({ ok: true });
   }
-).post("/input", zv("json", z13.object({ workspaceId: z13.string(), taskId: z13.string(), data: z13.string() })), (c) => {
+).post("/input", zv("json", z15.object({ workspaceId: z15.string(), taskId: z15.string(), data: z15.string() })), (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, taskId, data } = c.req.valid("json");
   ctx.getScheduler(workspaceId)?.writeToTerminal(taskId, data);
@@ -27486,7 +28509,7 @@ var terminalController = new Hono2().get("/buffer", zv("query", z13.object({ wor
 });
 
 // src/api/routes/tunnel.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 
 // src/api/services/tunnel-service.ts
 init_runtime_config();
@@ -27495,12 +28518,12 @@ init_runtime_config();
 import { execFile as execFile9, spawn as spawn7 } from "node:child_process";
 import { mkdir as mkdir4, writeFile as writeFile3, readFile as readFile3, access, unlink as unlink4 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import { promisify as promisify9 } from "node:util";
 init_runtime_config();
 init_logger();
 var execFileAsync7 = promisify9(execFile9);
-var CLOUDFLARED_DIR = join20(homedir5(), ".cloudflared");
+var CLOUDFLARED_DIR = join21(homedir5(), ".cloudflared");
 async function checkCloudflaredInstalled() {
   try {
     const { stdout } = await execFileAsync7("cloudflared", ["--version"]);
@@ -27512,7 +28535,7 @@ async function checkCloudflaredInstalled() {
 }
 async function checkCloudflaredAuth() {
   try {
-    await access(join20(CLOUDFLARED_DIR, "cert.pem"));
+    await access(join21(CLOUDFLARED_DIR, "cert.pem"));
     return true;
   } catch {
     return false;
@@ -27523,7 +28546,7 @@ async function openCloudflaredLogin(force = false) {
   if (alreadyLoggedIn && !force) return { alreadyLoggedIn: true };
   if (force) {
     try {
-      await unlink4(join20(CLOUDFLARED_DIR, "cert.pem"));
+      await unlink4(join21(CLOUDFLARED_DIR, "cert.pem"));
     } catch {
     }
   }
@@ -27592,7 +28615,7 @@ async function createTunnel(tunnelName) {
   }
 }
 async function writeTunnelConfig(tunnelId, tunnelName, domain) {
-  const credentialsFile = join20(CLOUDFLARED_DIR, `${tunnelId}.json`);
+  const credentialsFile = join21(CLOUDFLARED_DIR, `${tunnelId}.json`);
   const config = [
     `tunnel: ${tunnelId}`,
     `credentials-file: ${credentialsFile}`,
@@ -27603,12 +28626,12 @@ async function writeTunnelConfig(tunnelId, tunnelName, domain) {
     `  - service: http_status:404`
   ].join("\n");
   await mkdir4(CLOUDFLARED_DIR, { recursive: true });
-  await writeFile3(join20(CLOUDFLARED_DIR, "config.yml"), config, "utf-8");
+  await writeFile3(join21(CLOUDFLARED_DIR, "config.yml"), config, "utf-8");
   logger.info(`[tunnel-setup] Wrote ~/.cloudflared/config.yml for tunnel ${tunnelName}`);
 }
 async function readTunnelConfig() {
   try {
-    const raw2 = await readFile3(join20(CLOUDFLARED_DIR, "config.yml"), "utf-8");
+    const raw2 = await readFile3(join21(CLOUDFLARED_DIR, "config.yml"), "utf-8");
     const tunnelMatch = raw2.match(/^tunnel:\s*(.+)$/m);
     const hostnameMatch = raw2.match(/hostname:\s*(.+)$/m);
     return {
@@ -27657,9 +28680,9 @@ var resetTunnel = async () => {
   await updateGlobalConfig({ tunnelId: void 0, tunnelDomain: void 0, autoStartTunnel: false });
   const { unlink: unlink5 } = await import("node:fs/promises");
   const { homedir: homedir6 } = await import("node:os");
-  const { join: join23 } = await import("node:path");
+  const { join: join24 } = await import("node:path");
   try {
-    await unlink5(join23(homedir6(), ".cloudflared", "config.yml"));
+    await unlink5(join24(homedir6(), ".cloudflared", "config.yml"));
   } catch {
   }
 };
@@ -27671,9 +28694,9 @@ var tunnelController = new Hono2().get("/checkCloudflared", async (c) => {
   return c.json(await getTunnelConfig());
 }).get("/tunnelStatus", async (c) => {
   return c.json(await getTunnelStatus());
-}).post("/cloudflaredLogin", zv("json", z14.object({ force: z14.boolean().default(false) })), async (c) => {
+}).post("/cloudflaredLogin", zv("json", z16.object({ force: z16.boolean().default(false) })), async (c) => {
   return c.json(await cloudflaredLogin(c.req.valid("json").force));
-}).post("/createTunnel", zv("json", z14.object({ domain: z14.string() })), async (c) => {
+}).post("/createTunnel", zv("json", z16.object({ domain: z16.string() })), async (c) => {
   return c.json(await createTunnel2(c.req.valid("json").domain));
 }).post("/startTunnel", async (c) => {
   return c.json(await startTunnel());
@@ -27686,11 +28709,11 @@ var tunnelController = new Hono2().get("/checkCloudflared", async (c) => {
 
 // src/api/routes/workflows.ts
 init_api_contract();
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 
 // src/api/services/workflows-service.ts
 init_workspace_state();
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
 import { dirname as dirname8, isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
 var resolvePromptPath = async (workspaceId, requestedPath) => {
@@ -27735,22 +28758,22 @@ var writePromptFile = async (workspaceId, path2, content) => {
 };
 var readPromptFile = async (workspaceId, path2) => {
   const targetPath = await resolvePromptPath(workspaceId, path2);
-  if (!existsSync13(targetPath)) return { content: "", exists: false };
+  if (!existsSync14(targetPath)) return { content: "", exists: false };
   const content = await readFile4(targetPath, "utf-8");
   return { content, exists: true };
 };
 
 // src/api/routes/workflows.ts
-var workflowsController = new Hono2().get("/", zv("query", z15.object({ workspaceId: z15.string() })), async (c) => {
+var workflowsController = new Hono2().get("/", zv("query", z17.object({ workspaceId: z17.string() })), async (c) => {
   const { workspaceId } = c.req.valid("query");
   return c.json(await listWorkflows(workspaceId));
-}).post("/", zv("json", z15.object({ workspaceId: z15.string(), workflow: workflowSchema })), async (c) => {
+}).post("/", zv("json", z17.object({ workspaceId: z17.string(), workflow: workflowSchema })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId, workflow } = c.req.valid("json");
   const result = await upsertWorkflow(workspaceId, workflow);
   ctx.stateHub.broadcastWorkspaceUpdate(workspaceId);
   return c.json(result);
-}).delete("/:workflowId", zv("query", z15.object({ workspaceId: z15.string() })), async (c) => {
+}).delete("/:workflowId", zv("query", z17.object({ workspaceId: z17.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("query");
   const workflowId = c.req.param("workflowId");
@@ -27759,23 +28782,23 @@ var workflowsController = new Hono2().get("/", zv("query", z15.object({ workspac
   return c.json(result);
 }).post(
   "/prompt-file",
-  zv("json", z15.object({ workspaceId: z15.string(), path: z15.string().min(1), content: z15.string() })),
+  zv("json", z17.object({ workspaceId: z17.string(), path: z17.string().min(1), content: z17.string() })),
   async (c) => {
     const { workspaceId, path: path2, content } = c.req.valid("json");
     return c.json(await writePromptFile(workspaceId, path2, content));
   }
-).get("/prompt-file", zv("query", z15.object({ workspaceId: z15.string(), path: z15.string().min(1) })), async (c) => {
+).get("/prompt-file", zv("query", z17.object({ workspaceId: z17.string(), path: z17.string().min(1) })), async (c) => {
   const { workspaceId, path: path2 } = c.req.valid("query");
   return c.json(await readPromptFile(workspaceId, path2));
 });
 
 // src/api/routes/workspace.ts
 init_api_contract();
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // src/api/services/workspace-service.ts
 init_workspace_state();
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 var loadStateForWorkspace = async (workspaceId) => {
   const workspaces = await listWorkspaces();
   const ws = workspaces.find((w2) => w2.workspaceId === workspaceId);
@@ -27785,12 +28808,12 @@ var loadStateForWorkspace = async (workspaceId) => {
 var loadStateForContext = async (workspaceId, repoPath) => loadWorkspaceState(workspaceId, repoPath);
 var saveState = async (workspaceId, request2) => saveWorkspaceState(workspaceId, request2);
 var listRootFiles = (repoPath) => {
-  const ignored = spawnSync10(
+  const ignored = spawnSync11(
     "git",
     ["ls-files", "--others", "--ignored", "--exclude-standard", "--directory", "--no-empty-directory"],
     { cwd: repoPath, encoding: "utf-8" }
   );
-  const untracked = spawnSync10("git", ["ls-files", "--others", "--exclude-standard"], {
+  const untracked = spawnSync11("git", ["ls-files", "--others", "--exclude-standard"], {
     cwd: repoPath,
     encoding: "utf-8"
   });
@@ -27799,7 +28822,7 @@ var listRootFiles = (repoPath) => {
 };
 
 // src/api/routes/workspace.ts
-var workspaceController = new Hono2().get("/state", zv("query", z16.object({ workspaceId: z16.string().optional() })), async (c) => {
+var workspaceController = new Hono2().get("/state", zv("query", z18.object({ workspaceId: z18.string().optional() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("query");
   if (workspaceId) {
@@ -27807,10 +28830,10 @@ var workspaceController = new Hono2().get("/state", zv("query", z16.object({ wor
   }
   if (!ctx.currentWorkspaceId || !ctx.currentRepoPath) throw BadRequestError("No workspace context");
   return c.json(await loadStateForContext(ctx.currentWorkspaceId, ctx.currentRepoPath));
-}).post("/save", zv("json", runtimeWorkspaceStateSaveRequestSchema.extend({ workspaceId: z16.string() })), async (c) => {
+}).post("/save", zv("json", runtimeWorkspaceStateSaveRequestSchema.extend({ workspaceId: z18.string() })), async (c) => {
   const { workspaceId, board, revision } = c.req.valid("json");
   return c.json(await saveState(workspaceId, { board, revision }));
-}).get("/root-files", zv("query", z16.object({ workspaceId: z16.string() })), async (c) => {
+}).get("/root-files", zv("query", z18.object({ workspaceId: z18.string() })), async (c) => {
   const ctx = c.var.ctx;
   const { workspaceId } = c.req.valid("query");
   const ws = await ctx.ensureWorkspace(workspaceId);
@@ -27822,7 +28845,7 @@ function createApiApp(ctx) {
   const app = new Hono2().basePath("/api").use("*", async (c, next) => {
     c.set("ctx", ctx);
     await next();
-  }).get("/health", (c) => c.json({ ok: true })).route("/auth", authController).route("/agent", agentController).route("/agents", agentsController).route("/cards", cardsController).route("/config", configController).route("/fs", fsController).route("/memory", memoryController).route("/project-config", projectConfigController).route("/projects", projectsController).route("/recurring-agents", recurringAgentsController).route("/run", runController).route("/slack", slackController).route("/terminal", terminalController).route("/tunnel", tunnelController).route("/workflows", workflowsController).route("/workspace", workspaceController);
+  }).get("/health", (c) => c.json({ ok: true })).route("/auth", authController).route("/agent", agentController).route("/agents", agentsController).route("/cards", cardsController).route("/companion-saved-canvases", companionSavedCanvasesController).route("/companion-sessions", companionSessionsController).route("/config", configController).route("/fs", fsController).route("/memory", memoryController).route("/project-config", projectConfigController).route("/projects", projectsController).route("/recurring-agents", recurringAgentsController).route("/run", runController).route("/slack", slackController).route("/terminal", terminalController).route("/tunnel", tunnelController).route("/workflows", workflowsController).route("/workspace", workspaceController);
   app.onError(errorHandler2);
   return app;
 }
@@ -27932,6 +28955,9 @@ var RuntimeStateHub = class {
   broadcastRunSessionChange(workspaceId, cardId, status, errorMessage) {
     this.broadcastToWorkspace(workspaceId, { type: "run_session_changed", cardId, status, errorMessage });
   }
+  broadcastCompanionCanvasUpdate(workspaceId, sessionId, canvas) {
+    this.broadcastToWorkspace(workspaceId, { type: "companion_canvas_updated", sessionId, canvas });
+  }
   broadcastToWorkspace(workspaceId, event) {
     const clientIds = this.workspaceClients.get(workspaceId);
     if (!clientIds) return;
@@ -27952,14 +28978,14 @@ var RuntimeStateHub = class {
 
 // src/core/update-check.ts
 init_paths();
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join21 } from "node:path";
-var CACHE_FILE = join21(WHIPPED_HOME_DIR, "update-check.json");
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join22 } from "node:path";
+var CACHE_FILE = join22(WHIPPED_HOME_DIR, "update-check.json");
 var REGISTRY_URL = "https://registry.npmjs.org/whipped/latest";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1e3;
 function readCache() {
   try {
-    return JSON.parse(readFileSync7(CACHE_FILE, "utf8"));
+    return JSON.parse(readFileSync8(CACHE_FILE, "utf8"));
   } catch {
     return null;
   }
@@ -28013,6 +29039,10 @@ async function cleanupStaleTasks(workspaceId, hub) {
   if (staleRecurring > 0) {
     logger.info(`[server] Cleared ${staleRecurring} stale recurring-agent run(s) for ${workspaceId}`);
   }
+  const staleCompanions = resetStaleCompanionSessions(workspaceId);
+  if (staleCompanions > 0) {
+    logger.info(`[server] Reset ${staleCompanions} stale companion session(s) for ${workspaceId}`);
+  }
   for (const card of Object.values(board.cards)) {
     if (card.terminalSessions?.some((s2) => s2.endedAt === void 0)) {
       await closeAllOpenTerminalSessions(workspaceId, card.id, now);
@@ -28241,9 +29271,9 @@ async function createRuntimeServer(options) {
     };
   }
   const apiApp = createApiApp(createContext());
-  const webUiDistPath = join22(__dirname2, "web-ui");
-  const webUiIndexPath = join22(webUiDistPath, "index.html");
-  const hasWebUi = existsSync14(webUiIndexPath);
+  const webUiDistPath = join23(__dirname2, "web-ui");
+  const webUiIndexPath = join23(webUiDistPath, "index.html");
+  const hasWebUi = existsSync15(webUiIndexPath);
   const httpServer = createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://${host}`);
     if (url.pathname === "/api/slack/oauth-callback") {
@@ -28476,7 +29506,7 @@ async function createRuntimeServer(options) {
         res.end("Bad request");
         return;
       }
-      const filePath = join22(ATTACHMENTS_DIR, cardId, filename);
+      const filePath = join23(ATTACHMENTS_DIR, cardId, filename);
       const { readFile: readFile5 } = await import("node:fs/promises");
       try {
         const data = await readFile5(filePath);
@@ -28551,15 +29581,15 @@ async function createRuntimeServer(options) {
       return;
     }
     if (hasWebUi) {
-      const filePath = url.pathname === "/" || !url.pathname.includes(".") ? webUiIndexPath : join22(webUiDistPath, url.pathname);
-      if (existsSync14(filePath)) {
-        const content = readFileSync8(filePath);
+      const filePath = url.pathname === "/" || !url.pathname.includes(".") ? webUiIndexPath : join23(webUiDistPath, url.pathname);
+      if (existsSync15(filePath)) {
+        const content = readFileSync9(filePath);
         res.writeHead(200, { "Content-Type": getContentType(filePath) });
         res.end(content);
         return;
       }
       res.writeHead(200, { "Content-Type": "text/html" });
-      res.end(readFileSync8(webUiIndexPath));
+      res.end(readFileSync9(webUiIndexPath));
       return;
     }
     res.writeHead(200, { "Content-Type": "text/plain" });
@@ -28632,15 +29662,17 @@ async function createRuntimeServer(options) {
       if (activeBuffer !== null) {
         if (activeBuffer && ws.readyState === 1) ws.send(prepareBufferForReplay(activeBuffer));
       } else {
-        const hubSnapshot = stateHub.getTerminalBuffer(workspaceId, taskId);
-        if (hubSnapshot) {
-          if (ws.readyState === 1) ws.send(prepareBufferForReplay(hubSnapshot));
-        } else {
-          loadTerminalBuffer(workspaceId, taskId).then((diskSnapshot) => {
-            if (diskSnapshot && ws.readyState === 1) ws.send(prepareBufferForReplay(diskSnapshot));
-          }).catch(() => {
-          });
-        }
+        loadTerminalBuffer(workspaceId, taskId).then((diskSnapshot) => {
+          if (diskSnapshot) {
+            if (ws.readyState === 1) ws.send(prepareBufferForReplay(diskSnapshot));
+            return;
+          }
+          const hubSnapshot = stateHub.getTerminalBuffer(workspaceId, taskId);
+          if (hubSnapshot && ws.readyState === 1) ws.send(prepareBufferForReplay(hubSnapshot));
+        }).catch(() => {
+          const hubSnapshot = stateHub.getTerminalBuffer(workspaceId, taskId);
+          if (hubSnapshot && ws.readyState === 1) ws.send(prepareBufferForReplay(hubSnapshot));
+        });
       }
       ws.on("message", (raw2) => {
         const text = raw2.toString();
@@ -28720,6 +29752,9 @@ async function createRuntimeServer(options) {
   await writeClaudeTaskHookSettings(port).catch((err) => {
     logger.warn("[server] Failed to write claude hook settings:", err);
   });
+  await writeClaudeCompanionSettings().catch((err) => {
+    logger.warn("[server] Failed to write claude companion settings:", err);
+  });
   if (_globalConfig.autoStartTunnel) tunnelManager.start();
   scheduleUpdateChecks(VERSION10, (latestVersion) => {
     stateHub.broadcastUpdateAvailable(latestVersion);
@@ -28770,7 +29805,7 @@ process.on("uncaughtException", (err) => {
   if (err.code === "EPIPE" || err.code === "ECONNRESET") return;
   throw err;
 });
-var VERSION9 = true ? "0.8.0" : "0.0.0-dev";
+var VERSION9 = true ? "0.9.0" : "0.0.0-dev";
 async function isPortAvailable(port, host) {
   return new Promise((resolve5) => {
     const probe = createServer2();