@papi-ai/server 0.7.1 → 0.7.2

package/dist/index.js

@@ -7674,6 +7674,31 @@ ${r.content}` + (r.carry_forward ? `
     `;
       }
       // -------------------------------------------------------------------------
+      // Bug Reports
+      // -------------------------------------------------------------------------
+      async submitBugReport(report) {
+        const [row] = await this.sql`
+      INSERT INTO bug_reports (project_id, user_id, description, diagnostics, status)
+      VALUES (
+        ${report.projectId},
+        ${report.userId ?? null},
+        ${report.description},
+        ${JSON.stringify(report.diagnostics)},
+        ${report.status}
+      )
+      RETURNING id, created_at
+    `;
+        return {
+          id: row.id,
+          projectId: report.projectId,
+          userId: report.userId,
+          description: report.description,
+          diagnostics: report.diagnostics,
+          status: report.status,
+          createdAt: row.created_at
+        };
+      }
+      // -------------------------------------------------------------------------
       // Task Comments (for plan context)
       // -------------------------------------------------------------------------
       async getRecentTaskComments(limit = 20) {
@@ -8488,6 +8513,10 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
       getBuildReportCountForTask(taskId) {
         return this.invoke("getBuildReportCountForTask", [taskId]);
       }
+      // --- Bug Reports ---
+      submitBugReport(report) {
+        return this.invoke("submitBugReport", [report]);
+      }
       // --- Atomic plan write-back ---
       planWriteBack(payload) {
         return this.invoke("planWriteBack", [payload]);
@@ -11558,41 +11587,47 @@ async function assembleContext(adapter2, mode, _config, filters, focus) {
     }
     timings["metricsAndReviews"] = t();
     t = startTimer();
+    const leanTargetCycle = health.totalCycles + 1;
+    const [
+      reviewPatternsResult,
+      pendingRecsResult,
+      taskCommentsResult,
+      discoveryCanvasResult,
+      calibrationResult,
+      docsResult,
+      cycleLogResult,
+      preAssignedResult,
+      reportsForCapsResult,
+      contextHashesResult
+    ] = await Promise.allSettled([
+      detectReviewPatterns(reviews2, health.totalCycles, 5),
+      adapter2.getPendingRecommendations(),
+      assembleTaskComments(adapter2),
+      assembleDiscoveryCanvasText(adapter2),
+      Promise.all([
+        adapter2.getEstimationCalibration?.(),
+        adapter2.getModuleEstimationStats?.()
+      ]),
+      adapter2.searchDocs?.({ status: "active", limit: 5 }),
+      adapter2.getCycleLog(5),
+      adapter2.queryBoard({ status: ["Backlog", "In Cycle", "Ready"] }),
+      adapter2.getRecentBuildReports(10),
+      adapter2.getContextHashes?.(health.totalCycles) ?? Promise.resolve(null)
+    ]);
+    timings["parallelReads"] = t();
     let reviewPatternsText2;
-    try {
-      const reviewPatterns = await detectReviewPatterns(reviews2, health.totalCycles, 5);
-      reviewPatternsText2 = hasReviewPatterns(reviewPatterns) ? formatReviewPatterns(reviewPatterns) : void 0;
-    } catch {
+    if (reviewPatternsResult.status === "fulfilled") {
+      reviewPatternsText2 = hasReviewPatterns(reviewPatternsResult.value) ? formatReviewPatterns(reviewPatternsResult.value) : void 0;
     }
     let strategyRecommendationsText2;
-    try {
-      const pendingRecs = await adapter2.getPendingRecommendations();
-      if (pendingRecs.length > 0) {
-        strategyRecommendationsText2 = formatStrategyRecommendations(pendingRecs, health.totalCycles);
-      }
-    } catch {
+    if (pendingRecsResult.status === "fulfilled" && pendingRecsResult.value.length > 0) {
+      strategyRecommendationsText2 = formatStrategyRecommendations(pendingRecsResult.value, health.totalCycles);
     }
-    timings["advisory"] = t();
-    logDataSourceSummary("plan (lean)", [
-      { label: "cycleHealth", hasData: !!health },
-      { label: "productBrief", hasData: warnIfEmpty("productBrief", productBrief) },
-      { label: "activeDecisions", hasData: warnIfEmpty("activeDecisions (lean)", leanSummary.activeDecisions) },
-      { label: "buildIntelligence", hasData: warnIfEmpty("buildIntelligence (lean)", leanSummary.buildIntelligence) },
-      { label: "cycleLog", hasData: warnIfEmpty("cycleLog (lean)", leanSummary.cycleLog) },
-      { label: "board", hasData: warnIfEmpty("board (lean)", leanSummary.board) },
-      { label: "metricsSnapshots", hasData: warnIfEmpty("readCycleMetrics", metricsSnapshots2) },
-      { label: "reviews", hasData: warnIfEmpty("getRecentReviews", reviews2) }
-    ]);
-    timings["total"] = totalTimer();
-    console.error(`[plan-perf] assembleContext (lean): ${JSON.stringify(timings)}ms`);
-    const taskCommentsText = await assembleTaskComments(adapter2);
-    const discoveryCanvasText = await assembleDiscoveryCanvasText(adapter2);
+    const taskCommentsText = taskCommentsResult.status === "fulfilled" ? taskCommentsResult.value : void 0;
+    const discoveryCanvasText = discoveryCanvasResult.status === "fulfilled" ? discoveryCanvasResult.value : void 0;
     let estimationCalibrationText;
-    try {
-      const [calibrationRows, moduleStats] = await Promise.all([
-        adapter2.getEstimationCalibration?.(),
-        adapter2.getModuleEstimationStats?.()
-      ]);
+    if (calibrationResult.status === "fulfilled") {
+      const [calibrationRows, moduleStats] = calibrationResult.value;
       if (calibrationRows && calibrationRows.length > 0) {
         estimationCalibrationText = formatEstimationCalibration(calibrationRows);
       }
@@ -11606,39 +11641,40 @@ async function assembleContext(adapter2, mode, _config, filters, focus) {
         ].join("\n");
         estimationCalibrationText = (estimationCalibrationText ?? "") + moduleLines;
       }
-    } catch {
     }
     let registeredDocsText;
-    try {
-      const docs = await adapter2.searchDocs?.({ status: "active", limit: 5 });
-      if (docs && docs.length > 0) {
-        const lines = docs.map((d) => `- **${d.title}** (${d.type}) \u2014 ${d.summary}`);
-        registeredDocsText = `${docs.length} active research doc(s):
+    if (docsResult.status === "fulfilled" && docsResult.value && docsResult.value.length > 0) {
+      const docs = docsResult.value;
+      const lines = docs.map((d) => `- **${d.title}** (${d.type}) \u2014 ${d.summary}`);
+      registeredDocsText = `${docs.length} active research doc(s):
 ${lines.join("\n")}`;
-      }
-    } catch {
     }
     const boardFlags = detectBoardFlagsFromText(leanSummary.board);
     let carryForwardStalenessLean;
