@papi-ai/server 0.7.62 → 0.7.64

package/dist/index.js

@@ -61,6 +61,7 @@ __export(git_exports, {
   isGitAvailable: () => isGitAvailable,
   isGitRepo: () => isGitRepo,
   listGroupedCycleBranches: () => listGroupedCycleBranches,
+  listOpenPullRequests: () => listOpenPullRequests,
   listOrphanFeatBranches: () => listOrphanFeatBranches,
   mergePullRequest: () => mergePullRequest,
   normalizeGitUrl: () => normalizeGitUrl,
@@ -347,6 +348,26 @@ function isGhAvailable() {
     return false;
   }
 }
+function listOpenPullRequests(cwd) {
+  if (!isGhAvailable()) return null;
+  try {
+    const out = execFileSync(
+      "gh",
+      ["pr", "list", "--state", "open", "--limit", "100", "--json", "number,title,author,headRefName,createdAt"],
+      { cwd, encoding: "utf-8" }
+    );
+    const raw = JSON.parse(out);
+    return raw.map((p) => ({
+      number: p.number,
+      title: p.title,
+      author: p.author?.login ?? "unknown",
+      headRefName: p.headRefName,
+      createdAt: p.createdAt
+    }));
+  } catch {
+    return null;
+  }
+}
 function getOriginRepoSlug(cwd) {
   try {
     const url = execFileSync("git", ["remote", "get-url", "origin"], {
@@ -1306,12 +1327,12 @@ var init_proxy_adapter = __esm({
       "listContributorReleasePrs",
       "claimReview",
       "getSiblingAds",
-      "getSiblingRepoTasks",
-      // task-2828 (C339): attributed-intelligence analytics reader — pg-only this cycle.
-      // Hosted forwarding needs a SECURITY DEFINER RPC + edge handler (like task-2394 did
-      // for getModuleEstimationStats); until then keep it here so hosted degrades to a
-      // safe `undefined` rather than forwarding into a 403. Wire under task-2390.
-      "getModelOutcomeStats"
+      "getSiblingRepoTasks"
+      // task-2828 (C339): attributed-intelligence analytics reader — pg-only that cycle.
+      // task-2864 (C343): WIRED. getModelOutcomeStats now has an edge case handler (raw
+      // SQL via postgres.js mirroring the pg query + inlined computeModelOutcomes bucketing)
+      // + an ALLOWED_METHODS entry, so it forwards. countPlanRunsForCycle wired alongside it
+      // (task-2860's auto-release guard reader). Both REMOVED from NO_FORWARD.
       // task-2394 (C329) — Batch A wired: findPendingDocActionsForTask,
       // getModuleEstimationStats and getDecisionScorePatterns now have edge case handlers
       // (each backed by a SECURITY DEFINER RPC, migration 20260714140000) plus
@@ -1444,7 +1465,8 @@ var init_proxy_adapter = __esm({
           if (response.status === 401) {
             throw new Error(
               `Auth: Invalid API key \u2014 PAPI_DATA_API_KEY was rejected by the proxy.
-Check PAPI_DATA_API_KEY in your .mcp.json config. You can regenerate it from the PAPI dashboard.
+This usually means the key was revoked or replaced. Mint a fresh key in the Connect panel on your PAPI dashboard (https://getpapi.ai/hub), then update PAPI_DATA_API_KEY in your .mcp.json.
+Moving off a local install? Switch to the remote MCP: https://getpapi.ai/docs/install
 (${response.status} on ${method}: ${message})`
             );
           }
@@ -2040,6 +2062,76 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
   }
 });
 
+// src/lib/reap-orphans.ts
+var reap_orphans_exports = {};
+__export(reap_orphans_exports, {
+  formatReapSummary: () => formatReapSummary,
+  isPapiServerCommand: () => isPapiServerCommand,
+  listProcesses: () => listProcesses,
+  reapOrphans: () => reapOrphans,
+  selectReapableOrphans: () => selectReapableOrphans
+});
+import { execFileSync as execFileSync6 } from "child_process";
+function isPapiServerCommand(command) {
+  return /@papi-ai[/\\]server/.test(command);
+}
+function selectReapableOrphans(procs, selfPid) {
+  return procs.filter(
+    (p) => p.pid !== selfPid && p.ppid === 1 && isPapiServerCommand(p.command)
+  );
+}
+function listProcesses() {
+  if (process.platform === "win32") return null;
+  try {
+    const out = execFileSync6("ps", ["-A", "-o", "pid=,ppid=,command="], { encoding: "utf-8" });
+    const procs = [];
+    for (const line of out.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const m = /^(\d+)\s+(\d+)\s+(.*)$/.exec(trimmed);
+      if (!m) continue;
+      procs.push({ pid: Number(m[1]), ppid: Number(m[2]), command: m[3] });
+    }
+    return procs;
+  } catch {
+    return null;
+  }
+}
+function reapOrphans(opts = {}) {
+  const procs = listProcesses();
+  if (procs === null) return { unsupported: true, candidates: [], reaped: [] };
+  const orphans = selectReapableOrphans(procs, process.pid);
+  const candidates = orphans.map((p) => p.pid);
+  const reaped = [];
+  if (!opts.dryRun) {
+    for (const pid of candidates) {
+      try {
+        process.kill(pid, "SIGTERM");
+        reaped.push(pid);
+      } catch {
+      }
+    }
+  }
+  return { unsupported: false, candidates, reaped };
+}
+function formatReapSummary(result, dryRun) {
+  if (result.unsupported) {
+    return "Orphan reaper: unsupported on this platform \u2014 skipped (no processes touched).";
+  }
+  if (result.candidates.length === 0) {
+    return "Orphan reaper: no parentless @papi-ai/server processes found.";
+  }
+  if (dryRun) {
+    return `Orphan reaper: ${result.candidates.length} parentless PAPI server process(es) found: ${result.candidates.join(", ")} (run with --reap-orphans to terminate).`;
+  }
+  return `Orphan reaper: terminated ${result.reaped.length} parentless PAPI server process(es): ${result.reaped.join(", ")}.`;
+}
+var init_reap_orphans = __esm({
+  "src/lib/reap-orphans.ts"() {
+    "use strict";
+  }
+});
+
 // ../../node_modules/postgres/src/query.js
 function cachedError(xs) {
   if (originCache.has(xs))
@@ -4242,7 +4334,7 @@ __export(doctor_exports, {
   __testing: () => __testing,
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync13 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join20 } from "path";
 function redact(name, value) {
@@ -4262,7 +4354,7 @@ function findMcpJson() {
   for (const path7 of candidates) {
     if (!existsSync11(path7)) continue;
     try {
-      const raw = readFileSync12(path7, "utf-8");
+      const raw = readFileSync13(path7, "utf-8");
       const parsed = JSON.parse(raw);
       const papiEntry = parsed.papi ?? parsed.mcpServers?.papi;
       if (!papiEntry) continue;
@@ -4506,12 +4598,16 @@ async function runDoctor(cliArgs2 = []) {
   const fixPool = cliArgs2.includes("--fix-pool") || cliArgs2.includes("--terminate-wedged");
   const pool = await diagnosePool({ fix: fixPool });
   process.stdout.write("\n" + formatPoolReport(pool) + "\n");
+  const reap = cliArgs2.includes("--reap-orphans");
+  const reapResult = reapOrphans({ dryRun: !reap });
+  process.stdout.write("\n" + formatReapSummary(reapResult, !reap) + "\n");
   return 0;
 }
 var SECRET_VARS, WEDGED_IDLE_TX_SECONDS, WEDGED_ACTIVE_SECONDS, __testing;
 var init_doctor = __esm({
   "src/cli/doctor.ts"() {
     "use strict";
+    init_reap_orphans();
     SECRET_VARS = /* @__PURE__ */ new Set(["PAPI_DATA_API_KEY", "DATABASE_URL", "PAPI_ENDPOINT"]);
     WEDGED_IDLE_TX_SECONDS = 300;
     WEDGED_ACTIVE_SECONDS = 300;
@@ -4536,7 +4632,7 @@ __export(reset_exports, {
   removePapiEntry: () => removePapiEntry,
   runReset: () => runReset
 });
-import { existsSync as existsSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join21 } from "path";
 import { createInterface } from "readline/promises";
@@ -4546,7 +4642,7 @@ function findResetTarget() {
     let raw;
     let parsed;
     try {
-      raw = readFileSync13(path7, "utf-8");
+      raw = readFileSync14(path7, "utf-8");
       parsed = JSON.parse(raw);
     } catch {
       continue;
@@ -4647,7 +4743,7 @@ __export(audit_exports, {
   __testing: () => __testing2,
   runAudit: () => runAudit
 });
-import { existsSync as existsSync13, readFileSync as readFileSync14, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15, readdirSync as readdirSync7 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join22 } from "path";
 function safeListDirs(dir) {
@@ -4668,7 +4764,7 @@ function readMcp(projectPath) {
   const path7 = join22(projectPath, ".mcp.json");
   if (!existsSync13(path7)) return { servers: [] };
   try {
-    const parsed = JSON.parse(readFileSync14(path7, "utf-8"));
+    const parsed = JSON.parse(readFileSync15(path7, "utf-8"));
     const mcpServers = parsed.mcpServers ?? {};
     const servers = Object.keys(mcpServers);
     if (parsed.papi && !servers.includes("papi")) servers.push("papi");
@@ -4724,7 +4820,7 @@ function readGlobalSkills() {
 function readGlobalMcpServers() {
   if (!existsSync13(GLOBAL_CLAUDE_JSON)) return [];
   try {
-    const parsed = JSON.parse(readFileSync14(GLOBAL_CLAUDE_JSON, "utf-8"));
+    const parsed = JSON.parse(readFileSync15(GLOBAL_CLAUDE_JSON, "utf-8"));
     const servers = parsed.mcpServers ?? {};
     return Object.keys(servers).sort((a, b2) => a.localeCompare(b2));
   } catch {
@@ -4890,7 +4986,7 @@ var setup_exports = {};
 __export(setup_exports, {
   runSetup: () => runSetup
 });
-import { existsSync as existsSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync7, chmodSync as chmodSync2, statSync as statSync7 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync16, writeFileSync as writeFileSync7, chmodSync as chmodSync2, statSync as statSync8 } from "fs";
 import { join as join23 } from "path";
 function baseUrl() {
   const fromEnv = process.env["PAPI_HOST"] ?? process.env["PAPI_BASE_URL"];
@@ -4927,7 +5023,7 @@ function writeMcpJson(opts) {
   let parsed = {};
   if (existsSync14(path7)) {
     try {
-      parsed = JSON.parse(readFileSync15(path7, "utf-8"));
+      parsed = JSON.parse(readFileSync16(path7, "utf-8"));
     } catch {
       throw new Error(`.mcp.json at ${path7} is not valid JSON. Fix it or remove it before re-running setup.`);
     }
@@ -4950,7 +5046,7 @@ function writeMcpJson(opts) {
   parsed.mcpServers = mcpServers;
   writeFileSync7(path7, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
   try {
-    const mode = statSync7(path7).mode & 511;
+    const mode = statSync8(path7).mode & 511;
     if (mode !== 384) chmodSync2(path7, 384);
   } catch {
   }
@@ -5058,7 +5154,7 @@ var init_setup = __esm({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { dirname as dirname6, join as join24, basename as basename2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -5104,7 +5200,6 @@ function loadConfig() {
       "\nPAPI is running, but no project is configured here.\n" + HELP_FOOTER + "\n"
     );
   }
-  const anthropicApiKey = process.env.PAPI_API_KEY ?? "";
   const autoCommit2 = process.env.PAPI_AUTO_COMMIT !== "false";
   const baseBranch = process.env.PAPI_BASE_BRANCH ?? "main";
   const autoPR = process.env.PAPI_AUTO_PR !== "false";
@@ -5178,7 +5273,6 @@ Already have an account? Make sure PAPI_USER_ID is set in your .mcp.json env con
   return {
     projectRoot,
     papiDir: path.join(projectRoot, ".papi"),
-    anthropicApiKey,
     autoCommit: autoCommit2,
     baseBranch,
     autoPR,
@@ -5469,6 +5563,9 @@ var SECTION_HEADERS = [
   "FILES LIKELY TOUCHED",
   "EFFORT"
 ];
+function normaliseHeaderLine(line) {
+  return line.trim().replace(/^#{1,6}\s*/, "").replace(/^-\s+/, "").replace(/^\*\*(.*?)\*\*$/, "$1").replace(/:\s*$/, "").trim();
+}
 function splitSections(text) {
   const sections = /* @__PURE__ */ new Map();
   const lines = text.split("\n");
@@ -5481,8 +5578,8 @@ function splitSections(text) {
     }
   };
   for (const line of lines) {
-    const trimmed = line.trim();
-    const matched = SECTION_HEADERS.find((h) => trimmed === h);
+    const normalised = normaliseHeaderLine(line);
+    const matched = SECTION_HEADERS.find((h) => normalised === h);
     if (matched) {
       flush();
       currentSection = matched;
@@ -5503,7 +5600,10 @@ function parseChecklist(text) {
   return text.split("\n").map((l) => l.replace(/^\s*\[[ x]]\s*/, "").trim()).filter((l) => l.length > 0);
 }
 function parseBuildHandoff(markdown) {
-  if (!markdown.includes("BUILD HANDOFF")) return null;
+  if (typeof markdown !== "string" || !markdown.trim()) return null;
+  if (!markdown.includes("BUILD HANDOFF") && splitSections(markdown).size === 0) {
+    return null;
+  }
   const taskIdMatch = markdown.match(/BUILD HANDOFF\s*—\s*(task-\d+)/);
   const taskTitleMatch = markdown.match(/^Task:\s*(.+)$/m);
   const cycleMatch = markdown.match(/^Cycle:\s*(\d+)$/m);
@@ -5538,6 +5638,28 @@ function parseBuildHandoff(markdown) {
     effort
   };
 }
+function coerceBuildHandoff(fields, taskId) {
+  const scope = ensureArray(fields.scope);
+  const scopeBoundary = ensureArray(fields.scopeBoundary);
+  if (scope.length === 0 && scopeBoundary.length === 0) return null;
+  const effortRaw = typeof fields.effort === "string" ? fields.effort.trim().toUpperCase() : "";
+  const effort = VALID_EFFORT_SIZES.has(effortRaw) ? effortRaw : "M";
+  const str = (v) => typeof v === "string" ? v.trim() : "";
+  return {
+    uuid: str(fields.uuid) || randomUUID2(),
+    taskId: str(fields.taskId) || taskId || "",
+    taskTitle: str(fields.taskTitle),
+    cycle: typeof fields.cycle === "number" ? fields.cycle : 0,
+    whyNow: str(fields.whyNow),
+    scope,
+    scopeBoundary,
+    acceptanceCriteria: ensureArray(fields.acceptanceCriteria),
+    securityConsiderations: str(fields.securityConsiderations),
+    verificationFiles: ensureArray(fields.verificationFiles),
+    filesLikelyTouched: ensureArray(fields.filesLikelyTouched),
+    effort
+  };
+}
 function ensureArray(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -8071,7 +8193,7 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
 }
 
 // src/server.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { access as access4, readdir as readdir4, readFile as readFile9 } from "fs/promises";
 import { join as join19, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -8912,6 +9034,7 @@ Everything in Part 1 (natural language) is **display-only**. Part 2 (structured
 - Updated or created Active Decisions in Part 1? \u2192 Put them in \`activeDecisions\` array (with id and full body including ### heading)
 - Found board corrections (wrong priority, missing fields, stale status) in Part 1? \u2192 Put them in \`boardCorrections\` array
 - Generated BUILD HANDOFFs in Part 1? \u2192 Put them in \`cycleHandoffs\` array
+- **\`complexity\` uses the LONG forms only** \u2014 "XS", "Small", "Medium", "Large", "XL". Do NOT reuse the handoff EFFORT short-forms (S/M/L) for task complexity.
 
 **Example with populated fields (DO NOT copy literally \u2014 adapt to your actual analysis):**
 \`\`\`json
@@ -8952,13 +9075,20 @@ This is Cycle 0 \u2014 the first planning cycle for a brand-new project.
    - Do NOT assume web-app patterns (routes, pages, components) unless the brief explicitly describes a web application
    - All tasks: status Backlog, priority P1-P2, reviewed true, phase "Phase 1"
 
+   **REASONING LINE (task-2868 \u2014 the first cycle must SHOW PAPI's intelligence, not read as a generic list).** For EVERY task, the \`notes\` field MUST OPEN with a single line in the exact form:
+   \`Why: <one plain-language sentence, \u2264160 chars, on why THIS task earns its place in the first cycle>\`
+   Then a blank line, then any other notes. Rules:
+   - Task 1's \`Why:\` must also justify its POSITION \u2014 say why it is the opening slice (the thinnest thing that puts the core loop in front of the user). This one line is the cycle's sequencing rationale; the dashboard surfaces it above the first task.
+   - Plain language for a semi-technical builder \u2014 no jargon, no raw IDs, not a restatement of the title.
+   - This is a hard requirement: the dashboard's first-cycle experience reads and renders this \`Why:\` line per task.
+
 4. **First Active Decision** \u2014 If the description implies a clear architectural choice, create AD-1 with Confidence: MEDIUM. If no clear choice, skip this.
 
 5. **BUILD HANDOFFs** \u2014 Generate a full BUILD HANDOFF block for EVERY task created in step 3 (all 3-5 tasks). Include each in the \`cycleHandoffs\` array. **tempId join (REQUIRED \u2014 mismatches silently scramble handoffs):** give EVERY \`newTasks\` entry a unique \`tempId\` (\`"new-1"\`, \`"new-2"\`, \u2026), and set each \`cycleHandoffs\` \`taskId\` to the EXACT \`tempId\` of the newTask it belongs to. Do NOT rely on array order, and do NOT reuse a tempId. The builder needs handoffs to run \`build_execute\` \u2014 without them, tasks must be completed via \`ad_hoc\`, which breaks the normal flow.
 
 ### Structured output for Bootstrap:
 In the JSON block, you MUST include:
-- "newTasks": array of task objects with ALL fields: title, status, priority, complexity, module, epic, phase, owner, notes. **This is how tasks get created on the board. If this array is empty, NO tasks will exist.**
+- "newTasks": array of task objects with ALL fields: title, status, priority, complexity, module, epic, phase, owner, notes. **This is how tasks get created on the board. If this array is empty, NO tasks will exist.** Every \`notes\` value MUST open with the \`Why: <sentence>\` reasoning line described in step 3 (the dashboard's first-cycle experience renders it).
 - "productBrief": the full Product Brief markdown content. **If null, the brief stays as the template.**
 - "activeDecisions": array of {id, body} objects. **If you created AD-1 in Part 1 but this array is empty, the AD will NOT be saved.**
 - "recommendedTaskId": null (the handler will use the first new task)
@@ -9502,10 +9632,17 @@ function coerceToString(value) {
   return JSON.stringify(value, null, 2);
 }
 function coerceStructuredOutput(parsed) {
-  const cycleHandoffs = Array.isArray(parsed.cycleHandoffs) ? parsed.cycleHandoffs.map((h) => ({
-    taskId: coerceToString(h.taskId),
-    buildHandoff: coerceToString(h.buildHandoff)
-  })) : [];
+  const cycleHandoffs = Array.isArray(parsed.cycleHandoffs) ? parsed.cycleHandoffs.map((h) => {
+    const { taskId: _t, buildHandoff: _b, ...rest } = h;
+    if (typeof h.buildHandoff === "object" && h.buildHandoff !== null && !Array.isArray(h.buildHandoff)) {
+      Object.assign(rest, h.buildHandoff);
+    }
+    return {
+      taskId: coerceToString(h.taskId),
+      buildHandoff: typeof h.buildHandoff === "string" ? h.buildHandoff : "",
+      ...Object.keys(rest).length > 0 ? { structuredFields: rest } : {}
+    };
+  }) : [];
   const newTasks = Array.isArray(parsed.newTasks) ? parsed.newTasks.map((t) => ({
     // task-2242: stable join key (optional — undefined falls back to index).
     tempId: t.tempId !== void 0 && t.tempId !== null ? coerceToString(t.tempId) : void 0,
@@ -10615,9 +10752,12 @@ async function applyHandoffs(adapter2, rawLlmOutput, cycleNumber, force = false)
         skipped++;
         continue;
       }
-      const parsed = parseBuildHandoff(handoff.buildHandoff);
+      const parsed = parseBuildHandoff(handoff.buildHandoff) ?? (handoff.structuredFields ? coerceBuildHandoff(handoff.structuredFields, handoff.taskId) : null);
       if (!parsed) {
-        warnings.push(`Failed to parse handoff for ${handoff.taskId}`);
+        const received = (handoff.buildHandoff ?? "").slice(0, 80);
+        warnings.push(
+          `Failed to parse handoff for ${handoff.taskId}. Received: "${received}${(handoff.buildHandoff ?? "").length > 80 ? "\u2026" : ""}". Send EITHER the BUILD HANDOFF markdown template in \`buildHandoff\` (section headers on their own lines: SCOPE (DO THIS) / SCOPE BOUNDARY (DO NOT DO THIS) / ACCEPTANCE CRITERIA / EFFORT, bullets as "- item") OR structured fields alongside taskId: {scope: string[], scopeBoundary: string[], acceptanceCriteria: string[], effort: "XS|S|M|L|XL"}.`
+        );
         continue;
       }
       const invalidFields = validateHandoffScope(parsed);
@@ -10625,7 +10765,6 @@ async function applyHandoffs(adapter2, rawLlmOutput, cycleNumber, force = false)
         warnings.push(
           `Rejected handoff for ${handoff.taskId}: missing or empty ${invalidFields.join(", ")}. Handoffs without explicit scope produce ambiguous builds.`
         );
-        skipped++;
         continue;
       }
       if (!parsed.createdAt) {
@@ -11100,6 +11239,20 @@ async function resolveOwnerGate(adapter2, config2) {
 }
 
 // src/services/plan.ts
+var COMPLEXITY_ALIASES = {
+  "XS": "XS",
+  "S": "Small",
+  "SMALL": "Small",
+  "M": "Medium",
+  "MEDIUM": "Medium",
+  "L": "Large",
+  "LARGE": "Large",
+  "XL": "XL"
+};
+function normalizeComplexity(value) {
+  const key = (value ?? "").trim().toUpperCase();
+  return COMPLEXITY_ALIASES[key] ?? "Small";
+}
 var PLAN_BUILD_REPORT_BUDGET = { maxReports: 12, fieldBudget: 280 };
 function leadChainWithRecommended(chain, recommendedTaskId) {
   const rec = recommendedTaskId?.trim();
@@ -12038,10 +12191,13 @@ ${cleanContent}`;
   } catch {
   }
   const handoffs = (data.cycleHandoffs ?? []).map((h) => {
-    const parsed = parseBuildHandoff(h.buildHandoff);
+    const parsed = parseBuildHandoff(h.buildHandoff) ?? (h.structuredFields ? coerceBuildHandoff(h.structuredFields, h.taskId) : null);
     if (parsed && !parsed.createdAt) {
       parsed.createdAt = (/* @__PURE__ */ new Date()).toISOString();
     }
+    if (!parsed) {
+      console.error(`[plan] dropping unparseable handoff for ${h.taskId} (not the BUILD HANDOFF template and no structured scope fields)`);
+    }
     return { taskId: h.taskId, handoff: parsed };
   }).filter((h) => h.handoff != null);
   const cycleTaskIds = data.cycleTaskIds?.length ? data.cycleTaskIds : (data.cycleHandoffs ?? []).map((h) => h.taskId);
@@ -12128,7 +12284,7 @@ ${cleanContent}`;
       title: t.title,
       status: t.status || "Backlog",
       priority: t.priority || "P1 High",
-      complexity: t.complexity || "Small",
+      complexity: normalizeComplexity(t.complexity),
       module: t.module || "Core",
       epic: t.epic || "Platform",
       phase: t.phase || "Phase 1",
@@ -12276,7 +12432,7 @@ ${cleanContent}`;
         title: task.title,
         status: task.status || "Backlog",
         priority: task.priority || "P1 High",
-        complexity: task.complexity || "Small",
+        complexity: normalizeComplexity(task.complexity),
         module: task.module || "Core",
         epic: task.epic || "Platform",
         phase: task.phase || "Phase 1",
@@ -13288,6 +13444,13 @@ async function resolveLlmResponse(inlineResponse, filePath) {
   }
   const resolvedPath = filePath.trim();
   if (!isAbsolute(resolvedPath)) {
+    const looksWindows = /^[A-Za-z]:[\\/]/.test(resolvedPath) || resolvedPath.startsWith("\\\\");
+    if (looksWindows && process.platform !== "win32") {
+      return {
+        ok: false,
+        error: `llm_response_file points at a path on YOUR machine (${resolvedPath}), but this PAPI server runs remotely and cannot read your filesystem. llm_response_file only works with a locally installed (stdio) server. On the hosted connection, pass the content inline via llm_response.`
+      };
+    }
     return {
       ok: false,
       error: `llm_response_file must be an absolute path, got: ${resolvedPath}`
@@ -13534,7 +13697,7 @@ var planTool = {
       },
       llm_response_file: {
         type: "string",
-        description: 'Absolute path to a file containing the plan output (mode "apply" only). Use this when the response is too large to pass as a string parameter (some hosts cap inputs around 50KB). The file must be absolute, exist, and be \u2264500KB. Mutually exclusive with llm_response.'
+        description: 'Absolute path to a file containing the plan output (mode "apply" only). LOCAL stdio servers only \u2014 on the hosted connection the server cannot read files on your machine; pass llm_response inline instead. Use this when the response is too large to pass as a string parameter (some hosts cap inputs around 50KB). The file must be absolute, exist, and be \u2264500KB. Mutually exclusive with llm_response.'
       },
       cycle_number: {
         type: "number",
@@ -13609,7 +13772,7 @@ function formatPlanResult(result) {
     return textResponse(
       `${pullLine}**${modeLabel} Mode \u2014 ${cycleLabel}**
 
-\u26A0\uFE0F **Persistence failed:** Structured output could not be parsed. Cycle log, board corrections, handoffs, and Active Decisions were NOT saved. Try running \`plan\` again.`
+\u26A0\uFE0F **Persistence failed:** Structured output could not be parsed. Cycle log, board corrections, handoffs, and Active Decisions were NOT saved. Your llm_response must contain the literal marker \`<!-- PAPI_STRUCTURED_OUTPUT -->\` followed by the JSON inside a \`\`\`json code fence \u2014 resend with that exact envelope (do not strip the marker or the fence).`
     );
   }
   const lines = [];
@@ -15940,6 +16103,11 @@ Confidence: ${input.confidence}. Captured mid-conversation via strategy_change c
 }
 
 // src/tools/strategy.ts
+function toDateLabel(value) {
+  if (typeof value === "string") return value.slice(0, 10);
+  const d = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(d.getTime()) ? "" : d.toISOString().slice(0, 10);
+}
 var reviewPrepareCache = new PerCallerCache();
 var strategyReviewTool = {
   name: "strategy_review",
@@ -15959,7 +16127,7 @@ var strategyReviewTool = {
       },
       llm_response_file: {
         type: "string",
-        description: 'Absolute path to a file containing the review output (mode "apply" only). Use this when the response is too large to pass as a string parameter (some hosts cap inputs around 50KB). The file must be absolute, exist, and be \u2264500KB. Mutually exclusive with llm_response.'
+        description: 'Absolute path to a file containing the review output (mode "apply" only). LOCAL stdio servers only \u2014 on the hosted connection the server cannot read files on your machine; pass llm_response inline instead. Use this when the response is too large to pass as a string parameter (some hosts cap inputs around 50KB). The file must be absolute, exist, and be \u2264500KB. Mutually exclusive with llm_response.'
       },
       cycle_number: {
         type: "number",
@@ -16241,7 +16409,7 @@ This topic will surface in the next \`strategy_review\`.`
     const lines = topics.map((t, i) => {
       const cycleSuffix = t.sourceCycle != null ? ` (Cycle ${t.sourceCycle})` : "";
       return `${i + 1}. ${t.topic}
-   _source: ${t.source}${cycleSuffix} \xB7 queued ${t.createdAt.slice(0, 10)}_`;
+   _source: ${t.source}${cycleSuffix} \xB7 queued ${toDateLabel(t.createdAt)}_`;
     });
     return textResponse(
       `**Pending Agenda (${topics.length})** \u2014 surfaces at next strategy review
@@ -17934,7 +18102,9 @@ async function applySetupOutputs(adapter2, config2, input, collector, briefText,
             }
             if (adapter2.upsertActiveDecision) {
               const title = ad.title || ad.body.split("\n")[0].replace(/^#+\s*/, "").slice(0, 120);
-              await adapter2.upsertActiveDecision(ad.id, ad.body, title, ad.confidence || "MEDIUM", 0);
+              const confidenceMatch = ad.body.match(/\[Confidence:\s*(HIGH|MEDIUM|LOW)\]/i);
+              const confidence = confidenceMatch ? confidenceMatch[1].toUpperCase() : ad.confidence || "MEDIUM";
+              await adapter2.upsertActiveDecision(ad.id, ad.body, title, confidence, 0);
             } else {
               await adapter2.updateActiveDecision(ad.id, ad.body, 0);
             }
@@ -18714,10 +18884,14 @@ ${[created, skipped].filter(Boolean).join(", ")}.${idea}`;
 \u26A0\uFE0F **Setup warnings (non-blocking):**
 ${result.warnings.map((w) => `- ${w}`).join("\n")}` : "";
   const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
-  return textResponse(
-    `${prefix}Product Brief generated and saved.${briefRegenNote}${adNote}${northStarNote}${taskNote}${constraintsHint}${editorNote}${gitignoreNote}${warningsNote}
+  const isHosted = !!result.filesToWrite && !result.filesToWrite.isEmpty();
+  const filesNote = isHosted ? `
+
+**Important:** This is a remote PAPI connection, so the server could not write to your project directory. Setup prepared your files (${harnessFiles}, .claude/settings.json, docs/) and returned them in the scaffolding section below \u2014 **write each one to disk, then commit** before running \`build_execute\` (it requires a clean working directory).` : `
 
-**Important:** Setup created/modified files (${harnessFiles}, .claude/settings.json, docs/). Commit these changes before running \`build_execute\` \u2014 it requires a clean working directory.
+**Important:** Setup created/modified files (${harnessFiles}, .claude/settings.json, docs/). Commit these changes before running \`build_execute\` \u2014 it requires a clean working directory.`;
+  return textResponse(
+    `${prefix}Product Brief generated and saved.${briefRegenNote}${adNote}${northStarNote}${taskNote}${constraintsHint}${editorNote}${gitignoreNote}${warningsNote}${filesNote}
 
 Tip: See \`docs/templates/example-project-brief.md\` for an example of a well-written brief.
 
@@ -19727,6 +19901,61 @@ async function completeRelease(tracker, opts) {
   }
   await tracker.recordStep("released", { metadata: { version: opts.version } });
 }
+var OPEN_PR_STALE_DAYS = 21;
+function taskIdFromBranch(headRefName) {
+  const m = /^feat\/(task-\d+)\b/.exec(headRefName);
+  return m ? m[1] : null;
+}
+function classifyOpenPr(pr, cycleNum, inReviewCycleTaskIds, nowMs) {
+  const head = pr.headRefName;
+  const ageDays = (nowMs - Date.parse(pr.createdAt)) / 864e5;
+  if (new RegExp(`^feat/cycle-${cycleNum}-`).test(head)) {
+    return { pr, bucket: "cycle-branch", action: `merge into this release \u2014 \`${head}\` is this cycle's branch and still open` };
+  }
+  const taskId = taskIdFromBranch(head);
+  if (taskId && inReviewCycleTaskIds.has(taskId)) {
+    return { pr, bucket: "held-adhoc-this-cycle", action: `MERGE before closing \u2014 ${taskId} is In Review pinned to Cycle ${cycleNum}` };
+  }
+  if (taskId) {
+    return { pr, bucket: "held-adhoc-other", action: "held adhoc not pinned to this cycle \u2014 defer, or merge if ready" };
+  }
+  if (Number.isFinite(ageDays) && ageDays > OPEN_PR_STALE_DAYS) {
+    return { pr, bucket: "stale", action: `review/close \u2014 open ${Math.round(ageDays)}d with no cycle link` };
+  }
+  return { pr, bucket: "external-other", action: "review manually \u2014 merge, defer, or close" };
+}
+var OPEN_PR_BUCKET_ORDER = [
+  "held-adhoc-this-cycle",
+  "cycle-branch",
+  "external-other",
+  "stale",
+  "held-adhoc-other"
+];
+function buildOpenPrSweepLines(openPrs, cycleNum, inReviewCycleTaskIds, nowMs) {
+  const lines = [];
+  if (openPrs === null) {
+    lines.push("", "**Open-PR sweep:** skipped \u2014 `gh` unavailable. Run `gh pr list` yourself to check for held/external PRs before considering the cycle closed.");
+  } else if (openPrs.length > 0) {
+    const classified = openPrs.map((pr) => classifyOpenPr(pr, cycleNum, inReviewCycleTaskIds, nowMs)).sort((a, b2) => OPEN_PR_BUCKET_ORDER.indexOf(a.bucket) - OPEN_PR_BUCKET_ORDER.indexOf(b2.bucket));
+    lines.push("", `**Open-PR sweep \u2014 ${openPrs.length} open PR(s). Resolve each before considering Cycle ${cycleNum} closed:**`);
+    for (const c of classified) {
+      lines.push(`- #${c.pr.number} \`${c.pr.headRefName}\` by ${c.pr.author} \u2014 [${c.bucket}] ${c.action}`);
+    }
+  }
+  if (inReviewCycleTaskIds.size > 0) {
+    const prByTask = /* @__PURE__ */ new Map();
+    for (const p of openPrs ?? []) {
+      const id = taskIdFromBranch(p.headRefName);
+      if (id) prByTask.set(id, p.number);
+    }
+    const rows = [...inReviewCycleTaskIds].sort().map((id) => {
+      const prNum = prByTask.get(id);
+      return `  - ${id}${prNum ? ` (PR #${prNum})` : " (no open PR found)"}`;
+    });
+    lines.push("", `\u26A0\uFE0F **${inReviewCycleTaskIds.size} task(s) still In Review, pinned to Cycle ${cycleNum} \u2014 their work is NOT merged. Accept/merge or defer before closing:**`, ...rows);
+  }
+  return lines;
+}
 
 // src/tools/release.ts
 init_git();
@@ -20217,6 +20446,20 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
     if (result.warnings?.length) {
       lines.push("", "\u26A0\uFE0F Warnings: " + result.warnings.join("; "));
     }
+    try {
+      const openPrs = listOpenPullRequests(config2.projectRoot);
+      const closedCycle = result.cycleClosed ?? 0;
+      let inReviewIds = /* @__PURE__ */ new Set();
+      if (closedCycle > 0) {
+        const board = await adapter2.queryBoard();
+        inReviewIds = new Set(
+          board.filter((t) => t.status === "In Review" && t.cycle === closedCycle).map((t) => t.id)
+        );
+      }
+      const sweep = buildOpenPrSweepLines(openPrs, closedCycle, inReviewIds, Date.now());
+      if (sweep.length > 0) lines.push(...sweep);
+    } catch {
+    }
     tracker.mark("surface-discovered-issues");
     try {
       const closedCycle = result.cycleClosed ?? 0;
@@ -20958,8 +21201,8 @@ async function startBuild(adapter2, config2, taskId, options = {}, clientName) {
         } else {
           const stashLabel = `papi-autostash/${taskId}-${Math.floor(Date.now() / 1e3)}`;
           try {
-            const { execFileSync: execFileSync6 } = await import("child_process");
-            execFileSync6("git", ["stash", "push", "-u", "-m", stashLabel, "--", ...toStash], {
+            const { execFileSync: execFileSync7 } = await import("child_process");
+            execFileSync7("git", ["stash", "push", "-u", "-m", stashLabel, "--", ...toStash], {
               cwd: config2.projectRoot,
               encoding: "utf-8"
             });
@@ -20985,8 +21228,8 @@ async function startBuild(adapter2, config2, taskId, options = {}, clientName) {
       if (hasRemote(config2.projectRoot) && !featureBranchExistsLocally) {
         if (featureBranchOnOrigin) {
           try {
-            const { execFileSync: execFileSync6 } = await import("child_process");
-            execFileSync6("git", ["fetch", "origin", `${featureBranch}:${featureBranch}`], {
+            const { execFileSync: execFileSync7 } = await import("child_process");
+            execFileSync7("git", ["fetch", "origin", `${featureBranch}:${featureBranch}`], {
               cwd: config2.projectRoot,
               encoding: "utf-8",
               timeout: 6e4
@@ -22110,6 +22353,10 @@ var buildExecuteTool = {
         enum: ["yes", "no", "partial"],
         description: "Whether the build was completed. Required for complete."
       },
+      acceptance_confirmed: {
+        type: "boolean",
+        description: `task-2833: set true to assert every acceptance criterion in the task's BUILD HANDOFF was met. Required to record a completed:"yes" build when the handoff lists acceptance criteria \u2014 without it, build_execute returns the criteria checklist and does NOT mark the task Done (the report is not discarded; re-send with acceptance_confirmed:true). Tasks with no acceptance criteria, and completed:"partial"/"no", are unaffected.`
+      },
       effort: {
         type: "string",
         enum: ["XS", "S", "M", "L", "XL"],
@@ -22565,6 +22812,25 @@ 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 acceptanceConfirmed = args.acceptance_confirmed === true;
+  if (completed === "yes" && !acceptanceConfirmed) {
+    const gateInfo = adapter2.getProjectInfo ? await adapter2.getProjectInfo().catch(() => null) : null;
+    const gateCaps = gateInfo?.capabilities ?? {};
+    const gateTask = isCapabilityEnabled(gateCaps, "acceptanceGate") ? await adapter2.getTask(taskId).catch(() => null) : null;
+    const criteria = (gateTask?.buildHandoff?.acceptanceCriteria ?? []).filter((c) => c && c.trim());
+    if (criteria.length > 0) {
+      const checklist = criteria.map((c) => `  - [ ] ${c}`).join("\n");
+      return textResponse(
+        `**Acceptance criteria not yet confirmed for ${taskId}.**
+
+This task's BUILD HANDOFF lists ${criteria.length} acceptance criteri${criteria.length === 1 ? "on" : "a"}. Confirm each was met, then re-call \`build_execute\` complete with the SAME report fields plus \`acceptance_confirmed: true\`:
+
+${checklist}
+
+Your report was NOT discarded and the task is NOT yet Done \u2014 re-send with \`acceptance_confirmed: true\` to record completion. If a criterion was NOT met, the task is not complete: finish it, or report \`completed: "partial"\` with what remains in \`surprises\`.`
+      );
+    }
+  }
   const tracker = new ProgressTracker("complete_validate").bindStream(adapter2, { stage: "build", taskId });
   try {
     tracker.mark("complete_build");
@@ -23042,7 +23308,7 @@ var bugTool = {
       severity: {
         type: "string",
         enum: ["critical", "major", "minor"],
-        description: 'Bug severity (default: "major"). Critical = P1, Major/Minor = P2.'
+        description: 'Bug severity (default: "major"). Critical = P0, Major = P1, Minor = P2.'
       },
       notes: {
         type: "string",
@@ -24222,6 +24488,13 @@ Re-run build_execute complete with a production_verification field, then re-subm
 
 // src/tools/review.ts
 var REVIEW_DISPATCH_THRESHOLD = 50 * 1024;
+var REVIEW_DISPATCH_CEILING = 40 * 1024;
+var REVIEW_ECHO_CAP = 4e3;
+function trimForEcho(text) {
+  if (text.length <= REVIEW_ECHO_CAP) return text;
+  return `${text.slice(0, REVIEW_ECHO_CAP)}
+\u2026[trimmed ${text.length - REVIEW_ECHO_CAP} chars]`;
+}
 var REVIEW_RUBRIC = [
   "You are reviewing a completed PAPI build for acceptance. Judge:",
   "- Correctness: does the change do what the build report claims, without obvious bugs?",
@@ -24551,6 +24824,7 @@ async function handleReviewSubmit(adapter2, config2, args) {
   const autoDispatchOptIn = args.dispatch !== "inline" && process.env.PAPI_AUTO_DISPATCH !== "false" && isCapabilityEnabled(caps, "prReviewer");
   const autoDispatchEligible = !verdict && autoDispatchOptIn;
   const capabilityAutoReviewEligible = verdict === "accept" && !autoReview && autoDispatchOptIn;
+  let capabilityReviewSkippedNote = "";
   if ((explicitDispatch || autoDispatchEligible || capabilityAutoReviewEligible) && stage === "build-acceptance" && taskId) {
     const dispatch = await buildReviewDispatch(
       adapter2,
@@ -24560,8 +24834,16 @@ async function handleReviewSubmit(adapter2, config2, args) {
     );
     if (!dispatch.ok) {
       if (explicitDispatch) return errorResponse(dispatch.error);
-    } else if (explicitDispatch || capabilityAutoReviewEligible || dispatch.contextBytes > REVIEW_DISPATCH_THRESHOLD) {
+    } else if (explicitDispatch || autoDispatchEligible && dispatch.contextBytes > REVIEW_DISPATCH_THRESHOLD) {
       return textResponse(dispatch.prompt);
+    } else if (capabilityAutoReviewEligible) {
+      if (dispatch.contextBytes <= REVIEW_DISPATCH_CEILING) {
+        return textResponse(dispatch.prompt);
+      }
+      const kb = (dispatch.contextBytes / 1024).toFixed(0);
+      capabilityReviewSkippedNote = `
+
+> \u26A0\uFE0F pr-reviewer auto-review skipped \u2014 the diff/build-report (~${kb} KB) exceeds the ${REVIEW_DISPATCH_CEILING / 1024} KB inline-dispatch ceiling, which would overflow the response and drop the accept (task-2854). Verdict recorded directly. To review the diff explicitly, run \`review_submit ${taskId} build-acceptance accept dispatch:"subagent"\`.`;
     }
   }
   if (explicitDispatch && stage !== "build-acceptance") {
@@ -24721,36 +25003,51 @@ ${overlap}`;
 
 \u2705 Verdict recorded. All cycle tasks are Done, but **auto-release is owner-only** \u2014 your identity does not match this project's owner, so no release was cut. Push your branch and open a PR for the owner to run \`release\`.${resolutionNote}`;
         } else if (cycleTasks.length > 0 && cycleTasks.every((t) => t.status === "Done")) {
-          const baseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
-          const unmergedCycleBranches = isGitAvailable() && isGitRepo(config2.projectRoot) ? listGroupedCycleBranches(config2.projectRoot, result.currentCycle, baseBranch) : [];
-          if (unmergedCycleBranches.length > 0) {
+          let planRunCount = null;
+          if (typeof adapter2.countPlanRunsForCycle === "function") {
+            try {
+              planRunCount = await adapter2.countPlanRunsForCycle(result.currentCycle);
+            } catch {
+              planRunCount = null;
+            }
+          }
+          if (planRunCount === 0) {
             autoReleaseNote = `
 
 ---
 
+\u26A0\uFE0F **Auto-release skipped** \u2014 Cycle ${result.currentCycle} has **no plan run** (100% injected/adhoc work), so it was never planned. Auto-release only fires for planned cycles, to avoid silently shipping a cycle nobody opened (C340 incident). All tasks are Done \u2014 run \`release\` explicitly to close and ship this cycle.`;
+          } else {
+            const baseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
+            const unmergedCycleBranches = isGitAvailable() && isGitRepo(config2.projectRoot) ? listGroupedCycleBranches(config2.projectRoot, result.currentCycle, baseBranch) : [];
+            if (unmergedCycleBranches.length > 0) {
+              autoReleaseNote = `
+
+---
+
 \u26A0\uFE0F **Auto-release skipped** \u2014 all tasks are Done but ${unmergedCycleBranches.length} cycle branch(es) not yet merged: \`${unmergedCycleBranches.join("`, `")}\`.
 
 Merge or squash those PRs first, then run \`release\` manually.`;
-          } else {
-            try {
-              const allReviews = await adapter2.getRecentReviews(200);
-              const cycleReviews = allReviews.filter(
-                (r) => r.cycle === result.currentCycle && r.stage === "build-acceptance"
-              );
-              const reviewsWithAutoReview = cycleReviews.filter((r) => r.autoReview);
-              if (reviewsWithAutoReview.length > 0) {
-                const verdictCounts = { pass: 0, warn: 0, fail: 0 };
-                const findingsBySeverity = { error: 0, warning: 0, info: 0 };
-                for (const r of reviewsWithAutoReview) {
-                  if (r.autoReview) {
-                    verdictCounts[r.autoReview.verdict] = (verdictCounts[r.autoReview.verdict] ?? 0) + 1;
-                    for (const f of r.autoReview.findings) {
-                      findingsBySeverity[f.severity] = (findingsBySeverity[f.severity] ?? 0) + 1;
+            } else {
+              try {
+                const allReviews = await adapter2.getRecentReviews(200);
+                const cycleReviews = allReviews.filter(
+                  (r) => r.cycle === result.currentCycle && r.stage === "build-acceptance"
+                );
+                const reviewsWithAutoReview = cycleReviews.filter((r) => r.autoReview);
+                if (reviewsWithAutoReview.length > 0) {
+                  const verdictCounts = { pass: 0, warn: 0, fail: 0 };
+                  const findingsBySeverity = { error: 0, warning: 0, info: 0 };
+                  for (const r of reviewsWithAutoReview) {
+                    if (r.autoReview) {
+                      verdictCounts[r.autoReview.verdict] = (verdictCounts[r.autoReview.verdict] ?? 0) + 1;
+                      for (const f of r.autoReview.findings) {
+                        findingsBySeverity[f.severity] = (findingsBySeverity[f.severity] ?? 0) + 1;
+                      }
                     }
                   }
-                }
-                const totalFindings = findingsBySeverity.error + findingsBySeverity.warning + findingsBySeverity.info;
-                batchSummaryNote = `
+                  const totalFindings = findingsBySeverity.error + findingsBySeverity.warning + findingsBySeverity.info;
+                  batchSummaryNote = `
 
 ---
 
@@ -24758,42 +25055,42 @@ Merge or squash those PRs first, then run \`release\` manually.`;
 
 - Verdicts: ${verdictCounts.pass} pass, ${verdictCounts.warn} warn, ${verdictCounts.fail} fail
 ` + (totalFindings > 0 ? `- Findings: ${findingsBySeverity.error} error${findingsBySeverity.error !== 1 ? "s" : ""}, ${findingsBySeverity.warning} warning${findingsBySeverity.warning !== 1 ? "s" : ""}, ${findingsBySeverity.info} info` : "- No findings logged");
+                }
+              } catch {
               }
-            } catch {
-            }
-            const version = `v0.${result.currentCycle}.0`;
-            const autoGate = evaluateReleaseGate(caps, config2.gateCommand, void 0);
-            if (autoGate.action !== "proceed") {
-              autoReleaseNote = `
+              const version = `v0.${result.currentCycle}.0`;
+              const autoGate = evaluateReleaseGate(caps, config2.gateCommand, void 0);
+              if (autoGate.action !== "proceed") {
+                autoReleaseNote = `
 
 ---
 
 \u26A0\uFE0F **Auto-release skipped** \u2014 a release quality gate is configured (\`${config2.gateCommand}\`), and it cannot be run from inside \`review_submit\`.
 
 Run \`release\` manually: PAPI will hand you the gate command, then release once you report it green.`;
-            } else {
-              const releaseTracker = new ProgressTracker("auto-release").bindStream(adapter2, { stage: "release" });
-              await beginRelease(releaseTracker, result.currentCycle);
-              const releaseResult = await createRelease(config2, baseBranch, version, adapter2, result.currentCycle);
-              await recordReadinessVerified(releaseTracker);
-              await recordQualityGate(releaseTracker, autoGate, caps);
-              await tracker.recordStep("auto_release_triggered", { metadata: { version: releaseResult.version } });
-              const autoChangelogDirective = buildChangelogDirective(
-                caps,
-                buildCycleUpdateCurationDirective(releaseResult.version, releaseResult.cycleClosed ?? 0)
-              );
-              const autoDeployDirective = buildDeployHookDirective(caps, config2.deployCommand);
-              await completeRelease(releaseTracker, {
-                cycleClosed: releaseResult.cycleClosed ?? null,
-                version: releaseResult.version,
-                caps,
-                branchMerges: releaseResult.groupedBranchMerges ?? [],
-                changelogEmitted: Boolean(autoChangelogDirective),
-                deployHookEmitted: Boolean(autoDeployDirective)
-              });
-              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 = `
+              } else {
+                const releaseTracker = new ProgressTracker("auto-release").bindStream(adapter2, { stage: "release" });
+                await beginRelease(releaseTracker, result.currentCycle);
+                const releaseResult = await createRelease(config2, baseBranch, version, adapter2, result.currentCycle);
+                await recordReadinessVerified(releaseTracker);
+                await recordQualityGate(releaseTracker, autoGate, caps);
+                await tracker.recordStep("auto_release_triggered", { metadata: { version: releaseResult.version } });
+                const autoChangelogDirective = buildChangelogDirective(
+                  caps,
+                  buildCycleUpdateCurationDirective(releaseResult.version, releaseResult.cycleClosed ?? 0)
+                );
+                const autoDeployDirective = buildDeployHookDirective(caps, config2.deployCommand);
+                await completeRelease(releaseTracker, {
+                  cycleClosed: releaseResult.cycleClosed ?? null,
+                  version: releaseResult.version,
+                  caps,
+                  branchMerges: releaseResult.groupedBranchMerges ?? [],
+                  changelogEmitted: Boolean(autoChangelogDirective),
+                  deployHookEmitted: Boolean(autoDeployDirective)
+                });
+                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 = `
 
 ---
 
@@ -24804,13 +25101,14 @@ Run \`release\` manually: PAPI will hand you the gate command, then release once
 - ${releaseResult.tagMessage}
 - ${pushInfo}` + groupedMergeNote + (releaseResult.warnings?.length ? `
 - Warnings: ${releaseResult.warnings.join(", ")}` : "") + // task-2598 (C328): the auto path previously swallowed the curated
-              // cycle-update directive that the manual path emits, so an auto-released
-              // cycle never prompted the Discord post. Same directive, same gate.
-              (autoChangelogDirective ? `
+                // cycle-update directive that the manual path emits, so an auto-released
+                // cycle never prompted the Discord post. Same directive, same gate.
+                (autoChangelogDirective ? `
 ${autoChangelogDirective}` : "") + (autoDeployDirective ? `
 ${autoDeployDirective}` : "") + `
 
 Run \`plan\` to create Cycle ${result.currentCycle + 1}.`;
+              }
             }
           }
         }
@@ -24870,9 +25168,9 @@ Next: address the feedback, then run \`build_execute ${taskId}\` to resubmit.`;
       `**${result.stageLabel}** recorded for ${result.taskId}.
 
 - **Verdict:** ${result.verdict}
-- **Comments:** ${result.comments}
+- **Comments:** ${trimForEcho(result.comments)}
 
-${statusNote}${autoReviewNote}${securityNote}${unblockNote}${docClosureNote}${regenNote}${mergeNote}${overlapNote}${batchSummaryNote}${autoReleaseNote}${nextStepNote}${phaseNote}`
+${statusNote}${capabilityReviewSkippedNote}${autoReviewNote}${securityNote}${unblockNote}${docClosureNote}${regenNote}${mergeNote}${overlapNote}${batchSummaryNote}${autoReleaseNote}${nextStepNote}${phaseNote}`
     );
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -26911,6 +27209,7 @@ async function handleOrient(adapter2, config2, args = {}, clientName) {
       // Skill proposals — one-time codebase scan on first orient per project.
       // PERF: hasToolMilestone (LIMIT 1 EXISTS) replaces readToolMetrics (5000-row pull).
       tracked("skill-scan", async () => {
+        if (!hasLocalWorkspace()) return "";
         const alreadyScanned = adapter2.hasToolMilestone ? await adapter2.hasToolMilestone("milestone:skill_scan_completed") : (await adapter2.readToolMetrics()).some((m) => m.tool === "milestone:skill_scan_completed");
         if (alreadyScanned) return "";
         const proposals = scanForSkillSignals(config2.projectRoot);
@@ -27805,11 +28104,11 @@ var handoffGenerateTool = {
       },
       llm_response: {
         type: "string",
-        description: 'Your raw output from executing the handoff prompt (mode "apply" only). Must include both Part 1 (markdown) and Part 2 (structured JSON after <!-- PAPI_STRUCTURED_OUTPUT -->). Mutually exclusive with llm_response_file.'
+        description: 'Your raw output from executing the handoff prompt (mode "apply" only). Must include both Part 1 (markdown) and Part 2 (structured JSON after <!-- PAPI_STRUCTURED_OUTPUT -->, inside a ```json fence). Each cycleHandoffs entry needs EITHER a buildHandoff string in the BUILD HANDOFF markdown template (section headers on their own lines: SCOPE (DO THIS) / SCOPE BOUNDARY (DO NOT DO THIS) / ACCEPTANCE CRITERIA / EFFORT) OR structured fields alongside taskId: {scope: string[], scopeBoundary: string[], acceptanceCriteria: string[], effort: "XS|S|M|L|XL"}. Mutually exclusive with llm_response_file.'
       },
       llm_response_file: {
         type: "string",
-        description: 'Absolute path to a file containing the handoff output (mode "apply" only). Use instead of llm_response when the output exceeds tool parameter size limits. Mutually exclusive with llm_response.'
+        description: 'Absolute path to a file containing the handoff output (mode "apply" only). LOCAL stdio servers only \u2014 on the hosted connection the server cannot read files on your machine; pass llm_response inline instead. Use instead of llm_response when the output exceeds tool parameter size limits. Mutually exclusive with llm_response.'
       },
       cycle_number: {
         type: "number",
@@ -27906,10 +28205,12 @@ ${result.userMessage}
   }
 }
 
+// src/tools/scope-brief.ts
+import { readFileSync as readFileSync11, statSync as statSync7 } from "fs";
+
 // src/services/scope-brief.ts
 import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "fs";
 import { join as join17, dirname as dirname4 } from "path";
-import Anthropic from "@anthropic-ai/sdk";
 var SCOPE_BRIEF_SYSTEM = `You are a technical scoping tool. You receive a brief-class task (too large to build directly) and decompose it into a structured scope document.
 
 A scope document must:
@@ -27940,7 +28241,18 @@ Return the scope document in Markdown. Use this exact structure:
 <Any unknowns that affect scope, or "None">
 
 Return ONLY the markdown document. No preamble, no commentary.`;
-async function runScopeBrief(adapter2, input) {
+async function buildScopeBriefPrompt(adapter2, taskId) {
+  const tasks = await adapter2.queryBoard({});
+  const task = tasks.find((t) => t.id === taskId || t.displayId === taskId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId}`);
+  }
+  if (task.scopeClass !== "brief") {
+    throw new Error(`Task ${taskId} is not brief-class (scopeClass=${task.scopeClass ?? "task"}). Only brief-class tasks can be scoped.`);
+  }
+  return { task, systemPrompt: SCOPE_BRIEF_SYSTEM, userContext: buildTaskContext(task) };
+}
+async function applyScopeBrief(adapter2, input) {
   const tasks = await adapter2.queryBoard({});
   const task = tasks.find((t) => t.id === input.taskId || t.displayId === input.taskId);
   if (!task) {
@@ -27949,17 +28261,9 @@ async function runScopeBrief(adapter2, input) {
   if (task.scopeClass !== "brief") {
     throw new Error(`Task ${input.taskId} is not brief-class (scopeClass=${task.scopeClass ?? "task"}). Only brief-class tasks can be scoped.`);
   }
-  const taskContext = buildTaskContext(task);
-  const client = new Anthropic({ apiKey: input.apiKey });
-  const response = await client.messages.create({
-    model: "claude-sonnet-4-6",
-    max_tokens: 2048,
-    system: SCOPE_BRIEF_SYSTEM,
-    messages: [{ role: "user", content: taskContext }]
-  });
-  const docContent = response.content[0].type === "text" ? response.content[0].text.trim() : "";
+  const docContent = input.llmMarkdown.trim();
   if (!docContent) {
-    throw new Error("LLM returned empty scope document");
+    throw new Error("Scope document is empty \u2014 pass the markdown you produced from the scope prompt as llm_response.");
   }
   const slug = input.taskId.replace(/[^a-z0-9-]/g, "-").toLowerCase();
   const relPath = `docs/scopes/${slug}.md`;
@@ -28044,7 +28348,7 @@ function buildSummary(task, taskCount) {
 // src/tools/scope-brief.ts
 var scopeBriefTool = {
   name: "scope_brief",
-  description: "Decompose a brief-class task (Large/XL, too large to build directly) into a structured scope document. Runs an LLM pass to produce sub-tasks, writes docs/scopes/<task-id>.md, registers it in the doc registry, and marks the source task as decomposed. Use before planning a cycle that includes brief-class tasks.",
+  description: 'Decompose a brief-class task (Large/XL, too large to build directly) into a structured scope document. Two phases, like plan/strategy \u2014 PAPI never calls a model itself (AD-58): first call (mode "prepare") returns a scoping prompt for YOU to run in your own AI workspace; then call again (mode "apply") with your markdown output in llm_response to write docs/scopes/<task-id>.md, register it, and mark the source task decomposed. Use before planning a cycle that includes brief-class tasks.',
   annotations: { title: "Scope Brief", readOnlyHint: false, destructiveHint: false, openWorldHint: false },
   inputSchema: {
     type: "object",
@@ -28052,42 +28356,102 @@ var scopeBriefTool = {
       task_id: {
         type: "string",
         description: 'ID of the brief-class task to decompose (e.g. "task-042").'
+      },
+      mode: {
+        type: "string",
+        enum: ["prepare", "apply"],
+        description: '"prepare" (default) returns the scoping prompt for you to run. "apply" persists the scope document you produced.'
+      },
+      llm_response: {
+        type: "string",
+        description: 'Your markdown scope document from running the prepare prompt (mode "apply" only).'
+      },
+      llm_response_file: {
+        type: "string",
+        description: 'Absolute path to a file holding your markdown scope document (mode "apply" only). LOCAL stdio servers only \u2014 the hosted server cannot read your machine. Mutually exclusive with llm_response; must be absolute, exist, and be \u2264500KB.'
       }
     },
     required: ["task_id"]
   }
 };
+var MAX_RESPONSE_FILE_BYTES = 500 * 1024;
 async function handleScopeBrief(adapter2, config2, args) {
   const taskId = args.task_id;
   if (!taskId) {
     return errorResponse("task_id is required.");
   }
-  const apiKey = process.env["ANTHROPIC_API_KEY"];
-  if (!apiKey) {
-    return errorResponse("ANTHROPIC_API_KEY is not set \u2014 scope_brief requires LLM access.");
-  }
+  const mode = args.mode ?? "prepare";
   const health = await adapter2.getCycleHealth().catch(() => ({ totalCycles: 0 }));
-  try {
-    const result = await runScopeBrief(adapter2, {
-      taskId,
-      apiKey,
-      projectRoot: config2.projectRoot,
-      cycleNumber: health.totalCycles,
-      adapterType: config2.adapterType
-    });
-    const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
-    return textResponse(
-      `**Scope document created:** \`${result.docPath}\`
+  if (mode === "prepare") {
+    try {
+      const { task, systemPrompt, userContext } = await buildScopeBriefPrompt(adapter2, taskId);
+      return textResponse(
+        `**Scope Brief \u2014 prepare** for ${task.id}: ${task.title}
+
+Run the scoping pass below in YOUR AI workspace (PAPI does not call a model \u2014 AD-58), then call \`scope_brief\` again with \`mode: "apply"\`, the same \`task_id\`, and your markdown document in \`llm_response\`.
+
+---
+
+## Scoping instructions
+
+${systemPrompt}
+
+---
+
+## Task to decompose
+
+${userContext}`
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return errorResponse(`scope_brief prepare failed: ${message}`);
+    }
+  }
+  if (mode === "apply") {
+    const llmMarkdown = readLlmResponse(args);
+    if (!llmMarkdown) {
+      return errorResponse('mode "apply" requires your scope document \u2014 pass it in llm_response (or llm_response_file on a local server).');
+    }
+    try {
+      const result = await applyScopeBrief(adapter2, {
+        taskId,
+        llmMarkdown,
+        projectRoot: config2.projectRoot,
+        cycleNumber: health.totalCycles,
+        adapterType: config2.adapterType
+      });
+      const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
+      return textResponse(
+        `**Scope document created:** \`${result.docPath}\`
 - **Sub-tasks defined:** ${result.taskCount}
 - **Doc registry ID:** ${result.docId}
 - **Source task:** ${taskId} marked as decomposed
 
 **Next step:** Review \`${result.docPath}\` and submit each sub-task via \`idea\` with \`Reference: ${result.docPath}\` in notes. The planner will pick them up in the next cycle.` + filesToWriteSection
-    );
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return errorResponse(`scope_brief failed: ${message}`);
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return errorResponse(`scope_brief apply failed: ${message}`);
+    }
+  }
+  return errorResponse(`Unknown mode "${mode}" \u2014 use "prepare" or "apply".`);
+}
+function readLlmResponse(args) {
+  const inline = args.llm_response;
+  if (inline && inline.trim()) return inline;
+  const filePath = args.llm_response_file;
+  if (filePath && filePath.trim()) {
+    try {
+      if (statSync7(filePath).size > MAX_RESPONSE_FILE_BYTES) {
+        throw new Error(`llm_response_file exceeds ${MAX_RESPONSE_FILE_BYTES} bytes`);
+      }
+      const body = readFileSync11(filePath, "utf-8");
+      return body.trim() ? body : null;
+    } catch (err) {
+      throw new Error(`could not read llm_response_file: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
+  return null;
 }
 
 // src/tools/ad-view.ts
@@ -29313,7 +29677,7 @@ function createServer(adapter2, config2) {
   const __pkgDir = dirname5(__pkgFilename);
   let serverVersion = "unknown";
   try {
-    const pkg = JSON.parse(readFileSync11(join19(__pkgDir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync12(join19(__pkgDir, "..", "package.json"), "utf-8"));
     serverVersion = pkg.version ?? "unknown";
   } catch {
   }
@@ -29738,6 +30102,13 @@ function startHttpTransport(opts) {
     const ip = clientIp(req);
     const origin = req.headers.origin;
     const cors = corsHeaders(origin);
+    const pathname = (() => {
+      try {
+        return new URL(req.url ?? "/", "http://internal").pathname;
+      } catch {
+        return req.url ?? "/";
+      }
+    })();
     if (req.method === "OPTIONS") {
       if (Object.keys(cors).length === 0) {
         sendError(res, { status: 403, body: { error: "Origin not allowed" } });
@@ -29752,12 +30123,12 @@ function startHttpTransport(opts) {
       sendError(res, { status: 400, body: { error: "HTTPS required" } });
       return;
     }
-    if (req.method === "GET" && req.url === "/healthz") {
+    if (req.method === "GET" && pathname === "/healthz") {
       res.writeHead(200, { "Content-Type": "text/plain", ...cors });
       res.end("ok");
       return;
     }
-    if (req.method === "GET" && req.url === "/.well-known/oauth-protected-resource") {
+    if (req.method === "GET" && pathname === "/.well-known/oauth-protected-resource") {
       res.writeHead(200, {
         "Content-Type": "application/json",
         "Cache-Control": "public, max-age=3600",
@@ -29773,7 +30144,7 @@ function startHttpTransport(opts) {
       );
       return;
     }
-    if (req.method === "GET" && req.url === "/.well-known/glama.json") {
+    if (req.method === "GET" && pathname === "/.well-known/glama.json") {
       res.writeHead(200, {
         "Content-Type": "application/json",
         "Cache-Control": "public, max-age=3600",
@@ -29787,7 +30158,7 @@ function startHttpTransport(opts) {
       );
       return;
     }
-    if (req.method === "GET" && req.url === "/.well-known/oauth-authorization-server") {
+    if (req.method === "GET" && pathname === "/.well-known/oauth-authorization-server") {
       res.writeHead(302, {
         Location: `${DASHBOARD_ORIGIN}/.well-known/oauth-authorization-server`,
         "Cache-Control": "public, max-age=3600",
@@ -29796,7 +30167,7 @@ function startHttpTransport(opts) {
       res.end();
       return;
     }
-    if (req.url !== "/mcp" && req.url !== "/sse") {
+    if (pathname !== "/mcp" && pathname !== "/sse") {
       sendError(res, { status: 404, body: { error: "Not found" } }, cors);
       return;
     }
@@ -30052,7 +30423,7 @@ async function dispatchRequest(args) {
 var __dirname = dirname6(fileURLToPath4(import.meta.url));
 var pkgVersion = "unknown";
 try {
-  const pkg = JSON.parse(readFileSync16(join24(__dirname, "..", "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync17(join24(__dirname, "..", "package.json"), "utf-8"));
   pkgVersion = pkg.version;
 } catch {
 }
@@ -30076,6 +30447,7 @@ Options:
   --yes, -y        Skip confirmation prompts (reset only)
   --idle-mcp       Flag PAPI-idle projects in audit (needs DATABASE_URL; read-only)
   --fix-pool       Terminate this role's confirmed-wedged DB backends (doctor only; guarded)
+  --reap-orphans   Terminate parentless @papi-ai/server processes (doctor only; guarded)
 
 Getting started:
   1. Run "npx @papi-ai/server setup" in any project folder
@@ -30238,6 +30610,15 @@ if (isHttpMode && httpPort !== void 0) {
     process.stderr.write("[papi] Fatal: stdio mode requires an MCP server instance.\n");
     process.exit(1);
   }
+  try {
+    const { reapOrphans: reapOrphans2 } = await Promise.resolve().then(() => (init_reap_orphans(), reap_orphans_exports));
+    const swept = reapOrphans2({});
+    if (swept.reaped.length > 0) {
+      process.stderr.write(`[papi] Reaped ${swept.reaped.length} orphaned server process(es): ${swept.reaped.join(", ")}
+`);
+    }
+  } catch {
+  }
   const transport = new StdioServerTransport();
   await server.connect(transport);
   const projectName = basename2(config.projectRoot);