@papi-ai/server 0.7.44 → 0.7.46

package/dist/index.js

@@ -1280,6 +1280,10 @@ var init_proxy_adapter = __esm({
       "claimReview",
       "getSiblingAds",
       "getSiblingRepoTasks"
+      // 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
+      // from NO_FORWARD (was the task-2484 pg-only gap) — hosted parity restored.
     ]);
     ProxyPapiAdapter = class _ProxyPapiAdapter {
       endpoint;
@@ -1989,7 +1993,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);
@@ -2001,7 +2005,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();
@@ -2132,7 +2136,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(
@@ -2170,7 +2174,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) {
@@ -2188,7 +2192,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) {
@@ -2303,7 +2307,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();
@@ -2482,10 +2486,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() {
@@ -2505,7 +2509,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;
@@ -2532,13 +2536,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;
@@ -2552,7 +2556,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);
@@ -2617,7 +2621,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";
@@ -3411,7 +3415,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();
@@ -3474,7 +3478,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;
@@ -3685,14 +3689,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) => {
@@ -3758,12 +3762,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
@@ -4153,7 +4157,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();
@@ -5043,6 +5047,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;
@@ -5060,6 +5065,9 @@ function loadConfig() {
   const projectOwner = process.env.PAPI_OWNER ?? "Cathal";
   const skipProjectSpecificRules = process.env.PAPI_SKIP_PROJECT_RULES === "true";
   const userId = process.env.PAPI_USER_ID || void 0;
+  const gateCommand = process.env.PAPI_GATE?.trim() || void 0;
+  const deployCommand = process.env.PAPI_DEPLOY?.trim() || void 0;
+  const verifyCommand = process.env.PAPI_VERIFY?.trim() || void 0;
   const telemetryEnabled = process.env.PAPI_TELEMETRY !== "off" && process.env.PAPI_TELEMETRY !== "false";
   const papiEndpoint = process.env.PAPI_ENDPOINT;
   const dataEndpoint = process.env.PAPI_DATA_ENDPOINT;
@@ -5134,7 +5142,10 @@ Already have an account? Make sure PAPI_USER_ID is set in your .mcp.json env con
     skipProjectSpecificRules,
     userId,
     telemetryEnabled,
-    resolutionMethod
+    resolutionMethod,
+    gateCommand,
+    deployCommand,
+    verifyCommand
   };
 }
 
@@ -5142,31 +5153,18 @@ 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
-var VALID_TRANSITIONS = {
-  "Backlog": ["In Cycle", "Ready", "In Progress", "Blocked", "Cancelled", "Deferred", "Done"],
-  "In Cycle": ["In Progress", "Backlog", "Blocked", "Cancelled"],
-  "Ready": ["In Progress", "Backlog", "Blocked", "Cancelled"],
-  "In Progress": ["In Review", "Backlog", "Blocked", "Cancelled"],
-  "In Review": ["Done", "In Progress", "Blocked", "Cancelled"],
-  "Done": [],
-  "Blocked": ["Backlog", "Ready", "In Cycle", "In Progress", "Cancelled"],
-  "Cancelled": [],
-  "Deferred": ["Backlog", "Cancelled"]
-};
-var RETIRED_DECISION_OUTCOMES = ["resolved", "abandoned", "superseded"];
-function isLiveDecision(d) {
-  if (d.superseded === true) return false;
-  if (d.outcome != null && RETIRED_DECISION_OUTCOMES.includes(d.outcome)) return false;
-  return true;
-}
-
-// ../../../../../packages/adapter-md/dist/index.js
+import {
+  VALID_TRANSITIONS as _VALID_TRANSITIONS,
+  isValidTransition as _isValidTransition,
+  validateTransition as _validateTransition,
+  isValidStatus as _isValidStatus,
+  isLiveDecision as _isLiveDecision,
+  RETIRED_DECISION_OUTCOMES as _RETIRED_DECISION_OUTCOMES
+} from "@papi-ai/shared";
 import { randomUUID } from "crypto";
 import { randomUUID as randomUUID3 } from "crypto";
 import yaml from "js-yaml";
@@ -5175,8 +5173,8 @@ import { randomUUID as randomUUID4 } from "crypto";
 import { randomUUID as randomUUID5 } from "crypto";
 import yaml2 from "js-yaml";
 import yaml3 from "js-yaml";
-var VALID_TRANSITIONS2 = VALID_TRANSITIONS;
-var isLiveDecision2 = isLiveDecision;
+var VALID_TRANSITIONS = _VALID_TRANSITIONS;
+var isLiveDecision = _isLiveDecision;
 function extractSection(content, heading) {
   const headingPattern = new RegExp(`^## ${heading}\\s*$`, "m");
   const start = content.search(headingPattern);
@@ -6477,6 +6475,7 @@ function toCycle(raw) {
   };
   if (raw.end_date) cycle.endDate = raw.end_date;
   if (raw.user_id) cycle.userId = raw.user_id;
+  if (raw.dependency_chain) cycle.dependencyChain = raw.dependency_chain;
   return cycle;
 }
 function fromCycle(cycle) {
@@ -6491,6 +6490,7 @@ function fromCycle(cycle) {
   };
   if (cycle.endDate) raw.end_date = cycle.endDate;
   if (cycle.userId) raw.user_id = cycle.userId;
+  if (cycle.dependencyChain) raw.dependency_chain = cycle.dependencyChain;
   return raw;
 }
 function extractYamlBlock2(content) {
@@ -6535,7 +6535,7 @@ function prependCycle(cycle, content) {
     const yamlStr = yaml2.dump({ cycles: [raw] }, { lineWidth: 120, quotingType: '"' });
     return header + YAML_START2 + "\n" + yamlStr + YAML_END2 + "\n";
   }
-  const existing = parseCycles(content);
+  const existing = parseCycles(content).filter((c) => c.number !== cycle.number);
   const merged = [cycle, ...existing];
   return serializeCycles(merged, content);
 }
@@ -6632,7 +6632,7 @@ var MdFileAdapter = class {
     if (!content) return [];
     const all = parseActiveDecisions(content);
     if (options?.includeRetired) return all;
-    return all.filter(isLiveDecision2);
+    return all.filter(isLiveDecision);
   }
   /** Read cycle log entries (newest first), optionally limited to {@link limit} entries. */
   async getCycleLog(limit) {
@@ -6669,14 +6669,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 [];
@@ -6787,7 +6800,7 @@ var MdFileAdapter = class {
     }
     if (updates.status && updates.status !== tasks[idx].status && !options?.force) {
       const from = tasks[idx].status;
-      const allowed = VALID_TRANSITIONS2[from];
+      const allowed = VALID_TRANSITIONS[from];
       if (!allowed.includes(updates.status)) {
         console.warn(`[papi] Warning: invalid status transition "${from}" \u2192 "${updates.status}" for task ${id}. Allowed from "${from}": ${allowed.length > 0 ? allowed.join(", ") : "none"}`);
       }
@@ -9112,6 +9125,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, "");
     }
