@papi-ai/server 0.7.43 → 0.7.45

package/dist/index.js

@@ -1177,7 +1177,9 @@ var init_telemetry = __esm({
 // src/proxy-adapter.ts
 var proxy_adapter_exports = {};
 __export(proxy_adapter_exports, {
-  ProxyPapiAdapter: () => ProxyPapiAdapter
+  ProxyPapiAdapter: () => ProxyPapiAdapter,
+  createProxyAdapter: () => createProxyAdapter,
+  wrapWithForwarding: () => wrapWithForwarding
 });
 function snakeToCamel(str) {
   return str.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
@@ -1216,7 +1218,22 @@ function fixDisplayIdEntities(data) {
   if (data && typeof data === "object") return fixDisplayIdEntity(data);
   return data;
 }
-var JSONB_PASSTHROUGH_KEYS, DISPLAY_ID_METHODS, ProxyPapiAdapter;
+function wrapWithForwarding(instance) {
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      const existing = Reflect.get(target, prop, receiver);
+      if (existing !== void 0) return existing;
+      if (typeof prop !== "string" || prop === "then" || prop.startsWith("_") || NO_FORWARD.has(prop)) {
+        return existing;
+      }
+      return (...args) => target.forward(prop, args);
+    }
+  });
+}
+function createProxyAdapter(config2) {
+  return wrapWithForwarding(new ProxyPapiAdapter(config2));
+}
+var JSONB_PASSTHROUGH_KEYS, DISPLAY_ID_METHODS, NO_FORWARD, ProxyPapiAdapter;
 var init_proxy_adapter = __esm({
   "src/proxy-adapter.ts"() {
     "use strict";
@@ -1240,6 +1257,30 @@ var init_proxy_adapter = __esm({
       "getRecentReviews",
       "getActiveDecisions"
     ]);
+    NO_FORWARD = /* @__PURE__ */ new Set([
+      // (1) local-only
+      "close",
+      "initRls",
+      // (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).
+      "createOwnerAction",
+      "findPendingDocActionsForTask",
+      "getContributorRole",
+      "getDecisionScorePatterns",
+      "getModuleEstimationStats",
+      "correctLatestBuildReportEffort",
+      "recordContributorReleasePr",
+      "setContributorReleasePrStatus",
+      "listContributorReleasePrs",
+      "resolveLearningsForDoneTasks",
+      "markCycleLearningResolved",
+      "updateStageExitCriteria",
+      "updateDocAction",
+      "claimReview",
+      "getSiblingAds",
+      "getSiblingRepoTasks"
+    ]);
     ProxyPapiAdapter = class _ProxyPapiAdapter {
       endpoint;
       apiKey;
@@ -1261,11 +1302,11 @@ var init_proxy_adapter = __esm({
        * data-proxy's validateProjectAccess re-checks server-side regardless.
        */
       withProject(projectId) {
-        return new _ProxyPapiAdapter({
+        return wrapWithForwarding(new _ProxyPapiAdapter({
           endpoint: this.endpoint,
           apiKey: this.apiKey,
           projectId
-        });
+        }));
       }
       /**
        * Ensure the authenticated user has a project. If none exists, auto-creates one.
@@ -1377,6 +1418,17 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
         }
         return result;
       }
+      /**
+       * Generic forward for the allowlist-driven proxy trap (SUP-2026-026). Any
+       * PapiAdapter method with no explicit wrapper here — and not in NO_FORWARD — is
+       * served through this single path, so a NEW adapter method needs only a data-proxy
+       * case handler, never a hand-written wrapper. Routes through invoke() so the
+       * transformKeys / DISPLAY_ID fixups apply identically to wrapped methods. This is
+       * the structural cure for the pg→proxy drift that caused SUP-2026-026.
+       */
+      forward(method, args) {
+        return this.invoke(method, args);
+      }
       /** Check if the proxy is reachable. */
       async probeConnection() {
         try {
@@ -1937,7 +1989,7 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
   }
 });
 
-// ../../../../../node_modules/postgres/src/query.js
+// ../../node_modules/postgres/src/query.js
 function cachedError(xs) {
   if (originCache.has(xs))
     return originCache.get(xs);
@@ -1949,7 +2001,7 @@ function cachedError(xs) {
 }
 var originCache, originStackCache, originError, CLOSE, Query;
 var init_query = __esm({
-  "../../../../../node_modules/postgres/src/query.js"() {
+  "../../node_modules/postgres/src/query.js"() {
     "use strict";
     originCache = /* @__PURE__ */ new Map();
     originStackCache = /* @__PURE__ */ new Map();
@@ -2080,7 +2132,7 @@ var init_query = __esm({
   }
 });
 
-// ../../../../../node_modules/postgres/src/errors.js
+// ../../node_modules/postgres/src/errors.js
 function connection(x, options, socket) {
   const { host, port } = socket || options;
   const error = Object.assign(
@@ -2118,7 +2170,7 @@ function notSupported(x) {
 }
 var PostgresError, Errors;
 var init_errors = __esm({
-  "../../../../../node_modules/postgres/src/errors.js"() {
+  "../../node_modules/postgres/src/errors.js"() {
     "use strict";
     PostgresError = class extends Error {
       constructor(x) {
@@ -2136,7 +2188,7 @@ var init_errors = __esm({
   }
 });
 
-// ../../../../../node_modules/postgres/src/types.js
+// ../../node_modules/postgres/src/types.js
 function handleValue(x, parameters, types2, options) {
   let value = x instanceof Parameter ? x.value : x;
   if (value === void 0) {
@@ -2251,7 +2303,7 @@ function createJsonTransform(fn) {
 }
 var types, NotTagged, Identifier, Parameter, Builder, defaultHandlers, builders, serializers, parsers, mergeUserTypes, escapeIdentifier, inferType, escapeBackslash, escapeQuote, arraySerializer, arrayParserState, arrayParser, toCamel, toPascal, toKebab, fromCamel, fromPascal, fromKebab, camel, pascal, kebab;
 var init_types = __esm({
-  "../../../../../node_modules/postgres/src/types.js"() {
+  "../../node_modules/postgres/src/types.js"() {
     "use strict";
     init_query();
     init_errors();
@@ -2430,10 +2482,10 @@ var init_types = __esm({
   }
 });
 
-// ../../../../../node_modules/postgres/src/result.js
+// ../../node_modules/postgres/src/result.js
 var Result;
 var init_result = __esm({
-  "../../../../../node_modules/postgres/src/result.js"() {
+  "../../node_modules/postgres/src/result.js"() {
     "use strict";
     Result = class extends Array {
       constructor() {
@@ -2453,7 +2505,7 @@ var init_result = __esm({
   }
 });
 
-// ../../../../../node_modules/postgres/src/queue.js
+// ../../node_modules/postgres/src/queue.js
 function Queue(initial = []) {
   let xs = initial.slice();
   let index = 0;
@@ -2480,13 +2532,13 @@ function Queue(initial = []) {
 }
 var queue_default;
 var init_queue = __esm({
-  "../../../../../node_modules/postgres/src/queue.js"() {
+  "../../node_modules/postgres/src/queue.js"() {
     "use strict";
     queue_default = Queue;
   }
 });
 
-// ../../../../../node_modules/postgres/src/bytes.js
+// ../../node_modules/postgres/src/bytes.js
 function fit(x) {
   if (buffer.length - b.i < x) {
     const prev = buffer, length = prev.length;
@@ -2500,7 +2552,7 @@ function reset() {
 }
 var size, buffer, messages, b, bytes_default;
 var init_bytes = __esm({
-  "../../../../../node_modules/postgres/src/bytes.js"() {
+  "../../node_modules/postgres/src/bytes.js"() {
     "use strict";
     size = 256;
     buffer = Buffer.allocUnsafe(size);
@@ -2565,7 +2617,7 @@ var init_bytes = __esm({
   }
 });
 
-// ../../../../../node_modules/postgres/src/connection.js
+// ../../node_modules/postgres/src/connection.js
 import net from "net";
 import tls from "tls";
 import crypto2 from "crypto";
@@ -3359,7 +3411,7 @@ function timer(fn, seconds) {
 }
 var connection_default, uid, Sync, Flush, SSLRequest, ExecuteUnnamed, DescribeUnnamed, noop, retryRoutines, errorFields;
 var init_connection = __esm({
-  "../../../../../node_modules/postgres/src/connection.js"() {
+  "../../node_modules/postgres/src/connection.js"() {
     "use strict";
     init_types();
     init_errors();
@@ -3422,7 +3474,7 @@ var init_connection = __esm({
   }
 });
 
-// ../../../../../node_modules/postgres/src/subscribe.js
+// ../../node_modules/postgres/src/subscribe.js
 function Subscribe(postgres2, options) {
   const subscribers = /* @__PURE__ */ new Map(), slot = "postgresjs_" + Math.random().toString(36).slice(2), state = {};
   let connection2, stream, ended = false;
@@ -3633,14 +3685,14 @@ function parseEvent(x) {
 }
 var noop2;
 var init_subscribe = __esm({
-  "../../../../../node_modules/postgres/src/subscribe.js"() {
+  "../../node_modules/postgres/src/subscribe.js"() {
     "use strict";
     noop2 = () => {
     };
   }
 });
 
-// ../../../../../node_modules/postgres/src/large.js
+// ../../node_modules/postgres/src/large.js
 import Stream2 from "stream";
 function largeObject(sql, oid, mode = 131072 | 262144) {
   return new Promise(async (resolve3, reject) => {
@@ -3706,12 +3758,12 @@ function largeObject(sql, oid, mode = 131072 | 262144) {
   });
 }
 var init_large = __esm({
-  "../../../../../node_modules/postgres/src/large.js"() {
+  "../../node_modules/postgres/src/large.js"() {
     "use strict";
   }
 });
 
-// ../../../../../node_modules/postgres/src/index.js
+// ../../node_modules/postgres/src/index.js
 var src_exports = {};
 __export(src_exports, {
   default: () => src_default
@@ -4101,7 +4153,7 @@ function osUsername() {
 }
 var src_default;
 var init_src = __esm({
-  "../../../../../node_modules/postgres/src/index.js"() {
+  "../../node_modules/postgres/src/index.js"() {
     "use strict";
     init_types();
     init_connection();
@@ -4991,6 +5043,7 @@ var HELP_FOOTER_MD = `
 // src/config.ts
 var STRATEGY_REVIEW_OFFER_GAP = 5;
 var STRATEGY_REVIEW_BLOCK_GAP = 7;
+var ZOOM_OUT_OFFER_GAP = 25;
 function loadConfig() {
   const projectArgIdx = process.argv.indexOf("--project");
   const configuredRoot = projectArgIdx !== -1 ? process.argv[projectArgIdx + 1] : process.env.PAPI_PROJECT_DIR;
@@ -5090,12 +5143,12 @@ Already have an account? Make sure PAPI_USER_ID is set in your .mcp.json env con
 import path3 from "path";
 import { execSync } from "child_process";
 
-// ../../../../../packages/adapter-md/dist/index.js
+// ../adapter-md/dist/index.js
 import { readFile, writeFile, access } from "fs/promises";
 import { randomUUID as randomUUID6 } from "crypto";
 import { join } from "path";
 
-// ../../../../../packages/shared/dist/index.js
+// ../shared/dist/index.js
 var VALID_TRANSITIONS = {
   "Backlog": ["In Cycle", "Ready", "In Progress", "Blocked", "Cancelled", "Deferred", "Done"],
   "In Cycle": ["In Progress", "Backlog", "Blocked", "Cancelled"],
@@ -5114,7 +5167,7 @@ function isLiveDecision(d) {
   return true;
 }
 
-// ../../../../../packages/adapter-md/dist/index.js
+// ../adapter-md/dist/index.js
 import { randomUUID } from "crypto";
 import { randomUUID as randomUUID3 } from "crypto";
 import yaml from "js-yaml";
@@ -6617,14 +6670,27 @@ var MdFileAdapter = class {
       notes: review.notes
     });
   }
-  /** Get the cycle number of the last strategy review. */
-  async getLastStrategyReviewCycle() {
+  /**
+   * Get the cycle number of the last strategy review.
+   * task-2416 (C315): `excludeZoomOut` is accepted for interface parity with the pg
+   * adapter. The md adapter already matches strategy-review titles only (zoom-out logs
+   * carry a "Zoom-Out" title, not a strategy-review one), so the flag is a no-op here —
+   * legacy/best-effort path.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async getLastStrategyReviewCycle(_opts) {
     const log2 = await this.getCycleLog();
     const entry = log2.find(
       (e) => /strategy.*review|strategic.*shift/i.test(e.title)
     );
     return entry?.cycleNumber ?? 0;
   }
+  /** task-2416 (C315): cycle of the last zoom-out retrospective. md best-effort — matches the log title. */
+  async getLastZoomOutCycle() {
+    const log2 = await this.getCycleLog();
+    const entry = log2.find((e) => /zoom[-\s]?out/i.test(e.title));
+    return entry?.cycleNumber ?? 0;
+  }
   /** Get strategy reviews — md adapter returns empty (reviews live in cycle log). */
   async getStrategyReviews(_limit, _includeFullAnalysis) {
     return [];
@@ -7841,7 +7907,7 @@ async function createAdapter(optionsOrType, maybePapiDir) {
       return adapter2;
     }
     case "proxy": {
-      const { ProxyPapiAdapter: ProxyPapiAdapter2 } = await Promise.resolve().then(() => (init_proxy_adapter(), proxy_adapter_exports));
+      const { ProxyPapiAdapter: ProxyPapiAdapter2, wrapWithForwarding: wrapWithForwarding2 } = 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"];
@@ -7944,7 +8010,7 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
           console.error("[papi] Set PAPI_PROJECT_ID in .mcp.json to connect to an existing project.");
         }
       }
-      return adapter2;
+      return wrapWithForwarding2(adapter2);
     }
     default: {
       const _exhaustive = adapterType;
@@ -9060,6 +9126,16 @@ function buildPlanUserMessage(ctx) {
     if (ctx.board) {
       parts.push("### Board", "", ctx.board, "");
     }
+    if (ctx.resurfacedBlockers) {
+      parts.push(
+        "### Ready to Unblock (typed blockers now resolved)",
+        "",
+        "These tasks are Blocked but their typed dependency has cleared. Treat them as actionable candidates \u2014 resurface them into the cycle (or confirm they still belong Blocked), do not leave them sitting.",
+        "",
+        ctx.resurfacedBlockers,
+        ""
+      );
+    }
     if (ctx.candidateTaskFullNotes) {
       parts.push("### Full Notes for Candidate Tasks", "", ctx.candidateTaskFullNotes, "");
     }
@@ -9299,6 +9375,7 @@ IMPORTANT: You are running as a non-interactive API call. Do NOT ask the user qu
 - **Product impact first, process second.** The reader wants to know: what got better for users, what's broken, what opportunities exist. Internal machinery (AD wording, taxonomy labels, hierarchy status) is secondary \u2014 handle it in a compact appendix, not the main review.
 - **Lead with insight, not data recitation.** Open each section with the strategic takeaway or pattern, THEN support it with cycle data and task references. Bad: "C131 built task-700, C132 built task-710." Good: "The last 5 cycles show a clear shift from infrastructure to user-facing work \u2014 80% of tasks were dashboard or onboarding, up from 30% in the prior review window."
 - **Cycle data first, conversation context second.** Base your review on build reports, cycle logs, board state, and ADs \u2014 not on whatever was discussed earlier in the conversation. If recent conversation context conflicts with the data, flag it but trust the data.
+- **Verify before claiming \u2014 your context is a snapshot, not live state.** The task bodies, doc summaries, prior strategy reviews, and zoom-out framing you were given were written in the cycle they are dated; the product and codebase have moved since. Treat every present-tense claim about current product or code state \u2014 "X is broken", "Y only works in Z", "feature not built", "metric unmeasured", a stalled task "still needs building" \u2014 as a HYPOTHESIS to check, not a fact. If you have tools to inspect the live code or dashboard (grep, file read, running app), verify the claim before asserting it. If you cannot verify, attribute and hedge it explicitly ("per task-NNNN's C303 framing \u2014 unverified against current code") rather than stating it as current fact. A confident claim the reader can falsify in one grep destroys the review's credibility. **Stalled tasks are the highest-risk case:** a task sitting in Backlog for many cycles is frequently already shipped under another task and never closed \u2014 check the code before recommending you build, cancel, or defer it.
 - **Be concise and scannable.** Use short paragraphs, bullet points, and clear headings. Avoid walls of text. The review should be readable in 3 minutes, not 15. Format cycle summaries as compact bullet points, not multi-paragraph narratives.
 - **Every conditional section earns its place.** If a conditional section has nothing meaningful to say, skip it entirely. Do not write "No issues found" or "No concerns" \u2014 just omit the section.
 - **AD housekeeping is an appendix, not the centerpiece.** Just list changes and make them. Don't score every AD individually. Don't ask for approval on wording tweaks \u2014 small changes (confidence bumps, deleting stale ADs, fixing wording) should just happen. Only flag ADs that represent a genuine strategic question.
@@ -10584,6 +10661,52 @@ function computeCarryForwardStaleness(log2, doneTaskIds) {
   ].join("\n");
 }
 
+// src/lib/blocker.ts
+function idMatches(candidate, ref) {
+  if (!candidate) return false;
+  return candidate.toLowerCase() === ref.toLowerCase();
+}
+function isBlockerResolved(blocker, ctx) {
+  if (!blocker || !blocker.ref) return false;
+  switch (blocker.type) {
+    case "depends-on": {
+      const dep = ctx.tasks.find(
+        (t) => idMatches(t.displayId, blocker.ref) || idMatches(t.id, blocker.ref)
+      );
+      return dep?.status === "Done";
+    }
+    case "owner-action": {
+      const action = ctx.ownerActions.find((a) => idMatches(a.id, blocker.ref));
+      return action != null && action.completed_at != null;
+    }
+    case "decision-gate": {
+      const decision = ctx.decisions.find(
+        (d) => idMatches(d.displayId, blocker.ref) || idMatches(d.id, blocker.ref)
+      );
+      const resolvedOutcomes = /* @__PURE__ */ new Set(["resolved", "confirmed", "validated", "superseded"]);
+      if (decision?.outcome && resolvedOutcomes.has(decision.outcome)) return true;
+      const hasRecentEvent = ctx.decisionEvents.some(
+        (e) => idMatches(e.decisionId, blocker.ref) && e.cycle >= blocker.blockedCycle
+      );
+      return hasRecentEvent;
+    }
+    default:
+      return false;
+  }
+}
+function formatBlockerWaiting(blocker) {
+  switch (blocker.type) {
+    case "depends-on":
+      return `waiting on ${blocker.ref} \u2014 clears when that task is Done`;
+    case "owner-action":
+      return `waiting on owner action ${blocker.ref} \u2014 clears when you complete it`;
+    case "decision-gate":
+      return `waiting on decision ${blocker.ref} \u2014 clears when that decision is resolved`;
+    default:
+      return `waiting on ${blocker.ref}`;
+  }
+}
+
 // src/lib/visibility-inheritance.ts
 var TIER_RANK = {
   public: 0,
@@ -11016,6 +11139,28 @@ function computeFoundationalTasksGuidance(cycleNumber, brief) {
     "- User-submitted backlog tasks remain in `cycleHandoffs` as usual \u2014 do NOT drop them in favour of foundational tasks."
   ].join("\n");
 }
+async function computeResurfacedBlockers(adapter2, tasks, decisions, currentCycle) {
+  const blocked = tasks.filter((t) => t.status === "Blocked" && t.blocker);
+  if (blocked.length === 0) return void 0;
+  const minCycle = Math.max(0, currentCycle - 5);
+  const decisionEvents = adapter2.getDecisionEventsSince ? await adapter2.getDecisionEventsSince(minCycle).catch(() => []) : [];
+  let ownerActions = [];
+  if (adapter2.listOwnerActionsForBlockerScan && adapter2.getProjectOwnerUserId) {
+    try {
+      const userId = await adapter2.getProjectOwnerUserId();
+      if (userId) ownerActions = await adapter2.listOwnerActionsForBlockerScan(userId);
+    } catch {
+    }
+  }
+  const ctx = { tasks, decisions, decisionEvents, ownerActions };
+  const resolvedLines = [];
+  for (const t of blocked) {
+    if (t.blocker && isBlockerResolved(t.blocker, ctx)) {
+      resolvedLines.push(`- **${t.displayId}** (${t.title}) \u2014 ${formatBlockerWaiting(t.blocker)} \u2192 now RESOLVED, ready to unblock`);
+    }
+  }
+  return resolvedLines.length > 0 ? resolvedLines.join("\n") : void 0;
+}
 function detectBoardFlags(tasks) {
   let hasBugTasks = false;
   let hasResearchTasks = false;
@@ -11494,6 +11639,7 @@ ${logLines}`);
   const targetCycle = health.totalCycles + 1;
   const preAssigned = plannerTasks.filter((t2) => t2.cycle === targetCycle);
   const preAssignedText = formatPreAssignedTasks(preAssigned, targetCycle);
+  const resurfacedBlockersText = await computeResurfacedBlockers(adapter2, tasks, decisions, health.totalCycles).catch(() => void 0);
   const gapFull = health.cyclesSinceLastStrategyReview;
   const lastReviewCycleFull = health.totalCycles - gapFull;
   const strategyReviewCadenceFull = gapFull <= 0 ? `\u2713 Strategy review completed this cycle (C${health.totalCycles}). No carry-forward needed.` : gapFull < STRATEGY_REVIEW_OFFER_GAP ? `\u2713 Strategy review on track \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycle(s) ago). Next due: C${lastReviewCycleFull + STRATEGY_REVIEW_OFFER_GAP}.` : gapFull < STRATEGY_REVIEW_BLOCK_GAP ? `\u25CB Strategy review available \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycles ago). Offered now (optional); planning hard-blocks at ${STRATEGY_REVIEW_BLOCK_GAP} cycles.` : `\u26A0\uFE0F Strategy review overdue \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycles ago). Planning is blocked until it runs (or \`force: true\`).`;
@@ -11526,6 +11672,7 @@ ${logLines}`);
       doneTasksResultFull.status === "fulfilled" ? new Set(doneTasksResultFull.value.map((t2) => t2.displayId)) : void 0
     ),
     preAssignedTasks: preAssignedText,
+    resurfacedBlockers: resurfacedBlockersText,
     recentlyShippedCapabilities: formatRecentlyShippedCapabilities(reports),
     strategyReviewCadence: strategyReviewCadenceFull,
     candidateTaskFullNotes: formatCandidateTaskFullNotes(plannerTasks),
@@ -12519,6 +12666,8 @@ function buildSubagentDispatchPrompt(input) {
     applyNote = `\`plan\` again with mode="apply", llm_response=<sub-agent output>, plan_mode="${applyMode ?? "full"}", cycle_number=${cycleNumber + 1}, strategy_review_warning=${JSON.stringify(strategyReviewWarning)}`;
   } else if (tool === "strategy_review") {
     applyNote = `\`strategy_review\` again with mode="apply", llm_response=<sub-agent output>, cycle_number=${cycleNumber}`;
+  } else if (tool === "zoom_out") {
+    applyNote = `\`zoom_out\` again with mode="apply", llm_response=<sub-agent output>, cycle_number=${cycleNumber}`;
   } else {
     applyNote = `\`review_submit\` with task_id="${taskId ?? "<task-id>"}", stage="build-acceptance", verdict=<your decision: accept / request-changes / reject>, comments=<your reasoning>, and auto_review set to the sub-agent's JSON object verbatim. The sub-agent's verdict is a RECOMMENDATION \u2014 you make the final call`;
   }
@@ -14385,7 +14534,7 @@ function extractDecisionEvidence(ad, eventType, warnings) {
 async function writeBack2(adapter2, cycleNumber, data, fullAnalysis, warnings) {
   const cleanTitle = data.sessionLogTitle.replace(/^(?:Cycle|Session)\s+\d+\s*—\s*/i, "").trim();
   const cleanContent = data.sessionLogContent.replace(/^#{1,3}\s+(?:Cycle|Session)\s+\d+\s*—[^\n]*\n*/i, "").trim();
-  const lastReviewCycle = await adapter2.getLastStrategyReviewCycle();
+  const lastReviewCycle = await adapter2.getLastStrategyReviewCycle({ excludeZoomOut: true });
   const rangeStart = lastReviewCycle > 0 ? lastReviewCycle + 1 : cycleNumber;
   const cycleRange = rangeStart < cycleNumber ? `${rangeStart}-${cycleNumber}` : `${cycleNumber}`;
   const logBlock = `### Cycles ${cycleRange} \u2014 ${cleanTitle}
@@ -15188,7 +15337,7 @@ Confidence: ${input.confidence}. Captured mid-conversation via strategy_change c
 var reviewPrepareCache = new PerCallerCache();
 var strategyReviewTool = {
   name: "strategy_review",
-  description: 'Run a Strategy Review \u2014 assesses project direction, velocity, and Active Decisions. Produces recommendations and potential AD updates that feed into the next plan. Offered every 5 cycles; hard-blocked at 7+ overdue cycles. If your current session is already heavy with build context, running the review in a fresh session gives cleaner output \u2014 but a genuinely fresh session needs no restart, just run it. First call returns a review prompt for you to execute (prepare phase). Then call again with mode "apply" and your output. Pass `force: true` to run before the cadence gate.',
+  description: 'Run a Strategy Review \u2014 assesses project direction, velocity, and Active Decisions. Produces recommendations and potential AD updates that feed into the next plan. Offered every 5 cycles; hard-blocked at 7+ overdue cycles. Run it in your current conversation \u2014 only start a fresh one if you are genuinely under context pressure (your host just compacted, you are near the context limit, or the session is heavy with build context), not just because a review is next. First call returns a review prompt for you to execute (prepare phase). Then call again with mode "apply" and your output. Pass `force: true` to run before the cadence gate.',
   annotations: { readOnlyHint: false, destructiveHint: false },
   inputSchema: {
     type: "object",
@@ -15774,6 +15923,15 @@ var boardDeprioritiseTool = {
         type: "string",
         description: 'Why this task is being removed. Required for "cancel", recommended for "defer".'
       },
+      blocker_type: {
+        type: "string",
+        enum: ["depends-on", "decision-gate", "owner-action"],
+        description: 'Optional (action="block" only). Typed blocker so the plan/orient scan can auto-detect when the block clears. "depends-on" = another task must be Done (blocker_ref = task display-id). "decision-gate" = a decision must resolve (blocker_ref = AD/decision id). "owner-action" = an owner action must complete (blocker_ref = owner_action id). Omit for a reason-only block.'
+      },
+      blocker_ref: {
+        type: "string",
+        description: "Required when blocker_type is set. The identifier being waited on: a task display-id (depends-on), an AD/decision id (decision-gate), or an owner_action id (owner-action)."
+      },
       defer: {
         type: "boolean",
         description: 'DEPRECATED \u2014 use action instead. If true, equivalent to action="defer".'
@@ -16008,19 +16166,50 @@ async function handleBoardDeprioritise(adapter2, args) {
     if (!reason) {
       return errorResponse("reason is required when blocking a task \u2014 explain what external dependency or gate is blocking it.");
     }
+    const blockerType = args.blocker_type;
+    const blockerRef = args.blocker_ref;
+    const validTypes = /* @__PURE__ */ new Set(["depends-on", "decision-gate", "owner-action"]);
+    if (blockerType !== void 0 && !validTypes.has(blockerType)) {
+      return errorResponse(`blocker_type must be one of: depends-on, decision-gate, owner-action (got "${blockerType}").`);
+    }
+    if (blockerType !== void 0 && !blockerRef) {
+      return errorResponse("blocker_ref is required when blocker_type is set \u2014 provide the task display-id, decision id, or owner_action id being waited on.");
+    }
     try {
       const task = await adapter2.getTask(taskId);
       if (!task) return errorResponse(`Task ${taskId} not found.`);
       const existingNotes = task.notes ? `${task.notes}
 
 ` : "";
-      await adapter2.updateTask(taskId, {
+      const updates = {
         status: "Blocked",
         notes: `${existingNotes}BLOCKED: ${reason}`
-      });
+      };
+      let typedSuffix = "";
+      if (blockerType !== void 0 && blockerRef) {
+        const health = await adapter2.getCycleHealth().catch(() => null);
+        const blockedCycle = health?.totalCycles ?? 0;
+        updates.blocker = {
+          type: blockerType,
+          ref: blockerRef,
+          reason,
+          blockedCycle
+        };
+        typedSuffix = `
+
+Blocker: **${blockerType}** \u2192 ${blockerRef} (auto-unblock scanned at plan/orient).`;
+        if (blockerType === "owner-action" && adapter2.linkOwnerActionToTask && adapter2.getProjectOwnerUserId) {
+          try {
+            const ownerUserId = await adapter2.getProjectOwnerUserId();
+            if (ownerUserId) await adapter2.linkOwnerActionToTask(blockerRef, task.uuid, ownerUserId);
+          } catch {
+          }
+        }
+      }
+      await adapter2.updateTask(taskId, updates);
       return textResponse(`Blocked **${taskId}** (${task.title}).
 
-Reason: ${reason}
+Reason: ${reason}${typedSuffix}
 
 Task remains visible on the board but will be skipped by the planner and build_list.`);
     } catch (err) {
@@ -16632,7 +16821,7 @@ This is a one-time check at the start of the cycle, not per-task. It catches sco
 Every 5 cycles, PAPI offers a strategy review \u2014 a deep analysis of velocity, estimation accuracy, active decisions, and project direction.
 
 - **Don't skip them.** They're where compounding value comes from.
-- If your session is already heavy with build context, run the review fresh for cleaner output \u2014 a genuinely fresh session needs no restart.
+- Run the review in your current conversation \u2014 a fresh one is only warranted if you're genuinely under context pressure (your host just compacted, or you're near the limit), never just because a review is next.
 - Reviews produce recommendations that feed into the next plan.
 - If the review recommends AD changes, use \`strategy_change\` to apply them.
 
@@ -16757,7 +16946,7 @@ var DOCS_INDEX_TEMPLATE = `# {{project_name}} \u2014 Document Index
 Who or what reads this doc: \`planner\`, \`builder\`, \`strategy-review\`, \`user\`, \`onboarding\`.
 `;
 var CURSOR_RULES_TEMPLATE = `---
-description: PAPI \u2014 Persistent Adaptive Planning Intelligence
+description: PAPI cycle workflow for {{project_name}} \u2014 plan, build, review
 globs:
 alwaysApply: true
 ---
@@ -18450,40 +18639,62 @@ To override, pass force=true (emits a telemetry warning).`
   if (adapter2) {
     const currentCycle = resolvedCycleNum;
     if (currentCycle > 0) {
+      let existing;
       try {
-        let existing;
-        try {
-          existing = (await adapter2.readCycles()).find((c) => c.number === currentCycle);
-        } catch {
-        }
-        await adapter2.createCycle({
-          id: `cycle-${currentCycle}`,
-          number: currentCycle,
-          status: "complete",
-          startDate: existing?.startDate ?? (/* @__PURE__ */ new Date()).toISOString(),
-          endDate: (/* @__PURE__ */ new Date()).toISOString(),
-          goals: existing?.goals ?? [],
-          boardHealth: existing?.boardHealth ?? "",
-          taskIds: existing?.taskIds ?? []
-        });
-      } catch (err) {
-        const msg = `createCycle (mark complete) failed for cycle ${currentCycle}: ${err instanceof Error ? err.message : String(err)}`;
-        console.error(`[release] ${msg}`);
-        throw new Error(
-          `Release blocked \u2014 could not mark cycle ${currentCycle} complete in the DB. ${err instanceof Error ? err.message : String(err)}. Resolve the DB error and re-run \`release\`.`
-        );
+        existing = (await adapter2.readCycles()).find((c) => c.number === currentCycle);
+      } catch {
       }
-      if (adapter2.appendCycleMetrics && adapter2.getBuildReportsSince) {
+      const completedCycle = {
+        id: `cycle-${currentCycle}`,
+        number: currentCycle,
+        status: "complete",
+        startDate: existing?.startDate ?? (/* @__PURE__ */ new Date()).toISOString(),
+        endDate: (/* @__PURE__ */ new Date()).toISOString(),
+        goals: existing?.goals ?? [],
+        boardHealth: existing?.boardHealth ?? "",
+        taskIds: existing?.taskIds ?? []
+      };
+      let snapshot;
+      if (adapter2.getBuildReportsSince) {
         try {
           const cycleReports = (await adapter2.getBuildReportsSince(currentCycle)).filter((r) => r.cycle === currentCycle);
-          const [snapshot] = computeSnapshotsFromBuildReports(cycleReports);
-          if (snapshot) await adapter2.appendCycleMetrics(snapshot);
+          [snapshot] = computeSnapshotsFromBuildReports(cycleReports);
         } catch (err) {
           console.error(
-            `[release] cycle-metrics snapshot write failed for cycle ${currentCycle} (non-blocking): ${err instanceof Error ? err.message : String(err)}`
+            `[release] cycle-metrics snapshot compute failed for cycle ${currentCycle} (non-blocking): ${err instanceof Error ? err.message : String(err)}`
           );
         }
       }
+      if (typeof adapter2.commitRelease === "function") {
+        try {
+          await adapter2.commitRelease({ cycle: completedCycle, snapshot: snapshot ?? null });
+        } catch (err) {
+          const msg = `commitRelease (mark complete) failed for cycle ${currentCycle}: ${err instanceof Error ? err.message : String(err)}`;
+          console.error(`[release] ${msg}`);
+          throw new Error(
+            `Release blocked \u2014 could not mark cycle ${currentCycle} complete in the DB. ${err instanceof Error ? err.message : String(err)}. Resolve the DB error and re-run \`release\`.`
+          );
+        }
+      } else {
+        try {
+          await adapter2.createCycle(completedCycle);
+        } catch (err) {
+          const msg = `createCycle (mark complete) failed for cycle ${currentCycle}: ${err instanceof Error ? err.message : String(err)}`;
+          console.error(`[release] ${msg}`);
+          throw new Error(
+            `Release blocked \u2014 could not mark cycle ${currentCycle} complete in the DB. ${err instanceof Error ? err.message : String(err)}. Resolve the DB error and re-run \`release\`.`
+          );
+        }
+        if (adapter2.appendCycleMetrics && snapshot) {
+          try {
+            await adapter2.appendCycleMetrics(snapshot);
+          } catch (err) {
+            console.error(
+              `[release] cycle-metrics snapshot write failed for cycle ${currentCycle} (non-blocking): ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
     }
   }
   return { resolvedCycleNum, warnings, force, skipVersion };
@@ -19137,18 +19348,26 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
 }
 
 // src/lib/owns-local-workspace.ts
-async function ownsLocalWorkspace(adapter2, cwd) {
-  if (!adapter2.getProjectInfo) return false;
+async function resolveWorkspaceOwners(adapter2, cwd) {
+  const empty = { storedOwner: null, remoteOwner: null, remoteSlug: null };
+  if (!adapter2.getProjectInfo) return empty;
   try {
     const info = await adapter2.getProjectInfo();
-    const storedOwner = parseGithubOwner(info?.repo_url ?? null);
-    const remoteOwner = parseGithubOwner(getOriginRepoSlug(cwd));
-    if (!storedOwner || !remoteOwner) return false;
-    return storedOwner === remoteOwner;
+    const remoteSlug = getOriginRepoSlug(cwd);
+    return {
+      storedOwner: parseGithubOwner(info?.repo_url ?? null),
+      remoteOwner: parseGithubOwner(remoteSlug),
+      remoteSlug
+    };
   } catch {
-    return false;
+    return empty;
   }
 }
+async function ownsLocalWorkspace(adapter2, cwd) {
+  const { storedOwner, remoteOwner } = await resolveWorkspaceOwners(adapter2, cwd);
+  if (!storedOwner || !remoteOwner) return false;
+  return storedOwner === remoteOwner;
+}
 
 // src/services/build.ts
 init_git();
@@ -19939,7 +20158,24 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}, cli
     } catch {
     }
   }
-  await adapter2.appendBuildReport(report);
+  const surpriseNote = input.surprises === "None" ? "" : ` Surprises: ${input.surprises}.`;
+  const issueNote = input.discoveredIssues === "None" ? "" : ` Issues: ${input.discoveredIssues}.`;
+  const iterNote = iterationCount > 1 ? ` Iterations: ${iterationCount} (${iterationCount - 1} pushback${iterationCount > 2 ? "s" : ""}).` : "";
+  const buildReportSummary = `${capitalizeCompleted(input.completed)}. Effort ${input.effort} vs estimated ${input.estimatedEffort}.${iterNote}${surpriseNote}${issueNote}`;
+  const statusChange = input.completed === "yes" ? { from: task.status, to: options.light ? "Done" : "In Review" } : void 0;
+  let atomicCommitDone = false;
+  if (typeof adapter2.commitBuildComplete === "function") {
+    await adapter2.commitBuildComplete({
+      report,
+      taskId,
+      buildReportSummary,
+      statusChange,
+      cycle: cycleNumber
+    });
+    atomicCommitDone = true;
+  } else {
+    await adapter2.appendBuildReport(report);
+  }
   let reportWriteVerified;
   if (typeof adapter2.getBuildReportCountForTask === "function") {
     try {
@@ -20080,16 +20316,14 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}, cli
   if (task.cycle == null && cycleNumber > 0) {
     await adapter2.updateTask(taskId, { cycle: cycleNumber });
   }
-  const surpriseNote = input.surprises === "None" ? "" : ` Surprises: ${input.surprises}.`;
-  const issueNote = input.discoveredIssues === "None" ? "" : ` Issues: ${input.discoveredIssues}.`;
-  const iterNote = iterationCount > 1 ? ` Iterations: ${iterationCount} (${iterationCount - 1} pushback${iterationCount > 2 ? "s" : ""}).` : "";
-  const buildReportSummary = `${capitalizeCompleted(input.completed)}. Effort ${input.effort} vs estimated ${input.estimatedEffort}.${iterNote}${surpriseNote}${issueNote}`;
-  await adapter2.updateTask(taskId, { buildReport: buildReportSummary });
-  if (input.completed === "yes") {
-    if (options.light) {
-      await adapter2.updateTaskStatus(taskId, "Done");
-    } else {
-      await adapter2.updateTaskStatus(taskId, "In Review");
+  if (!atomicCommitDone) {
+    await adapter2.updateTask(taskId, { buildReport: buildReportSummary });
+    if (input.completed === "yes") {
+      if (options.light) {
+        await adapter2.updateTaskStatus(taskId, "Done");
+      } else {
+        await adapter2.updateTaskStatus(taskId, "In Review");
+      }
     }
   }
   let dogfoodResolvedCount = 0;
@@ -20358,7 +20592,7 @@ import { homedir as homedir3 } from "os";
 import { randomUUID as randomUUID12 } from "crypto";
 var docRegisterTool = {
   name: "doc_register",
-  description: "Register a document in the doc registry. Called after finalising a research/planning doc, or when build_execute detects unregistered docs. Stores metadata and structured summary \u2014 not full content.",
+  description: "Register or update a document in the doc registry. Called after finalising a research/planning doc, or when build_execute detects unregistered docs. Stores metadata and structured summary \u2014 not full content. Re-registering an existing doc updates its summary, tags, actions, type, and status (upsert). Visibility and owner are not changed on re-register.",
   annotations: { readOnlyHint: false, destructiveHint: false },
   inputSchema: {
     type: "object",
@@ -22654,10 +22888,20 @@ Re-run build_execute complete with a production_verification field, then re-subm
   if (input.autoReview) {
     review.autoReview = input.autoReview;
   }
-  await adapter2.writeReview(review);
   const newStatus = resolveStatus(input.stage, input.verdict);
-  if (newStatus) {
-    await adapter2.updateTaskStatus(input.taskId, newStatus);
+  const statusChange = newStatus ? { from: task.status, to: newStatus } : void 0;
+  if (typeof adapter2.commitReviewSubmit === "function") {
+    await adapter2.commitReviewSubmit({
+      review,
+      taskId: input.taskId,
+      statusChange,
+      cycle
+    });
+  } else {
+    await adapter2.writeReview(review);
+    if (newStatus) {
+      await adapter2.updateTaskStatus(input.taskId, newStatus);
+    }
   }
   const unblockedTasks = [];
   if (newStatus === "Done") {
@@ -23883,6 +24127,14 @@ ${writeNote}
 }
 
 // src/services/health.ts
+function computeZoomOutWarning(cycleNumber, lastZoomOutCycle) {
+  if (cycleNumber <= 0) return "";
+  const baseline = lastZoomOutCycle > 0 ? lastZoomOutCycle : 1;
+  const gap = cycleNumber - baseline;
+  if (gap < ZOOM_OUT_OFFER_GAP) return "";
+  const ran = lastZoomOutCycle > 0 ? `last run Cycle ${lastZoomOutCycle}` : "never run";
+  return `\u25CB Zoom-out available \u2014 ${gap} cycles since last zoom-out (${ran}). QBR/all-hands tier above strategy review; offer-only, no block. Run \`zoom_out\` to read the full project arc.`;
+}
 function computeHealthScore(cycleNumber, snapshots, activeTasks, decisionUsage) {
   if (cycleNumber < 3) return null;
   const scores = [];
@@ -23952,6 +24204,12 @@ async function getHealthSummary(adapter2) {
   const reviewGateBlocking = cyclesSinceReview >= STRATEGY_REVIEW_BLOCK_GAP;
   const reviewAvailable = cyclesSinceReview >= STRATEGY_REVIEW_OFFER_GAP && !reviewGateBlocking;
   const reviewWarning = reviewGateBlocking ? `\u26A0\uFE0F  GATE \u2014 ${cyclesSinceReview} cycles since last Strategy Review. \`plan\` is blocked until \`strategy_review\` runs (or \`force: true\`).` : reviewAvailable ? `\u25CB Strategy review available \u2014 ${cyclesSinceReview} cycles since last review. Offered now (optional); \`plan\` hard-blocks at ${STRATEGY_REVIEW_BLOCK_GAP} cycles.` : `\u2713 On track \u2014 ${cyclesSinceReview} cycle(s) since last review. Next due: ${reviewDue}`;
+  let zoomOutWarning = "";
+  try {
+    const lastZoomOutCycle = adapter2.getLastZoomOutCycle ? await adapter2.getLastZoomOutCycle() : 0;
+    zoomOutWarning = computeZoomOutWarning(cycleNumber, lastZoomOutCycle);
+  } catch {
+  }
   const deferredCount = activeTasks.filter((t) => t.status === "Deferred").length;
   const nonDeferredTasks = activeTasks.filter((t) => t.status !== "Deferred");
   const statusCounts = countByStatus(nonDeferredTasks);
@@ -24105,6 +24363,7 @@ ${lines.join("\n")}`;
     latestCycleStatus: health.latestCycleStatus,
     connectionStatus: getConnectionStatus(),
     reviewWarning,
+    zoomOutWarning,
     boardSummary,
     staleTasks,
     inReviewSummary,
@@ -24182,6 +24441,30 @@ async function findUnblockCandidates(adapter2, currentCycle) {
   } catch {
     return [];
   }
+  const blockedTasks = allTasks.filter((t) => t.status === "Blocked");
+  if (blockedTasks.length === 0) return [];
+  const ctx = await buildResolverContext(adapter2, allTasks, currentCycle).catch(
+    () => ({ tasks: allTasks, decisions: [], decisionEvents: [], ownerActions: [] })
+  );
+  const candidates = [];
+  for (const blocked of blockedTasks) {
+    if (candidates.length >= MAX_CANDIDATES) break;
+    const blocker = blocked.blocker;
+    if (!blocker) continue;
+    const resolved = isBlockerResolved(blocker, ctx);
+    candidates.push({
+      blockedId: blocked.displayId ?? blocked.id,
+      blockedTitle: blocked.title,
+      blockerId: blocker.ref,
+      blockerTitle: "",
+      blockerCycle: blocker.blockedCycle,
+      typed: {
+        kind: blocker.type,
+        waiting: formatBlockerWaiting(blocker),
+        resolved
+      }
+    });
+  }
   const minCycle = Math.max(0, currentCycle - RECENT_CYCLE_WINDOW + 1);
   const recentDoneById = /* @__PURE__ */ new Map();
   for (const t of allTasks) {
@@ -24190,42 +24473,71 @@ async function findUnblockCandidates(adapter2, currentCycle) {
     if (cycle < minCycle) continue;
     if (t.displayId) recentDoneById.set(t.displayId.toLowerCase(), t);
   }
-  if (recentDoneById.size === 0) return [];
-  const candidates = [];
-  for (const blocked of allTasks) {
-    if (blocked.status !== "Blocked") continue;
-    const notes = blocked.notes ?? "";
-    if (!notes) continue;
-    const matches = notes.match(TASK_REF);
-    if (!matches) continue;
-    const seen = /* @__PURE__ */ new Set();
-    for (const raw of matches) {
-      const key = raw.toLowerCase();
-      if (seen.has(key)) continue;
-      seen.add(key);
-      if (blocked.displayId && key === blocked.displayId.toLowerCase()) continue;
-      const blocker = recentDoneById.get(key);
-      if (!blocker) continue;
-      candidates.push({
-        blockedId: blocked.displayId ?? blocked.id,
-        blockedTitle: blocked.title,
-        blockerId: blocker.displayId ?? blocker.id,
-        blockerTitle: blocker.title,
-        blockerCycle: blocker.cycle ?? 0
-      });
-      break;
+  if (recentDoneById.size > 0) {
+    for (const blocked of blockedTasks) {
+      if (candidates.length >= MAX_CANDIDATES) break;
+      if (blocked.blocker) continue;
+      const notes = blocked.notes ?? "";
+      if (!notes) continue;
+      const matches = notes.match(TASK_REF);
+      if (!matches) continue;
+      const seen = /* @__PURE__ */ new Set();
+      for (const raw of matches) {
+        const key = raw.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        if (blocked.displayId && key === blocked.displayId.toLowerCase()) continue;
+        const blocker = recentDoneById.get(key);
+        if (!blocker) continue;
+        candidates.push({
+          blockedId: blocked.displayId ?? blocked.id,
+          blockedTitle: blocked.title,
+          blockerId: blocker.displayId ?? blocker.id,
+          blockerTitle: blocker.title,
+          blockerCycle: blocker.cycle ?? 0
+        });
+        break;
+      }
     }
-    if (candidates.length >= MAX_CANDIDATES) break;
   }
   return candidates;
 }
+async function buildResolverContext(adapter2, tasks, currentCycle) {
+  const decisions = adapter2.getActiveDecisions ? await adapter2.getActiveDecisions().catch(() => []) : [];
+  const minCycle = Math.max(0, currentCycle - RECENT_CYCLE_WINDOW);
+  const decisionEvents = adapter2.getDecisionEventsSince ? await adapter2.getDecisionEventsSince(minCycle).catch(() => []) : [];
+  let ownerActions = [];
+  if (adapter2.listOwnerActionsForBlockerScan && adapter2.getProjectOwnerUserId) {
+    try {
+      const userId = await adapter2.getProjectOwnerUserId();
+      if (userId) ownerActions = await adapter2.listOwnerActionsForBlockerScan(userId);
+    } catch {
+    }
+  }
+  return { tasks, decisions, decisionEvents, ownerActions };
+}
 function formatUnblockSection(candidates) {
   if (candidates.length === 0) return "";
+  const resolved = candidates.filter((c) => c.typed?.resolved || !c.typed);
+  const stillWaiting = candidates.filter((c) => c.typed && !c.typed.resolved);
   const lines = ["## Unblock Candidates"];
-  lines.push(`${candidates.length} blocked task(s) may now be unblocked \u2014 run \`board_reconcile\` to promote.`);
-  lines.push("");
-  for (const c of candidates) {
-    lines.push(`- **${c.blockedId}** (${c.blockedTitle}) \u2014 blocker **${c.blockerId}** Done in C${c.blockerCycle}`);
+  if (resolved.length > 0) {
+    lines.push(`${resolved.length} blocked task(s) ready to unblock \u2014 run \`board_reconcile\` to promote.`);
+    lines.push("");
+    for (const c of resolved) {
+      if (c.typed) {
+        lines.push(`- **${c.blockedId}** (${c.blockedTitle}) \u2014 ${c.typed.kind}: ${c.blockerId} now resolved \u2705`);
+      } else {
+        lines.push(`- **${c.blockedId}** (${c.blockedTitle}) \u2014 blocker **${c.blockerId}** Done in C${c.blockerCycle}`);
+      }
+    }
+  }
+  if (stillWaiting.length > 0) {
+    if (resolved.length > 0) lines.push("");
+    lines.push(`${stillWaiting.length} still blocked:`);
+    for (const c of stillWaiting) {
+      lines.push(`- **${c.blockedId}** (${c.blockedTitle}) \u2014 ${c.typed.waiting}`);
+    }
   }
   return lines.join("\n");
 }
@@ -24554,6 +24866,10 @@ function formatOrientSummary(health, buildInfo, hierarchy, latestTag, projectRoo
   lines.push("");
   lines.push(`**Strategy Review:** ${health.reviewWarning}`);
   lines.push("");
+  if (health.zoomOutWarning) {
+    lines.push(`**Zoom-Out:** ${health.zoomOutWarning}`);
+    lines.push("");
+  }
   if (hierarchy) {
     lines.push(`**Position:** ${hierarchy.horizon} \u2192 ${hierarchy.stage}`);
     if (hierarchy.activePhases.length > 0) {
@@ -25258,6 +25574,21 @@ async function handleOrient(adapter2, config2, args = {}, clientName) {
       for (const w of verifyWarnings) buildResult.warnings.push(w);
     } catch {
     }
+    try {
+      if (hasLocalWorkspace() && adapter2.getProjectInfo) {
+        const { storedOwner, remoteOwner, remoteSlug } = await resolveWorkspaceOwners(adapter2, config2.projectRoot);
+        if (storedOwner && remoteOwner && storedOwner !== remoteOwner) {
+          buildResult.warnings.push(
+            `\u26A0\uFE0F Project mismatch \u2014 this PAPI project is bound to owner '${storedOwner}' but the cwd git remote points to owner '${remoteOwner}'. Run \`project_switch\` to the right project, or update the project's repo_url.`
+          );
+        } else if (!storedOwner && remoteOwner) {
+          buildResult.warnings.push(
+            `\u2139\uFE0F repo_url not set on this project \u2014 cwd git remote is '${remoteSlug}'. Run \`setup\` to capture it so the mismatch guard can fire.`
+          );
+        }
+      }
+    } catch {
+    }
     const ttfvNote = ttfvOutcome.status === "fulfilled" ? ttfvOutcome.value : "";
     const latestTag = latestTagOutcome.status === "fulfilled" ? latestTagOutcome.value : "";
     const versionDrift = versionDriftOutcome.status === "fulfilled" ? versionDriftOutcome.value : void 0;
@@ -25772,7 +26103,8 @@ async function prepareZoomOut(adapter2, projectRoot) {
   return {
     cycleNumber,
     systemPrompt: ZOOM_OUT_SYSTEM_PROMPT,
-    userMessage
+    userMessage,
+    contextBytes: Buffer.byteLength(userMessage, "utf-8")
   };
 }
 async function applyZoomOut(adapter2, llmResponse, cycleNumber) {
@@ -25780,7 +26112,8 @@ async function applyZoomOut(adapter2, llmResponse, cycleNumber) {
     cycleNumber,
     title: `Zoom-Out Retrospective \u2014 Cycle ${cycleNumber}`,
     content: llmResponse.slice(0, 500),
-    fullAnalysis: llmResponse
+    fullAnalysis: llmResponse,
+    reviewType: "zoom_out"
   });
   return {
     cycleNumber,
@@ -25808,6 +26141,11 @@ var zoomOutTool = {
       cycle_number: {
         type: "number",
         description: 'The cycle number from prepare phase (mode "apply" only).'
+      },
+      dispatch: {
+        type: "string",
+        enum: ["inline", "subagent"],
+        description: '"inline" (default) returns the retrospective prompt for the calling LLM to execute directly. "subagent" returns a Task() invocation prompt to dispatch the heavyweight reasoning to a fresh sub-agent. The apply-phase contract is unchanged either way. Auto-routes to "subagent" past the same context threshold plan/strategy_review use (zoom_out runs the largest context of any tool).'
       }
     },
     required: []
@@ -25835,6 +26173,26 @@ Retrospective saved. Use insights to inform your next \`strategy_review\` or \`p
     }
     {
       const result = await prepareZoomOut(adapter2, config2.projectRoot);
+      const autoDispatchEnabled = process.env.PAPI_AUTO_DISPATCH !== "false";
+      const autoDispatchThreshold = 50 * 1024;
+      let dispatch;
+      if (args.dispatch === "inline" || args.dispatch === "subagent") {
+        dispatch = args.dispatch;
+      } else if (autoDispatchEnabled && result.contextBytes > autoDispatchThreshold) {
+        dispatch = "subagent";
+      } else {
+        dispatch = "inline";
+      }
+      if (dispatch === "subagent") {
+        const dispatchPrompt = buildSubagentDispatchPrompt({
+          tool: "zoom_out",
+          cycleNumber: result.cycleNumber,
+          systemPrompt: result.systemPrompt,
+          userMessage: result.userMessage,
+          contextBytes: result.contextBytes
+        });
+        return textResponse(dispatchPrompt);
+      }
       return textResponse(
         `## PAPI Zoom-Out Retrospective \u2014 Prepare Phase (Cycle ${result.cycleNumber})
 
@@ -26630,7 +26988,7 @@ var contributorRemoveTool = {
 };
 var contributorListTool = {
   name: "contributor_list",
-  description: "List the current project's contributors (owner-only). Shows each member's email, display name, role, and join date. Does not call the Anthropic API.",
+  description: "List the current project's contributors (any project member). Shows each member's email, display name, role, and join date. Does not call the Anthropic API.",
   annotations: { readOnlyHint: true, destructiveHint: false },
   inputSchema: {
     type: "object",
@@ -26643,10 +27001,15 @@ var contributorListTool = {
     required: []
   }
 };
-async function denyUnlessOwner(adapter2, config2) {
+function denyUnlessCohortCapable(adapter2) {
   if (typeof adapter2.listContributors !== "function") {
     return "Contributor management is not available on this adapter (requires the pg or proxy adapter \u2014 the local md adapter has no cohort).";
   }
+  return null;
+}
+async function denyUnlessOwner(adapter2, config2) {
+  const capDenied = denyUnlessCohortCapable(adapter2);
+  if (capDenied) return capDenied;
   const gate = await resolveOwnerGate(adapter2, config2);
   if (gate.enforced && !gate.callerIsOwner) {
     const note = gate.resolutionError ? ` (Identity resolution failed: ${gate.resolutionError} \u2014 the gate fails closed; retry once connectivity is restored.)` : "";
@@ -26654,6 +27017,17 @@ async function denyUnlessOwner(adapter2, config2) {
   }
   return null;
 }
+async function denyUnlessMember(adapter2, config2) {
+  const capDenied = denyUnlessCohortCapable(adapter2);
+  if (capDenied) return capDenied;
+  const gate = await resolveOwnerGate(adapter2, config2);
+  if (!gate.enforced) return null;
+  if (gate.callerIsOwner) return null;
+  const callerRole = gate.callerUserId && typeof adapter2.getContributorRole === "function" ? await adapter2.getContributorRole(gate.callerUserId).catch(() => null) : null;
+  if (callerRole) return null;
+  const note = gate.resolutionError ? ` (Identity resolution failed: ${gate.resolutionError} \u2014 the gate fails closed; retry once connectivity is restored.)` : "";
+  return `Listing contributors is restricted to project members. Your identity does not match this project's owner or any contributor.${note}`;
+}
 var EMAIL_SHAPE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 function requireEmail(args) {
   const email = typeof args.email === "string" ? args.email.trim() : "";
@@ -26693,7 +27067,7 @@ async function handleContributorRemove(adapter2, config2, args) {
   }
 }
 async function handleContributorList(adapter2, config2, _args) {
-  const denied = await denyUnlessOwner(adapter2, config2);
+  const denied = await denyUnlessMember(adapter2, config2);
   if (denied) return errorResponse(denied);
   try {
     const entries = await adapter2.listContributors();
@@ -27308,7 +27682,10 @@ var LONG_RUNNING_TOOLS = /* @__PURE__ */ new Set([
   "release",
   "setup",
   "doc_register",
-  "doc_scan"
+  "doc_scan",
+  // task-2416 (C315): zoom_out assembles a 120–150K-char context and, hosted, fans out
+  // ~14 proxied HTTP round-trips — well over the 30s default. See zoom-out-tooling-audit-c313.md #3.
+  "zoom_out"
 ]);
 function toolTimeoutMs(name) {
   return LONG_RUNNING_TOOLS.has(name) ? LONG_TOOL_TIMEOUT_MS : DEFAULT_TOOL_TIMEOUT_MS;