-    try {
-      const recentLog = await adapter2.getCycleLog(5);
-      carryForwardStalenessLean = computeCarryForwardStaleness(recentLog);
-    } catch {
+    if (cycleLogResult.status === "fulfilled") {
+      carryForwardStalenessLean = computeCarryForwardStaleness(cycleLogResult.value);
     }
-    const leanTargetCycle = health.totalCycles + 1;
     let preAssignedTextLean;
-    try {
-      const preAssignedTasks = await adapter2.queryBoard({ status: ["Backlog", "In Cycle", "Ready"] });
-      const preAssigned2 = preAssignedTasks.filter((t2) => t2.cycle === leanTargetCycle);
+    if (preAssignedResult.status === "fulfilled") {
+      const preAssigned2 = preAssignedResult.value.filter((t2) => t2.cycle === leanTargetCycle);
       preAssignedTextLean = formatPreAssignedTasks(preAssigned2, leanTargetCycle);
-    } catch {
     }
     let recentlyShippedLean;
-    try {
-      const reportsForCaps = await adapter2.getRecentBuildReports(10);
-      recentlyShippedLean = formatRecentlyShippedCapabilities(reportsForCaps);
-    } catch {
+    if (reportsForCapsResult.status === "fulfilled") {
+      recentlyShippedLean = formatRecentlyShippedCapabilities(reportsForCapsResult.value);
     }
+    logDataSourceSummary("plan (lean)", [
+      { label: "cycleHealth", hasData: !!health },
+      { label: "productBrief", hasData: warnIfEmpty("productBrief", productBrief) },
+      { label: "activeDecisions", hasData: warnIfEmpty("activeDecisions (lean)", leanSummary.activeDecisions) },
+      { label: "buildIntelligence", hasData: warnIfEmpty("buildIntelligence (lean)", leanSummary.buildIntelligence) },
+      { label: "cycleLog", hasData: warnIfEmpty("cycleLog (lean)", leanSummary.cycleLog) },
+      { label: "board", hasData: warnIfEmpty("board (lean)", leanSummary.board) },
+      { label: "metricsSnapshots", hasData: warnIfEmpty("readCycleMetrics", metricsSnapshots2) },
+      { label: "reviews", hasData: warnIfEmpty("getRecentReviews", reviews2) }
+    ]);
+    timings["total"] = totalTimer();
+    console.error(`[plan-perf] assembleContext (lean): ${JSON.stringify(timings)}ms`);
     let ctx2 = {
       mode,
       cycleNumber: health.totalCycles,
@@ -11663,7 +11699,7 @@ ${lines.join("\n")}`;
       recentlyShippedCapabilities: recentlyShippedLean
     };
     t = startTimer();
-    const prevHashes2 = await adapter2.getContextHashes?.(health.totalCycles) ?? null;
+    const prevHashes2 = contextHashesResult.status === "fulfilled" ? contextHashesResult.value : null;
     const { ctx: diffedCtx2, newHashes: newHashes2, savedBytes: savedBytes2 } = applyContextDiff(ctx2, prevHashes2);
     ctx2 = diffedCtx2;
     timings["contextDiff"] = t();
@@ -11686,30 +11722,52 @@ ${lines.join("\n")}`;
   timings["fullQueries"] = t();
   const reports = reportsSinceCycle.length > 0 ? reportsSinceCycle : await adapter2.getRecentBuildReports(5);
   t = startTimer();
+  const [
+    allReportsResult,
+    reviewPatternsResultFull,
+    pendingRecsResultFull,
+    discoveryCanvasResultFull,
+    taskCommentsResultFull,
+    docsResultFull,
+    contextHashesResultFull
+  ] = await Promise.allSettled([
+    adapter2.getRecentBuildReports(50),
+    detectReviewPatterns(reviews, health.totalCycles, 5),
+    adapter2.getPendingRecommendations(),
+    assembleDiscoveryCanvasText(adapter2),
+    assembleTaskComments(adapter2),
+    adapter2.searchDocs?.({ status: "active", limit: 5 }),
+    adapter2.getContextHashes?.(health.totalCycles) ?? Promise.resolve(null)
+  ]);
+  timings["parallelAdvisory"] = t();
   let buildPatternsText;
   let allReportsForPatterns = [];
-  try {
-    allReportsForPatterns = await adapter2.getRecentBuildReports(50);
-    const patterns = await detectBuildPatterns(allReportsForPatterns, health.totalCycles, 5);
-    buildPatternsText = hasBuildPatterns(patterns) ? formatBuildPatterns(patterns) : void 0;
-  } catch {
+  if (allReportsResult.status === "fulfilled") {
+    allReportsForPatterns = allReportsResult.value;
+    try {
+      const patterns = await detectBuildPatterns(allReportsForPatterns, health.totalCycles, 5);
+      buildPatternsText = hasBuildPatterns(patterns) ? formatBuildPatterns(patterns) : void 0;
+    } catch {
+    }
   }
   let reviewPatternsText;
-  try {
-    const reviewPatterns = await detectReviewPatterns(reviews, health.totalCycles, 5);
-    reviewPatternsText = hasReviewPatterns(reviewPatterns) ? formatReviewPatterns(reviewPatterns) : void 0;
-  } catch {
+  if (reviewPatternsResultFull.status === "fulfilled") {
+    reviewPatternsText = hasReviewPatterns(reviewPatternsResultFull.value) ? formatReviewPatterns(reviewPatternsResultFull.value) : void 0;
   }
   let strategyRecommendationsText;
-  try {
-    const pendingRecs = await adapter2.getPendingRecommendations();
-    if (pendingRecs.length > 0) {
-      strategyRecommendationsText = formatStrategyRecommendations(pendingRecs);
-    }
-  } catch {
+  if (pendingRecsResultFull.status === "fulfilled" && pendingRecsResultFull.value.length > 0) {
+    strategyRecommendationsText = formatStrategyRecommendations(pendingRecsResultFull.value);
   }
-  timings["advisory"] = t();
   const metricsSnapshots = allReportsForPatterns.length > 0 ? computeSnapshotsFromBuildReports(allReportsForPatterns) : rawMetricsSnapshots.filter((s) => s.accuracy.length > 0 || s.velocity.length > 0);
+  const discoveryCanvasTextFull = discoveryCanvasResultFull.status === "fulfilled" ? discoveryCanvasResultFull.value : void 0;
+  const taskCommentsTextFull = taskCommentsResultFull.status === "fulfilled" ? taskCommentsResultFull.value : void 0;
+  let registeredDocsTextFull;
+  if (docsResultFull.status === "fulfilled" && docsResultFull.value && docsResultFull.value.length > 0) {
+    const docs = docsResultFull.value;
+    const lines = docs.map((d) => `- **${d.title}** (${d.type}) \u2014 ${d.summary}`);
+    registeredDocsTextFull = `${docs.length} active research doc(s):
+${lines.join("\n")}`;
+  }
   logDataSourceSummary("plan (full)", [
     { label: "cycleHealth", hasData: !!health },
     { label: "productBrief", hasData: warnIfEmpty("productBrief", productBrief) },
@@ -11723,18 +11781,6 @@ ${lines.join("\n")}`;
   ]);
   timings["total"] = totalTimer();
   console.error(`[plan-perf] assembleContext (full): ${JSON.stringify(timings)}ms`);
-  const discoveryCanvasTextFull = await assembleDiscoveryCanvasText(adapter2);
-  const taskCommentsTextFull = await assembleTaskComments(adapter2);
-  let registeredDocsTextFull;
-  try {
-    const docs = await adapter2.searchDocs?.({ status: "active", limit: 5 });
-    if (docs && docs.length > 0) {
-      const lines = docs.map((d) => `- **${d.title}** (${d.type}) \u2014 ${d.summary}`);
-      registeredDocsTextFull = `${docs.length} active research doc(s):
-${lines.join("\n")}`;
-    }
-  } catch {
-  }
   const MAX_PLAN_BUILD_REPORT_CYCLES = 3;
   const cappedReports = reports.length > 0 ? (() => {
     const maxCycle = Math.max(...reports.map((r) => r.cycle ?? 0));
@@ -11773,7 +11819,7 @@ ${lines.join("\n")}`;
     preAssignedTasks: preAssignedText,
     recentlyShippedCapabilities: formatRecentlyShippedCapabilities(allReportsForPatterns)
   };
-  const prevHashes = await adapter2.getContextHashes?.(health.totalCycles) ?? null;
+  const prevHashes = contextHashesResultFull.status === "fulfilled" ? contextHashesResultFull.value : null;
   const { ctx: diffedCtx, newHashes, savedBytes } = applyContextDiff(ctx, prevHashes);
   ctx = diffedCtx;
   if (savedBytes > 0) {
@@ -14220,6 +14266,26 @@ ${result.slackWarning}` : "";
       const header = `**Strategy Review \u2014 Cycle ${result.cycleNumber}**
 
 `;
+      let recsCloseOut = "";
+      try {
+        const pendingRecs = await adapter2.getPendingRecommendations();
+        if (pendingRecs.length > 0) {
+          const recLines = pendingRecs.map(
+            (rec) => `- **[${rec.type}]** ${rec.content.slice(0, 120)}${rec.content.length > 120 ? "..." : ""}${rec.target ? ` (target: ${rec.target})` : ""}`
+          );
+          recsCloseOut = `
+
+---
+
+## Pending Recommendations (${pendingRecs.length})
+
+${recLines.join("\n")}
+
+**Review these recommendations before running \`plan\`.** Use \`idea\` to convert any into backlog tasks, or dismiss by noting which ones don't apply.
+`;
+        }
+      } catch {
+      }
       const actionReminder = `
 
 ---
@@ -14228,9 +14294,9 @@ ${result.slackWarning}` : "";
 1. Review the AD changes above \u2014 are any resolved/modified ADs still referenced by active tasks?
 2. Act on strategic recommendations \u2014 cancel, defer, or reprioritise tasks as suggested.
 3. Run \`strategy_change\` if any recommendation requires an AD update not already captured.
-4. Run \`/slack-strategy\` to notify the team.
+4. Run \`/patch-notes\` to post curated patch notes to Discord.
 5. Then run \`plan\` for the next cycle.`;
-      const response = textResponse(header + result.displayText + slackNote + actionReminder);
+      const response = textResponse(header + result.displayText + slackNote + recsCloseOut + actionReminder);
       return {
         ...response,
         ...contextBytes !== void 0 ? { _contextBytes: contextBytes } : {},
@@ -17666,6 +17732,7 @@ Re-submit with \`notes: "... Reference: <path>"\` to link one, or ignore if none
 }
 
 // src/tools/bug.ts
+import os2 from "os";
 init_git();
 
 // src/services/bug.ts
@@ -17714,15 +17781,26 @@ async function captureBug(adapter2, input) {
 }
 
 // src/tools/bug.ts
+function collectDiagnostics(config2) {
+  return {
+    nodeVersion: process.version,
+    platform: os2.platform(),
+    arch: os2.arch(),
+    adapterType: config2.adapterType,
+    projectRoot: config2.projectRoot,
+    hasEndpoint: !!config2.papiEndpoint,
+    lightMode: config2.lightMode
+  };
+}
 var bugTool = {
   name: "bug",
-  description: 'Report a bug as a Backlog task with severity-based priority. Bugs are created with "investigated" maturity so they can be picked up by the next plan without further triage. Does not call the Anthropic API.',
+  description: "Report a bug. Two modes: (1) Default \u2014 creates a Backlog task with severity-based priority for the project board. (2) With report=true \u2014 submits a diagnostic bug report with system info for cross-project visibility (external user issue reporting). Does not call the Anthropic API.",
   inputSchema: {
     type: "object",
     properties: {
       text: {
         type: "string",
-        description: "The bug description \u2014 becomes the task title."
+        description: "The bug description \u2014 becomes the task title (default mode) or report description (report mode)."
       },
       severity: {
         type: "string",
@@ -17744,6 +17822,10 @@ var bugTool = {
       phase: {
         type: "string",
         description: "Target phase (default: current active phase)."
+      },
+      report: {
+        type: "boolean",
+        description: "When true, submits a diagnostic bug report with system info instead of creating a board task. Use this to report issues to PAPI maintainers."
       }
     },
     required: ["text"]
@@ -17754,6 +17836,38 @@ async function handleBug(adapter2, config2, args) {
   if (!text) {
     return errorResponse("text is required \u2014 describe the bug you want to report.");
   }
+  if (args.report === true) {
+    if (!adapter2.submitBugReport) {
+      return errorResponse("Bug reports require a database adapter (pg or proxy). The md adapter does not support bug reports.");
+    }
+    const diagnostics = collectDiagnostics(config2);
+    const notes = args.notes?.trim();
+    if (notes) {
+      diagnostics.userNotes = notes;
+    }
+    let projectId;
+    try {
+      const health = await adapter2.getCycleHealth();
+      projectId = adapter2.projectId ?? "unknown";
+      diagnostics.cycleNumber = health.totalCycles;
+    } catch {
+      projectId = "unknown";
+    }
+    const report = await adapter2.submitBugReport({
+      projectId,
+      description: text,
+      diagnostics,
+      status: "open"
+    });
+    return textResponse(
+      `**Bug report submitted** \u2014 ID: \`${report.id}\`
+
+Description: ${text}
+Diagnostics collected: Node ${diagnostics.nodeVersion}, ${diagnostics.platform}/${diagnostics.arch}, adapter=${diagnostics.adapterType}
+
+This report is visible to PAPI maintainers. No further action needed from you.`
+    );
+  }
   const MAX_NOTES_LENGTH = 2e3;
   let rawNotes = args.notes?.trim();
   let notesTruncated = false;
@@ -17808,10 +17922,14 @@ 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.`);
     }
-    await adapter2.updateTask(input.taskId, {
+    const updatePayload = {
       notes: existing.notes ? `${existing.notes}
 [ad-hoc] ${input.notes || "Work recorded via ad_hoc"}` : `[ad-hoc] ${input.notes || "Work recorded via ad_hoc"}`
-    });
+    };
+    if (existing.status === "In Progress") {
+      updatePayload.status = "In Review";
+    }
+    await adapter2.updateTask(input.taskId, updatePayload);
     task = await adapter2.getTask(input.taskId);
   } else {
     const phase = resolveCurrentPhase(phases);

package/package.json

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