@@ -9249,6 +9272,14 @@ function buildHandoffsOnlyUserMessage(inputs) {
   }
   return parts.join("\n");
 }
+function extractDependencyChain(displayText) {
+  const match = displayText.match(
+    /^##\s+Dependency Chain[^\n]*\n([\s\S]*?)(?=\n#{2,3}\s|$(?![\s\S]))/m
+  );
+  if (!match) return void 0;
+  const body = match[1].trim();
+  return body.length > 0 ? body : void 0;
+}
 function parseStructuredOutput(raw) {
   const marker = "<!-- PAPI_STRUCTURED_OUTPUT -->";
   const markerIdx = raw.indexOf(marker);
@@ -9264,6 +9295,7 @@ function parseStructuredOutput(raw) {
   try {
     const parsed = JSON.parse(jsonMatch[1].trim());
     const data = coerceStructuredOutput(parsed);
+    data.dependencyChain = extractDependencyChain(displayText);
     return { displayText, data };
   } catch {
     return { displayText, data: null };
@@ -9351,6 +9383,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.
@@ -10636,6 +10669,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,
@@ -11068,6 +11147,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;
@@ -11546,6 +11647,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\`).`;
@@ -11578,6 +11680,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),
@@ -11651,8 +11754,27 @@ ${cleanContent}`;
     contextHashes,
     // task-2071 (MU-3): own the cycle by the planning member (pg defaults to the
     // project owner when unset, so owner-operated plans stay correct).
-    ...options.ownerUserId ? { userId: options.ownerUserId } : {}
+    ...options.ownerUserId ? { userId: options.ownerUserId } : {},
+    // task-2483 (C319): persist the plan's Dependency Chain build-order markdown.
+    ...data.dependencyChain ? { dependencyChain: data.dependencyChain } : {}
   };
+  const earlyCreateWarnings = [];
+  try {
+    await adapter2.createCycle({
+      id: `cycle-${newCycleNumber}`,
+      number: newCycleNumber,
+      status: "active",
+      startDate: cycle.startDate,
+      goals: cycle.goals,
+      boardHealth: "",
+      taskIds: [],
+      ...cycle.userId ? { userId: cycle.userId } : {}
+    });
+  } catch (err) {
+    const msg = `early createCycle failed for cycle ${newCycleNumber}: ${err instanceof Error ? err.message : String(err)}`;
+    console.error(`[plan] ${msg}`);
+    earlyCreateWarnings.push(msg);
+  }
   let dedupedNewTasks = data.newTasks ?? [];
   if (dedupedNewTasks.length > 0) {
     const existingTasks = await adapter2.queryBoard({ compact: true });
@@ -11745,7 +11867,7 @@ ${cleanContent}`;
       `Plan write-back created ${actualNewTasks} of ${expectedNewTasks} new tasks the transaction was asked to create \u2014 investigate the planWriteBack handler. (This count is returned by the committed transaction, not a board re-read, so it is not a hosted read-lag artifact.)`
     );
   }
-  const allWarnings = [...result.warnings, ...verifyWarnings];
+  const allWarnings = [...result.warnings, ...verifyWarnings, ...earlyCreateWarnings];
   const handoffCount = data.cycleHandoffs?.length ?? 0;
   const correctionCount = data.boardCorrections?.length ?? 0;
   const newTaskCount = result.newTaskIdMap.size;
@@ -11785,6 +11907,23 @@ ${cleanContent}`;
   });
   const cycleTaskCount = legacyHandoffs.length;
   const cycleEffortPoints = legacyHandoffs.reduce((sum, h) => sum + (effortMap[h.handoff.effort] ?? 3), 0);
+  try {
+    await adapter2.createCycle({
+      id: `cycle-${newCycleNumber}`,
+      number: newCycleNumber,
+      status: "active",
+      startDate: (/* @__PURE__ */ new Date()).toISOString(),
+      goals: data.cycleLogTitle ? [data.cycleLogTitle] : [],
+      boardHealth: "",
+      taskIds: [],
+      contextHashes,
+      ...options.ownerUserId ? { userId: options.ownerUserId } : {}
+    });
+  } catch (err) {
+    const msg = `early createCycle failed for cycle ${newCycleNumber}: ${err instanceof Error ? err.message : String(err)}`;
+    console.error(`[plan] ${msg}`);
+    warnings.push(msg);
+  }
   const cycleLogPromise = adapter2.writeCycleLogEntry({
     uuid: randomUUID8(),
     cycleNumber: newCycleNumber,
@@ -12047,7 +12186,10 @@ ${cleanContent}`;
         taskIds: cycleTaskIds,
         contextHashes,
         // task-2071 (MU-3): own the cycle by the planning member.
