@papi-ai/server 0.4.0-alpha → 0.5.0

package/dist/index.js

@@ -4396,7 +4396,9 @@ function definedEntries(obj) {
 async function ensureSchema(config2) {
   const sql = src_default(config2.connectionString, {
     max: 1,
-    connect_timeout: 10
+    connect_timeout: 10,
+    prepare: false
+    // Supabase PgBouncer transaction mode invalidates prepared statements
   });
   try {
     const [result] = await sql`
@@ -4702,8 +4704,10 @@ var init_dist3 = __esm({
           max: config2.maxConnections ?? 10,
           idle_timeout: 20,
           // Release idle connections after 20s
-          connect_timeout: 10
+          connect_timeout: 10,
           // Fail fast if DB unreachable
+          prepare: false
+          // Supabase PgBouncer transaction mode invalidates prepared statements
         });
       }
       // -------------------------------------------------------------------------
@@ -4711,12 +4715,12 @@ var init_dist3 = __esm({
       // -------------------------------------------------------------------------
       async createProject(input) {
         const [row] = input.id ? await this.sql`
-          INSERT INTO projects (id, slug, name, repo_url, papi_dir)
-          VALUES (${input.id}, ${input.slug}, ${input.name}, ${input.repo_url ?? null}, ${input.papi_dir ?? null})
+          INSERT INTO projects (id, slug, name, repo_url, papi_dir, user_id)
+          VALUES (${input.id}, ${input.slug}, ${input.name}, ${input.repo_url ?? null}, ${input.papi_dir ?? null}, ${input.user_id ?? null})
           RETURNING *
         ` : await this.sql`
-          INSERT INTO projects (slug, name, repo_url, papi_dir)
-          VALUES (${input.slug}, ${input.name}, ${input.repo_url ?? null}, ${input.papi_dir ?? null})
+          INSERT INTO projects (slug, name, repo_url, papi_dir, user_id)
+          VALUES (${input.slug}, ${input.name}, ${input.repo_url ?? null}, ${input.papi_dir ?? null}, ${input.user_id ?? null})
           RETURNING *
         `;
         return row;
@@ -5224,6 +5228,7 @@ CREATE TABLE IF NOT EXISTS projects (
   name TEXT NOT NULL,
   repo_url TEXT,
   papi_dir TEXT,
+  user_id UUID,
   created_at TIMESTAMPTZ DEFAULT now() NOT NULL,
   updated_at TIMESTAMPTZ DEFAULT now() NOT NULL,
   site_url TEXT,
@@ -5630,6 +5635,7 @@ CREATE TABLE IF NOT EXISTS entity_references (
 CREATE TABLE IF NOT EXISTS dogfood_log (
   id UUID DEFAULT gen_random_uuid() NOT NULL,
   project_id UUID NOT NULL REFERENCES projects(id),
+  user_id UUID,
   cycle_number INTEGER NOT NULL,
   category TEXT NOT NULL,
   content TEXT NOT NULL,
@@ -5654,6 +5660,7 @@ CREATE TABLE IF NOT EXISTS task_comments (
 CREATE TABLE IF NOT EXISTS task_transitions (
   id UUID DEFAULT gen_random_uuid() NOT NULL,
   project_id UUID NOT NULL REFERENCES projects(id),
+  user_id UUID,
   task_id VARCHAR(50) NOT NULL,
   from_status VARCHAR(50) NOT NULL,
   to_status VARCHAR(50) NOT NULL,
@@ -5962,6 +5969,10 @@ EXCEPTION WHEN duplicate_object THEN NULL; END $$;
           max: 5,
           idle_timeout: 20,
           connect_timeout: 10,
+          // Supabase uses PgBouncer in transaction mode — prepared statements are
+          // bound to backend connections and become invalid when PgBouncer reassigns.
+          // This caused "prepared statement does not exist" errors on strategy_review.
+          prepare: false,
           connection: {
             // 30s statement timeout prevents hung queries from blocking the server
             statement_timeout: 3e4
@@ -6077,20 +6088,23 @@ EXCEPTION WHEN duplicate_object THEN NULL; END $$;
         }));
       }
       async getCycleHealth() {
-        const cycles = await this.sql`
-      SELECT number, status FROM cycles
-      WHERE project_id = ${this.projectId}
-      ORDER BY number DESC
-    `;
-        const totalCycles = cycles.length > 0 ? cycles[0].number : 0;
-        const latestCycleStatus = cycles.length > 0 ? cycles[0].status : void 0;
-        const [lastStrategy] = await this.sql`
-      SELECT cycle_number, board_health, strategic_direction FROM strategy_reviews
-      WHERE project_id = ${this.projectId}
-      ORDER BY cycle_number DESC
-      LIMIT 1
+        const [row] = await this.sql`
+      SELECT
+        COALESCE((SELECT number FROM cycles WHERE project_id = ${this.projectId} ORDER BY number DESC LIMIT 1), 0) AS total_cycles,
+        (SELECT status FROM cycles WHERE project_id = ${this.projectId} ORDER BY number DESC LIMIT 1) AS latest_status,
+        sr.cycle_number AS last_review_cycle,
+        sr.board_health,
+        sr.strategic_direction
+      FROM (SELECT 1) AS _dummy
+      LEFT JOIN LATERAL (
+        SELECT cycle_number, board_health, strategic_direction
+        FROM strategy_reviews WHERE project_id = ${this.projectId}
+        ORDER BY cycle_number DESC LIMIT 1
+      ) sr ON true
     `;
-        const lastStrategyReviewCycle = lastStrategy?.cycle_number ?? 0;
+        const totalCycles = row?.total_cycles ?? 0;
+        const latestCycleStatus = row?.latest_status ?? void 0;
+        const lastStrategyReviewCycle = row?.last_review_cycle ?? 0;
         const gap = totalCycles - lastStrategyReviewCycle;
         const strategyReviewDue = gap >= 5 ? `Cycle ${totalCycles}` : `Cycle ${lastStrategyReviewCycle + 5}`;
         return {
@@ -6098,8 +6112,8 @@ EXCEPTION WHEN duplicate_object THEN NULL; END $$;
           latestCycleStatus,
           cyclesSinceLastStrategyReview: gap,
           strategyReviewDue,
-          boardHealth: lastStrategy?.board_health ?? "",
-          strategicDirection: lastStrategy?.strategic_direction ?? "",
+          boardHealth: row?.board_health ?? "",
+          strategicDirection: row?.strategic_direction ?? "",
           lastFullMode: 0
         };
       }
@@ -6271,20 +6285,16 @@ ${newParts.join("\n")}` : newParts.join("\n");
       }
       async writeDogfoodEntries(entries) {
         if (entries.length === 0) return;
-        for (const entry of entries) {
-          await this.sql`
-        INSERT INTO dogfood_log (project_id, cycle_number, category, content, source_tool, status, linked_task_id)
-        VALUES (
-          ${this.projectId},
-          ${entry.cycleNumber},
-          ${entry.category},
-          ${entry.content},
-          ${entry.sourceTool ?? "strategy_review"},
-          ${entry.status ?? "observed"},
-          ${entry.linkedTaskId ?? null}
-        )
-      `;
-        }
+        const values2 = entries.map((entry) => ({
+          project_id: this.projectId,
+          cycle_number: entry.cycleNumber,
+          category: entry.category,
+          content: entry.content,
+          source_tool: entry.sourceTool ?? "strategy_review",
+          status: entry.status ?? "observed",
+          linked_task_id: entry.linkedTaskId ?? null
+        }));
+        await this.sql`INSERT INTO dogfood_log ${this.sql(values2)}`;
       }
       async getDogfoodLog(limit = 10) {
         const rows = await this.sql`
@@ -6708,24 +6718,41 @@ ${newParts.join("\n")}` : newParts.join("\n");
         return rows.map(rowToPhase);
       }
       async writePhases(phases) {
-        for (const phase of phases) {
-          if (phase.stageId) {
-            await this.sql`
-          INSERT INTO phases (project_id, slug, label, description, status, sort_order, stage_id)
-          VALUES (${this.projectId}, ${phase.slug}, ${phase.label}, ${phase.description}, ${phase.status}, ${phase.order}, ${phase.stageId})
-          ON CONFLICT (project_id, slug)
-          DO UPDATE SET label = ${phase.label}, description = ${phase.description},
-                        status = ${phase.status}, sort_order = ${phase.order}, stage_id = ${phase.stageId}
-        `;
-          } else {
-            await this.sql`
-          INSERT INTO phases (project_id, slug, label, description, status, sort_order)
-          VALUES (${this.projectId}, ${phase.slug}, ${phase.label}, ${phase.description}, ${phase.status}, ${phase.order})
-          ON CONFLICT (project_id, slug)
-          DO UPDATE SET label = ${phase.label}, description = ${phase.description},
-                        status = ${phase.status}, sort_order = ${phase.order}
-        `;
-          }
+        if (phases.length === 0) return;
+        const withStage = phases.filter((p) => p.stageId);
+        const withoutStage = phases.filter((p) => !p.stageId);
+        if (withStage.length > 0) {
+          const values2 = withStage.map((p) => ({
+            project_id: this.projectId,
+            slug: p.slug,
+            label: p.label,
+            description: p.description,
+            status: p.status,
+            sort_order: p.order,
+            stage_id: p.stageId
+          }));
+          await this.sql`
+        INSERT INTO phases ${this.sql(values2)}
+        ON CONFLICT (project_id, slug)
+        DO UPDATE SET label = EXCLUDED.label, description = EXCLUDED.description,
+                      status = EXCLUDED.status, sort_order = EXCLUDED.sort_order, stage_id = EXCLUDED.stage_id
+      `;
+        }
+        if (withoutStage.length > 0) {
+          const values2 = withoutStage.map((p) => ({
+            project_id: this.projectId,
+            slug: p.slug,
+            label: p.label,
+            description: p.description,
+            status: p.status,
+            sort_order: p.order
+          }));
+          await this.sql`
+        INSERT INTO phases ${this.sql(values2)}
+        ON CONFLICT (project_id, slug)
+        DO UPDATE SET label = EXCLUDED.label, description = EXCLUDED.description,
+                      status = EXCLUDED.status, sort_order = EXCLUDED.sort_order
+      `;
         }
       }
       // -------------------------------------------------------------------------
@@ -7291,17 +7318,15 @@ ${r.content}` + (r.carry_forward ? `
       // -------------------------------------------------------------------------
       async logEntityReferences(refs) {
         if (refs.length === 0) return;
-        for (const ref of refs) {
-          await this.sql`
-        INSERT INTO entity_references (
-          project_id, entity_type, entity_id, reference_context,
-          tool_name, cycle_number
-        ) VALUES (
-          ${this.projectId}, ${ref.entityType}, ${ref.entityId},
-          ${ref.referenceContext}, ${ref.toolName}, ${ref.cycleNumber}
-        )
-      `;
-        }
+        const values2 = refs.map((ref) => ({
+          project_id: this.projectId,
+          entity_type: ref.entityType,
+          entity_id: ref.entityId,
+          reference_context: ref.referenceContext,
+          tool_name: ref.toolName,
+          cycle_number: ref.cycleNumber
+        }));
+        await this.sql`INSERT INTO entity_references ${this.sql(values2)}`;
       }
       async getDecisionUsage(currentSprint) {
         const rows = await this.sql`
@@ -8035,7 +8060,8 @@ async function createAdapter(optionsOrType, maybePapiDir) {
         if (!existing) {
           const projectRoot = options.projectRoot ?? process.env["PAPI_PROJECT_DIR"] ?? "";
           const slug = path2.basename(projectRoot) || "unnamed";
-          await pgAdapter.createProject({ id: projectId, slug, name: slug, papi_dir: papiDir });
+          const userId = process.env["PAPI_USER_ID"] ?? void 0;
+          await pgAdapter.createProject({ id: projectId, slug, name: slug, papi_dir: papiDir, user_id: userId });
         }
         await pgAdapter.close();
       } catch {
@@ -8130,15 +8156,25 @@ 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}]
-
-${d.body}`;
+      return `- ${d.id}: ${d.title} [SUPERSEDED by ${d.supersededBy}${lifecycle}]${summaryLine}`;
     }
-    return `### ${d.id}: ${d.title} [Confidence: ${d.confidence}${lifecycle}]
-
-${d.body}`;
-  }).join("\n\n");
+    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);
@@ -9858,7 +9894,8 @@ Start with a level-2 heading for each conventions section. Example sections:
 - If the project type implies a tech stack (e.g. mobile-app \u2192 React Native/Flutter), suggest conventions for the most likely stack
 - Include build & test commands if inferrable (e.g. "npm test", "pytest", "cargo test")
 - Do NOT repeat the workflow or documentation maintenance sections \u2014 those are already included
-- Do NOT include a top-level heading \u2014 the file already has one`;
+- Do NOT include a top-level heading \u2014 the file already has one
+- Do NOT include a dogfood logging section \u2014 that is added separately during setup`;
 function buildConventionsPrompt(ctx) {
   const parts = [
     "Generate coding conventions for this project's CLAUDE.md file.",
@@ -11202,7 +11239,7 @@ ${result.userMessage}
 
 // src/services/strategy.ts
 init_dist2();
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID8, createHash as createHash2 } from "crypto";
 
 // src/lib/phase-realign.ts
 function extractPhaseNumber(phaseField) {
@@ -11426,16 +11463,33 @@ function formatPreviousReviews(reviews) {
   if (reviews.length === 0) return void 0;
   return reviews.map((r) => {
     const range = r.cycleRange ? `Cycles ${r.cycleRange}` : `Cycle ${r.cycleNumber}`;
-    const parts = [`#### ${range} \u2014 ${r.title}`];
+    const parts = [`- **${range} \u2014 ${r.title}**`];
     const meta = [];
-    if (r.boardHealth) meta.push(`**Board Health:** ${r.boardHealth}`);
-    if (r.strategicDirection) meta.push(`**Strategic Direction:** ${r.strategicDirection}`);
-    if (r.velocityAssessment) meta.push(`**Velocity:** ${r.velocityAssessment}`);
-    if (meta.length > 0) parts.push("", meta.join("\n"));
-    const content = r.content.replace(/^###\s+.*\n\n/m, "");
-    parts.push("", content);
+    if (r.strategicDirection) meta.push(`Direction: ${r.strategicDirection}`);
+    if (r.boardHealth) meta.push(`Board: ${r.boardHealth}`);
+    if (r.velocityAssessment) meta.push(`Velocity: ${r.velocityAssessment}`);
+    if (meta.length > 0) parts.push(`  ${meta.join(" | ")}`);
+    const topRec = extractTopRecommendation(r.content);
+    if (topRec) parts.push(`  Top rec: ${topRec}`);
     return parts.join("\n");
-  }).join("\n\n---\n\n");
+  }).join("\n");
+}
+function extractTopRecommendation(content) {
+  if (!content) return void 0;
+  const lines = content.split("\n");
+  let inRecommendations = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/recommend/i.test(trimmed) && (trimmed.startsWith("#") || trimmed.startsWith("**"))) {
+      inRecommendations = true;
+      continue;
+    }
+    if (inRecommendations && (trimmed.startsWith("-") || trimmed.startsWith("1"))) {
+      const clean = trimmed.replace(/^[-\d.)\s]+/, "").replace(/\*\*/g, "");
+      return clean.length > 150 ? clean.slice(0, 147) + "..." : clean;
+    }
+  }
+  return void 0;
 }
 function capProductBrief2(brief, maxChars = 2e3) {
   if (brief.length <= maxChars) return brief;
@@ -11462,7 +11516,16 @@ function formatBoardForReviewSmart(tasks, lastReviewCycle) {
     parts.push(`
 ### Completed Since Last Review \u2014 Cycle ${lastReviewCycle}+ (${recentDone.length})
 `);
-    parts.push(...recentDone.map((t) => formatTaskCompact(t)));
+    const byModule = /* @__PURE__ */ new Map();
+    for (const t of recentDone) {
+      const mod = t.module || "Core";
+      if (!byModule.has(mod)) byModule.set(mod, []);
+      byModule.get(mod).push(t);
+    }
+    for (const [mod, modTasks] of byModule) {
+      const titles = modTasks.map((t) => `${t.id}: ${t.title}`).join(", ");
+      parts.push(`**${mod}** (${modTasks.length}): ${titles}`);
+    }
   }
   if (olderDone.length > 0) {
     const byPhase = /* @__PURE__ */ new Map();
@@ -11495,22 +11558,41 @@ function formatTaskCompact(t) {
 }
 async function assembleContext2(adapter2, cycleNumber, cyclesSinceLastReview, projectRoot) {
   const lastReviewCycleNum = cycleNumber - cyclesSinceLastReview;
-  const [productBrief, decisions, reports, log, activeTasks, recentDoneTasks, reviews, dogfoodLog, previousStrategyReviews, currentNorthStar] = await Promise.all([
+  const [
+    productBrief,
+    decisions,
+    reports,
+    log,
+    activeTasks,
+    recentDoneTasks,
+    reviews,
+    dogfoodLog,
+    previousStrategyReviews,
+    currentNorthStar,
+    canvas,
+    decisionUsage,
+    recData
+  ] = await Promise.all([
     adapter2.readProductBrief(),
     adapter2.getActiveDecisions(),
     adapter2.getBuildReportsSince(lastReviewCycleNum),
     adapter2.getCycleLogSince(lastReviewCycleNum),
     adapter2.queryBoard({
-      status: ["Backlog", "In Cycle", "In Progress", "In Review", "Blocked", "Deferred"]
+      status: ["Backlog", "In Cycle", "In Progress", "In Review", "Blocked"]
+      // Deferred tasks excluded — they're intentionally deprioritised and add context noise
     }),
     adapter2.queryBoard({
       status: ["Done"],
       cycleSince: lastReviewCycleNum
     }),
-    adapter2.getRecentReviews(20),
+    adapter2.getRecentReviews(5),
     readDogfoodEntries(projectRoot, 10, adapter2),
     adapter2.getStrategyReviews(3),
-    adapter2.getCurrentNorthStar?.() ?? Promise.resolve(null)
+    adapter2.getCurrentNorthStar?.() ?? Promise.resolve(null),
+    // Previously sequential — now parallel
+    adapter2.readDiscoveryCanvas().catch(() => ({})),
+    adapter2.getDecisionUsage(cycleNumber).catch(() => []),
+    adapter2.getRecommendationEffectiveness?.()?.catch(() => []) ?? Promise.resolve([])
   ]);
   const tasks = [...activeTasks, ...recentDoneTasks];
   const recentLog = log;
@@ -11544,8 +11626,17 @@ async function assembleContext2(adapter2, cycleNumber, cyclesSinceLastReview, pr
   ]);
   let discoveryCanvasText;
   try {
-    const canvas = await adapter2.readDiscoveryCanvas();
-    discoveryCanvasText = formatDiscoveryCanvasForReview(canvas);
+    const fullCanvasText = formatDiscoveryCanvasForReview(canvas);
+    if (fullCanvasText) {
+      const canvasHash = createHash2("md5").update(fullCanvasText).digest("hex");
+      const lastReview = previousStrategyReviews?.[0];
+      const prevHash = lastReview?.structuredData?.canvasHash;
+      if (prevHash && prevHash === canvasHash) {
+        discoveryCanvasText = "Discovery Canvas: No changes since last review.";
+      } else {
+        discoveryCanvasText = fullCanvasText;
+      }
+    }
   } catch {
   }
   const briefImplicationsFromBuilds = reports.filter((r) => Array.isArray(r.briefImplications) && r.briefImplications.length > 0).flatMap((r) => r.briefImplications.map((bi) => ({ ...bi, taskName: r.taskName, cycle: r.cycle })));
@@ -11555,7 +11646,7 @@ async function assembleContext2(adapter2, cycleNumber, cyclesSinceLastReview, pr
   }
   let phasesText;
   try {
-    phasesText = await formatHierarchyForReview(adapter2, cycleNumber);
+    phasesText = await formatHierarchyForReview(adapter2, cycleNumber, tasks);
     if (!phasesText) {
       const phases = await adapter2.readPhases();
       phasesText = formatPhasesForReview(phases, cycleNumber);
@@ -11564,13 +11655,11 @@ async function assembleContext2(adapter2, cycleNumber, cyclesSinceLastReview, pr
   }
   let decisionUsageText;
   try {
-    const usage = await adapter2.getDecisionUsage(cycleNumber);
-    decisionUsageText = formatDecisionUsageForReview(usage);
+    decisionUsageText = formatDecisionUsageForReview(decisionUsage);
   } catch {
   }
   let recEffectivenessText;
   try {
-    const recData = await adapter2.getRecommendationEffectiveness?.();
     if (recData && recData.length > 0) {
       recEffectivenessText = "| Type | Total | Actioned | Pending | Acceptance Rate | Avg Cycles to Action |\n|------|-------|----------|---------|-----------------|---------------------|\n" + recData.map(
         (r) => `| ${r.type} | ${r.total} | ${r.actioned} | ${r.pending} | ${r.acceptanceRate}% | ${r.avgCyclesToAction ?? "N/A"} |`
@@ -11678,7 +11767,18 @@ ${cleanContent}`;
     strategicDirection: data.strategicDirection,
     fullAnalysis: fullAnalysis ?? void 0,
     velocityAssessment: data.velocityAssessment ?? void 0,
-    structuredData: data
+    structuredData: await (async () => {
+      const sd = data;
+      try {
+        const currentCanvas = await adapter2.readDiscoveryCanvas();
+        const canvasText = formatDiscoveryCanvasForReview(currentCanvas);
+        if (canvasText) {
+          return { ...sd, canvasHash: createHash2("md5").update(canvasText).digest("hex") };
+        }
+      } catch {
+      }
+      return sd;
+    })()
   });
   await adapter2.setCycleHealth({
     cyclesSinceLastStrategyReview: 0,
@@ -11702,7 +11802,7 @@ ${cleanContent}`;
   } catch {
   }
   if (data.activeDecisionUpdates && data.activeDecisionUpdates.length > 0) {
-    for (const ad of data.activeDecisionUpdates) {
+    await Promise.all(data.activeDecisionUpdates.map(async (ad) => {
       if (ad.action === "delete" && adapter2.deleteActiveDecision) {
         await adapter2.deleteActiveDecision(ad.id);
       } else {
@@ -11720,10 +11820,10 @@ ${cleanContent}`;
         });
       } catch {
       }
-    }
+    }));
   }
   if (data.decisionScores && data.decisionScores.length > 0) {
-    for (const score of data.decisionScores) {
+    await Promise.all(data.decisionScores.map(async (score) => {
       try {
         await adapter2.writeDecisionScore({
           decisionId: score.id,
@@ -11745,7 +11845,7 @@ ${cleanContent}`;
         });
       } catch {
       }
-    }
+    }));
   }
   if (data.productBriefUpdates) {
     try {
@@ -11762,8 +11862,8 @@ ${cleanContent}`;
   }
   try {
     const recs = extractRecommendations(data, cycleNumber);
-    for (const rec of recs) {
-      await adapter2.writeRecommendation(rec);
+    if (recs.length > 0) {
+      await Promise.all(recs.map((rec) => adapter2.writeRecommendation(rec)));
     }
   } catch {
   }
@@ -12012,20 +12112,22 @@ function formatPhasesForReview(phases, currentCycle) {
   lines.push(`_Current cycle: ${currentCycle}. Use phase status + board task distribution to detect staleness._`);
   return lines.join("\n");
 }
-async function formatHierarchyForReview(adapter2, currentCycle) {
+async function formatHierarchyForReview(adapter2, currentCycle, prefetchedTasks) {
   let horizons = [];
   let stages = [];
   let phases = [];
   try {
-    horizons = await adapter2.readHorizons();
-    stages = await adapter2.readStages();
-    phases = await adapter2.readPhases();
+    [horizons, stages, phases] = await Promise.all([
+      adapter2.readHorizons(),
+      adapter2.readStages(),
+      adapter2.readPhases()
+    ]);
   } catch {
   }
   if (horizons.length === 0 && phases.length === 0) return void 0;
   let tasksByPhase = /* @__PURE__ */ new Map();
   try {
-    const allTasks = await adapter2.queryBoard();
+    const allTasks = prefetchedTasks ?? await adapter2.queryBoard();
     for (const t of allTasks) {
       const phase = t.phase || "Unscoped";
       const existing = tasksByPhase.get(phase) || { total: 0, done: 0, backlog: 0, inProgress: 0 };
@@ -13604,6 +13706,41 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
     } catch {
     }
   }
+  try {
+    const claudeMdPath = join2(config2.projectRoot, "CLAUDE.md");
+    const existing = await readFile3(claudeMdPath, "utf-8");
+    if (!existing.includes("Dogfood Logging")) {
+      const dogfoodSection = [
+        "",
+        "## Dogfood Logging",
+        "",
+        "After each `release`, append a dogfood entry capturing observations from the cycle.",
+        "Call the adapter method with structured entries for each observation:",
+        "",
+        "- **friction** \u2014 workflow pain points, confusing flows, things that broke or slowed you down",
+        "- **methodology** \u2014 what worked or didn't in the plan/build/review cycle",
+        "- **signal** \u2014 indicators of product-market fit, user value, or growth potential",
+        "- **commercial** \u2014 cost, pricing, or business model observations",
+        "",
+        "This is autonomous plumbing \u2014 log observations after release without asking.",
+        ""
+      ].join("\n");
+      await writeFile2(claudeMdPath, existing + dogfoodSection, "utf-8");
+    }
+  } catch {
+  }
+  if (adapter2.writeDogfoodEntries) {
+    try {
+      await adapter2.writeDogfoodEntries([{
+        cycleNumber: 0,
+        category: "signal",
+        content: "Project setup completed \u2014 PAPI is configured and ready for first plan.",
+        sourceTool: "setup",
+        status: "observed"
+      }]);
+    } catch {
+    }
+  }
   try {
     await adapter2.appendToolMetric({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -15093,13 +15230,9 @@ async function recordAdHoc(adapter2, input) {
     if (!existing) {
       throw new Error(`Task "${input.taskId}" not found on the board. Check the task ID and try again.`);
     }
-    if (existing.status === "Done") {
-      throw new Error(`Task "${input.taskId}" (${existing.title}) is already Done.`);
-    }
     await adapter2.updateTask(input.taskId, {
-      status: "Done",
       notes: existing.notes ? `${existing.notes}
-[ad-hoc] ${input.notes || "Completed via ad_hoc"}` : `[ad-hoc] ${input.notes || "Completed via ad_hoc"}`
+[ad-hoc] ${input.notes || "Work recorded via ad_hoc"}` : `[ad-hoc] ${input.notes || "Work recorded via ad_hoc"}`
     });
     task = await adapter2.getTask(input.taskId);
   } else {
@@ -15144,7 +15277,7 @@ async function recordAdHoc(adapter2, input) {
 var VALID_EFFORTS = ["XS", "S", "M", "L", "XL"];
 var adHocTool = {
   name: "ad_hoc",
-  description: "Record work done outside the normal cycle. Creates a Done task with a lightweight build report, or completes an existing task if task_id is provided. Use for quick fixes, bug patches, or ad-hoc changes. Use task_id to complete an existing board task instead of creating a new one. Does not call the Anthropic API.",
+  description: "Record work done outside the normal cycle. Creates a Done task with a lightweight build report, or associates work with an existing task if task_id is provided (without changing task status \u2014 use build_execute for status transitions). Use for quick fixes, bug patches, or ad-hoc changes. Does not call the Anthropic API.",
   inputSchema: {
     type: "object",
     properties: {
@@ -15154,7 +15287,7 @@ var adHocTool = {
       },
       task_id: {
         type: "string",
-        description: 'Existing task ID to complete (e.g. "task-42"). When provided, marks the existing task as Done and attaches a build report instead of creating a new task.'
+        description: 'Existing task ID to associate this work with (e.g. "task-42"). When provided, appends notes and attaches a build report to the existing task without changing its status.'
       },
       notes: {
         type: "string",
@@ -15214,7 +15347,7 @@ async function handleAdHoc(adapter2, config2, args) {
   }
   const truncateWarning = notesTruncated ? ` (notes truncated to ${MAX_NOTES_LENGTH} chars)` : "";
   return textResponse(
-    `**${result.task.id}:** "${result.task.title}" \u2014 recorded as ad-hoc (${effortRaw}). Task marked Done with build report.${truncateWarning}`
+    `**${result.task.id}:** "${result.task.title}" \u2014 recorded as ad-hoc (${effortRaw}). Build report attached.${truncateWarning}`
   );
 }
 
@@ -15908,8 +16041,8 @@ async function createRelease(config2, branch, version, adapter2) {
   const warnings = [];
   if (adapter2) {
     try {
-      const health = await adapter2.getCycleHealth();
-      const currentCycle = health.totalCycles;
+      const versionMatch = version.match(/^v0\.(\d+)\./);
+      const currentCycle = versionMatch ? parseInt(versionMatch[1], 10) : 0;
       if (currentCycle > 0) {
         await adapter2.createCycle({
           id: `cycle-${currentCycle}`,
@@ -16029,6 +16162,10 @@ async function handleRelease(adapter2, config2, args) {
   }
 }
 
+// src/tools/review.ts
+import { existsSync } from "fs";
+import { join as join4 } from "path";
+
 // src/services/review.ts
 init_dist2();
 import { randomUUID as randomUUID13 } from "crypto";
@@ -16075,11 +16212,15 @@ async function submitReview(adapter2, input) {
     throw new Error(`Task ${input.taskId} not found.`);
   }
   let cycle;
-  try {
-    const health = await adapter2.getCycleHealth();
-    cycle = health.totalCycles;
-  } catch {
-    cycle = 0;
+  if (task.cycle && task.cycle > 0) {
+    cycle = task.cycle;
+  } else {
+    try {
+      const health = await adapter2.getCycleHealth();
+      cycle = health.totalCycles;
+    } catch {
+      cycle = 0;
+    }
   }
   const date = (/* @__PURE__ */ new Date()).toISOString();
   const review = {
@@ -16261,21 +16402,24 @@ function mergeAfterAccept(config2, taskId) {
   }
   const featureBranch = taskBranchName(taskId);
   const baseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
-  try {
-    const commitResult = stageDirAndCommit(
-      config2.projectRoot,
-      ".papi",
-      `chore(${taskId}): record build-acceptance review`
-    );
-    if (commitResult.committed) {
-      const push = gitPush(config2.projectRoot, featureBranch);
-      if (!push.success) {
-        lines.push(`Push failed: ${push.message}`);
-        return lines;
+  const papiDir = join4(config2.projectRoot, ".papi");
+  if (existsSync(papiDir)) {
+    try {
+      const commitResult = stageDirAndCommit(
+        config2.projectRoot,
+        ".papi",
+        `chore(${taskId}): record build-acceptance review`
+      );
+      if (commitResult.committed) {
+        const push = gitPush(config2.projectRoot, featureBranch);
+        if (!push.success) {
+          lines.push(`Push failed: ${push.message}`);
+          return lines;
+        }
       }
+    } catch (err) {
+      lines.push(`Pre-merge commit failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-  } catch (err) {
-    lines.push(`Pre-merge commit failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   const merge = mergePullRequest(config2.projectRoot, featureBranch);
   if (!merge.success) {
@@ -16283,6 +16427,20 @@ function mergeAfterAccept(config2, taskId) {
     return lines;
   }
   lines.push(merge.message);
+  if (hasUncommittedChanges(config2.projectRoot, AUTO_WRITTEN_PATHS)) {
+    try {
+      const cleanup = stageDirAndCommit(
+        config2.projectRoot,
+        ".",
+        `chore(${taskId}): commit remaining changes before branch switch`
+      );
+      if (cleanup.committed) {
+        lines.push("Committed uncommitted changes before switching branches.");
+      }
+    } catch {
+      lines.push("Warning: uncommitted changes detected \u2014 branch switch may fail.");
+    }
+  }
   const checkout = checkoutBranch(config2.projectRoot, baseBranch);
   if (checkout.success) {
     const pull = gitPull(config2.projectRoot);
@@ -16292,7 +16450,7 @@ function mergeAfterAccept(config2, taskId) {
       lines.push(del.message);
     }
   } else {
-    lines.push(`Could not switch to '${baseBranch}': ${checkout.message}`);
+    lines.push(`Could not switch to '${baseBranch}': ${checkout.message}. You may need to manually run: git checkout ${baseBranch}`);
   }
   return lines;
 }
@@ -17153,6 +17311,50 @@ ${result.userMessage}
   }
 }
 
+// src/lib/telemetry.ts
+var TELEMETRY_SUPABASE_URL = "https://guewgygcpcmrcoppihzx.supabase.co";
+var TELEMETRY_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imd1ZXdneWdjcGNtcmNvcHBpaHp4Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzI2Njk2NTMsImV4cCI6MjA4ODI0NTY1M30.V5Jw7wJgiMpSQPa2mt0ftjyye5ynG1qLlam00yPVNJY";
+function isEnabled() {
+  return process.env["PAPI_TELEMETRY"] !== "false";
+}
+function emitTelemetryEvent(event) {
+  if (!isEnabled()) return;
+  const body = {
+    project_id: event.project_id,
+    tool_name: event.tool_name,
+    event_type: event.event_type,
+    metadata: event.metadata ?? {}
+  };
+  fetch(`${TELEMETRY_SUPABASE_URL}/rest/v1/telemetry_events`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "apikey": TELEMETRY_API_KEY,
+      "Authorization": `Bearer ${TELEMETRY_API_KEY}`,
+      "Prefer": "return=minimal"
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(5e3)
+  }).catch(() => {
+  });
+}
+function emitToolCall(projectId, toolName, durationMs, extra) {
+  emitTelemetryEvent({
+    project_id: projectId,
+    tool_name: toolName,
+    event_type: "tool_call",
+    metadata: { duration_ms: durationMs, ...extra }
+  });
+}
+function emitMilestone(projectId, milestone, extra) {
+  emitTelemetryEvent({
+    project_id: projectId,
+    tool_name: milestone,
+    event_type: "milestone",
+    metadata: extra
+  });
+}
+
 // src/server.ts
 var TOOLS_REQUIRING_PAPI = /* @__PURE__ */ new Set([
   "plan",
@@ -17323,6 +17525,23 @@ function createServer(adapter2, config2) {
       } catch {
       }
     }
+    const telemetryProjectId = process.env["PAPI_PROJECT_ID"];
+    if (telemetryProjectId) {
+      emitToolCall(telemetryProjectId, name, elapsed, {
+        adapter_type: config2.adapterType
+      });
+      const isApplyMode = safeArgs.mode === "apply";
+      const isError = result.content.some((c) => c.text.startsWith("Error:") || c.text.startsWith("\u274C"));
+      if (!isError) {
+        if (name === "setup" && isApplyMode) {
+          emitMilestone(telemetryProjectId, "setup_completed");
+        } else if (name === "plan" && isApplyMode) {
+          emitMilestone(telemetryProjectId, "plan_completed");
+        } else if (name === "release") {
+          emitMilestone(telemetryProjectId, "release_completed");
+        }
+      }
+    }
     const footer = formatMetricsFooter(elapsed, usage, contextBytes);
     result.content.push({ type: "text", text: footer });
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papi-ai/server",
-  "version": "0.4.0-alpha",
+  "version": "0.5.0",
   "description": "PAPI MCP server — AI-powered sprint planning, build execution, and strategy review for software projects",
   "license": "Elastic-2.0",
   "type": "module",