@papi-ai/server 0.7.75 → 0.7.77

package/dist/backfill-cycle-metrics.js

@@ -1236,10 +1236,21 @@ var init_proxy_adapter = __esm({
       // (1) local-only
       "close",
       "initRls",
+      // task-3207 (C357): commitBuildComplete, commitReviewSubmit, commitRelease have no
+      // edge case handler and no ALLOWED_METHODS entry — forwarding them 403s at the edge
+      // with no try/catch at the call site, crashing build_execute/review_submit/release
+      // completion for every hosted user. Restores the intended graceful degradation
+      // (separate appendBuildReport + updateTaskStatus calls) until they're atomically wired.
+      "commitBuildComplete",
+      "commitReviewSubmit",
+      "commitRelease",
       // (2) not-yet-wired hosted gaps — shrink as data-proxy handlers land (task-2390).
       // getToolCallCount + updatePhaseStatus are ABSENT: they now have edge handlers and
       // are served through the forwarder (getToolCallCount = SUP-2026-026 handler #1).
       "getContributorRole",
+      // task-3018 (C356): storeDocBody + getDocBodyUsage are now WIRED — edge case
+      // handlers + ALLOWED_METHODS/WRITE_METHODS entries exist, so they forward and
+      // hosted callers get body storage. Removed from this list, as task-3017 required.
       // task-2728 (C331): createOwnerAction REMOVED from NO_FORWARD — the PRODUCER half
       // of the owner-action queue. Six readers were wired C329 (task-2412) but the
       // producer stayed here, so the hosted Owner Action Queue was structurally empty
@@ -1267,7 +1278,7 @@ var init_proxy_adapter = __esm({
       // 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
+      // updateStageExitCriteria, updateDocAction 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
@@ -1851,9 +1862,19 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
         return this.invoke("updateDocStatus", [id, status, supersededBy]);
       }
       // --- Cycle Learnings ---
-      appendCycleLearnings(learnings) {
-        return this.invoke("appendCycleLearnings", [learnings]);
+      /**
+       * task-2999 / task-2998 (C356): the edge handler now calls append_cycle_learnings
+       * and returns { id, findingKey, inserted } per row, so hosted callers get the same
+       * per-row signal the pg path does. The [] normalisation stays as a floor for an
+       * edge deployed BEFORE that change — callers must read [] as "no signal
+       * available", never as "nothing was new".
+       */
+      async appendCycleLearnings(learnings) {
+        const result = await this.invoke("appendCycleLearnings", [learnings]);
+        return Array.isArray(result) ? result : [];
       }
+      // task-2998: includeResolved was missing here, so the flag could not even be SENT
+      // to the edge — the hosted caught->fixed ledger had no way to ask for history.
       getCycleLearnings(opts) {
         return this.invoke("getCycleLearnings", [opts]);
       }
@@ -2930,6 +2951,59 @@ var ACCURACY_HEADER = "| Cycle | Reports | Match Rate | MAE | Bias |";
 var ACCURACY_SEPARATOR = "|--------|---------|------------|-----|------|";
 var VELOCITY_HEADER = "| Cycle | Completed | Partial | Failed | Effort Points |";
 var VELOCITY_SEPARATOR = "|--------|-----------|---------|--------|---------------|";
+var EFFORT_SCALE = {
+  XS: 1,
+  S: 2,
+  M: 3,
+  L: 4,
+  XL: 5
+};
+function effortOrdinal(effort) {
+  const normalized = effort.trim().toUpperCase();
+  return EFFORT_SCALE[normalized];
+}
+function calculateCycleMetrics(reports, currentCycle, window = 5) {
+  const recentReports = reports.filter(
+    (r) => r.cycle > currentCycle - window && r.cycle <= currentCycle
+  );
+  const perCycle = /* @__PURE__ */ new Map();
+  for (const r of recentReports) {
+    const group = perCycle.get(r.cycle) ?? [];
+    group.push(r);
+    perCycle.set(r.cycle, group);
+  }
+  const accuracy = [];
+  const velocity = [];
+  const sortedCycles = [...perCycle.keys()].sort((a, b) => a - b);
+  for (const cycle of sortedCycles) {
+    const reps = perCycle.get(cycle);
+    const deltas = [];
+    for (const r of reps) {
+      const actual = effortOrdinal(r.actualEffort);
+      const estimated = effortOrdinal(r.estimatedEffort);
+      if (actual !== void 0 && estimated !== void 0) {
+        deltas.push(actual - estimated);
+      }
+    }
+    if (deltas.length > 0) {
+      accuracy.push({
+        cycle,
+        reports: deltas.length,
+        matchRate: Math.round(deltas.filter((d) => d === 0).length / deltas.length * 100),
+        mae: Math.round(deltas.reduce((s, d) => s + Math.abs(d), 0) / deltas.length * 10) / 10,
+        bias: Math.round(deltas.reduce((s, d) => s + d, 0) / deltas.length * 10) / 10
+      });
+    }
+    velocity.push({
+      cycle,
+      completed: reps.filter((r) => r.completed === "Yes").length,
+      partial: reps.filter((r) => r.completed === "Partial").length,
+      failed: reps.filter((r) => r.completed === "No").length,
+      effortPoints: reps.reduce((s, r) => s + (effortOrdinal(r.actualEffort) ?? 0), 0)
+    });
+  }
+  return { accuracy, velocity };
+}
 function serializeAccuracyRow(a) {
   return `| ${a.cycle} | ${a.reports} | ${a.matchRate}% | ${a.mae} | ${a.bias >= 0 ? "+" : ""}${a.bias} |`;
 }
@@ -4713,13 +4787,14 @@ function computeSnapshotsFromBuildReports(reports, tasks) {
     const cycleReports = reportsByCycle.get(sn) ?? [];
     const cycleTaskRows = tasksByCycle.get(sn);
     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;
+    const [computedAccuracy] = calculateCycleMetrics(withEffort, sn, 1).accuracy;
     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 }],
+      // No report in this cycle carried BOTH an estimate and an actual, so there
+      // is genuinely nothing to measure. Zeros here mean "no data", not "no bias".
+      accuracy: [computedAccuracy ?? { cycle: sn, reports: 0, matchRate: 0, mae: 0, bias: 0 }],
       velocity: [{
         cycle: sn,
         completed,