yapout 0.15.2 → 0.18.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command16 } from "commander";
+import { Command as Command18 } from "commander";
 
 // src/commands/login.ts
 import { Command as Command2 } from "commander";
@@ -45,6 +45,31 @@ function getRepoFullName(cwd) {
   if (httpsMatch) return httpsMatch[1];
   throw new Error(`Could not parse GitHub repo from remote URL: ${url}`);
 }
+function getOriginRemoteUrl(cwd) {
+  return git("remote get-url origin", cwd);
+}
+function normalizeGitRemote(raw) {
+  if (!raw) return null;
+  let s = raw.trim();
+  if (s.endsWith(".git")) s = s.slice(0, -4);
+  s = s.replace(/^git@([^:]+):/, "$1/");
+  s = s.replace(/^ssh:\/\/(?:git@)?/, "");
+  s = s.replace(/^https?:\/\//, "");
+  s = s.replace(/^github\.com\//, "");
+  const parts = s.split("/").filter(Boolean);
+  if (parts.length < 2) return null;
+  const owner = parts[0];
+  const repo = parts[1];
+  return `https://github.com/${owner}/${repo}`;
+}
+function isInGitRepo(cwd) {
+  try {
+    git("rev-parse --git-dir", cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getDefaultBranch(cwd) {
   try {
     const ref = git("rev-parse --abbrev-ref origin/HEAD", cwd);
@@ -174,6 +199,57 @@ function getOrCreateDeviceIdentity(defaultName) {
   writeDeviceIdentity(identity);
   return identity;
 }
+function readResourceConfig(cwd) {
+  const path = join(resolveRepoRoot(cwd), ".yapout", "config.json");
+  if (!existsSync(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    if (!raw || typeof raw !== "object") return null;
+    if (!raw.resourceId || !raw.canonicalId) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function writeResourceConfig(cwd, cfg) {
+  const yapoutDir = join(resolveRepoRoot(cwd), ".yapout");
+  if (!existsSync(yapoutDir)) {
+    mkdirSync(yapoutDir, { recursive: true });
+  }
+  const path = join(yapoutDir, "config.json");
+  writeFileSync(path, JSON.stringify(cfg, null, 2) + "\n");
+}
+function readActiveExecution(cwd) {
+  const path = join(cwd, ".yapout", "active-execution.json");
+  if (!existsSync(path)) {
+    const fallback = join(resolveRepoRoot(cwd), ".yapout", "active-execution.json");
+    if (!existsSync(fallback)) return null;
+    try {
+      return JSON.parse(readFileSync(fallback, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeActiveExecution(cwd, active) {
+  const yapoutDir = join(cwd, ".yapout");
+  if (!existsSync(yapoutDir)) {
+    mkdirSync(yapoutDir, { recursive: true });
+  }
+  writeFileSync(
+    join(yapoutDir, "active-execution.json"),
+    JSON.stringify(active, null, 2) + "\n"
+  );
+}
+function clearActiveExecution(cwd) {
+  const path = join(cwd, ".yapout", "active-execution.json");
+  if (existsSync(path)) unlinkSync(path);
+}
 var WATCH_DEFAULTS = {
   auto_enrich: true,
   auto_implement: true,
@@ -296,7 +372,7 @@ function requireAuth() {
 }
 
 // src/commands/serve.ts
-var CLI_VERSION = "0.15.2";
+var CLI_VERSION = "0.18.0";
 var DEFAULT_PORT = 7777;
 var PORT_RANGE = 10;
 var HEARTBEAT_MS = 12e4;
@@ -345,7 +421,7 @@ function startServer(payload) {
     res.writeHead(404, headers);
     res.end();
   });
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve16, reject) => {
     let attempt = 0;
     const tryListen = () => {
       const port = DEFAULT_PORT + attempt;
@@ -361,7 +437,7 @@ function startServer(payload) {
       server.once("error", onError);
       server.listen(port, "127.0.0.1", () => {
         server.removeListener("error", onError);
-        resolve12({
+        resolve16({
           port,
           close: () => server.close()
         });
@@ -518,7 +594,7 @@ var serveCommand = new Command("serve").description(
 });
 
 // src/commands/login.ts
-var CLI_VERSION2 = "0.15.2";
+var CLI_VERSION2 = "0.18.0";
 function safeReturnTo(raw) {
   if (!raw) return null;
   try {
@@ -530,7 +606,7 @@ function safeReturnTo(raw) {
   }
 }
 function startCallbackServer() {
-  return new Promise((resolve12) => {
+  return new Promise((resolve16) => {
     let resolveData;
     let rejectData;
     const dataPromise = new Promise((res, rej) => {
@@ -579,7 +655,7 @@ function startCallbackServer() {
     server.listen(0, () => {
       const address = server.address();
       const port = typeof address === "object" && address ? address.port : 0;
-      resolve12({ port, data: dataPromise });
+      resolve16({ port, data: dataPromise });
     });
     setTimeout(() => {
       server.close();
@@ -681,15 +757,6 @@ async function pickProject(projects) {
     })
   });
 }
-async function pickOrg(orgs, message = "Which org does this project belong to?") {
-  return await select({
-    message,
-    choices: orgs.map((o) => ({
-      name: `${o.name}  (${o.slug}, ${o.role})`,
-      value: o
-    }))
-  });
-}
 
 // src/commands/link.ts
 var CONFIG_YAML_CONTENT = `# yapout local configuration
@@ -716,7 +783,50 @@ branch_prefix: feat
 #   {{ticket.linearTicketId}}, {{ticket.id}}
 # commit_template: "{{ticket.type}}({{ticket.linearTicketId}}): {{ticket.title}}"
 `;
-var linkCommand = new Command4("link").description("Link the current directory to a yapout project").action(async () => {
+var linkCommand = new Command4("link").description(
+  "Link the current Resource into a Group (--group), or link the current directory to a project (legacy)."
+).option(
+  "--group <groupId>",
+  "Attach the active Resource into a Group (requires `yapout init` to have run in this repo)"
+).action(async (options) => {
+  if (options.group) {
+    await linkResourceToGroup(options.group);
+    return;
+  }
+  await legacyLinkProject();
+});
+async function linkResourceToGroup(groupId) {
+  const creds = requireAuth();
+  const cwd = resolve2(process.cwd());
+  const resourceCfg = readResourceConfig(cwd);
+  if (!resourceCfg) {
+    console.error(
+      chalk5.red("No `.yapout/config.json` found.") + " Run " + chalk5.cyan("yapout init") + " here first."
+    );
+    process.exit(1);
+  }
+  const client = createConvexClient(creds.token);
+  try {
+    await client.mutation(anyApi.functions.resourcesCli.linkResourceToGroup, {
+      resourceId: resourceCfg.resourceId,
+      groupId
+    });
+  } catch (err) {
+    console.error(
+      chalk5.red("Failed to link Resource to Group."),
+      err.message
+    );
+    process.exit(1);
+  }
+  writeResourceConfig(resolve2(process.cwd()), {
+    ...resourceCfg,
+    groupId
+  });
+  console.log(
+    chalk5.green("Linked Resource ") + chalk5.cyan(resourceCfg.canonicalId) + chalk5.green(" to Group ") + chalk5.cyan(groupId) + "."
+  );
+}
+async function legacyLinkProject() {
   const creds = requireAuth();
   const cwd = resolveRepoRoot(resolve2(process.cwd()));
   const client = createConvexClient(creds.token);
@@ -776,10 +886,7 @@ var linkCommand = new Command4("link").description("Link the current directory t
   if (existsSync3(gitignorePath)) {
     const content = readFileSync3(gitignorePath, "utf-8");
     if (!content.includes(".yapout/")) {
-      appendFileSync(
-        gitignorePath,
-        "\n# yapout local config\n.yapout/\n"
-      );
+      appendFileSync(gitignorePath, "\n# yapout local config\n.yapout/\n");
     }
   } else {
     writeFileSync3(gitignorePath, "# yapout local config\n.yapout/\n");
@@ -803,7 +910,7 @@ var linkCommand = new Command4("link").description("Link the current directory t
   console.log(
     chalk5.green(`Linked to ${label}${orgSuffix}.`) + " Claude Code will discover yapout tools automatically."
   );
-});
+}
 function getCliVersion() {
   try {
     const pkg = JSON.parse(
@@ -916,7 +1023,6 @@ import {
   readFileSync as readFileSync5,
   appendFileSync as appendFileSync2
 } from "fs";
-import { hostname as hostname4 } from "os";
 import chalk8 from "chalk";
 var CONFIG_YAML_CONTENT2 = `# yapout local configuration
 # See: https://docs.yapout.dev/cli/config
@@ -927,7 +1033,6 @@ var CONFIG_YAML_CONTENT2 = `# yapout local configuration
 #   - 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.
@@ -936,170 +1041,89 @@ 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 Command7("init").description("Create a yapout project from the current repo and link it").argument("[name]", "Project name (defaults to repo name)").option("--org <slug>", "Org slug to create the project in (skips picker)").action(async (name, options) => {
+var initCommand = new Command7("init").description(
+  "Register the current repo as a Resource and start the MCP server scoped to it"
+).option(
+  "--group <groupId>",
+  "Optional Group id to attach the Resource to (defaults to the org's migration-bridge group)"
+).action(async (options) => {
   const creds = requireAuth();
-  const cwd = resolveRepoRoot(resolve5(process.cwd()));
-  let repoFullName;
-  let defaultBranch;
-  try {
-    repoFullName = getRepoFullName(cwd);
-    defaultBranch = getDefaultBranch(cwd);
-  } catch (err) {
+  const cwd = resolve5(process.cwd());
+  if (!isInGitRepo(cwd)) {
     console.error(
-      chalk8.red("Not a git repo with a GitHub remote."),
-      err.message
+      chalk8.red("`yapout init` must be run from inside a git repo.") + "\n  No .git/ directory found from " + chalk8.dim(cwd) + "."
     );
     process.exit(1);
   }
-  const projectName = name || repoFullName.split("/")[1] || "unnamed";
-  const client = createConvexClient(creds.token);
-  let orgs;
+  const repoRoot = resolveRepoRoot(cwd);
+  let rawRemote;
   try {
-    orgs = await client.query(
-      anyApi.functions.orgMembers.getMyOrgs,
-      {}
-    );
+    rawRemote = getOriginRemoteUrl(repoRoot);
   } catch (err) {
     console.error(
-      chalk8.red("Failed to load your orgs."),
-      err.message
+      chalk8.red("Failed to read origin remote URL.") + "\n  " + err.message + "\n  Set a GitHub remote (`git remote add origin ...`) before running `yapout init`."
     );
     process.exit(1);
   }
-  if (!orgs || orgs.length === 0) {
+  const canonicalId = normalizeGitRemote(rawRemote);
+  if (!canonicalId) {
     console.error(
       chalk8.red(
-        "You aren't a member of any org. Sign in to the web app once to create your personal org, then re-run."
-      )
+        `Could not derive a canonical id from the origin remote URL: ${rawRemote}`
+      ) + "\n  yapout currently supports github.com remotes only."
     );
     process.exit(1);
   }
-  let chosenOrgId;
-  let chosenOrgName;
-  if (options?.org) {
-    const match = orgs.find((o) => o.org.slug === options.org);
-    if (!match) {
-      console.error(
-        chalk8.red(`Org "${options.org}" not found among your memberships.`)
-      );
-      console.error(
-        chalk8.dim(
-          "Available: " + orgs.map((o) => o.org.slug).join(", ")
-        )
-      );
-      process.exit(1);
-    }
-    chosenOrgId = match.org._id;
-    chosenOrgName = match.org.name;
-  } else if (orgs.length === 1) {
-    chosenOrgId = orgs[0].org._id;
-    chosenOrgName = orgs[0].org.name;
-    console.log(
-      chalk8.dim(`Creating in `) + chalk8.cyan(chosenOrgName)
-    );
-  } else {
-    const picked = await pickOrg(
-      orgs.map((o) => ({
-        id: o.org._id,
-        name: o.org.name,
-        slug: o.org.slug,
-        role: o.role
-      }))
-    );
-    chosenOrgId = picked.id;
-    chosenOrgName = picked.name;
-  }
-  const device = getOrCreateDeviceIdentity(hostname4());
+  let defaultBranch;
   try {
-    await client.mutation(anyApi.functions.devices.registerDevice, {
-      deviceId: device.deviceId,
-      name: device.name,
-      cliVersion: getCliVersion2(),
-      machineHostname: hostname4()
-    });
-  } catch (err) {
-    console.warn(
-      chalk8.yellow("Warning: device registration failed \u2014 "),
-      err.message
-    );
+    defaultBranch = getDefaultBranch(repoRoot);
+  } catch {
+    defaultBranch = void 0;
   }
+  const client = createConvexClient(creds.token);
   let result;
   try {
     result = await client.mutation(
-      anyApi.functions.projects.createProjectFromCli,
+      anyApi.functions.resourcesCli.findOrCreateRepoResource,
       {
-        orgId: chosenOrgId,
-        name: projectName,
-        githubRepoFullName: repoFullName,
-        githubDefaultBranch: defaultBranch
+        canonicalId,
+        remoteUrl: canonicalId,
+        defaultBranch,
+        ...options?.group ? { groupId: options.group } : {}
       }
     );
   } catch (err) {
     console.error(
-      chalk8.red("Failed to create project."),
+      chalk8.red("Failed to register Resource."),
       err.message
     );
     process.exit(1);
   }
-  try {
-    await client.mutation(anyApi.functions.projectCheckouts.linkCheckout, {
-      projectId: result.projectId,
-      deviceId: device.deviceId,
-      localPath: cwd
-    });
-  } catch (err) {
-    console.warn(
-      chalk8.yellow("Warning: failed to record project checkout \u2014 "),
-      err.message
-    );
-  }
-  setProjectMapping(cwd, {
-    projectId: result.projectId,
-    projectName: result.projectName,
+  const yapoutDir = join5(repoRoot, ".yapout");
+  if (!existsSync5(yapoutDir)) mkdirSync3(yapoutDir, { recursive: true });
+  writeResourceConfig(repoRoot, {
+    resourceId: result.resourceId,
+    canonicalId: result.canonicalId,
+    groupId: result.groupId,
+    remoteUrl: canonicalId,
+    defaultBranch,
     linkedAt: Date.now()
   });
-  let agentToken = null;
-  try {
-    const agentRes = await client.mutation(
-      anyApi.functions.agents.createAgent,
-      {
-        projectId: result.projectId,
-        displayName: `${creds.email}'s default agent (${result.projectName})`,
-        roleDescription: "Default agent created at yapout init. Has full tool access.",
-        scopes: ["*"],
-        label: "yapout init default"
-      }
-    );
-    agentToken = agentRes.rawToken;
-  } catch (err) {
-    console.warn(
-      chalk8.yellow("Warning: failed to provision default agent \u2014 "),
-      err.message
-    );
-  }
-  const yapoutDir = join5(cwd, ".yapout");
-  if (!existsSync5(yapoutDir)) mkdirSync3(yapoutDir, { recursive: true });
-  const configPath = join5(yapoutDir, "config.yml");
-  if (!existsSync5(configPath)) {
-    writeFileSync5(configPath, CONFIG_YAML_CONTENT2);
+  const configYamlPath = join5(yapoutDir, "config.yml");
+  if (!existsSync5(configYamlPath)) {
+    writeFileSync5(configYamlPath, CONFIG_YAML_CONTENT2);
   }
-  const gitignorePath = join5(cwd, ".gitignore");
+  const gitignorePath = join5(repoRoot, ".gitignore");
   if (existsSync5(gitignorePath)) {
     const content = readFileSync5(gitignorePath, "utf-8");
     if (!content.includes(".yapout/")) {
-      appendFileSync2(
-        gitignorePath,
-        "\n# yapout local config\n.yapout/\n"
-      );
+      appendFileSync2(gitignorePath, "\n# yapout local config\n.yapout/\n");
     }
+  } else {
+    writeFileSync5(gitignorePath, "# yapout local config\n.yapout/\n");
   }
-  const mcpPath = join5(cwd, ".mcp.json");
+  const mcpPath = join5(repoRoot, ".mcp.json");
   let mcpConfig = {};
   if (existsSync5(mcpPath)) {
     try {
@@ -1110,40 +1134,25 @@ var initCommand = new Command7("init").description("Create a yapout project from
   if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
   const existingYapoutServer = mcpConfig.mcpServers.yapout ?? {};
   const existingEnv = existingYapoutServer.env && typeof existingYapoutServer.env === "object" ? existingYapoutServer.env : {};
-  const newEnv = { ...existingEnv };
-  if (agentToken) {
-    newEnv.YAPOUT_AGENT_TOKEN = agentToken;
-  }
   mcpConfig.mcpServers.yapout = {
     command: "yapout",
     args: ["mcp-server"],
-    ...Object.keys(newEnv).length > 0 ? { env: newEnv } : {}
+    ...Object.keys(existingEnv).length > 0 ? { env: existingEnv } : {}
   };
   writeFileSync5(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+  const verb = result.created ? "Registered" : "Linked";
   console.log(
-    chalk8.green(`Created project "${result.projectName}"`) + chalk8.dim(
-      ` in ${chosenOrgName} (${repoFullName}, branch: ${defaultBranch})`
-    )
+    chalk8.green(`${verb} Resource `) + chalk8.cyan(canonicalId) + chalk8.dim(` (id: ${result.resourceId}).`)
   );
-  if (agentToken) {
-    console.log(
-      chalk8.dim("Provisioned default agent \u2014 token stored in ") + chalk8.cyan(".mcp.json")
-    );
+  if (defaultBranch) {
+    console.log(chalk8.dim(`  default branch: ${defaultBranch}`));
   }
   console.log(
-    chalk8.dim("Run ") + chalk8.cyan("yapout_compact") + chalk8.dim(" in Claude Code to generate project context.")
+    chalk8.dim(
+      "Claude Code will discover yapout's MCP tools via .mcp.json on next launch."
+    )
   );
 });
-function getCliVersion2() {
-  try {
-    const pkg = JSON.parse(
-      readFileSync5(join5(import.meta.dirname, "..", "package.json"), "utf-8")
-    );
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
 
 // src/commands/mcp-server.ts
 import { Command as Command8 } from "commander";
@@ -1516,151 +1525,457 @@ function registerUpdateContextTool(server, ctx) {
   );
 }
 
-// src/mcp/tools/queue.ts
-import { z as z4 } from "zod";
-function formatFinding(f, indent, done) {
-  const ref = f.linearIssueId ? `  ${f.linearIssueId}` : "";
-  const prefix = done ? "\u2713 " : "";
-  return `${indent}${prefix}${f.title}  ${f.type}\xB7${f.priority}${ref}`;
-}
-function formatWorkItem(item, done) {
-  const lines = [];
-  if (item.kind === "bundle") {
-    const count = item.findings.length;
-    const priority = item.findings.length > 0 ? item.findings.map((f) => f.priority).sort((a, b) => {
-      const order = { urgent: 0, high: 1, medium: 2, low: 3 };
-      return (order[a] ?? 3) - (order[b] ?? 3);
-    })[0] : "medium";
-    const prefix = done ? "\u2713 " : "";
-    const prRef = done && item.pr?.githubPrNumber ? `  PR #${item.pr.githubPrNumber}` : "";
-    lines.push(`  ${prefix}\u{1F4E6} ${item.title} (${count} findings) \u2014 ${priority}${prRef}`);
-    for (const f of item.findings) {
-      lines.push(formatFinding(f, "     ", done));
+// src/mcp/tools/dev-loop.ts
+import { resolve as resolve6 } from "path";
+
+// src/lib/worktree.ts
+import { execSync as execSync2 } from "child_process";
+import { join as join7 } from "path";
+import { existsSync as existsSync7, symlinkSync, copyFileSync, mkdirSync as mkdirSync5 } from "fs";
+var WORKTREES_DIR = ".yapout/worktrees";
+function getWorktreesDir(cwd) {
+  return join7(cwd, WORKTREES_DIR);
+}
+function getWorktreePath(cwd, ticketId) {
+  return join7(cwd, WORKTREES_DIR, ticketId);
+}
+function createWorktree(cwd, ticketId, branchName, baseBranch) {
+  const wtPath = getWorktreePath(cwd, ticketId);
+  const wtDir = getWorktreesDir(cwd);
+  if (!existsSync7(wtDir)) mkdirSync5(wtDir, { recursive: true });
+  execSync2(
+    `git worktree add "${wtPath}" -b ${branchName} origin/${baseBranch}`,
+    { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  );
+  const nodeModulesSrc = join7(cwd, "node_modules");
+  const nodeModulesDst = join7(wtPath, "node_modules");
+  if (existsSync7(nodeModulesSrc) && !existsSync7(nodeModulesDst)) {
+    try {
+      symlinkSync(nodeModulesSrc, nodeModulesDst, "junction");
+    } catch {
+      try {
+        execSync2("npm install --prefer-offline", {
+          cwd: wtPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: 12e4
+        });
+      } catch {
+      }
     }
-  } else {
-    const f = item.findings[0];
-    if (f) {
-      const prRef = done && item.pr?.githubPrNumber ? `  PR #${item.pr.githubPrNumber}` : "";
-      const prefix = done ? "\u2713 " : "";
-      const ref = f.linearIssueId ? `  ${f.linearIssueId}` : "";
-      lines.push(`  ${prefix}${item.title}  ${f.type}\xB7${f.priority}${ref}${prRef}`);
+  }
+  for (const envFile of [".env", ".env.local"]) {
+    const src = join7(cwd, envFile);
+    if (existsSync7(src)) {
+      copyFileSync(src, join7(wtPath, envFile));
     }
   }
-  return lines.join("\n");
+  return wtPath;
 }
-function registerQueueTool(server, ctx) {
-  server.tool(
-    "yapout_queue",
-    "List work items (bundles and standalone findings) ready for local implementation, plus active and done items.",
-    {
-      includeIds: z4.boolean().optional().describe("Include work item IDs in output (default: false)")
-    },
-    withScopeCheck(ctx, "yapout_queue", 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(
-        anyApi5.functions.workQueue.getWorkQueue,
-        { projectId: ctx.projectId }
-      );
-      if (!data) {
-        return {
-          content: [
-            { type: "text", text: "Could not fetch work queue." }
-          ],
-          isError: true
-        };
-      }
-      const sections = [];
-      sections.push(`Ready (${data.ready.length}):`);
-      if (data.ready.length === 0) {
-        sections.push("  (none)");
-      } else {
-        for (const item of data.ready) {
-          const line = formatWorkItem(item);
-          if (args.includeIds) {
-            sections.push(`${line}  [${item.id}]`);
-          } else {
-            sections.push(line);
+function removeWorktree(cwd, wtPath) {
+  try {
+    execSync2(`git worktree remove "${wtPath}" --force`, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    try {
+      execSync2(`git worktree prune`, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+    }
+  }
+}
+
+// src/mcp/tools/dev-loop.ts
+var queueTool = defineTool({
+  name: "yapout_queue",
+  description: "List Directives for the repo's bound Resource (data-model-redesign-2026-05-01). Buckets queued / in_progress / review by default; pass includeAll to get drafted / vetted / done / cancelled too.",
+  inputSchema: {
+    includeAll: z.boolean().optional().describe(
+      "Include drafted/vetted/done/cancelled directives (default: false \u2014 only queued/in_progress/review)"
+    ),
+    limit: z.number().optional().describe("Max directives to fetch (default: 100)")
+  },
+  handler: async (ctx, args) => {
+    const repoRoot = resolveRepoRoot(ctx.cwd);
+    const cfg = readResourceConfig(repoRoot);
+    if (!cfg) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No `.yapout/config.json` found. Run `yapout init` in this repo first."
           }
-        }
+        ],
+        isError: true
+      };
+    }
+    const result = await ctx.client.query(
+      anyApi5.functions.dashboardNewModel.listDirectivesForResource,
+      {
+        resourceId: cfg.resourceId,
+        limit: args.limit ?? 100
       }
-      sections.push("");
-      sections.push(`Active (${data.active.length}):`);
-      if (data.active.length === 0) {
-        sections.push("  (none)");
-      } else {
-        for (const item of data.active) {
-          const statusTag = item.status === "failed" ? " \u274C FAILED" : item.status === "review" ? " \u{1F50D} review" : "";
-          const line = formatWorkItem(item);
-          if (args.includeIds) {
-            sections.push(`${line}${statusTag}  [${item.id}]`);
-          } else {
-            sections.push(`${line}${statusTag}`);
+    );
+    if (!result) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No access to the bound Resource. Check `yapout status` and re-run `yapout init` if needed."
           }
+        ],
+        isError: true
+      };
+    }
+    const visible = args.includeAll ? result.directives : result.directives.filter(
+      (d) => ["queued", "in_progress", "review"].includes(d.status)
+    );
+    const buckets = {};
+    for (const d of visible) (buckets[d.status] ??= []).push(d);
+    const lines = [];
+    lines.push(
+      `Resource: ${result.resource.remoteUrl ?? result.resource.canonicalId} (${result.resource._id})`
+    );
+    lines.push("");
+    const order = args.includeAll ? [
+      "queued",
+      "in_progress",
+      "review",
+      "vetted",
+      "drafted",
+      "deployed",
+      "done",
+      "cancelled"
+    ] : ["queued", "in_progress", "review"];
+    let total = 0;
+    for (const status of order) {
+      const rows = buckets[status];
+      if (!rows || rows.length === 0) continue;
+      total += rows.length;
+      lines.push(`${labelForStatus(status)} (${rows.length}):`);
+      for (const d of rows) {
+        const exec2 = d.latestExecution ? ` [exec ${d.latestExecution._id.slice(-6)} ${d.latestExecution.devStatus}]` : "";
+        lines.push(`  ${d._id}  ${d.title}${exec2}`);
+        if (d.parentRequestTitles.length > 0) {
+          lines.push(
+            `    \u21B3 ${d.parentRequestTitles.join(" | ")}` + (d.parentRequestCount > d.parentRequestTitles.length ? ` (+${d.parentRequestCount - d.parentRequestTitles.length} more)` : "")
+          );
         }
       }
-      sections.push("");
-      sections.push(`Done (${data.done.length}):`);
-      if (data.done.length === 0) {
-        sections.push("  (none)");
-      } else {
-        for (const item of data.done) {
-          const line = formatWorkItem(item, true);
-          if (args.includeIds) {
-            sections.push(`${line}  [${item.id}]`);
-          } else {
-            sections.push(line);
-          }
-        }
-      }
-      if (data.agentStatus.isActive) {
-        sections.push("");
-        sections.push(`Agent: ${data.agentStatus.agentCount} active, ${data.agentStatus.worktreeCount} worktrees`);
+      lines.push("");
+    }
+    if (total === 0) {
+      const filter = args.includeAll ? "" : " (use includeAll=true to include drafted/done)";
+      lines.push(`No directives.${filter}`);
+    }
+    const structured = {
+      resource: result.resource,
+      directives: visible.map((d) => ({
+        directiveId: d._id,
+        title: d.title,
+        status: d.status,
+        actionVerb: d.actionVerb,
+        branchName: d.branchName,
+        parentRequestTitles: d.parentRequestTitles,
+        parentRequestCount: d.parentRequestCount,
+        latestExecution: d.latestExecution
+      }))
+    };
+    return {
+      content: [
+        { type: "text", text: lines.join("\n") },
+        {
+          type: "text",
+          text: "\n---\nStructured data:\n" + JSON.stringify(structured, null, 2)
+        }
+      ]
+    };
+  }
+});
+var pickTool = defineTool({
+  name: "yapout_pick",
+  description: "Claim a queued Directive for the active worktree (data-model-redesign-2026-05-01). Locks the Directive (queued \u2192 in_progress), inserts an Execution row at devStatus=running, creates a `.yapout/worktrees/directive-<short>` git worktree, and writes `.yapout/active-execution.json` inside it.",
+  inputSchema: {
+    directiveId: z.string().describe("Convex `directives._id` to pick"),
+    branch: z.string().optional().describe(
+      "Override branch name (default: `<branch_prefix>/directive-<short-id>` from .yapout/config.yml)"
+    ),
+    agent: z.string().optional().describe("Implementer identity tag (default: 'claude')")
+  },
+  handler: async (ctx, args) => {
+    const repoRoot = resolveRepoRoot(ctx.cwd);
+    const cfg = readResourceConfig(repoRoot);
+    if (!cfg) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No `.yapout/config.json` found. Run `yapout init` in this repo first."
+          }
+        ],
+        isError: true
+      };
+    }
+    const yapoutCfg = readYapoutConfig(repoRoot);
+    const baseBranch = cfg.defaultBranch ?? (() => {
+      try {
+        return getDefaultBranch(repoRoot);
+      } catch {
+        return "main";
       }
-      const structured = {
-        ready: data.ready.map((item) => ({
-          workItemId: item.id,
-          kind: item.kind,
-          title: item.title,
-          findings: item.findings.map((f) => ({
-            id: f.id,
-            title: f.title,
-            type: f.type,
-            priority: f.priority,
-            linearIssueId: f.linearIssueId
-          }))
-        })),
-        activeCount: data.active.length,
-        doneCount: data.done.length
+    })();
+    const shortId = args.directiveId.slice(-6);
+    const branchName = args.branch ?? `${yapoutCfg.branch_prefix}/directive-${shortId}`;
+    const worktreePath = getWorktreePath(repoRoot, `directive-${shortId}`);
+    let result;
+    try {
+      result = await ctx.client.mutation(
+        anyApi5.functions.resourcesCli.createExecutionForDirective,
+        {
+          directiveId: args.directiveId,
+          worktreePath,
+          branch: branchName,
+          agent: args.agent ?? "claude"
+        }
+      );
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to pick Directive: ${err.message}`
+          }
+        ],
+        isError: true
       };
+    }
+    try {
+      createWorktree(
+        repoRoot,
+        `directive-${shortId}`,
+        branchName,
+        baseBranch
+      );
+    } catch (err) {
       return {
         content: [
-          { type: "text", text: sections.join("\n") },
-          { type: "text", text: "\n---\nStructured data:\n" + JSON.stringify(structured, null, 2) }
-        ]
+          {
+            type: "text",
+            text: `Server-side pick succeeded but worktree creation failed: ${err.message}
+
+Recovery: the Directive is now \`in_progress\` and an Execution row exists (executionId: ${result.executionId}). Resolve the worktree issue and re-run, or flip the Directive back to \`queued\` from the dashboard.`
+          }
+        ],
+        isError: true
       };
-    })
-  );
+    }
+    writeActiveExecution(worktreePath, {
+      executionId: result.executionId,
+      directiveId: result.directiveId,
+      branch: branchName,
+      worktreePath,
+      startedAt: Date.now()
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Picked: ${result.directiveTitle}
+  directive: ${result.directiveId}
+  execution: ${result.executionId}
+  worktree:  ${worktreePath}
+  branch:    ${branchName}
+
+Next: cd into the worktree to implement. Use yapout_observe for tangential observations and yapout_submit when ready for review.`
+        }
+      ]
+    };
+  }
+});
+var submitTool = defineTool({
+  name: "yapout_submit",
+  description: "Mark the active Execution as submitted and move the parent Directive to review (data-model-redesign-2026-05-01). Reads `.yapout/active-execution.json` from cwd; clears it on success. Pushing/PR opening is out of scope (the harness handles publication).",
+  inputSchema: {},
+  handler: async (ctx) => {
+    const repoRoot = resolveRepoRoot(ctx.cwd);
+    const cfg = readResourceConfig(repoRoot);
+    if (!cfg) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No `.yapout/config.json` found. Run `yapout init` in this repo first."
+          }
+        ],
+        isError: true
+      };
+    }
+    const active = readActiveExecution(ctx.cwd);
+    if (!active) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No active Execution. yapout_submit must run from a worktree where yapout_pick (or `yapout pick`) was called."
+          }
+        ],
+        isError: true
+      };
+    }
+    let result;
+    try {
+      result = await ctx.client.mutation(
+        anyApi5.functions.resourcesCli.submitExecution,
+        { executionId: active.executionId }
+      );
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to submit Execution: ${err.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+    clearActiveExecution(ctx.cwd);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Submitted Execution ${result.executionId}.
+Directive ${result.directiveId} is now in \`review\`.`
+        }
+      ]
+    };
+  }
+});
+var observeTool = defineTool({
+  name: "yapout_observe",
+  description: "File an `agent_observation` Raw against the active Execution (data-model-redesign-2026-05-01). Bypasses intakeRoutes; lineage anchored via `spawnedByExecutionId`. Use when the implementing agent notices something tangential to the Directive \u2014 extraction will turn it into a Request (or link it to an existing one).",
+  inputSchema: {
+    body: z.string().describe(
+      "Freeform observation text. The extraction pipeline parses this into a Request."
+    ),
+    severity: z.enum(["low", "normal", "high"]).optional().describe("Severity hint (default: normal)"),
+    area: z.string().optional().describe(
+      "Optional scoping hint for the extraction chain (e.g., 'auth', 'billing')"
+    )
+  },
+  handler: async (ctx, args) => {
+    const cwd = resolve6(ctx.cwd);
+    const repoRoot = resolveRepoRoot(cwd);
+    const cfg = readResourceConfig(repoRoot);
+    if (!cfg) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No `.yapout/config.json` found. Run `yapout init` in this repo first."
+          }
+        ],
+        isError: true
+      };
+    }
+    const active = readActiveExecution(cwd);
+    if (!active) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No active Execution. yapout_observe must run from a worktree where yapout_pick (or `yapout pick`) was called."
+          }
+        ],
+        isError: true
+      };
+    }
+    const body = args.body.trim();
+    if (!body) {
+      return {
+        content: [
+          { type: "text", text: "Observation body cannot be empty." }
+        ],
+        isError: true
+      };
+    }
+    let result;
+    try {
+      result = await ctx.client.mutation(
+        anyApi5.functions.resourcesCli.createAgentObservationRaw,
+        {
+          executionId: active.executionId,
+          body,
+          ...args.severity ? { severityHint: args.severity } : {},
+          ...args.area ? { area: args.area } : {}
+        }
+      );
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to file observation: ${err.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Filed agent observation (raw: ${result.rawId}, execution: ${result.executionId}).
+Extraction will turn this into a Request (or link it to an existing one).`
+        }
+      ]
+    };
+  }
+});
+function registerDevLoopTools(server, ctx) {
+  registerTool(server, ctx, queueTool);
+  registerTool(server, ctx, pickTool);
+  registerTool(server, ctx, submitTool);
+  registerTool(server, ctx, observeTool);
+}
+function labelForStatus(status) {
+  switch (status) {
+    case "queued":
+      return "Ready to pick";
+    case "in_progress":
+      return "In progress";
+    case "review":
+      return "In review";
+    case "vetted":
+      return "Vetted (PM-side)";
+    case "drafted":
+      return "Drafted (PM-side)";
+    case "deployed":
+      return "Deployed";
+    case "done":
+      return "Done";
+    case "cancelled":
+      return "Cancelled";
+    default:
+      return status;
+  }
 }
 
 // src/mcp/tools/get-brief.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 function registerGetBriefTool(server, ctx) {
   server.tool(
     "yapout_get_brief",
     "Fetch the full implementation context for a work item (finding or bundle)",
     {
-      findingId: z5.string().optional().describe("The finding ID to get the brief for (deprecated: use workItemId)"),
-      workItemId: z5.string().optional().describe("The work item ID (finding or bundle) to get the brief for")
+      findingId: z4.string().optional().describe("The finding ID to get the brief for (deprecated: use workItemId)"),
+      workItemId: z4.string().optional().describe("The work item ID (finding or bundle) to get the brief for")
     },
     withScopeCheck(ctx, "yapout_get_brief", async (args) => {
       const itemId = args.workItemId || args.findingId;
@@ -1741,72 +2056,7 @@ function registerGetBriefTool(server, ctx) {
 }
 
 // src/mcp/tools/claim.ts
-import { z as z6 } from "zod";
-
-// src/lib/worktree.ts
-import { execSync as execSync2 } from "child_process";
-import { join as join7 } from "path";
-import { existsSync as existsSync7, symlinkSync, copyFileSync, mkdirSync as mkdirSync5 } from "fs";
-var WORKTREES_DIR = ".yapout/worktrees";
-function getWorktreesDir(cwd) {
-  return join7(cwd, WORKTREES_DIR);
-}
-function getWorktreePath(cwd, ticketId) {
-  return join7(cwd, WORKTREES_DIR, ticketId);
-}
-function createWorktree(cwd, ticketId, branchName, baseBranch) {
-  const wtPath = getWorktreePath(cwd, ticketId);
-  const wtDir = getWorktreesDir(cwd);
-  if (!existsSync7(wtDir)) mkdirSync5(wtDir, { recursive: true });
-  execSync2(
-    `git worktree add "${wtPath}" -b ${branchName} origin/${baseBranch}`,
-    { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-  );
-  const nodeModulesSrc = join7(cwd, "node_modules");
-  const nodeModulesDst = join7(wtPath, "node_modules");
-  if (existsSync7(nodeModulesSrc) && !existsSync7(nodeModulesDst)) {
-    try {
-      symlinkSync(nodeModulesSrc, nodeModulesDst, "junction");
-    } catch {
-      try {
-        execSync2("npm install --prefer-offline", {
-          cwd: wtPath,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"],
-          timeout: 12e4
-        });
-      } catch {
-      }
-    }
-  }
-  for (const envFile of [".env", ".env.local"]) {
-    const src = join7(cwd, envFile);
-    if (existsSync7(src)) {
-      copyFileSync(src, join7(wtPath, envFile));
-    }
-  }
-  return wtPath;
-}
-function removeWorktree(cwd, wtPath) {
-  try {
-    execSync2(`git worktree remove "${wtPath}" --force`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch {
-    try {
-      execSync2(`git worktree prune`, {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } catch {
-    }
-  }
-}
-
-// src/mcp/tools/claim.ts
+import { z as z5 } from "zod";
 import { join as join8 } from "path";
 import { existsSync as existsSync8, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
 
@@ -1964,9 +2214,9 @@ function registerClaimTool(server, ctx) {
     "yapout_claim",
     "Claim a work item (bundle or standalone finding) for local implementation. Creates a branch (or worktree), writes the brief, and updates status.",
     {
-      workItemId: z6.string().describe("The work item ID to claim (bundle ID or finding ID from yapout_queue)"),
-      findingId: z6.string().optional().describe("Deprecated: use workItemId instead. If provided, treated as a standalone finding."),
-      worktree: z6.boolean().optional().describe("Create a git worktree for parallel work (default: false)")
+      workItemId: z5.string().describe("The work item ID to claim (bundle ID or finding ID from yapout_queue)"),
+      findingId: z5.string().optional().describe("Deprecated: use workItemId instead. If provided, treated as a standalone finding."),
+      worktree: z5.boolean().optional().describe("Create a git worktree for parallel work (default: false)")
     },
     withScopeCheck(ctx, "yapout_claim", async (args) => {
       if (!ctx.projectId) {
@@ -2222,17 +2472,17 @@ async function reportClaimEvents(ctx, pipelineRunId, title, branchName) {
 }
 
 // src/mcp/tools/event.ts
-import { z as z7 } from "zod";
+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: z7.string().describe("The pipeline run ID"),
-      event: z7.string().describe(
+      pipelineRunId: z6.string().describe("The pipeline run ID"),
+      event: z6.string().describe(
         'Event type (e.g., "reading_codebase", "writing_code", "running_tests")'
       ),
-      message: z7.string().describe("Human-readable description")
+      message: z6.string().describe("Human-readable description")
     },
     withScopeCheck(ctx, "yapout_event", async (args) => {
       try {
@@ -2268,7 +2518,7 @@ function registerEventTool(server, ctx) {
 }
 
 // src/mcp/tools/ship.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 
 // src/lib/github-cli.ts
 import { execSync as execSync3 } from "child_process";
@@ -2347,10 +2597,10 @@ function registerShipTool(server, ctx) {
     "yapout_ship",
     "Commit, push, open a PR, and mark the work item as done. Run yapout_check first if post-flight checks are configured.",
     {
-      message: z8.string().optional().describe("Custom commit message (overrides template)"),
-      skipPr: z8.boolean().optional().describe("Just push, don't open a PR"),
-      pipelineRunId: z8.string().describe("The pipeline run ID from yapout_claim"),
-      worktreePath: z8.string().optional().describe("Worktree path (if claiming was done with worktree: true)")
+      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)")
     },
     withScopeCheck(ctx, "yapout_ship", async (args) => {
       const gitCwd = args.worktreePath || ctx.cwd;
@@ -2570,7 +2820,7 @@ function registerShipTool(server, ctx) {
 }
 
 // src/mcp/tools/check.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 import { exec } from "child_process";
 var COMMAND_TIMEOUT_MS = 5 * 60 * 1e3;
 var MAX_OUTPUT_LINES = 100;
@@ -2581,7 +2831,7 @@ function truncate(text) {
 ` + lines.slice(-MAX_OUTPUT_LINES).join("\n");
 }
 function runCommand(command, cwd) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve16) => {
     const start = Date.now();
     const child = exec(command, {
       cwd,
@@ -2589,7 +2839,7 @@ function runCommand(command, cwd) {
       maxBuffer: 10 * 1024 * 1024
       // 10MB
     }, (error, stdout, stderr) => {
-      resolve12({
+      resolve16({
         exitCode: error?.code ?? (error ? 1 : 0),
         stdout: truncate(stdout),
         stderr: truncate(stderr),
@@ -2597,7 +2847,7 @@ function runCommand(command, cwd) {
       });
     });
     child.on("error", () => {
-      resolve12({
+      resolve16({
         exitCode: 1,
         stdout: "",
         stderr: `Command timed out after ${COMMAND_TIMEOUT_MS / 1e3}s`,
@@ -2611,9 +2861,9 @@ function registerCheckTool(server, ctx) {
     "yapout_check",
     "Run post-flight checks (lint, test, typecheck) before shipping. Configure commands in .yapout/config.yml",
     {
-      commands: z9.array(z9.string()).optional().describe("Override: run these commands instead of post_flight config"),
-      pipelineRunId: z9.string().optional().describe("Pipeline run ID for event reporting"),
-      worktreePath: z9.string().optional().describe("Run checks in this worktree directory instead of the repo root")
+      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")
     },
     withScopeCheck(ctx, "yapout_check", async (args) => {
       const checkCwd = args.worktreePath || ctx.cwd;
@@ -2683,109 +2933,26 @@ function registerCheckTool(server, ctx) {
   );
 }
 
-// src/mcp/tools/bundle.ts
-import { z as z10 } from "zod";
-import { join as join10 } from "path";
-import { existsSync as existsSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7 } from "fs";
-function registerBundleTool(server, ctx) {
+// src/mcp/tools/get-unenriched-findings.ts
+import { z as z9 } from "zod";
+function registerGetUnenrichedFindingsTool(server, ctx) {
   server.tool(
-    "yapout_bundle",
-    "Add a finding to the current finding's bundle so they ship as one PR",
+    "yapout_get_unenriched_finding",
+    `Start enriching a finding. Returns the next draft finding (or a specific one by ID) with full context including the original capture quote, project context, and existing finding titles for duplicate detection.
+
+The finding 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 existingFindings list
+3. If the finding 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`,
     {
-      findingId: z10.string().describe("Finding ID to add to the bundle"),
-      withFinding: z10.string().describe("Lead finding ID (currently being worked on)")
+      findingId: z9.string().optional().describe("Specific finding ID to enrich. If omitted, returns the highest priority draft finding.")
     },
-    withScopeCheck(ctx, "yapout_bundle", async (args) => {
-      const result = await ctx.client.mutation(
-        anyApi5.functions.bundles.createBundle,
-        { leadFindingId: args.withFinding, joiningFindingId: args.findingId }
-      );
-      const bundledBrief = await ctx.client.query(
-        anyApi5.functions.bundles.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.findings.length} findings`,
-        ""
-      ];
-      for (const t of bundledBrief.findings) {
-        sections.push(`## ${t.linearIssueId ?? t.findingId}: ${t.title}`);
-        sections.push("");
-        sections.push(`**Priority:** ${t.priority} | **Type:** ${t.type}`);
-        if (t.linearIssueUrl) sections.push(`**Linear:** ${t.linearIssueUrl}`);
-        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 = join10(ctx.cwd, ".yapout");
-      if (!existsSync10(yapoutDir)) mkdirSync7(yapoutDir, { recursive: true });
-      writeFileSync8(join10(yapoutDir, "brief.md"), combinedBrief);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                bundleId: result.bundleId,
-                findings: bundledBrief.findings.map((t) => ({
-                  findingId: t.findingId,
-                  title: t.title
-                })),
-                combinedBrief,
-                message: `${bundledBrief.findings.length} findings bundled. Brief updated.`
-              },
-              null,
-              2
-            )
-          }
-        ]
-      };
-    })
-  );
-}
-
-// src/mcp/tools/get-unenriched-findings.ts
-import { z as z11 } from "zod";
-function registerGetUnenrichedFindingsTool(server, ctx) {
-  server.tool(
-    "yapout_get_unenriched_finding",
-    `Start enriching a finding. Returns the next draft finding (or a specific one by ID) with full context including the original capture quote, project context, and existing finding titles for duplicate detection.
-
-The finding 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 existingFindings list
-3. If the finding 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`,
-    {
-      findingId: z11.string().optional().describe("Specific finding ID to enrich. If omitted, returns the highest priority draft finding.")
-    },
-    withScopeCheck(ctx, "yapout_get_unenriched_finding", async (args) => {
-      const projectId = ctx.projectId ?? process.env.YAPOUT_PROJECT_ID;
-      if (!projectId) {
+    withScopeCheck(ctx, "yapout_get_unenriched_finding", async (args) => {
+      const projectId = ctx.projectId ?? process.env.YAPOUT_PROJECT_ID;
+      if (!projectId) {
         return {
           content: [
             {
@@ -2895,7 +3062,7 @@ function registerGetExistingFindingsTool(server, ctx) {
 }
 
 // src/mcp/tools/save-enrichment.ts
-import { z as z12 } from "zod";
+import { z as z10 } from "zod";
 
 // src/mcp/tools/enrichment-session.ts
 var activeSessions = /* @__PURE__ */ new Map();
@@ -2940,22 +3107,22 @@ This tool saves the enrichment, then automatically creates the Linear issue with
 
 The finding transitions: enriching \u2192 enriched \u2192 ready.`,
     {
-      findingId: z12.string().describe("The finding ID to enrich (from yapout_get_unenriched_finding)"),
-      title: z12.string().describe("Refined finding title \u2014 improve it if the original was vague"),
-      cleanDescription: z12.string().describe("Human-readable summary for the Linear issue body. Write the kind of finding a senior engineer would write."),
-      acceptanceCriteria: z12.array(z12.string()).describe("List of testable acceptance criteria (each a single clear statement)"),
-      implementationBrief: z12.string().describe("Deep technical context for the implementing agent: which files, what approach, edge cases to watch for"),
-      clarifications: z12.array(
-        z12.object({
-          question: z12.string().describe("The question you asked the developer"),
-          answer: z12.string().describe("The developer's answer")
+      findingId: z10.string().describe("The finding ID to enrich (from yapout_get_unenriched_finding)"),
+      title: z10.string().describe("Refined finding title \u2014 improve it if the original was vague"),
+      cleanDescription: z10.string().describe("Human-readable summary for the Linear issue body. Write the kind of finding a senior engineer would write."),
+      acceptanceCriteria: z10.array(z10.string()).describe("List of testable acceptance criteria (each a single clear statement)"),
+      implementationBrief: z10.string().describe("Deep technical context for the implementing agent: which files, what approach, edge cases to watch for"),
+      clarifications: z10.array(
+        z10.object({
+          question: z10.string().describe("The question you asked the developer"),
+          answer: z10.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: z12.boolean().optional().describe("Set to true if this finding is too large for a single PR"),
-      suggestedSplit: z12.array(z12.string()).optional().describe("If oversized: suggested sub-finding titles for breaking it down"),
-      nature: z12.enum(["implementable", "operational", "spike"]).optional().describe("Override the finding's nature if enrichment reveals it should be reclassified"),
-      cloudSafe: z12.boolean().optional().describe("Set to true ONLY if this is a small mechanical change a cloud agent can ship without sandbox testing \u2014 text/copy edits, classname tweaks, single-named-constant changes, \u226430 lines, single file, no logic/type/dependency changes. Default false."),
-      sessionId: z12.string().optional().describe("Bulk enrichment session ID (from yapout_start_enrichment). Updates session stats.")
+      isOversized: z10.boolean().optional().describe("Set to true if this finding is too large for a single PR"),
+      suggestedSplit: z10.array(z10.string()).optional().describe("If oversized: suggested sub-finding titles for breaking it down"),
+      nature: z10.enum(["implementable", "operational", "spike"]).optional().describe("Override the finding's nature if enrichment reveals it should be reclassified"),
+      cloudSafe: z10.boolean().optional().describe("Set to true ONLY if this is a small mechanical change a cloud agent can ship without sandbox testing \u2014 text/copy edits, classname tweaks, single-named-constant changes, \u226430 lines, single file, no logic/type/dependency changes. Default false."),
+      sessionId: z10.string().optional().describe("Bulk enrichment session ID (from yapout_start_enrichment). Updates session stats.")
     },
     withScopeCheck(ctx, "yapout_save_enrichment", async (args) => {
       try {
@@ -3027,13 +3194,13 @@ The finding transitions: enriching \u2192 enriched \u2192 ready.`,
 }
 
 // src/mcp/tools/sync-to-linear.ts
-import { z as z13 } from "zod";
+import { z as z11 } from "zod";
 function registerSyncToLinearTool(server, ctx) {
   server.tool(
     "yapout_sync_to_linear",
     "Trigger Linear issue creation for an enriched finding. The sync runs server-side (encrypted Linear token in Convex).",
     {
-      findingId: z13.string().describe("The finding ID to sync to Linear")
+      findingId: z11.string().describe("The finding ID to sync to Linear")
     },
     withScopeCheck(ctx, "yapout_sync_to_linear", async (args) => {
       try {
@@ -3072,371 +3239,8 @@ function registerSyncToLinearTool(server, ctx) {
   );
 }
 
-// src/mcp/tools/submit-yap-session.ts
-import { z as z14 } from "zod";
-function registerSubmitYapSessionTool(server, ctx) {
-  server.tool(
-    "yapout_submit_yap_session",
-    "Submit a yap session transcript for finding extraction",
-    {
-      title: z14.string().describe("Session title (e.g., 'Notification system brainstorm')"),
-      transcript: z14.string().describe("Cleaned conversation transcript")
-    },
-    withScopeCheck(ctx, "yapout_submit_yap_session", async (args) => {
-      if (!ctx.projectId) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "No project linked. Run yapout_init or yapout link first."
-            }
-          ],
-          isError: true
-        };
-      }
-      try {
-        const captureId = await ctx.client.mutation(
-          anyApi5.functions.captures.createFromYapSession,
-          {
-            projectId: ctx.projectId,
-            title: args.title,
-            transcript: args.transcript
-          }
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  captureId,
-                  message: "Yap session submitted. Findings 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 z15 } 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(input5) {
-  const lower = input5.toLowerCase().trim();
-  return PERSONA_PRESETS[lower] ?? input5;
-}
-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: z15.string().optional().describe(
-        'Interviewer persona: "tech lead", "qa engineer", "product owner", "end user", or a custom description'
-      ),
-      context: z15.string().optional().describe("What the developer wants to discuss")
-    },
-    withScopeCheck(ctx, "yapout_start_yap", 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 findings \u2014 implementation happens later through the normal finding pipeline. If the user asks you to "just do it" or "make that change now," push back: "That's what the findings 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 finding. For each finding, track:
-- What has been clearly stated (title, scope, priority)
-- What has been discussed in enough depth to write a finding (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 findings. This is normal \u2014 real conversations are not linear. Your job is to follow the thread and keep track of the state of each finding 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 finding. For each one, ask yourself:
-- Could a developer read this finding 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 finding 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 finding, you must make an honest call: is this enriched or not?
-
-Mark a finding as ENRICHED (isEnriched: true) when:
-- The conversation covered it thoroughly enough to produce a clear finding
-- 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 finding 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 findings get enriched properly later. Falsely marking something as enriched skips that process and produces bad findings.
-
-PRESENTING THE FINAL PICTURE:
-When the conversation feels complete, present a summary grouped by bundles and standalone issues:
-
-"Here's what I've gathered from our conversation:
-
-**[Bundle 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 finding, provide:
-- title, description, sourceQuote, type, priority, confidence, nature
-- isEnriched: your honest assessment (see above)
-
-For ENRICHED findings (isEnriched: true), also include:
-- enrichedDescription: clean, final description \u2014 write the kind of finding 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 finding
-
-For findings with CHILDREN (bundles), also include:
-- bundleDescription: 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:
-- Findings with children become bundles \u2014 never create child issues as separate top-level findings
-- 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)
-- findings: the array (bundles with children, standalone issues)
-
-This creates findings (enriched or draft based on your assessment) and bundles \u2014 all in one call. Enriched findings 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 findings.
-
---- 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 z16 } from "zod";
-var clarificationSchema = z16.object({
-  question: z16.string().describe("The question asked during the conversation"),
-  answer: z16.string().describe("The answer given")
-});
-var childSchema = z16.object({
-  title: z16.string().describe("Child issue title"),
-  description: z16.string().describe("What needs to be done and why"),
-  sourceQuote: z16.string().describe("Relevant excerpt from the conversation"),
-  type: z16.enum(["feature", "bug", "chore", "spike"]).describe("Finding category"),
-  priority: z16.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
-  confidence: z16.number().min(0).max(1).describe("Confidence this is a clear, actionable finding (0-1)"),
-  nature: z16.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 finding a developer could pick up.
-  isEnriched: z16.boolean().optional().describe(
-    "Did the conversation cover this issue deeply enough to produce a complete finding? true = enriched (ready for Linear), false/omitted = draft (needs async enrichment)"
-  ),
-  enrichedDescription: z16.string().optional().describe("Clean, final description for the Linear issue body (required if isEnriched)"),
-  acceptanceCriteria: z16.array(z16.string()).optional().describe("Testable acceptance criteria (required if isEnriched)"),
-  implementationBrief: z16.string().optional().describe("Technical context: files, approach, edge cases (optional \u2014 the implementing agent reads the codebase anyway)"),
-  clarifications: z16.array(clarificationSchema).optional().describe("Relevant Q&A from the conversation that shaped this finding"),
-  dependsOn: z16.array(z16.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 findings 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-finding. Creates capture, findings (enriched or draft). Enriched findings are ready for the user to sync to Linear from the UI. Draft findings need further enrichment via the async pipeline.",
-    {
-      sessionTitle: z16.string().describe("Descriptive title for this yap session"),
-      sessionTranscript: z16.string().describe("Cleaned transcript of the conversation (meeting-notes style)"),
-      findings: z16.array(
-        z16.object({
-          title: z16.string().describe("Finding title"),
-          description: z16.string().describe("What needs to be done and why"),
-          sourceQuote: z16.string().describe("Relevant excerpt from the conversation"),
-          type: z16.enum(["feature", "bug", "chore", "spike"]).describe("Finding category (do not use spike \u2014 use nature instead)"),
-          priority: z16.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
-          confidence: z16.number().min(0).max(1).describe("Your confidence this is a clear, actionable finding (0-1)"),
-          nature: z16.enum(["implementable", "operational", "spike"]).describe("implementable = code changes, operational = manual task, spike = needs scoping"),
-          sourceFindingId: z16.string().optional().describe("ID of an existing finding this scopes (e.g., scoping a spike)"),
-          // Enrichment data for standalone findings
-          isEnriched: z16.boolean().optional().describe("For standalone issues: was this thoroughly discussed? true = enriched, false = draft"),
-          enrichedDescription: z16.string().optional().describe("Clean description for Linear (required if isEnriched)"),
-          acceptanceCriteria: z16.array(z16.string()).optional().describe("Testable acceptance criteria (required if isEnriched)"),
-          implementationBrief: z16.string().optional().describe("Technical context (optional)"),
-          clarifications: z16.array(clarificationSchema).optional().describe("Relevant Q&A from conversation"),
-          // Bundle fields — when a finding has children, a bundle is created
-          bundleDescription: z16.string().optional().describe("What this body of work accomplishes (only for findings with children)"),
-          suggestedOrder: z16.string().optional().describe("Implementation order: 'Phase 1: A, then Phase 2: B+C' (only for findings with children)"),
-          children: z16.array(childSchema).optional().describe("Child issues \u2014 when present, a bundle is created from this finding")
-        })
-      ).describe("Findings from the conversation. Projects include children inline.")
-    },
-    withScopeCheck(ctx, "yapout_extract_from_yap", 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(
-          anyApi5.functions.captures.extractFromYapSession,
-          {
-            projectId: ctx.projectId,
-            title: args.sessionTitle,
-            transcript: args.sessionTranscript,
-            findings: args.findings
-          }
-        );
-        let enrichedCount = 0;
-        let draftCount = 0;
-        let totalFindings = 0;
-        for (const item of result.items) {
-          if (item.children && item.children.length > 0) {
-            for (const child of item.children) {
-              totalFindings++;
-              if (child.findingStatus === "enriched") enrichedCount++;
-              else draftCount++;
-            }
-          } else {
-            totalFindings++;
-            if (item.findingStatus === "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(
-                {
-                  captureId: result.captureId,
-                  items: result.items,
-                  summary: {
-                    totalFindings,
-                    enriched: enrichedCount,
-                    needsEnrichment: draftCount
-                  },
-                  message: `Created ${totalFindings} finding${totalFindings === 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/decompose-finding.ts
-import { z as z17 } from "zod";
+import { z as z12 } from "zod";
 function registerDecomposeFindingTool(server, ctx) {
   server.tool(
     "yapout_decompose_finding",
@@ -3454,19 +3258,19 @@ archives the original finding. Returns the bundle ID and child finding IDs.
 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.`,
     {
-      findingId: z17.string().describe("The finding being decomposed (from yapout_get_unenriched_finding)"),
-      bundleDescription: z17.string().describe("Description for the bundle \u2014 what this body of work accomplishes"),
-      suggestedOrder: z17.string().describe("Human-readable implementation order (e.g. 'Phase 1: A, then Phase 2: B+C in parallel, then Phase 3: D')"),
-      linearProjectId: z17.string().optional().describe("Existing Linear project ID to associate with. Omit to skip Linear project association."),
-      issues: z17.array(
-        z17.object({
-          title: z17.string().describe("Child issue title"),
-          description: z17.string().describe("What needs to be done and why"),
-          acceptanceCriteria: z17.array(z17.string()).describe("Testable acceptance criteria"),
-          implementationBrief: z17.string().describe("Full spec: files to modify, schema changes, edge cases, approach"),
-          type: z17.enum(["feature", "bug", "chore", "spike"]).describe("Category of work"),
-          priority: z17.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
-          dependsOn: z17.array(z17.number()).describe("Indices (0-based) of issues in this array that must be completed first")
+      findingId: z12.string().describe("The finding being decomposed (from yapout_get_unenriched_finding)"),
+      bundleDescription: z12.string().describe("Description for the bundle \u2014 what this body of work accomplishes"),
+      suggestedOrder: z12.string().describe("Human-readable implementation order (e.g. 'Phase 1: A, then Phase 2: B+C in parallel, then Phase 3: D')"),
+      linearProjectId: z12.string().optional().describe("Existing Linear project ID to associate with. Omit to skip Linear project association."),
+      issues: z12.array(
+        z12.object({
+          title: z12.string().describe("Child issue title"),
+          description: z12.string().describe("What needs to be done and why"),
+          acceptanceCriteria: z12.array(z12.string()).describe("Testable acceptance criteria"),
+          implementationBrief: z12.string().describe("Full spec: files to modify, schema changes, edge cases, approach"),
+          type: z12.enum(["feature", "bug", "chore", "spike"]).describe("Category of work"),
+          priority: z12.enum(["urgent", "high", "medium", "low"]).describe("Priority level"),
+          dependsOn: z12.array(z12.number()).describe("Indices (0-based) of issues in this array that must be completed first")
         })
       ).describe("The child issues produced by decomposition")
     },
@@ -3529,7 +3333,7 @@ full spec \u2014 schema changes, files to modify, edge cases, and acceptance cri
 }
 
 // src/mcp/tools/mark-duplicate.ts
-import { z as z18 } from "zod";
+import { z as z13 } from "zod";
 function registerMarkDuplicateTool(server, ctx) {
   server.tool(
     "yapout_mark_duplicate",
@@ -3539,9 +3343,9 @@ flow when you discover the work is already tracked in Linear.
 The finding must be in "enriching" or "enriched" status. It will be transitioned to
 "failed" with the duplicate reference stored. Nothing is synced to Linear.`,
     {
-      findingId: z18.string().describe("The yapout finding to archive as a duplicate"),
-      duplicateOfLinearId: z18.string().describe("The Linear issue identifier it duplicates (e.g. 'ENG-234')"),
-      reason: z18.string().describe("Brief explanation of why this is a duplicate")
+      findingId: z13.string().describe("The yapout finding to archive as a duplicate"),
+      duplicateOfLinearId: z13.string().describe("The Linear issue identifier it duplicates (e.g. 'ENG-234')"),
+      reason: z13.string().describe("Brief explanation of why this is a duplicate")
     },
     withScopeCheck(ctx, "yapout_mark_duplicate", async (args) => {
       if (!ctx.projectId) {
@@ -3670,7 +3474,7 @@ and issue counts so you can ask the user for confirmation before creating a new
 }
 
 // src/mcp/tools/start-enrichment.ts
-import { z as z19 } from "zod";
+import { z as z14 } from "zod";
 function registerStartEnrichmentTool(server, ctx) {
   server.tool(
     "yapout_start_enrichment",
@@ -3681,10 +3485,10 @@ and maintains filter criteria so you don't re-pass them on every call.
 
 Optionally filter by tags, capture, or explicit finding IDs.`,
     {
-      filter: z19.object({
-        tags: z19.array(z19.string()).optional().describe("Only enrich findings with these tags"),
-        captureId: z19.string().optional().describe("Only enrich findings from this capture"),
-        findingIds: z19.array(z19.string()).optional().describe("Only enrich these specific findings")
+      filter: z14.object({
+        tags: z14.array(z14.string()).optional().describe("Only enrich findings with these tags"),
+        captureId: z14.string().optional().describe("Only enrich findings from this capture"),
+        findingIds: z14.array(z14.string()).optional().describe("Only enrich these specific findings")
       }).optional().describe("Filter criteria. If omitted, all draft findings in the project are included.")
     },
     withScopeCheck(ctx, "yapout_start_enrichment", async (args) => {
@@ -3740,7 +3544,7 @@ Optionally filter by tags, capture, or explicit finding IDs.`,
 }
 
 // src/mcp/tools/enrich-next.ts
-import { z as z20 } from "zod";
+import { z as z15 } from "zod";
 function registerEnrichNextTool(server, ctx) {
   server.tool(
     "yapout_enrich_next",
@@ -3751,9 +3555,9 @@ Returns the next unclaimed draft finding matching the session's filter.
 
 When done=true, all findings have been processed.`,
     {
-      sessionId: z20.string().describe("Session ID from yapout_start_enrichment"),
-      skip: z20.boolean().optional().describe("If true, skip the current finding (release back to draft)"),
-      skipFindingId: z20.string().optional().describe("The finding ID to skip (must be in 'enriching' status)")
+      sessionId: z15.string().describe("Session ID from yapout_start_enrichment"),
+      skip: z15.boolean().optional().describe("If true, skip the current finding (release back to draft)"),
+      skipFindingId: z15.string().optional().describe("The finding ID to skip (must be in 'enriching' status)")
     },
     withScopeCheck(ctx, "yapout_enrich_next", async (args) => {
       const session = getSession(args.sessionId);
@@ -3881,149 +3685,32 @@ When done=true, all findings have been processed.`,
   );
 }
 
-// src/mcp/tools/enrich-bundle.ts
-import { z as z21 } from "zod";
-function registerEnrichBundleTool(server, ctx) {
+// src/mcp/tools/block-enrichment.ts
+import { z as z16 } from "zod";
+function registerBlockEnrichmentTool(server, ctx) {
   server.tool(
-    "yapout_enrich_bundle",
-    `Claim an entire bundle for enrichment. Returns ALL findings in the bundle at once
-with their relationships, source quotes, and project context.
+    "yapout_block_enrichment",
+    `Refuse to enrich a finding because the user has not provided enough specifics for an autonomous agent to complete the work end-to-end.
+
+Use this when the finding lacks any of: target file/component, intended behavior, scope boundaries, or success criteria. Do NOT produce a half-baked enrichment "for review" \u2014 block instead. The bar for "enriched" is "another agent can ship this with zero further input."
 
-This is for enriching a bundle as a single cohesive unit \u2014 NOT individual findings.
-The agent should understand the full scope, ask questions about the bundle as a whole,
-then call yapout_save_bundle_enrichment with enrichment data for every finding.
+The finding must currently be in "enriching" status (claimed via yapout_get_unenriched_finding).
 
-The bundle and all its findings transition to "enriching" status.`,
+Transitions: enriching \u2192 needs_input. The user sees the blockerReason and questions in the UI, adds context, and resubmits.`,
     {
-      bundleId: z21.string().describe("The bundle ID to enrich")
+      findingId: z16.string().describe("The finding ID to block (currently in 'enriching')"),
+      blockerReason: z16.string().describe("One sentence: why this finding cannot be enriched as written. State the missing piece concretely."),
+      blockerQuestions: z16.array(z16.string()).min(1).describe("2-5 specific questions the user must answer before enrichment can succeed. Each must be answerable in a sentence or two.")
     },
-    withScopeCheck(ctx, "yapout_enrich_bundle", async (args) => {
+    withScopeCheck(ctx, "yapout_block_enrichment", async (args) => {
       try {
-        const result = await ctx.client.mutation(
-          anyApi5.functions.bundles.claimBundleForEnrichment,
-          { bundleId: args.bundleId }
-        );
-        if (!result) {
-          return {
-            content: [{ type: "text", text: "Failed to claim bundle for enrichment." }],
-            isError: true
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result, null, 2)
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error claiming bundle: ${err.message}` }],
-          isError: true
-        };
-      }
-    })
-  );
-}
-
-// src/mcp/tools/save-bundle-enrichment.ts
-import { z as z22 } from "zod";
-function registerSaveBundleEnrichmentTool(server, ctx) {
-  server.tool(
-    "yapout_save_bundle_enrichment",
-    `Save enrichment for an entire bundle at once. Call this after you've analyzed all
-findings in the bundle as a cohesive unit, read the codebase, and asked any questions.
-
-Provide:
-- Bundle-level: overall description, combined acceptance criteria, implementation brief
-- Per-finding: each finding gets its own refined title, description, acceptance criteria, and brief
-
-The bundle and all findings transition from "enriching" to "enriched".
-Call yapout_sync_bundle_to_linear afterwards to create the Linear project.`,
-    {
-      bundleId: z22.string().describe("The bundle ID"),
-      title: z22.string().optional().describe("Refined bundle title (optional, keeps existing if omitted)"),
-      enrichedDescription: z22.string().describe("Bundle-level description \u2014 the cohesive story of what this bundle delivers"),
-      acceptanceCriteria: z22.array(z22.string()).describe("Bundle-level acceptance criteria"),
-      implementationBrief: z22.string().describe("Bundle-level implementation brief \u2014 overall approach, architecture decisions, key files"),
-      cloudSafe: z22.boolean().optional().describe("Set true ONLY if the entire bundle is small mechanical work (\u226430 lines total, single-file ideally, text/className/constant edits). Default false. If unsure, false."),
-      findings: z22.array(z22.object({
-        findingId: z22.string().describe("Finding ID"),
-        title: z22.string().describe("Refined finding title"),
-        enrichedDescription: z22.string().describe("Finding-specific description"),
-        acceptanceCriteria: z22.array(z22.string()).describe("Finding-specific acceptance criteria"),
-        implementationBrief: z22.string().describe("Finding-specific implementation brief")
-      })).describe("Per-finding enrichment data \u2014 one entry per finding in the bundle")
-    },
-    withScopeCheck(ctx, "yapout_save_bundle_enrichment", async (args) => {
-      try {
-        await ctx.client.mutation(
-          anyApi5.functions.bundles.saveBundleEnrichment,
-          {
-            bundleId: args.bundleId,
-            title: args.title,
-            enrichedDescription: args.enrichedDescription,
-            acceptanceCriteria: args.acceptanceCriteria,
-            implementationBrief: args.implementationBrief,
-            cloudSafe: args.cloudSafe,
-            findings: args.findings.map((f) => ({
-              findingId: f.findingId,
-              title: f.title,
-              enrichedDescription: f.enrichedDescription,
-              acceptanceCriteria: f.acceptanceCriteria,
-              implementationBrief: f.implementationBrief
-            }))
-          }
-        );
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                bundleId: args.bundleId,
-                findingsEnriched: args.findings.length,
-                message: `Bundle enriched successfully (${args.findings.length} findings). Call yapout_sync_bundle_to_linear to create the Linear project.`
-              }, null, 2)
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Error saving bundle enrichment: ${err.message}` }],
-          isError: true
-        };
-      }
-    })
-  );
-}
-
-// src/mcp/tools/block-enrichment.ts
-import { z as z23 } from "zod";
-function registerBlockEnrichmentTool(server, ctx) {
-  server.tool(
-    "yapout_block_enrichment",
-    `Refuse to enrich a finding because the user has not provided enough specifics for an autonomous agent to complete the work end-to-end.
-
-Use this when the finding lacks any of: target file/component, intended behavior, scope boundaries, or success criteria. Do NOT produce a half-baked enrichment "for review" \u2014 block instead. The bar for "enriched" is "another agent can ship this with zero further input."
-
-The finding must currently be in "enriching" status (claimed via yapout_get_unenriched_finding).
-
-Transitions: enriching \u2192 needs_input. The user sees the blockerReason and questions in the UI, adds context, and resubmits.`,
-    {
-      findingId: z23.string().describe("The finding ID to block (currently in 'enriching')"),
-      blockerReason: z23.string().describe("One sentence: why this finding cannot be enriched as written. State the missing piece concretely."),
-      blockerQuestions: z23.array(z23.string()).min(1).describe("2-5 specific questions the user must answer before enrichment can succeed. Each must be answerable in a sentence or two.")
-    },
-    withScopeCheck(ctx, "yapout_block_enrichment", async (args) => {
-      try {
-        await ctx.client.mutation(
-          anyApi5.functions.localPipeline.blockLocalEnrichment,
-          {
-            findingId: args.findingId,
-            blockerReason: args.blockerReason,
-            blockerQuestions: args.blockerQuestions
-          }
+        await ctx.client.mutation(
+          anyApi5.functions.localPipeline.blockLocalEnrichment,
+          {
+            findingId: args.findingId,
+            blockerReason: args.blockerReason,
+            blockerQuestions: args.blockerQuestions
+          }
         );
         return {
           content: [
@@ -4060,9 +3747,9 @@ Transitions: enriching \u2192 needs_input. The user sees the blockerReason and q
 
 Same semantics as yapout_block_enrichment but for an entire bundle. Bundle status transitions enriching \u2192 needs_input; child findings revert to draft.`,
     {
-      bundleId: z23.string().describe("The bundle ID to block (currently in 'enriching')"),
-      blockerReason: z23.string().describe("One sentence: why this bundle cannot be enriched."),
-      blockerQuestions: z23.array(z23.string()).min(1).describe("2-5 specific questions the user must answer.")
+      bundleId: z16.string().describe("The bundle ID to block (currently in 'enriching')"),
+      blockerReason: z16.string().describe("One sentence: why this bundle cannot be enriched."),
+      blockerQuestions: z16.array(z16.string()).min(1).describe("2-5 specific questions the user must answer.")
     },
     async (args) => {
       try {
@@ -5163,143 +4850,6 @@ function registerProjectTools(server, ctx) {
   registerTool(server, ctx, listProjectsTool);
 }
 
-// src/mcp/tools/bundles-crud.ts
-var getBundleTool = defineTool({
-  name: "yapout_get_bundle",
-  description: `Fetch a bundle by id, including its child findings array. Use this when you need full bundle context \u2014 title, description, enrichment data, claim state, child findings \u2014 not just the work-queue summary.`,
-  inputSchema: { bundleId: z.string() },
-  handler: async (ctx, args) => {
-    const bundle = await ctx.client.query(
-      anyApi5.functions.bundles.getBundle,
-      args
-    );
-    if (!bundle) {
-      return {
-        content: [{ type: "text", text: "Bundle not found." }],
-        isError: true
-      };
-    }
-    return {
-      content: [
-        { type: "text", text: JSON.stringify(bundle, null, 2) }
-      ]
-    };
-  }
-});
-var listBundlesTool = defineTool({
-  name: "yapout_list_bundles",
-  description: `List every bundle in the current project. Returns the bundle records (title, status, claim, archive metadata). For per-bundle child findings, follow up with yapout_get_bundle.`,
-  inputSchema: {},
-  handler: async (ctx) => {
-    if (!ctx.projectId) {
-      return {
-        content: [{ type: "text", text: "No project linked." }],
-        isError: true
-      };
-    }
-    const bundles = await ctx.client.query(
-      anyApi5.functions.bundles.getProjectBundles,
-      { projectId: ctx.projectId }
-    );
-    return {
-      content: [
-        { type: "text", text: JSON.stringify(bundles, null, 2) }
-      ]
-    };
-  }
-});
-var updateBundleTool = defineTool({
-  name: "yapout_update_bundle",
-  description: `Patch a bundle's editable content fields: title, description. Pass only the fields you want to change. Status / claim / archive go through dedicated tools.`,
-  inputSchema: {
-    bundleId: z.string(),
-    title: z.string().optional(),
-    description: z.string().optional()
-  },
-  handler: async (ctx, args) => {
-    await ctx.client.mutation(
-      anyApi5.functions.bundles.updateBundle,
-      args
-    );
-    return {
-      content: [{ type: "text", text: "Bundle updated." }]
-    };
-  }
-});
-var archiveBundleTool = defineTool({
-  name: "yapout_archive_bundle",
-  description: `Archive a bundle. Children are detached (their bundleId cleared) so they can be re-bundled or shipped solo. Use yapout_restore_bundle to bring it back.`,
-  inputSchema: { bundleId: z.string() },
-  handler: async (ctx, args) => {
-    await ctx.client.mutation(
-      anyApi5.functions.bundles.archiveBundle,
-      args
-    );
-    return {
-      content: [{ type: "text", text: "Bundle archived." }]
-    };
-  }
-});
-var restoreBundleTool = defineTool({
-  name: "yapout_restore_bundle",
-  description: `Restore an archived bundle. Defaults to draft; pass to: "ready" to bring it straight back to the open queue.`,
-  inputSchema: {
-    bundleId: z.string(),
-    to: z.enum(["draft", "ready"]).optional()
-  },
-  handler: async (ctx, args) => {
-    await ctx.client.mutation(
-      anyApi5.functions.bundles.restoreBundle,
-      args
-    );
-    return {
-      content: [{ type: "text", text: "Bundle restored." }]
-    };
-  }
-});
-var addFindingToBundleTool = defineTool({
-  name: "yapout_add_finding_to_bundle",
-  description: `Attach an existing finding to a bundle. The finding's bundleId is set; its status is left alone (use yapout_set_finding_status separately if you want to align statuses).`,
-  inputSchema: {
-    findingId: z.string(),
-    bundleId: z.string()
-  },
-  handler: async (ctx, args) => {
-    await ctx.client.mutation(
-      anyApi5.functions.findings.addToBundle,
-      args
-    );
-    return {
-      content: [{ type: "text", text: "Finding added to bundle." }]
-    };
-  }
-});
-var removeFindingFromBundleTool = defineTool({
-  name: "yapout_remove_finding_from_bundle",
-  description: `Detach a finding from its current bundle. The finding stays in the project; only its bundleId is cleared.`,
-  inputSchema: { findingId: z.string() },
-  handler: async (ctx, args) => {
-    await ctx.client.mutation(
-      anyApi5.functions.findings.removeFromBundle,
-      args
-    );
-    return {
-      content: [
-        { type: "text", text: "Finding removed from bundle." }
-      ]
-    };
-  }
-});
-function registerBundleCrudTools(server, ctx) {
-  registerTool(server, ctx, getBundleTool);
-  registerTool(server, ctx, listBundlesTool);
-  registerTool(server, ctx, updateBundleTool);
-  registerTool(server, ctx, archiveBundleTool);
-  registerTool(server, ctx, restoreBundleTool);
-  registerTool(server, ctx, addFindingToBundleTool);
-  registerTool(server, ctx, removeFindingFromBundleTool);
-}
-
 // src/mcp/tools/insights.ts
 var listInsightsTool = defineTool({
   name: "yapout_list_insights",
@@ -5471,32 +5021,26 @@ async function startMcpServer() {
   };
   const server = new McpServer({
     name: "yapout",
-    version: "0.15.2"
+    version: "0.18.0"
   });
   registerInitTool(server, ctx);
   registerCompactTool(server, ctx);
   registerUpdateContextTool(server, ctx);
-  registerQueueTool(server, ctx);
+  registerDevLoopTools(server, ctx);
   registerGetBriefTool(server, ctx);
   registerClaimTool(server, ctx);
   registerEventTool(server, ctx);
   registerShipTool(server, ctx);
   registerCheckTool(server, ctx);
-  registerBundleTool(server, ctx);
   registerGetUnenrichedFindingsTool(server, ctx);
   registerGetExistingFindingsTool(server, ctx);
   registerSaveEnrichmentTool(server, ctx);
   registerSyncToLinearTool(server, ctx);
-  registerSubmitYapSessionTool(server, ctx);
-  registerStartYapTool(server, ctx);
-  registerExtractFromYapTool(server, ctx);
   registerDecomposeFindingTool(server, ctx);
   registerMarkDuplicateTool(server, ctx);
   registerGetLinearProjectsTool(server, ctx);
   registerStartEnrichmentTool(server, ctx);
   registerEnrichNextTool(server, ctx);
-  registerEnrichBundleTool(server, ctx);
-  registerSaveBundleEnrichmentTool(server, ctx);
   registerBlockEnrichmentTool(server, ctx);
   registerSessionTools(server, ctx);
   registerCodebaseTools(server, ctx);
@@ -5506,7 +5050,6 @@ async function startMcpServer() {
   registerFindingReadTools(server, ctx);
   registerFindingWriteTools(server, ctx);
   registerProjectTools(server, ctx);
-  registerBundleCrudTools(server, ctx);
   registerInsightTools(server, ctx);
   registerPipelineRunTools(server, ctx);
   const transport = new StdioServerTransport();
@@ -5520,108 +5063,133 @@ var mcpServerCommand = new Command8("mcp-server").description("Start the MCP ser
 
 // src/commands/queue.ts
 import { Command as Command9 } from "commander";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 import chalk9 from "chalk";
-var queueCommand = new Command9("queue").description("Show pipeline state \u2014 what's ready, blocked, and pending").action(async () => {
+var queueCommand = new Command9("queue").description("Show Directives for this repo's Resource").option("--all", "Include drafted/vetted/done/cancelled directives", false).option("--limit <n>", "Max directives to fetch (default 100)", "100").action(async (options) => {
   const creds = requireAuth();
-  const cwd = resolve6(process.cwd());
-  const mapping = getProjectMapping(cwd);
-  if (!mapping) {
+  const cwd = resolve7(process.cwd());
+  const repoRoot = resolveRepoRoot(cwd);
+  const resourceCfg = readResourceConfig(repoRoot);
+  if (!resourceCfg) {
     console.error(
-      chalk9.red("No project linked.") + " Run " + chalk9.cyan("yapout link") + " in a repo."
+      chalk9.red("No `.yapout/config.json` found.") + " Run " + chalk9.cyan("yapout init") + " in this repo first."
     );
     process.exit(1);
   }
+  const limit = Math.max(1, parseInt(options.limit, 10) || 100);
   const client = createConvexClient(creds.token);
-  const { anyApi: anyApi6 } = await import("convex/server");
-  const [queueData, unenriched, pending] = await Promise.all([
-    client.query(anyApi6.functions.tickets.getLocalQueuedTickets, {
-      projectId: mapping.projectId
-    }),
-    client.query(anyApi6.functions.localPipeline.getUnenrichedTickets, {
-      projectId: mapping.projectId
-    }),
-    client.query(anyApi6.functions.localPipeline.getPendingSources, {
-      projectId: mapping.projectId
-    })
-  ]);
-  console.log();
-  if (queueData?.ready && queueData.ready.length > 0) {
-    console.log(chalk9.bold("Ready to implement:"));
-    for (const t of queueData.ready) {
-      const ref = t.linearTicketId ?? t.ticketId;
-      const prio = colorPriority(t.priority);
-      console.log(
-        `  ${chalk9.bold(ref)}  ${t.title.slice(0, 45).padEnd(45)}  ${prio}  ${chalk9.dim(t.type)}`
-      );
-    }
-    console.log();
+  let result;
+  try {
+    result = await client.query(
+      anyApi.functions.dashboardNewModel.listDirectivesForResource,
+      {
+        resourceId: resourceCfg.resourceId,
+        limit
+      }
+    );
+  } catch (err) {
+    console.error(
+      chalk9.red("Failed to load directive queue."),
+      err.message
+    );
+    process.exit(1);
   }
-  if (queueData?.blocked && queueData.blocked.length > 0) {
-    console.log(chalk9.bold("Blocked:"));
-    for (const t of queueData.blocked) {
-      console.log(
-        `  ${chalk9.bold(t.ticketId.slice(-6))}  ${t.title.slice(0, 45)}  ${chalk9.red("blocked by " + t.blockedBy.map((id) => id.slice(-6)).join(", "))}`
-      );
-    }
-    console.log();
+  if (!result) {
+    console.error(
+      chalk9.red("No access.") + " The Resource bound in `.yapout/config.json` is unreachable. Check `yapout status` and re-run `yapout init` if needed."
+    );
+    process.exit(1);
   }
-  if (unenriched && unenriched.length > 0) {
-    console.log(chalk9.bold("Needs enrichment:"));
-    for (const t of unenriched) {
-      const ref = t.ticketId;
-      console.log(
-        `  ${chalk9.bold(ref.slice(-6))}  ${t.title.slice(0, 45).padEnd(45)}  ${chalk9.dim(t.priority)}`
-      );
-    }
+  console.log();
+  console.log(
+    chalk9.bold(result.resource.remoteUrl ?? result.resource.canonicalId) + chalk9.dim(`  (resource ${result.resource._id})`)
+  );
+  const interesting = options.all ? result.directives : result.directives.filter(
+    (d) => ["queued", "in_progress", "review"].includes(d.status)
+  );
+  if (interesting.length === 0) {
+    const filter = options.all ? "" : " (use --all to include drafted/done)";
+    console.log(chalk9.dim(`No directives.${filter}`));
     console.log();
+    return;
   }
-  if (pending && pending.length > 0) {
-    console.log(chalk9.bold("Pending extraction:"));
-    for (const t of pending) {
-      const ago = formatAgo(Date.now() - t.createdAt);
+  const buckets = {};
+  for (const d of interesting) {
+    (buckets[d.status] ??= []).push(d);
+  }
+  const order = options.all ? [
+    "queued",
+    "in_progress",
+    "review",
+    "vetted",
+    "drafted",
+    "deployed",
+    "done",
+    "cancelled"
+  ] : ["queued", "in_progress", "review"];
+  for (const status of order) {
+    const rows = buckets[status];
+    if (!rows || rows.length === 0) continue;
+    console.log();
+    console.log(
+      chalk9.bold(labelForStatus2(status)) + chalk9.dim(`  (${rows.length})`)
+    );
+    for (const d of rows) {
+      const idTail = d._id.slice(-6);
+      const title = truncate2(d.title, 55).padEnd(55);
+      const verb = d.actionVerb ? chalk9.dim(d.actionVerb) : "";
+      const exec2 = d.latestExecution ? chalk9.dim(
+        `[exec ${d.latestExecution._id.slice(-6)} ${d.latestExecution.devStatus}]`
+      ) : "";
       console.log(
-        `  "${t.meetingTitle ?? "Untitled"}" ${chalk9.dim(`(uploaded ${ago})`)}`
+        `  ${chalk9.bold(idTail)}  ${title}  ${verb}  ${exec2}`.trimEnd()
       );
+      if (d.parentRequestTitles.length > 0) {
+        const parentSummary = d.parentRequestTitles.map((t) => truncate2(t, 40)).join(" | ");
+        console.log(
+          chalk9.dim(
+            `    \u21B3 ${parentSummary}` + (d.parentRequestCount > d.parentRequestTitles.length ? ` (+${d.parentRequestCount - d.parentRequestTitles.length} more)` : "")
+          )
+        );
+      }
     }
-    console.log();
-  }
-  if ((!queueData?.ready || queueData.ready.length === 0) && (!unenriched || unenriched.length === 0) && (!pending || pending.length === 0)) {
-    console.log(chalk9.dim("Queue is empty. Upload a transcript to get started."));
-    console.log();
   }
+  console.log();
 });
-function colorPriority(p) {
-  switch (p) {
-    case "urgent":
-      return chalk9.red(p);
-    case "high":
-      return chalk9.yellow(p);
-    case "medium":
-      return chalk9.white(p);
-    case "low":
-      return chalk9.dim(p);
+function labelForStatus2(status) {
+  switch (status) {
+    case "queued":
+      return "Ready to pick";
+    case "in_progress":
+      return "In progress";
+    case "review":
+      return "In review";
+    case "vetted":
+      return "Vetted (PM-side)";
+    case "drafted":
+      return "Drafted (PM-side)";
+    case "deployed":
+      return "Deployed";
+    case "done":
+      return "Done";
+    case "cancelled":
+      return "Cancelled";
     default:
-      return p;
+      return status;
   }
 }
-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`;
+function truncate2(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
 }
 
 // src/commands/recap.ts
 import { Command as Command10 } from "commander";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 import chalk10 from "chalk";
 var recapCommand = new Command10("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 = resolve7(process.cwd());
+  const cwd = resolve8(process.cwd());
   const mapping = getProjectMapping(cwd);
   if (!mapping) {
     console.error(
@@ -5675,44 +5243,13 @@ var recapCommand = new Command10("recap").description("Show a summary of recent
   console.log();
 });
 
-// src/commands/yap.ts
+// src/commands/agent.ts
 import { Command as Command11 } from "commander";
 import chalk11 from "chalk";
-var yapCommand = new Command11("yap").description(
-  "Start a yap session \u2014 brainstorm with an AI that knows your codebase"
-).action(() => {
-  console.log(chalk11.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(
-    chalk11.green(`  "Let's have a yap session about [topic]"`)
-  );
-  console.log(
-    chalk11.green(
-      '  "I want to brainstorm [idea] \u2014 be a skeptical QA engineer"'
-    )
-  );
-  console.log();
-  console.log(chalk11.dim("Personas: tech lead, qa engineer, product owner, end user, or custom"));
-  console.log(
-    chalk11.dim(
-      "Claude will call yapout_start_yap to get instructions and yapout_submit_yap_session when done."
-    )
-  );
-});
-
-// src/commands/agent.ts
-import { Command as Command12 } from "commander";
-import chalk12 from "chalk";
 import { input, confirm } from "@inquirer/prompts";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 async function resolveProjectId() {
-  const cwd = resolve8(process.cwd());
+  const cwd = resolve9(process.cwd());
   const mapping = getProjectMapping(cwd);
   if (!mapping) {
     throw new Error(
@@ -5724,7 +5261,7 @@ async function resolveProjectId() {
     projectName: mapping.projectName
   };
 }
-var agentCreate = new Command12("create").description("Create a new agent identity with a fresh token").option("--name <name>", "Display name (e.g. 'frontend-implementer')").option("--role <description>", "One-line role description").option(
+var agentCreate = new Command11("create").description("Create a new agent identity with a fresh token").option("--name <name>", "Display name (e.g. 'frontend-implementer')").option("--role <description>", "One-line role description").option(
   "--scopes <scopes>",
   "Comma-separated list of MCP tool names, or '*' for full access",
   "*"
@@ -5745,23 +5282,23 @@ var agentCreate = new Command12("create").description("Create a new agent identi
       label: opts.label
     }
   );
-  console.log(chalk12.green(`Agent "${name}" created in ${projectName}.`));
+  console.log(chalk11.green(`Agent "${name}" created in ${projectName}.`));
   console.log("");
-  console.log(chalk12.dim("agentUserId:"), result.agentUserId);
-  console.log(chalk12.dim("tokenId:    "), result.tokenId);
-  console.log(chalk12.dim("token:      "), chalk12.yellow(result.rawToken));
+  console.log(chalk11.dim("agentUserId:"), result.agentUserId);
+  console.log(chalk11.dim("tokenId:    "), result.tokenId);
+  console.log(chalk11.dim("token:      "), chalk11.yellow(result.rawToken));
   console.log("");
   console.log(
-    chalk12.bold("Store this token now."),
+    chalk11.bold("Store this token now."),
     "Yapout keeps only the SHA-256 hash; this is the only time it's shown."
   );
   console.log(
     "Pass to the harness via the",
-    chalk12.cyan("YAPOUT_AGENT_TOKEN"),
+    chalk11.cyan("YAPOUT_AGENT_TOKEN"),
     "env var."
   );
 });
-var agentList = new Command12("list").description("List agents in the current project").action(async () => {
+var agentList = new Command11("list").description("List agents in the current project").action(async () => {
   const creds = requireAuth();
   const { projectId, projectName } = await resolveProjectId();
   const client = createConvexClient(creds.token);
@@ -5770,26 +5307,26 @@ var agentList = new Command12("list").description("List agents in the current pr
     { projectId }
   );
   if (rows.length === 0) {
-    console.log(chalk12.dim(`No agents in ${projectName}.`));
+    console.log(chalk11.dim(`No agents in ${projectName}.`));
     return;
   }
-  console.log(chalk12.bold(`Agents in ${projectName}:`));
+  console.log(chalk11.bold(`Agents in ${projectName}:`));
   for (const a of rows) {
-    const role = a.roleDescription ? chalk12.dim(`  \u2014 ${a.roleDescription}`) : "";
-    console.log(`  ${chalk12.cyan(a.displayName)}${role}`);
-    console.log(chalk12.dim(`    id: ${a._id}`));
+    const role = a.roleDescription ? chalk11.dim(`  \u2014 ${a.roleDescription}`) : "";
+    console.log(`  ${chalk11.cyan(a.displayName)}${role}`);
+    console.log(chalk11.dim(`    id: ${a._id}`));
     console.log(
-      chalk12.dim(`    created: ${new Date(a.createdAt).toLocaleString()}`)
+      chalk11.dim(`    created: ${new Date(a.createdAt).toLocaleString()}`)
     );
   }
 });
-var agentRevoke = new Command12("revoke").description("Revoke an agent token by tokenId").argument("<tokenId>", "Token id (from `yapout agent list` or creation output)").action(async (tokenId) => {
+var agentRevoke = new Command11("revoke").description("Revoke an agent token by tokenId").argument("<tokenId>", "Token id (from `yapout agent list` or creation output)").action(async (tokenId) => {
   const creds = requireAuth();
   const client = createConvexClient(creds.token);
   await client.mutation(anyApi.functions.agents.revokeToken, { tokenId });
-  console.log(chalk12.green("Token revoked."));
+  console.log(chalk11.green("Token revoked."));
 });
-var agentRotate = new Command12("rotate").description("Issue a new token and revoke the old one (for an existing agent)").argument("<tokenId>", "Old token id to rotate").option(
+var agentRotate = new Command11("rotate").description("Issue a new token and revoke the old one (for an existing agent)").argument("<tokenId>", "Old token id to rotate").option(
   "--scopes <scopes>",
   "Comma-separated MCP tool names or '*'. Defaults to the old token's scopes."
 ).option("--label <label>", "New token label").action(async (oldTokenId, opts) => {
@@ -5800,7 +5337,7 @@ var agentRotate = new Command12("rotate").description("Issue a new token and rev
     { tokenId: oldTokenId }
   );
   if (!oldToken) {
-    console.error(chalk12.red("Old token not found or you don't have access."));
+    console.error(chalk11.red("Old token not found or you don't have access."));
     process.exit(1);
   }
   const scopes = opts.scopes ? opts.scopes === "*" ? ["*"] : opts.scopes.split(",").map((s) => s.trim()).filter(Boolean) : oldToken.scopes;
@@ -5826,21 +5363,21 @@ var agentRotate = new Command12("rotate").description("Issue a new token and rev
     tokenId: oldTokenId
   });
   console.log(
-    chalk12.green(`Token rotated for "${oldToken.agentDisplayName ?? oldToken.agentUserId}".`)
+    chalk11.green(`Token rotated for "${oldToken.agentDisplayName ?? oldToken.agentUserId}".`)
   );
-  console.log(chalk12.dim("new tokenId:"), created.tokenId);
-  console.log(chalk12.dim("token:      "), chalk12.yellow(created.rawToken));
+  console.log(chalk11.dim("new tokenId:"), created.tokenId);
+  console.log(chalk11.dim("token:      "), chalk11.yellow(created.rawToken));
   console.log("");
-  console.log(chalk12.bold("Store this token now."), "Old token revoked.");
+  console.log(chalk11.bold("Store this token now."), "Old token revoked.");
 });
-var agentCommand = new Command12("agent").description("Manage agent identities and tokens").addCommand(agentCreate).addCommand(agentList).addCommand(agentRevoke).addCommand(agentRotate);
+var agentCommand = new Command11("agent").description("Manage agent identities and tokens").addCommand(agentCreate).addCommand(agentList).addCommand(agentRevoke).addCommand(agentRotate);
 
 // src/commands/webhook.ts
-import { Command as Command13 } from "commander";
-import chalk13 from "chalk";
+import { Command as Command12 } from "commander";
+import chalk12 from "chalk";
 import { input as input2, checkbox } from "@inquirer/prompts";
 import { randomBytes } from "crypto";
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 var SUPPORTED_EVENTS = [
   "finding.status_changed",
   "finding.created",
@@ -5852,7 +5389,7 @@ var SUPPORTED_EVENTS = [
   "settings.changed"
 ];
 async function resolveProjectId2() {
-  const cwd = resolve9(process.cwd());
+  const cwd = resolve10(process.cwd());
   const mapping = getProjectMapping(cwd);
   if (!mapping) {
     throw new Error(
@@ -5861,7 +5398,7 @@ async function resolveProjectId2() {
   }
   return { projectId: mapping.projectId, projectName: mapping.projectName };
 }
-var webhookList = new Command13("list").description("List outbound webhooks for the current project").action(async () => {
+var webhookList = new Command12("list").description("List outbound webhooks for the current project").action(async () => {
   const creds = requireAuth();
   const { projectId, projectName } = await resolveProjectId2();
   const client = createConvexClient(creds.token);
@@ -5870,19 +5407,19 @@ var webhookList = new Command13("list").description("List outbound webhooks for
     { projectId }
   );
   if (rows.length === 0) {
-    console.log(chalk13.dim(`No webhooks for ${projectName}.`));
+    console.log(chalk12.dim(`No webhooks for ${projectName}.`));
     return;
   }
-  console.log(chalk13.bold(`Webhooks for ${projectName}:`));
+  console.log(chalk12.bold(`Webhooks for ${projectName}:`));
   for (const w of rows) {
-    const status = w.active ? chalk13.green("active") : chalk13.red(`disabled (${w.consecutiveFailures} failures)`);
-    console.log(`  ${chalk13.cyan(w.label ?? w.url)} \u2014 ${status}`);
-    console.log(chalk13.dim(`    id: ${w._id}`));
-    console.log(chalk13.dim(`    url: ${w.url}`));
-    console.log(chalk13.dim(`    events: ${w.events.join(", ")}`));
+    const status = w.active ? chalk12.green("active") : chalk12.red(`disabled (${w.consecutiveFailures} failures)`);
+    console.log(`  ${chalk12.cyan(w.label ?? w.url)} \u2014 ${status}`);
+    console.log(chalk12.dim(`    id: ${w._id}`));
+    console.log(chalk12.dim(`    url: ${w.url}`));
+    console.log(chalk12.dim(`    events: ${w.events.join(", ")}`));
   }
 });
-var webhookCreate = new Command13("create").description("Create an outbound webhook subscription").option("--url <url>", "Webhook target URL").option("--label <label>", "Human-readable label").option(
+var webhookCreate = new Command12("create").description("Create an outbound webhook subscription").option("--url <url>", "Webhook target URL").option("--label <label>", "Human-readable label").option(
   "--events <list>",
   `Comma-separated event names. Available: ${SUPPORTED_EVENTS.join(", ")}`
 ).option(
@@ -5909,23 +5446,23 @@ var webhookCreate = new Command13("create").description("Create an outbound webh
     anyApi.functions.webhooks.createWebhook,
     { projectId, url, label, events, secret }
   );
-  console.log(chalk13.green(`Webhook created in ${projectName}.`));
-  console.log(chalk13.dim("webhookId:"), result.webhookId);
+  console.log(chalk12.green(`Webhook created in ${projectName}.`));
+  console.log(chalk12.dim("webhookId:"), result.webhookId);
   if (!opts.secret) {
-    console.log(chalk13.dim("secret:   "), chalk13.yellow(secret));
+    console.log(chalk12.dim("secret:   "), chalk12.yellow(secret));
     console.log(
-      chalk13.bold("Store this secret now."),
+      chalk12.bold("Store this secret now."),
       "Yapout keeps only the encrypted form; the receiver needs the plaintext to verify HMAC signatures."
     );
   }
 });
-var webhookDelete = new Command13("delete").description("Delete a webhook subscription").argument("<webhookId>").action(async (webhookId) => {
+var webhookDelete = new Command12("delete").description("Delete a webhook subscription").argument("<webhookId>").action(async (webhookId) => {
   const creds = requireAuth();
   const client = createConvexClient(creds.token);
   await client.mutation(anyApi.functions.webhooks.deleteWebhook, { webhookId });
-  console.log(chalk13.green("Webhook deleted."));
+  console.log(chalk12.green("Webhook deleted."));
 });
-var webhookTest = new Command13("test").description("Inspect recent delivery attempts for a webhook").argument("<webhookId>").option("-n, --limit <n>", "Number of deliveries to show", "20").action(async (webhookId, opts) => {
+var webhookTest = new Command12("test").description("Inspect recent delivery attempts for a webhook").argument("<webhookId>").option("-n, --limit <n>", "Number of deliveries to show", "20").action(async (webhookId, opts) => {
   const creds = requireAuth();
   const client = createConvexClient(creds.token);
   const limit = parseInt(opts.limit, 10);
@@ -5934,28 +5471,28 @@ var webhookTest = new Command13("test").description("Inspect recent delivery att
     { webhookId, limit }
   );
   if (rows.length === 0) {
-    console.log(chalk13.dim("No deliveries yet."));
+    console.log(chalk12.dim("No deliveries yet."));
     return;
   }
   for (const d of rows) {
-    const statusLabel = d.status === "success" ? chalk13.green(d.status) : d.status === "failed" ? chalk13.red(d.status) : chalk13.yellow(d.status);
+    const statusLabel = d.status === "success" ? chalk12.green(d.status) : d.status === "failed" ? chalk12.red(d.status) : chalk12.yellow(d.status);
     const time = new Date(d.createdAt).toLocaleString();
     const http3 = d.httpStatus !== void 0 ? ` HTTP ${d.httpStatus}` : "";
-    const err = d.error ? chalk13.dim(` (${d.error})`) : "";
+    const err = d.error ? chalk12.dim(` (${d.error})`) : "";
     console.log(
-      `  ${time} \u2014 ${statusLabel} attempt ${d.attempt}${http3} \u2014 ${chalk13.cyan(d.event)}${err}`
+      `  ${time} \u2014 ${statusLabel} attempt ${d.attempt}${http3} \u2014 ${chalk12.cyan(d.event)}${err}`
     );
   }
 });
-var webhookCommand = new Command13("webhook").description("Manage outbound webhook subscriptions").addCommand(webhookList).addCommand(webhookCreate).addCommand(webhookDelete).addCommand(webhookTest);
+var webhookCommand = new Command12("webhook").description("Manage outbound webhook subscriptions").addCommand(webhookList).addCommand(webhookCreate).addCommand(webhookDelete).addCommand(webhookTest);
 
 // src/commands/inbound.ts
-import { Command as Command14 } from "commander";
-import chalk14 from "chalk";
+import { Command as Command13 } from "commander";
+import chalk13 from "chalk";
 import { input as input3 } from "@inquirer/prompts";
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 async function resolveProjectId3() {
-  const cwd = resolve10(process.cwd());
+  const cwd = resolve11(process.cwd());
   const mapping = getProjectMapping(cwd);
   if (!mapping) {
     throw new Error(
@@ -5964,7 +5501,7 @@ async function resolveProjectId3() {
   }
   return { projectId: mapping.projectId, projectName: mapping.projectName };
 }
-var inboundList = new Command14("list").description("List inbound webhook tokens for the current project").action(async () => {
+var inboundList = new Command13("list").description("List inbound webhook tokens for the current project").action(async () => {
   const creds = requireAuth();
   const { projectId, projectName } = await resolveProjectId3();
   const client = createConvexClient(creds.token);
@@ -5973,20 +5510,20 @@ var inboundList = new Command14("list").description("List inbound webhook tokens
     { projectId }
   );
   if (rows.length === 0) {
-    console.log(chalk14.dim(`No inbound webhook tokens for ${projectName}.`));
+    console.log(chalk13.dim(`No inbound webhook tokens for ${projectName}.`));
     return;
   }
-  console.log(chalk14.bold(`Inbound tokens for ${projectName}:`));
+  console.log(chalk13.bold(`Inbound tokens for ${projectName}:`));
   for (const t of rows) {
-    const status = t.revokedAt ? chalk14.red("revoked") : t.lastUsedAt ? chalk14.green(`last used ${new Date(t.lastUsedAt).toLocaleString()}`) : chalk14.dim("unused");
-    console.log(`  ${chalk14.cyan(t.label)} \u2014 ${status}`);
-    console.log(chalk14.dim(`    id: ${t._id}`));
+    const status = t.revokedAt ? chalk13.red("revoked") : t.lastUsedAt ? chalk13.green(`last used ${new Date(t.lastUsedAt).toLocaleString()}`) : chalk13.dim("unused");
+    console.log(`  ${chalk13.cyan(t.label)} \u2014 ${status}`);
+    console.log(chalk13.dim(`    id: ${t._id}`));
     console.log(
-      chalk14.dim(`    created: ${new Date(t.createdAt).toLocaleString()}`)
+      chalk13.dim(`    created: ${new Date(t.createdAt).toLocaleString()}`)
     );
   }
 });
-var inboundCreate = new Command14("create").description("Issue a new inbound webhook token").option("--label <label>", "Human-readable label").action(async (opts) => {
+var inboundCreate = new Command13("create").description("Issue a new inbound webhook token").option("--label <label>", "Human-readable label").action(async (opts) => {
   const creds = requireAuth();
   const { projectId, projectName } = await resolveProjectId3();
   const client = createConvexClient(creds.token);
@@ -5999,15 +5536,15 @@ var inboundCreate = new Command14("create").description("Issue a new inbound web
     const cloudUrl = getConvexUrl();
     return cloudUrl.replace(/\.convex\.cloud(\/.*)?$/, ".convex.site");
   })();
-  console.log(chalk14.green(`Inbound token created in ${projectName}.`));
-  console.log(chalk14.dim("tokenId:"), result.tokenId);
-  console.log(chalk14.dim("token:  "), chalk14.yellow(result.rawToken));
+  console.log(chalk13.green(`Inbound token created in ${projectName}.`));
+  console.log(chalk13.dim("tokenId:"), result.tokenId);
+  console.log(chalk13.dim("token:  "), chalk13.yellow(result.rawToken));
   console.log("");
-  console.log(chalk14.bold("Store this token now."), "Yapout keeps only the SHA-256 hash.");
+  console.log(chalk13.bold("Store this token now."), "Yapout keeps only the SHA-256 hash.");
   console.log("");
   console.log("Usage:");
   console.log(
-    `  ${chalk14.cyan("curl")} -X POST ${convexSiteUrl}/api/inbound/${projectId} \\`
+    `  ${chalk13.cyan("curl")} -X POST ${convexSiteUrl}/api/inbound/${projectId} \\`
   );
   console.log(`    -H "Authorization: Bearer ${result.rawToken}" \\`);
   console.log(`    -H "Content-Type: application/json" \\`);
@@ -6015,22 +5552,22 @@ var inboundCreate = new Command14("create").description("Issue a new inbound web
     `    -d '{ "content": "<raw text>", "sourceLabel": "${label}" }'`
   );
 });
-var inboundRevoke = new Command14("revoke").description("Revoke an inbound webhook token").argument("<tokenId>").action(async (tokenId) => {
+var inboundRevoke = new Command13("revoke").description("Revoke an inbound webhook token").argument("<tokenId>").action(async (tokenId) => {
   const creds = requireAuth();
   const client = createConvexClient(creds.token);
   await client.mutation(anyApi.functions.inboundTokens.revokeInboundToken, {
     tokenId
   });
-  console.log(chalk14.green("Inbound token revoked."));
+  console.log(chalk13.green("Inbound token revoked."));
 });
-var inboundCommand = new Command14("inbound").description("Manage inbound webhook tokens (long-tail capture sources)").addCommand(inboundList).addCommand(inboundCreate).addCommand(inboundRevoke);
+var inboundCommand = new Command13("inbound").description("Manage inbound webhook tokens (long-tail capture sources)").addCommand(inboundList).addCommand(inboundCreate).addCommand(inboundRevoke);
 
 // src/commands/pillar.ts
-import { Command as Command15 } from "commander";
-import chalk15 from "chalk";
+import { Command as Command14 } from "commander";
+import chalk14 from "chalk";
 import { input as input4, select as select2 } from "@inquirer/prompts";
 import { randomBytes as randomBytes2 } from "crypto";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 var PILLARS = [
   "extraction",
   "enrichment",
@@ -6039,7 +5576,7 @@ var PILLARS = [
 ];
 var MODES = ["cloud-default", "disabled", "external-webhook"];
 async function resolveProjectId4() {
-  const cwd = resolve11(process.cwd());
+  const cwd = resolve12(process.cwd());
   const mapping = getProjectMapping(cwd);
   if (!mapping) {
     throw new Error(
@@ -6051,14 +5588,14 @@ async function resolveProjectId4() {
 function modeBadge(mode) {
   switch (mode) {
     case "cloud-default":
-      return chalk15.dim("cloud");
+      return chalk14.dim("cloud");
     case "disabled":
-      return chalk15.gray("disabled");
+      return chalk14.gray("disabled");
     case "external-webhook":
-      return chalk15.green("webhook");
+      return chalk14.green("webhook");
   }
 }
-var pillarList = new Command15("list").description("Show current modes for all four pillars").action(async () => {
+var pillarList = new Command14("list").description("Show current modes for all four pillars").action(async () => {
   const creds = requireAuth();
   const { projectId, projectName } = await resolveProjectId4();
   const client = createConvexClient(creds.token);
@@ -6066,17 +5603,17 @@ var pillarList = new Command15("list").description("Show current modes for all f
     anyApi.functions.projectConfig.getProjectConfig,
     { projectId }
   );
-  console.log(chalk15.bold(`Pillars for ${projectName}:`));
+  console.log(chalk14.bold(`Pillars for ${projectName}:`));
   for (const p of PILLARS) {
     const setting = config?.pillars?.[p] ?? { mode: "cloud-default" };
-    const url = setting.mode === "external-webhook" && setting.webhookUrl ? chalk15.dim(` \u2192 ${setting.webhookUrl}`) : "";
+    const url = setting.mode === "external-webhook" && setting.webhookUrl ? chalk14.dim(` \u2192 ${setting.webhookUrl}`) : "";
     console.log(`  ${p.padEnd(15)}  ${modeBadge(setting.mode)}${url}`);
   }
 });
-var pillarSet = new Command15("set").description("Set a pillar's mode (interactive when setting external-webhook)").argument("<pillar>", "extraction | enrichment | intelligence | implementation").argument("[mode]", "cloud-default | disabled | external-webhook").option("--url <url>", "Webhook URL (for external-webhook mode)").option("--reason <reason>", "Optional reason captured in the audit log").action(
+var pillarSet = new Command14("set").description("Set a pillar's mode (interactive when setting external-webhook)").argument("<pillar>", "extraction | enrichment | intelligence | implementation").argument("[mode]", "cloud-default | disabled | external-webhook").option("--url <url>", "Webhook URL (for external-webhook mode)").option("--reason <reason>", "Optional reason captured in the audit log").action(
   async (pillar, mode, opts) => {
     if (!PILLARS.includes(pillar)) {
-      console.error(chalk15.red(`Unknown pillar "${pillar}".`));
+      console.error(chalk14.red(`Unknown pillar "${pillar}".`));
       console.error(`  Choices: ${PILLARS.join(", ")}`);
       process.exit(1);
     }
@@ -6091,7 +5628,7 @@ var pillarSet = new Command15("set").description("Set a pillar's mode (interacti
       });
     }
     if (!MODES.includes(chosenMode)) {
-      console.error(chalk15.red(`Invalid mode "${chosenMode}".`));
+      console.error(chalk14.red(`Invalid mode "${chosenMode}".`));
       console.error(`  Choices: ${MODES.join(", ")}`);
       process.exit(1);
     }
@@ -6099,7 +5636,7 @@ var pillarSet = new Command15("set").description("Set a pillar's mode (interacti
     if (chosenMode === "external-webhook") {
       const url = opts.url ?? await input4({ message: "Webhook URL:" });
       if (!url.trim()) {
-        console.error(chalk15.red("Webhook URL required."));
+        console.error(chalk14.red("Webhook URL required."));
         process.exit(1);
       }
       const secret = randomBytes2(32).toString("hex");
@@ -6115,13 +5652,13 @@ var pillarSet = new Command15("set").description("Set a pillar's mode (interacti
         }
       );
       console.log(
-        chalk15.green(`Set ${pillar} \u2192 external-webhook in ${projectName}.`)
+        chalk14.green(`Set ${pillar} \u2192 external-webhook in ${projectName}.`)
       );
-      console.log(chalk15.dim("URL:   "), setting.webhookUrl);
-      console.log(chalk15.dim("secret:"), chalk15.yellow(secret));
+      console.log(chalk14.dim("URL:   "), setting.webhookUrl);
+      console.log(chalk14.dim("secret:"), chalk14.yellow(secret));
       console.log("");
       console.log(
-        chalk15.bold("Store this secret now."),
+        chalk14.bold("Store this secret now."),
         "Yapout encrypts it at rest; this is the only time it's shown. The receiver needs the plaintext to verify HMAC signatures."
       );
       return;
@@ -6136,13 +5673,13 @@ var pillarSet = new Command15("set").description("Set a pillar's mode (interacti
       }
     );
     console.log(
-      chalk15.green(`Set ${pillar} \u2192 ${chosenMode} in ${projectName}.`)
+      chalk14.green(`Set ${pillar} \u2192 ${chosenMode} in ${projectName}.`)
     );
   }
 );
-var pillarTest = new Command15("test").description("Send a test delivery to a pillar's external webhook").argument("<pillar>", "extraction | enrichment | intelligence | implementation").action(async (pillar) => {
+var pillarTest = new Command14("test").description("Send a test delivery to a pillar's external webhook").argument("<pillar>", "extraction | enrichment | intelligence | implementation").action(async (pillar) => {
   if (!PILLARS.includes(pillar)) {
-    console.error(chalk15.red(`Unknown pillar "${pillar}".`));
+    console.error(chalk14.red(`Unknown pillar "${pillar}".`));
     process.exit(1);
   }
   const creds = requireAuth();
@@ -6155,7 +5692,7 @@ var pillarTest = new Command15("test").description("Send a test delivery to a pi
   const setting = config?.pillars?.[pillar];
   if (!setting || setting.mode !== "external-webhook") {
     console.error(
-      chalk15.red(
+      chalk14.red(
         `${pillar} is in "${setting?.mode ?? "cloud-default"}" mode \u2014 set it to external-webhook first via \`yapout pillar set ${pillar} external-webhook\`.`
       )
     );
@@ -6163,11 +5700,11 @@ var pillarTest = new Command15("test").description("Send a test delivery to a pi
   }
   if (!setting.webhookUrl || !setting.webhookSecret) {
     console.error(
-      chalk15.red(`${pillar} is missing webhookUrl or webhookSecret.`)
+      chalk14.red(`${pillar} is missing webhookUrl or webhookSecret.`)
     );
     process.exit(1);
   }
-  console.log(chalk15.dim(`POSTing test payload to ${setting.webhookUrl}...`));
+  console.log(chalk14.dim(`POSTing test payload to ${setting.webhookUrl}...`));
   const result = await client.action(
     anyApi.functions.pillarHooks.testDelivery,
     {
@@ -6177,23 +5714,239 @@ var pillarTest = new Command15("test").description("Send a test delivery to a pi
     }
   );
   if (result.ok) {
-    console.log(chalk15.green(`\u2713 HTTP ${result.httpStatus} \u2014 receiver returned 2xx`));
+    console.log(chalk14.green(`\u2713 HTTP ${result.httpStatus} \u2014 receiver returned 2xx`));
   } else {
-    console.log(chalk15.red(`\u26A0 HTTP ${result.httpStatus ?? "n/a"}`));
-    if (result.error) console.log(chalk15.dim(`  error: ${result.error}`));
+    console.log(chalk14.red(`\u26A0 HTTP ${result.httpStatus ?? "n/a"}`));
+    if (result.error) console.log(chalk14.dim(`  error: ${result.error}`));
   }
   if (result.body) {
-    console.log(chalk15.dim("  body:"));
+    console.log(chalk14.dim("  body:"));
     console.log(
       result.body.split("\n").map((l) => `    ${l}`).join("\n")
     );
   }
 });
-var pillarCommand = new Command15("pillar").description("Manage per-project pillar overrides (extraction / enrichment / intelligence / implementation)").addCommand(pillarList).addCommand(pillarSet).addCommand(pillarTest);
+var pillarCommand = new Command14("pillar").description("Manage per-project pillar overrides (extraction / enrichment / intelligence / implementation)").addCommand(pillarList).addCommand(pillarSet).addCommand(pillarTest);
+
+// src/commands/observe.ts
+import { Command as Command15 } from "commander";
+import { resolve as resolve13 } from "path";
+import chalk15 from "chalk";
+var observeCommand = new Command15("observe").description("File an observation Raw against the active Execution").argument("<observation...>", "Freeform observation text").option(
+  "--severity <level>",
+  "Severity hint: low | normal | high (default: normal)"
+).option(
+  "--area <hint>",
+  "Optional scoping hint for the extraction chain (e.g., 'auth', 'billing')"
+).action(
+  async (words, options) => {
+    const creds = requireAuth();
+    const cwd = resolve13(process.cwd());
+    const resourceCfg = readResourceConfig(cwd);
+    if (!resourceCfg) {
+      console.error(
+        chalk15.red("No `.yapout/config.json` found.") + " Run " + chalk15.cyan("yapout init") + " in this repo first."
+      );
+      process.exit(1);
+    }
+    const active = readActiveExecution(cwd);
+    if (!active) {
+      console.error(
+        chalk15.red("No active Execution.") + " `yapout observe` must run from a worktree where " + chalk15.cyan("yapout pick") + " has been called."
+      );
+      process.exit(1);
+    }
+    const body = words.join(" ").trim();
+    if (!body) {
+      console.error(chalk15.red("Observation body cannot be empty."));
+      process.exit(1);
+    }
+    const severityHint = parseSeverity(options.severity);
+    if (options.severity && !severityHint) {
+      console.error(
+        chalk15.red(
+          `Invalid --severity: ${options.severity}. Allowed: low, normal, high.`
+        )
+      );
+      process.exit(1);
+    }
+    const client = createConvexClient(creds.token);
+    let result;
+    try {
+      result = await client.mutation(
+        anyApi.functions.resourcesCli.createAgentObservationRaw,
+        {
+          executionId: active.executionId,
+          body,
+          ...severityHint ? { severityHint } : {},
+          ...options.area ? { area: options.area } : {}
+        }
+      );
+    } catch (err) {
+      console.error(
+        chalk15.red("Failed to file observation."),
+        err.message
+      );
+      process.exit(1);
+    }
+    console.log(
+      chalk15.green("Filed agent observation. ") + chalk15.dim(
+        `(raw: ${result.rawId}, execution: ${result.executionId})`
+      )
+    );
+    console.log(
+      chalk15.dim(
+        "Extraction will turn this into a Request (or link it to an existing one)."
+      )
+    );
+  }
+);
+function parseSeverity(raw) {
+  if (!raw) return void 0;
+  const v = raw.toLowerCase();
+  if (v === "low" || v === "normal" || v === "high") return v;
+  return void 0;
+}
+
+// src/commands/pick.ts
+import { Command as Command16 } from "commander";
+import { resolve as resolve14 } from "path";
+import chalk16 from "chalk";
+var pickCommand = new Command16("pick").description(
+  "Claim a queued Directive: create worktree + start an Execution"
+).argument("<directive-id>", "Convex `directives._id` to pick").option(
+  "--branch <name>",
+  "Override the branch name (default: directive.branchName or `directive/<short-id>`)"
+).option(
+  "--agent <name>",
+  "Implementer identity tag (default: 'claude')"
+).action(
+  async (directiveId, options) => {
+    const creds = requireAuth();
+    const cwd = resolve14(process.cwd());
+    const repoRoot = resolveRepoRoot(cwd);
+    const resourceCfg = readResourceConfig(repoRoot);
+    if (!resourceCfg) {
+      console.error(
+        chalk16.red("No `.yapout/config.json` found.") + " Run " + chalk16.cyan("yapout init") + " in this repo first."
+      );
+      process.exit(1);
+    }
+    const yapoutCfg = readYapoutConfig(repoRoot);
+    const baseBranch = resourceCfg.defaultBranch ?? (() => {
+      try {
+        return getDefaultBranch(repoRoot);
+      } catch {
+        return "main";
+      }
+    })();
+    const client = createConvexClient(creds.token);
+    const shortId = directiveId.slice(-6);
+    const branchName = options.branch ?? `${yapoutCfg.branch_prefix}/directive-${shortId}`;
+    const worktreePath = getWorktreePath(repoRoot, `directive-${shortId}`);
+    let result;
+    try {
+      result = await client.mutation(
+        anyApi.functions.resourcesCli.createExecutionForDirective,
+        {
+          directiveId,
+          worktreePath,
+          branch: branchName,
+          agent: options.agent ?? "claude"
+        }
+      );
+    } catch (err) {
+      console.error(
+        chalk16.red("Failed to pick Directive."),
+        err.message
+      );
+      process.exit(1);
+    }
+    try {
+      createWorktree(repoRoot, `directive-${shortId}`, branchName, baseBranch);
+    } catch (err) {
+      console.error(
+        chalk16.red("Server-side pick succeeded but worktree creation failed.")
+      );
+      console.error(chalk16.dim(`  ${err.message}`));
+      console.error(
+        chalk16.yellow("Recovery: ") + "the Directive is now `in_progress` and an Execution row exists. Either resolve the worktree issue and re-run with the same id, or flip the Directive back to `queued` from the dashboard."
+      );
+      console.error(chalk16.dim(`  executionId: ${result.executionId}`));
+      process.exit(1);
+    }
+    writeActiveExecution(worktreePath, {
+      executionId: result.executionId,
+      directiveId: result.directiveId,
+      branch: branchName,
+      worktreePath,
+      startedAt: Date.now()
+    });
+    console.log(
+      chalk16.green("Picked ") + chalk16.bold(result.directiveTitle) + chalk16.dim(` (id: ${result.directiveId}).`)
+    );
+    console.log(
+      chalk16.dim("  worktree: ") + chalk16.cyan(worktreePath)
+    );
+    console.log(chalk16.dim("  branch:   ") + chalk16.cyan(branchName));
+    console.log(chalk16.dim("  execution: ") + chalk16.cyan(result.executionId));
+    console.log();
+    console.log(
+      chalk16.dim("Next: ") + "cd into the worktree and start work. Use " + chalk16.cyan("yapout observe") + " to file tangential observations and " + chalk16.cyan("yapout submit") + " when ready for review."
+    );
+  }
+);
+
+// src/commands/submit.ts
+import { Command as Command17 } from "commander";
+import { resolve as resolve15 } from "path";
+import chalk17 from "chalk";
+var submitCommand = new Command17("submit").description(
+  "Mark the active Execution as submitted and move the Directive to review"
+).action(async () => {
+  const creds = requireAuth();
+  const cwd = resolve15(process.cwd());
+  const repoRoot = resolveRepoRoot(cwd);
+  const resourceCfg = readResourceConfig(repoRoot);
+  if (!resourceCfg) {
+    console.error(
+      chalk17.red("No `.yapout/config.json` found.") + " Run " + chalk17.cyan("yapout init") + " in this repo first."
+    );
+    process.exit(1);
+  }
+  const active = readActiveExecution(cwd);
+  if (!active) {
+    console.error(
+      chalk17.red("No active Execution.") + " `yapout submit` must run from a worktree where " + chalk17.cyan("yapout pick") + " has been called."
+    );
+    process.exit(1);
+  }
+  const client = createConvexClient(creds.token);
+  let result;
+  try {
+    result = await client.mutation(
+      anyApi.functions.resourcesCli.submitExecution,
+      { executionId: active.executionId }
+    );
+  } catch (err) {
+    console.error(
+      chalk17.red("Failed to submit Execution."),
+      err.message
+    );
+    process.exit(1);
+  }
+  clearActiveExecution(cwd);
+  console.log(
+    chalk17.green("Submitted Execution. ") + chalk17.dim(`(execution: ${result.executionId})`)
+  );
+  console.log(
+    chalk17.dim("Directive ") + chalk17.cyan(result.directiveId) + chalk17.dim(" is now in `review`.")
+  );
+});
 
 // src/index.ts
-var program = new Command16();
-program.name("yapout").description("yapout \u2014 the PM tool for agents").version("0.15.2");
+var program = new Command18();
+program.name("yapout").description("yapout \u2014 the PM tool for agents").version("0.18.0");
 program.addCommand(loginCommand);
 program.addCommand(logoutCommand);
 program.addCommand(initCommand);
@@ -6203,10 +5956,12 @@ program.addCommand(statusCommand);
 program.addCommand(mcpServerCommand);
 program.addCommand(queueCommand);
 program.addCommand(recapCommand);
-program.addCommand(yapCommand);
 program.addCommand(serveCommand);
 program.addCommand(agentCommand);
 program.addCommand(webhookCommand);
 program.addCommand(inboundCommand);
 program.addCommand(pillarCommand);
+program.addCommand(observeCommand);
+program.addCommand(pickCommand);
+program.addCommand(submitCommand);
 program.parse();