@papi-ai/server 0.6.1 → 0.7.0-alpha.1

package/dist/index.js

@@ -7381,6 +7381,13 @@ ${newParts.join("\n")}` : newParts.join("\n");
       UPDATE strategy_recommendations
       SET status = 'actioned', actioned_cycle = ${cycleNumber}, updated_at = now()
       WHERE id = ${id} AND project_id = ${this.projectId}
+    `;
+      }
+      async dismissRecommendation(id, reason) {
+        await this.sql`
+      UPDATE strategy_recommendations
+      SET status = 'actioned', dismissal_reason = ${reason}, updated_at = now()
+      WHERE id = ${id} AND project_id = ${this.projectId}
     `;
       }
       // -------------------------------------------------------------------------
@@ -8067,7 +8074,48 @@ var init_proxy_adapter = __esm({
       constructor(config2) {
         this.endpoint = config2.endpoint.replace(/\/$/, "");
         this.apiKey = config2.apiKey;
-        this.projectId = config2.projectId;
+        this.projectId = config2.projectId ?? "";
+      }
+      /** Resolved project ID — available after ensureProject() completes. */
+      getProjectId() {
+        return this.projectId;
+      }
+      /**
+       * Ensure the authenticated user has a project. If none exists, auto-creates one.
+       * Returns the project ID (existing or newly created). Idempotent and race-safe.
+       *
+       * Call this before any other adapter method when PAPI_PROJECT_ID is not configured.
+       */
+      async ensureProject(projectName, repoUrl) {
+        const url = `${this.endpoint}/ensure-project`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify({
+            ...projectName ? { projectName } : {},
+            ...repoUrl ? { repoUrl } : {}
+          })
+        });
+        if (!response.ok) {
+          const errorBody = await response.text();
+          let message;
+          try {
+            const parsed = JSON.parse(errorBody);
+            message = parsed.error ?? errorBody;
+          } catch {
+            message = errorBody;
+          }
+          throw new Error(`Auto-provision failed (${response.status}): ${message}`);
+        }
+        const body = await response.json();
+        if (!body.ok && body.error) {
+          throw new Error(`Auto-provision failed: ${body.error}`);
+        }
+        this.projectId = body.projectId;
+        return { projectId: body.projectId, projectName: body.projectName, created: body.created };
       }
       /**
        * Send an adapter method call to the proxy Edge Function.
@@ -8097,6 +8145,20 @@ var init_proxy_adapter = __esm({
           } catch {
             message = errorBody;
           }
+          if (response.status === 401) {
+            throw new Error(
+              `Auth: Invalid API key \u2014 PAPI_DATA_API_KEY was rejected by the proxy.
+Check PAPI_DATA_API_KEY in your .mcp.json config. You can regenerate it from the PAPI dashboard.
+(${response.status} on ${method}: ${message})`
+            );
+          }
+          if (response.status === 403 || response.status === 404) {
+            throw new Error(
+              `Auth: Project not found or access denied \u2014 PAPI_PROJECT_ID may be wrong.
+Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI dashboard settings.
+(${response.status} on ${method}: ${message})`
+            );
+          }
           throw new Error(`Proxy error (${response.status}) on ${method}: ${message}`);
         }
         const body = await response.json();
@@ -8120,6 +8182,27 @@ var init_proxy_adapter = __esm({
           return false;
         }
       }
+      /**
+       * Validate API key and project access against the proxy.
+       * Returns HTTP status so callers can distinguish 401 (bad key) from 403/404 (bad project).
+       * Status 0 means a network error occurred.
+       */
+      async probeAuth(projectId) {
+        try {
+          const response = await fetch(`${this.endpoint}/invoke`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({ projectId, method: "projectExists", args: [] }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          return { ok: response.ok, status: response.status };
+        } catch {
+          return { ok: false, status: 0 };
+        }
+      }
       // --- Planning & Health ---
       readPlanningLog() {
         return this.invoke("readPlanningLog");
@@ -8370,6 +8453,9 @@ var init_proxy_adapter = __esm({
       projectExists() {
         return this.invoke("projectExists");
       }
+      getBuildReportCountForTask(taskId) {
+        return this.invoke("getBuildReportCountForTask", [taskId]);
+      }
       // --- Atomic plan write-back ---
       planWriteBack(payload) {
         return this.invoke("planWriteBack", [payload]);
@@ -8378,1042 +8464,1191 @@ var init_proxy_adapter = __esm({
   }
 });
 
-// src/index.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/config.ts
-import path from "path";
-function loadConfig() {
-  const projectArgIdx = process.argv.indexOf("--project");
-  const projectRoot = projectArgIdx !== -1 ? process.argv[projectArgIdx + 1] : process.env.PAPI_PROJECT_DIR;
-  if (!projectRoot) {
-    throw new Error(
-      "Project root required. Pass --project /path/to/project or set PAPI_PROJECT_DIR."
-    );
+// src/lib/git.ts
+var git_exports = {};
+__export(git_exports, {
+  AUTO_WRITTEN_PATHS: () => AUTO_WRITTEN_PATHS,
+  branchExists: () => branchExists,
+  checkoutBranch: () => checkoutBranch,
+  createAndCheckoutBranch: () => createAndCheckoutBranch,
+  createPullRequest: () => createPullRequest,
+  createTag: () => createTag,
+  deleteLocalBranch: () => deleteLocalBranch,
+  detectBoardMismatches: () => detectBoardMismatches,
+  detectUnrecordedCommits: () => detectUnrecordedCommits,
+  ensureLatestDevelop: () => ensureLatestDevelop,
+  getCommitsSinceTag: () => getCommitsSinceTag,
+  getCurrentBranch: () => getCurrentBranch,
+  getFilesChangedFromBase: () => getFilesChangedFromBase,
+  getHeadCommitSha: () => getHeadCommitSha,
+  getLatestTag: () => getLatestTag,
+  getOriginRepoSlug: () => getOriginRepoSlug,
+  getUnmergedBranches: () => getUnmergedBranches,
+  gitPull: () => gitPull,
+  gitPush: () => gitPush,
+  hasRemote: () => hasRemote,
+  hasUncommittedChanges: () => hasUncommittedChanges,
+  hasUnpushedCommits: () => hasUnpushedCommits,
+  isGhAvailable: () => isGhAvailable,
+  isGitAvailable: () => isGitAvailable,
+  isGitRepo: () => isGitRepo,
+  mergePullRequest: () => mergePullRequest,
+  resolveBaseBranch: () => resolveBaseBranch,
+  runAutoCommit: () => runAutoCommit,
+  stageAllAndCommit: () => stageAllAndCommit,
+  stageDirAndCommit: () => stageDirAndCommit,
+  tagExists: () => tagExists,
+  taskBranchName: () => taskBranchName,
+  withBaseBranchSync: () => withBaseBranchSync
+});
+import { execFileSync } from "child_process";
+function isGitAvailable() {
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
   }
-  const anthropicApiKey = process.env.PAPI_API_KEY ?? "";
-  const autoCommit2 = process.env.PAPI_AUTO_COMMIT !== "false";
-  const baseBranch = process.env.PAPI_BASE_BRANCH ?? "main";
-  const autoPR = process.env.PAPI_AUTO_PR !== "false";
-  const lightMode = process.env.PAPI_LIGHT_MODE === "true";
-  const papiEndpoint = process.env.PAPI_ENDPOINT;
-  const dataEndpoint = process.env.PAPI_DATA_ENDPOINT;
-  const databaseUrl = process.env.DATABASE_URL;
-  const explicitAdapter = process.env.PAPI_ADAPTER;
-  const adapterType = papiEndpoint ? "pg" : databaseUrl && explicitAdapter === "pg" ? "pg" : dataEndpoint ? "proxy" : explicitAdapter ? explicitAdapter : databaseUrl ? "pg" : "proxy";
-  return {
-    projectRoot,
-    papiDir: path.join(projectRoot, ".papi"),
-    anthropicApiKey,
-    autoCommit: autoCommit2,
-    baseBranch,
-    autoPR,
-    adapterType,
-    papiEndpoint,
-    lightMode
-  };
 }
-
-// src/adapter-factory.ts
-init_dist2();
-import path2 from "path";
-import { execSync } from "child_process";
-function detectUserId() {
+function isGitRepo(cwd) {
   try {
-    const email = execSync("git config user.email", { encoding: "utf8", timeout: 5e3 }).trim();
-    if (email) return email;
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
   } catch {
+    return false;
   }
+}
+function stageDirAndCommit(cwd, dir, message) {
   try {
-    const ghUser = execSync("gh api user --jq .email", { encoding: "utf8", timeout: 1e4 }).trim();
-    if (ghUser && ghUser !== "null") return ghUser;
+    execFileSync("git", ["check-ignore", "-q", dir], { cwd });
+    return { committed: false, message: `Skipped commit \u2014 '${dir}' is gitignored.` };
   } catch {
   }
-  return void 0;
-}
-var HOSTED_PROXY_ENDPOINT = "https://guewgygcpcmrcoppihzx.supabase.co/functions/v1/data-proxy";
-var PLACEHOLDER_PATTERNS = [
-  "<YOUR_DATABASE_URL>",
-  "your-database-url",
-  "your_database_url",
-  "placeholder",
-  "example.com",
-  "localhost:5432/dbname",
-  "user:password@host"
-];
-function validateDatabaseUrl(connectionString) {
-  const lower = connectionString.toLowerCase().trim();
-  if (PLACEHOLDER_PATTERNS.some((p) => lower.includes(p.toLowerCase()))) {
-    throw new Error(
-      "DATABASE_URL contains a placeholder value and is not configured.\nReplace it with your actual Supabase connection string in .mcp.json.\nIf you don't have one yet, contact the PAPI admin for access."
-    );
+  execFileSync("git", ["add", dir], { cwd });
+  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    encoding: "utf-8"
+  }).trim();
+  if (!staged) {
+    return { committed: false, message: "No changes to commit." };
   }
-  if (!lower.startsWith("postgres://") && !lower.startsWith("postgresql://")) {
-    throw new Error(
-      `DATABASE_URL must be a PostgreSQL connection string (postgres:// or postgresql://).
-Got: "${connectionString.slice(0, 30)}..."
-Check your .mcp.json configuration.`
-    );
+  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
+  return { committed: true, message };
+}
+function stageAllAndCommit(cwd, message) {
+  execFileSync("git", ["add", "."], { cwd });
+  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
+    cwd,
+    encoding: "utf-8"
+  }).trim();
+  if (!staged) {
+    return { committed: false, message: "No changes to commit." };
   }
+  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
+  return { committed: true, message };
 }
-var _connectionStatus = "offline";
-function getConnectionStatus() {
-  return _connectionStatus;
+function getCurrentBranch(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return null;
+  }
 }
-async function createAdapter(optionsOrType, maybePapiDir) {
-  const options = typeof optionsOrType === "string" ? { adapterType: optionsOrType, papiDir: maybePapiDir } : optionsOrType;
-  const { adapterType, papiDir, papiEndpoint } = options;
-  switch (adapterType) {
-    case "md":
-      _connectionStatus = "offline";
-      return new MdFileAdapter(papiDir);
-    case "pg": {
-      const { PgAdapter: PgAdapter2, PgPapiAdapter: PgPapiAdapter2, configFromEnv: configFromEnv2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
-      const projectId = process.env["PAPI_PROJECT_ID"];
-      if (!projectId) {
-        throw new Error(
-          "PAPI_PROJECT_ID is required when using PostgreSQL storage. Set it to the UUID of your project in the database."
-        );
-      }
-      const config2 = papiEndpoint ? { connectionString: papiEndpoint } : configFromEnv2();
-      validateDatabaseUrl(config2.connectionString);
-      try {
-        const { ensureSchema: ensureSchema2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
-        await ensureSchema2(config2);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`[papi] \u2717 Schema creation failed: ${msg}`);
-        console.error("[papi]   Check DATABASE_URL and Supabase access.");
-      }
-      try {
-        const pgAdapter = new PgAdapter2(config2);
-        const existing = await pgAdapter.getProject(projectId);
-        if (!existing) {
-          const projectRoot = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? "";
-          const slug = path2.basename(projectRoot) || "unnamed";
-          let userId = process.env["PAPI_USER_ID"] ?? void 0;
-          if (!userId) {
-            userId = detectUserId();
-            if (userId) {
-              console.error(`[papi] Auto-detected user identity: ${userId}`);
-              console.error("[papi] Set PAPI_USER_ID in .mcp.json to make this explicit.");
-            } else {
-              console.error("[papi] \u26A0 No PAPI_USER_ID set and auto-detection failed.");
-              console.error("[papi]   Project will have no user scope \u2014 it may be visible to all dashboard users.");
-              console.error("[papi]   Set PAPI_USER_ID in your .mcp.json env to fix this.");
-            }
-          }
-          await pgAdapter.createProject({ id: projectId, slug, name: slug, papi_dir: papiDir, user_id: userId });
-        }
-        await pgAdapter.close();
-      } catch {
-      }
-      const adapter2 = new PgPapiAdapter2(config2, projectId);
-      try {
-        await adapter2.initRls();
-      } catch {
-      }
-      const connected = await adapter2.probeConnection();
-      if (connected) {
-        _connectionStatus = "connected";
-        console.error("[papi] \u2713 Supabase connected");
-      } else {
-        _connectionStatus = "degraded";
-        console.error("[papi] \u2717 Supabase unreachable \u2014 running in degraded mode, data may be stale");
-        console.error("[papi] Check your DATABASE_URL in .mcp.json \u2014 is the connection string correct?");
-      }
-      return adapter2;
-    }
-    case "proxy": {
-      const { ProxyPapiAdapter: ProxyPapiAdapter2 } = await Promise.resolve().then(() => (init_proxy_adapter(), proxy_adapter_exports));
-      const dashboardUrl = process.env["PAPI_DASHBOARD_URL"] || "https://papi-web-three.vercel.app";
-      const projectId = process.env["PAPI_PROJECT_ID"];
-      const dataApiKey = process.env["PAPI_DATA_API_KEY"];
-      if (!projectId && !dataApiKey) {
-        throw new Error(
-          `PAPI needs an account to store your project data.
-
-Get started in 3 steps:
-  1. Sign up at ${dashboardUrl}/login
-  2. Complete the onboarding wizard \u2014 it generates your .mcp.json config
-  3. Download the config, place it in your project root, and restart Claude Code
-
-Already have an account? Make sure PAPI_DATA_API_KEY and PAPI_PROJECT_ID are set in your .mcp.json env config.`
-        );
-      }
-      if (!projectId) {
-        throw new Error(
-          `PAPI_PROJECT_ID is required.
-Visit ${dashboardUrl}/onboard to generate your config, or add PAPI_PROJECT_ID to your .mcp.json env config.`
-        );
-      }
-      const dataEndpoint = process.env["PAPI_DATA_ENDPOINT"] || HOSTED_PROXY_ENDPOINT;
-      if (!dataApiKey) {
-        throw new Error(
-          `PAPI_DATA_API_KEY is required for proxy mode.
-To get your API key:
-  1. Sign up or sign in at ${dashboardUrl}/login
-  2. Your API key is shown on the onboarding page (save it \u2014 shown only once)
-  3. Add PAPI_DATA_API_KEY to your .mcp.json env config
-If you already have a key, set it in your MCP configuration.`
-        );
-      }
-      const adapter2 = new ProxyPapiAdapter2({
-        endpoint: dataEndpoint,
-        apiKey: dataApiKey,
-        projectId
-      });
-      const connected = await adapter2.probeConnection();
-      if (connected) {
-        _connectionStatus = "connected";
-        console.error("[papi] \u2713 Data proxy connected");
-      } else {
-        _connectionStatus = "degraded";
-        console.error("[papi] \u2717 Data proxy unreachable \u2014 running in degraded mode");
-        console.error("[papi] Check your PAPI_DATA_ENDPOINT configuration.");
-      }
-      return adapter2;
-    }
-    default: {
-      const _exhaustive = adapterType;
-      throw new Error(
-        `Unknown PAPI_ADAPTER value: "${_exhaustive}". Valid options: "md", "pg", "proxy".`
-      );
+function hasUncommittedChanges(cwd, ignore) {
+  try {
+    const args = ["status", "--porcelain"];
+    if (ignore?.length) {
+      args.push("--", ".", ...ignore.map((p) => `:!${p}`));
     }
+    const status = execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return false;
   }
 }
-
-// src/server.ts
-import { access as access4, readdir as readdir2, readFile as readFile5 } from "fs/promises";
-import { join as join9, dirname } from "path";
-import { fileURLToPath } from "url";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-
-// src/lib/response.ts
-function textResponse(text, usage) {
-  const result = {
-    content: [{ type: "text", text }]
-  };
-  if (usage) {
-    result._usage = usage;
+function branchExists(cwd, branch) {
+  try {
+    execFileSync("git", ["rev-parse", "--verify", branch], {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
   }
-  return result;
 }
-function errorResponse(message) {
-  return { content: [{ type: "text", text: `Error: ${message}` }] };
+function checkoutBranch(cwd, branch) {
+  try {
+    execFileSync("git", ["checkout", branch], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Checked out branch '${branch}'.` };
+  } catch {
+    return { success: false, message: `Failed to checkout branch '${branch}'.` };
+  }
 }
-
-// src/services/plan.ts
-init_dist2();
-import { createHash, randomUUID as randomUUID7 } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-import path3 from "path";
-
-// src/lib/formatters.ts
-function formatActiveDecisionsForPlan(decisions) {
-  if (decisions.length === 0) return "No active decisions.";
-  return decisions.filter((d) => !d.superseded).map((d) => `### ${d.id}: ${d.title} [Confidence: ${d.confidence}]
-
-${d.body}`).join("\n\n");
+function createAndCheckoutBranch(cwd, branch) {
+  try {
+    execFileSync("git", ["checkout", "-b", branch], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Created and checked out branch '${branch}'.` };
+  } catch {
+    return { success: false, message: `Failed to create branch '${branch}'.` };
+  }
 }
-function formatActiveDecisionsForReview(decisions) {
-  if (decisions.length === 0) return "No active decisions.";
-  return decisions.map((d) => {
-    const lifecycle = d.outcome && d.outcome !== "pending" ? ` | Outcome: ${d.outcome}` + (d.revisionCount ? ` | ${d.revisionCount} revision(s)` : "") : "";
-    const summary = extractDecisionSummary(d.body);
-    const summaryLine = summary ? `
-  Summary: ${summary}` : "";
-    if (d.superseded) {
-      return `- ${d.id}: ${d.title} [SUPERSEDED by ${d.supersededBy}${lifecycle}]${summaryLine}`;
-    }
-    return `- ${d.id}: ${d.title} [${d.confidence}${lifecycle}]${summaryLine}`;
-  }).join("\n");
+function hasRemote(cwd, remote = "origin") {
+  try {
+    const remotes = execFileSync("git", ["remote"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    return remotes.split("\n").includes(remote);
+  } catch {
+    return false;
+  }
 }
-function extractDecisionSummary(body) {
-  if (!body) return "";
-  const lines = body.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("---")) continue;
-    const clean = trimmed.replace(/\*\*/g, "").replace(/\*/g, "");
-    return clean.length > 150 ? clean.slice(0, 147) + "..." : clean;
+function gitPull(cwd) {
+  try {
+    execFileSync("git", ["pull"], { cwd, encoding: "utf-8", timeout: GIT_NETWORK_TIMEOUT_MS });
+    return { success: true, message: "Pulled latest changes." };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const isTimeout = msg.includes("ETIMEDOUT") || msg.includes("killed");
+    return {
+      success: false,
+      message: isTimeout ? "Pull timed out after 30s." : `Pull failed: ${msg}`
+    };
   }
-  return "";
 }
-function formatDecisionLifecycleSummary(decisions) {
-  const active = decisions.filter((d) => !d.superseded);
-  if (active.length === 0) return void 0;
-  const counts = {};
-  for (const d of active) {
-    const outcome = d.outcome ?? "pending";
-    counts[outcome] = (counts[outcome] ?? 0) + 1;
+function gitPush(cwd, branch) {
+  try {
+    execFileSync("git", ["push", "-u", "origin", branch], {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_NETWORK_TIMEOUT_MS
+    });
+    return { success: true, message: `Pushed branch '${branch}' to origin.` };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const isTimeout = msg.includes("ETIMEDOUT") || msg.includes("killed");
+    return {
+      success: false,
+      message: isTimeout ? `Push timed out after 30s.` : `Push failed: ${msg}`
+    };
   }
-  const parts = Object.entries(counts).map(([k, v]) => `${v} ${k}`);
-  const revised = active.filter((d) => (d.revisionCount ?? 0) > 0);
-  if (revised.length > 0) {
-    parts.push(`${revised.length} with revisions`);
+}
+function isGhAvailable() {
+  try {
+    execFileSync("gh", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
   }
-  return parts.join(", ");
 }
-function formatBuildReports(reports) {
-  if (reports.length === 0) return "No build reports yet.";
-  return reports.map(
-    (r) => `### ${r.taskName} \u2014 ${r.date} \u2014 Cycle ${r.cycle}
-
-- **Completed:** ${r.completed}
-- **Actual Effort:** ${r.actualEffort} vs estimated ${r.estimatedEffort}
-` + (r.correctionsCount ? `- **Corrections:** ${r.correctionsCount}
-` : "") + (Array.isArray(r.briefImplications) && r.briefImplications.length ? `- **Brief Implications:** ${r.briefImplications.map((bi) => `[${bi.canvasSection}/${bi.type}] ${bi.detail}`).join("; ")}
-` : "") + `- **Surprises:** ${r.surprises}
-- **Discovered Issues:** ${r.discoveredIssues}
-- **Architecture Notes:** ${r.architectureNotes}` + (r.deadEnds ? `
-- **Dead Ends:** ${r.deadEnds}` : "")
-  ).join("\n\n---\n\n");
+function getOriginRepoSlug(cwd) {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+    const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch) return sshMatch[1];
+    const httpsMatch = url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch) return httpsMatch[1];
+    return null;
+  } catch {
+    return null;
+  }
 }
-function formatRecentlyShippedCapabilities(reports) {
-  const completed = reports.filter((r) => r.completed === "Yes" || r.completed === "Partial");
-  if (completed.length === 0) return void 0;
-  const lines = completed.map((r) => {
-    const parts = [`- **${r.taskId}:** ${r.taskName}`];
-    if (r.architectureNotes && r.architectureNotes !== "None") {
-      const trimmed = r.architectureNotes.length > 150 ? r.architectureNotes.slice(0, 150) + "..." : r.architectureNotes;
-      parts.push(`  _Delivered:_ ${trimmed}`);
-    }
-    if (r.filesChanged && r.filesChanged.length > 0) {
-      parts.push(`  _Files:_ ${r.filesChanged.slice(0, 5).join(", ")}${r.filesChanged.length > 5 ? ` (+${r.filesChanged.length - 5} more)` : ""}`);
+function createPullRequest(cwd, branch, baseBranch, title, body) {
+  try {
+    const args = ["pr", "create", "--base", baseBranch, "--head", branch, "--title", title, "--body", body];
+    const repo = getOriginRepoSlug(cwd);
+    if (repo) {
+      args.push("--repo", repo);
     }
-    return parts.join("\n");
-  });
-  return [
-    `${completed.length} task(s) completed in recent cycles:`,
-    "",
-    ...lines,
-    "",
-    "Cross-reference candidate tasks against this list. If >80% of a candidate task's scope appears here, recommend cancellation or scope reduction instead of scheduling."
-  ].join("\n");
-}
-function formatCycleLog(entries) {
-  if (entries.length === 0) return "No cycle log entries yet.";
-  return entries.map(
-    (e) => `### Cycle ${e.cycleNumber} \u2014 ${e.title}
-
-${e.content}` + (e.carryForward ? `
-
-**Carry Forward:** ${e.carryForward}` : "") + (e.notes ? `
-
-**Cycle Notes:** ${e.notes}` : "")
-  ).join("\n\n---\n\n");
-}
-var PLAN_EXCLUDED_STATUSES = /* @__PURE__ */ new Set(["Done", "Cancelled", "Archived", "Deferred"]);
-var PLAN_NOTES_MAX_LENGTH = 300;
-function truncateNotes(notes, maxLen) {
-  if (!notes) return "";
-  if (notes.length <= maxLen) return notes;
-  return notes.slice(0, maxLen) + "...";
-}
-var ACTIVE_WORK_STATUSES = /* @__PURE__ */ new Set(["In Progress", "In Review", "Blocked"]);
-function isRecentTask(task, currentCycle) {
-  if (!task.reviewed) return true;
-  if (ACTIVE_WORK_STATUSES.has(task.status)) return true;
-  if (task.createdCycle === void 0) return true;
-  if (task.createdCycle >= currentCycle - 1) return true;
-  if (task.cycle !== void 0 && task.cycle >= currentCycle) return true;
-  return false;
+    const output = execFileSync("gh", args, { cwd, encoding: "utf-8" }).trim();
+    return { success: true, message: output };
+  } catch (err) {
+    return {
+      success: false,
+      message: `PR creation failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
 }
-function formatCompactTask(task) {
-  const handoffTag = task.hasHandoff ? " | \u2713 handoff" : "";
-  const typeTag = task.taskType && task.taskType !== "task" ? ` | ${task.taskType}` : "";
-  return `- ${task.id}: ${task.title} [${task.status} | ${task.priority} | ${task.complexity}${typeTag}${handoffTag}]`;
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function formatDetailedTask(t) {
-  const notes = truncateNotes(t.notes, PLAN_NOTES_MAX_LENGTH);
-  const hasHandoff = t.hasHandoff;
-  const typeTag = t.taskType && t.taskType !== "task" ? ` | Type: ${t.taskType}` : "";
-  return `- **${t.id}:** ${t.title}
-  Status: ${t.status} | Priority: ${t.priority} | Complexity: ${t.complexity}${typeTag}
-  Module: ${t.module} | Epic: ${t.epic} | Phase: ${t.phase} | Owner: ${t.owner}
-  Reviewed: ${t.reviewed}${t.dependsOn ? ` | Depends on: ${t.dependsOn}` : ""}${hasHandoff ? " | Has BUILD HANDOFF: yes" : ""}${t.docRef ? ` | Doc ref: ${t.docRef}` : ""}${notes ? `
-  Notes: ${notes}` : ""}`;
-}
-function formatBoardForPlan(tasks, filters, currentCycle) {
-  if (tasks.length === 0) return "No tasks on the board.";
-  let active = tasks.filter((t) => !PLAN_EXCLUDED_STATUSES.has(t.status));
-  const excludedCount = tasks.length - active.length;
-  if (filters) {
-    if (filters.phase) active = active.filter((t) => t.phase === filters.phase);
-    if (filters.module) active = active.filter((t) => t.module === filters.module);
-    if (filters.epic) active = active.filter((t) => t.epic === filters.epic);
-    if (filters.priority) active = active.filter((t) => t.priority === filters.priority);
-  }
-  const userFilteredCount = tasks.length - excludedCount - active.length;
-  const filterParts = [];
-  if (excludedCount > 0) filterParts.push(`${excludedCount} completed filtered`);
-  if (userFilteredCount > 0) filterParts.push(`${userFilteredCount} excluded by filters`);
-  const filterSuffix = filterParts.length > 0 ? filterParts.join(", ") : "";
-  if (active.length === 0) {
-    return `No active tasks on the board (${filterSuffix || "all filtered"}).`;
-  }
-  const byCounts = (statuses) => statuses.map((s) => {
-    const n = active.filter((t) => t.status === s).length;
-    return n > 0 ? `${n} ${s.toLowerCase()}` : null;
-  }).filter(Boolean).join(", ");
-  const summary = `Board: ${active.length} active tasks (${byCounts(["Backlog", "In Cycle", "Ready", "In Progress", "In Review", "Blocked"])})` + (filterSuffix ? ` \u2014 ${filterSuffix}` : "");
-  if (currentCycle === void 0) {
-    const formatted = active.map(formatDetailedTask).join("\n\n");
-    return `${summary}
-
-${formatted}`;
+function mergePullRequest(cwd, branch) {
+  const repo = getOriginRepoSlug(cwd);
+  const baseArgs = ["pr", "merge", branch, "--merge", "--delete-branch"];
+  if (repo) {
+    baseArgs.push("--repo", repo);
   }
-  const recent = [];
-  const stable = [];
-  for (const t of active) {
-    if (isRecentTask(t, currentCycle)) {
-      recent.push(t);
-    } else {
-      stable.push(t);
+  for (let attempt = 1; attempt <= MERGE_MAX_RETRIES; attempt++) {
+    try {
+      execFileSync("gh", baseArgs, { cwd, encoding: "utf-8" });
+      return { success: true, message: `Merged PR for '${branch}' and deleted branch.` };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isNotMergeable = msg.includes("not mergeable");
+      if (isNotMergeable && attempt < MERGE_MAX_RETRIES) {
+        sleepSync(MERGE_RETRY_DELAY_MS);
+        continue;
+      }
+      return { success: false, message: `PR merge failed: ${msg}` };
     }
   }
-  const sections = [summary];
-  if (recent.length > 0) {
-    sections.push(recent.map(formatDetailedTask).join("\n\n"));
-  }
-  if (stable.length > 0) {
-    sections.push(
-      `**Stable backlog (${stable.length} tasks \u2014 compact):**
-` + stable.map(formatCompactTask).join("\n")
-    );
+  return { success: false, message: "PR merge failed: max retries exceeded" };
+}
+function deleteLocalBranch(cwd, branch) {
+  try {
+    execFileSync("git", ["branch", "-d", branch], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Deleted local branch '${branch}'.` };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Failed to delete local branch '${branch}': ${err instanceof Error ? err.message : String(err)}`
+    };
   }
-  return sections.join("\n\n");
 }
-function formatBoardForReview(tasks) {
-  if (tasks.length === 0) return "No tasks on the board.";
-  return tasks.map(
-    (t) => `- **${t.id}:** ${t.title}
-  Status: ${t.status} | Priority: ${t.priority} | Complexity: ${t.complexity}
-  Module: ${t.module} | Epic: ${t.epic} | Phase: ${t.phase} | Owner: ${t.owner}
-  Reviewed: ${t.reviewed}${t.dependsOn ? ` | Depends on: ${t.dependsOn}` : ""}${t.notes ? `
-  Notes: ${t.notes}` : ""}`
-  ).join("\n\n");
+function tagExists(cwd, tag) {
+  try {
+    execFileSync("git", ["rev-parse", "--verify", `refs/tags/${tag}`], {
+      cwd,
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
 }
-function trendArrow(current, previous, higherIsBetter) {
-  if (previous === void 0) return "";
-  if (current === previous) return " \u2192";
-  const improving = higherIsBetter ? current > previous : current < previous;
-  return improving ? " \u2191" : " \u2193";
+function createTag(cwd, tag, message) {
+  try {
+    execFileSync("git", ["tag", "-a", tag, "-m", message], { cwd, encoding: "utf-8" });
+    return { success: true, message: `Created tag '${tag}'.` };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Failed to create tag: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
 }
-var EFFORT_MAP2 = { XS: 1, S: 2, M: 3, L: 5, XL: 8 };
-function computeSnapshotsFromBuildReports(reports) {
-  if (reports.length === 0) return [];
-  const byCycleMap = /* @__PURE__ */ new Map();
-  for (const r of reports) {
-    const existing = byCycleMap.get(r.cycle) ?? [];
-    existing.push(r);
-    byCycleMap.set(r.cycle, existing);
+function getLatestTag(cwd) {
+  try {
+    return execFileSync("git", ["describe", "--tags", "--abbrev=0"], {
+      cwd,
+      encoding: "utf-8"
+    }).trim() || null;
+  } catch {
+    return null;
   }
-  const snapshots = [];
-  for (const [sn, cycleReports] of byCycleMap) {
-    const completed = cycleReports.filter((r) => r.completed === "Yes").length;
-    const total = cycleReports.length;
-    const withEffort = cycleReports.filter((r) => r.estimatedEffort && r.actualEffort);
-    const accurate = withEffort.filter((r) => r.estimatedEffort === r.actualEffort).length;
-    const matchRate = withEffort.length > 0 ? Math.round(accurate / withEffort.length * 100) : 0;
-    let effortPoints = 0;
-    for (const r of cycleReports) {
-      effortPoints += EFFORT_MAP2[r.actualEffort] ?? 3;
-    }
-    snapshots.push({
-      cycle: sn,
-      date: (/* @__PURE__ */ new Date()).toISOString(),
-      accuracy: [{ cycle: sn, reports: total, matchRate, mae: 0, bias: 0 }],
-      velocity: [{ cycle: sn, completed, partial: 0, failed: total - completed, effortPoints }]
-    });
+}
+function getCommitsSinceTag(cwd, tag) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["log", `${tag}..HEAD`, "--oneline"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return output ? output.split("\n") : [];
+  } catch {
+    return [];
   }
-  snapshots.sort((a, b2) => a.cycle - b2.cycle);
-  return snapshots;
 }
-function formatCycleMetrics(snapshots) {
-  if (snapshots.length === 0) return "No methodology metrics yet.";
-  const latest = snapshots[snapshots.length - 1];
-  const previous = snapshots.length > 1 ? snapshots[snapshots.length - 2] : void 0;
-  const lines = [];
-  if (latest.velocity.length > 0) {
-    const latestV = latest.velocity[latest.velocity.length - 1];
-    lines.push("**Cycle Sizing**");
-    lines.push(`- Last cycle: ${latestV.completed} tasks, ${latestV.effortPoints} effort points`);
-    if (latestV.partial > 0 || latestV.failed > 0) {
-      lines.push(`- Partial: ${latestV.partial} | Failed: ${latestV.failed}`);
+async function withBaseBranchSync(config2, fn) {
+  const warnings = [];
+  if (!isGitAvailable() || !isGitRepo(config2.projectRoot)) {
+    return { result: await fn(), warnings };
+  }
+  const baseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
+  if (baseBranch !== config2.baseBranch) {
+    warnings.push(`Base branch '${config2.baseBranch}' not found \u2014 using '${baseBranch}'.`);
+  }
+  const currentBranch = getCurrentBranch(config2.projectRoot);
+  const needsBranchSwitch = currentBranch !== null && currentBranch !== baseBranch;
+  let previousBranch = null;
+  if (needsBranchSwitch && hasUncommittedChanges(config2.projectRoot, AUTO_WRITTEN_PATHS)) {
+    warnings.push("Skipping pull \u2014 uncommitted changes detected. Board data may be stale.");
+  } else if (needsBranchSwitch) {
+    const checkout = checkoutBranch(config2.projectRoot, baseBranch);
+    if (!checkout.success) {
+      warnings.push(`Could not switch to ${baseBranch}: ${checkout.message} Board data may be stale.`);
+    } else {
+      previousBranch = currentBranch;
+      if (hasRemote(config2.projectRoot)) {
+        const pull = gitPull(config2.projectRoot);
+        if (!pull.success && config2.abortOnConflict && /conflict/i.test(pull.message)) {
+          checkoutBranch(config2.projectRoot, previousBranch);
+          return { result: void 0, warnings, abort: pull.message };
+        }
+        warnings.push(pull.success ? `Synced from ${baseBranch}.` : `Pull failed: ${pull.message}`);
+      }
+    }
+  } else if (hasRemote(config2.projectRoot)) {
+    const pull = gitPull(config2.projectRoot);
+    if (!pull.success && config2.abortOnConflict && /conflict/i.test(pull.message)) {
+      return { result: void 0, warnings, abort: pull.message };
     }
+    warnings.push(pull.success ? `Synced from ${baseBranch}.` : `Pull failed: ${pull.message}`);
   }
-  const allVelocities = snapshots.flatMap((s) => s.velocity).sort((a, b2) => a.cycle - b2.cycle);
-  const recentVelocities = allVelocities.slice(-5);
-  if (recentVelocities.length > 0) {
-    const avgEffort = Math.round(
-      recentVelocities.reduce((sum, v) => sum + v.effortPoints, 0) / recentVelocities.length * 10
-    ) / 10;
-    lines.push("");
-    lines.push("**Cycle Sizing (effort points \u2014 primary signal)**");
-    lines.push(`- Last ${recentVelocities.length} cycles: ${recentVelocities.map((v) => `S${v.cycle}=${v.effortPoints}pts`).join(", ")}`);
-    lines.push(`- Average: ${avgEffort} effort points/cycle (XS=1, S=2, M=3, L=5, XL=8)`);
-    lines.push(`- Use average as a reference, not a target \u2014 size cycles based on what the selected tasks actually require.`);
+  const result = await fn();
+  if (previousBranch) {
+    checkoutBranch(config2.projectRoot, previousBranch);
   }
-  if (latest.accuracy.length > 0) {
-    const latestA = latest.accuracy[latest.accuracy.length - 1];
-    const prevA = previous?.accuracy[previous.accuracy.length - 1];
-    lines.push("");
-    lines.push("**Estimation Accuracy**");
-    lines.push(`- Match rate: ${latestA.matchRate}%${trendArrow(latestA.matchRate, prevA?.matchRate, true)}`);
-    lines.push(`- MAE: ${latestA.mae}${trendArrow(latestA.mae, prevA?.mae, false)}`);
-    lines.push(`- Bias: ${latestA.bias >= 0 ? "+" : ""}${latestA.bias}${trendArrow(Math.abs(latestA.bias), prevA ? Math.abs(prevA.bias) : void 0, false)}`);
+  return { result, warnings };
+}
+function hasUnpushedCommits(cwd) {
+  try {
+    const output = execFileSync(
+      "git",
+      ["rev-list", "@{u}..HEAD", "--count"],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    return parseInt(output, 10) > 0;
+  } catch {
+    return false;
   }
-  return lines.join("\n");
 }
-function formatDerivedMetrics(snapshots, backlogTasks) {
-  const lines = [];
-  if (snapshots.length > 0) {
-    const velocities = snapshots.flatMap((s) => s.velocity).sort((a, b2) => a.cycle - b2.cycle);
-    if (velocities.length >= 2) {
-      const recent = velocities.slice(-5);
-      const avg = recent.reduce((sum, v) => sum + v.completed, 0) / recent.length;
-      const latest = recent[recent.length - 1];
-      lines.push("**Cycle History (5-cycle avg)**");
-      lines.push(`- Average: ${avg.toFixed(1)} tasks/cycle`);
-      lines.push(`- Latest (Cycle ${latest.cycle}): ${latest.completed} tasks, ${latest.effortPoints} effort points`);
-    }
+function ensureLatestDevelop(cwd, baseBranch) {
+  if (!isGitAvailable() || !isGitRepo(cwd)) {
+    return { pulled: false };
   }
-  const activeTasks = backlogTasks.filter(
-    (t) => t.status === "Backlog" || t.status === "In Cycle" || t.status === "Ready"
-  );
-  if (activeTasks.length > 0) {
-    const highPriority = activeTasks.filter(
-      (t) => t.priority === "P1 High" || t.priority === "P0 Critical"
-    ).length;
-    const ratio = (highPriority / activeTasks.length * 100).toFixed(0);
-    const health = highPriority <= 3 ? "healthy" : highPriority <= 6 ? "moderate" : "top-heavy";
-    if (lines.length > 0) lines.push("");
-    lines.push("**Backlog Health**");
-    lines.push(`- ${activeTasks.length} items, ${highPriority} high-priority (${ratio}%) \u2014 ${health}`);
-  }
-  if (snapshots.length > 0) {
-    const accuracies = snapshots.flatMap((s) => s.accuracy).sort((a, b2) => a.cycle - b2.cycle);
-    if (accuracies.length >= 3) {
-      const recent = accuracies.slice(-5);
-      const avgBias = recent.reduce((sum, a) => sum + a.bias, 0) / recent.length;
-      const biasDir = avgBias > 0.3 ? "over-estimates" : avgBias < -0.3 ? "under-estimates" : "balanced";
-      const avgMatch = recent.reduce((sum, a) => sum + a.matchRate, 0) / recent.length;
-      if (lines.length > 0) lines.push("");
-      lines.push("**Estimation Trend (5-cycle)**");
-      lines.push(`- Avg match rate: ${avgMatch.toFixed(0)}%`);
-      lines.push(`- Avg bias: ${avgBias >= 0 ? "+" : ""}${avgBias.toFixed(1)} \u2014 ${biasDir}`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatBuildPatterns(patterns) {
-  const sections = [];
-  if (patterns.recurringSurprises.length > 0) {
-    const items = patterns.recurringSurprises.map((s) => `- "${s.text}" \u2014 ${s.count} occurrences (cycles ${s.cycles.join(", ")})`).join("\n");
-    sections.push(`**Recurring Surprises**
-${items}`);
-  }
-  if (patterns.estimationBias !== "none") {
-    const direction = patterns.estimationBias === "under" ? "under-estimated (actual effort exceeded estimates)" : "over-estimated (actual effort was less than estimates)";
-    sections.push(`**Estimation Bias**
-Tasks are consistently ${direction} \u2014 ${patterns.estimationBiasRate}% of recent builds.`);
-  }
-  const scopeKeys = Object.keys(patterns.scopeAccuracyBreakdown);
-  if (scopeKeys.length > 0) {
-    const items = scopeKeys.map((k) => `- ${k}: ${patterns.scopeAccuracyBreakdown[k]}`).join("\n");
-    sections.push(`**Scope Accuracy**
-${items}`);
-  }
-  if (patterns.untriagedIssues.length > 0) {
-    const items = patterns.untriagedIssues.map((issue) => `- ${issue}`).join("\n");
-    sections.push(`**Discovered Issues (untriaged)**
-${items}`);
-  }
-  return sections.join("\n\n");
-}
-function formatReviewPatterns(patterns) {
-  const sections = [];
-  if (patterns.recurringFeedback.length > 0) {
-    const items = patterns.recurringFeedback.map((f) => `- "${f.text}" \u2014 ${f.count} occurrences (${f.taskIds.join(", ")})`).join("\n");
-    sections.push(`**Recurring Review Feedback**
-${items}`);
-  }
-  const verdictKeys = Object.keys(patterns.verdictBreakdown);
-  if (verdictKeys.length > 0) {
-    const items = verdictKeys.map((k) => `- ${k}: ${patterns.verdictBreakdown[k]}`).join("\n");
-    sections.push(`**Verdict Breakdown**
-${items}`);
-  }
-  if (patterns.requestChangesRate >= 50) {
-    sections.push(`**High Rework Rate**
-${patterns.requestChangesRate}% of recent reviews requested changes.`);
-  }
-  return sections.join("\n\n");
-}
-function formatReviews(reviews) {
-  if (reviews.length === 0) return "";
-  return reviews.map(
-    (r) => `### ${r.taskId} \u2014 ${r.stage === "handoff-review" ? "Handoff Review" : "Build Acceptance"} \u2014 ${r.date}
-
-- **Verdict:** ${r.verdict}
-- **Reviewer:** ${r.reviewer}
-- **Comments:** ${r.comments}`
-  ).join("\n\n---\n\n");
-}
-function formatTaskComments(comments, taskIds, heading = "## Task Comments") {
-  const relevant = comments.filter((c) => taskIds.has(c.taskId));
-  if (relevant.length === 0) return "";
-  const byTask = /* @__PURE__ */ new Map();
-  for (const c of relevant) {
-    const list = byTask.get(c.taskId) ?? [];
-    list.push(c);
-    byTask.set(c.taskId, list);
-  }
-  const lines = ["", heading];
-  for (const [taskId, taskComments] of byTask) {
-    for (const c of taskComments.slice(0, 3)) {
-      const date = c.createdAt.split("T")[0];
-      const text = c.content.length > 200 ? c.content.slice(0, 200) + "..." : c.content;
-      lines.push(`- **${taskId}** \u2014 ${c.author} (${date}): "${text}"`);
-    }
-  }
-  return lines.join("\n");
-}
-function formatDiscoveryCanvas(canvas) {
-  const sections = [];
-  if (canvas.landscapeReferences && canvas.landscapeReferences.length > 0) {
-    sections.push("**Landscape & References:**");
-    for (const ref of canvas.landscapeReferences) {
-      const url = ref.url ? ` (${ref.url})` : "";
-      const notes = ref.notes ? ` \u2014 ${ref.notes}` : "";
-      sections.push(`- ${ref.name}${url}${notes}`);
-    }
+  const current = getCurrentBranch(cwd);
+  if (!current || current !== baseBranch) {
+    return { pulled: false, warning: `Skipping pull \u2014 not on ${baseBranch} (on ${current ?? "unknown"}).` };
   }
-  if (canvas.userJourneys && canvas.userJourneys.length > 0) {
-    sections.push("**User Journeys:**");
-    for (const j of canvas.userJourneys) {
-      const priority = j.priority ? ` [${j.priority}]` : "";
-      sections.push(`- **${j.persona}:** ${j.journey}${priority}`);
-    }
+  if (hasUncommittedChanges(cwd, AUTO_WRITTEN_PATHS)) {
+    return { pulled: false, warning: "Skipping pull \u2014 uncommitted changes detected." };
   }
-  if (canvas.mvpBoundary) {
-    sections.push("**MVP Boundary:**", canvas.mvpBoundary);
+  if (hasUnpushedCommits(cwd)) {
+    return { pulled: false, warning: "Skipping pull \u2014 unpushed commits on current branch." };
   }
-  if (canvas.assumptionsOpenQuestions && canvas.assumptionsOpenQuestions.length > 0) {
-    sections.push("**Assumptions & Open Questions:**");
-    for (const a of canvas.assumptionsOpenQuestions) {
-      const evidence = a.evidence ? ` Evidence: ${a.evidence}` : "";
-      sections.push(`- [${a.status}] ${a.text}${evidence}`);
-    }
+  if (!hasRemote(cwd)) {
+    return { pulled: false };
   }
-  if (canvas.successSignals && canvas.successSignals.length > 0) {
-    sections.push("**Success Signals:**");
-    for (const s of canvas.successSignals) {
-      const metric = s.metric ? ` (${s.metric}` + (s.target ? `, target: ${s.target})` : ")") : "";
-      sections.push(`- ${s.signal}${metric}`);
-    }
+  const result = gitPull(cwd);
+  if (!result.success) {
+    return { pulled: false, warning: `Pull failed \u2014 using local data. ${result.message}` };
   }
-  return sections.length > 0 ? sections.join("\n") : void 0;
+  return { pulled: true };
 }
-
-// src/lib/git.ts
-import { execFileSync } from "child_process";
-var AUTO_WRITTEN_PATHS = [".papi/*"];
-function isGitAvailable() {
+function getUnmergedBranches(cwd, baseBranch) {
   try {
-    execFileSync("git", ["--version"], { stdio: "ignore" });
-    return true;
+    const output = execFileSync(
+      "git",
+      ["branch", "--no-merged", baseBranch],
+      { cwd, encoding: "utf-8" }
+    ).trim();
+    if (!output) return [];
+    return output.split("\n").map((b2) => b2.replace(/^\*?\s+/, "").trim()).filter(Boolean);
   } catch {
-    return false;
+    return [];
   }
 }
-function isGitRepo(cwd) {
+function resolveBaseBranch(cwd, preferred) {
+  if (branchExists(cwd, preferred)) return preferred;
+  if (preferred !== "main" && branchExists(cwd, "main")) return "main";
+  if (preferred !== "master" && branchExists(cwd, "master")) return "master";
+  return preferred;
+}
+function detectBoardMismatches(cwd, tasks) {
+  const empty = { codeAhead: [], staleInProgress: [] };
+  if (!isGitAvailable() || !isGitRepo(cwd)) return empty;
   try {
-    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+    const mergedOutput = execFileSync("git", ["branch", "--merged", "HEAD"], {
       cwd,
-      stdio: "ignore"
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
     });
-    return true;
+    const allOutput = execFileSync("git", ["branch"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const parseBranches = (raw) => new Set(raw.split("\n").map((l) => l.trim().replace(/^\* /, "")).filter(Boolean));
+    const mergedBranches = parseBranches(mergedOutput);
+    const allBranches = parseBranches(allOutput);
+    const codeAhead = [];
+    const staleInProgress = [];
+    for (const task of tasks) {
+      const branch = `feat/${task.displayId}`;
+      if (task.status === "Backlog" && mergedBranches.has(branch)) {
+        codeAhead.push({ displayId: task.displayId, title: task.title, branch });
+      }
+      if (task.status === "In Progress" && !allBranches.has(branch)) {
+        staleInProgress.push({ displayId: task.displayId, title: task.title });
+      }
+    }
+    return { codeAhead, staleInProgress };
   } catch {
-    return false;
+    return empty;
   }
 }
-function stageDirAndCommit(cwd, dir, message) {
+function detectUnrecordedCommits(cwd, baseBranch) {
+  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
+  const latestTag = getLatestTag(cwd);
+  if (!latestTag) return [];
   try {
-    execFileSync("git", ["check-ignore", "-q", dir], { cwd });
-    return { committed: false, message: `Skipped commit \u2014 '${dir}' is gitignored.` };
+    const output = execFileSync(
+      "git",
+      ["log", `${latestTag}..${baseBranch}`, "--oneline", "--max-count=20"],
+      { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    if (!output) return [];
+    const CYCLE_PATTERNS = [
+      /feat\(task-\d+\):/,
+      // build_execute commits: feat(task-NNN): title
+      /^[a-f0-9]+ release:/,
+      // release commits
+      /^[a-f0-9]+ Merge /,
+      // merge commits from PRs
+      /chore\(task-/
+      // task-related housekeeping
+    ];
+    return output.split("\n").filter((line) => line.trim() && !CYCLE_PATTERNS.some((p) => p.test(line))).map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      return {
+        hash: line.slice(0, spaceIdx),
+        message: line.slice(spaceIdx + 1)
+      };
+    });
   } catch {
+    return [];
   }
-  execFileSync("git", ["add", dir], { cwd });
-  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
-    cwd,
-    encoding: "utf-8"
-  }).trim();
-  if (!staged) {
-    return { committed: false, message: "No changes to commit." };
-  }
-  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
-  return { committed: true, message };
 }
-function stageAllAndCommit(cwd, message) {
-  execFileSync("git", ["add", "."], { cwd });
-  const staged = execFileSync("git", ["diff", "--cached", "--name-only"], {
-    cwd,
-    encoding: "utf-8"
-  }).trim();
-  if (!staged) {
-    return { committed: false, message: "No changes to commit." };
-  }
-  execFileSync("git", ["commit", "-m", message], { cwd, encoding: "utf-8" });
-  return { committed: true, message };
+function taskBranchName(taskId) {
+  return `feat/${taskId}`;
 }
-function getCurrentBranch(cwd) {
+function getHeadCommitSha(cwd) {
   try {
-    return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd,
-      encoding: "utf-8"
-    }).trim();
+    return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8" }).trim() || null;
   } catch {
     return null;
   }
 }
-function hasUncommittedChanges(cwd, ignore) {
+function runAutoCommit(projectRoot, commitFn) {
+  if (!isGitAvailable()) return "Auto-commit: skipped (git not found).";
+  if (!isGitRepo(projectRoot)) return "Auto-commit: skipped (not a git repository).";
   try {
-    const args = ["status", "--porcelain"];
-    if (ignore?.length) {
-      args.push("--", ".", ...ignore.map((p) => `:!${p}`));
-    }
-    const status = execFileSync("git", args, {
-      cwd,
-      encoding: "utf-8"
-    }).trim();
-    return status.length > 0;
-  } catch {
-    return false;
+    const result = commitFn();
+    return result.committed ? `Auto-committed: ${result.message}` : `Auto-commit: ${result.message}`;
+  } catch (err) {
+    return `Auto-commit failed: ${err instanceof Error ? err.message : String(err)}`;
   }
 }
-function branchExists(cwd, branch) {
+function getFilesChangedFromBase(cwd, baseBranch) {
   try {
-    execFileSync("git", ["rev-parse", "--verify", branch], {
-      cwd,
-      stdio: "ignore"
-    });
-    return true;
+    const mergeBase = execFileSync("git", ["merge-base", baseBranch, "HEAD"], { cwd, encoding: "utf-8" }).trim();
+    const output = execFileSync("git", ["diff", "--name-only", mergeBase, "HEAD"], { cwd, encoding: "utf-8" }).trim();
+    return output ? output.split("\n").filter(Boolean) : [];
   } catch {
-    return false;
+    return [];
   }
 }
-function checkoutBranch(cwd, branch) {
-  try {
-    execFileSync("git", ["checkout", branch], { cwd, encoding: "utf-8" });
-    return { success: true, message: `Checked out branch '${branch}'.` };
-  } catch {
-    return { success: false, message: `Failed to checkout branch '${branch}'.` };
+var AUTO_WRITTEN_PATHS, GIT_NETWORK_TIMEOUT_MS, MERGE_RETRY_DELAY_MS, MERGE_MAX_RETRIES;
+var init_git = __esm({
+  "src/lib/git.ts"() {
+    "use strict";
+    AUTO_WRITTEN_PATHS = [".papi/*"];
+    GIT_NETWORK_TIMEOUT_MS = 6e4;
+    MERGE_RETRY_DELAY_MS = 2e3;
+    MERGE_MAX_RETRIES = 3;
+  }
+});
+
+// src/index.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join11 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema as CallToolRequestSchema2,
+  ListToolsRequestSchema as ListToolsRequestSchema2
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/config.ts
+import path from "path";
+function loadConfig() {
+  const projectArgIdx = process.argv.indexOf("--project");
+  const configuredRoot = projectArgIdx !== -1 ? process.argv[projectArgIdx + 1] : process.env.PAPI_PROJECT_DIR;
+  const projectRoot = configuredRoot ?? process.cwd();
+  if (!configuredRoot) {
+    process.stderr.write(
+      '\nPAPI is running but no project is configured.\nSay "run setup" to get started.\n\n'
+    );
   }
+  const anthropicApiKey = process.env.PAPI_API_KEY ?? "";
+  const autoCommit2 = process.env.PAPI_AUTO_COMMIT !== "false";
+  const baseBranch = process.env.PAPI_BASE_BRANCH ?? "main";
+  const autoPR = process.env.PAPI_AUTO_PR !== "false";
+  const lightMode = process.env.PAPI_LIGHT_MODE === "true";
+  const papiEndpoint = process.env.PAPI_ENDPOINT;
+  const dataEndpoint = process.env.PAPI_DATA_ENDPOINT;
+  const databaseUrl = process.env.DATABASE_URL;
+  const explicitAdapter = process.env.PAPI_ADAPTER;
+  const adapterType = papiEndpoint ? "pg" : databaseUrl && explicitAdapter === "pg" ? "pg" : dataEndpoint ? "proxy" : explicitAdapter ? explicitAdapter : databaseUrl ? "pg" : "proxy";
+  return {
+    projectRoot,
+    papiDir: path.join(projectRoot, ".papi"),
+    anthropicApiKey,
+    autoCommit: autoCommit2,
+    baseBranch,
+    autoPR,
+    adapterType,
+    papiEndpoint,
+    lightMode
+  };
 }
-function createAndCheckoutBranch(cwd, branch) {
+
+// src/adapter-factory.ts
+init_dist2();
+import path2 from "path";
+import { execSync } from "child_process";
+function detectUserId() {
   try {
-    execFileSync("git", ["checkout", "-b", branch], { cwd, encoding: "utf-8" });
-    return { success: true, message: `Created and checked out branch '${branch}'.` };
+    const email = execSync("git config user.email", { encoding: "utf8", timeout: 5e3 }).trim();
+    if (email) return email;
   } catch {
-    return { success: false, message: `Failed to create branch '${branch}'.` };
   }
-}
-function hasRemote(cwd, remote = "origin") {
   try {
-    const remotes = execFileSync("git", ["remote"], {
-      cwd,
-      encoding: "utf-8"
-    }).trim();
-    return remotes.split("\n").includes(remote);
+    const ghUser = execSync("gh api user --jq .email", { encoding: "utf8", timeout: 1e4 }).trim();
+    if (ghUser && ghUser !== "null") return ghUser;
   } catch {
-    return false;
   }
+  return void 0;
 }
-var GIT_NETWORK_TIMEOUT_MS = 6e4;
-function gitPull(cwd) {
-  try {
-    execFileSync("git", ["pull"], { cwd, encoding: "utf-8", timeout: GIT_NETWORK_TIMEOUT_MS });
-    return { success: true, message: "Pulled latest changes." };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    const isTimeout = msg.includes("ETIMEDOUT") || msg.includes("killed");
-    return {
-      success: false,
-      message: isTimeout ? "Pull timed out after 30s." : `Pull failed: ${msg}`
-    };
+var HOSTED_PROXY_ENDPOINT = "https://guewgygcpcmrcoppihzx.supabase.co/functions/v1/data-proxy";
+var PLACEHOLDER_PATTERNS = [
+  "<YOUR_DATABASE_URL>",
+  "your-database-url",
+  "your_database_url",
+  "placeholder",
+  "example.com",
+  "localhost:5432/dbname",
+  "user:password@host"
+];
+function validateDatabaseUrl(connectionString) {
+  const lower = connectionString.toLowerCase().trim();
+  if (PLACEHOLDER_PATTERNS.some((p) => lower.includes(p.toLowerCase()))) {
+    throw new Error(
+      "DATABASE_URL contains a placeholder value and is not configured.\nReplace it with your actual Supabase connection string in .mcp.json.\nIf you don't have one yet, contact the PAPI admin for access."
+    );
+  }
+  if (!lower.startsWith("postgres://") && !lower.startsWith("postgresql://")) {
+    throw new Error(
+      `DATABASE_URL must be a PostgreSQL connection string (postgres:// or postgresql://).
+Got: "${connectionString.slice(0, 30)}..."
+Check your .mcp.json configuration.`
+    );
   }
 }
-function gitPush(cwd, branch) {
-  try {
-    execFileSync("git", ["push", "-u", "origin", branch], {
-      cwd,
-      encoding: "utf-8",
-      timeout: GIT_NETWORK_TIMEOUT_MS
-    });
-    return { success: true, message: `Pushed branch '${branch}' to origin.` };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    const isTimeout = msg.includes("ETIMEDOUT") || msg.includes("killed");
-    return {
-      success: false,
-      message: isTimeout ? `Push timed out after 30s.` : `Push failed: ${msg}`
-    };
+var _connectionStatus = "offline";
+function getConnectionStatus() {
+  return _connectionStatus;
+}
+async function createAdapter(optionsOrType, maybePapiDir) {
+  const options = typeof optionsOrType === "string" ? { adapterType: optionsOrType, papiDir: maybePapiDir } : optionsOrType;
+  const { adapterType, papiDir, papiEndpoint } = options;
+  switch (adapterType) {
+    case "md":
+      _connectionStatus = "offline";
+      return new MdFileAdapter(papiDir);
+    case "pg": {
+      const { PgAdapter: PgAdapter2, PgPapiAdapter: PgPapiAdapter2, configFromEnv: configFromEnv2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
+      const projectId = process.env["PAPI_PROJECT_ID"];
+      if (!projectId) {
+        throw new Error(
+          "PAPI_PROJECT_ID is required when using PostgreSQL storage. Set it to the UUID of your project in the database."
+        );
+      }
+      const config2 = papiEndpoint ? { connectionString: papiEndpoint } : configFromEnv2();
+      validateDatabaseUrl(config2.connectionString);
+      try {
+        const { ensureSchema: ensureSchema2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
+        await ensureSchema2(config2);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[papi] \u2717 Schema creation failed: ${msg}`);
+        console.error("[papi]   Check DATABASE_URL and Supabase access.");
+      }
+      try {
+        const pgAdapter = new PgAdapter2(config2);
+        const existing = await pgAdapter.getProject(projectId);
+        if (!existing) {
+          const projectRoot = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? "";
+          const slug = path2.basename(projectRoot) || "unnamed";
+          let userId = process.env["PAPI_USER_ID"] ?? void 0;
+          if (!userId) {
+            userId = detectUserId();
+            if (userId) {
+              console.error(`[papi] Auto-detected user identity: ${userId}`);
+              console.error("[papi] Set PAPI_USER_ID in .mcp.json to make this explicit.");
+            } else {
+              console.error("[papi] \u26A0 No PAPI_USER_ID set and auto-detection failed.");
+              console.error("[papi]   Project will have no user scope \u2014 it may be visible to all dashboard users.");
+              console.error("[papi]   Set PAPI_USER_ID in your .mcp.json env to fix this.");
+            }
+          }
+          await pgAdapter.createProject({ id: projectId, slug, name: slug, papi_dir: papiDir, user_id: userId });
+        }
+        await pgAdapter.close();
+      } catch {
+      }
+      const adapter2 = new PgPapiAdapter2(config2, projectId);
+      try {
+        await adapter2.initRls();
+      } catch {
+      }
+      const connected = await adapter2.probeConnection();
+      if (connected) {
+        _connectionStatus = "connected";
+        console.error("[papi] \u2713 Supabase connected");
+      } else {
+        _connectionStatus = "degraded";
+        console.error("[papi] \u2717 Supabase unreachable \u2014 running in degraded mode, data may be stale");
+        console.error("[papi] Check your DATABASE_URL in .mcp.json \u2014 is the connection string correct?");
+      }
+      return adapter2;
+    }
+    case "proxy": {
+      const { ProxyPapiAdapter: ProxyPapiAdapter2 } = await Promise.resolve().then(() => (init_proxy_adapter(), proxy_adapter_exports));
+      const dashboardUrl = process.env["PAPI_DASHBOARD_URL"] || "https://getpapi.ai";
+      const projectId = process.env["PAPI_PROJECT_ID"];
+      const dataApiKey = process.env["PAPI_DATA_API_KEY"];
+      if (!dataApiKey) {
+        throw new Error(
+          `PAPI needs an account to store your project data.
+
+Get started in 3 steps:
+  1. Sign up at ${dashboardUrl}/login
+  2. Complete the onboarding wizard \u2014 it generates your .mcp.json config
+  3. Download the config, place it in your project root, and restart Claude Code
+
+Already have an account? Make sure PAPI_DATA_API_KEY is set in your .mcp.json env config.`
+        );
+      }
+      const dataEndpoint = process.env["PAPI_DATA_ENDPOINT"] || HOSTED_PROXY_ENDPOINT;
+      const adapter2 = new ProxyPapiAdapter2({
+        endpoint: dataEndpoint,
+        apiKey: dataApiKey,
+        projectId: projectId || void 0
+      });
+      const connected = await adapter2.probeConnection();
+      if (!connected) {
+        _connectionStatus = "degraded";
+        console.error("[papi] \u2717 Data proxy unreachable \u2014 running in degraded mode");
+        console.error("[papi] Check your PAPI_DATA_ENDPOINT configuration.");
+      } else if (projectId) {
+        const auth = await adapter2.probeAuth(projectId);
+        if (!auth.ok) {
+          if (auth.status === 401) {
+            throw new Error(
+              "PAPI_DATA_API_KEY is invalid \u2014 authentication failed.\nCheck the key in your .mcp.json config. You can generate a new key from the PAPI dashboard."
+            );
+          } else if (auth.status === 403 || auth.status === 404) {
+            throw new Error(
+              `PAPI_PROJECT_ID "${projectId}" was not found or you don't have access.
+Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI dashboard settings.`
+            );
+          } else if (auth.status !== 0) {
+            _connectionStatus = "degraded";
+            console.error(`[papi] \u26A0 Auth check returned ${auth.status} \u2014 running in degraded mode`);
+          }
+        } else {
+          _connectionStatus = "connected";
+          console.error("[papi] \u2713 Data proxy connected");
+        }
+      } else {
+        _connectionStatus = "connected";
+        console.error("[papi] \u2713 Data proxy reachable \u2014 project will be auto-provisioned");
+      }
+      if (!projectId && connected) {
+        try {
+          const { getOriginRepoSlug: getOriginRepoSlug2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+          const projectRoot = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? process.cwd();
+          const repoSlug = getOriginRepoSlug2(projectRoot);
+          const projectName = repoSlug ? repoSlug.split("/").pop() || path2.basename(projectRoot) || "My Project" : path2.basename(projectRoot) || "My Project";
+          let repoUrl;
+          try {
+            repoUrl = execSync("git remote get-url origin", { cwd: projectRoot, encoding: "utf8", timeout: 3e3 }).trim() || void 0;
+          } catch {
+          }
+          const result = await adapter2.ensureProject(projectName, repoUrl);
+          if (result.created) {
+            console.error(`[papi] \u2713 Project "${result.projectName}" auto-provisioned (${result.projectId})`);
+            console.error("[papi] Tip: add PAPI_PROJECT_ID to .mcp.json to skip this check on future starts.");
+          } else {
+            console.error(`[papi] \u2713 Using project "${result.projectName}" (${result.projectId})`);
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[papi] \u26A0 Auto-provision failed: ${msg}`);
+          console.error("[papi] Set PAPI_PROJECT_ID in .mcp.json to connect to an existing project.");
+        }
+      }
+      return adapter2;
+    }
+    default: {
+      const _exhaustive = adapterType;
+      throw new Error(
+        `Unknown PAPI_ADAPTER value: "${_exhaustive}". Valid options: "md", "pg", "proxy".`
+      );
+    }
   }
 }
-function isGhAvailable() {
-  try {
-    execFileSync("gh", ["--version"], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+
+// src/server.ts
+import { access as access4, readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { join as join10, dirname } from "path";
+import { fileURLToPath } from "url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/lib/response.ts
+function textResponse(text, usage) {
+  const result = {
+    content: [{ type: "text", text }]
+  };
+  if (usage) {
+    result._usage = usage;
   }
+  return result;
 }
-function getOriginRepoSlug(cwd) {
-  try {
-    const url = execFileSync("git", ["remote", "get-url", "origin"], {
-      cwd,
-      encoding: "utf-8"
-    }).trim();
-    const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
-    if (sshMatch) return sshMatch[1];
-    const httpsMatch = url.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
-    if (httpsMatch) return httpsMatch[1];
-    return null;
-  } catch {
-    return null;
+function errorResponse(message) {
+  return { content: [{ type: "text", text: `Error: ${message}` }] };
+}
+
+// src/services/plan.ts
+init_dist2();
+import { createHash, randomUUID as randomUUID7 } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/lib/formatters.ts
+function formatActiveDecisionsForPlan(decisions) {
+  if (decisions.length === 0) return "No active decisions.";
+  return decisions.filter((d) => !d.superseded).map((d) => `### ${d.id}: ${d.title} [Confidence: ${d.confidence}]
+
+${d.body}`).join("\n\n");
+}
+function formatActiveDecisionsForReview(decisions) {
+  if (decisions.length === 0) return "No active decisions.";
+  return decisions.map((d) => {
+    const lifecycle = d.outcome && d.outcome !== "pending" ? ` | Outcome: ${d.outcome}` + (d.revisionCount ? ` | ${d.revisionCount} revision(s)` : "") : "";
+    const summary = extractDecisionSummary(d.body);
+    const summaryLine = summary ? `
+  Summary: ${summary}` : "";
+    if (d.superseded) {
+      return `- ${d.id}: ${d.title} [SUPERSEDED by ${d.supersededBy}${lifecycle}]${summaryLine}`;
+    }
+    return `- ${d.id}: ${d.title} [${d.confidence}${lifecycle}]${summaryLine}`;
+  }).join("\n");
+}
+function extractDecisionSummary(body) {
+  if (!body) return "";
+  const lines = body.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("---")) continue;
+    const clean = trimmed.replace(/\*\*/g, "").replace(/\*/g, "");
+    return clean.length > 150 ? clean.slice(0, 147) + "..." : clean;
+  }
+  return "";
+}
+function formatDecisionLifecycleSummary(decisions) {
+  const active = decisions.filter((d) => !d.superseded);
+  if (active.length === 0) return void 0;
+  const counts = {};
+  for (const d of active) {
+    const outcome = d.outcome ?? "pending";
+    counts[outcome] = (counts[outcome] ?? 0) + 1;
+  }
+  const parts = Object.entries(counts).map(([k, v]) => `${v} ${k}`);
+  const revised = active.filter((d) => (d.revisionCount ?? 0) > 0);
+  if (revised.length > 0) {
+    parts.push(`${revised.length} with revisions`);
+  }
+  return parts.join(", ");
+}
+function formatBuildReports(reports) {
+  if (reports.length === 0) return "No build reports yet.";
+  return reports.map(
+    (r) => `### ${r.taskName} \u2014 ${r.date} \u2014 Cycle ${r.cycle}
+
+- **Completed:** ${r.completed}
+- **Actual Effort:** ${r.actualEffort} vs estimated ${r.estimatedEffort}
+` + (r.correctionsCount ? `- **Corrections:** ${r.correctionsCount}
+` : "") + (Array.isArray(r.briefImplications) && r.briefImplications.length ? `- **Brief Implications:** ${r.briefImplications.map((bi) => `[${bi.canvasSection}/${bi.type}] ${bi.detail}`).join("; ")}
+` : "") + `- **Surprises:** ${r.surprises}
+- **Discovered Issues:** ${r.discoveredIssues}
+- **Architecture Notes:** ${r.architectureNotes}` + (r.deadEnds ? `
+- **Dead Ends:** ${r.deadEnds}` : "")
+  ).join("\n\n---\n\n");
+}
+function formatRecentlyShippedCapabilities(reports) {
+  const completed = reports.filter((r) => r.completed === "Yes" || r.completed === "Partial");
+  if (completed.length === 0) return void 0;
+  const lines = completed.map((r) => {
+    const parts = [`- **${r.taskId}:** ${r.taskName}`];
+    if (r.architectureNotes && r.architectureNotes !== "None") {
+      const trimmed = r.architectureNotes.length > 150 ? r.architectureNotes.slice(0, 150) + "..." : r.architectureNotes;
+      parts.push(`  _Delivered:_ ${trimmed}`);
+    }
+    if (r.filesChanged && r.filesChanged.length > 0) {
+      parts.push(`  _Files:_ ${r.filesChanged.slice(0, 5).join(", ")}${r.filesChanged.length > 5 ? ` (+${r.filesChanged.length - 5} more)` : ""}`);
+    }
+    return parts.join("\n");
+  });
+  return [
+    `${completed.length} task(s) completed in recent cycles:`,
+    "",
+    ...lines,
+    "",
+    "Cross-reference candidate tasks against this list. If >80% of a candidate task's scope appears here, recommend cancellation or scope reduction instead of scheduling."
+  ].join("\n");
+}
+function formatCycleLog(entries) {
+  if (entries.length === 0) return "No cycle log entries yet.";
+  return entries.map(
+    (e) => `### Cycle ${e.cycleNumber} \u2014 ${e.title}
+
+${e.content}` + (e.carryForward ? `
+
+**Carry Forward:** ${e.carryForward}` : "") + (e.notes ? `
+
+**Cycle Notes:** ${e.notes}` : "")
+  ).join("\n\n---\n\n");
+}
+var PLAN_EXCLUDED_STATUSES = /* @__PURE__ */ new Set(["Done", "Cancelled", "Archived", "Deferred"]);
+var PLAN_NOTES_MAX_LENGTH = 300;
+function truncateNotes(notes, maxLen) {
+  if (!notes) return "";
+  if (notes.length <= maxLen) return notes;
+  return notes.slice(0, maxLen) + "...";
+}
+var ACTIVE_WORK_STATUSES = /* @__PURE__ */ new Set(["In Progress", "In Review", "Blocked"]);
+function isRecentTask(task, currentCycle) {
+  if (!task.reviewed) return true;
+  if (ACTIVE_WORK_STATUSES.has(task.status)) return true;
+  if (task.createdCycle === void 0) return true;
+  if (task.createdCycle >= currentCycle - 1) return true;
+  if (task.cycle !== void 0 && task.cycle >= currentCycle) return true;
+  return false;
+}
+function formatCompactTask(task) {
+  const handoffTag = task.hasHandoff ? " | \u2713 handoff" : "";
+  const typeTag = task.taskType && task.taskType !== "task" ? ` | ${task.taskType}` : "";
+  return `- ${task.id}: ${task.title} [${task.status} | ${task.priority} | ${task.complexity}${typeTag}${handoffTag}]`;
+}
+function formatDetailedTask(t) {
+  const notes = truncateNotes(t.notes, PLAN_NOTES_MAX_LENGTH);
+  const hasHandoff = t.hasHandoff;
+  const typeTag = t.taskType && t.taskType !== "task" ? ` | Type: ${t.taskType}` : "";
+  return `- **${t.id}:** ${t.title}
+  Status: ${t.status} | Priority: ${t.priority} | Complexity: ${t.complexity}${typeTag}
+  Module: ${t.module} | Epic: ${t.epic} | Phase: ${t.phase} | Owner: ${t.owner}
+  Reviewed: ${t.reviewed}${t.dependsOn ? ` | Depends on: ${t.dependsOn}` : ""}${hasHandoff ? " | Has BUILD HANDOFF: yes" : ""}${t.docRef ? ` | Doc ref: ${t.docRef}` : ""}${notes ? `
+  Notes: ${notes}` : ""}`;
+}
+function formatBoardForPlan(tasks, filters, currentCycle) {
+  if (tasks.length === 0) return "No tasks on the board.";
+  let active = tasks.filter((t) => !PLAN_EXCLUDED_STATUSES.has(t.status));
+  const excludedCount = tasks.length - active.length;
+  if (filters) {
+    if (filters.phase) active = active.filter((t) => t.phase === filters.phase);
+    if (filters.module) active = active.filter((t) => t.module === filters.module);
+    if (filters.epic) active = active.filter((t) => t.epic === filters.epic);
+    if (filters.priority) active = active.filter((t) => t.priority === filters.priority);
+  }
+  const userFilteredCount = tasks.length - excludedCount - active.length;
+  const filterParts = [];
+  if (excludedCount > 0) filterParts.push(`${excludedCount} completed filtered`);
+  if (userFilteredCount > 0) filterParts.push(`${userFilteredCount} excluded by filters`);
+  const filterSuffix = filterParts.length > 0 ? filterParts.join(", ") : "";
+  if (active.length === 0) {
+    return `No active tasks on the board (${filterSuffix || "all filtered"}).`;
+  }
+  const byCounts = (statuses) => statuses.map((s) => {
+    const n = active.filter((t) => t.status === s).length;
+    return n > 0 ? `${n} ${s.toLowerCase()}` : null;
+  }).filter(Boolean).join(", ");
+  const summary = `Board: ${active.length} active tasks (${byCounts(["Backlog", "In Cycle", "Ready", "In Progress", "In Review", "Blocked"])})` + (filterSuffix ? ` \u2014 ${filterSuffix}` : "");
+  if (currentCycle === void 0) {
+    const formatted = active.map(formatDetailedTask).join("\n\n");
+    return `${summary}
+
+${formatted}`;
+  }
+  const recent = [];
+  const stable = [];
+  for (const t of active) {
+    if (isRecentTask(t, currentCycle)) {
+      recent.push(t);
+    } else {
+      stable.push(t);
+    }
+  }
+  const sections = [summary];
+  if (recent.length > 0) {
+    sections.push(recent.map(formatDetailedTask).join("\n\n"));
+  }
+  if (stable.length > 0) {
+    sections.push(
+      `**Stable backlog (${stable.length} tasks \u2014 compact):**
+` + stable.map(formatCompactTask).join("\n")
+    );
   }
+  return sections.join("\n\n");
 }
-function createPullRequest(cwd, branch, baseBranch, title, body) {
-  try {
-    const args = ["pr", "create", "--base", baseBranch, "--head", branch, "--title", title, "--body", body];
-    const repo = getOriginRepoSlug(cwd);
-    if (repo) {
-      args.push("--repo", repo);
-    }
-    const output = execFileSync("gh", args, { cwd, encoding: "utf-8" }).trim();
-    return { success: true, message: output };
-  } catch (err) {
-    return {
-      success: false,
-      message: `PR creation failed: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
+function formatBoardForReview(tasks) {
+  if (tasks.length === 0) return "No tasks on the board.";
+  return tasks.map(
+    (t) => `- **${t.id}:** ${t.title}
+  Status: ${t.status} | Priority: ${t.priority} | Complexity: ${t.complexity}
+  Module: ${t.module} | Epic: ${t.epic} | Phase: ${t.phase} | Owner: ${t.owner}
+  Reviewed: ${t.reviewed}${t.dependsOn ? ` | Depends on: ${t.dependsOn}` : ""}${t.notes ? `
+  Notes: ${t.notes}` : ""}`
+  ).join("\n\n");
 }
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+function trendArrow(current, previous, higherIsBetter) {
+  if (previous === void 0) return "";
+  if (current === previous) return " \u2192";
+  const improving = higherIsBetter ? current > previous : current < previous;
+  return improving ? " \u2191" : " \u2193";
 }
-var MERGE_RETRY_DELAY_MS = 2e3;
-var MERGE_MAX_RETRIES = 3;
-function mergePullRequest(cwd, branch) {
-  const repo = getOriginRepoSlug(cwd);
-  const baseArgs = ["pr", "merge", branch, "--merge", "--delete-branch"];
-  if (repo) {
-    baseArgs.push("--repo", repo);
+var EFFORT_MAP2 = { XS: 1, S: 2, M: 3, L: 5, XL: 8 };
+function computeSnapshotsFromBuildReports(reports) {
+  if (reports.length === 0) return [];
+  const byCycleMap = /* @__PURE__ */ new Map();
+  for (const r of reports) {
+    const existing = byCycleMap.get(r.cycle) ?? [];
+    existing.push(r);
+    byCycleMap.set(r.cycle, existing);
   }
-  for (let attempt = 1; attempt <= MERGE_MAX_RETRIES; attempt++) {
-    try {
-      execFileSync("gh", baseArgs, { cwd, encoding: "utf-8" });
-      return { success: true, message: `Merged PR for '${branch}' and deleted branch.` };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      const isNotMergeable = msg.includes("not mergeable");
-      if (isNotMergeable && attempt < MERGE_MAX_RETRIES) {
-        sleepSync(MERGE_RETRY_DELAY_MS);
-        continue;
-      }
-      return { success: false, message: `PR merge failed: ${msg}` };
+  const snapshots = [];
+  for (const [sn, cycleReports] of byCycleMap) {
+    const completed = cycleReports.filter((r) => r.completed === "Yes").length;
+    const total = cycleReports.length;
+    const withEffort = cycleReports.filter((r) => r.estimatedEffort && r.actualEffort);
+    const accurate = withEffort.filter((r) => r.estimatedEffort === r.actualEffort).length;
+    const matchRate = withEffort.length > 0 ? Math.round(accurate / withEffort.length * 100) : 0;
+    let effortPoints = 0;
+    for (const r of cycleReports) {
+      effortPoints += EFFORT_MAP2[r.actualEffort] ?? 3;
     }
+    snapshots.push({
+      cycle: sn,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      accuracy: [{ cycle: sn, reports: total, matchRate, mae: 0, bias: 0 }],
+      velocity: [{ cycle: sn, completed, partial: 0, failed: total - completed, effortPoints }]
+    });
   }
-  return { success: false, message: "PR merge failed: max retries exceeded" };
+  snapshots.sort((a, b2) => a.cycle - b2.cycle);
+  return snapshots;
 }
-function deleteLocalBranch(cwd, branch) {
-  try {
-    execFileSync("git", ["branch", "-d", branch], { cwd, encoding: "utf-8" });
-    return { success: true, message: `Deleted local branch '${branch}'.` };
-  } catch (err) {
-    return {
-      success: false,
-      message: `Failed to delete local branch '${branch}': ${err instanceof Error ? err.message : String(err)}`
-    };
+function formatCycleMetrics(snapshots) {
+  if (snapshots.length === 0) return "No methodology metrics yet.";
+  const latest = snapshots[snapshots.length - 1];
+  const previous = snapshots.length > 1 ? snapshots[snapshots.length - 2] : void 0;
+  const lines = [];
+  if (latest.velocity.length > 0) {
+    const latestV = latest.velocity[latest.velocity.length - 1];
+    lines.push("**Cycle Sizing**");
+    lines.push(`- Last cycle: ${latestV.completed} tasks, ${latestV.effortPoints} effort points`);
+    if (latestV.partial > 0 || latestV.failed > 0) {
+      lines.push(`- Partial: ${latestV.partial} | Failed: ${latestV.failed}`);
+    }
   }
-}
-function tagExists(cwd, tag) {
-  try {
-    execFileSync("git", ["rev-parse", "--verify", `refs/tags/${tag}`], {
-      cwd,
-      stdio: "ignore"
-    });
-    return true;
-  } catch {
-    return false;
+  const allVelocities = snapshots.flatMap((s) => s.velocity).sort((a, b2) => a.cycle - b2.cycle);
+  const recentVelocities = allVelocities.slice(-5);
+  if (recentVelocities.length > 0) {
+    const avgEffort = Math.round(
+      recentVelocities.reduce((sum, v) => sum + v.effortPoints, 0) / recentVelocities.length * 10
+    ) / 10;
+    lines.push("");
+    lines.push("**Cycle Sizing (effort points \u2014 primary signal)**");
+    lines.push(`- Last ${recentVelocities.length} cycles: ${recentVelocities.map((v) => `S${v.cycle}=${v.effortPoints}pts`).join(", ")}`);
+    lines.push(`- Average: ${avgEffort} effort points/cycle (XS=1, S=2, M=3, L=5, XL=8)`);
+    lines.push(`- Use average as a reference, not a target \u2014 size cycles based on what the selected tasks actually require.`);
   }
-}
-function createTag(cwd, tag, message) {
-  try {
-    execFileSync("git", ["tag", "-a", tag, "-m", message], { cwd, encoding: "utf-8" });
-    return { success: true, message: `Created tag '${tag}'.` };
-  } catch (err) {
-    return {
-      success: false,
-      message: `Failed to create tag: ${err instanceof Error ? err.message : String(err)}`
-    };
+  if (latest.accuracy.length > 0) {
+    const latestA = latest.accuracy[latest.accuracy.length - 1];
+    const prevA = previous?.accuracy[previous.accuracy.length - 1];
+    lines.push("");
+    lines.push("**Estimation Accuracy**");
+    lines.push(`- Match rate: ${latestA.matchRate}%${trendArrow(latestA.matchRate, prevA?.matchRate, true)}`);
+    lines.push(`- MAE: ${latestA.mae}${trendArrow(latestA.mae, prevA?.mae, false)}`);
+    lines.push(`- Bias: ${latestA.bias >= 0 ? "+" : ""}${latestA.bias}${trendArrow(Math.abs(latestA.bias), prevA ? Math.abs(prevA.bias) : void 0, false)}`);
   }
+  return lines.join("\n");
 }
-function getLatestTag(cwd) {
-  try {
-    return execFileSync("git", ["describe", "--tags", "--abbrev=0"], {
-      cwd,
-      encoding: "utf-8"
-    }).trim() || null;
-  } catch {
-    return null;
+function formatDerivedMetrics(snapshots, backlogTasks) {
+  const lines = [];
+  if (snapshots.length > 0) {
+    const velocities = snapshots.flatMap((s) => s.velocity).sort((a, b2) => a.cycle - b2.cycle);
+    if (velocities.length >= 2) {
+      const recent = velocities.slice(-5);
+      const avg = recent.reduce((sum, v) => sum + v.completed, 0) / recent.length;
+      const latest = recent[recent.length - 1];
+      lines.push("**Cycle History (5-cycle avg)**");
+      lines.push(`- Average: ${avg.toFixed(1)} tasks/cycle`);
+      lines.push(`- Latest (Cycle ${latest.cycle}): ${latest.completed} tasks, ${latest.effortPoints} effort points`);
+    }
   }
-}
-function getCommitsSinceTag(cwd, tag) {
-  try {
-    const output = execFileSync(
-      "git",
-      ["log", `${tag}..HEAD`, "--oneline"],
-      { cwd, encoding: "utf-8" }
-    ).trim();
-    return output ? output.split("\n") : [];
-  } catch {
-    return [];
+  const activeTasks = backlogTasks.filter(
+    (t) => t.status === "Backlog" || t.status === "In Cycle" || t.status === "Ready"
+  );
+  if (activeTasks.length > 0) {
+    const highPriority = activeTasks.filter(
+      (t) => t.priority === "P1 High" || t.priority === "P0 Critical"
+    ).length;
+    const ratio = (highPriority / activeTasks.length * 100).toFixed(0);
+    const health = highPriority <= 3 ? "healthy" : highPriority <= 6 ? "moderate" : "top-heavy";
+    if (lines.length > 0) lines.push("");
+    lines.push("**Backlog Health**");
+    lines.push(`- ${activeTasks.length} items, ${highPriority} high-priority (${ratio}%) \u2014 ${health}`);
+  }
+  if (snapshots.length > 0) {
+    const accuracies = snapshots.flatMap((s) => s.accuracy).sort((a, b2) => a.cycle - b2.cycle);
+    if (accuracies.length >= 3) {
+      const recent = accuracies.slice(-5);
+      const avgBias = recent.reduce((sum, a) => sum + a.bias, 0) / recent.length;
+      const biasDir = avgBias > 0.3 ? "over-estimates" : avgBias < -0.3 ? "under-estimates" : "balanced";
+      const avgMatch = recent.reduce((sum, a) => sum + a.matchRate, 0) / recent.length;
+      if (lines.length > 0) lines.push("");
+      lines.push("**Estimation Trend (5-cycle)**");
+      lines.push(`- Avg match rate: ${avgMatch.toFixed(0)}%`);
+      lines.push(`- Avg bias: ${avgBias >= 0 ? "+" : ""}${avgBias.toFixed(1)} \u2014 ${biasDir}`);
+    }
   }
+  return lines.join("\n");
 }
-async function withBaseBranchSync(config2, fn) {
-  const warnings = [];
-  if (!isGitAvailable() || !isGitRepo(config2.projectRoot)) {
-    return { result: await fn(), warnings };
+function formatBuildPatterns(patterns) {
+  const sections = [];
+  if (patterns.recurringSurprises.length > 0) {
+    const items = patterns.recurringSurprises.map((s) => `- "${s.text}" \u2014 ${s.count} occurrences (cycles ${s.cycles.join(", ")})`).join("\n");
+    sections.push(`**Recurring Surprises**
+${items}`);
   }
-  const baseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
-  if (baseBranch !== config2.baseBranch) {
-    warnings.push(`Base branch '${config2.baseBranch}' not found \u2014 using '${baseBranch}'.`);
+  if (patterns.estimationBias !== "none") {
+    const direction = patterns.estimationBias === "under" ? "under-estimated (actual effort exceeded estimates)" : "over-estimated (actual effort was less than estimates)";
+    sections.push(`**Estimation Bias**
+Tasks are consistently ${direction} \u2014 ${patterns.estimationBiasRate}% of recent builds.`);
   }
-  const currentBranch = getCurrentBranch(config2.projectRoot);
-  const needsBranchSwitch = currentBranch !== null && currentBranch !== baseBranch;
-  let previousBranch = null;
-  if (needsBranchSwitch && hasUncommittedChanges(config2.projectRoot, AUTO_WRITTEN_PATHS)) {
-    warnings.push("Skipping pull \u2014 uncommitted changes detected. Board data may be stale.");
-  } else if (needsBranchSwitch) {
-    const checkout = checkoutBranch(config2.projectRoot, baseBranch);
-    if (!checkout.success) {
-      warnings.push(`Could not switch to ${baseBranch}: ${checkout.message} Board data may be stale.`);
-    } else {
-      previousBranch = currentBranch;
-      if (hasRemote(config2.projectRoot)) {
-        const pull = gitPull(config2.projectRoot);
-        if (!pull.success && config2.abortOnConflict && /conflict/i.test(pull.message)) {
-          checkoutBranch(config2.projectRoot, previousBranch);
-          return { result: void 0, warnings, abort: pull.message };
-        }
-        warnings.push(pull.success ? `Synced from ${baseBranch}.` : `Pull failed: ${pull.message}`);
-      }
-    }
-  } else if (hasRemote(config2.projectRoot)) {
-    const pull = gitPull(config2.projectRoot);
-    if (!pull.success && config2.abortOnConflict && /conflict/i.test(pull.message)) {
-      return { result: void 0, warnings, abort: pull.message };
-    }
-    warnings.push(pull.success ? `Synced from ${baseBranch}.` : `Pull failed: ${pull.message}`);
+  const scopeKeys = Object.keys(patterns.scopeAccuracyBreakdown);
+  if (scopeKeys.length > 0) {
+    const items = scopeKeys.map((k) => `- ${k}: ${patterns.scopeAccuracyBreakdown[k]}`).join("\n");
+    sections.push(`**Scope Accuracy**
+${items}`);
+  }
+  if (patterns.untriagedIssues.length > 0) {
+    const items = patterns.untriagedIssues.map((issue) => `- ${issue}`).join("\n");
+    sections.push(`**Discovered Issues (untriaged)**
+${items}`);
+  }
+  return sections.join("\n\n");
+}
+function formatReviewPatterns(patterns) {
+  const sections = [];
+  if (patterns.recurringFeedback.length > 0) {
+    const items = patterns.recurringFeedback.map((f) => `- "${f.text}" \u2014 ${f.count} occurrences (${f.taskIds.join(", ")})`).join("\n");
+    sections.push(`**Recurring Review Feedback**
+${items}`);
   }
-  const result = await fn();
-  if (previousBranch) {
-    checkoutBranch(config2.projectRoot, previousBranch);
+  const verdictKeys = Object.keys(patterns.verdictBreakdown);
+  if (verdictKeys.length > 0) {
+    const items = verdictKeys.map((k) => `- ${k}: ${patterns.verdictBreakdown[k]}`).join("\n");
+    sections.push(`**Verdict Breakdown**
+${items}`);
   }
-  return { result, warnings };
-}
-function getUnmergedBranches(cwd, baseBranch) {
-  try {
-    const output = execFileSync(
-      "git",
-      ["branch", "--no-merged", baseBranch],
-      { cwd, encoding: "utf-8" }
-    ).trim();
-    if (!output) return [];
-    return output.split("\n").map((b2) => b2.replace(/^\*?\s+/, "").trim()).filter(Boolean);
-  } catch {
-    return [];
+  if (patterns.requestChangesRate >= 50) {
+    sections.push(`**High Rework Rate**
+${patterns.requestChangesRate}% of recent reviews requested changes.`);
   }
+  return sections.join("\n\n");
 }
-function resolveBaseBranch(cwd, preferred) {
-  if (branchExists(cwd, preferred)) return preferred;
-  if (preferred !== "main" && branchExists(cwd, "main")) return "main";
-  if (preferred !== "master" && branchExists(cwd, "master")) return "master";
-  return preferred;
+function formatReviews(reviews) {
+  if (reviews.length === 0) return "";
+  return reviews.map(
+    (r) => `### ${r.taskId} \u2014 ${r.stage === "handoff-review" ? "Handoff Review" : "Build Acceptance"} \u2014 ${r.date}
+
+- **Verdict:** ${r.verdict}
+- **Reviewer:** ${r.reviewer}
+- **Comments:** ${r.comments}`
+  ).join("\n\n---\n\n");
 }
-function detectBoardMismatches(cwd, tasks) {
-  const empty = { codeAhead: [], staleInProgress: [] };
-  if (!isGitAvailable() || !isGitRepo(cwd)) return empty;
-  try {
-    const mergedOutput = execFileSync("git", ["branch", "--merged", "HEAD"], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const allOutput = execFileSync("git", ["branch"], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const parseBranches = (raw) => new Set(raw.split("\n").map((l) => l.trim().replace(/^\* /, "")).filter(Boolean));
-    const mergedBranches = parseBranches(mergedOutput);
-    const allBranches = parseBranches(allOutput);
-    const codeAhead = [];
-    const staleInProgress = [];
-    for (const task of tasks) {
-      const branch = `feat/${task.displayId}`;
-      if (task.status === "Backlog" && mergedBranches.has(branch)) {
-        codeAhead.push({ displayId: task.displayId, title: task.title, branch });
-      }
-      if (task.status === "In Progress" && !allBranches.has(branch)) {
-        staleInProgress.push({ displayId: task.displayId, title: task.title });
-      }
+function formatTaskComments(comments, taskIds, heading = "## Task Comments") {
+  const relevant = comments.filter((c) => taskIds.has(c.taskId));
+  if (relevant.length === 0) return "";
+  const byTask = /* @__PURE__ */ new Map();
+  for (const c of relevant) {
+    const list = byTask.get(c.taskId) ?? [];
+    list.push(c);
+    byTask.set(c.taskId, list);
+  }
+  const lines = ["", heading];
+  for (const [taskId, taskComments] of byTask) {
+    for (const c of taskComments.slice(0, 3)) {
+      const date = c.createdAt.split("T")[0];
+      const text = c.content.length > 200 ? c.content.slice(0, 200) + "..." : c.content;
+      lines.push(`- **${taskId}** \u2014 ${c.author} (${date}): "${text}"`);
     }
-    return { codeAhead, staleInProgress };
-  } catch {
-    return empty;
   }
+  return lines.join("\n");
 }
-function taskBranchName(taskId) {
-  return `feat/${taskId}`;
-}
-function getHeadCommitSha(cwd) {
-  try {
-    return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8" }).trim() || null;
-  } catch {
-    return null;
+function formatDiscoveryCanvas(canvas) {
+  const sections = [];
+  if (canvas.landscapeReferences && canvas.landscapeReferences.length > 0) {
+    sections.push("**Landscape & References:**");
+    for (const ref of canvas.landscapeReferences) {
+      const url = ref.url ? ` (${ref.url})` : "";
+      const notes = ref.notes ? ` \u2014 ${ref.notes}` : "";
+      sections.push(`- ${ref.name}${url}${notes}`);
+    }
   }
-}
-function runAutoCommit(projectRoot, commitFn) {
-  if (!isGitAvailable()) return "Auto-commit: skipped (git not found).";
-  if (!isGitRepo(projectRoot)) return "Auto-commit: skipped (not a git repository).";
-  try {
-    const result = commitFn();
-    return result.committed ? `Auto-committed: ${result.message}` : `Auto-commit: ${result.message}`;
-  } catch (err) {
-    return `Auto-commit failed: ${err instanceof Error ? err.message : String(err)}`;
+  if (canvas.userJourneys && canvas.userJourneys.length > 0) {
+    sections.push("**User Journeys:**");
+    for (const j of canvas.userJourneys) {
+      const priority = j.priority ? ` [${j.priority}]` : "";
+      sections.push(`- **${j.persona}:** ${j.journey}${priority}`);
+    }
   }
-}
-function getFilesChangedFromBase(cwd, baseBranch) {
-  try {
-    const mergeBase = execFileSync("git", ["merge-base", baseBranch, "HEAD"], { cwd, encoding: "utf-8" }).trim();
-    const output = execFileSync("git", ["diff", "--name-only", mergeBase, "HEAD"], { cwd, encoding: "utf-8" }).trim();
-    return output ? output.split("\n").filter(Boolean) : [];
-  } catch {
-    return [];
+  if (canvas.mvpBoundary) {
+    sections.push("**MVP Boundary:**", canvas.mvpBoundary);
+  }
+  if (canvas.assumptionsOpenQuestions && canvas.assumptionsOpenQuestions.length > 0) {
+    sections.push("**Assumptions & Open Questions:**");
+    for (const a of canvas.assumptionsOpenQuestions) {
+      const evidence = a.evidence ? ` Evidence: ${a.evidence}` : "";
+      sections.push(`- [${a.status}] ${a.text}${evidence}`);
+    }
+  }
+  if (canvas.successSignals && canvas.successSignals.length > 0) {
+    sections.push("**Success Signals:**");
+    for (const s of canvas.successSignals) {
+      const metric = s.metric ? ` (${s.metric}` + (s.target ? `, target: ${s.target})` : ")") : "";
+      sections.push(`- ${s.signal}${metric}`);
+    }
   }
+  return sections.length > 0 ? sections.join("\n") : void 0;
 }
 
+// src/services/plan.ts
+init_git();
+
 // src/lib/horizon.ts
 function buildHorizonContext(phases, tasks) {
   if (phases.length === 0) return null;
@@ -9604,6 +9839,9 @@ ACCEPTANCE CRITERIA
 [ ] [criterion 1]
 [ ] [criterion 2]
 
+PRE-MORTEM
+[For projects with 10+ cycles: 1-3 bullet points \u2014 most likely technical blocker, integration risk with adjacent systems, and scope creep signal. Draw from dead_ends and surprises in recent build reports for the same module. Omit this section entirely for projects with fewer than 10 cycles.]
+
 SECURITY CONSIDERATIONS
 [data exposure, secrets handling, auth/access control, dependency risks \u2014 or "None \u2014 no security-relevant changes"]
 
@@ -9798,6 +10036,7 @@ Standard planning cycle with full board review.
    **Estimation calibration:** Estimate **XS** for: copy/text-only changes, single string replacements, config tweaks, and any task where the scope is "change words in an existing file" with no logic changes. Estimate **S** for: wiring existing adapter methods, adding API routes following established patterns, modifying prompts, or documentation-only changes. Default to S for pattern-following work. Only use M when genuine new architecture, new DB tables, or multi-file architectural changes are needed. Historical data shows systematic over-estimation (198 over vs 8 under out of 528 tasks) \u2014 when in doubt, estimate smaller. If an "Estimation Calibration (Historical)" section is provided in the context below, use its data to adjust your estimates \u2014 it shows how often each estimated size matched the actual effort. Pay special attention to systematic over/under-estimation patterns (e.g. if M\u2192S happens frequently, estimate S instead of M for similar work).
    **Reference docs:** If a task's notes include a \`Reference:\` path (e.g. \`Reference: docs/architecture/papi-brain-v1.md\`), include a REFERENCE DOCS section in the BUILD HANDOFF with those paths. This tells the builder to read the referenced doc for background context before implementing. Do NOT omit or summarise the reference \u2014 pass it through so the builder can access the full document. Only tasks with explicit \`Reference:\` paths in their notes should have this section.
    **Pre-build verification:** EVERY handoff MUST include a PRE-BUILD VERIFICATION section listing 2-5 specific file paths the builder should read before implementing. Derive these from FILES LIKELY TOUCHED \u2014 pick the files most likely to already contain the target functionality. This is the #1 prevention mechanism for wasted build slots (C120, C125, C126 all scheduled already-shipped work). If the builder finds >80% of the scope already implemented, they report "already built" instead of re-implementing.
+   **Pre-mortem:** For projects with 10+ cycles, include a PRE-MORTEM section in every BUILD HANDOFF with 1-3 bullet points: (a) most likely technical blocker based on module history, (b) integration risk with adjacent systems, (c) scope creep signal \u2014 what the builder might be tempted to expand beyond scope. Draw from \`dead_ends\` and \`surprises\` in recent build reports for the same module. Omit this section entirely for projects with fewer than 10 cycles.
    **Research task detection:** When a task's title starts with "Research:" or the task type is "research", add a RESEARCH OUTPUT section to the BUILD HANDOFF after ACCEPTANCE CRITERIA:
 
    RESEARCH OUTPUT
@@ -9969,7 +10208,8 @@ Standard planning cycle with full board review.
    **Security section guidance:** Each handoff includes a SECURITY CONSIDERATIONS section. Populate it when the task involves: data exposure risks (PII, secrets in logs/storage), secrets or credentials handling (API keys, tokens, env vars), auth/access control changes, or dependency security risks (new packages, version changes). For pure refactoring, documentation, prompt-text, or UI-only tasks, write "None \u2014 no security-relevant changes".
    **Estimation calibration:** Estimate **XS** for: copy/text-only changes, single string replacements, config tweaks, and any task where the scope is "change words in an existing file" with no logic changes. Estimate **S** for: wiring existing adapter methods, adding API routes following established patterns, modifying prompts, or documentation-only changes. Default to S for pattern-following work. Only use M when genuine new architecture, new DB tables, or multi-file architectural changes are needed. Historical data shows systematic over-estimation (198 over vs 8 under out of 528 tasks) \u2014 when in doubt, estimate smaller. If an "Estimation Calibration (Historical)" section is provided in the context below, use its data to adjust your estimates \u2014 it shows how often each estimated size matched the actual effort. Pay special attention to systematic over/under-estimation patterns (e.g. if M\u2192S happens frequently, estimate S instead of M for similar work).
    **Reference docs:** If a task's notes include a \`Reference:\` path (e.g. \`Reference: docs/architecture/papi-brain-v1.md\`), include a REFERENCE DOCS section in the BUILD HANDOFF with those paths. This tells the builder to read the referenced doc for background context before implementing. Do NOT omit or summarise the reference \u2014 pass it through so the builder can access the full document. Only tasks with explicit \`Reference:\` paths in their notes should have this section.
-   **Pre-build verification:** EVERY handoff MUST include a PRE-BUILD VERIFICATION section listing 2-5 specific file paths the builder should read before implementing. Derive these from FILES LIKELY TOUCHED \u2014 pick the files most likely to already contain the target functionality. This is the #1 prevention mechanism for wasted build slots (C120, C125, C126 all scheduled already-shipped work). If the builder finds >80% of the scope already implemented, they report "already built" instead of re-implementing.`);
+   **Pre-build verification:** EVERY handoff MUST include a PRE-BUILD VERIFICATION section listing 2-5 specific file paths the builder should read before implementing. Derive these from FILES LIKELY TOUCHED \u2014 pick the files most likely to already contain the target functionality. This is the #1 prevention mechanism for wasted build slots (C120, C125, C126 all scheduled already-shipped work). If the builder finds >80% of the scope already implemented, they report "already built" instead of re-implementing.
+   **Pre-mortem:** For projects with 10+ cycles, include a PRE-MORTEM section in every BUILD HANDOFF with 1-3 bullet points: (a) most likely technical blocker based on module history, (b) integration risk with adjacent systems, (c) scope creep signal \u2014 what the builder might be tempted to expand beyond scope. Draw from \`dead_ends\` and \`surprises\` in recent build reports for the same module. Omit this section entirely for projects with fewer than 10 cycles.`);
   if (flags.hasResearchTasks) parts.push(PLAN_FRAGMENT_RESEARCH);
   if (flags.hasBugTasks) parts.push(PLAN_FRAGMENT_BUG);
   if (flags.hasIdeaTasks) parts.push(PLAN_FRAGMENT_IDEA);
@@ -10632,6 +10872,9 @@ ACCEPTANCE CRITERIA
 [ ] [criterion 1]
 [ ] [criterion 2]
 
+PRE-MORTEM
+[For projects with 10+ cycles: 1-3 bullet points \u2014 most likely technical blocker, integration risk, scope creep signal. Omit for projects with fewer than 10 cycles.]
+
 SECURITY CONSIDERATIONS
 [or "None \u2014 no security-relevant changes"]
 
@@ -11521,7 +11764,7 @@ ${cleanContent}`;
     pendingRecIds = pending.map((r) => r.id);
   } catch {
   }
-  const handoffs2 = (data.cycleHandoffs ?? []).map((h) => {
+  const handoffs = (data.cycleHandoffs ?? []).map((h) => {
     const parsed = parseBuildHandoff(h.buildHandoff);
     if (parsed && !parsed.createdAt) {
       parsed.createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -11560,8 +11803,8 @@ ${cleanContent}`;
   } catch {
   }
   const effortMapLegacy = { XS: 1, S: 2, M: 3, L: 5, XL: 8 };
-  const legacyTaskCount = handoffs2.length;
-  const legacyEffortPoints = handoffs2.reduce((sum, h) => sum + (effortMapLegacy[h.handoff.effort] ?? 3), 0);
+  const legacyTaskCount = handoffs.length;
+  const legacyEffortPoints = handoffs.reduce((sum, h) => sum + (effortMapLegacy[h.handoff.effort] ?? 3), 0);
   const payload = {
     cycleNumber: newCycleNumber,
     cycleLog: {
@@ -11611,7 +11854,7 @@ ${cleanContent}`;
       body: ad.body
     })),
     pendingRecommendationIds: pendingRecIds,
-    handoffs: handoffs2,
+    handoffs,
     cycle,
     reviewedTaskIds
   };
@@ -11660,8 +11903,12 @@ async function writeBack(adapter2, _mode, cycleNumber, data, contextHashes) {
 
 ${cleanContent}`;
   const effortMap = { XS: 1, S: 2, M: 3, L: 5, XL: 8 };
-  const cycleTaskCount = handoffs.length;
-  const cycleEffortPoints = handoffs.reduce((sum, h) => sum + (effortMap[h.handoff.effort] ?? 3), 0);
+  const legacyHandoffs = (data.cycleHandoffs ?? []).map((h) => {
+    const parsed = parseBuildHandoff(h.buildHandoff);
+    return { taskId: h.taskId, handoff: parsed ?? { effort: "M" } };
+  });
+  const cycleTaskCount = legacyHandoffs.length;
+  const cycleEffortPoints = legacyHandoffs.reduce((sum, h) => sum + (effortMap[h.handoff.effort] ?? 3), 0);
   const cycleLogPromise = adapter2.writeCycleLogEntry({
     uuid: randomUUID7(),
     cycleNumber: newCycleNumber,
@@ -12063,7 +12310,7 @@ async function preparePlan(adapter2, config2, filters, focus, force, handoffsOnl
     const [decisions, reports, brief] = await Promise.all([
       adapter2.getActiveDecisions(),
       adapter2.getRecentBuildReports(10),
-      adapter2.getProductBrief()
+      adapter2.readProductBrief()
     ]);
     const northStar = await adapter2.getCurrentNorthStar?.() ?? "";
     const userMessage2 = buildHandoffsOnlyUserMessage({
@@ -12801,6 +13048,27 @@ async function assembleContext2(adapter2, cycleNumber, cyclesSinceLastReview, pr
     adapter2.searchDocs?.({ status: "active", limit: 10 })?.catch(() => []) ?? Promise.resolve([])
   ]);
   const tasks = [...activeTasks, ...recentDoneTasks];
+  const existingAdIds = new Set(decisions.map((d) => d.id));
+  const survivingPendingRecs = [];
+  for (const rec of pendingRecs) {
+    const isOrphaned = (() => {
+      if (rec.target && /^AD-\d+$/.test(rec.target) && !existingAdIds.has(rec.target)) return true;
+      if (rec.type === "ad_update") {
+        const adMatch = rec.content.match(/^(?:delete|resolve|confidence_change|supersede|modify):\s*(AD-\d+)/i);
+        if (adMatch && !existingAdIds.has(adMatch[1])) return true;
+      }
+      return false;
+    })();
+    if (isOrphaned) {
+      try {
+        await adapter2.dismissRecommendation?.(rec.id, "target AD no longer exists");
+        console.error(`[strategy_review] Swept orphaned pending rec ${rec.id} (target: ${rec.target ?? rec.content.slice(0, 50)})`);
+      } catch {
+      }
+    } else {
+      survivingPendingRecs.push(rec);
+    }
+  }
   const recentLog = log;
   let buildPatternsText;
   let reviewPatternsText;
@@ -12906,7 +13174,7 @@ ${lines.join("\n")}`;
   try {
     const plansDir = join2(homedir(), ".claude", "plans");
     if (existsSync(plansDir)) {
-      const lastReviewDate = previousStrategyReviews?.[0]?.date ? new Date(previousStrategyReviews[0].date) : /* @__PURE__ */ new Date(0);
+      const lastReviewDate = previousStrategyReviews?.[0]?.createdAt ? new Date(previousStrategyReviews[0].createdAt) : /* @__PURE__ */ new Date(0);
       const planFiles = readdirSync(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
         const fullPath = join2(plansDir, f);
         const stat2 = statSync(fullPath);
@@ -13150,7 +13418,7 @@ ${cleanContent}`;
       } else {
         await adapter2.updateActiveDecision(ad.id, ad.body, cycleNumber, ad.action);
       }
-      const eventType = ad.action === "delete" ? "deleted" : ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
+      const eventType = ad.action === "delete" ? "invalidated" : ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
       try {
         await adapter2.appendDecisionEvent({
           decisionId: ad.id,
@@ -13211,7 +13479,25 @@ ${cleanContent}`;
   try {
     const recs = extractRecommendations(data, cycleNumber);
     if (recs.length > 0) {
-      await Promise.all(recs.map((rec) => adapter2.writeRecommendation(rec)));
+      const existingAds = await adapter2.getActiveDecisions().catch(() => []);
+      const existingAdIds = new Set(existingAds.map((ad) => ad.id));
+      const filteredRecs = recs.filter((rec) => {
+        if (rec.target && /^AD-\d+$/.test(rec.target)) {
+          if (!existingAdIds.has(rec.target)) {
+            console.error(`[strategy_review] Skipped ghost recommendation for non-existent ${rec.target}: "${rec.content.slice(0, 80)}"`);
+            return false;
+          }
+        }
+        if (rec.type === "ad_update") {
+          const adMatch = rec.content.match(/^(?:delete|resolve|confidence_change|supersede|modify):\s*(AD-\d+)/i);
+          if (adMatch && !existingAdIds.has(adMatch[1])) {
+            console.error(`[strategy_review] Skipped ghost recommendation for non-existent ${adMatch[1]}: "${rec.content.slice(0, 80)}"`);
+            return false;
+          }
+        }
+        return true;
+      });
+      await Promise.all(filteredRecs.map((rec) => adapter2.writeRecommendation(rec)));
     }
   } catch {
   }
@@ -13293,6 +13579,17 @@ async function processReviewOutput(adapter2, rawOutput, cycleNumber) {
   let slackWarning;
   let writeBackFailed;
   let phaseChanges;
+  if (!data) {
+    const marker = "<!-- PAPI_STRUCTURED_OUTPUT -->";
+    const hasMarker = rawOutput.includes(marker);
+    if (hasMarker) {
+      const afterMarker = rawOutput.slice(rawOutput.indexOf(marker) + marker.length, rawOutput.indexOf(marker) + marker.length + 300).trim();
+      writeBackFailed = `Structured output marker found but JSON block was missing or malformed. Content after marker (first 300 chars): "${afterMarker}". Ensure your output includes a valid \`\`\`json block after <!-- PAPI_STRUCTURED_OUTPUT -->.`;
+    } else {
+      const preview = rawOutput.slice(0, 200).trim();
+      writeBackFailed = `No structured output marker found. Expected "<!-- PAPI_STRUCTURED_OUTPUT -->" followed by a \`\`\`json block. Received (first 200 chars): "${preview}". Re-run strategy_review apply with the complete output including both parts.`;
+    }
+  }
   if (data) {
     try {
       phaseChanges = await writeBack2(adapter2, cycleNumber, data, displayText);
@@ -13516,8 +13813,8 @@ async function formatHierarchyForReview(adapter2, currentCycle, prefetchedTasks)
   let phases = [];
   try {
     [horizons, stages, phases] = await Promise.all([
-      adapter2.readHorizons(),
-      adapter2.readStages(),
+      adapter2.readHorizons?.() ?? [],
+      adapter2.readStages?.() ?? [],
       adapter2.readPhases()
     ]);
   } catch {
@@ -13650,7 +13947,7 @@ ${cleanContent}`;
           } else {
             await adapter2.updateActiveDecision(ad.id, ad.body, cycleNumber, ad.action);
           }
-          const eventType = ad.action === "delete" ? "deleted" : ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
+          const eventType = ad.action === "delete" ? "invalidated" : ad.action === "confidence_change" ? "confidence_changed" : ad.action === "supersede" ? "superseded" : ad.action === "new" ? "created" : "modified";
           try {
             await adapter2.appendDecisionEvent({
               decisionId: ad.id,
@@ -13763,7 +14060,7 @@ async function captureDecision(adapter2, input) {
       decisionId: adId,
       eventType: adAction === "created" ? "created" : "modified",
       cycle: cycleNumber,
-      source: "strategy_capture",
+      source: "strategy_change",
       sourceRef: `cycle-${cycleNumber}-capture`,
       detail: `Captured: ${input.text.slice(0, 200)}`
     });
@@ -14264,10 +14561,10 @@ function formatBoard(result) {
     t.title,
     t.status,
     t.cycle != null ? String(t.cycle) : "-",
-    t.phase,
-    t.module,
-    t.epic,
-    t.complexity,
+    t.phase ?? "-",
+    t.module ?? "-",
+    t.epic ?? "-",
+    t.complexity ?? "-",
     t.createdAt ?? "-"
   ]);
   const widths = headers.map(
@@ -14486,7 +14783,45 @@ async function handleBoardEdit(adapter2, args) {
 // src/services/setup.ts
 init_dist2();
 import { mkdir, writeFile as writeFile2, readFile as readFile3, readdir, access as access2, stat } from "fs/promises";
-import { join as join3, basename, extname } from "path";
+import { join as join4, basename, extname } from "path";
+
+// src/lib/detect-codebase.ts
+import { existsSync as existsSync2 } from "fs";
+import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+function detectCodebaseType(projectRoot) {
+  if (existsSync2(join3(projectRoot, ".git"))) {
+    return "existing_codebase";
+  }
+  const manifests = [
+    "package.json",
+    "Cargo.toml",
+    "pyproject.toml",
+    "go.mod",
+    "Gemfile",
+    "pom.xml",
+    "build.gradle",
+    "CMakeLists.txt"
+  ];
+  for (const manifest of manifests) {
+    if (existsSync2(join3(projectRoot, manifest))) {
+      return "existing_codebase";
+    }
+  }
+  try {
+    const entries = readdirSync2(projectRoot).filter((f) => !f.startsWith("."));
+    const fileCount = entries.filter((f) => {
+      try {
+        return statSync2(join3(projectRoot, f)).isFile();
+      } catch {
+        return false;
+      }
+    }).length;
+    if (fileCount > 5) return "existing_codebase";
+  } catch {
+  }
+  return "new_project";
+}
 
 // src/templates.ts
 var PLANNING_LOG_TEMPLATE = `# PAPI Planning Log
@@ -15079,7 +15414,7 @@ async function scaffoldPapiDir(adapter2, config2, input) {
       await mkdir(config2.papiDir, { recursive: true });
       for (const [filename, template] of Object.entries(FILE_TEMPLATES)) {
         const content = substitute(template, vars);
-        await writeFile2(join3(config2.papiDir, filename), content, "utf-8");
+        await writeFile2(join4(config2.papiDir, filename), content, "utf-8");
       }
     }
   } else {
@@ -15094,18 +15429,18 @@ async function scaffoldPapiDir(adapter2, config2, input) {
     } catch {
     }
   }
-  const commandsDir = join3(config2.projectRoot, ".claude", "commands");
-  const docsDir = join3(config2.projectRoot, "docs");
+  const commandsDir = join4(config2.projectRoot, ".claude", "commands");
+  const docsDir = join4(config2.projectRoot, "docs");
   await mkdir(commandsDir, { recursive: true });
   await mkdir(docsDir, { recursive: true });
-  const claudeMdPath = join3(config2.projectRoot, "CLAUDE.md");
+  const claudeMdPath = join4(config2.projectRoot, "CLAUDE.md");
   let claudeMdExists = false;
   try {
     await access2(claudeMdPath);
     claudeMdExists = true;
   } catch {
   }
-  const docsIndexPath = join3(docsDir, "INDEX.md");
+  const docsIndexPath = join4(docsDir, "INDEX.md");
   let docsIndexExists = false;
   try {
     await access2(docsIndexPath);
@@ -15113,9 +15448,9 @@ async function scaffoldPapiDir(adapter2, config2, input) {
   } catch {
   }
   const scaffoldFiles = {
-    [join3(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
-    [join3(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
-    [join3(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
+    [join4(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
+    [join4(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
+    [join4(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
   };
   if (!docsIndexExists) {
     scaffoldFiles[docsIndexPath] = substitute(DOCS_INDEX_TEMPLATE, vars);
@@ -15132,7 +15467,7 @@ async function scaffoldPapiDir(adapter2, config2, input) {
     } catch {
     }
   }
-  const cursorDir = join3(config2.projectRoot, ".cursor");
+  const cursorDir = join4(config2.projectRoot, ".cursor");
   let cursorDetected = false;
   try {
     await access2(cursorDir);
@@ -15140,8 +15475,8 @@ async function scaffoldPapiDir(adapter2, config2, input) {
   } catch {
   }
   if (cursorDetected) {
-    const cursorRulesDir = join3(cursorDir, "rules");
-    const cursorRulesPath = join3(cursorRulesDir, "papi.mdc");
+    const cursorRulesDir = join4(cursorDir, "rules");
+    const cursorRulesPath = join4(cursorRulesDir, "papi.mdc");
     await mkdir(cursorRulesDir, { recursive: true });
     try {
       await access2(cursorRulesPath);
@@ -15167,7 +15502,7 @@ async function scaffoldPapiDir(adapter2, config2, input) {
 }
 var PAPI_PERMISSION = "mcp__papi__*";
 async function ensurePapiPermission(projectRoot) {
-  const settingsPath = join3(projectRoot, ".claude", "settings.json");
+  const settingsPath = join4(projectRoot, ".claude", "settings.json");
   try {
     let settings = {};
     try {
@@ -15186,14 +15521,14 @@ async function ensurePapiPermission(projectRoot) {
     if (!allow.includes(PAPI_PERMISSION)) {
       allow.push(PAPI_PERMISSION);
     }
-    await mkdir(join3(projectRoot, ".claude"), { recursive: true });
+    await mkdir(join4(projectRoot, ".claude"), { recursive: true });
     await writeFile2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 async function applySetupOutputs(adapter2, config2, input, briefText, adSeedText, conventionsText) {
   if (config2.adapterType !== "pg") {
-    await writeFile2(join3(config2.papiDir, "PRODUCT_BRIEF.md"), briefText, "utf-8");
+    await writeFile2(join4(config2.papiDir, "PRODUCT_BRIEF.md"), briefText, "utf-8");
   }
   await adapter2.updateProductBrief(briefText);
   const briefPhases = parsePhases(briefText);
@@ -15227,7 +15562,12 @@ async function applySetupOutputs(adapter2, config2, input, briefText, adSeedText
       if (Array.isArray(ads)) {
         for (const ad of ads) {
           if (ad.id && ad.body) {
-            await adapter2.updateActiveDecision(ad.id, ad.body, 0);
+            if (adapter2.upsertActiveDecision) {
+              const title = ad.title || ad.body.split("\n")[0].replace(/^#+\s*/, "").slice(0, 120);
+              await adapter2.upsertActiveDecision(ad.id, ad.body, title, ad.confidence || "MEDIUM", 0);
+            } else {
+              await adapter2.updateActiveDecision(ad.id, ad.body, 0);
+            }
             seededAds++;
           }
         }
@@ -15237,7 +15577,7 @@ async function applySetupOutputs(adapter2, config2, input, briefText, adSeedText
   }
   if (conventionsText?.trim()) {
     try {
-      const claudeMdPath = join3(config2.projectRoot, "CLAUDE.md");
+      const claudeMdPath = join4(config2.projectRoot, "CLAUDE.md");
       const existing = await readFile3(claudeMdPath, "utf-8");
       await writeFile2(claudeMdPath, existing + "\n" + conventionsText.trim() + "\n", "utf-8");
     } catch {
@@ -15305,13 +15645,13 @@ async function scanCodebase(projectRoot) {
   }
   let packageJson;
   try {
-    const content = await readFile3(join3(projectRoot, "package.json"), "utf-8");
+    const content = await readFile3(join4(projectRoot, "package.json"), "utf-8");
     packageJson = JSON.parse(content);
   } catch {
   }
   let readme;
   for (const name of ["README.md", "readme.md", "README.txt", "README"]) {
-    const content = await safeReadFile(join3(projectRoot, name), 5e3);
+    const content = await safeReadFile(join4(projectRoot, name), 5e3);
     if (content) {
       readme = content;
       break;
@@ -15321,7 +15661,7 @@ async function scanCodebase(projectRoot) {
   let totalFiles = topLevelFiles.length;
   for (const dir of topLevelDirs) {
     try {
-      const entries = await readdir(join3(projectRoot, dir), { withFileTypes: true });
+      const entries = await readdir(join4(projectRoot, dir), { withFileTypes: true });
       const files = entries.filter((e) => e.isFile());
       const extensions = [...new Set(files.map((f) => extname(f.name).toLowerCase()).filter(Boolean))];
       totalFiles += files.length;
@@ -15400,16 +15740,19 @@ async function prepareSetup(adapter2, config2, input) {
     existingBrief = await adapter2.readProductBrief();
   } catch {
     throw new Error(
-      config2.adapterType === "pg" ? "Could not read Product Brief from database. Check DATABASE_URL and PAPI_PROJECT_ID are set correctly in your MCP config." : "Could not read PRODUCT_BRIEF.md. Ensure .papi/ directory exists."
+      config2.adapterType === "proxy" ? "Could not read Product Brief from PAPI. Check PAPI_DATA_API_KEY and PAPI_PROJECT_ID are set correctly in your MCP config." : config2.adapterType === "pg" ? "Could not read Product Brief from database. Check DATABASE_URL and PAPI_PROJECT_ID are set correctly in your MCP config." : "Could not read PRODUCT_BRIEF.md. Ensure .papi/ directory exists."
     );
   }
   const TEMPLATE_MARKER = "*Describe your project's core value proposition here.*";
   if (existingBrief.trim() && !existingBrief.includes(TEMPLATE_MARKER) && !input.force) {
     throw new Error("PRODUCT_BRIEF.md already contains a generated Product Brief. Running setup again would overwrite it.\n\nTo proceed anyway, run setup with force: true.");
   }
+  const detectedCodebaseType = detectCodebaseType(config2.projectRoot);
+  const autoDetected = input.existingProject === void 0 || input.existingProject === false;
+  const isExistingProject = input.existingProject === true || autoDetected && detectedCodebaseType === "existing_codebase";
   let codebaseSummary;
   let sourceContents;
-  if (input.existingProject) {
+  if (isExistingProject) {
     const scan = await scanCodebase(config2.projectRoot);
     if (input.sources) {
       sourceContents = await readSourceFiles(input.sources);
@@ -15452,7 +15795,7 @@ async function prepareSetup(adapter2, config2, input) {
       constraints: input.constraints
     })
   } : void 0;
-  const initialTasksPrompt = input.existingProject && codebaseSummary ? {
+  const initialTasksPrompt = isExistingProject && codebaseSummary ? {
     system: INITIAL_TASKS_SYSTEM,
     user: buildInitialTasksPrompt({
       projectName: input.projectName,
@@ -15468,7 +15811,9 @@ async function prepareSetup(adapter2, config2, input) {
     adSeedPrompt,
     conventionsPrompt,
     initialTasksPrompt,
-    codebaseSummary
+    codebaseSummary,
+    detectedCodebaseType,
+    autoDetected: autoDetected && detectedCodebaseType !== "new_project"
   };
 }
 async function applySetup(adapter2, config2, input, briefText, adSeedText, conventionsText, initialTasksText) {
@@ -15507,7 +15852,7 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
     }
   }
   try {
-    const claudeMdPath = join3(config2.projectRoot, "CLAUDE.md");
+    const claudeMdPath = join4(config2.projectRoot, "CLAUDE.md");
     const existing = await readFile3(claudeMdPath, "utf-8");
     if (!existing.includes("Dogfood Logging")) {
       const dogfoodSection = [
@@ -15551,7 +15896,7 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
   }
   let cursorScaffolded = false;
   try {
-    await access2(join3(config2.projectRoot, ".cursor", "rules", "papi.mdc"));
+    await access2(join4(config2.projectRoot, ".cursor", "rules", "papi.mdc"));
     cursorScaffolded = true;
   } catch {
   }
@@ -15712,14 +16057,25 @@ PAPI needs just 3 things: project name, what it does, and who it's for.`
       if (!args.project_type) inferredDefaults.push(`- **Project type:** defaulted to "${input.projectType}"`);
       if (!args.team_size) inferredDefaults.push(`- **Team size:** defaulted to "${input.teamSize}"`);
       if (!args.deployment_target) inferredDefaults.push(`- **Deployment:** defaulted to "${input.deploymentTarget}"`);
-      const isExisting = input.existingProject;
+      const isExisting = result.detectedCodebaseType === "existing_codebase";
       const sections = [
-        isExisting ? `## PAPI Setup \u2014 Adopt Existing Project (Prepare Phase)` : `## PAPI Setup \u2014 Prepare Phase`,
+        isExisting ? `## PAPI Setup \u2014 Adopt Existing Project (Prepare Phase)` : `## PAPI Setup \u2014 New Project (Prepare Phase)`,
         "",
         result.createdProject ? config2.adapterType === "md" ? `Project "${result.projectName}" scaffolded \u2014 .papi/ directory created.
 ` : `Project "${result.projectName}" scaffolded \u2014 database tables created.
 ` : ""
       ];
+      if (result.autoDetected) {
+        sections.push(
+          `**Codebase detected:** Existing codebase found \u2014 running in adoption mode. If this is wrong, re-run setup with \`existing_project: false\`.`,
+          ""
+        );
+      } else if (result.detectedCodebaseType === "new_project" && input.existingProject === void 0) {
+        sections.push(
+          `**Codebase detected:** Fresh project \u2014 running in new project mode. If you have existing code, re-run setup with \`existing_project: true\`.`,
+          ""
+        );
+      }
       if (inferredDefaults.length > 0) {
         sections.push(
           `**Defaults applied** (override by re-running setup with these fields):`,
@@ -15817,9 +16173,10 @@ ${result.initialTasksPrompt.user}
 init_dist2();
 
 // src/services/build.ts
+init_git();
 import { randomUUID as randomUUID9 } from "crypto";
-import { readdirSync as readdirSync2, existsSync as existsSync2, readFileSync } from "fs";
-import { join as join4 } from "path";
+import { readdirSync as readdirSync3, existsSync as existsSync3, readFileSync } from "fs";
+import { join as join5 } from "path";
 function capitalizeCompleted(value) {
   const map = {
     yes: "Yes",
@@ -16220,14 +16577,14 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
   let docWarning;
   try {
     if (adapter2.searchDocs) {
-      const docsDir = join4(config2.projectRoot, "docs");
-      if (existsSync2(docsDir)) {
+      const docsDir = join5(config2.projectRoot, "docs");
+      if (existsSync3(docsDir)) {
         const scanDir = (dir, depth = 0) => {
           if (depth > 8) return [];
-          const entries = readdirSync2(dir, { withFileTypes: true });
+          const entries = readdirSync3(dir, { withFileTypes: true });
           const files = [];
           for (const e of entries) {
-            const full = join4(dir, e.name);
+            const full = join5(dir, e.name);
             if (e.isDirectory() && !e.isSymbolicLink()) files.push(...scanDir(full, depth + 1));
             else if (e.name.endsWith(".md")) files.push(full.replace(config2.projectRoot + "/", ""));
           }
@@ -16242,7 +16599,7 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
           const failed = [];
           for (const docPath of unregistered) {
             try {
-              const meta = extractDocMeta(join4(config2.projectRoot, docPath), docPath, cycleNumber);
+              const meta = extractDocMeta(join5(config2.projectRoot, docPath), docPath, cycleNumber);
               await adapter2.registerDoc({
                 title: meta.title,
                 type: meta.type,
@@ -16821,6 +17178,9 @@ Reason: ${result.reason}`);
   }
 }
 
+// src/tools/idea.ts
+init_git();
+
 // src/services/idea.ts
 import { randomUUID as randomUUID10 } from "crypto";
 var ROUTING_PATTERNS = [
@@ -17273,6 +17633,9 @@ Re-submit with \`notes: "... Reference: <path>"\` to link one, or ignore if none
   return textResponse(result.message);
 }
 
+// src/tools/bug.ts
+init_git();
+
 // src/services/bug.ts
 import { randomUUID as randomUUID11 } from "crypto";
 function resolveCurrentPhase2(phases) {
@@ -17395,6 +17758,9 @@ async function handleBug(adapter2, config2, args) {
   return textResponse(`\u{1F41B} ${task.id}: "${task.title}" \u2014 ${severityLabel} bug added to backlog${branchNote}. Will be picked up by next plan.${truncateWarning}`);
 }
 
+// src/tools/ad-hoc.ts
+init_git();
+
 // src/services/ad-hoc.ts
 import { randomUUID as randomUUID12 } from "crypto";
 async function recordAdHoc(adapter2, input) {
@@ -17531,6 +17897,9 @@ async function handleAdHoc(adapter2, config2, args) {
   );
 }
 
+// src/tools/board-reconcile.ts
+init_git();
+
 // src/services/reconcile.ts
 async function prepareReconcile(adapter2) {
   const health = await adapter2.getCycleHealth();
@@ -17586,15 +17955,15 @@ async function prepareReconcile(adapter2) {
     const misaligned = allTasks.filter((t) => {
       const mapping = phaseStageMap.get(t.phase ?? "");
       if (!mapping) return false;
-      return mapping.stage.status === "Not Started" || mapping.horizon.status === "Not Started";
+      return mapping.stage.status === "deferred" || mapping.horizon.status === "deferred";
     });
     if (misaligned.length > 0) {
-      lines.push("### Hierarchy Misalignment (tasks in Not Started stages/horizons)");
+      lines.push("### Hierarchy Misalignment (tasks in deferred stages/horizons)");
       for (const t of misaligned) {
         const mapping = phaseStageMap.get(t.phase ?? "");
         const stageLabel = mapping?.stage.label ?? "unknown";
         const horizonLabel = mapping?.horizon.label ?? "unknown";
-        lines.push(`- **${t.id}:** ${t.title} \u2014 phase "${t.phase}" belongs to **${stageLabel}** (${horizonLabel}), which is Not Started. Consider deferring or reassigning.`);
+        lines.push(`- **${t.id}:** ${t.title} \u2014 phase "${t.phase}" belongs to **${stageLabel}** (${horizonLabel}), which is deferred. Consider deferring or reassigning.`);
       }
       lines.push("");
     }
@@ -17764,7 +18133,7 @@ async function prepareRetriage(adapter2) {
   lines.push(`**${allTasks.length} tasks** to reassess priority and complexity.`);
   lines.push("");
   try {
-    const ads = await adapter2.readActiveDecisions();
+    const ads = await adapter2.getActiveDecisions();
     if (ads.length > 0) {
       lines.push("### Active Decisions (strategic context)");
       for (const ad of ads.slice(0, 10)) {
@@ -18098,6 +18467,53 @@ Assess each task above and produce your retriage output. Then call \`board_recon
 }
 
 // src/services/health.ts
+function computeHealthScore(cycleNumber, snapshots, activeTasks, decisionUsage) {
+  if (cycleNumber < 3) return null;
+  const scores = [];
+  const recentSnaps = snapshots.slice(-3);
+  const baselineSnaps = snapshots.slice(-10);
+  if (recentSnaps.length > 0 && baselineSnaps.length > 0) {
+    const avg = (snaps) => snaps.reduce((s, sn) => s + (sn.velocity[0]?.effortPoints ?? 0), 0) / snaps.length;
+    const recentAvg = avg(recentSnaps);
+    const baselineAvg = avg(baselineSnaps);
+    const velocityScore = baselineAvg > 0 ? Math.min(100, Math.round(recentAvg / baselineAvg * 100)) : 50;
+    scores.push({ name: "Velocity", score: velocityScore, weight: 0.25 });
+  } else {
+    scores.push({ name: "Velocity", score: 50, weight: 0.25 });
+  }
+  if (recentSnaps.length > 0) {
+    const avgMatchRate = recentSnaps.reduce((s, sn) => s + (sn.accuracy[0]?.matchRate ?? 0), 0) / recentSnaps.length;
+    scores.push({ name: "Estimation accuracy", score: Math.round(avgMatchRate), weight: 0.25 });
+  } else {
+    scores.push({ name: "Estimation accuracy", score: 50, weight: 0.25 });
+  }
+  const inReviewCount = activeTasks.filter((t) => t.status === "In Review").length;
+  const reviewScore = inReviewCount === 0 ? 100 : inReviewCount <= 2 ? 60 : 20;
+  scores.push({ name: "Review throughput", score: reviewScore, weight: 0.2 });
+  const backlogTasks = activeTasks.filter((t) => t.status === "Backlog");
+  if (backlogTasks.length > 0) {
+    const criticalCount = backlogTasks.filter(
+      (t) => t.priority === "P0 Critical" || t.priority === "P1 High"
+    ).length;
+    const criticalRatio = criticalCount / backlogTasks.length;
+    const backlogScore = criticalRatio > 0.5 ? 40 : criticalRatio > 0.3 ? 70 : 90;
+    scores.push({ name: "Backlog health", score: backlogScore, weight: 0.15 });
+  } else {
+    scores.push({ name: "Backlog health", score: 80, weight: 0.15 });
+  }
+  if (decisionUsage.length > 0) {
+    const staleCount = decisionUsage.filter((u) => u.cyclesSinceLastReference >= 10).length;
+    const freshRatio = (decisionUsage.length - staleCount) / decisionUsage.length;
+    scores.push({ name: "AD freshness", score: Math.round(freshRatio * 100), weight: 0.15 });
+  } else {
+    scores.push({ name: "AD freshness", score: 70, weight: 0.15 });
+  }
+  const totalScore = Math.round(scores.reduce((sum, s) => sum + s.score * s.weight, 0));
+  const status = totalScore >= 70 ? "GREEN" : totalScore >= 50 ? "AMBER" : "RED";
+  const worst = scores.reduce((min, s) => s.score < min.score ? s : min, scores[0]);
+  const reason = status === "GREEN" ? "All components healthy" : `${worst.name} below target (${worst.score}/100)`;
+  return { score: totalScore, status, reason };
+}
 function countByStatus(tasks) {
   const counts = /* @__PURE__ */ new Map();
   for (const task of tasks) {
@@ -18175,8 +18591,8 @@ async function getHealthSummary(adapter2) {
   }
   let metricsSection;
   let derivedMetricsSection = "";
+  let snapshots = [];
   try {
-    let snapshots = [];
     try {
       const reports = await adapter2.getRecentBuildReports(50);
       snapshots = computeSnapshotsFromBuildReports(reports);
@@ -18208,8 +18624,10 @@ async function getHealthSummary(adapter2) {
   }
   const costSection = "Disabled \u2014 local MCP, no API costs.";
   let decisionUsageSection = "";
+  let decisionUsageEntries = [];
   try {
     const usage = await adapter2.getDecisionUsage(cycleNumber);
+    decisionUsageEntries = usage;
     if (usage.length > 0) {
       const stale = usage.filter((u) => u.cyclesSinceLastReference >= 5);
       if (stale.length > 0) {
@@ -18264,6 +18682,7 @@ ${lines.join("\n")}`;
     }
   } catch {
   }
+  const healthResult = computeHealthScore(cycleNumber, snapshots, activeTasks, decisionUsageEntries);
   return {
     cycleNumber,
     latestCycleStatus: health.latestCycleStatus,
@@ -18281,7 +18700,10 @@ ${lines.join("\n")}`;
     decisionLifecycleSection,
     decisionScoresSection,
     contextUtilisationSection,
-    northStarSection
+    northStarSection,
+    healthScore: healthResult?.score ?? null,
+    healthStatus: healthResult?.status ?? null,
+    healthReason: healthResult?.reason ?? null
   };
 }
 
@@ -18378,8 +18800,9 @@ async function handleHealth(adapter2) {
 }
 
 // src/services/release.ts
+init_git();
 import { writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var INITIAL_RELEASE_NOTES = `# Changelog
 
 ## v0.1.0-alpha \u2014 Initial Release
@@ -18470,7 +18893,7 @@ async function createRelease(config2, branch, version, adapter2) {
     const commits = getCommitsSinceTag(config2.projectRoot, latestTag);
     changelogContent = generateChangelog(version, commits);
   }
-  const changelogPath = join5(config2.projectRoot, "CHANGELOG.md");
+  const changelogPath = join6(config2.projectRoot, "CHANGELOG.md");
   await writeFile3(changelogPath, changelogContent, "utf-8");
   const commitResult = stageAllAndCommit(config2.projectRoot, `release: ${version}`);
   const commitNote = commitResult.committed ? `Committed CHANGELOG.md.` : `CHANGELOG.md: ${commitResult.message}`;
@@ -18566,8 +18989,9 @@ async function handleRelease(adapter2, config2, args) {
 }
 
 // src/tools/review.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+init_git();
 
 // src/services/review.ts
 init_dist2();
@@ -18805,8 +19229,8 @@ function mergeAfterAccept(config2, taskId) {
   }
   const featureBranch = taskBranchName(taskId);
   const baseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
-  const papiDir = join6(config2.projectRoot, ".papi");
-  if (existsSync3(papiDir)) {
+  const papiDir = join7(config2.projectRoot, ".papi");
+  if (existsSync4(papiDir)) {
     try {
       const commitResult = stageDirAndCommit(
         config2.projectRoot,
@@ -19044,6 +19468,7 @@ async function handleInit(config2, args) {
   const mcpJsonPath = path4.join(projectRoot, ".mcp.json");
   const force = args.force === true;
   const projectName = args.project_name?.trim() || path4.basename(projectRoot);
+  const usingCwdDefault = !process.env.PAPI_PROJECT_DIR && process.argv.indexOf("--project") === -1;
   let existingConfig = null;
   try {
     await access3(mcpJsonPath);
@@ -19070,44 +19495,93 @@ Path: ${mcpJsonPath}`
       }
     }
   }
-  const projectId = randomUUID14();
-  const mcpConfig = {
-    mcpServers: {
-      papi: {
-        command: "npx",
-        args: ["-y", "@papi-ai/server"],
-        env: {
-          PAPI_PROJECT_DIR: projectRoot,
-          PAPI_ADAPTER: "pg",
-          DATABASE_URL: "<YOUR_DATABASE_URL>",
-          PAPI_PROJECT_ID: projectId
+  const existingApiKey = process.env.PAPI_DATA_API_KEY;
+  const existingProjectId = process.env.PAPI_PROJECT_ID;
+  const isProxyUser = Boolean(existingApiKey) || config2.adapterType === "proxy";
+  const isDatabaseUser = Boolean(process.env.DATABASE_URL) || config2.adapterType === "pg";
+  if (isProxyUser && existingApiKey && existingProjectId) {
+    const mcpConfig = {
+      mcpServers: {
+        papi: {
+          command: "npx",
+          args: ["-y", "@papi-ai/server"],
+          env: {
+            PAPI_PROJECT_ID: existingProjectId,
+            PAPI_DATA_API_KEY: existingApiKey
+          }
+        }
+      }
+    };
+    await writeFile4(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
+    await ensureGitignoreEntry(projectRoot, ".mcp.json");
+    return textResponse(
+      `# PAPI Initialised \u2014 ${projectName}
+
+**Config:** \`${mcpJsonPath}\`
+
+Your existing API key and project ID have been saved to .mcp.json.
+
+## Next Steps
+
+1. **Restart your MCP client** to pick up the new config.
+2. **Run \`setup\`** \u2014 this scaffolds your project with a Product Brief and CLAUDE.md.
+`
+    );
+  }
+  if (isDatabaseUser) {
+    const projectId = randomUUID14();
+    const mcpConfig = {
+      mcpServers: {
+        papi: {
+          command: "npx",
+          args: ["-y", "@papi-ai/server"],
+          env: {
+            PAPI_PROJECT_DIR: projectRoot,
+            PAPI_ADAPTER: "pg",
+            DATABASE_URL: process.env.DATABASE_URL || "<YOUR_DATABASE_URL>",
+            PAPI_PROJECT_ID: projectId
+          }
         }
       }
-    }
-  };
-  await writeFile4(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
-  await ensureGitignoreEntry(projectRoot, ".mcp.json");
+    };
+    await writeFile4(mcpJsonPath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
+    await ensureGitignoreEntry(projectRoot, ".mcp.json");
+    const output2 = [
+      `# PAPI Initialised \u2014 ${projectName}`,
+      "",
+      `**Project ID:** \`${projectId}\``,
+      `**Config:** \`${mcpJsonPath}\``,
+      "",
+      "## Next Steps",
+      "",
+      ...process.env.DATABASE_URL ? ["1. **Restart your MCP client** to pick up the new config."] : ["1. **Set your DATABASE_URL** \u2014 replace `<YOUR_DATABASE_URL>` in `.mcp.json` with your Supabase connection string."],
+      "2. **Run `setup`** \u2014 this scaffolds your project with a Product Brief, Active Decisions, and CLAUDE.md."
+    ].join("\n");
+    return textResponse(output2);
+  }
   const output = [
-    `# PAPI Initialised \u2014 ${projectName}`,
+    `# PAPI \u2014 Account Required`,
     "",
-    `**Project ID:** \`${projectId}\``,
-    `**Config:** \`${mcpJsonPath}\``,
+    `PAPI needs an account to store your project data.`,
     "",
-    "## Next Steps",
+    "## Get Started in 3 Steps",
     "",
-    "1. **Set your DATABASE_URL** \u2014 replace `<YOUR_DATABASE_URL>` in `.mcp.json` with the connection string provided to you.",
-    "2. **Restart Claude Code** \u2014 it will detect the new MCP server on restart.",
-    "3. **Run `setup`** \u2014 this scaffolds your project with a Product Brief, Active Decisions, and CLAUDE.md.",
+    "1. **Sign up** at https://getpapi.ai/login",
+    "2. **Complete the onboarding wizard** \u2014 it generates your `.mcp.json` config with your API key and project ID",
+    "3. **Download the config**, place it in your project root, and restart your MCP client",
     "",
-    "> `.mcp.json` uses `npx @papi-ai/server` \u2014 no local paths to maintain. See `docs/install-guide.md` for multi-client configs."
+    "The onboarding wizard generates everything you need \u2014 no manual configuration required.",
+    "",
+    `> Already have an account? Make sure both \`PAPI_PROJECT_ID\` and \`PAPI_DATA_API_KEY\` are set in your .mcp.json.`
   ].join("\n");
   return textResponse(output);
 }
 
 // src/tools/orient.ts
+init_git();
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync5 } from "fs";
+import { join as join8 } from "path";
 var orientTool = {
   name: "orient",
   description: "Session orientation \u2014 run this FIRST at session start before any other tool. Single call that replaces build_list + health. Returns: cycle number, task counts by status, in-progress/in-review tasks, strategy review cadence, velocity snapshot, recommended next action, and a release reminder when all cycle tasks are Done but release has not run. Read-only, does not modify any files.",
@@ -19117,7 +19591,7 @@ var orientTool = {
     required: []
   }
 };
-function formatOrientSummary(health, buildInfo, hierarchy, latestTag) {
+function formatOrientSummary(health, buildInfo, hierarchy, latestTag, projectRoot) {
   const lines = [];
   const cycleIsComplete = health.latestCycleStatus === "complete";
   const tagSuffix = latestTag ? ` \u2014 ${latestTag}` : "";
@@ -19156,6 +19630,11 @@ function formatOrientSummary(health, buildInfo, hierarchy, latestTag) {
     lines.push(`**North Star:** ${health.northStarSection}`);
     lines.push("");
   }
+  if (health.healthScore !== null && health.healthStatus !== null) {
+    const icon = health.healthStatus === "GREEN" ? "\u{1F7E2}" : health.healthStatus === "AMBER" ? "\u{1F7E1}" : "\u{1F534}";
+    lines.push(`**Health:** ${icon} ${health.healthStatus} (${health.healthScore}/100) \u2014 ${health.healthReason}`);
+    lines.push("");
+  }
   lines.push("## Board");
   lines.push(health.boardSummary);
   lines.push("");
@@ -19184,7 +19663,16 @@ function formatOrientSummary(health, buildInfo, hierarchy, latestTag) {
   }
   if (buildInfo.isEmpty) {
     lines.push("## Tasks");
-    lines.push(buildInfo.currentCycle === 0 ? "No tasks found \u2014 run `setup` then `plan` to create your first cycle." : "Board is empty \u2014 run `plan` to create your next cycle.");
+    if (buildInfo.currentCycle === 0) {
+      const codebaseType = projectRoot ? detectCodebaseType(projectRoot) : "new_project";
+      if (codebaseType === "existing_codebase") {
+        lines.push("No tasks found. Existing codebase detected \u2014 run `setup existing_project: true` to analyse your project structure, generate a Product Brief and initial backlog, then `plan` to start your first cycle.");
+      } else {
+        lines.push("No tasks found. Fresh project \u2014 run `setup` to define your Product Brief, then `plan` to create your first cycle.");
+      }
+    } else {
+      lines.push("Board is empty \u2014 run `plan` to create your next cycle.");
+    }
     lines.push("");
   } else if (buildInfo.noHandoffs) {
     lines.push("## Tasks");
@@ -19222,15 +19710,15 @@ function formatOrientSummary(health, buildInfo, hierarchy, latestTag) {
 async function getHierarchyPosition(adapter2) {
   try {
     const [horizons, stages, phases, allTasks] = await Promise.all([
-      adapter2.readHorizons(),
-      adapter2.readStages(),
+      adapter2.readHorizons?.() ?? [],
+      adapter2.readStages?.() ?? [],
       adapter2.readPhases(),
       adapter2.queryBoard()
     ]);
     if (horizons.length === 0) return void 0;
-    const activeHorizon = horizons.find((h) => h.status === "Active") || horizons[0];
+    const activeHorizon = horizons.find((h) => h.status === "active") || horizons[0];
     const activeStages = stages.filter((s) => s.horizonId === activeHorizon.id);
-    const activeStage = activeStages.find((s) => s.status === "Active") || activeStages[0];
+    const activeStage = activeStages.find((s) => s.status === "active") || activeStages[0];
     if (!activeStage) return void 0;
     const stagePhases = phases.filter((p) => p.stageId === activeStage.id);
     const activePhases = stagePhases.filter((p) => p.status === "In Progress");
@@ -19271,7 +19759,7 @@ function getLatestGitTag(projectRoot) {
 }
 function checkNpmVersionDrift() {
   try {
-    const pkgPath = join7(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
+    const pkgPath = join8(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     const localVersion = pkg.version;
     const packageName = pkg.name;
@@ -19363,6 +19851,19 @@ ${versionDrift}` : "";
       }
     } catch {
     }
+    let unrecordedNote = "";
+    try {
+      const unrecorded = detectUnrecordedCommits(config2.projectRoot, config2.baseBranch);
+      if (unrecorded.length > 0) {
+        const lines = ["\n\n## Unrecorded Work"];
+        lines.push(`${unrecorded.length} commit(s) on ${config2.baseBranch} since last release not captured by \`build_execute\`. Run \`ad_hoc\` to record them.`);
+        for (const c of unrecorded) {
+          lines.push(`- \`${c.hash}\` ${c.message}`);
+        }
+        unrecordedNote = lines.join("\n");
+      }
+    } catch {
+    }
     let recsNote = "";
     try {
       const pendingRecs = await adapter2.getPendingRecommendations();
@@ -19396,15 +19897,15 @@ ${versionDrift}` : "";
       }
     } catch {
     }
-    return textResponse(formatOrientSummary(healthResult, buildInfo, hierarchy, latestTag) + ttfvNote + reconciliationNote + recsNote + pendingReviewNote + patternsNote + versionNote + enrichmentNote);
+    return textResponse(formatOrientSummary(healthResult, buildInfo, hierarchy, latestTag, config2.projectRoot) + ttfvNote + reconciliationNote + unrecordedNote + recsNote + pendingReviewNote + patternsNote + versionNote + enrichmentNote);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return errorResponse(`Orient failed: ${message}`);
   }
 }
 function enrichClaudeMd(projectRoot, cycleNumber) {
-  const claudeMdPath = join7(projectRoot, "CLAUDE.md");
-  if (!existsSync4(claudeMdPath)) return "";
+  const claudeMdPath = join8(projectRoot, "CLAUDE.md");
+  if (!existsSync5(claudeMdPath)) return "";
   const content = readFileSync2(claudeMdPath, "utf-8");
   const additions = [];
   if (cycleNumber >= 6 && !content.includes(CLAUDE_MD_ENRICHMENT_SENTINEL_T1)) {
@@ -19487,6 +19988,9 @@ async function handleHierarchyUpdate(adapter2, args) {
         const available = phases.map((p) => p.label).join(", ");
         return errorResponse(`Phase "${name}" not found. Available phases: ${available || "none"}`);
       }
+      if (!status) {
+        return errorResponse("status is required for phase updates.");
+      }
       if (phase.status === status) {
         return textResponse(`Phase "${phase.label}" is already "${status}". No change made.`);
       }
@@ -19540,6 +20044,9 @@ async function handleHierarchyUpdate(adapter2, args) {
       const available = horizons.map((h) => h.label).join(", ");
       return errorResponse(`Horizon "${name}" not found. Available horizons: ${available || "none"}`);
     }
+    if (!status) {
+      return errorResponse("status is required for horizon updates.");
+    }
     if (horizon.status === status) {
       return textResponse(`Horizon "${horizon.label}" is already "${status}". No change made.`);
     }
@@ -19603,8 +20110,8 @@ async function assembleZoomOutContext(adapter2, cycleNumber, projectRoot) {
   let hierarchyText = "";
   try {
     const [horizons, stages, phases] = await Promise.all([
-      adapter2.readHorizons(),
-      adapter2.readStages(),
+      adapter2.readHorizons?.() ?? [],
+      adapter2.readStages?.() ?? [],
       adapter2.readPhases()
     ]);
     if (horizons.length > 0) {
@@ -19891,8 +20398,8 @@ ${result.userMessage}
 }
 
 // src/tools/doc-registry.ts
-import { readdirSync as readdirSync3, existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { join as join8, relative } from "path";
+import { readdirSync as readdirSync4, existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { join as join9, relative } from "path";
 import { homedir as homedir2 } from "os";
 var docRegisterTool = {
   name: "doc_register",
@@ -20033,12 +20540,12 @@ ${d.summary}
 ${lines.join("\n---\n\n")}`);
 }
 function scanMdFiles(dir, rootDir) {
-  if (!existsSync5(dir)) return [];
+  if (!existsSync6(dir)) return [];
   const files = [];
   try {
-    const entries = readdirSync3(dir, { withFileTypes: true });
+    const entries = readdirSync4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join8(dir, entry.name);
+      const full = join9(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...scanMdFiles(full, rootDir));
       } else if (entry.name.endsWith(".md")) {
@@ -20067,17 +20574,17 @@ async function handleDocScan(adapter2, config2, args) {
   const includePlans = args.include_plans ?? false;
   const registered = await adapter2.searchDocs({ limit: 500, status: "all" });
   const registeredPaths = new Set(registered.map((d) => d.path));
-  const docsDir = join8(config2.projectRoot, "docs");
+  const docsDir = join9(config2.projectRoot, "docs");
   const docsFiles = scanMdFiles(docsDir, config2.projectRoot);
   const unregisteredDocs = docsFiles.filter((f) => !registeredPaths.has(f));
   let unregisteredPlans = [];
   if (includePlans) {
-    const plansDir = join8(homedir2(), ".claude", "plans");
-    if (existsSync5(plansDir)) {
+    const plansDir = join9(homedir2(), ".claude", "plans");
+    if (existsSync6(plansDir)) {
       const planFiles = scanMdFiles(plansDir, plansDir);
       unregisteredPlans = planFiles.map((f) => `plans/${f}`).filter((f) => !registeredPaths.has(f)).map((f) => ({
         path: f,
-        title: extractTitle(join8(plansDir, f.replace("plans/", "")))
+        title: extractTitle(join9(plansDir, f.replace("plans/", "")))
       }));
     }
   }
@@ -20088,7 +20595,7 @@ async function handleDocScan(adapter2, config2, args) {
   if (unregisteredDocs.length > 0) {
     lines.push(`## Unregistered Docs (${unregisteredDocs.length})`);
     for (const f of unregisteredDocs) {
-      const title = extractTitle(join8(config2.projectRoot, f));
+      const title = extractTitle(join9(config2.projectRoot, f));
       lines.push(`- \`${f}\`${title ? ` \u2014 ${title}` : ""}`);
     }
   }
@@ -20252,8 +20759,8 @@ function createServer(adapter2, config2) {
     { capabilities: { tools: {}, prompts: {} } }
   );
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const skillsDir = join9(__dirname, "..", "skills");
+  const __dirname2 = dirname(__filename);
+  const skillsDir = join10(__dirname2, "..", "skills");
   function parseSkillFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
@@ -20271,7 +20778,7 @@ function createServer(adapter2, config2) {
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       const prompts = [];
       for (const file of mdFiles) {
-        const content = await readFile5(join9(skillsDir, file), "utf-8");
+        const content = await readFile5(join10(skillsDir, file), "utf-8");
         const meta = parseSkillFrontmatter(content);
         if (meta) {
           prompts.push({ name: meta.name, description: meta.description });
@@ -20287,7 +20794,7 @@ function createServer(adapter2, config2) {
     try {
       const files = await readdir2(skillsDir);
       for (const file of files.filter((f) => f.endsWith(".md"))) {
-        const content = await readFile5(join9(skillsDir, file), "utf-8");
+        const content = await readFile5(join10(skillsDir, file), "utf-8");
         const meta = parseSkillFrontmatter(content);
         if (meta?.name === name) {
           const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "");
@@ -20354,7 +20861,7 @@ function createServer(adapter2, config2) {
         return {
           content: [{
             type: "text",
-            text: `No project found for PAPI_PROJECT_ID \`${config2.projectId}\`. Run \`setup\` first to initialise your project.`
+            text: `No project found for PAPI_PROJECT_ID \`${process.env.PAPI_PROJECT_ID ?? "(not set)"}\`. Run \`setup\` first to initialise your project.`
           }]
         };
       }
@@ -20488,15 +20995,88 @@ function createServer(adapter2, config2) {
 }
 
 // src/index.ts
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var pkgVersion = "unknown";
+try {
+  const pkg = JSON.parse(readFileSync4(join11(__dirname, "..", "package.json"), "utf-8"));
+  pkgVersion = pkg.version;
+} catch {
+}
+var cliArgs = process.argv.slice(2);
+if (cliArgs.includes("--help") || cliArgs.includes("-h")) {
+  console.log(`papi-server v${pkgVersion} \u2014 PAPI MCP server
+
+Usage: npx @papi-ai/server [options]
+
+Options:
+  --help, -h       Show this help message
+  --version, -v    Show version number
+  --project <dir>  Set the project directory
+
+Getting started:
+  1. Sign up at https://getpapi.ai/login
+  2. Complete the onboarding wizard to get your API key
+  3. Add the generated config to your MCP client
+  4. Say "run setup" in your AI tool
+
+Docs: https://getpapi.ai/docs
+`);
+  process.exit(0);
+}
+if (cliArgs.includes("--version") || cliArgs.includes("-v")) {
+  console.log(pkgVersion);
+  process.exit(0);
+}
 process.on("unhandledRejection", (err) => {
   console.error("[papi] unhandledRejection (swallowed):", err instanceof Error ? err.message : err);
 });
 var config = loadConfig();
-var adapter = await createAdapter({
-  adapterType: config.adapterType,
-  papiDir: config.papiDir,
-  papiEndpoint: config.papiEndpoint
-});
-var server = createServer(adapter, config);
+var adapter;
+var setupError;
+try {
+  adapter = await createAdapter({
+    adapterType: config.adapterType,
+    papiDir: config.papiDir,
+    papiEndpoint: config.papiEndpoint
+  });
+} catch (err) {
+  setupError = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`[papi] Startup error: ${setupError}
+`);
+}
+var server;
+if (adapter && !setupError) {
+  server = createServer(adapter, config);
+} else {
+  server = new Server2(
+    { name: "papi", version: pkgVersion },
+    { capabilities: { tools: {} } }
+  );
+  const errorMessage = setupError || "Unknown startup error";
+  server.setRequestHandler(ListToolsRequestSchema2, async () => ({
+    tools: [{
+      name: "setup",
+      description: "PAPI is not connected \u2014 run this tool for setup instructions.",
+      inputSchema: { type: "object", properties: {}, required: [] }
+    }]
+  }));
+  server.setRequestHandler(CallToolRequestSchema2, async () => ({
+    content: [{
+      type: "text",
+      text: `# PAPI Connection Error
+
+${errorMessage}
+
+## Quick Fix
+
+If you haven't set up PAPI yet:
+1. Go to https://getpapi.ai/login and sign up
+2. Complete the onboarding wizard \u2014 it generates your config
+3. Copy the config to your project and restart your AI tool
+
+If you already have an account, check that both **PAPI_PROJECT_ID** and **PAPI_DATA_API_KEY** are set in your .mcp.json env config.`
+    }]
+  }));
+}
 var transport = new StdioServerTransport();
 await server.connect(transport);