@papi-ai/server 0.7.52 → 0.7.54

package/dist/backfill-cycle-metrics.js

@@ -25,6 +25,7 @@ __export(git_exports, {
   detectUnrecordedCommits: () => detectUnrecordedCommits,
   ensureLatestDevelop: () => ensureLatestDevelop,
   ensureTagAtHead: () => ensureTagAtHead,
+  findTaskCommitsOnBase: () => findTaskCommitsOnBase,
   getBranchDiff: () => getBranchDiff,
   getCommitsSinceTag: () => getCommitsSinceTag,
   getCurrentBranch: () => getCurrentBranch,
@@ -718,11 +719,29 @@ function escapeRegexLiteral(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function detectMergedInProgress(cwd, preferredBase, tasks) {
-  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
   const inProgress = tasks.filter((t) => t.status === "In Progress");
   if (inProgress.length === 0) return [];
+  const landed = findTaskCommitsOnBase(cwd, preferredBase, inProgress.map((t) => t.displayId));
+  const hits = [];
+  for (const task of inProgress) {
+    const hit = landed.get(task.displayId);
+    if (!hit) continue;
+    hits.push({
+      displayId: task.displayId,
+      title: task.title,
+      commit: hit.commit,
+      subject: hit.subject,
+      pr: hit.pr
+    });
+  }
+  return hits;
+}
+function findTaskCommitsOnBase(cwd, preferredBase, displayIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (displayIds.length === 0) return out;
+  if (!isGitAvailable() || !isGitRepo(cwd)) return out;
   const base = resolveDefaultBranch(cwd, preferredBase);
-  if (!branchExists(cwd, base)) return [];
+  if (!branchExists(cwd, base)) return out;
   let raw;
   try {
     raw = execFileSync(
@@ -731,28 +750,25 @@ function detectMergedInProgress(cwd, preferredBase, tasks) {
       { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     );
   } catch {
-    return [];
+    return out;
   }
   const commits = raw.split("\n").map((line) => {
     const idx = line.indexOf("
");
     if (idx === -1) return null;
     return { hash: line.slice(0, idx).trim(), subject: line.slice(idx + 1).trim() };
   }).filter((c) => c !== null && c.hash !== "");
-  const hits = [];
-  for (const task of inProgress) {
-    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(task.displayId)}([^\\w-]|$)`);
+  for (const displayId of displayIds) {
+    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(displayId)}([^\\w-]|$)`);
     const hit = commits.find((c) => re.test(c.subject));
     if (!hit) continue;
     const prMatch = hit.subject.match(/#(\d+)/);
-    hits.push({
-      displayId: task.displayId,
-      title: task.title,
+    out.set(displayId, {
       commit: hit.hash,
       subject: hit.subject,
       pr: prMatch ? `#${prMatch[1]}` : null
     });
   }
-  return hits;
+  return out;
 }
 function detectUnrecordedCommits(cwd, baseBranch) {
   if (!isGitAvailable() || !isGitRepo(cwd)) return [];
@@ -1164,21 +1180,27 @@ var init_proxy_adapter = __esm({
       // getToolCallCount + updatePhaseStatus are ABSENT: they now have edge handlers and
       // are served through the forwarder (getToolCallCount = SUP-2026-026 handler #1).
       "createOwnerAction",
-      "findPendingDocActionsForTask",
       "getContributorRole",
-      "getDecisionScorePatterns",
-      "getModuleEstimationStats",
-      "correctLatestBuildReportEffort",
       "recordContributorReleasePr",
       "setContributorReleasePrStatus",
       "listContributorReleasePrs",
-      "resolveLearningsForDoneTasks",
-      "markCycleLearningResolved",
-      "updateStageExitCriteria",
-      "updateDocAction",
       "claimReview",
       "getSiblingAds",
       "getSiblingRepoTasks"
+      // task-2394 (C329) — Batch A wired: findPendingDocActionsForTask,
+      // getModuleEstimationStats and getDecisionScorePatterns now have edge case handlers
+      // (each backed by a SECURITY DEFINER RPC, migration 20260714140000) plus
+      // ALLOWED_METHODS entries, so they forward. The two planner-context reads returned
+      // EMPTY for every hosted user before this — the planner ran on worse context than
+      // the owner's on the only install path external users have (AD-72).
+      // task-2412 (C329) — listOwnerActionsForBlockerScan + linkOwnerActionToTask wired.
+      // First USER-scoped ([C]) methods to forward: the edge binds both to the bearer's
+      // user_id and discards the client-supplied one, so the typed-blocker scan (task-2343)
+      // now works for hosted users without exposing one member's owner actions to another.
+      // task-2393 (C329) — Batch B wired: markCycleLearningResolved (the P1 — hosted
+      // discovered_issue_resolve hard-errored), correctLatestBuildReportEffort,
+      // updateStageExitCriteria, updateDocAction, resolveLearningsForDoneTasks all have
+      // edge case handlers + ALLOWED_METHODS/WRITE_METHODS entries now, so they forward.
       // task-2489 (C320): recordProgressStep is now wired to the edge data-proxy
       // (case handler + ALLOWED_METHODS/WRITE_METHODS entries), so it forwards for
       // hosted callers and persists a project-scoped cycle_progress_steps row. Removed
@@ -4535,6 +4557,7 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
 }
 
 // src/lib/formatters.ts
+var PLAN_FULL_NOTES_BUDGET_BYTES = Number(process.env.PAPI_PLAN_NOTES_BUDGET) || 6e4;
 function effortWeight(size) {
   switch ((size || "").toUpperCase()) {
     case "XS":
@@ -4554,6 +4577,29 @@ function effortWeight(size) {
       return 3;
   }
 }
+function computeCycleEffort(cycleTaskRows, cycleReports) {
+  if (cycleTaskRows && cycleTaskRows.length > 0) {
+    const done = cycleTaskRows.filter((t) => t.status === "Done");
+    const reportByTask = /* @__PURE__ */ new Map();
+    for (const r of cycleReports) if (r.taskId) reportByTask.set(r.taskId, r);
+    return {
+      completed: done.length,
+      total: cycleTaskRows.length,
+      plannedPoints: done.reduce((s, t) => s + effortWeight(t.complexity), 0),
+      deliveredPoints: done.reduce((s, t) => {
+        const actual = reportByTask.get(t.id)?.actualEffort;
+        return s + effortWeight(actual || t.complexity);
+      }, 0)
+    };
+  }
+  const completed = cycleReports.filter((r) => r.completed === "Yes").length;
+  return {
+    completed,
+    total: cycleReports.length,
+    plannedPoints: cycleReports.reduce((s, r) => s + effortWeight(r.estimatedEffort || r.actualEffort), 0),
+    deliveredPoints: cycleReports.reduce((s, r) => s + effortWeight(r.actualEffort || r.estimatedEffort), 0)
+  };
+}
 function computeSnapshotsFromBuildReports(reports, tasks) {
   const reportsByCycle = /* @__PURE__ */ new Map();
   for (const r of reports) {
@@ -4577,24 +4623,19 @@ function computeSnapshotsFromBuildReports(reports, tasks) {
     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 completed;
-    let total;
-    let effortPoints;
-    if (cycleTaskRows && cycleTaskRows.length > 0) {
-      const done = cycleTaskRows.filter((t) => t.status === "Done");
-      completed = done.length;
-      total = cycleTaskRows.length;
-      effortPoints = done.reduce((s, t) => s + effortWeight(t.complexity), 0);
-    } else {
-      completed = cycleReports.filter((r) => r.completed === "Yes").length;
-      total = cycleReports.length;
-      effortPoints = cycleReports.reduce((s, r) => s + effortWeight(r.actualEffort), 0);
-    }
+    const { completed, total, plannedPoints, deliveredPoints } = computeCycleEffort(cycleTaskRows, cycleReports);
     snapshots.push({
       cycle: sn,
       date: (/* @__PURE__ */ new Date()).toISOString(),
       accuracy: [{ cycle: sn, reports: cycleReports.length, matchRate, mae: 0, bias: 0 }],
-      velocity: [{ cycle: sn, completed, partial: 0, failed: Math.max(0, total - completed), effortPoints }]
+      velocity: [{
+        cycle: sn,
+        completed,
+        partial: 0,
+        failed: Math.max(0, total - completed),
+        effortPoints: plannedPoints,
+        deliveredPoints
+      }]
     });
   }
   snapshots.sort((a, b) => a.cycle - b.cycle);