-        ...options.ownerUserId ? { userId: options.ownerUserId } : {}
+        ...options.ownerUserId ? { userId: options.ownerUserId } : {},
+        // task-2483 (C319): persist the plan's Dependency Chain build-order markdown.
+        // This full write patches the early minimal row created in Phase 1.
+        ...data.dependencyChain ? { dependencyChain: data.dependencyChain } : {}
       };
       await adapter2.createCycle(cycle);
     } catch (err) {
@@ -12527,12 +12669,58 @@ ${JSON.stringify(payload, null, 2)}`;
 }
 var ProgressTracker = class {
   lastStep;
+  persistAdapter;
+  streamCtx;
   constructor(initial = "start") {
     this.lastStep = initial;
   }
   mark(step) {
     this.lastStep = step;
   }
+  /**
+   * Arm progress-stream persistence for this tool call. Safe to call with any
+   * adapter — persistence stays disarmed unless the adapter exposes BOTH
+   * `getProjectId` and `recordProgressStep` (i.e. the pg/DB-backed path). Returns
+   * `this` for chaining at the tracker construction site.
+   */
+  bindStream(adapter2, ctx) {
+    if (adapter2?.getProjectId && adapter2.recordProgressStep) {
+      this.persistAdapter = adapter2;
+    }
+    this.streamCtx = ctx;
+    return this;
+  }
+  /** Update the bound scope mid-call (e.g. once the cycle number is resolved). */
+  setStreamScope(scope) {
+    if (!this.streamCtx) return;
+    if (scope.cycle !== void 0) this.streamCtx.cycle = scope.cycle;
+    if (scope.taskId !== void 0) this.streamCtx.taskId = scope.taskId;
+  }
+  /**
+   * Record one step of the progress stream. Also advances `lastStep` so the
+   * structured-error diagnostic still points at the most recent named step.
+   * Fire-and-forget and fully guarded — the returned promise always resolves.
+   */
+  recordStep(step, opts = {}) {
+    this.lastStep = step;
+    const adapter2 = this.persistAdapter;
+    const ctx = this.streamCtx;
+    if (!adapter2?.recordProgressStep || !ctx) return Promise.resolve();
+    const row = {
+      stage: opts.stage ?? ctx.stage,
+      step,
+      status: opts.status ?? "complete",
+      cycle: opts.cycle !== void 0 ? opts.cycle : ctx.cycle ?? null,
+      taskId: opts.taskId !== void 0 ? opts.taskId : ctx.taskId ?? null,
+      capabilityKey: opts.capabilityKey ?? null,
+      capabilityEnabled: opts.capabilityEnabled ?? null,
+      metadata: opts.metadata
+    };
+    return adapter2.recordProgressStep(row).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[progress-stream] failed to persist ${ctx.stage}/${step} (${row.status}): ${message}`);
+    });
+  }
 };
 function defaultHint(tool) {
   const knownTools = /* @__PURE__ */ new Set([
@@ -12571,6 +12759,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`;
   }
@@ -12991,7 +13181,7 @@ async function handlePlan(adapter2, config2, args) {
   const focus = typeof args.focus === "string" ? args.focus : void 0;
   const force = args.force === true;
   const handoffsOnly = args.handoffs_only === true;
-  const tracker = new ProgressTracker(toolMode === "apply" ? "apply_validate" : "prepare_validate");
+  const tracker = new ProgressTracker(toolMode === "apply" ? "apply_validate" : "prepare_validate").bindStream(adapter2, { stage: "plan" });
   try {
     if (toolMode === "apply") {
       const resolved = await resolveLlmResponse(
@@ -13063,6 +13253,10 @@ async function handlePlan(adapter2, config2, args) {
       }
       const skipHandoffs = args.skip_handoffs === true;
       const result = await preparePlan(adapter2, config2, filters, focus, force, handoffsOnly, skipHandoffs, tracker);
+      tracker.setStreamScope({ cycle: result.cycleNumber + 1 });
+      for (const step of ["health-check", "inbox-triage", "board-integrity", "maturity-gate", "recommendation", "dependency-chain"]) {
+        await tracker.recordStep(step);
+      }
       planPrepareCache.set(callerKey, {
         contextHashes: result.contextHashes,
         userMessage: result.userMessage,
@@ -14437,7 +14631,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}
@@ -15240,7 +15434,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",
@@ -15826,6 +16020,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".'
@@ -16060,19 +16263,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) {
@@ -16684,7 +16918,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.
 
@@ -16809,7 +17043,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
 ---
@@ -18185,6 +18419,86 @@ Examples (use whichever provider you have): ${spec.examples}.
 _Recommendation only \u2014 PAPI never selects or runs a model. Policy: XS/S \u2192 cheap, M/L \u2192 capable, XL \u2192 frontier._`;
 }
 
+// src/lib/capabilities.ts
+import {
+  CAPABILITY_KEYS,
+  CAPABILITY_REGISTRY,
+  isCapabilityKey,
+  isCapabilityEnabled
+} from "@papi-ai/shared";
+
+// src/lib/directive-builders.ts
+function buildPrReviewerDirective(caps) {
+  if (!isCapabilityEnabled(caps, "prReviewer")) return null;
+  return `
+
+**Quality Gate:** no auto-review attached. PAPI's standard pre-accept step is a code review of the branch diff \u2014 run \`review_submit\` with \`dispatch:"subagent"\` to auto-review, or attach \`auto_review\` findings. Risk-tier work (auth, data, migrations, CI) should always carry one.`;
+}
+function buildChangelogDirective(caps, inner) {
+  if (!isCapabilityEnabled(caps, "changelog")) return null;
+  return inner;
+}
+function buildDiscoveredIssuesDirective(caps, issueLines) {
+  if (!isCapabilityEnabled(caps, "discoveredIssues")) return null;
+  if (issueLines.length === 0) return null;
+  return [
+    "",
+    "---",
+    "",
+    `## Discovered Issues (${issueLines.length})`,
+    "",
+    ...issueLines,
+    "",
+    "*These issues were logged during builds \u2014 triage them in the next plan.*"
+  ].join("\n");
+}
+function buildModelRecommendationDirective(caps, tierBlock) {
+  if (!isCapabilityEnabled(caps, "modelRecommendation")) return null;
+  return tierBlock;
+}
+function buildVerifyHealthCheckDirective(caps) {
+  if (!isCapabilityEnabled(caps, "verifyHealthCheck")) return null;
+  return `
+
+**Health check:** before you consider the cycle shipped, verify cycle state (plan validity, review coverage, branch hygiene) \u2014 run the \`papi-verify\` skill or a quick \`board_view\` pass.`;
+}
+function buildGestaltPreBuildDirective(caps) {
+  if (!isCapabilityEnabled(caps, "gestaltPreBuild")) return null;
+  return `
+
+**Gestalt pre-build:** on the first task of a multi-task cycle, read every task's BUILD HANDOFF together (shared files, sequencing, module split) before building \u2014 one-time check at cycle start.`;
+}
+function buildBatchBuildRollupDirective(caps) {
+  if (!isCapabilityEnabled(caps, "batchBuildRollup")) return null;
+  return `
+
+**Batch rollup:** after the final task of a batch, emit a cycle-level rollup \u2014 build summary table + discovered issues grouped by severity + next action.`;
+}
+function buildSecurityScanDirective(caps) {
+  if (!isCapabilityEnabled(caps, "securityScan")) return null;
+  return `
+
+**Security scan:** risk-tier changes (auth, data, migrations, secrets, endpoints) should carry a security pass \u2014 OWASP top-10 + secret-exposure check on the changed surface before merge.`;
+}
+function buildDeployHookDirective(caps, deployCommand) {
+  if (!isCapabilityEnabled(caps, "deployHook")) return null;
+  const command = deployCommand?.trim() || void 0;
+  if (!command) return null;
+  return `
+
+---
+
+## Deploy \u2014 run after this release
+
+The post-release deploy hook is on and a deploy command is configured, so ship the merged release now.
+
+Run your deploy command yourself:
+\`\`\`
+${command}
+\`\`\`
+PAPI never runs this command itself (AD-58) \u2014 you run it in your own environment. Turn the "Post-release deploy" capability off in the dashboard, or unset PAPI_DEPLOY, to stop this reminder.`;
+}
+
 // src/services/build.ts
 import { randomUUID as randomUUID11 } from "crypto";
 import { readdirSync as readdirSync5, existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
@@ -18502,40 +18816,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 };
@@ -18839,6 +19175,65 @@ async function updatePluginMarketplaces(version) {
   return [cursor, vscode].filter((r) => r !== null);
 }
 
+// src/lib/release-gate.ts
+function evaluateReleaseGate(caps, gateCommand, gateResult) {
+  const command = gateCommand?.trim() || void 0;
+  if (!isCapabilityEnabled(caps, "releaseGate")) {
+    return {
+      action: "proceed",
+      stepStatus: "complete",
+      metadata: { skipped: true, reason: "capability_off" },
+      message: ""
+    };
+  }
+  if (!command) {
+    return {
+      action: "proceed",
+      stepStatus: "complete",
+      metadata: { note: "no gate configured" },
+      message: ""
+    };
+  }
+  if (gateResult === "fail") {
+    return {
+      action: "block",
+      stepStatus: "failed",
+      metadata: { command },
+      message: `Release blocked \u2014 quality gate failed.
+
+The gate command \`${command}\` reported a failure, so PAPI did NOT tag, merge, or close the cycle.
+
+Fix the failing tests/build, re-run \`${command}\`, and call \`release\` again with \`gate_result: "pass"\` once it is green. To ship past a failing gate anyway, turn the "Release quality gate" capability off in the dashboard, or unset PAPI_GATE.`
+    };
+  }
+  if (gateResult === "pass") {
+    return {
+      action: "proceed",
+      stepStatus: "complete",
+      metadata: { command },
+      message: ""
+    };
+  }
+  return {
+    action: "directive",
+    stepStatus: "active",
+    metadata: { command },
+    message: `## Quality gate \u2014 run before this release ships
+
+PAPI's release quality gate is on and a gate command is configured, so the release is HELD until the gate passes. Nothing has been tagged, merged, or closed yet.
+
+1. Run the gate command yourself:
+   \`\`\`
+   ${command}
+   \`\`\`
+2. Re-call \`release\` with the same \`branch\` and \`version\`, adding:
+   - \`gate_result: "pass"\` if it succeeded \u2014 the release then proceeds normally.
+   - \`gate_result: "fail"\` if it failed \u2014 the release stays blocked so you can fix it first.
+
+PAPI never runs this command itself (AD-58) \u2014 you run it in your own environment and report the result.`
+  };
+}
+
 // src/tools/release.ts
 function parseGithubOwner(input) {
   if (!input) return null;
@@ -18919,6 +19314,11 @@ var releaseTool = {
         type: "boolean",
         description: "Update CHANGELOG.md and mark the cycle complete, but skip creating a git tag and pushing it. Use when you want cycle closure and changelog tracking without burning a version number. The version parameter is still used for the CHANGELOG entry heading."
       },
+      gate_result: {
+        type: "string",
+        enum: ["pass", "fail"],
+        description: 'task-2482 (release quality gate): the result of running the configured gate command (papi.gate / PAPI_GATE). Set this on the SECOND release call AFTER you have run the gate command yourself \u2014 "pass" lets the release proceed, "fail" keeps it blocked. Leave it UNSET on the first call: if the release-quality-gate capability is on and a gate command is configured, release returns a directive telling you to run the command, then re-call with the result. PAPI never runs the command itself (AD-58).'
+      },
       observations: {
         type: "array",
         description: "Optional dogfood observations from this cycle to persist to the DB. Each entry records friction, methodology signals, or commercial insights.",
@@ -18949,6 +19349,7 @@ async function handleRelease(adapter2, config2, args) {
   let version = args.version;
   const force = args.force;
   const skipVersion = args.skipVersion;
+  const gateResult = args.gate_result;
   const rawObservations = args.observations;
   if (!branch || !version) {
     return errorResponse('both branch and version are required. Example: release branch="main" version="v0.1.0-alpha"');
@@ -18962,8 +19363,9 @@ async function handleRelease(adapter2, config2, args) {
       version = `${version}-${suffix}`;
     }
   }
-  const tracker = new ProgressTracker("validate-args");
+  const tracker = new ProgressTracker("validate-args").bindStream(adapter2, { stage: "release" });
   try {
+    await tracker.recordStep("release_starting");
     tracker.mark("owner-identity-guard");
     const gate = await resolveOwnerGate(adapter2, config2);
     const productionBaseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
@@ -19090,12 +19492,41 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
         console.error(`[release] gh CLI not available \u2014 ${pendingGrouped.length} shared branch(es) will be squash-merged via git: ${pendingGrouped.join(", ")}`);
       }
     }
+    await tracker.recordStep("readiness_verified");
+    let caps = {};
+    try {
+      const info = adapter2.getProjectInfo ? await adapter2.getProjectInfo() : null;
+      caps = info?.capabilities ?? {};
+    } catch {
+      caps = {};
+    }
+    tracker.mark("quality-gate");
+    const gateDecision = evaluateReleaseGate(caps, config2.gateCommand, gateResult);
+    await tracker.recordStep("quality_gate", {
+      status: gateDecision.stepStatus,
+      capabilityKey: "releaseGate",
+      capabilityEnabled: isCapabilityEnabled(caps, "releaseGate"),
+      metadata: gateDecision.metadata
+    });
+    if (gateDecision.action === "directive") {
+      return textResponse(gateDecision.message);
+    }
+    if (gateDecision.action === "block") {
+      return errorResponse(gateDecision.message);
+    }
     tracker.mark("create-release");
     const result = await createRelease(config2, branch, version, adapter2, void 0, {
       force: force ?? false,
       skipVersion: skipVersion ?? false,
       callerUserId: gate.callerUserId
     });
+    tracker.setStreamScope({ cycle: result.cycleClosed ?? null });
+    await tracker.recordStep("cycle_complete", { metadata: { version: result.version } });
+    for (const m of result.groupedBranchMerges ?? []) {
+      await tracker.recordStep("branch_merged", {
+        metadata: { branch: m.branch, prUrl: m.prUrl ?? null }
+      });
+    }
     const lines = [
       `## Release ${result.version}${skipVersion ? " (skip version)" : ""}`,
       "",
@@ -19124,10 +19555,8 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
         const reports = await adapter2.getBuildReportsSince(closedCycle);
         const EMPTY = /* @__PURE__ */ new Set(["None", "none", "N/A", "", "null"]);
         const issues = reports.filter((r) => r.discoveredIssues && !EMPTY.has(r.discoveredIssues.trim())).map((r) => `- **${r.taskId}** (${r.taskName}): ${r.discoveredIssues}`);
-        if (issues.length > 0) {
-          lines.push("", "---", "", `## Discovered Issues (${issues.length})`, "", ...issues);
-          lines.push("", "*These issues were logged during builds \u2014 triage them in the next plan.*");
-        }
+        const issuesDirective = buildDiscoveredIssuesDirective(caps, issues);
+        if (issuesDirective) lines.push(issuesDirective);
       }
     } catch {
     }
@@ -19147,28 +19576,54 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
         lines.push("", "\u26A0\uFE0F Dogfood observations could not be saved to DB \u2014 log them manually in DOGFOOD_LOG.md.");
       }
     }
-    const cycleUpdateDirective = buildCycleUpdateCurationDirective(result.version, result.cycleClosed ?? 0);
+    const cycleUpdateDirective = buildChangelogDirective(
+      caps,
+      buildCycleUpdateCurationDirective(result.version, result.cycleClosed ?? 0)
+    );
     if (cycleUpdateDirective) lines.push(cycleUpdateDirective);
-    try {
-      const xPosted = await postReleaseToX(result.version, result.cycleClosed ?? 0);
-      if (xPosted) lines.push("", "Posted release announcement to X.");
-    } catch {
+    await tracker.recordStep("changelog", {
+      capabilityKey: "changelog",
+      capabilityEnabled: isCapabilityEnabled(caps, "changelog"),
+      status: cycleUpdateDirective ? "complete" : "active"
+    });
+    const deployDirective = buildDeployHookDirective(caps, config2.deployCommand);
+    if (deployDirective) {
+      lines.push(deployDirective);
+      await tracker.recordStep("deploy_hook", {
+        capabilityKey: "deployHook",
+        capabilityEnabled: isCapabilityEnabled(caps, "deployHook"),
+        status: "complete",
+        metadata: { configured: true }
+      });
     }
-    try {
-      const registryResults = await updateRegistryListings(result.version);
-      for (const r of registryResults) {
-        lines.push("", `Registry [${r.registry}]: ${r.message}`);
+    const publishEnabled = isCapabilityEnabled(caps, "publishDirective");
+    if (publishEnabled) {
+      try {
+        const xPosted = await postReleaseToX(result.version, result.cycleClosed ?? 0);
+        if (xPosted) lines.push("", "Posted release announcement to X.");
+      } catch {
       }
-    } catch {
     }
-    try {
-      const marketplaceResults = await updatePluginMarketplaces(result.version);
-      for (const r of marketplaceResults) {
-        lines.push("", `Marketplace [${r.registry}]: ${r.message}`);
+    if (publishEnabled) {
+      try {
+        const registryResults = await updateRegistryListings(result.version);
+        for (const r of registryResults) {
+          lines.push("", `Registry [${r.registry}]: ${r.message}`);
+        }
+      } catch {
+      }
+      try {
+        const marketplaceResults = await updatePluginMarketplaces(result.version);
+        for (const r of marketplaceResults) {
+          lines.push("", `Marketplace [${r.registry}]: ${r.message}`);
+        }
+      } catch {
       }
-    } catch {
     }
+    const verifyDirective = buildVerifyHealthCheckDirective(caps);
+    if (verifyDirective) lines.push(verifyDirective);
     lines.push("", `Next: cycle released! Run \`plan\` to start your next cycle, or \`idea "<what's next>"\` first if your backlog is thin.`);
+    await tracker.recordStep("released", { metadata: { version: result.version } });
     const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
     return textResponse(lines.join("\n") + filesToWriteSection);
   } catch (err) {
@@ -19189,18 +19644,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();
@@ -19917,13 +20380,19 @@ function assertDeployVerification(config2, input) {
   if (triggerHits.length === 0) return;
   const verification = input.productionVerification;
   if (!verification) {
-    throw new Error(
-      `Deploy-verification required: this branch's diff touches ${triggerHits.length} trigger-surface file(s):
-` + triggerHits.map((p) => `  - ${p}`).join("\n") + `
+    const targetLine = config2.verifyCommand ? `
 
-Run a curl against the live deploy and pass production_verification on build_execute complete:
+Verify against your configured target (papi.verify): \`${config2.verifyCommand}\`
+Run it yourself, then pass production_verification on build_execute complete:
   { urls, curl_command, http_status, response_excerpt, verified_at }
+` : `
 
+Run a curl against the live deploy and pass production_verification on build_execute complete:
+  { urls, curl_command, http_status, response_excerpt, verified_at }
+`;
+    throw new Error(
+      `Deploy-verification required: this branch's diff touches ${triggerHits.length} trigger-surface file(s):
+` + triggerHits.map((p) => `  - ${p}`).join("\n") + targetLine + `
 Trigger surface is enforced because changes here have historically shipped to prod undetected (C166, C264-C265, C271).`
     );
   }
@@ -19991,7 +20460,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 {
@@ -20132,16 +20618,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;
@@ -20410,7 +20894,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",
@@ -21122,13 +21606,17 @@ async function handleBuildExecute(adapter2, config2, args, clientName) {
   if (hasReportFields(args)) {
     return handleExecuteComplete(adapter2, config2, taskId, args, light, clientName);
   }
-  const tracker = new ProgressTracker("start_build");
+  const tracker = new ProgressTracker("start_build").bindStream(adapter2, { stage: "build", taskId });
   try {
+    await tracker.recordStep("started");
     const result = await startBuild(adapter2, config2, taskId, { light }, clientName);
+    tracker.setStreamScope({ taskId: result.task.displayId ?? result.task.id, cycle: result.task.cycle ?? null });
+    await tracker.recordStep("branch_ready");
     tracker.mark("start_decorate_handoff");
     const branchInfo = result.branchLines.length > 0 ? result.branchLines.map((l) => `> ${l}`).join("\n") + "\n\n" : "";
     const phaseNote = result.phaseChanges.length > 0 ? "\n\n" + result.phaseChanges.map((c) => `Phase auto-updated: ${c.phaseId} ${c.oldStatus} \u2192 ${c.newStatus}`).join("\n") : "";
     const projectInfo = adapter2.getProjectInfo ? await adapter2.getProjectInfo().catch(() => null) : null;
+    const caps = projectInfo?.capabilities ?? {};
     const projectBanner = projectInfo ? getProjectConnectionBanner(projectInfo.name, projectInfo.slug) : null;
     const projectLine = projectBanner ? `> ${projectBanner}
 
@@ -21176,8 +21664,12 @@ ${entries}`;
     const moduleInstructions = getModuleInstructions(result.task.module);
     const moduleContext = await getModuleContext(adapter2, result.task);
     const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
-    const modelNote = formatModelRecommendation(result.task.buildHandoff?.effort ?? result.task.complexity);
-    return textResponse(header + serializeBuildHandoff(result.task.buildHandoff) + modelNote + adSection + moduleInstructions + moduleContext + dogfoodSection + verificationNote + chainInstruction + phaseNote + filesToWriteSection);
+    const modelNote = buildModelRecommendationDirective(
+      caps,
+      formatModelRecommendation(result.task.buildHandoff?.effort ?? result.task.complexity)
+    ) ?? "";
+    const gestaltNote = buildGestaltPreBuildDirective(caps) ?? "";
+    return textResponse(header + serializeBuildHandoff(result.task.buildHandoff) + modelNote + gestaltNote + adSection + moduleInstructions + moduleContext + dogfoodSection + verificationNote + chainInstruction + phaseNote + filesToWriteSection);
   } catch (err) {
     if (isNoHandoffError(err)) {
       const lines = [
@@ -21264,7 +21756,7 @@ async function handleExecuteComplete(adapter2, config2, taskId, args, light = fa
   if (!parsedEstimatedEffort) {
     return errorResponse(`Invalid estimated_effort value "${estimatedEffort}". Must be one of: XS, S, M, L, XL.`);
   }
-  const tracker = new ProgressTracker("complete_validate");
+  const tracker = new ProgressTracker("complete_validate").bindStream(adapter2, { stage: "build", taskId });
   try {
     tracker.mark("complete_build");
     const result = await completeBuild(adapter2, config2, taskId, {
@@ -21293,6 +21785,11 @@ async function handleExecuteComplete(adapter2, config2, taskId, args, light = fa
       preview
     }, { light }, clientName);
     tracker.mark("complete_format");
+    tracker.setStreamScope({ taskId: result.task.displayId ?? result.task.id, cycle: result.cycleNumber });
+    await tracker.recordStep("report_written");
+    await tracker.recordStep("issues_triaged", {
+      metadata: { autoTriagedCount: result.autoTriagedCount ?? 0 }
+    });
     if (resolvesLearnings && resolvesLearnings.length > 0 && adapter2.updateCycleLearningActionRef) {
       for (const learningId of resolvesLearnings) {
         try {
@@ -21301,8 +21798,35 @@ async function handleExecuteComplete(adapter2, config2, taskId, args, light = fa
         }
       }
     }
+    await tracker.recordStep("learnings", {
+      metadata: { learningsLinkedCount: result.learningsLinkedCount ?? 0 }
+    });
+    await tracker.recordStep("moving-to-review", {
+      metadata: { status: result.task.status }
+    });
+    if (productionVerification) {
+      await tracker.recordStep("verify", {
+        stage: "release",
+        status: "complete",
+        metadata: {
+          httpStatus: productionVerification.http_status,
+          urlCount: productionVerification.urls.length,
+          targetConfigured: Boolean(config2.verifyCommand)
+        }
+      });
+    }
     const docsNote = await detectUnregisteredDocsNote(adapter2, config2);
-    return textResponse(formatCompleteResult(result) + docsNote);
+    let batchRollupNote = "";
+    if (result.cycleProgress && result.cycleProgress.completed >= result.cycleProgress.total) {
+      try {
+        const info = adapter2.getProjectInfo ? await adapter2.getProjectInfo() : null;
+        const caps = info?.capabilities ?? {};
+        batchRollupNote = buildBatchBuildRollupDirective(caps) ?? "";
+      } catch {
+        batchRollupNote = "";
+      }
+    }
+    return textResponse(formatCompleteResult(result) + docsNote + batchRollupNote);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     if (isBuildPushError(err)) {
@@ -21838,6 +22362,12 @@ init_git();
 
 // src/services/ad-hoc.ts
 import { randomUUID as randomUUID14 } from "crypto";
+function resolveAdHocCycle(cycle, latest, latestComplete) {
+  if (cycle === void 0) return null;
+  if (typeof cycle === "number") return cycle;
+  if (cycle === "current") return latest;
+  return latestComplete ? latest + 1 : latest;
+}
 async function recordAdHoc(adapter2, input) {
   const [health, phases] = await Promise.all([
     adapter2.getCycleHealth(),
@@ -21845,6 +22375,14 @@ async function recordAdHoc(adapter2, input) {
   ]);
   const cycle = health.totalCycles;
   const now = /* @__PURE__ */ new Date();
+  const held = input.hold === true;
+  const targetCycle = held ? cycle + 1 : resolveAdHocCycle(
+    input.cycle,
+    health.totalCycles,
+    health.latestCycleStatus === "complete"
+  );
+  const promoted = targetCycle !== null;
+  const landInReview = held || promoted && input.stage === "release";
   let task;
   if (input.taskId) {
     const existing = await adapter2.getTask(input.taskId);
@@ -21866,18 +22404,19 @@ async function recordAdHoc(adapter2, input) {
       uuid: randomUUID14(),
       displayId: "",
       title: input.title,
-      status: "Done",
+      status: landInReview ? "In Review" : "Done",
       priority: input.priority || "P2 Medium",
       complexity: input.effort === "XS" || input.effort === "S" ? "Small" : "Medium",
       module: input.module || "Core",
       epic: input.epic || "Platform",
       phase,
       owner: input.owner || "Cathal",
-      reviewed: true,
+      reviewed: !landInReview,
       createdCycle: cycle,
+      ...targetCycle !== null ? { cycle: targetCycle } : {},
       notes: input.notes ? `[ad-hoc] ${input.notes}` : "[ad-hoc]",
       taskType: input.taskType || "task",
-      source: "owner"
+      source: "ad_hoc"
     });
   }
   const report = {
@@ -21952,6 +22491,22 @@ var adHocTool = {
         type: "string",
         enum: ["task", "bug", "research", "discovery", "spike", "idea"],
         description: 'Task type (default: inferred from description \u2014 "fix"/"bug" \u2192 bug, "research"/"investigate" \u2192 research, otherwise task).'
+      },
+      cycle: {
+        description: 'task-2352: promote this ad-hoc work into a cycle so it shows on the hub and is counted as INJECTED work (distinct from planned). Omit for the default behaviour (an immediate Done task with no cycle). "current" = the active cycle; "next-if-plan-not-run" = the next cycle if the latest already shipped (so between-cycle work is not lost), else current; or an explicit cycle number.',
+        oneOf: [
+          { type: "string", enum: ["current", "next-if-plan-not-run"] },
+          { type: "integer" }
+        ]
+      },
+      stage: {
+        type: "string",
+        enum: ["done", "release"],
+        description: 'task-2352: where promoted work lands. "done" (default) records it as Done + reviewed. "release" lands it In Review so it is reviewed and released WITH the cycle (fold-in) instead of being force-completed. Only meaningful with `cycle`.'
+      },
+      hold: {
+        type: "boolean",
+        description: "task-2477: held-adhoc. When true, do NOT force-complete or commit to main \u2014 record the task In Review pinned to the NEXT cycle (current + 1) so the planner won't re-plan it, and return a branch/PR directive (commit on feat/<task-id>, never main, leave unmerged) so it rides the next cycle's review \u2192 release bundled with planned work. One-call replacement for the two-call ad_hoc + board_edit stopgap. Takes precedence over `cycle`/`stage`."
       }
     },
     required: []
@@ -21982,6 +22537,12 @@ async function handleAdHoc(adapter2, config2, args) {
     rawNotes = rawNotes.slice(0, MAX_NOTES_LENGTH);
     notesTruncated = true;
   }
+  const rawCycle = args.cycle;
+  let cycleArg;
+  if (typeof rawCycle === "number") cycleArg = rawCycle;
+  else if (rawCycle === "current" || rawCycle === "next-if-plan-not-run") cycleArg = rawCycle;
+  const stageArg = args.stage === "release" ? "release" : void 0;
+  const holdArg = args.hold === true;
   const result = await recordAdHoc(adapter2, {
     title: title || "",
     taskId,
@@ -21992,9 +22553,12 @@ async function handleAdHoc(adapter2, config2, args) {
     priority: priorityRaw,
     taskType: typeRaw,
     // PROJECT-SPECIFIC: owner resolved from config (PAPI_OWNER env var, default 'Cathal')
-    owner: config2.projectOwner
+    owner: config2.projectOwner,
+    cycle: cycleArg,
+    stage: stageArg,
+    hold: holdArg
   });
-  if (isGitAvailable() && isGitRepo(config2.projectRoot)) {
+  if (!holdArg && isGitAvailable() && isGitRepo(config2.projectRoot)) {
     try {
       stageDirAndCommit(
         config2.projectRoot,
@@ -22007,8 +22571,29 @@ async function handleAdHoc(adapter2, config2, args) {
   const truncateWarning = notesTruncated ? ` (notes truncated to ${MAX_NOTES_LENGTH} chars)` : "";
   const taskModule = result.task.module || "Core";
   const typeLabel = result.task.taskType || typeRaw;
+  const promoNote = result.task.cycle != null ? ` Promoted into Cycle ${result.task.cycle} as injected work${result.task.status === "In Review" ? " (In Review \u2014 will release with the cycle)" : ""}.` : "";
+  if (holdArg) {
+    const branch = `feat/${result.task.id}`;
+    return textResponse(
+      `**${result.task.id}:** "${result.task.title}" held for review (${effortRaw}, ${priorityRaw}, ${typeLabel}, ${taskModule}).${truncateWarning}${promoNote} Build report attached.
+
+## Held for the next cycle \u2014 branch + commit, do NOT merge
+The task is recorded **In Review** and pinned to **Cycle ${result.task.cycle}**, so the planner won't re-plan it and it rides that cycle's review \u2192 release bundled with planned work.
+
+1. Create a branch and commit your code there (never \`main\`):
+   \`\`\`
+   git switch -c ${branch}
+   git add -- <your changed files>
+   git commit -m "feat(${result.task.id}): ${result.task.title}"
+   git push -u origin ${branch}
+   \`\`\`
+2. Leave the branch **unmerged** \u2014 it is picked up by the next cycle's \`release\`.
+
+_To correct: board_edit ${result.task.id} with updated fields._`
+    );
+  }
   return textResponse(
-    `**${result.task.id}:** "${result.task.title}" recorded (${effortRaw}, ${priorityRaw}, ${typeLabel}, ${taskModule}).${truncateWarning} Build report attached.
+    `**${result.task.id}:** "${result.task.title}" recorded (${effortRaw}, ${priorityRaw}, ${typeLabel}, ${taskModule}).${truncateWarning}${promoNote} Build report attached.
 _To correct: board_edit ${result.task.id} with updated fields._`
   );
 }
@@ -22706,10 +23291,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") {
@@ -23093,13 +23688,22 @@ async function handleReviewSubmit(adapter2, config2, args) {
   if (!stage) {
     return errorResponse('stage is required. Use "handoff-review" or "build-acceptance".');
   }
+  let caps = {};
+  try {
+    const info = adapter2.getProjectInfo ? await adapter2.getProjectInfo() : null;
+    caps = info?.capabilities ?? {};
+  } catch {
+    caps = {};
+  }
   const explicitDispatch = args.dispatch === "subagent";
-  const autoDispatchEligible = !verdict && args.dispatch !== "inline" && process.env.PAPI_AUTO_DISPATCH !== "false";
-  if ((explicitDispatch || autoDispatchEligible) && stage === "build-acceptance" && taskId) {
+  const autoDispatchOptIn = args.dispatch !== "inline" && process.env.PAPI_AUTO_DISPATCH !== "false" && isCapabilityEnabled(caps, "prReviewer");
+  const autoDispatchEligible = !verdict && autoDispatchOptIn;
+  const capabilityAutoReviewEligible = verdict === "accept" && !autoReview && autoDispatchOptIn;
+  if ((explicitDispatch || autoDispatchEligible || capabilityAutoReviewEligible) && stage === "build-acceptance" && taskId) {
     const dispatch = await buildReviewDispatch(adapter2, config2, taskId);
     if (!dispatch.ok) {
       if (explicitDispatch) return errorResponse(dispatch.error);
-    } else if (explicitDispatch || dispatch.contextBytes > REVIEW_DISPATCH_THRESHOLD) {
+    } else if (explicitDispatch || capabilityAutoReviewEligible || dispatch.contextBytes > REVIEW_DISPATCH_THRESHOLD) {
       return textResponse(dispatch.prompt);
     }
   }
@@ -23140,7 +23744,8 @@ async function handleReviewSubmit(adapter2, config2, args) {
       }
     }
   }
-  const tracker = new ProgressTracker("validate-args");
+  const tracker = new ProgressTracker("validate-args").bindStream(adapter2, { stage: "review", taskId });
+  await tracker.recordStep("reviewer_confirmed");
   const handoffRegenResponse = args.handoff_regen_response;
   if (handoffRegenResponse?.trim()) {
     tracker.mark("apply-handoff-regen");
@@ -23157,6 +23762,14 @@ async function handleReviewSubmit(adapter2, config2, args) {
       adapter2,
       { taskId, stage, verdict, comments, reviewer, autoReview }
     );
+    tracker.setStreamScope({ cycle: result.currentCycle > 0 ? result.currentCycle : null });
+    await tracker.recordStep("verdict_recorded", { metadata: { verdict, stage } });
+    if (result.unblockedTasks.length > 0) {
+      await tracker.recordStep("dependents_unblocked", { metadata: { count: result.unblockedTasks.length } });
+    }
+    if (result.closedDocActions.length > 0) {
+      await tracker.recordStep("docs_closed", { metadata: { count: result.closedDocActions.length } });
+    }
     const statusNote = result.newStatus ? ` Task status updated to **${result.newStatus}**.` : " Task status unchanged.";
     const unblockNote = result.unblockedTasks.length > 0 ? `
 
@@ -23196,6 +23809,7 @@ ${result.handoffRegenPrompt.userMessage}
 
 > ${mergeResult.message}`;
         }
+        await tracker.recordStep("deferred", { metadata: { reason: "merge-skipped" } });
       } else if (!mergeResult.merged) {
         mergeFailed = true;
         let revertNote = "";
@@ -23210,11 +23824,13 @@ ${result.handoffRegenPrompt.userMessage}
 \u26A0\uFE0F **PR merge failed \u2014 task NOT marked Done.**${revertNote}
 
 ${mergeResult.message}`;
+        await tracker.recordStep("deferred", { status: "failed", metadata: { reason: "merge-failed" } });
       } else {
         try {
           await adapter2.updateTask(taskId, { mergedAt: (/* @__PURE__ */ new Date()).toISOString() });
         } catch {
         }
+        await tracker.recordStep("merged");
         const detailLines = mergeResult.details.map((l) => `> ${l}`).join("\n");
         mergeNote = `
 
@@ -23290,6 +23906,7 @@ Merge or squash those PRs first, then run \`release\` manually.`;
             }
             const version = `v0.${result.currentCycle}.0`;
             const releaseResult = await createRelease(config2, baseBranch, version, adapter2, result.currentCycle);
+            await tracker.recordStep("auto_release_triggered", { metadata: { version: releaseResult.version } });
             const pushInfo = releaseResult.pushNotes.join(" ");
             const groupedMergeNote = releaseResult.groupedBranchMerges?.length ? "\n" + releaseResult.groupedBranchMerges.map((r) => `- Merged shared branch \`${r.branch}\` via PR: ${r.prUrl ?? "n/a"}`).join("\n") : "";
             autoReleaseNote = `
@@ -23345,9 +23962,7 @@ ${findingLines}${more}` : "");
 \u26A0\uFE0F **Override recorded:** ${reviewer} accepted past a ${autoReview.verdict} quality gate (${autoReview.findings.length} finding${autoReview.findings.length === 1 ? "" : "s"}). The verdict + findings are stored on this review for the audit trail.`;
       }
     } else if (stage === "build-acceptance" && verdict === "accept") {
-      autoReviewNote = `
-
-**Quality Gate:** no auto-review attached. PAPI's standard pre-accept step is a code review of the branch diff \u2014 run \`review_submit\` with \`dispatch:"subagent"\` to auto-review, or attach \`auto_review\` findings. Risk-tier work (auth, data, migrations, CI) should always carry one.`;
+      autoReviewNote = buildPrReviewerDirective(caps) ?? "";
     }
     let nextStepNote = "";
     if (!autoReleaseNote && stage === "build-acceptance") {
@@ -23359,6 +23974,7 @@ ${findingLines}${more}` : "");
 Next: address the feedback, then run \`build_execute ${taskId}\` to resubmit.`;
       }
     }
+    const securityNote = stage === "build-acceptance" && verdict === "accept" ? buildSecurityScanDirective(caps) ?? "" : "";
     tracker.mark("format-response");
     return textResponse(
       `**${result.stageLabel}** recorded for ${result.taskId}.
@@ -23366,7 +23982,7 @@ Next: address the feedback, then run \`build_execute ${taskId}\` to resubmit.`;
 - **Verdict:** ${result.verdict}
 - **Comments:** ${result.comments}
 
-${statusNote}${autoReviewNote}${unblockNote}${docClosureNote}${regenNote}${mergeNote}${overlapNote}${batchSummaryNote}${autoReleaseNote}${nextStepNote}${phaseNote}`
+${statusNote}${autoReviewNote}${securityNote}${unblockNote}${docClosureNote}${regenNote}${mergeNote}${overlapNote}${batchSummaryNote}${autoReleaseNote}${nextStepNote}${phaseNote}`
     );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -23935,6 +24551,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 = [];
@@ -24004,6 +24628,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);
@@ -24157,6 +24787,7 @@ ${lines.join("\n")}`;
     latestCycleStatus: health.latestCycleStatus,
     connectionStatus: getConnectionStatus(),
     reviewWarning,
+    zoomOutWarning,
     boardSummary,
     staleTasks,
     inReviewSummary,
@@ -24234,6 +24865,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) {
@@ -24242,42 +24897,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");
 }
@@ -24606,6 +25290,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) {
@@ -25310,6 +25998,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;
@@ -25824,7 +26527,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) {
@@ -25832,7 +26536,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,
@@ -25860,6 +26565,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: []
@@ -25887,6 +26597,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})
 
@@ -26682,7 +27412,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",
@@ -26695,10 +27425,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.)` : "";
@@ -26706,6 +27441,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() : "";
@@ -26745,7 +27491,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();
@@ -27360,7 +28106,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;