yapout 0.1.0

package/dist/index.js

@@ -0,0 +1,4029 @@
+#!/usr/bin/env node
+import {
+  createWorktree,
+  getWorktreesDir,
+  listWorktrees,
+  removeWorktree
+} from "./chunk-DLHFRTYU.js";
+
+// src/index.ts
+import { Command as Command16 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import http from "http";
+import chalk from "chalk";
+import open from "open";
+
+// src/lib/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync
+} from "fs";
+import { parse as yamlParse } from "yaml";
+var YAPOUT_DIR = join(homedir(), ".yapout");
+function ensureYapoutDir() {
+  if (!existsSync(YAPOUT_DIR)) {
+    mkdirSync(YAPOUT_DIR, { recursive: true });
+  }
+}
+function getYapoutDir() {
+  return YAPOUT_DIR;
+}
+var CREDENTIALS_PATH = join(YAPOUT_DIR, "credentials.json");
+function readCredentials() {
+  if (!existsSync(CREDENTIALS_PATH)) return null;
+  try {
+    return JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCredentials(creds) {
+  ensureYapoutDir();
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), {
+    mode: 384
+  });
+}
+function deleteCredentials() {
+  if (existsSync(CREDENTIALS_PATH)) {
+    unlinkSync(CREDENTIALS_PATH);
+  }
+}
+var PROJECTS_PATH = join(YAPOUT_DIR, "projects.json");
+function readProjectMappings() {
+  if (!existsSync(PROJECTS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(PROJECTS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeProjectMappings(mappings) {
+  ensureYapoutDir();
+  writeFileSync(PROJECTS_PATH, JSON.stringify(mappings, null, 2));
+}
+function getProjectMapping(dir) {
+  const mappings = readProjectMappings();
+  return mappings[dir] || null;
+}
+function setProjectMapping(dir, mapping) {
+  const mappings = readProjectMappings();
+  mappings[dir] = mapping;
+  writeProjectMappings(mappings);
+}
+function removeProjectMapping(dir) {
+  const mappings = readProjectMappings();
+  delete mappings[dir];
+  writeProjectMappings(mappings);
+}
+var WATCH_DEFAULTS = {
+  auto_enrich: true,
+  auto_implement: true,
+  auto_retry: false
+};
+var CONFIG_DEFAULTS = {
+  post_flight: [],
+  ship_requires_checks: false,
+  branch_prefix: "feat",
+  watch: { ...WATCH_DEFAULTS }
+};
+function readYapoutConfig(cwd) {
+  const configPath = join(cwd, ".yapout", "config.yml");
+  if (!existsSync(configPath)) return { ...CONFIG_DEFAULTS };
+  try {
+    const raw = yamlParse(readFileSync(configPath, "utf-8"));
+    if (!raw) return { ...CONFIG_DEFAULTS };
+    const watchRaw = raw.watch ?? {};
+    return {
+      post_flight: Array.isArray(raw.post_flight) ? raw.post_flight : [],
+      ship_requires_checks: raw.ship_requires_checks === true,
+      branch_prefix: typeof raw.branch_prefix === "string" ? raw.branch_prefix : "feat",
+      commit_template: typeof raw.commit_template === "string" ? raw.commit_template : void 0,
+      watch: {
+        auto_enrich: watchRaw.auto_enrich !== false,
+        auto_implement: watchRaw.auto_implement !== false,
+        auto_retry: watchRaw.auto_retry === true
+      }
+    };
+  } catch {
+    return { ...CONFIG_DEFAULTS };
+  }
+}
+function getMaxAgents() {
+  const envVal = process.env.YAPOUT_MAX_AGENTS;
+  if (envVal) {
+    const parsed = parseInt(envVal, 10);
+    if (!isNaN(parsed) && parsed > 0) return parsed;
+  }
+  return 2;
+}
+function readDotEnvValue(dir, key) {
+  for (const file of [".env.local", ".env"]) {
+    const filePath = join(dir, file);
+    if (!existsSync(filePath)) continue;
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        const k = trimmed.slice(0, eqIdx).trim();
+        if (k === key) {
+          let v = trimmed.slice(eqIdx + 1).trim();
+          if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+            v = v.slice(1, -1);
+          }
+          return v || null;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getConvexUrl() {
+  const fromEnv = process.env.CONVEX_URL;
+  if (fromEnv) return fromEnv;
+  const creds = readCredentials();
+  if (creds?.convexUrl) return creds.convexUrl;
+  if (process.env.NEXT_PUBLIC_CONVEX_URL) return process.env.NEXT_PUBLIC_CONVEX_URL;
+  const cwd = process.cwd();
+  const fromDotEnv = readDotEnvValue(cwd, "NEXT_PUBLIC_CONVEX_URL");
+  if (fromDotEnv) return fromDotEnv;
+  throw new Error(
+    "Could not find Convex URL. Run `yapout login` to authenticate, or set CONVEX_URL."
+  );
+}
+function getAppUrl() {
+  return process.env.YAPOUT_APP_URL || "https://yapout.vercel.app";
+}
+
+// src/lib/protocol.ts
+import { execSync, spawnSync } from "child_process";
+import { platform, homedir as homedir2 } from "os";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join as join2, dirname } from "path";
+function getYapoutBinPath() {
+  const os = platform();
+  try {
+    if (os === "win32") {
+      const result = spawnSync("where", ["yapout"], { encoding: "utf-8" });
+      return result.stdout.trim().split("\n")[0].trim();
+    } else {
+      const result = spawnSync("which", ["yapout"], { encoding: "utf-8" });
+      return result.stdout.trim();
+    }
+  } catch {
+    throw new Error(
+      "Could not find `yapout` on PATH. Make sure @yapout/cli is installed globally."
+    );
+  }
+}
+function registerWindows(yapoutPath) {
+  const key = "HKCU\\Software\\Classes\\yapout";
+  const handler = `"${yapoutPath}" handle-uri "%1"`;
+  const commands = [
+    `reg add "${key}" /ve /d "URL:yapout Protocol" /f`,
+    `reg add "${key}" /v "URL Protocol" /d "" /f`,
+    `reg add "${key}\\shell\\open\\command" /ve /d "${handler}" /f`
+  ];
+  for (const cmd of commands) {
+    execSync(cmd, { stdio: "pipe" });
+  }
+}
+function registerMacOS(_yapoutPath) {
+  const appPath = join2(homedir2(), "Applications", "YapoutHandler.app");
+  const yapoutDir = join2(homedir2(), ".yapout");
+  const handlerPy = join2(yapoutDir, "handle-url.py");
+  const tmpScript = join2(yapoutDir, ".tmp-handler.applescript");
+  mkdirSync2(yapoutDir, { recursive: true });
+  const pythonHandler = `#!/usr/bin/env python3
+"""yapout:// URL handler \u2014 called by YapoutHandler.app"""
+import json, os, shlex, sys
+from urllib.parse import urlparse, parse_qs
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(0)
+
+    uri = sys.argv[1]
+    r = urlparse(uri)
+    action = r.hostname or ""
+    ticket_id = r.path.strip("/")
+    qs = parse_qs(r.query)
+    topic = qs.get("topic", [""])[0]
+    persona = qs.get("persona", [""])[0]
+
+    # Read project directory from ~/.yapout/projects.json
+    projects_path = os.path.expanduser("~/.yapout/projects.json")
+    try:
+        with open(projects_path) as f:
+            projects = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        print("echo 'No yapout project linked. Run yapout init first.'", end="")
+        sys.exit(1)
+
+    dirs = sorted(projects.keys(), key=lambda k: projects[k].get("linkedAt", 0), reverse=True)
+    if not dirs:
+        print("echo 'No yapout project linked. Run yapout init first.'", end="")
+        sys.exit(1)
+    project_dir = dirs[0]
+
+    # Build claude prompt based on action
+    if action == "claim":
+        prompt = (
+            f'Use yapout to implement ticket "{ticket_id}". '
+            f'Claim it with yapout_claim (use worktree mode), read the brief, '
+            f'implement the changes, run yapout_check, then ship with yapout_ship.'
+        )
+    elif action == "enrich":
+        prompt = (
+            f'A ticket has been approved and needs enrichment before implementation. '
+            f'Call yapout_get_unenriched_ticket with ticketId for "{ticket_id}" to fetch the ticket details.\\n\\n'
+            f'Read the codebase to understand the project structure, then produce:\\n'
+            f'1. An implementation brief (3-5 sentences, specific files/patterns involved)\\n'
+            f'2. An enriched description with technical context\\n'
+            f"3. Clarifying questions (0-5) where the answer can't be inferred\\n"
+            f'4. Duplicate check \u2014 call yapout_get_existing_tickets and compare\\n'
+            f'5. Scope assessment (is this too large for one PR?)\\n\\n'
+            f'Call yapout_save_enrichment with your analysis. '
+            f'If no questions were generated, also call yapout_sync_to_linear to create the Linear ticket.'
+        )
+    elif action == "yap":
+        prompt = "Let's have a yap session"
+        if topic:
+            prompt += f" about {topic}"
+        if persona and persona != "tech lead":
+            prompt += f" \u2014 be a {persona}"
+    elif action == "compact":
+        prompt = "Run yapout_compact to update the project context summary."
+    else:
+        sys.exit(0)
+
+    # Write a .command file and open it \u2014 Terminal handles .command files natively,
+    # no Apple Events / automation permissions required.
+    import subprocess, tempfile, stat
+    cmd_file = os.path.expanduser("~/.yapout/.run.command")
+    with open(cmd_file, "w") as f:
+        f.write("#!/bin/bash\\n")
+        f.write(f"cd {shlex.quote(project_dir)}\\n")
+        f.write(f"clear\\n")
+        f.write(f"claude --dangerously-skip-permissions {shlex.quote(prompt)}\\n")
+    os.chmod(cmd_file, stat.S_IRWXU)
+    subprocess.run(["open", cmd_file])
+
+if __name__ == "__main__":
+    main()
+`;
+  writeFileSync2(handlerPy, pythonHandler, { mode: 493 });
+  const escapedHandlerPy = handlerPy.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const scriptContent = `on open location theURL
+	do shell script "/usr/bin/python3 " & quoted form of "${escapedHandlerPy}" & " " & quoted form of theURL
+	quit
+end open location
+
+on idle
+	quit
+	return 5
+end idle`;
+  writeFileSync2(tmpScript, scriptContent);
+  try {
+    execSync(`rm -rf "${appPath}"`, { stdio: "pipe" });
+  } catch {
+  }
+  mkdirSync2(dirname(appPath), { recursive: true });
+  execSync(`osacompile -s -o "${appPath}" "${tmpScript}"`, { stdio: "pipe" });
+  try {
+    unlinkSync2(tmpScript);
+  } catch {
+  }
+  const plistPath = join2(appPath, "Contents", "Info.plist");
+  const plistCommands = [
+    "Add :CFBundleIdentifier string dev.yapout.handler",
+    "Add :CFBundleURLTypes array",
+    "Add :CFBundleURLTypes:0 dict",
+    'Add :CFBundleURLTypes:0:CFBundleURLName string "yapout Protocol"',
+    "Add :CFBundleURLTypes:0:CFBundleURLSchemes array",
+    "Add :CFBundleURLTypes:0:CFBundleURLSchemes:0 string yapout"
+  ];
+  for (const cmd of plistCommands) {
+    try {
+      execSync(`/usr/libexec/PlistBuddy -c '${cmd}' "${plistPath}"`, { stdio: "pipe" });
+    } catch {
+    }
+  }
+  try {
+    execSync(
+      `/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -R "${appPath}"`,
+      { stdio: "pipe" }
+    );
+  } catch {
+  }
+}
+function registerLinux(yapoutPath) {
+  const appsDir = join2(homedir2(), ".local", "share", "applications");
+  mkdirSync2(appsDir, { recursive: true });
+  const desktop = `[Desktop Entry]
+Name=yapout Handler
+Comment=Handle yapout:// URIs
+Exec="${yapoutPath}" handle-uri %u
+Type=Application
+NoDisplay=true
+MimeType=x-scheme-handler/yapout;
+`;
+  writeFileSync2(join2(appsDir, "yapout-handler.desktop"), desktop);
+  try {
+    execSync(
+      `xdg-mime default yapout-handler.desktop x-scheme-handler/yapout`,
+      { stdio: "pipe" }
+    );
+  } catch {
+  }
+}
+function registerProtocolHandler() {
+  const os = platform();
+  const yapoutPath = getYapoutBinPath();
+  if (os === "win32") {
+    registerWindows(yapoutPath);
+  } else if (os === "darwin") {
+    registerMacOS(yapoutPath);
+  } else {
+    registerLinux(yapoutPath);
+  }
+}
+
+// src/commands/login.ts
+function startCallbackServer() {
+  return new Promise((resolve11) => {
+    let resolveData;
+    let rejectData;
+    const dataPromise = new Promise((res, rej) => {
+      resolveData = res;
+      rejectData = rej;
+    });
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const email = url.searchParams.get("email");
+        const expiresAt = url.searchParams.get("expiresAt");
+        const convexUrl = url.searchParams.get("convexUrl");
+        const error = url.searchParams.get("error");
+        if (error || !token) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(
+            `<html><body style="font-family:sans-serif;text-align:center;padding:2rem"><h2>Authentication failed</h2><p>${error || "No token received."}</p><p>You can close this tab.</p></body></html>`
+          );
+          server.close();
+          rejectData(new Error(error || "No token received"));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<html><body style="font-family:sans-serif;text-align:center;padding:2rem"><h2>Authenticated!</h2><p>You can close this tab and return to the terminal.</p></body></html>`
+        );
+        server.close();
+        resolveData({
+          token,
+          email: email || "",
+          expiresAt: Number(expiresAt) || Date.now() + 36e5,
+          convexUrl: convexUrl || ""
+        });
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    server.listen(0, () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      resolve11({ port, data: dataPromise });
+    });
+    setTimeout(() => {
+      server.close();
+      rejectData(
+        new Error("Authentication timed out. Please try again.")
+      );
+    }, 12e4);
+  });
+}
+var loginCommand = new Command("login").description("Authenticate with yapout").action(async () => {
+  console.log(chalk.dim("Starting authentication..."));
+  const { port, data } = await startCallbackServer();
+  const appUrl = getAppUrl();
+  const authUrl = `${appUrl}/auth/cli?port=${port}`;
+  console.log(chalk.dim(`Opening browser...`));
+  await open(authUrl);
+  console.log(chalk.dim("Waiting for authentication in browser..."));
+  try {
+    const result = await data;
+    const creds = {
+      token: result.token,
+      email: result.email,
+      expiresAt: result.expiresAt,
+      convexUrl: result.convexUrl || void 0
+    };
+    writeCredentials(creds);
+    const daysLeft = Math.max(
+      1,
+      Math.round((result.expiresAt - Date.now()) / 864e5)
+    );
+    console.log(
+      chalk.green("Logged in as ") + chalk.bold(result.email) + chalk.dim(
+        ` (expires in ${daysLeft} day${daysLeft === 1 ? "" : "s"})`
+      )
+    );
+    try {
+      registerProtocolHandler();
+      console.log(
+        chalk.dim("Registered yapout:// protocol handler")
+      );
+    } catch {
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error(chalk.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+var logoutCommand = new Command2("logout").description("Log out of yapout").action(() => {
+  deleteCredentials();
+  console.log(chalk2.green("Logged out."));
+});
+
+// src/commands/link.ts
+import { Command as Command3 } from "commander";
+import { resolve, join as join3 } from "path";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync3,
+  appendFileSync
+} from "fs";
+import chalk4 from "chalk";
+
+// src/lib/auth.ts
+import chalk3 from "chalk";
+function requireAuth() {
+  const creds = readCredentials();
+  if (!creds) {
+    console.error(
+      chalk3.red("Not logged in.") + " Run " + chalk3.cyan("yapout login") + " first."
+    );
+    process.exit(1);
+  }
+  if (Date.now() > creds.expiresAt) {
+    console.error(
+      chalk3.red("Session expired.") + " Run " + chalk3.cyan("yapout login") + " to re-authenticate."
+    );
+    process.exit(1);
+  }
+  return creds;
+}
+
+// src/lib/convex.ts
+import { ConvexHttpClient } from "convex/browser";
+import { anyApi } from "convex/server";
+function createConvexClient(token) {
+  const url = getConvexUrl();
+  const client = new ConvexHttpClient(url);
+  client.setAuth(token);
+  return client;
+}
+
+// src/lib/prompts.ts
+import { select } from "@inquirer/prompts";
+async function pickProject(projects) {
+  return await select({
+    message: "Select a project to link to this directory:",
+    choices: projects.map((p) => ({
+      name: p.githubRepoFullName ? `${p.name} (${p.githubRepoFullName})` : p.name,
+      value: p
+    }))
+  });
+}
+
+// src/commands/link.ts
+var CONFIG_YAML_CONTENT = `# yapout local configuration
+# See: https://docs.yapout.dev/cli/config
+
+# Commands to run after implementation, before shipping.
+# Each runs sequentially. If any fails, yapout_check reports failure.
+# Examples:
+#   - npm run lint
+#   - npm run typecheck
+#   - npm run test
+#   - sf project deploy --dry-run --target-org scratch
+post_flight: []
+
+# Require post_flight checks to pass before yapout_ship succeeds.
+# If true, yapout_ship refuses to run unless yapout_check passed.
+ship_requires_checks: false
+
+# Git branch prefix (used by yapout_claim)
+branch_prefix: feat
+
+# Commit message template (optional \u2014 uses sensible default if omitted)
+# Available variables: {{ticket.title}}, {{ticket.type}}, {{ticket.priority}},
+#   {{ticket.linearTicketId}}, {{ticket.id}}
+# commit_template: "{{ticket.type}}({{ticket.linearTicketId}}): {{ticket.title}}"
+`;
+var linkCommand = new Command3("link").description("Link the current directory to a yapout project").action(async () => {
+  const creds = requireAuth();
+  const cwd = resolve(process.cwd());
+  const client = createConvexClient(creds.token);
+  let projects;
+  try {
+    projects = await client.query(
+      anyApi.functions.projects.getProjectsForCli,
+      {}
+    );
+  } catch (err) {
+    console.error(
+      chalk4.red("Failed to fetch projects."),
+      err.message
+    );
+    process.exit(1);
+  }
+  if (projects.length === 0) {
+    console.error(
+      chalk4.yellow("No projects found.") + " Create one at " + chalk4.cyan(`${getAppUrl()}/dashboard`)
+    );
+    process.exit(1);
+  }
+  const selected = await pickProject(projects);
+  setProjectMapping(cwd, {
+    projectId: selected.id,
+    projectName: selected.name,
+    linkedAt: Date.now()
+  });
+  const yapoutDir = join3(cwd, ".yapout");
+  if (!existsSync2(yapoutDir)) {
+    mkdirSync3(yapoutDir, { recursive: true });
+  }
+  const configPath = join3(yapoutDir, "config.yml");
+  if (!existsSync2(configPath)) {
+    writeFileSync3(configPath, CONFIG_YAML_CONTENT);
+  }
+  const gitignorePath = join3(cwd, ".gitignore");
+  if (existsSync2(gitignorePath)) {
+    const content = readFileSync2(gitignorePath, "utf-8");
+    if (!content.includes(".yapout/")) {
+      appendFileSync(
+        gitignorePath,
+        "\n# yapout local config\n.yapout/\n"
+      );
+    }
+  } else {
+    writeFileSync3(gitignorePath, "# yapout local config\n.yapout/\n");
+  }
+  const mcpPath = join3(cwd, ".mcp.json");
+  let mcpConfig = {};
+  if (existsSync2(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers.yapout = {
+    command: "yapout",
+    args: ["mcp-server"]
+  };
+  writeFileSync3(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+  const label = selected.githubRepoFullName ? `${selected.name} (${selected.githubRepoFullName})` : selected.name;
+  console.log(
+    chalk4.green(`Linked to ${label}.`) + " Claude Code will discover yapout tools automatically."
+  );
+});
+
+// src/commands/unlink.ts
+import { Command as Command4 } from "commander";
+import { resolve as resolve2, join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4, rmSync } from "fs";
+import chalk5 from "chalk";
+var unlinkCommand = new Command4("unlink").description("Unlink the current directory from its yapout project").action(() => {
+  const cwd = resolve2(process.cwd());
+  const mapping = getProjectMapping(cwd);
+  if (!mapping) {
+    console.error(chalk5.yellow("No project linked to this directory."));
+    process.exit(1);
+  }
+  removeProjectMapping(cwd);
+  const yapoutDir = join4(cwd, ".yapout");
+  if (existsSync3(yapoutDir)) {
+    rmSync(yapoutDir, { recursive: true });
+  }
+  const mcpPath = join4(cwd, ".mcp.json");
+  if (existsSync3(mcpPath)) {
+    try {
+      const mcpConfig = JSON.parse(readFileSync3(mcpPath, "utf-8"));
+      if (mcpConfig.mcpServers?.yapout) {
+        delete mcpConfig.mcpServers.yapout;
+        if (Object.keys(mcpConfig.mcpServers).length === 0) {
+          rmSync(mcpPath);
+        } else {
+          writeFileSync4(
+            mcpPath,
+            JSON.stringify(mcpConfig, null, 2) + "\n"
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  console.log(chalk5.green("Unlinked."));
+});
+
+// src/commands/status.ts
+import { Command as Command5 } from "commander";
+import { resolve as resolve3 } from "path";
+import chalk6 from "chalk";
+var statusCommand = new Command5("status").description("Show yapout status for this directory").action(() => {
+  console.log(chalk6.bold("yapout status\n"));
+  const creds = readCredentials();
+  if (!creds) {
+    console.log(
+      `  Auth:     ${chalk6.red("Not logged in.")} Run ${chalk6.cyan("yapout login")}.`
+    );
+  } else if (Date.now() > creds.expiresAt) {
+    console.log(
+      `  Auth:     ${chalk6.red("Session expired.")} Run ${chalk6.cyan("yapout login")}.`
+    );
+  } else {
+    const daysLeft = Math.max(
+      1,
+      Math.round((creds.expiresAt - Date.now()) / 864e5)
+    );
+    console.log(
+      `  Auth:     ${chalk6.green(creds.email)} (expires in ${daysLeft} day${daysLeft === 1 ? "" : "s"})`
+    );
+  }
+  const cwd = resolve3(process.cwd());
+  const mapping = getProjectMapping(cwd);
+  if (!mapping) {
+    console.log(
+      `  Project:  ${chalk6.yellow("No project linked.")} Run ${chalk6.cyan("yapout link")} in a repo.`
+    );
+  } else {
+    console.log(`  Project:  ${chalk6.green(mapping.projectName)}`);
+  }
+  console.log(`  Daemon:   ${chalk6.dim("not running")}`);
+  console.log(`  Work:     ${chalk6.dim("no active tickets")}`);
+  console.log();
+});
+
+// src/commands/init.ts
+import { Command as Command6 } from "commander";
+import { resolve as resolve4, join as join5 } from "path";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  writeFileSync as writeFileSync5,
+  readFileSync as readFileSync4,
+  appendFileSync as appendFileSync2
+} from "fs";
+import chalk7 from "chalk";
+
+// src/lib/git.ts
+import { execSync as execSync2 } from "child_process";
+function git(args, cwd) {
+  return execSync2(`git ${args}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+function getRepoFullName(cwd) {
+  const url = git("remote get-url origin", cwd);
+  const sshMatch = url.match(/git@github\.com:(.+?)(?:\.git)?$/);
+  if (sshMatch) return sshMatch[1];
+  const httpsMatch = url.match(/github\.com\/(.+?)(?:\.git)?$/);
+  if (httpsMatch) return httpsMatch[1];
+  throw new Error(`Could not parse GitHub repo from remote URL: ${url}`);
+}
+function getDefaultBranch(cwd) {
+  try {
+    const ref = git("rev-parse --abbrev-ref origin/HEAD", cwd);
+    return ref.replace("origin/", "");
+  } catch {
+    try {
+      git("rev-parse --verify origin/main", cwd);
+      return "main";
+    } catch {
+      return "master";
+    }
+  }
+}
+function getCurrentBranch(cwd) {
+  return git("branch --show-current", cwd);
+}
+function fetchOrigin(cwd) {
+  git("fetch origin", cwd);
+}
+function checkoutNewBranch(name, base, cwd) {
+  git(`checkout -b ${name} origin/${base}`, cwd);
+}
+function stageAll(cwd) {
+  git("add -A", cwd);
+  try {
+    git("reset HEAD -- .yapout/", cwd);
+  } catch {
+  }
+}
+function commit(message, cwd) {
+  git(`commit -m "${message.replace(/"/g, '\\"')}"`, cwd);
+  return git("rev-parse HEAD", cwd);
+}
+function push(branch, cwd) {
+  git(`push -u origin ${branch}`, cwd);
+}
+function getDiffStats(base, head, cwd) {
+  try {
+    return git(`diff --stat origin/${base}...${head}`, cwd);
+  } catch {
+    return "(could not compute diff stats)";
+  }
+}
+
+// src/commands/init.ts
+var CONFIG_YAML_CONTENT2 = `# yapout local configuration
+# See: https://docs.yapout.dev/cli/config
+
+# Commands to run after implementation, before shipping.
+# Each runs sequentially. If any fails, yapout_check reports failure.
+# Examples:
+#   - npm run lint
+#   - npm run typecheck
+#   - npm run test
+#   - sf project deploy --dry-run --target-org scratch
+post_flight: []
+
+# Require post_flight checks to pass before yapout_ship succeeds.
+# If true, yapout_ship refuses to run unless yapout_check passed.
+ship_requires_checks: false
+
+# Git branch prefix (used by yapout_claim)
+branch_prefix: feat
+
+# Commit message template (optional \u2014 uses sensible default if omitted)
+# Available variables: {{ticket.title}}, {{ticket.type}}, {{ticket.priority}},
+#   {{ticket.linearTicketId}}, {{ticket.id}}
+# commit_template: "{{ticket.type}}({{ticket.linearTicketId}}): {{ticket.title}}"
+`;
+var initCommand = new Command6("init").description("Create a yapout project from the current repo and link it").argument("[name]", "Project name (defaults to repo name)").action(async (name) => {
+  const creds = requireAuth();
+  const cwd = resolve4(process.cwd());
+  let repoFullName;
+  let defaultBranch;
+  try {
+    repoFullName = getRepoFullName(cwd);
+    defaultBranch = getDefaultBranch(cwd);
+  } catch (err) {
+    console.error(
+      chalk7.red("Not a git repo with a GitHub remote."),
+      err.message
+    );
+    process.exit(1);
+  }
+  const projectName = name || repoFullName.split("/")[1] || "unnamed";
+  const client = createConvexClient(creds.token);
+  let result;
+  try {
+    result = await client.mutation(
+      anyApi.functions.projects.createProjectFromCli,
+      {
+        name: projectName,
+        githubRepoFullName: repoFullName,
+        githubDefaultBranch: defaultBranch
+      }
+    );
+  } catch (err) {
+    console.error(
+      chalk7.red("Failed to create project."),
+      err.message
+    );
+    process.exit(1);
+  }
+  setProjectMapping(cwd, {
+    projectId: result.projectId,
+    projectName: result.projectName,
+    linkedAt: Date.now()
+  });
+  const yapoutDir = join5(cwd, ".yapout");
+  if (!existsSync4(yapoutDir)) mkdirSync4(yapoutDir, { recursive: true });
+  const configPath = join5(yapoutDir, "config.yml");
+  if (!existsSync4(configPath)) {
+    writeFileSync5(configPath, CONFIG_YAML_CONTENT2);
+  }
+  const gitignorePath = join5(cwd, ".gitignore");
+  if (existsSync4(gitignorePath)) {
+    const content = readFileSync4(gitignorePath, "utf-8");
+    if (!content.includes(".yapout/")) {
+      appendFileSync2(
+        gitignorePath,
+        "\n# yapout local config\n.yapout/\n"
+      );
+    }
+  }
+  const mcpPath = join5(cwd, ".mcp.json");
+  let mcpConfig = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      mcpConfig = JSON.parse(readFileSync4(mcpPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+  mcpConfig.mcpServers.yapout = {
+    command: "yapout",
+    args: ["mcp-server"]
+  };
+  writeFileSync5(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+  console.log(
+    chalk7.green(`Created project "${result.projectName}"`) + chalk7.dim(` (${repoFullName}, branch: ${defaultBranch})`)
+  );
+  console.log(
+    chalk7.dim("Run ") + chalk7.cyan("yapout_compact") + chalk7.dim(" in Claude Code to generate project context.")
+  );
+});
+
+// src/commands/mcp-server.ts
+import { Command as Command7 } from "commander";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ConvexHttpClient as ConvexHttpClient2 } from "convex/browser";
+import { anyApi as anyApi2 } from "convex/server";
+
+// src/mcp/tools/init.ts
+import { z } from "zod";
+import { join as join6 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { stringify as yamlStringify } from "yaml";
+function registerInitTool(server, ctx) {
+  server.tool(
+    "yapout_init",
+    "Create a new yapout project from the current repo",
+    {
+      name: z.string().optional().describe("Project name (defaults to repo name)"),
+      linearTeamId: z.string().optional().describe("Linear team ID to associate")
+    },
+    async (args) => {
+      const repoFullName = getRepoFullName(ctx.cwd);
+      const defaultBranch = getDefaultBranch(ctx.cwd);
+      const projectName = args.name || repoFullName.split("/")[1] || "unnamed";
+      const result = await ctx.client.mutation(
+        anyApi2.functions.projects.createProjectFromCli,
+        {
+          name: projectName,
+          githubRepoFullName: repoFullName,
+          githubDefaultBranch: defaultBranch,
+          linearTeamId: args.linearTeamId
+        }
+      );
+      ctx.projectId = result.projectId;
+      ctx.projectName = result.projectName;
+      setProjectMapping(ctx.cwd, {
+        projectId: result.projectId,
+        projectName: result.projectName,
+        linkedAt: Date.now()
+      });
+      const yapoutDir = join6(ctx.cwd, ".yapout");
+      if (!existsSync5(yapoutDir)) mkdirSync5(yapoutDir, { recursive: true });
+      const configPath = join6(yapoutDir, "config.yml");
+      if (!existsSync5(configPath)) {
+        writeFileSync6(
+          configPath,
+          `# yapout local configuration
+
+` + yamlStringify({ post_flight: [], branch_prefix: "feat" })
+        );
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                projectId: result.projectId,
+                projectName: result.projectName,
+                githubRepo: repoFullName,
+                message: "Project created. Run yapout_compact to generate context."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/compact.ts
+var COMPACT_INSTRUCTIONS = `Analyze this codebase and produce a project context summary with the following sections:
+
+1. **Project Description** (2-3 sentences): What this project does, who it's for.
+2. **Tech Stack**: Frameworks, languages, key dependencies with versions.
+3. **Architecture Patterns**: How data flows, key abstractions, directory structure conventions.
+4. **Key Conventions**: Naming patterns, state management approach, error handling patterns.
+5. **Recent History**: Major recent changes visible in the code (not git log, just what you observe).
+6. **Known Gaps**: TODOs, incomplete features, technical debt you notice.
+
+Read the following to build your understanding:
+- package.json (dependencies, scripts)
+- README.md and any CLAUDE.md files
+- Top-level directory structure (2 levels deep)
+- Database schema or type definitions
+- A few representative source files
+
+Output a single markdown document. Be concise \u2014 this will be given to other Claude Code sessions as context for implementing tickets.
+
+After you produce the summary, call yapout_update_context with the summary text to save it.`;
+function registerCompactTool(server, ctx) {
+  server.tool(
+    "yapout_compact",
+    "Get instructions for generating a project context summary. After reading the codebase, call yapout_update_context with the result.",
+    {},
+    async () => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init first."
+            }
+          ],
+          isError: true
+        };
+      }
+      let currentContext;
+      let lastUpdated;
+      try {
+        const project = await ctx.client.query(
+          anyApi2.functions.projects.getProject,
+          { projectId: ctx.projectId }
+        );
+        currentContext = project?.contextSummary ?? void 0;
+        lastUpdated = project?.contextUpdatedAt ?? void 0;
+      } catch {
+      }
+      const result = {
+        instructions: COMPACT_INSTRUCTIONS
+      };
+      if (currentContext) result.currentContext = currentContext;
+      if (lastUpdated) result.lastUpdated = lastUpdated;
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/update-context.ts
+import { z as z2 } from "zod";
+function registerUpdateContextTool(server, ctx) {
+  server.tool(
+    "yapout_update_context",
+    "Save a project context summary to yapout",
+    {
+      summary: z2.string().describe("The project context summary markdown")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init first."
+            }
+          ],
+          isError: true
+        };
+      }
+      await ctx.client.mutation(
+        anyApi2.functions.projects.updateProjectContext,
+        {
+          projectId: ctx.projectId,
+          summary: args.summary
+        }
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, message: "Project context updated." })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/queue.ts
+import { z as z3 } from "zod";
+function registerQueueTool(server, ctx) {
+  server.tool(
+    "yapout_queue",
+    "List tickets ready for local implementation. Only returns tickets in backlog/unstarted Linear status.",
+    {
+      includeBlocked: z3.boolean().optional().describe("Show blocked tickets too (default: false)")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      const data = await ctx.client.query(
+        anyApi2.functions.tickets.getLocalQueuedTickets,
+        { projectId: ctx.projectId }
+      );
+      if (!data) {
+        return {
+          content: [
+            { type: "text", text: "Could not fetch queue." }
+          ],
+          isError: true
+        };
+      }
+      let ready = data.ready;
+      ready = ready.filter((t) => t.nature !== "operational");
+      const linearIds = ready.map((t) => t.linearTicketId).filter((id) => !!id);
+      if (linearIds.length > 0) {
+        try {
+          const statuses = await ctx.client.action(
+            anyApi2.functions.linearStatusMutations.getIssueStatuses,
+            { projectId: ctx.projectId, linearIssueIds: linearIds }
+          );
+          const statusMap = new Map(
+            statuses.map((s) => [s.linearIssueId, s.statusType])
+          );
+          ready = ready.filter((t) => {
+            if (!t.linearTicketId) return true;
+            const type = statusMap.get(t.linearTicketId);
+            if (!type) return true;
+            return type === "backlog" || type === "unstarted";
+          });
+        } catch {
+        }
+      }
+      const result = {
+        ready,
+        contextStale: data.contextStale,
+        contextLastUpdated: data.contextLastUpdated
+      };
+      if (args.includeBlocked) {
+        result.blocked = data.blocked;
+      }
+      if (data.contextStale) {
+        const daysAgo = data.contextLastUpdated ? Math.round(
+          (Date.now() - data.contextLastUpdated) / 864e5
+        ) : null;
+        result.note = daysAgo ? `Project context was last updated ${daysAgo} days ago. Consider running yapout_compact.` : "Project context has never been generated. Run yapout_compact.";
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/get-brief.ts
+import { z as z4 } from "zod";
+function registerGetBriefTool(server, ctx) {
+  server.tool(
+    "yapout_get_brief",
+    "Fetch the full implementation context for a ticket",
+    {
+      ticketId: z4.string().describe("The ticket ID to get the brief for")
+    },
+    async (args) => {
+      const data = await ctx.client.query(
+        anyApi2.functions.tickets.getTicketBrief,
+        { ticketId: args.ticketId }
+      );
+      if (!data) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Ticket not found or you don't have access."
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(data, null, 2) }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/claim.ts
+import { z as z5 } from "zod";
+import { join as join7 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+function readBranchPrefix(cwd) {
+  try {
+    const config = readYapoutConfig(cwd);
+    return config.branch_prefix || "feat";
+  } catch {
+    return "feat";
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function formatBrief(data) {
+  const ticket = data.ticket;
+  const sections = [
+    `# ${ticket.title}`,
+    "",
+    `**Priority:** ${ticket.priority} | **Type:** ${ticket.type}`
+  ];
+  if (ticket.linearUrl) {
+    sections.push(`**Linear:** ${ticket.linearUrl}`);
+  }
+  sections.push("", "## Description", "", ticket.description);
+  if (data.enrichedDescription) {
+    sections.push("", "## Enriched Description", "", data.enrichedDescription);
+  }
+  if (data.implementationBrief) {
+    sections.push("", "## Implementation Brief", "", data.implementationBrief);
+  }
+  const qa = data.enrichmentQA;
+  if (qa && qa.length > 0) {
+    sections.push("", "## Q&A");
+    for (const item of qa) {
+      sections.push("", `**Q:** ${item.question}`);
+      sections.push(`**A:** ${item.answer || "(no answer yet)"}`);
+    }
+  }
+  if (data.userContext) {
+    sections.push("", "## User Context", "", data.userContext);
+  }
+  if (data.projectContext) {
+    sections.push("", "## Project Context", "", data.projectContext);
+  }
+  const warnings = data.warnings;
+  if (warnings?.duplicateWarning || warnings?.scopeWarning) {
+    sections.push("", "## Warnings");
+    if (warnings.duplicateWarning)
+      sections.push("", `**Duplicate:** ${warnings.duplicateWarning}`);
+    if (warnings.scopeWarning)
+      sections.push("", `**Scope:** ${warnings.scopeWarning}`);
+  }
+  return sections.join("\n");
+}
+function registerClaimTool(server, ctx) {
+  server.tool(
+    "yapout_claim",
+    "Claim a ticket for local implementation. Creates a branch (or worktree), writes the brief, and updates status.",
+    {
+      ticketId: z5.string().describe("The ticket ID to claim"),
+      worktree: z5.boolean().optional().describe("Create a git worktree for parallel work (default: false)")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init first."
+            }
+          ],
+          isError: true
+        };
+      }
+      const briefData = await ctx.client.query(
+        anyApi2.functions.tickets.getTicketBrief,
+        { ticketId: args.ticketId }
+      );
+      if (!briefData) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Ticket not found or you don't have access."
+            }
+          ],
+          isError: true
+        };
+      }
+      const ticket = briefData.ticket;
+      const linearTicketId = briefData.linearTicketId;
+      const defaultBranch = briefData.defaultBranch || "main";
+      const prefix = readBranchPrefix(ctx.cwd);
+      const slug = slugify(ticket.title);
+      const branchName = linearTicketId ? `${prefix}/${linearTicketId.toLowerCase()}-${slug}` : `${prefix}/${slug}`;
+      const claim = await ctx.client.mutation(
+        anyApi2.functions.tickets.claimTicketLocal,
+        { ticketId: args.ticketId, branchName }
+      );
+      if (linearTicketId && ctx.projectId) {
+        try {
+          await ctx.client.action(
+            anyApi2.functions.linearStatusMutations.moveIssueStatus,
+            {
+              projectId: ctx.projectId,
+              linearIssueId: linearTicketId,
+              statusType: "started"
+            }
+          );
+        } catch {
+        }
+      }
+      let worktreePath;
+      if (args.worktree) {
+        fetchOrigin(ctx.cwd);
+        worktreePath = createWorktree(
+          ctx.cwd,
+          args.ticketId,
+          branchName,
+          defaultBranch
+        );
+        const wtYapoutDir = join7(worktreePath, ".yapout");
+        if (!existsSync6(wtYapoutDir)) mkdirSync6(wtYapoutDir, { recursive: true });
+        const brief2 = formatBrief(briefData);
+        writeFileSync7(join7(wtYapoutDir, "brief.md"), brief2);
+        try {
+          await ctx.client.mutation(
+            anyApi2.functions.pipelineRuns.reportDaemonEvent,
+            {
+              pipelineRunId: claim.pipelineRunId,
+              event: "worktree_created",
+              message: `Worktree: ${worktreePath}`
+            }
+          );
+        } catch {
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  branch: branchName,
+                  worktreePath,
+                  briefPath: `${worktreePath}/.yapout/brief.md`,
+                  brief: formatBrief(briefData),
+                  pipelineRunId: claim.pipelineRunId
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      fetchOrigin(ctx.cwd);
+      checkoutNewBranch(branchName, defaultBranch, ctx.cwd);
+      const yapoutDir = join7(ctx.cwd, ".yapout");
+      if (!existsSync6(yapoutDir)) mkdirSync6(yapoutDir, { recursive: true });
+      const brief = formatBrief(briefData);
+      writeFileSync7(join7(yapoutDir, "brief.md"), brief);
+      try {
+        await ctx.client.mutation(
+          anyApi2.functions.pipelineRuns.reportDaemonEvent,
+          {
+            pipelineRunId: claim.pipelineRunId,
+            event: "daemon_claimed",
+            message: `Claimed ticket: ${ticket.title}`
+          }
+        );
+        await ctx.client.mutation(
+          anyApi2.functions.pipelineRuns.reportDaemonEvent,
+          {
+            pipelineRunId: claim.pipelineRunId,
+            event: "branch_created",
+            message: `Branch: ${branchName}`
+          }
+        );
+      } catch {
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                branch: branchName,
+                briefPath: ".yapout/brief.md",
+                brief,
+                pipelineRunId: claim.pipelineRunId
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/event.ts
+import { z as z6 } from "zod";
+function registerEventTool(server, ctx) {
+  server.tool(
+    "yapout_event",
+    "Report a status event back to yapout for the activity feed",
+    {
+      pipelineRunId: z6.string().describe("The pipeline run ID"),
+      event: z6.string().describe(
+        'Event type (e.g., "reading_codebase", "writing_code", "running_tests")'
+      ),
+      message: z6.string().describe("Human-readable description")
+    },
+    async (args) => {
+      try {
+        await ctx.client.mutation(
+          anyApi2.functions.pipelineRuns.reportDaemonEvent,
+          {
+            pipelineRunId: args.pipelineRunId,
+            event: args.event,
+            message: args.message
+          }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ success: true })
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: err.message
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/ship.ts
+import { z as z7 } from "zod";
+
+// src/lib/github-cli.ts
+import { execSync as execSync3 } from "child_process";
+function hasGhCli() {
+  try {
+    execSync3("gh --version", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createPrWithGh(title, body, branch, base, cwd) {
+  const escaped = body.replace(/"/g, '\\"').replace(/`/g, "\\`");
+  const output = execSync3(
+    `gh pr create --title "${title.replace(/"/g, '\\"')}" --body "${escaped}" --base ${base} --head ${branch} --draft`,
+    { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  ).trim();
+  const url = output;
+  const numberMatch = url.match(/\/pull\/(\d+)/);
+  return {
+    number: numberMatch ? Number(numberMatch[1]) : 0,
+    url
+  };
+}
+async function createPrWithApi(title, body, branch, base, repoFullName) {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(
+      "Cannot create PR: gh CLI not available and GITHUB_TOKEN not set."
+    );
+  }
+  const response = await fetch(
+    `https://api.github.com/repos/${repoFullName}/pulls`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ title, body, head: branch, base, draft: true })
+    }
+  );
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`GitHub API error ${response.status}: ${text}`);
+  }
+  const data = await response.json();
+  return { number: data.number, url: data.html_url };
+}
+async function createPullRequest(title, body, branch, base, repoFullName, cwd) {
+  if (hasGhCli()) {
+    return createPrWithGh(title, body, branch, base, cwd);
+  }
+  return createPrWithApi(title, body, branch, base, repoFullName);
+}
+
+// src/mcp/tools/ship.ts
+import { join as join8 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+function buildCommitMessage(message, template, ticket) {
+  if (message) return message;
+  if (template) {
+    return template.replace(/\{\{ticket\.type\}\}/g, ticket.type).replace(/\{\{ticket\.title\}\}/g, ticket.title).replace(/\{\{ticket\.linearTicketId\}\}/g, ticket.linearTicketId ?? "draft").replace(/\{\{ticket\.id\}\}/g, ticket.id ?? "").replace(/\{\{ticket\.priority\}\}/g, ticket.priority ?? "medium");
+  }
+  const prefix = ticket.type === "bug" ? "fix" : "feat";
+  const ref = ticket.linearTicketId ? ` (${ticket.linearTicketId})` : "";
+  return `${prefix}(${ticket.type}): ${ticket.title}${ref}`;
+}
+function registerShipTool(server, ctx) {
+  server.tool(
+    "yapout_ship",
+    "Commit, push, open a PR, and mark the ticket as done. Run yapout_check first if post-flight checks are configured.",
+    {
+      message: z7.string().optional().describe("Custom commit message (overrides template)"),
+      skipPr: z7.boolean().optional().describe("Just push, don't open a PR"),
+      pipelineRunId: z7.string().describe("The pipeline run ID from yapout_claim"),
+      worktreePath: z7.string().optional().describe("Worktree path (if claiming was done with worktree: true)")
+    },
+    async (args) => {
+      const gitCwd = args.worktreePath || ctx.cwd;
+      const config = readYapoutConfig(ctx.cwd);
+      if (config.ship_requires_checks) {
+        if (ctx.lastCheckPassedForRun !== args.pipelineRunId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "Post-flight checks are required but haven't passed. Run yapout_check first.",
+                  ship_requires_checks: true
+                })
+              }
+            ]
+          };
+        }
+      }
+      const branch = getCurrentBranch(gitCwd);
+      const defaultBranch = getDefaultBranch(gitCwd);
+      let ticketTitle = branch;
+      let ticketType = "feature";
+      let ticketLinearId;
+      try {
+        const briefPath = join8(gitCwd, ".yapout", "brief.md");
+        if (existsSync7(briefPath)) {
+          const brief = readFileSync6(briefPath, "utf-8");
+          const titleMatch = brief.match(/^# (.+)$/m);
+          if (titleMatch) ticketTitle = titleMatch[1];
+          const typeMatch = brief.match(/\*\*Type:\*\* (\w+)/);
+          if (typeMatch) ticketType = typeMatch[1];
+          const linearMatch = brief.match(/\*\*Linear:\*\* .+\/([A-Z]+-\d+)\//);
+          if (linearMatch) ticketLinearId = linearMatch[1];
+        }
+      } catch {
+      }
+      const commitMsg = buildCommitMessage(args.message, config.commit_template, {
+        title: ticketTitle,
+        type: ticketType,
+        linearTicketId: ticketLinearId
+      });
+      stageAll(gitCwd);
+      const sha = commit(commitMsg, gitCwd);
+      push(branch, gitCwd);
+      const result = {
+        commit: sha,
+        branch,
+        pushed: true
+      };
+      if (!config.ship_requires_checks && config.post_flight.length > 0) {
+        if (ctx.lastCheckPassedForRun !== args.pipelineRunId) {
+          result.warning = "Shipped without running post-flight checks.";
+        }
+      }
+      let prNumber;
+      let prUrl;
+      if (!args.skipPr) {
+        try {
+          const repoFullName = getRepoFullName(gitCwd);
+          const diffStats = getDiffStats(defaultBranch, branch, gitCwd);
+          const prBody = [
+            `## Summary`,
+            "",
+            ticketTitle,
+            "",
+            `## Changes`,
+            "",
+            "```",
+            diffStats,
+            "```",
+            "",
+            "---",
+            `Implemented via [yapout](https://yapout.dev) daemon`
+          ].join("\n");
+          const pr = await createPullRequest(
+            ticketTitle,
+            prBody,
+            branch,
+            defaultBranch,
+            repoFullName,
+            gitCwd
+          );
+          prNumber = pr.number;
+          prUrl = pr.url;
+          result.pr = { number: pr.number, url: pr.url };
+        } catch (err) {
+          result.prError = err.message;
+        }
+      }
+      try {
+        await ctx.client.mutation(
+          anyApi2.functions.pipelineRuns.reportDaemonEvent,
+          {
+            pipelineRunId: args.pipelineRunId,
+            event: "push_completed",
+            message: `Pushed ${sha.slice(0, 7)} to ${branch}`
+          }
+        );
+        if (prUrl) {
+          await ctx.client.mutation(
+            anyApi2.functions.pipelineRuns.reportDaemonEvent,
+            {
+              pipelineRunId: args.pipelineRunId,
+              event: "pr_opened",
+              message: `PR #${prNumber}: ${prUrl}`
+            }
+          );
+        }
+      } catch {
+      }
+      try {
+        await ctx.client.mutation(
+          anyApi2.functions.pipelineRuns.completePipelineLocal,
+          {
+            pipelineRunId: args.pipelineRunId,
+            githubPrNumber: prNumber,
+            githubPrUrl: prUrl
+          }
+        );
+        result.pipelineCompleted = true;
+      } catch (err) {
+        result.completionError = err.message;
+      }
+      if (ticketLinearId && ctx.projectId) {
+        try {
+          await ctx.client.action(
+            anyApi2.functions.linearStatusMutations.moveIssueStatus,
+            {
+              projectId: ctx.projectId,
+              linearIssueId: ticketLinearId,
+              statusType: "completed"
+            }
+          );
+        } catch {
+        }
+        if (prUrl) {
+          try {
+            await ctx.client.action(
+              anyApi2.functions.linearStatusMutations.addLinearComment,
+              {
+                projectId: ctx.projectId,
+                linearIssueId: ticketLinearId,
+                body: `PR opened: [#${prNumber}](${prUrl})`
+              }
+            );
+          } catch {
+          }
+        }
+      }
+      if (args.worktreePath) {
+        try {
+          removeWorktree(ctx.cwd, args.worktreePath);
+          result.worktreeCleaned = true;
+          try {
+            await ctx.client.mutation(
+              anyApi2.functions.pipelineRuns.reportDaemonEvent,
+              {
+                pipelineRunId: args.pipelineRunId,
+                event: "worktree_cleaned",
+                message: `Worktree removed: ${args.worktreePath}`
+              }
+            );
+          } catch {
+          }
+        } catch {
+          result.worktreeCleanError = "Failed to remove worktree. Run `yapout clean` later.";
+        }
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/check.ts
+import { z as z8 } from "zod";
+import { exec } from "child_process";
+var COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_OUTPUT_LINES = 100;
+function truncate(text) {
+  const lines = text.split("\n");
+  if (lines.length <= MAX_OUTPUT_LINES) return text;
+  return `... (${lines.length - MAX_OUTPUT_LINES} lines truncated)
+` + lines.slice(-MAX_OUTPUT_LINES).join("\n");
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve11) => {
+    const start = Date.now();
+    const child = exec(command, {
+      cwd,
+      timeout: COMMAND_TIMEOUT_MS,
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    }, (error, stdout, stderr) => {
+      resolve11({
+        exitCode: error?.code ?? (error ? 1 : 0),
+        stdout: truncate(stdout),
+        stderr: truncate(stderr),
+        durationMs: Date.now() - start
+      });
+    });
+    child.on("error", () => {
+      resolve11({
+        exitCode: 1,
+        stdout: "",
+        stderr: `Command timed out after ${COMMAND_TIMEOUT_MS / 1e3}s`,
+        durationMs: Date.now() - start
+      });
+    });
+  });
+}
+function registerCheckTool(server, ctx) {
+  server.tool(
+    "yapout_check",
+    "Run post-flight checks (lint, test, typecheck) before shipping. Configure commands in .yapout/config.yml",
+    {
+      commands: z8.array(z8.string()).optional().describe("Override: run these commands instead of post_flight config"),
+      pipelineRunId: z8.string().optional().describe("Pipeline run ID for event reporting"),
+      worktreePath: z8.string().optional().describe("Run checks in this worktree directory instead of the repo root")
+    },
+    async (args) => {
+      const checkCwd = args.worktreePath || ctx.cwd;
+      const config = readYapoutConfig(ctx.cwd);
+      const commands = args.commands ?? config.post_flight;
+      if (commands.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                passed: true,
+                results: [],
+                summary: "No post-flight checks configured. Add commands to .yapout/config.yml under post_flight."
+              })
+            }
+          ]
+        };
+      }
+      const results = [];
+      for (const command of commands) {
+        if (args.pipelineRunId) {
+          try {
+            await ctx.client.mutation(
+              anyApi2.functions.pipelineRuns.reportDaemonEvent,
+              {
+                pipelineRunId: args.pipelineRunId,
+                event: "running_check",
+                message: `Running: ${command}`
+              }
+            );
+          } catch {
+          }
+        }
+        const result = await runCommand(command, checkCwd);
+        const passed = result.exitCode === 0;
+        results.push({
+          command,
+          passed,
+          ...result
+        });
+        if (args.pipelineRunId) {
+          try {
+            await ctx.client.mutation(
+              anyApi2.functions.pipelineRuns.reportDaemonEvent,
+              {
+                pipelineRunId: args.pipelineRunId,
+                event: passed ? "check_passed" : "check_failed",
+                message: passed ? `Passed: ${command} (${(result.durationMs / 1e3).toFixed(1)}s)` : `Failed: ${command} (exit ${result.exitCode})`
+              }
+            );
+          } catch {
+          }
+        }
+      }
+      const passedCount = results.filter((r) => r.passed).length;
+      const allPassed = passedCount === results.length;
+      const failedNames = results.filter((r) => !r.passed).map((r) => r.command);
+      const summary = allPassed ? `${passedCount}/${results.length} checks passed` : `${passedCount}/${results.length} checks passed. Failed: ${failedNames.join(", ")}`;
+      if (allPassed && args.pipelineRunId) {
+        ctx.lastCheckPassedForRun = args.pipelineRunId;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ passed: allPassed, results, summary }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/bundle.ts
+import { z as z9 } from "zod";
+import { join as join9 } from "path";
+import { existsSync as existsSync8, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
+function registerBundleTool(server, ctx) {
+  server.tool(
+    "yapout_bundle",
+    "Add a ticket to the current ticket's bundle so they ship as one PR",
+    {
+      ticketId: z9.string().describe("Ticket ID to add to the bundle"),
+      withTicket: z9.string().describe("Lead ticket ID (currently being worked on)")
+    },
+    async (args) => {
+      const result = await ctx.client.mutation(
+        anyApi2.functions.tickets.bundleTickets,
+        { leadTicketId: args.withTicket, joiningTicketId: args.ticketId }
+      );
+      const bundledBrief = await ctx.client.query(
+        anyApi2.functions.tickets.getBundledBrief,
+        { bundleId: result.bundleId }
+      );
+      if (!bundledBrief) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                bundleId: result.bundleId,
+                message: "Bundled successfully but could not fetch combined brief."
+              })
+            }
+          ]
+        };
+      }
+      const sections = [
+        `# Bundle: ${bundledBrief.tickets.length} tickets`,
+        ""
+      ];
+      for (const t of bundledBrief.tickets) {
+        sections.push(`## ${t.linearTicketId ?? t.ticketId}: ${t.title}`);
+        sections.push("");
+        sections.push(`**Priority:** ${t.priority} | **Type:** ${t.type}`);
+        if (t.linearUrl) sections.push(`**Linear:** ${t.linearUrl}`);
+        sections.push("", t.description);
+        if (t.enrichedDescription) {
+          sections.push("", "### Enriched Description", "", t.enrichedDescription);
+        }
+        if (t.implementationBrief) {
+          sections.push("", "### Implementation Brief", "", t.implementationBrief);
+        }
+        sections.push("", "---", "");
+      }
+      if (bundledBrief.projectContext) {
+        sections.push("## Project Context", "", bundledBrief.projectContext);
+      }
+      const combinedBrief = sections.join("\n");
+      const yapoutDir = join9(ctx.cwd, ".yapout");
+      if (!existsSync8(yapoutDir)) mkdirSync7(yapoutDir, { recursive: true });
+      writeFileSync8(join9(yapoutDir, "brief.md"), combinedBrief);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                bundleId: result.bundleId,
+                tickets: bundledBrief.tickets.map((t) => ({
+                  ticketId: t.ticketId,
+                  title: t.title
+                })),
+                combinedBrief,
+                message: `${bundledBrief.tickets.length} tickets bundled. Brief updated.`
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/get-unenriched-tickets.ts
+import { z as z10 } from "zod";
+function registerGetUnenrichedTicketsTool(server, ctx) {
+  server.tool(
+    "yapout_get_unenriched_ticket",
+    `Start enriching a ticket. Returns the next draft ticket (or a specific one by ID) with full context including the original transcript quote, project context, and existing ticket titles for duplicate detection.
+
+The ticket is locked to "enriching" status \u2014 no other agent can enrich it concurrently.
+
+After calling this tool, you should:
+1. Read the relevant parts of the codebase to understand the area affected
+2. Check for duplicates against the existingTickets list
+3. If the decision is ambiguous, ask the developer clarifying questions in conversation
+4. When confident, call yapout_save_enrichment with a clean description, acceptance criteria, and implementation brief`,
+    {
+      ticketId: z10.string().optional().describe("Specific ticket ID to enrich. If omitted, returns the highest priority draft ticket.")
+    },
+    async (args) => {
+      const projectId = ctx.projectId ?? process.env.YAPOUT_PROJECT_ID;
+      if (!projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await ctx.client.mutation(
+          anyApi2.functions.localPipeline.claimForEnrichment,
+          {
+            projectId,
+            ...args.ticketId ? { ticketId: args.ticketId } : {}
+          }
+        );
+        if (!result) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No tickets need enrichment. All tickets are either already enriched or in progress."
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error claiming ticket for enrichment: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/get-existing-tickets.ts
+function registerGetExistingTicketsTool(server, ctx) {
+  server.tool(
+    "yapout_get_existing_tickets",
+    "Fetch all ticket titles in the project for duplicate detection during enrichment",
+    {},
+    async () => {
+      const projectId = ctx.projectId ?? process.env.YAPOUT_PROJECT_ID;
+      if (!projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const tickets = await ctx.client.query(
+          anyApi2.functions.localPipeline.getExistingTicketTitles,
+          { projectId }
+        );
+        if (!tickets || tickets.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No existing tickets in this project."
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(tickets, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching existing tickets: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/save-enrichment.ts
+import { z as z11 } from "zod";
+function registerSaveEnrichmentTool(server, ctx) {
+  server.tool(
+    "yapout_save_enrichment",
+    `Save enrichment and sync to Linear. Call this after you have read the codebase, asked any necessary clarifying questions, and formulated a clean description, acceptance criteria, and implementation brief.
+
+The ticket must have been claimed via yapout_get_unenriched_ticket first (status must be "enriching").
+
+This tool saves the enrichment, then automatically creates the Linear issue with:
+- Clean description + acceptance criteria as the issue body
+- Clarification Q&A as a branded comment (if any)
+- Implementation brief as attachment metadata
+
+The ticket transitions: enriching \u2192 enriched \u2192 synced.`,
+    {
+      ticketId: z11.string().describe("The ticket ID to enrich (from yapout_get_unenriched_ticket)"),
+      title: z11.string().describe("Refined ticket title \u2014 improve it if the original was vague"),
+      cleanDescription: z11.string().describe("Human-readable summary for the Linear issue body. Write the kind of ticket a senior engineer would write."),
+      acceptanceCriteria: z11.array(z11.string()).describe("List of testable acceptance criteria (each a single clear statement)"),
+      implementationBrief: z11.string().describe("Deep technical context for the implementing agent: which files, what approach, edge cases to watch for"),
+      clarifications: z11.array(
+        z11.object({
+          question: z11.string().describe("The question you asked the developer"),
+          answer: z11.string().describe("The developer's answer")
+        })
+      ).optional().describe("Only meaningful Q&A from the conversation \u2014 deviations from expected scope, scoping decisions, etc. Omit if you had no questions."),
+      isOversized: z11.boolean().optional().describe("Set to true if this ticket is too large for a single PR"),
+      suggestedSplit: z11.array(z11.string()).optional().describe("If oversized: suggested sub-ticket titles for breaking it down"),
+      level: z11.enum(["project", "issue"]).optional().describe("Override the decision's level if enrichment reveals it should be reclassified"),
+      nature: z11.enum(["implementable", "operational", "spike"]).optional().describe("Override the decision's nature if enrichment reveals it should be reclassified")
+    },
+    async (args) => {
+      try {
+        await ctx.client.mutation(
+          anyApi2.functions.localPipeline.saveLocalEnrichment,
+          {
+            ticketId: args.ticketId,
+            title: args.title,
+            cleanDescription: args.cleanDescription,
+            acceptanceCriteria: args.acceptanceCriteria,
+            implementationBrief: args.implementationBrief,
+            clarifications: args.clarifications,
+            isOversized: args.isOversized,
+            suggestedSplit: args.suggestedSplit,
+            level: args.level,
+            nature: args.nature
+          }
+        );
+        await ctx.client.action(
+          anyApi2.functions.localPipeline.syncTicketToLinearLocal,
+          { ticketId: args.ticketId }
+        );
+        const ticket = await ctx.client.query(
+          anyApi2.functions.tickets.getTicket,
+          { ticketId: args.ticketId }
+        );
+        const response = {
+          ticketId: args.ticketId,
+          linearIssueId: ticket?.linearTicketId ?? null,
+          linearUrl: ticket?.linearUrl ?? null,
+          message: ticket?.linearUrl ? `Ticket enriched and synced to Linear: ${ticket.linearUrl}` : "Ticket enriched and synced to Linear."
+        };
+        if (args.isOversized && args.suggestedSplit?.length) {
+          response.warning = `This ticket is oversized. Suggested split: ${args.suggestedSplit.join(", ")}`;
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error saving enrichment: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/sync-to-linear.ts
+import { z as z12 } from "zod";
+function registerSyncToLinearTool(server, ctx) {
+  server.tool(
+    "yapout_sync_to_linear",
+    "Trigger Linear ticket creation for an enriched ticket. The sync runs server-side (encrypted Linear token in Convex).",
+    {
+      ticketId: z12.string().describe("The ticket ID to sync to Linear")
+    },
+    async (args) => {
+      try {
+        await ctx.client.action(
+          anyApi2.functions.localPipeline.syncTicketToLinearLocal,
+          { ticketId: args.ticketId }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  success: true,
+                  ticketId: args.ticketId,
+                  message: "Ticket synced to Linear successfully. It will now appear in the work queue for implementation."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error syncing to Linear: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/submit-yap-session.ts
+import { z as z13 } from "zod";
+function registerSubmitYapSessionTool(server, ctx) {
+  server.tool(
+    "yapout_submit_yap_session",
+    "Submit a yap session transcript for decision extraction",
+    {
+      title: z13.string().describe("Session title (e.g., 'Notification system brainstorm')"),
+      transcript: z13.string().describe("Cleaned conversation transcript")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const transcriptId = await ctx.client.mutation(
+          anyApi2.functions.transcripts.createFromYapSession,
+          {
+            projectId: ctx.projectId,
+            title: args.title,
+            transcript: args.transcript
+          }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  transcriptId,
+                  message: "Yap session submitted. Decisions will appear for review shortly."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to submit yap session: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/start-yap.ts
+import { z as z14 } from "zod";
+var PERSONA_PRESETS = {
+  "tech lead": "You are an experienced tech lead. You care about maintainability, simplicity, and shipping. Challenge over-engineering and vague scope.",
+  "qa engineer": "You are a skeptical QA engineer. Focus on error states, edge cases, missing validation, accessibility, and user-facing failure modes.",
+  "product owner": "You are a product owner. Focus on user value, scope, prioritization, and whether features solve real problems. Push back on technical gold-plating.",
+  "end user": "You are an end user of this application. You're not technical. Focus on usability, clarity, frustration points, and what you'd expect to happen."
+};
+function resolvePersona(input) {
+  const lower = input.toLowerCase().trim();
+  return PERSONA_PRESETS[lower] ?? input;
+}
+function registerStartYapTool(server, ctx) {
+  server.tool(
+    "yapout_start_yap",
+    "Start a yap session \u2014 a structured AI-guided brainstorming conversation. Call this when the user wants to brainstorm, discuss ideas, or have a yap session. Returns instructions for how to conduct the session. Available personas: tech lead (default), qa engineer, product owner, end user, or any custom description.",
+    {
+      persona: z14.string().optional().describe(
+        'Interviewer persona: "tech lead", "qa engineer", "product owner", "end user", or a custom description'
+      ),
+      context: z14.string().optional().describe("What the developer wants to discuss")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      const persona = args.persona ?? "tech lead";
+      const personaBlock = resolvePersona(persona);
+      const contextSection = args.context ? `The developer wants to discuss: ${args.context}. Start by reading relevant parts of the codebase, then open with a specific question about their idea.` : "Start by asking the developer what they'd like to discuss. Read the codebase first to understand the project.";
+      const instructions = `You are now in a yapout yap session \u2014 a structured brainstorming conversation about this codebase.
+
+YOUR ROLE: ${personaBlock}
+
+WHAT YOU DO:
+- Have a natural, focused conversation about the developer's idea
+- Read files from the codebase to inform your questions (package.json, schema, relevant source files)
+- Ask ONE question at a time \u2014 don't overwhelm
+- Push back on vague statements: "What do you mean by 'better'? Better for whom?"
+- Surface edge cases: "What happens when the user has no internet?"
+- Reference actual code: "I see you have a stateMachines.ts \u2014 should this new status go there?"
+- When the developer makes a clear decision, acknowledge it and move to the next topic
+- Keep the conversation productive \u2014 steer away from tangents
+
+WHAT YOU DON'T DO:
+- Don't implement anything. Don't write code. Don't edit files. Just discuss.
+- Don't agree with everything. Challenge ideas that seem undercooked.
+- Don't ask more than 5 questions without letting the developer steer.
+- Don't make changes to the codebase, even if the user asks. A yap session produces decisions and tickets \u2014 implementation happens later through the normal ticket pipeline. If the user asks you to "just do it" or "make that change now," push back: "That's what the tickets are for. Let's capture it properly so it goes through review." This boundary is critical \u2014 implementing during a yap bypasses every approval gate yapout exists to enforce.
+
+${contextSection}
+
+DURING THE SESSION \u2014 COMPLETENESS TRACKING:
+As the conversation progresses, you are building a mental model of every decision. For each decision, track:
+- What has been clearly stated (title, scope, priority)
+- What has been discussed in enough depth to write a ticket (enrichment)
+- What is still vague, contradicted, or unanswered
+
+The conversation does NOT need to follow a rigid structure. The user may jump between topics, change their mind, go on tangents, or revisit earlier decisions. This is normal \u2014 real conversations are not linear. Your job is to follow the thread and keep track of the state of each decision regardless of conversation order.
+
+If the user contradicts an earlier statement, note it and confirm which version they mean when the time is right. Don't interrupt the flow for minor clarifications \u2014 batch them for later.
+
+BEFORE SUBMITTING \u2014 GAP FILLING:
+Before you submit, review your mental model of every decision. For each one, ask yourself:
+- Could a developer read this ticket and start working without asking questions?
+- Are the acceptance criteria specific enough to verify?
+- Are there ambiguities the user didn't resolve?
+
+If there are gaps, ask the user to fill them. Be direct: "Before I submit, I need clarity on a few things..." Group related gaps together rather than asking one at a time.
+
+You do NOT need to fill every gap. If the conversation didn't cover something deeply enough, mark that decision as NOT enriched \u2014 it will go through the async enrichment pipeline later. Be honest about what you know vs. what you're guessing.
+
+ENRICHMENT ASSESSMENT:
+For each decision, you must make an honest call: is this enriched or not?
+
+Mark a decision as ENRICHED (isEnriched: true) when:
+- The conversation covered it thoroughly enough to produce a clear ticket
+- You can write an enrichedDescription that a senior engineer would recognize as well-scoped
+- You can write at least 2-3 testable acceptance criteria
+- The user explicitly validated the scope (not just mentioned it in passing)
+
+Mark a decision as NOT ENRICHED (isEnriched: false or omitted) when:
+- It came up late in the conversation without much discussion
+- The user mentioned it but didn't elaborate on scope or requirements
+- You're uncertain about key aspects (what it should do, how it should work)
+- It's a spike or needs further scoping
+
+This is a quality gate. Do not inflate your assessment \u2014 unenriched tickets get enriched properly later. Falsely marking something as enriched skips that process and produces bad tickets.
+
+PRESENTING THE FINAL PICTURE:
+When the conversation feels complete, present a summary grouped by project:
+
+"Here's what I've gathered from our conversation:
+
+**[Project Name]** \u2014 [one-line description]
+  1. [Child issue] \u2014 enriched \u2713
+  2. [Child issue] \u2014 enriched \u2713
+  3. [Child issue] \u2014 needs enrichment (we didn't discuss scope)
+
+**Standalone issues:**
+  4. [Issue] \u2014 enriched \u2713
+
+[Any open questions you still need answered]
+
+Should I submit this to yapout?"
+
+SUBMITTING:
+On confirmation, call yapout_extract_from_yap with the full data.
+
+For each decision, provide:
+- title, description, sourceQuote, type, priority, confidence, level, nature
+- isEnriched: your honest assessment (see above)
+
+For ENRICHED decisions (isEnriched: true), also include:
+- enrichedDescription: clean, final description \u2014 write the kind of ticket a senior engineer would write
+- acceptanceCriteria: array of specific, testable statements
+- implementationBrief: (optional) technical context \u2014 files, approach, edge cases. Only include if you read the codebase during the session. The implementing agent reads the codebase anyway.
+- clarifications: relevant Q&A from the conversation that shaped the decision
+
+For PROJECT-level decisions, also include:
+- projectDescription: what this body of work accomplishes
+- suggestedOrder: implementation sequencing ("Phase 1: A, then Phase 2: B+C")
+- children: array of child issues (each with their own enrichment data)
+
+For children with DEPENDENCIES, include:
+- dependsOn: array of sibling indices (0-based) that must complete first
+
+Structure:
+- Projects include children inline \u2014 never create child issues as separate top-level decisions
+- Standalone issues go at the top level
+- The hierarchy you produce should be the final structure
+
+Call yapout_extract_from_yap with:
+- sessionTitle: descriptive title for this session
+- sessionTranscript: clean summary of the conversation (meeting-notes style)
+- decisions: the array (projects with children, standalone issues)
+
+This creates decisions (as converted \u2014 your participation was the approval), tickets (enriched or draft based on your assessment), and project decomposition \u2014 all in one call. Enriched tickets appear in the work queue ready for the user to sync to Linear.
+
+Only fall back to yapout_submit_yap_session if the session was purely exploratory with no clear actionable decisions.
+
+--- BEGIN THE SESSION NOW ---`;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                projectId: ctx.projectId,
+                projectName: ctx.projectName,
+                persona,
+                instructions
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/extract-from-yap.ts
+import { z as z15 } from "zod";
+var clarificationSchema = z15.object({
+  question: z15.string().describe("The question asked during the conversation"),
+  answer: z15.string().describe("The answer given")
+});
+var childSchema = z15.object({
+  title: z15.string().describe("Child issue title"),
+  description: z15.string().describe("What needs to be done and why"),
+  sourceQuote: z15.string().describe("Relevant excerpt from the conversation"),
+  type: z15.enum(["feature", "bug", "chore"]).describe("Decision category"),
+  priority: z15.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
+  confidence: z15.number().min(0).max(1).describe("Confidence this is a clear, actionable decision (0-1)"),
+  nature: z15.enum(["implementable", "operational", "spike"]).describe("What kind of work"),
+  // Enrichment — set isEnriched: true only if the conversation covered this
+  // issue thoroughly enough to produce a ticket a developer could pick up.
+  isEnriched: z15.boolean().optional().describe(
+    "Did the conversation cover this issue deeply enough to produce a complete ticket? true = enriched (ready for Linear), false/omitted = draft (needs async enrichment)"
+  ),
+  enrichedDescription: z15.string().optional().describe("Clean, final description for the Linear issue body (required if isEnriched)"),
+  acceptanceCriteria: z15.array(z15.string()).optional().describe("Testable acceptance criteria (required if isEnriched)"),
+  implementationBrief: z15.string().optional().describe("Technical context: files, approach, edge cases (optional \u2014 the implementing agent reads the codebase anyway)"),
+  clarifications: z15.array(clarificationSchema).optional().describe("Relevant Q&A from the conversation that shaped this decision"),
+  dependsOn: z15.array(z15.number()).optional().describe("Indices (0-based) of sibling children that must be completed first")
+});
+function registerExtractFromYapTool(server, ctx) {
+  server.tool(
+    "yapout_extract_from_yap",
+    "Submit decisions from a yap session you conducted. The yap session IS the enrichment \u2014 you participated in the conversation, gathered context, and can assess completeness per-decision. Creates transcript, decisions (as converted), and tickets (enriched or draft). Enriched tickets are ready for the user to sync to Linear from the UI. Draft tickets need further enrichment via the async pipeline.",
+    {
+      sessionTitle: z15.string().describe("Descriptive title for this yap session"),
+      sessionTranscript: z15.string().describe("Cleaned transcript of the conversation (meeting-notes style)"),
+      decisions: z15.array(
+        z15.object({
+          title: z15.string().describe("Decision title"),
+          description: z15.string().describe("What needs to be done and why"),
+          sourceQuote: z15.string().describe("Relevant excerpt from the conversation"),
+          type: z15.enum(["feature", "bug", "chore"]).describe("Decision category (do not use spike \u2014 use nature instead)"),
+          priority: z15.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
+          confidence: z15.number().min(0).max(1).describe("Your confidence this is a clear, actionable decision (0-1)"),
+          level: z15.enum(["project", "issue"]).describe("project = body of work with children, issue = single unit"),
+          nature: z15.enum(["implementable", "operational", "spike"]).describe("implementable = code changes, operational = manual task, spike = needs scoping"),
+          sourceDecisionId: z15.string().optional().describe("ID of an existing decision this scopes (e.g., scoping a spike)"),
+          // Issue-level enrichment (when level === "issue")
+          isEnriched: z15.boolean().optional().describe("For standalone issues: was this thoroughly discussed? true = enriched, false = draft"),
+          enrichedDescription: z15.string().optional().describe("Clean description for Linear (standalone issues only, required if isEnriched)"),
+          acceptanceCriteria: z15.array(z15.string()).optional().describe("Testable acceptance criteria (standalone issues only, required if isEnriched)"),
+          implementationBrief: z15.string().optional().describe("Technical context (standalone issues only, optional)"),
+          clarifications: z15.array(clarificationSchema).optional().describe("Relevant Q&A from conversation (standalone issues only)"),
+          // Project-level fields (when level === "project")
+          projectDescription: z15.string().optional().describe("What this body of work accomplishes (projects only)"),
+          suggestedOrder: z15.string().optional().describe("Implementation order: 'Phase 1: A, then Phase 2: B+C' (projects only)"),
+          children: z15.array(childSchema).optional().describe("Child issues for project-level decisions")
+        })
+      ).describe("Decisions from the conversation. Projects include children inline.")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await ctx.client.mutation(
+          anyApi2.functions.transcripts.extractFromYapSession,
+          {
+            projectId: ctx.projectId,
+            title: args.sessionTitle,
+            transcript: args.sessionTranscript,
+            decisions: args.decisions
+          }
+        );
+        let enrichedCount = 0;
+        let draftCount = 0;
+        let totalTickets = 0;
+        for (const item of result.items) {
+          if (item.level === "project") {
+            for (const child of item.children ?? []) {
+              totalTickets++;
+              if (child.ticketStatus === "enriched") enrichedCount++;
+              else draftCount++;
+            }
+          } else {
+            totalTickets++;
+            if (item.ticketStatus === "enriched") enrichedCount++;
+            else draftCount++;
+          }
+        }
+        const parts = [];
+        if (enrichedCount > 0) parts.push(`${enrichedCount} enriched (ready for Linear)`);
+        if (draftCount > 0) parts.push(`${draftCount} need enrichment`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  transcriptId: result.transcriptId,
+                  items: result.items,
+                  summary: {
+                    totalTickets,
+                    enriched: enrichedCount,
+                    needsEnrichment: draftCount
+                  },
+                  message: `Created ${totalTickets} ticket${totalTickets === 1 ? "" : "s"}: ${parts.join(", ")}. Review in the yapout work queue.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to extract from yap session: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/save-project-enrichment.ts
+import { z as z16 } from "zod";
+function registerSaveProjectEnrichmentTool(server, ctx) {
+  server.tool(
+    "yapout_save_project_enrichment",
+    `Save the decomposition of a project-level decision into implementable child issues.
+
+Call this after enriching a ticket with level: "project". The agent should have:
+1. Read the codebase extensively
+2. Asked the user scoping questions
+3. Produced a set of child issues with dependencies
+
+This tool creates child decisions and tickets in yapout, transitions the original
+ticket to "decomposed", and returns the child ticket IDs for subsequent Linear sync.
+
+Each child issue's implementation brief must be detailed enough to stand alone as a
+full spec \u2014 schema changes, files to modify, edge cases, and acceptance criteria.`,
+    {
+      ticketId: z16.string().describe("The project-level ticket being decomposed (from yapout_get_unenriched_ticket)"),
+      projectDescription: z16.string().describe("Description for the project \u2014 what this body of work accomplishes"),
+      suggestedOrder: z16.string().describe("Human-readable implementation order (e.g. 'Phase 1: A, then Phase 2: B+C in parallel, then Phase 3: D')"),
+      linearProjectId: z16.string().optional().describe("Existing Linear project ID to associate child issues with. Omit to skip Linear project association \u2014 issues will be synced without a project."),
+      issues: z16.array(
+        z16.object({
+          title: z16.string().describe("Child issue title"),
+          description: z16.string().describe("What needs to be done and why"),
+          acceptanceCriteria: z16.array(z16.string()).describe("Testable acceptance criteria"),
+          implementationBrief: z16.string().describe("Full spec: files to modify, schema changes, edge cases, approach"),
+          type: z16.enum(["feature", "bug", "chore"]).describe("Category of work"),
+          priority: z16.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
+          dependsOn: z16.array(z16.number()).describe("Indices (0-based) of issues in this array that must be completed first")
+        })
+      ).describe("The child issues produced by decomposition")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await ctx.client.mutation(
+          anyApi2.functions.localPipeline.saveProjectEnrichment,
+          {
+            ticketId: args.ticketId,
+            projectDescription: args.projectDescription,
+            suggestedOrder: args.suggestedOrder,
+            linearProjectId: args.linearProjectId,
+            issues: args.issues
+          }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ticketId: result.ticketId,
+                  status: "decomposed",
+                  childTicketIds: result.childTicketIds,
+                  suggestedOrder: result.suggestedOrder,
+                  message: `Project decomposed into ${result.childTicketIds.length} child issues. Original ticket marked as decomposed. Child tickets are in draft status \u2014 enrich and sync each one individually, or approve them for the user to review.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error saving project enrichment: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/mark-duplicate.ts
+import { z as z17 } from "zod";
+function registerMarkDuplicateTool(server, ctx) {
+  server.tool(
+    "yapout_mark_duplicate",
+    `Mark a ticket as a duplicate of existing Linear work. Use this during any enrichment
+flow when you discover the work is already tracked in Linear.
+
+The ticket must be in "enriching" or "enriched" status. It will be transitioned to
+"failed" with the duplicate reference stored. Nothing is synced to Linear.`,
+    {
+      ticketId: z17.string().describe("The yapout ticket to archive as a duplicate"),
+      duplicateOfLinearId: z17.string().describe("The Linear issue identifier it duplicates (e.g. 'ENG-234')"),
+      reason: z17.string().describe("Brief explanation of why this is a duplicate")
+    },
+    async (args) => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await ctx.client.mutation(
+          anyApi2.functions.tickets.markDuplicate,
+          {
+            ticketId: args.ticketId,
+            duplicateOfLinearId: args.duplicateOfLinearId,
+            reason: args.reason
+          }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  ticketId: result.ticketId,
+                  status: "failed",
+                  duplicateOf: result.duplicateOfLinearId,
+                  message: `Ticket archived as duplicate of ${args.duplicateOfLinearId}. Nothing synced to Linear.`
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error marking duplicate: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/get-linear-projects.ts
+function registerGetLinearProjectsTool(server, ctx) {
+  server.tool(
+    "yapout_get_linear_projects",
+    `Fetch active Linear projects for the current team.
+
+Use this during project enrichment to check if an existing Linear project matches
+the one you're about to create. Returns a list of active projects with descriptions
+and issue counts so you can ask the user for confirmation before creating a new one.`,
+    {},
+    async () => {
+      if (!ctx.projectId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No project linked. Run yapout_init or yapout link first."
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const project = await ctx.client.query(
+          anyApi2.functions.projects.getProject,
+          { projectId: ctx.projectId }
+        );
+        if (!project?.linearTeamId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No Linear team configured. Go to project Settings and select a Linear team."
+              }
+            ],
+            isError: true
+          };
+        }
+        const projects = await ctx.client.action(
+          anyApi2.functions.linearProjectsMutations.fetchProjectsDetailed,
+          { teamId: project.linearTeamId }
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  teamId: project.linearTeamId,
+                  projects,
+                  message: projects.length > 0 ? `Found ${projects.length} active Linear project${projects.length === 1 ? "" : "s"}. Check if any match before creating a new one.` : "No active Linear projects found. A new one will be created during project decomposition."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error fetching Linear projects: ${err.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/server.ts
+async function startMcpServer() {
+  const cwd = process.cwd();
+  const credentials = readCredentials();
+  if (!credentials) {
+    console.error(
+      "[yapout] Not logged in. Run `yapout login` first."
+    );
+    process.exit(1);
+  }
+  if (Date.now() > credentials.expiresAt) {
+    console.error(
+      "[yapout] Session expired. Run `yapout login` to re-authenticate."
+    );
+    process.exit(1);
+  }
+  const mapping = getProjectMapping(cwd);
+  const envProjectId = process.env.YAPOUT_PROJECT_ID;
+  const client = new ConvexHttpClient2(getConvexUrl());
+  client.setAuth(credentials.token);
+  const ctx = {
+    client,
+    projectId: envProjectId ?? mapping?.projectId ?? null,
+    projectName: mapping?.projectName ?? null,
+    cwd,
+    credentials,
+    lastCheckPassedForRun: null
+  };
+  const server = new McpServer({
+    name: "yapout",
+    version: "0.1.0"
+  });
+  registerInitTool(server, ctx);
+  registerCompactTool(server, ctx);
+  registerUpdateContextTool(server, ctx);
+  registerQueueTool(server, ctx);
+  registerGetBriefTool(server, ctx);
+  registerClaimTool(server, ctx);
+  registerEventTool(server, ctx);
+  registerShipTool(server, ctx);
+  registerCheckTool(server, ctx);
+  registerBundleTool(server, ctx);
+  registerGetUnenrichedTicketsTool(server, ctx);
+  registerGetExistingTicketsTool(server, ctx);
+  registerSaveEnrichmentTool(server, ctx);
+  registerSyncToLinearTool(server, ctx);
+  registerSubmitYapSessionTool(server, ctx);
+  registerStartYapTool(server, ctx);
+  registerExtractFromYapTool(server, ctx);
+  registerSaveProjectEnrichmentTool(server, ctx);
+  registerMarkDuplicateTool(server, ctx);
+  registerGetLinearProjectsTool(server, ctx);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/mcp-server.ts
+var mcpServerCommand = new Command7("mcp-server").description("Start the MCP server (used by Claude Code)").action(async () => {
+  await startMcpServer();
+});
+
+// src/commands/worktrees.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import { resolve as resolve5 } from "path";
+var worktreesCommand = new Command8("worktrees").description("List active yapout worktrees").action(() => {
+  const cwd = resolve5(process.cwd());
+  const worktrees = listWorktrees(cwd);
+  if (worktrees.length === 0) {
+    console.log(chalk8.dim("No active yapout worktrees."));
+    return;
+  }
+  console.log(chalk8.bold("Active worktrees:\n"));
+  for (const wt of worktrees) {
+    console.log(
+      `  ${chalk8.cyan(wt.path)}  ${chalk8.green(wt.branch)}` + (wt.ticketId ? `  ${chalk8.dim(`(${wt.ticketId})`)}` : "")
+    );
+  }
+  console.log();
+});
+
+// src/commands/clean.ts
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+import { resolve as resolve6 } from "path";
+var cleanCommand = new Command9("clean").description("Remove worktrees for completed or failed tickets").action(async () => {
+  const creds = requireAuth();
+  const cwd = resolve6(process.cwd());
+  const worktrees = listWorktrees(cwd);
+  if (worktrees.length === 0) {
+    console.log(chalk9.dim("No worktrees to clean."));
+    return;
+  }
+  const client = createConvexClient(creds.token);
+  let cleaned = 0;
+  for (const wt of worktrees) {
+    if (!wt.ticketId) continue;
+    try {
+      const ticket = await client.query(
+        anyApi.functions.tickets.getTicket,
+        { ticketId: wt.ticketId }
+      );
+      const isStale = !ticket || ticket.status === "failed" || ticket.status === "workflow2_done";
+      if (isStale) {
+        const label = ticket ? `${ticket.status}: ${ticket.title}` : "ticket not found";
+        console.log(
+          chalk9.dim(`Removing worktree for ${wt.ticketId} (${label})...`)
+        );
+        removeWorktree(cwd, wt.path);
+        cleaned++;
+      }
+    } catch {
+    }
+  }
+  if (cleaned === 0) {
+    console.log(chalk9.dim("All worktrees are still active."));
+  } else {
+    console.log(
+      chalk9.green(
+        `Cleaned ${cleaned} worktree${cleaned === 1 ? "" : "s"}.`
+      )
+    );
+  }
+});
+
+// src/commands/watch.ts
+import { Command as Command10 } from "commander";
+import { resolve as resolve7 } from "path";
+import {
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync9,
+  existsSync as existsSync10,
+  unlinkSync as unlinkSync3
+} from "fs";
+import { join as join11 } from "path";
+import chalk11 from "chalk";
+import { ConvexHttpClient as ConvexHttpClient3 } from "convex/browser";
+
+// src/daemon/watcher.ts
+import { anyApi as anyApi4 } from "convex/server";
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8 } from "fs";
+import { join as join10 } from "path";
+import { hostname as osHostname } from "os";
+
+// src/daemon/heartbeat.ts
+import { anyApi as anyApi3 } from "convex/server";
+var HEARTBEAT_INTERVAL = 3e4;
+var Heartbeat = class {
+  client;
+  sessionId;
+  timer = null;
+  constructor(client, sessionId) {
+    this.client = client;
+    this.sessionId = sessionId;
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.beat(), HEARTBEAT_INTERVAL);
+    this.timer.unref();
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async beat(status, currentTicketId, currentBranch, worktreePath) {
+    try {
+      const args = { sessionId: this.sessionId };
+      if (status) args.status = status;
+      if (currentTicketId) args.currentTicketId = currentTicketId;
+      if (currentBranch) args.currentBranch = currentBranch;
+      if (worktreePath) args.worktreePath = worktreePath;
+      await this.client.mutation(anyApi3.functions.agents.agentHeartbeat, args);
+    } catch {
+    }
+  }
+};
+
+// src/daemon/spawner.ts
+import { spawn } from "child_process";
+
+// src/daemon/notifications.ts
+var notifier = null;
+async function getNotifier() {
+  if (notifier !== null) return notifier;
+  try {
+    const mod = await import("node-notifier");
+    notifier = mod.default;
+    return notifier;
+  } catch {
+    notifier = { notify: () => {
+    } };
+    return notifier;
+  }
+}
+async function notify(message) {
+  const n = await getNotifier();
+  n?.notify({ title: "yapout", message });
+}
+async function notifyShipped(ticketRef, prNumber) {
+  await notify(`${ticketRef} shipped \u2014 PR #${prNumber}`);
+}
+async function notifyFailed(ticketRef, reason) {
+  await notify(
+    `${ticketRef} implementation failed${reason ? ` \u2014 ${reason}` : " \u2014 check logs"}`
+  );
+}
+async function notifyEnrichmentDone(ticketRef) {
+  await notify(`${ticketRef} enriched \u2014 ready for implementation`);
+}
+
+// src/daemon/spawner.ts
+var Spawner = class {
+  agents = /* @__PURE__ */ new Map();
+  callbacks;
+  projectId;
+  shuttingDown = false;
+  constructor(projectId, callbacks) {
+    this.projectId = projectId;
+    this.callbacks = callbacks;
+  }
+  get activeCount() {
+    return this.agents.size;
+  }
+  get activeAgents() {
+    return Array.from(this.agents.values()).map((a) => ({
+      ticketRef: a.ticketRef,
+      title: a.title,
+      phase: a.phase,
+      worktree: a.worktreePath,
+      startedAt: a.startedAt
+    }));
+  }
+  isRunning(ticketRef) {
+    return this.agents.has(ticketRef);
+  }
+  spawnEnrichmentAgent(ticketId, ticketRef, title, worktreePath) {
+    if (this.shuttingDown) return;
+    const prompt = [
+      `A ticket has been approved and needs enrichment before implementation.`,
+      `Call yapout_get_unenriched_ticket with ticketId "${ticketId}" to fetch the ticket details.`,
+      ``,
+      `Read the codebase to understand the project structure, then produce:`,
+      `1. An implementation brief (3-5 sentences, specific files/patterns involved)`,
+      `2. An enriched description with technical context`,
+      `3. Clarifying questions (0-5) where the answer can't be inferred`,
+      `4. Duplicate check \u2014 call yapout_get_existing_tickets and compare`,
+      `5. Scope assessment (is this too large for one PR?)`,
+      ``,
+      `Call yapout_save_enrichment with your analysis.`,
+      `If no questions were generated, also call yapout_sync_to_linear to create the Linear ticket.`
+    ].join("\n");
+    this.spawnAgent(ticketRef, title, "enrich", worktreePath, prompt);
+  }
+  spawnImplementationAgent(ticketRef, title, worktreePath) {
+    if (this.shuttingDown) return;
+    const prompt = [
+      `Use yapout to implement ticket "${ticketRef}: ${title}".`,
+      `Claim it with yapout_claim (use worktree mode), read the brief,`,
+      `implement the changes, run yapout_check, then ship with yapout_ship.`
+    ].join(" ");
+    this.spawnAgent(ticketRef, title, "implement", worktreePath, prompt);
+  }
+  spawnAgent(ticketRef, title, stage, worktreePath, prompt) {
+    const env = {
+      ...process.env,
+      YAPOUT_PROJECT_ID: this.projectId
+    };
+    const child = spawn("claude", ["--dangerously-skip-permissions", prompt], {
+      cwd: worktreePath,
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+      // On Windows, shell: true is needed for .cmd executables
+      shell: process.platform === "win32"
+    });
+    const agent = {
+      process: child,
+      ticketRef,
+      title,
+      stage,
+      worktreePath,
+      startedAt: Date.now(),
+      phase: stage === "enrich" ? "reading codebase" : "starting"
+    };
+    this.agents.set(ticketRef, agent);
+    this.callbacks.onAgentStart(agent);
+    this.callbacks.onEvent({
+      time: Date.now(),
+      icon: "\u25B6",
+      message: `${ticketRef} ${stage === "enrich" ? "enrichment" : "agent"} started`
+    });
+    let stdoutBuffer = "";
+    child.stdout?.on("data", (data) => {
+      stdoutBuffer += data.toString();
+      const phase = this.detectPhase(stdoutBuffer, stage);
+      if (phase && phase !== agent.phase) {
+        agent.phase = phase;
+        this.callbacks.onAgentPhase(agent, phase);
+      }
+    });
+    child.stderr?.on("data", () => {
+    });
+    child.on("close", (code) => {
+      this.agents.delete(ticketRef);
+      this.callbacks.onAgentComplete(agent, code);
+      if (code === 0) {
+        if (stage === "enrich") {
+          this.callbacks.onEvent({
+            time: Date.now(),
+            icon: "\u2713",
+            message: `${ticketRef} enrichment complete`
+          });
+          notifyEnrichmentDone(ticketRef);
+        } else {
+          this.callbacks.onEvent({
+            time: Date.now(),
+            icon: "\u2713",
+            message: `${ticketRef} shipped`
+          });
+          notifyShipped(ticketRef, 0);
+        }
+      } else {
+        this.callbacks.onEvent({
+          time: Date.now(),
+          icon: "\u2717",
+          message: `${ticketRef} ${stage} failed (exit ${code})`
+        });
+        notifyFailed(ticketRef);
+      }
+    });
+    child.on("error", (err) => {
+      this.agents.delete(ticketRef);
+      this.callbacks.onEvent({
+        time: Date.now(),
+        icon: "\u2717",
+        message: `${ticketRef} spawn error: ${err.message}`
+      });
+    });
+  }
+  detectPhase(output, stage) {
+    const lower = output.toLowerCase();
+    if (stage === "enrich") {
+      if (lower.includes("yapout_save_enrichment")) return "saving enrichment";
+      if (lower.includes("yapout_sync_to_linear")) return "syncing to linear";
+      if (lower.includes("yapout_get_existing_tickets")) return "checking duplicates";
+      if (lower.includes("reading") || lower.includes("exploring")) return "reading codebase";
+      return null;
+    }
+    if (lower.includes("yapout_ship")) return "shipping";
+    if (lower.includes("yapout_check")) return "running checks";
+    if (lower.includes("writing") || lower.includes("editing")) return "writing code";
+    if (lower.includes("yapout_claim")) return "claiming ticket";
+    if (lower.includes("reading") || lower.includes("exploring")) return "reading codebase";
+    return null;
+  }
+  async gracefulShutdown() {
+    this.shuttingDown = true;
+    if (this.agents.size === 0) return;
+    const timeout = 10 * 60 * 1e3;
+    const start = Date.now();
+    await new Promise((resolve11) => {
+      const check = () => {
+        if (this.agents.size === 0 || Date.now() - start > timeout) {
+          resolve11();
+          return;
+        }
+        setTimeout(check, 2e3);
+      };
+      check();
+    });
+  }
+  forceKill() {
+    for (const agent of this.agents.values()) {
+      agent.process.kill("SIGTERM");
+    }
+    this.agents.clear();
+  }
+};
+
+// src/daemon/display.ts
+import chalk10 from "chalk";
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h ${minutes % 60}m`;
+}
+function formatTime(timestamp) {
+  return new Date(timestamp).toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true
+  });
+}
+function truncate2(str, max) {
+  return str.length > max ? str.slice(0, max - 1) + "\u2026" : str;
+}
+function render(state) {
+  const now = Date.now();
+  const lines = [];
+  const activeCount = state.activeAgents.length;
+  const queuedCount = state.queuedTickets.length;
+  const statusParts = [];
+  if (activeCount > 0) statusParts.push(`${activeCount} agent${activeCount === 1 ? "" : "s"} active`);
+  if (queuedCount > 0) statusParts.push(`${queuedCount} queued`);
+  const statusLine = statusParts.length > 0 ? statusParts.join(" | ") : "idle";
+  lines.push(
+    `${chalk10.bold("yapout watch")} \u2014 ${state.projectName}`
+  );
+  lines.push(`${chalk10.green("Watching")} | ${statusLine}`);
+  lines.push("");
+  for (const agent of state.activeAgents) {
+    const elapsed = formatElapsed(now - agent.startedAt);
+    const wt = agent.worktree ? chalk10.dim(`worktree/${agent.ticketRef.toLowerCase()}`) : "";
+    lines.push(
+      `  ${chalk10.green("\u25CF")} ${chalk10.bold(agent.ticketRef)}  ${chalk10.dim(truncate2(`"${agent.title}"`, 35))}  ${chalk10.yellow(agent.phase)}  ${wt}  ${chalk10.dim(elapsed)}`
+    );
+  }
+  for (const ticket of state.queuedTickets) {
+    lines.push(
+      `  ${chalk10.dim("\u25CB")} ${chalk10.bold(ticket.ticketRef)}  ${chalk10.dim(truncate2(`"${ticket.title}"`, 35))}  ${chalk10.dim("queued")}`
+    );
+  }
+  if (state.activeAgents.length > 0 || state.queuedTickets.length > 0) {
+    lines.push("");
+  }
+  if (state.recentEvents.length > 0) {
+    lines.push(chalk10.dim("Recent:"));
+    for (const event of state.recentEvents.slice(0, 8)) {
+      lines.push(
+        `  ${chalk10.dim(formatTime(event.time))}  ${event.icon} ${event.message}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push(chalk10.dim("Ctrl+C to stop (agents will finish)"));
+  return lines.join("\n");
+}
+function clearAndRender(state) {
+  process.stdout.write("\x1B[2J\x1B[H");
+  process.stdout.write(render(state) + "\n");
+}
+
+// src/daemon/watcher.ts
+var POLL_INTERVAL = 1e4;
+var TOKEN_EXPIRY_BUFFER = 60 * 60 * 1e3;
+var Watcher = class {
+  client;
+  heartbeat;
+  spawner;
+  sessionId;
+  options;
+  pollTimer = null;
+  running = false;
+  recentEvents = [];
+  maxAgents;
+  constructor(options, client) {
+    this.options = options;
+    this.client = client;
+    this.sessionId = crypto.randomUUID();
+    this.maxAgents = getMaxAgents();
+    this.heartbeat = new Heartbeat(client, this.sessionId);
+    this.spawner = new Spawner(options.projectId, {
+      onAgentStart: (agent) => this.onAgentStart(agent),
+      onAgentPhase: () => this.updateDisplay(),
+      onAgentComplete: (agent, code) => this.onAgentComplete(agent, code),
+      onEvent: (event) => this.addEvent(event)
+    });
+  }
+  async start() {
+    this.running = true;
+    if (this.options.credentials.expiresAt - Date.now() < TOKEN_EXPIRY_BUFFER) {
+      console.error(
+        "Session expires soon. Run `yapout login` to re-authenticate."
+      );
+      process.exit(1);
+    }
+    await this.client.mutation(anyApi4.functions.agents.registerAgent, {
+      projectId: this.options.projectId,
+      sessionId: this.sessionId,
+      machineHostname: this.getHostname()
+    });
+    this.heartbeat.start();
+    this.prefetch();
+    await this.recoverOrphanedWorktrees();
+    this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL);
+    await this.poll();
+    this.addEvent({
+      time: Date.now(),
+      icon: "\u25B6",
+      message: "Watcher started"
+    });
+    if (!this.options.background) {
+      this.updateDisplay();
+    }
+  }
+  async stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.heartbeat.stop();
+    if (this.spawner.activeCount > 0) {
+      if (!this.options.background) {
+        console.log(
+          `
+Waiting for ${this.spawner.activeCount} agent(s) to finish...`
+        );
+      }
+      await this.spawner.gracefulShutdown();
+    }
+    try {
+      await this.client.mutation(anyApi4.functions.agents.unregisterAgent, {
+        sessionId: this.sessionId
+      });
+    } catch {
+    }
+  }
+  forceStop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.heartbeat.stop();
+    this.spawner.forceKill();
+    this.client.mutation(anyApi4.functions.agents.unregisterAgent, {
+      sessionId: this.sessionId
+    }).catch(() => {
+    });
+  }
+  async poll() {
+    if (!this.running) return;
+    try {
+      if (this.options.credentials.expiresAt - Date.now() < TOKEN_EXPIRY_BUFFER) {
+        this.addEvent({
+          time: Date.now(),
+          icon: "\u26A0",
+          message: "Session expiring soon \u2014 run `yapout login`"
+        });
+        return;
+      }
+      const slotsAvailable = this.maxAgents - this.spawner.activeCount;
+      if (slotsAvailable <= 0) return;
+      if (this.options.config.auto_enrich) {
+        await this.checkForEnrichmentWork(slotsAvailable);
+      }
+      if (this.options.config.auto_implement) {
+        const slotsLeft = this.maxAgents - this.spawner.activeCount;
+        if (slotsLeft > 0) {
+          await this.checkForImplementationWork(slotsLeft);
+        }
+      }
+      const status = this.spawner.activeCount > 0 ? "active" : "idle";
+      await this.heartbeat.beat(status);
+      if (!this.options.background) {
+        this.updateDisplay();
+      }
+    } catch (err) {
+      this.addEvent({
+        time: Date.now(),
+        icon: "\u26A0",
+        message: `Poll error: ${err.message}`
+      });
+    }
+  }
+  async checkForEnrichmentWork(maxSlots) {
+    const tickets = await this.client.query(
+      anyApi4.functions.localPipeline.getUnenrichedTickets,
+      { projectId: this.options.projectId }
+    );
+    if (!tickets || tickets.length === 0) return;
+    const enrichable = tickets.filter((t) => t.nature !== "spike");
+    if (enrichable.length === 0) return;
+    const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+    const sorted = enrichable.sort(
+      (a, b) => (priorityOrder[a.priority] ?? 3) - (priorityOrder[b.priority] ?? 3)
+    );
+    const enrichSlots = Math.min(1, maxSlots);
+    let spawned = 0;
+    for (const ticket of sorted) {
+      if (spawned >= enrichSlots) break;
+      const ref = ticket.linearTicketId ?? ticket.ticketId;
+      if (this.spawner.isRunning(ref)) continue;
+      const enrichWorktree = this.ensureEnrichWorktree();
+      if (!enrichWorktree) continue;
+      this.spawner.spawnEnrichmentAgent(
+        ticket.ticketId,
+        ref,
+        ticket.title,
+        enrichWorktree
+      );
+      spawned++;
+    }
+  }
+  async checkForImplementationWork(maxSlots) {
+    const data = await this.client.query(
+      anyApi4.functions.tickets.getLocalQueuedTickets,
+      { projectId: this.options.projectId }
+    );
+    if (!data || data.ready.length === 0) return;
+    let spawned = 0;
+    for (const ticket of data.ready) {
+      if (spawned >= maxSlots) break;
+      const ref = ticket.linearTicketId ?? ticket.ticketId;
+      if (this.spawner.isRunning(ref)) continue;
+      this.prefetch();
+      const defaultBranch = getDefaultBranch(this.options.cwd);
+      const branchName = `feat/${ref.toLowerCase().replace(/\s+/g, "-")}-${ticket.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40)}`;
+      try {
+        const wtPath = createWorktree(
+          this.options.cwd,
+          ticket.ticketId,
+          branchName,
+          defaultBranch
+        );
+        this.spawner.spawnImplementationAgent(ref, ticket.title, wtPath);
+        spawned++;
+      } catch (err) {
+        this.addEvent({
+          time: Date.now(),
+          icon: "\u2717",
+          message: `Failed to create worktree for ${ref}: ${err.message}`
+        });
+      }
+    }
+  }
+  ensureEnrichWorktree() {
+    const wtDir = getWorktreesDir(this.options.cwd);
+    const enrichPath = join10(wtDir, "_enrich");
+    if (existsSync9(enrichPath)) return enrichPath;
+    try {
+      if (!existsSync9(wtDir)) mkdirSync8(wtDir, { recursive: true });
+      const defaultBranch = getDefaultBranch(this.options.cwd);
+      execSync4(
+        `git worktree add "${enrichPath}" origin/${defaultBranch}`,
+        { cwd: this.options.cwd, stdio: ["pipe", "pipe", "pipe"] }
+      );
+      return enrichPath;
+    } catch (err) {
+      this.addEvent({
+        time: Date.now(),
+        icon: "\u2717",
+        message: `Failed to create enrich worktree: ${err.message}`
+      });
+      return null;
+    }
+  }
+  prefetch() {
+    try {
+      execSync4("git fetch origin", {
+        cwd: this.options.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 3e4
+      });
+    } catch {
+    }
+  }
+  async recoverOrphanedWorktrees() {
+    try {
+      const { listWorktrees: listWorktrees2 } = await import("./worktree-ZZZIL7TK.js");
+      const worktrees = listWorktrees2(this.options.cwd);
+      for (const wt of worktrees) {
+        if (wt.ticketId === "_enrich") {
+          removeWorktree(this.options.cwd, wt.path);
+          continue;
+        }
+        if (wt.ticketId) {
+          try {
+            const ticket = await this.client.query(
+              anyApi4.functions.tickets.getTicket,
+              { ticketId: wt.ticketId }
+            );
+            if (ticket && (ticket.status === "failed" || ticket.status === "workflow2_done")) {
+              removeWorktree(this.options.cwd, wt.path);
+              this.addEvent({
+                time: Date.now(),
+                icon: "\u{1F9F9}",
+                message: `Cleaned up orphaned worktree for ${wt.ticketId}`
+              });
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  onAgentStart(agent) {
+    if (!this.options.background) {
+      this.updateDisplay();
+    }
+    notify(
+      `${agent.stage === "enrich" ? "Enriching" : "Implementing"} ${agent.ticketRef}: "${agent.title}"`
+    );
+  }
+  onAgentComplete(agent, exitCode) {
+    if (agent.stage === "implement" && exitCode === 0 && agent.worktreePath) {
+      try {
+        removeWorktree(this.options.cwd, agent.worktreePath);
+      } catch {
+      }
+    }
+    if (!this.options.background) {
+      this.updateDisplay();
+    }
+  }
+  addEvent(event) {
+    this.recentEvents.unshift(event);
+    if (this.recentEvents.length > 20) {
+      this.recentEvents = this.recentEvents.slice(0, 20);
+    }
+    if (!this.options.background) {
+      this.updateDisplay();
+    }
+  }
+  updateDisplay() {
+    const state = {
+      projectName: this.options.projectName,
+      activeAgents: this.spawner.activeAgents,
+      queuedTickets: [],
+      recentEvents: this.recentEvents
+    };
+    clearAndRender(state);
+  }
+  getHostname() {
+    try {
+      return osHostname();
+    } catch {
+      return "unknown";
+    }
+  }
+};
+
+// src/commands/watch.ts
+var PID_FILE = join11(getYapoutDir(), "watch.pid");
+var LOG_FILE = join11(getYapoutDir(), "watch.log");
+var watchCommand = new Command10("watch").description("Watch for work and spawn Claude Code agents").option("--bg", "Run in background (detached)").option("--stop", "Stop the background watcher").option("--status", "Check if watcher is running").option("--force", "Force kill on Ctrl+C (don't wait for agents)").action(async (opts) => {
+  if (opts.status) {
+    if (existsSync10(PID_FILE)) {
+      const pid = parseInt(readFileSync7(PID_FILE, "utf-8").trim(), 10);
+      if (isProcessRunning(pid)) {
+        console.log(
+          chalk11.green("Watcher is running") + chalk11.dim(` (PID ${pid})`)
+        );
+      } else {
+        console.log(chalk11.dim("Watcher is not running (stale PID file)"));
+        unlinkSync3(PID_FILE);
+      }
+    } else {
+      console.log(chalk11.dim("Watcher is not running"));
+    }
+    return;
+  }
+  if (opts.stop) {
+    if (!existsSync10(PID_FILE)) {
+      console.log(chalk11.dim("No watcher running"));
+      return;
+    }
+    const pid = parseInt(readFileSync7(PID_FILE, "utf-8").trim(), 10);
+    try {
+      process.kill(pid, "SIGTERM");
+      console.log(chalk11.green(`Stopped watcher (PID ${pid})`));
+    } catch {
+      console.log(chalk11.dim("Watcher already stopped"));
+    }
+    unlinkSync3(PID_FILE);
+    return;
+  }
+  const creds = requireAuth();
+  const cwd = resolve7(process.cwd());
+  const mapping = getProjectMapping(cwd);
+  if (!mapping) {
+    console.error(
+      chalk11.red("No project linked.") + " Run " + chalk11.cyan("yapout link") + " in a repo."
+    );
+    process.exit(1);
+  }
+  const config = readYapoutConfig(cwd);
+  const client = new ConvexHttpClient3(getConvexUrl());
+  client.setAuth(creds.token);
+  if (opts.bg) {
+    writeFileSync9(PID_FILE, process.pid.toString());
+    console.log(
+      chalk11.green("Watcher started in background") + chalk11.dim(` (PID ${process.pid}, log: ${LOG_FILE})`)
+    );
+  }
+  console.log(chalk11.bold(`yapout watch v0.1.0`));
+  console.log(
+    `Project: ${chalk11.green(mapping.projectName)} (${mapping.projectId})`
+  );
+  console.log(chalk11.dim("Watching..."));
+  console.log();
+  const watcher = new Watcher(
+    {
+      projectId: mapping.projectId,
+      projectName: mapping.projectName,
+      cwd,
+      credentials: creds,
+      config: config.watch,
+      background: opts.bg
+    },
+    client
+  );
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      watcher.forceStop();
+      if (existsSync10(PID_FILE)) unlinkSync3(PID_FILE);
+      process.exit(0);
+    }
+    shuttingDown = true;
+    console.log(chalk11.dim("\nShutting down..."));
+    if (opts.force) {
+      watcher.forceStop();
+    } else {
+      await watcher.stop();
+    }
+    if (existsSync10(PID_FILE)) unlinkSync3(PID_FILE);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    shutdown();
+  });
+  process.on("SIGTERM", () => {
+    shutdown();
+  });
+  await watcher.start();
+  await new Promise(() => {
+  });
+});
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/queue.ts
+import { Command as Command11 } from "commander";
+import { resolve as resolve8 } from "path";
+import chalk12 from "chalk";
+var queueCommand = new Command11("queue").description("Show pipeline state \u2014 what's ready, blocked, and pending").action(async () => {
+  const creds = requireAuth();
+  const cwd = resolve8(process.cwd());
+  const mapping = getProjectMapping(cwd);
+  if (!mapping) {
+    console.error(
+      chalk12.red("No project linked.") + " Run " + chalk12.cyan("yapout link") + " in a repo."
+    );
+    process.exit(1);
+  }
+  const client = createConvexClient(creds.token);
+  const { anyApi: anyApi5 } = await import("convex/server");
+  const [queueData, unenriched, pending] = await Promise.all([
+    client.query(anyApi5.functions.tickets.getLocalQueuedTickets, {
+      projectId: mapping.projectId
+    }),
+    client.query(anyApi5.functions.localPipeline.getUnenrichedTickets, {
+      projectId: mapping.projectId
+    }),
+    client.query(anyApi5.functions.localPipeline.getPendingSources, {
+      projectId: mapping.projectId
+    })
+  ]);
+  console.log();
+  if (queueData?.ready && queueData.ready.length > 0) {
+    console.log(chalk12.bold("Ready to implement:"));
+    for (const t of queueData.ready) {
+      const ref = t.linearTicketId ?? t.ticketId;
+      const prio = colorPriority(t.priority);
+      console.log(
+        `  ${chalk12.bold(ref)}  ${t.title.slice(0, 45).padEnd(45)}  ${prio}  ${chalk12.dim(t.type)}`
+      );
+    }
+    console.log();
+  }
+  if (queueData?.blocked && queueData.blocked.length > 0) {
+    console.log(chalk12.bold("Blocked:"));
+    for (const t of queueData.blocked) {
+      console.log(
+        `  ${chalk12.bold(t.ticketId.slice(-6))}  ${t.title.slice(0, 45)}  ${chalk12.red("blocked by " + t.blockedBy.map((id) => id.slice(-6)).join(", "))}`
+      );
+    }
+    console.log();
+  }
+  if (unenriched && unenriched.length > 0) {
+    console.log(chalk12.bold("Needs enrichment:"));
+    for (const t of unenriched) {
+      const ref = t.ticketId;
+      console.log(
+        `  ${chalk12.bold(ref.slice(-6))}  ${t.title.slice(0, 45).padEnd(45)}  ${chalk12.dim(t.priority)}`
+      );
+    }
+    console.log();
+  }
+  if (pending && pending.length > 0) {
+    console.log(chalk12.bold("Pending extraction:"));
+    for (const t of pending) {
+      const ago = formatAgo(Date.now() - t.createdAt);
+      console.log(
+        `  "${t.meetingTitle ?? "Untitled"}" ${chalk12.dim(`(uploaded ${ago})`)}`
+      );
+    }
+    console.log();
+  }
+  if ((!queueData?.ready || queueData.ready.length === 0) && (!unenriched || unenriched.length === 0) && (!pending || pending.length === 0)) {
+    console.log(chalk12.dim("Queue is empty. Upload a transcript to get started."));
+    console.log();
+  }
+});
+function colorPriority(p) {
+  switch (p) {
+    case "urgent":
+      return chalk12.red(p);
+    case "high":
+      return chalk12.yellow(p);
+    case "medium":
+      return chalk12.white(p);
+    case "low":
+      return chalk12.dim(p);
+    default:
+      return p;
+  }
+}
+function formatAgo(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+
+// src/commands/next.ts
+import { Command as Command12 } from "commander";
+import { resolve as resolve9 } from "path";
+import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join12 } from "path";
+import chalk13 from "chalk";
+var nextCommand = new Command12("next").description("Claim the highest priority ticket and set up for implementation").option("--worktree", "Create a git worktree instead of checking out a branch").action(async (opts) => {
+  const creds = requireAuth();
+  const cwd = resolve9(process.cwd());
+  const mapping = getProjectMapping(cwd);
+  if (!mapping) {
+    console.error(
+      chalk13.red("No project linked.") + " Run " + chalk13.cyan("yapout link") + " in a repo."
+    );
+    process.exit(1);
+  }
+  const client = createConvexClient(creds.token);
+  const { anyApi: anyApi5 } = await import("convex/server");
+  const data = await client.query(
+    anyApi5.functions.tickets.getLocalQueuedTickets,
+    { projectId: mapping.projectId }
+  );
+  if (!data?.ready || data.ready.length === 0) {
+    console.log(chalk13.dim("No tickets ready for implementation."));
+    return;
+  }
+  const ticket = data.ready[0];
+  const ref = ticket.linearTicketId ?? ticket.ticketId;
+  const config = readYapoutConfig(cwd);
+  const defaultBranch = getDefaultBranch(cwd);
+  const branchName = `${config.branch_prefix}/${ref.toLowerCase().replace(/\s+/g, "-")}-${ticket.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40)}`;
+  console.log(chalk13.bold(`
+Claimed: ${ref} "${ticket.title}"`));
+  fetchOrigin(cwd);
+  let workDir = cwd;
+  if (opts.worktree) {
+    const { createWorktree: createWorktree2 } = await import("./worktree-ZZZIL7TK.js");
+    workDir = createWorktree2(cwd, ticket.ticketId, branchName, defaultBranch);
+    console.log(`Worktree: ${chalk13.cyan(workDir)}`);
+  } else {
+    checkoutNewBranch(branchName, defaultBranch, cwd);
+  }
+  console.log(`Branch: ${chalk13.cyan(branchName)}`);
+  const brief = await client.query(
+    anyApi5.functions.tickets.getTicketBrief,
+    { ticketId: ticket.ticketId }
+  );
+  if (brief) {
+    const briefPath = join12(workDir, ".yapout", "brief.md");
+    const briefContent = formatBrief2(ref, ticket, brief);
+    writeFileSync10(briefPath, briefContent);
+    console.log(`Brief: ${chalk13.cyan(briefPath)}`);
+  }
+  console.log();
+  console.log("Start Claude Code to implement, or run:");
+  console.log(
+    chalk13.cyan(
+      `  claude --dangerously-skip-permissions "Read .yapout/brief.md, implement it, run yapout_check, then yapout_ship"`
+    )
+  );
+  console.log();
+});
+function formatBrief2(ref, ticket, brief) {
+  const lines = [
+    `# ${ref}: ${ticket.title}`,
+    "",
+    `**Priority:** ${ticket.priority}`,
+    `**Type:** ${ticket.type}`,
+    ""
+  ];
+  if (brief.enrichedDescription) {
+    lines.push("## Description", "", String(brief.enrichedDescription), "");
+  } else if (brief.ticket && typeof brief.ticket === "object") {
+    const t = brief.ticket;
+    if (t.description) lines.push("## Description", "", t.description, "");
+  }
+  if (brief.implementationBrief) {
+    lines.push("## Implementation Brief", "", String(brief.implementationBrief), "");
+  }
+  if (brief.enrichmentQA && Array.isArray(brief.enrichmentQA)) {
+    const qa = brief.enrichmentQA;
+    if (qa.length > 0) {
+      lines.push("## Q&A", "");
+      for (const q of qa) {
+        lines.push(`**Q:** ${q.question}`);
+        if (q.answer) lines.push(`**A:** ${q.answer}`);
+        lines.push("");
+      }
+    }
+  }
+  if (brief.userContext) {
+    lines.push("## Additional Context", "", String(brief.userContext), "");
+  }
+  if (brief.projectContext) {
+    lines.push("## Project Context", "", String(brief.projectContext), "");
+  }
+  const warnings = brief.warnings;
+  if (warnings?.duplicateWarning || warnings?.scopeWarning) {
+    lines.push("## Warnings", "");
+    if (warnings.duplicateWarning) lines.push(`\u26A0 Duplicate: ${warnings.duplicateWarning}`, "");
+    if (warnings.scopeWarning) lines.push(`\u26A0 Scope: ${warnings.scopeWarning}`, "");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/recap.ts
+import { Command as Command13 } from "commander";
+import { resolve as resolve10 } from "path";
+import chalk14 from "chalk";
+var recapCommand = new Command13("recap").description("Show a summary of recent yapout activity").option("--week", "Show full week summary (default: today)").action(async (opts) => {
+  const creds = requireAuth();
+  const cwd = resolve10(process.cwd());
+  const mapping = getProjectMapping(cwd);
+  if (!mapping) {
+    console.error(
+      chalk14.red("No project linked.") + " Run " + chalk14.cyan("yapout link") + " in a repo."
+    );
+    process.exit(1);
+  }
+  const client = createConvexClient(creds.token);
+  const { anyApi: anyApi5 } = await import("convex/server");
+  const now = /* @__PURE__ */ new Date();
+  const todayStart = new Date(
+    now.getFullYear(),
+    now.getMonth(),
+    now.getDate()
+  ).getTime();
+  const weekStart = todayStart - 6 * 24 * 60 * 60 * 1e3;
+  const since = opts.week ? weekStart : todayStart;
+  const data = await client.query(
+    anyApi5.functions.localPipeline.getRecentActivity,
+    { projectId: mapping.projectId, since }
+  );
+  if (!data) {
+    console.log(chalk14.dim("Could not fetch activity data."));
+    return;
+  }
+  const period = opts.week ? "This week" : "Today";
+  console.log();
+  console.log(chalk14.bold(`${period}:`));
+  if (data.recentTickets.length > 0) {
+    for (const t of data.recentTickets) {
+      const ref = t.linearTicketId ?? "ticket";
+      console.log(`  ${chalk14.green("\u2713")} ${ref}  ${t.title}`);
+    }
+  }
+  if (data.recentPRs.length > 0) {
+    for (const p of data.recentPRs) {
+      const prRef = p.githubPrNumber ? `PR #${p.githubPrNumber}` : "PR";
+      const statusColor = p.status === "opened" ? chalk14.green : p.status === "draft" ? chalk14.dim : chalk14.yellow;
+      console.log(
+        `  ${statusColor("\u2191")} ${p.prTitle.slice(0, 45)}  ${statusColor(prRef)}  ${statusColor(p.status)}`
+      );
+    }
+  }
+  if (data.recentTickets.length === 0 && data.recentPRs.length === 0) {
+    console.log(chalk14.dim("  No activity yet."));
+  }
+  console.log();
+  console.log(
+    `  ${data.ticketsShipped} tickets shipped | ${data.prsMerged} PRs merged | ${data.successRate}% agent success rate`
+  );
+  console.log();
+});
+
+// src/commands/yap.ts
+import { Command as Command14 } from "commander";
+import chalk15 from "chalk";
+var yapCommand = new Command14("yap").description(
+  "Start a yap session \u2014 brainstorm with an AI that knows your codebase"
+).action(() => {
+  console.log(chalk15.bold("yapout yap sessions"));
+  console.log();
+  console.log(
+    "Yap sessions run inside Claude \u2014 Desktop, CLI, or web \u2014 anywhere the"
+  );
+  console.log("yapout MCP server is connected.");
+  console.log();
+  console.log("Just tell Claude:");
+  console.log(
+    chalk15.green(`  "Let's have a yap session about [topic]"`)
+  );
+  console.log(
+    chalk15.green(
+      '  "I want to brainstorm [idea] \u2014 be a skeptical QA engineer"'
+    )
+  );
+  console.log();
+  console.log(chalk15.dim("Personas: tech lead, qa engineer, product owner, end user, or custom"));
+  console.log(
+    chalk15.dim(
+      "Claude will call yapout_start_yap to get instructions and yapout_submit_yap_session when done."
+    )
+  );
+});
+
+// src/commands/handle-uri.ts
+import { Command as Command15 } from "commander";
+import { spawn as spawn2 } from "child_process";
+import { platform as platform2 } from "os";
+import chalk16 from "chalk";
+var VALID_ACTIONS = ["claim", "enrich", "yap", "compact"];
+function parseYapoutUri(raw) {
+  const url = new URL(raw);
+  const action = url.hostname;
+  if (!VALID_ACTIONS.includes(action)) {
+    throw new Error(
+      `Unknown action: ${action}. Expected one of: ${VALID_ACTIONS.join(", ")}`
+    );
+  }
+  const ticketId = url.pathname.replace(/^\//, "") || void 0;
+  if ((action === "claim" || action === "enrich") && !ticketId) {
+    throw new Error(`Missing ticket ID in URI: ${raw}`);
+  }
+  return {
+    action,
+    ticketId,
+    topic: url.searchParams.get("topic") || void 0,
+    persona: url.searchParams.get("persona") || void 0
+  };
+}
+function buildPrompt(parsed) {
+  switch (parsed.action) {
+    case "claim":
+      return [
+        `Use yapout to implement ticket "${parsed.ticketId}".`,
+        `Claim it with yapout_claim (use worktree mode), read the brief,`,
+        `implement the changes, run yapout_check, then ship with yapout_ship.`
+      ].join(" ");
+    case "enrich":
+      return [
+        `A ticket has been approved and needs enrichment before implementation.`,
+        `Call yapout_get_unenriched_ticket with ticketId for "${parsed.ticketId}" to fetch the ticket details.`,
+        ``,
+        `Read the codebase to understand the project structure, then produce:`,
+        `1. An implementation brief (3-5 sentences, specific files/patterns involved)`,
+        `2. An enriched description with technical context`,
+        `3. Clarifying questions (0-5) where the answer can't be inferred`,
+        `4. Duplicate check \u2014 call yapout_get_existing_tickets and compare`,
+        `5. Scope assessment (is this too large for one PR?)`,
+        ``,
+        `Call yapout_save_enrichment with your analysis.`,
+        `If no questions were generated, also call yapout_sync_to_linear to create the Linear ticket.`
+      ].join("\n");
+    case "yap": {
+      const parts = ["Let's have a yap session"];
+      if (parsed.topic) parts[0] += ` about ${parsed.topic}`;
+      if (parsed.persona && parsed.persona !== "tech lead") {
+        parts.push(`be a ${parsed.persona}`);
+      }
+      return parts.join(" \u2014 ");
+    }
+    case "compact":
+      return "Run yapout_compact to update the project context summary.";
+  }
+}
+function findProjectDir() {
+  const mappings = readProjectMappings();
+  const dirs = Object.keys(mappings);
+  if (dirs.length === 0) return null;
+  dirs.sort(
+    (a, b) => (mappings[b].linkedAt ?? 0) - (mappings[a].linkedAt ?? 0)
+  );
+  return dirs[0];
+}
+function launchTerminal(cwd, claudeArgs) {
+  const os = platform2();
+  const claudeCmd = `claude ${claudeArgs.map(shellEscape).join(" ")}`;
+  if (os === "win32") {
+    const wtArgs = ["wt", "-d", cwd, "cmd", "/k", claudeCmd];
+    const child = spawn2("cmd", ["/c", "start", ...wtArgs], {
+      cwd,
+      stdio: "ignore",
+      detached: true,
+      shell: true
+    });
+    child.unref();
+    child.on("error", () => {
+      const fallback = spawn2(
+        "cmd",
+        ["/c", "start", "cmd", "/k", claudeCmd],
+        { cwd, stdio: "ignore", detached: true, shell: true }
+      );
+      fallback.unref();
+    });
+  } else if (os === "darwin") {
+    const escaped = claudeCmd.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    const script = `tell application "Terminal"
+  activate
+  do script "cd ${shellEscape(cwd)} && ${escaped}"
+end tell`;
+    const child = spawn2("osascript", ["-e", script], {
+      stdio: "ignore",
+      detached: true
+    });
+    child.unref();
+  } else {
+    const terminals = [
+      { cmd: "x-terminal-emulator", args: ["-e", `bash -c 'cd ${shellEscape(cwd)} && ${claudeCmd}; exec bash'`] },
+      { cmd: "gnome-terminal", args: ["--", "bash", "-c", `cd ${shellEscape(cwd)} && ${claudeCmd}; exec bash`] },
+      { cmd: "konsole", args: ["-e", "bash", "-c", `cd ${shellEscape(cwd)} && ${claudeCmd}; exec bash`] },
+      { cmd: "xterm", args: ["-e", `cd ${shellEscape(cwd)} && ${claudeCmd}; exec bash`] }
+    ];
+    let launched = false;
+    for (const term of terminals) {
+      try {
+        const child = spawn2(term.cmd, term.args, {
+          stdio: "ignore",
+          detached: true
+        });
+        child.unref();
+        launched = true;
+        break;
+      } catch {
+        continue;
+      }
+    }
+    if (!launched) {
+      console.error(
+        chalk16.red("Could not find a terminal emulator. Install gnome-terminal, konsole, or xterm.")
+      );
+      process.exit(1);
+    }
+  }
+}
+function shellEscape(s) {
+  if (platform2() === "win32") {
+    return `"${s.replace(/"/g, '""')}"`;
+  }
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+var handleUriCommand = new Command15("handle-uri").description("Handle a yapout:// URI (used by OS protocol handler)").argument("<uri>", "The yapout:// URI to handle").action(async (uri) => {
+  try {
+    const parsed = parseYapoutUri(uri);
+    const prompt = buildPrompt(parsed);
+    const cwd = findProjectDir();
+    if (!cwd) {
+      console.error(
+        chalk16.red(
+          "No linked project found. Run `yapout init` or `yapout link` in your repo first."
+        )
+      );
+      process.exit(1);
+    }
+    const label = parsed.ticketId ? `${parsed.action} ${parsed.ticketId}` : parsed.action;
+    console.log(chalk16.dim(`Launching Claude Code to ${label}...`));
+    launchTerminal(cwd, ["--dangerously-skip-permissions", prompt]);
+    setTimeout(() => process.exit(0), 500);
+  } catch (err) {
+    console.error(chalk16.red(err.message));
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command16();
+program.name("yapout").description("yapout \u2014 from meeting transcript to merged PR").version("0.1.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(initCommand);
+program.addCommand(linkCommand);
+program.addCommand(unlinkCommand);
+program.addCommand(statusCommand);
+program.addCommand(mcpServerCommand);
+program.addCommand(worktreesCommand);
+program.addCommand(cleanCommand);
+program.addCommand(watchCommand);
+program.addCommand(queueCommand);
+program.addCommand(nextCommand);
+program.addCommand(recapCommand);
+program.addCommand(yapCommand);
+program.addCommand(handleUriCommand);
+program.parse();