@papi-ai/server 0.7.52 → 0.7.54

package/dist/index.js

@@ -26,6 +26,7 @@ __export(git_exports, {
   detectUnrecordedCommits: () => detectUnrecordedCommits,
   ensureLatestDevelop: () => ensureLatestDevelop,
   ensureTagAtHead: () => ensureTagAtHead,
+  findTaskCommitsOnBase: () => findTaskCommitsOnBase,
   getBranchDiff: () => getBranchDiff,
   getCommitsSinceTag: () => getCommitsSinceTag,
   getCurrentBranch: () => getCurrentBranch,
@@ -719,11 +720,29 @@ function escapeRegexLiteral(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function detectMergedInProgress(cwd, preferredBase, tasks) {
-  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
   const inProgress = tasks.filter((t) => t.status === "In Progress");
   if (inProgress.length === 0) return [];
+  const landed = findTaskCommitsOnBase(cwd, preferredBase, inProgress.map((t) => t.displayId));
+  const hits = [];
+  for (const task of inProgress) {
+    const hit = landed.get(task.displayId);
+    if (!hit) continue;
+    hits.push({
+      displayId: task.displayId,
+      title: task.title,
+      commit: hit.commit,
+      subject: hit.subject,
+      pr: hit.pr
+    });
+  }
+  return hits;
+}
+function findTaskCommitsOnBase(cwd, preferredBase, displayIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (displayIds.length === 0) return out;
+  if (!isGitAvailable() || !isGitRepo(cwd)) return out;
   const base = resolveDefaultBranch(cwd, preferredBase);
-  if (!branchExists(cwd, base)) return [];
+  if (!branchExists(cwd, base)) return out;
   let raw;
   try {
     raw = execFileSync(
@@ -732,28 +751,25 @@ function detectMergedInProgress(cwd, preferredBase, tasks) {
       { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     );
   } catch {
-    return [];
+    return out;
   }
   const commits = raw.split("\n").map((line) => {
     const idx = line.indexOf("
");
     if (idx === -1) return null;
     return { hash: line.slice(0, idx).trim(), subject: line.slice(idx + 1).trim() };
   }).filter((c) => c !== null && c.hash !== "");
-  const hits = [];
-  for (const task of inProgress) {
-    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(task.displayId)}([^\\w-]|$)`);
+  for (const displayId of displayIds) {
+    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(displayId)}([^\\w-]|$)`);
     const hit = commits.find((c) => re.test(c.subject));
     if (!hit) continue;
     const prMatch = hit.subject.match(/#(\d+)/);
-    hits.push({
-      displayId: task.displayId,
-      title: task.title,
+    out.set(displayId, {
       commit: hit.hash,
       subject: hit.subject,
       pr: prMatch ? `#${prMatch[1]}` : null
     });
   }
-  return hits;
+  return out;
 }
 function detectUnrecordedCommits(cwd, baseBranch) {
   if (!isGitAvailable() || !isGitRepo(cwd)) return [];
@@ -1281,21 +1297,27 @@ var init_proxy_adapter = __esm({
       // getToolCallCount + updatePhaseStatus are ABSENT: they now have edge handlers and
       // are served through the forwarder (getToolCallCount = SUP-2026-026 handler #1).
       "createOwnerAction",
-      "findPendingDocActionsForTask",
       "getContributorRole",
-      "getDecisionScorePatterns",
-      "getModuleEstimationStats",
-      "correctLatestBuildReportEffort",
       "recordContributorReleasePr",
       "setContributorReleasePrStatus",
       "listContributorReleasePrs",
-      "resolveLearningsForDoneTasks",
-      "markCycleLearningResolved",
-      "updateStageExitCriteria",
-      "updateDocAction",
       "claimReview",
       "getSiblingAds",
       "getSiblingRepoTasks"
+      // task-2394 (C329) — Batch A wired: findPendingDocActionsForTask,
+      // getModuleEstimationStats and getDecisionScorePatterns now have edge case handlers
+      // (each backed by a SECURITY DEFINER RPC, migration 20260714140000) plus
+      // ALLOWED_METHODS entries, so they forward. The two planner-context reads returned
+      // EMPTY for every hosted user before this — the planner ran on worse context than
+      // the owner's on the only install path external users have (AD-72).
+      // task-2412 (C329) — listOwnerActionsForBlockerScan + linkOwnerActionToTask wired.
+      // First USER-scoped ([C]) methods to forward: the edge binds both to the bearer's
+      // user_id and discards the client-supplied one, so the typed-blocker scan (task-2343)
+      // now works for hosted users without exposing one member's owner actions to another.
+      // task-2393 (C329) — Batch B wired: markCycleLearningResolved (the P1 — hosted
+      // discovered_issue_resolve hard-errored), correctLatestBuildReportEffort,
+      // updateStageExitCriteria, updateDocAction, resolveLearningsForDoneTasks all have
+      // edge case handlers + ALLOWED_METHODS/WRITE_METHODS entries now, so they forward.
       // task-2489 (C320): recordProgressStep is now wired to the edge data-proxy
       // (case handler + ALLOWED_METHODS/WRITE_METHODS entries), so it forwards for
       // hosted callers and persists a project-scoped cycle_progress_steps row. Removed
@@ -4211,9 +4233,9 @@ __export(doctor_exports, {
   __testing: () => __testing,
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync12 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function redact(name, value) {
   if (!value) return "(empty)";
   if (SECRET_VARS.has(name)) {
@@ -4224,14 +4246,14 @@ function redact(name, value) {
 }
 function findMcpJson() {
   const candidates = [
-    join19(process.cwd(), ".mcp.json"),
-    join19(homedir4(), ".claude", ".mcp.json"),
-    join19(homedir4(), ".mcp.json")
+    join20(process.cwd(), ".mcp.json"),
+    join20(homedir4(), ".claude", ".mcp.json"),
+    join20(homedir4(), ".mcp.json")
   ];
   for (const path7 of candidates) {
-    if (!existsSync10(path7)) continue;
+    if (!existsSync11(path7)) continue;
     try {
-      const raw = readFileSync11(path7, "utf-8");
+      const raw = readFileSync12(path7, "utf-8");
       const parsed = JSON.parse(raw);
       const papiEntry = parsed.papi ?? parsed.mcpServers?.papi;
       if (!papiEntry) continue;
@@ -4505,17 +4527,17 @@ __export(reset_exports, {
   removePapiEntry: () => removePapiEntry,
   runReset: () => runReset
 });
-import { existsSync as existsSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { createInterface } from "readline/promises";
 function findResetTarget() {
   for (const path7 of CANDIDATE_PATHS()) {
-    if (!existsSync11(path7)) continue;
+    if (!existsSync12(path7)) continue;
     let raw;
     let parsed;
     try {
-      raw = readFileSync12(path7, "utf-8");
+      raw = readFileSync13(path7, "utf-8");
       parsed = JSON.parse(raw);
     } catch {
       continue;
@@ -4586,7 +4608,7 @@ async function runReset(args = []) {
     }
   }
   try {
-    writeFileSync5(target.path, removePapiEntry(target), "utf-8");
+    writeFileSync6(target.path, removePapiEntry(target), "utf-8");
     process.stdout.write(`
 \u2713 Removed papi entry from ${target.path}
 `);
@@ -4603,9 +4625,9 @@ var init_reset = __esm({
   "src/cli/reset.ts"() {
     "use strict";
     CANDIDATE_PATHS = () => [
-      join20(process.cwd(), ".mcp.json"),
-      join20(homedir5(), ".claude", ".mcp.json"),
-      join20(homedir5(), ".mcp.json")
+      join21(process.cwd(), ".mcp.json"),
+      join21(homedir5(), ".claude", ".mcp.json"),
+      join21(homedir5(), ".mcp.json")
     ];
   }
 });
@@ -4616,9 +4638,9 @@ __export(audit_exports, {
   __testing: () => __testing2,
   runAudit: () => runAudit
 });
-import { existsSync as existsSync12, readFileSync as readFileSync13, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync14, readdirSync as readdirSync7 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function safeListDirs(dir) {
   try {
     return readdirSync7(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b2) => a.localeCompare(b2));
@@ -4634,10 +4656,10 @@ function safeListFiles(dir, ext) {
   }
 }
 function readMcp(projectPath) {
-  const path7 = join21(projectPath, ".mcp.json");
-  if (!existsSync12(path7)) return { servers: [] };
+  const path7 = join22(projectPath, ".mcp.json");
+  if (!existsSync13(path7)) return { servers: [] };
   try {
-    const parsed = JSON.parse(readFileSync13(path7, "utf-8"));
+    const parsed = JSON.parse(readFileSync14(path7, "utf-8"));
     const mcpServers = parsed.mcpServers ?? {};
     const servers = Object.keys(mcpServers);
     if (parsed.papi && !servers.includes("papi")) servers.push("papi");
@@ -4669,18 +4691,18 @@ function auditProjectSync(projectPath, name) {
     path: projectPath,
     papiProjectId,
     mcpServers: servers,
-    skills: safeListDirs(join21(projectPath, ".claude", "skills")),
-    agentSkills: safeListDirs(join21(projectPath, ".agents", "skills")),
-    agents: safeListFiles(join21(projectPath, ".claude", "agents"), ".md"),
-    hooks: safeListFiles(join21(projectPath, ".claude", "hooks"), ".sh")
+    skills: safeListDirs(join22(projectPath, ".claude", "skills")),
+    agentSkills: safeListDirs(join22(projectPath, ".agents", "skills")),
+    agents: safeListFiles(join22(projectPath, ".claude", "agents"), ".md"),
+    hooks: safeListFiles(join22(projectPath, ".claude", "hooks"), ".sh")
   };
 }
 function discoverProjects() {
   const out = [];
   for (const root of PROJECT_ROOTS) {
     for (const name of safeListDirs(root)) {
-      const path7 = join21(root, name);
-      if (existsSync12(join21(path7, ".mcp.json")) || existsSync12(join21(path7, ".claude"))) {
+      const path7 = join22(root, name);
+      if (existsSync13(join22(path7, ".mcp.json")) || existsSync13(join22(path7, ".claude"))) {
         out.push({ name, path: path7 });
       }
     }
@@ -4691,9 +4713,9 @@ function readGlobalSkills() {
   return safeListDirs(GLOBAL_SKILLS_DIR);
 }
 function readGlobalMcpServers() {
-  if (!existsSync12(GLOBAL_CLAUDE_JSON)) return [];
+  if (!existsSync13(GLOBAL_CLAUDE_JSON)) return [];
   try {
-    const parsed = JSON.parse(readFileSync13(GLOBAL_CLAUDE_JSON, "utf-8"));
+    const parsed = JSON.parse(readFileSync14(GLOBAL_CLAUDE_JSON, "utf-8"));
     const servers = parsed.mcpServers ?? {};
     return Object.keys(servers).sort((a, b2) => a.localeCompare(b2));
   } catch {
@@ -4845,9 +4867,9 @@ var PROJECT_ROOTS, GLOBAL_SKILLS_DIR, GLOBAL_CLAUDE_JSON, IDLE_WINDOW_DAYS, GLOB
 var init_audit = __esm({
   "src/cli/audit.ts"() {
     "use strict";
-    PROJECT_ROOTS = [join21(homedir6(), "Ai-App-Projects"), join21(homedir6(), "android-projects")];
-    GLOBAL_SKILLS_DIR = join21(homedir6(), ".claude", "skills");
-    GLOBAL_CLAUDE_JSON = join21(homedir6(), ".claude.json");
+    PROJECT_ROOTS = [join22(homedir6(), "Ai-App-Projects"), join22(homedir6(), "android-projects")];
+    GLOBAL_SKILLS_DIR = join22(homedir6(), ".claude", "skills");
+    GLOBAL_CLAUDE_JSON = join22(homedir6(), ".claude.json");
     IDLE_WINDOW_DAYS = 30;
     GLOBALIZE_THRESHOLD = 3;
     __testing2 = { readMcp, computeFlags, formatReport: formatReport2, discoverProjects, auditProjectSync };
@@ -4859,8 +4881,8 @@ var setup_exports = {};
 __export(setup_exports, {
   runSetup: () => runSetup
 });
-import { existsSync as existsSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync6, chmodSync as chmodSync2, statSync as statSync6 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync7, chmodSync as chmodSync2, statSync as statSync7 } from "fs";
+import { join as join23 } from "path";
 function baseUrl() {
   const fromEnv = process.env["PAPI_HOST"] ?? process.env["PAPI_BASE_URL"];
   if (fromEnv) return fromEnv.replace(/\/$/, "");
@@ -4892,11 +4914,11 @@ function sleep(ms) {
   return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function writeMcpJson(opts) {
-  const path7 = join22(process.cwd(), ".mcp.json");
+  const path7 = join23(process.cwd(), ".mcp.json");
   let parsed = {};
-  if (existsSync13(path7)) {
+  if (existsSync14(path7)) {
     try {
-      parsed = JSON.parse(readFileSync14(path7, "utf-8"));
+      parsed = JSON.parse(readFileSync15(path7, "utf-8"));
     } catch {
       throw new Error(`.mcp.json at ${path7} is not valid JSON. Fix it or remove it before re-running setup.`);
     }
@@ -4917,9 +4939,9 @@ function writeMcpJson(opts) {
   }
   mcpServers.papi = papiEntry;
   parsed.mcpServers = mcpServers;
-  writeFileSync6(path7, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+  writeFileSync7(path7, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
   try {
-    const mode = statSync6(path7).mode & 511;
+    const mode = statSync7(path7).mode & 511;
     if (mode !== 384) chmodSync2(path7, 384);
   } catch {
   }
@@ -5027,8 +5049,8 @@ var init_setup = __esm({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname6, join as join23 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { dirname as dirname6, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
@@ -8037,9 +8059,9 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
 }
 
 // src/server.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import { access as access4, readdir as readdir4, readFile as readFile9 } from "fs/promises";
-import { join as join18, dirname as dirname5 } from "path";
+import { join as join19, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
@@ -8301,16 +8323,41 @@ ${deferredSection}` : body;
   if (deferredSection) sections.push(deferredSection);
   return sections.join("\n\n");
 }
-function formatCandidateTaskFullNotes(tasks) {
+var PLAN_FULL_NOTES_BUDGET_BYTES = Number(process.env.PAPI_PLAN_NOTES_BUDGET) || 6e4;
+var priorityRank = (p) => p ? PRIORITY_RANK[p] ?? 4 : 4;
+function formatCandidateTaskFullNotes(tasks, budgetBytes = PLAN_FULL_NOTES_BUDGET_BYTES) {
   const candidates = tasks.filter((t) => !PLAN_EXCLUDED_STATUSES.has(t.status)).filter((t) => (t.notes?.length ?? 0) > PLAN_NOTES_MAX_LENGTH);
   if (candidates.length === 0) return void 0;
-  const lines = candidates.map((t) => `**${t.id}** \u2014 ${t.title}
-${t.notes}`);
-  return [
-    `${candidates.length} candidate task(s) have notes longer than ${PLAN_NOTES_MAX_LENGTH} chars. Full untruncated notes below \u2014 reference these when generating BUILD HANDOFFs so submitter context, constraints, and reasoning are preserved. The Board section above uses truncated notes for concise task selection; this section supplies the missing detail for tasks you choose to schedule.`,
-    "",
-    ...lines
-  ].join("\n\n");
+  const ranked = candidates.map((t, i) => ({ t, i })).sort((a, b2) => priorityRank(a.t.priority) - priorityRank(b2.t.priority) || a.i - b2.i).map(({ t }) => t);
+  const included = [];
+  const elided = [];
+  let spent = 0;
+  for (const t of ranked) {
+    const entry = `**${t.id}** \u2014 ${t.title}
+${t.notes}`;
+    const cost = Buffer.byteLength(entry, "utf-8");
+    if (included.length > 0 && spent + cost > budgetBytes) {
+      elided.push(t);
+      continue;
+    }
+    included.push(entry);
+    spent += cost;
+  }
+  const header = `${candidates.length} candidate task(s) have notes longer than ${PLAN_NOTES_MAX_LENGTH} chars. Full untruncated notes below \u2014 reference these when generating BUILD HANDOFFs so submitter context, constraints, and reasoning are preserved. The Board section above uses truncated notes for concise task selection; this section supplies the missing detail for tasks you choose to schedule.`;
+  const parts = [header, "", ...included];
+  if (elided.length > 0) {
+    parts.push(
+      "",
+      `### ELIDED \u2014 ${elided.length} lower-priority candidate(s) omitted to keep this payload under ${Math.round(budgetBytes / 1024)} KB`,
+      "",
+      "Full notes were included above for the highest-priority candidates only. The following tasks have long notes that are NOT shown here:",
+      "",
+      elided.map((t) => `- ${t.id} (${t.priority ?? "unranked"})`).join("\n"),
+      "",
+      `You still have each of these tasks in the Board section with its notes truncated to ${PLAN_NOTES_MAX_LENGTH} chars, which is enough to rank and select them. If you schedule one, say so in the cycle log and scope its handoff from the truncated notes. Do NOT invent or infer the elided detail \u2014 if a task genuinely needs its full notes to be scoped, prefer leaving it unscheduled over guessing at the submitter's intent.`
+    );
+  }
+  return parts.join("\n\n");
 }
 function formatBoardForReview(tasks) {
   if (tasks.length === 0) return "No tasks on the board.";
@@ -8341,6 +8388,29 @@ function effortWeight(size2) {
       return 3;
   }
 }
+function computeCycleEffort(cycleTaskRows, cycleReports) {
+  if (cycleTaskRows && cycleTaskRows.length > 0) {
+    const done = cycleTaskRows.filter((t) => t.status === "Done");
+    const reportByTask = /* @__PURE__ */ new Map();
+    for (const r of cycleReports) if (r.taskId) reportByTask.set(r.taskId, r);
+    return {
+      completed: done.length,
+      total: cycleTaskRows.length,
+      plannedPoints: done.reduce((s, t) => s + effortWeight(t.complexity), 0),
+      deliveredPoints: done.reduce((s, t) => {
+        const actual = reportByTask.get(t.id)?.actualEffort;
+        return s + effortWeight(actual || t.complexity);
+      }, 0)
+    };
+  }
+  const completed = cycleReports.filter((r) => r.completed === "Yes").length;
+  return {
+    completed,
+    total: cycleReports.length,
+    plannedPoints: cycleReports.reduce((s, r) => s + effortWeight(r.estimatedEffort || r.actualEffort), 0),
+    deliveredPoints: cycleReports.reduce((s, r) => s + effortWeight(r.actualEffort || r.estimatedEffort), 0)
+  };
+}
 function computeSnapshotsFromBuildReports(reports, tasks) {
   const reportsByCycle = /* @__PURE__ */ new Map();
   for (const r of reports) {
@@ -8364,24 +8434,19 @@ function computeSnapshotsFromBuildReports(reports, tasks) {
     const withEffort = cycleReports.filter((r) => r.estimatedEffort && r.actualEffort);
     const accurate = withEffort.filter((r) => r.estimatedEffort === r.actualEffort).length;
     const matchRate = withEffort.length > 0 ? Math.round(accurate / withEffort.length * 100) : 0;
-    let completed;
-    let total;
-    let effortPoints;
-    if (cycleTaskRows && cycleTaskRows.length > 0) {
-      const done = cycleTaskRows.filter((t) => t.status === "Done");
-      completed = done.length;
-      total = cycleTaskRows.length;
-      effortPoints = done.reduce((s, t) => s + effortWeight(t.complexity), 0);
-    } else {
-      completed = cycleReports.filter((r) => r.completed === "Yes").length;
-      total = cycleReports.length;
-      effortPoints = cycleReports.reduce((s, r) => s + effortWeight(r.actualEffort), 0);
-    }
+    const { completed, total, plannedPoints, deliveredPoints } = computeCycleEffort(cycleTaskRows, cycleReports);
     snapshots.push({
       cycle: sn,
       date: (/* @__PURE__ */ new Date()).toISOString(),
       accuracy: [{ cycle: sn, reports: cycleReports.length, matchRate, mae: 0, bias: 0 }],
-      velocity: [{ cycle: sn, completed, partial: 0, failed: Math.max(0, total - completed), effortPoints }]
+      velocity: [{
+        cycle: sn,
+        completed,
+        partial: 0,
+        failed: Math.max(0, total - completed),
+        effortPoints: plannedPoints,
+        deliveredPoints
+      }]
     });
   }
   snapshots.sort((a, b2) => a.cycle - b2.cycle);
@@ -8393,13 +8458,25 @@ function formatCycleMetrics(snapshots) {
   const allVelocities = snapshots.flatMap((s) => s.velocity).sort((a, b2) => a.cycle - b2.cycle);
   const recentVelocities = allVelocities.slice(-5);
   if (recentVelocities.length > 0) {
-    const avgEffort = Math.round(
+    const avgPlanned = Math.round(
       recentVelocities.reduce((sum, v) => sum + v.effortPoints, 0) / recentVelocities.length * 10
     ) / 10;
-    lines.push("**Cycle Sizing (effort points \u2014 primary signal)**");
-    lines.push(`- Last ${recentVelocities.length} cycles: ${recentVelocities.map((v) => `S${v.cycle}=${v.effortPoints}pts`).join(", ")}`);
-    lines.push(`- Average: ${avgEffort} effort points/cycle (XS=1, S=2, M=3, L=5, XL=8)`);
-    lines.push(`- Use average as a reference, not a target \u2014 size cycles based on what the selected tasks actually require.`);
+    const withDelivered = recentVelocities.filter((v) => v.deliveredPoints !== void 0);
+    const avgDelivered = withDelivered.length > 0 ? Math.round(withDelivered.reduce((sum, v) => sum + (v.deliveredPoints ?? 0), 0) / withDelivered.length * 10) / 10 : void 0;
+    lines.push("**Cycle Sizing \u2014 planned vs delivered effort points**");
+    lines.push(
+      `- Last ${recentVelocities.length} cycles: ` + recentVelocities.map((v) => v.deliveredPoints !== void 0 ? `S${v.cycle}=${v.effortPoints} planned/${v.deliveredPoints} delivered` : `S${v.cycle}=${v.effortPoints} planned`).join(", ")
+    );
+    if (avgDelivered !== void 0) {
+      const delta = Math.round((avgDelivered - avgPlanned) * 10) / 10;
+      const sign = delta > 0 ? "+" : "";
+      const read = delta === 0 ? "delivered matches planned" : delta > 0 ? "cycles cost MORE than scoped (under-scoping)" : "cycles cost LESS than scoped (over-scoping)";
+      lines.push(`- Average: ${avgPlanned} planned / ${avgDelivered} delivered (XS=1, S=2, M=3, L=5, XL=8)`);
+      lines.push(`- Scope accuracy: ${sign}${delta} pts/cycle \u2014 ${read}.`);
+    } else {
+      lines.push(`- Average: ${avgPlanned} planned effort points/cycle (XS=1, S=2, M=3, L=5, XL=8)`);
+    }
+    lines.push(`- Size cycles on what the selected tasks actually require \u2014 planned is a reference, not a target.`);
   }
   return lines.join("\n");
 }
@@ -12474,6 +12551,9 @@ async function preparePlan(adapter2, config2, filters, focus, force, handoffsOnl
   const prepareScope = await resolvePlanScope(adapter2, config2);
   const { mode, cycleNumber, strategyReviewWarning } = await validateAndPrepare(adapter2, force, prepareScope.callerUserId);
   const validateMs = t();
+  const incomingCycle = cycleNumber + 1;
+  tracker?.setStreamScope({ cycle: incomingCycle });
+  await recordPlanPrepareStep(tracker, incomingCycle, "health-check");
   if (handoffsOnly) {
     tracker?.mark("handoffs_only_assemble");
     t = startTimer();
@@ -12518,6 +12598,8 @@ async function preparePlan(adapter2, config2, filters, focus, force, handoffsOnl
   t = startTimer();
   const { context, contextHashes } = await assembleContext(adapter2, mode, config2, filters, focus);
   const assembleMs = t();
+  await recordPlanPrepareStep(tracker, incomingCycle, "inbox-triage");
+  await recordPlanPrepareStep(tracker, incomingCycle, "board-integrity");
   const TEMPLATE_MARKER2 = "*Describe your project's core value proposition here.*";
   if (mode !== "bootstrap" && context.productBrief.includes(TEMPLATE_MARKER2)) {
     throw new Error("TEMPLATE_BRIEF");
@@ -12535,6 +12617,7 @@ async function preparePlan(adapter2, config2, filters, focus, force, handoffsOnl
   }
   const scanMs = t();
   console.error(`[plan-perf] codebaseScan: ${scanMs}ms`);
+  await recordPlanPrepareStep(tracker, incomingCycle, "maturity-gate");
   tracker?.mark("build_user_message");
   t = startTimer();
   const foundation = await buildProjectFoundation(adapter2);
@@ -12570,7 +12653,13 @@ async function preparePlan(adapter2, config2, filters, focus, force, handoffsOnl
     contextHashes
   };
 }
-var PLAN_STAGE_STEPS = ["health-check", "inbox-triage", "board-integrity", "maturity-gate", "recommendation", "dependency-chain"];
+var PLAN_PREPARE_STEPS = ["health-check", "inbox-triage", "board-integrity", "maturity-gate"];
+var PLAN_APPLY_STEPS = ["recommendation", "dependency-chain"];
+var PLAN_STAGE_STEPS = [...PLAN_PREPARE_STEPS, ...PLAN_APPLY_STEPS];
+async function recordPlanPrepareStep(tracker, incomingCycleNumber, step) {
+  if (!tracker) return;
+  await tracker.recordStep(step, { cycle: incomingCycleNumber, stage: "plan" });
+}
 async function streamPlanStageSteps(tracker, newCycleNumber) {
   tracker.setStreamScope({ cycle: newCycleNumber });
   for (const step of PLAN_STAGE_STEPS) {
@@ -13091,6 +13180,49 @@ var PerCallerCache = class {
   }
 };
 
+// src/lib/plan-prepare-store.ts
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, existsSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+var SPILL_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_CALLER_KEY3 = "__default__";
+function spillPath(projectId, callerKey) {
+  const id = createHash2("sha256").update(`${projectId ?? "no-project"}|${callerKey ?? DEFAULT_CALLER_KEY3}`).digest("hex").slice(0, 16);
+  return join3(tmpdir(), `papi-plan-prepare-${id}.json`);
+}
+function savePrepareSpill(projectId, callerKey, state) {
+  try {
+    writeFileSync2(
+      spillPath(projectId, callerKey),
+      JSON.stringify({ savedAt: Date.now(), state }),
+      { mode: 384 }
+    );
+  } catch {
+  }
+}
+function loadPrepareSpill(projectId, callerKey) {
+  const path7 = spillPath(projectId, callerKey);
+  try {
+    if (!existsSync(path7)) return void 0;
+    if (Date.now() - statSync(path7).mtimeMs > SPILL_TTL_MS) {
+      clearPrepareSpill(projectId, callerKey);
+      return void 0;
+    }
+    const parsed = JSON.parse(readFileSync2(path7, "utf-8"));
+    return parsed.state;
+  } catch {
+    return void 0;
+  }
+}
+function clearPrepareSpill(projectId, callerKey) {
+  try {
+    const path7 = spillPath(projectId, callerKey);
+    if (existsSync(path7)) unlinkSync(path7);
+  } catch {
+  }
+}
+
 // src/tools/plan.ts
 var planPrepareCache = new PerCallerCache();
 var planTool = {
@@ -13258,7 +13390,7 @@ async function handlePlan(adapter2, config2, args) {
       const planMode = args.plan_mode || "full";
       const rawCycleNumber = args.cycle_number != null ? Number(args.cycle_number) : NaN;
       const strategyReviewWarning = args.strategy_review_warning || "";
-      const prep = planPrepareCache.peek(callerKey);
+      const prep = planPrepareCache.peek(callerKey) ?? loadPrepareSpill(adapter2.getProjectId?.(), callerKey);
       const contextHashes = prep?.contextHashes;
       const inputContext = prep?.userMessage;
       const contextBytes = prep?.contextBytes;
@@ -13286,6 +13418,7 @@ async function handlePlan(adapter2, config2, args) {
       }
       const cycleNumber = newCycleNumber - 1;
       planPrepareCache.clear(callerKey);
+      clearPrepareSpill(adapter2.getProjectId?.(), callerKey);
       let utilisation;
       if (inputContext) {
         try {
@@ -13316,13 +13449,15 @@ async function handlePlan(adapter2, config2, args) {
       }
       const skipHandoffs = args.skip_handoffs === true;
       const result = await preparePlan(adapter2, config2, filters, focus, force, handoffsOnly, skipHandoffs, tracker);
-      planPrepareCache.set(callerKey, {
+      const prepareState = {
         contextHashes: result.contextHashes,
         userMessage: result.userMessage,
         contextBytes: result.contextBytes,
         cycleNumber: result.cycleNumber,
         skipHandoffs: skipHandoffs || void 0
-      });
+      };
+      planPrepareCache.set(callerKey, prepareState);
+      savePrepareSpill(adapter2.getProjectId?.(), callerKey, prepareState);
       const autoDispatchEnabled = process.env.PAPI_AUTO_DISPATCH !== "false";
       const autoDispatchThreshold = 50 * 1024;
       let dispatch;
@@ -13406,10 +13541,10 @@ ${result.userMessage}
 }
 
 // src/services/strategy.ts
-import { randomUUID as randomUUID10, createHash as createHash2 } from "crypto";
+import { randomUUID as randomUUID10, createHash as createHash3 } from "crypto";
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync, readdirSync, statSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/lib/hosted-mode.ts
@@ -14355,7 +14490,7 @@ async function assembleContext2(adapter2, cycleNumber, cyclesSinceLastReview, pr
   try {
     const fullCanvasText = formatDiscoveryCanvas(canvas);
     if (fullCanvasText) {
-      const canvasHash = createHash2("md5").update(fullCanvasText).digest("hex");
+      const canvasHash = createHash3("md5").update(fullCanvasText).digest("hex");
       const lastReview = previousStrategyReviews?.[0];
       const prevHash = lastReview?.structuredData?.canvasHash;
       if (prevHash && prevHash === canvasHash) {
@@ -14425,12 +14560,12 @@ ${lines.join("\n")}`;
   }
   let recentPlansText;
   try {
-    const plansDir = join3(homedir2(), ".claude", "plans");
-    if (existsSync(plansDir)) {
+    const plansDir = join4(homedir2(), ".claude", "plans");
+    if (existsSync2(plansDir)) {
       const lastReviewDate = previousStrategyReviews?.[0]?.createdAt ? new Date(previousStrategyReviews[0].createdAt) : /* @__PURE__ */ new Date(0);
       const planFiles = readdirSync(plansDir).filter((f) => f.endsWith(".md")).map((f) => {
-        const fullPath = join3(plansDir, f);
-        const stat4 = statSync(fullPath);
+        const fullPath = join4(plansDir, f);
+        const stat4 = statSync2(fullPath);
         return { name: f, modified: stat4.mtime, size: stat4.size };
       }).filter((f) => f.modified > lastReviewDate).sort((a, b2) => b2.modified.getTime() - a.modified.getTime()).slice(0, 15);
       if (planFiles.length > 0) {
@@ -14446,15 +14581,15 @@ ${lines.join("\n")}`;
   }
   let unregisteredDocsText;
   try {
-    const docsDir = join3(projectRoot, "docs");
-    if (hasLocalWorkspace() && existsSync(docsDir)) {
+    const docsDir = join4(projectRoot, "docs");
+    if (hasLocalWorkspace() && existsSync2(docsDir)) {
       const registeredPaths = new Set(
         (registeredDocs ?? []).map((d) => d.path).filter(Boolean)
       );
       const allDocFiles = [];
       const scanDir = (dir, prefix) => {
         for (const entry of readdirSync(dir, { withFileTypes: true })) {
-          if (entry.isDirectory()) scanDir(join3(dir, entry.name), `${prefix}${entry.name}/`);
+          if (entry.isDirectory()) scanDir(join4(dir, entry.name), `${prefix}${entry.name}/`);
           else if (entry.name.endsWith(".md")) allDocFiles.push(`${prefix}${entry.name}`);
         }
       };
@@ -14730,7 +14865,7 @@ ${cleanContent}`;
         const currentCanvas = await adapter2.readDiscoveryCanvas();
         const canvasText = formatDiscoveryCanvas(currentCanvas);
         if (canvasText) {
-          return { ...sd, canvasHash: createHash2("md5").update(canvasText).digest("hex") };
+          return { ...sd, canvasHash: createHash3("md5").update(canvasText).digest("hex") };
         }
       } catch {
       }
@@ -16592,15 +16727,15 @@ ${existing}` : entry;
 
 // src/services/setup.ts
 import { mkdir, writeFile as writeFile2, readFile as readFile4, readdir, access as access2, stat as stat2, chmod } from "fs/promises";
-import { join as join8, basename, extname, dirname as dirname3 } from "path";
+import { join as join9, basename, extname, dirname as dirname3 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
 // src/lib/detect-codebase.ts
-import { existsSync as existsSync2 } from "fs";
-import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { join as join5 } from "path";
 function detectCodebaseType(projectRoot) {
-  if (existsSync2(join4(projectRoot, ".git"))) {
+  if (existsSync3(join5(projectRoot, ".git"))) {
     return "existing_codebase";
   }
   const manifests = [
@@ -16614,7 +16749,7 @@ function detectCodebaseType(projectRoot) {
     "CMakeLists.txt"
   ];
   for (const manifest of manifests) {
-    if (existsSync2(join4(projectRoot, manifest))) {
+    if (existsSync3(join5(projectRoot, manifest))) {
       return "existing_codebase";
     }
   }
@@ -16622,7 +16757,7 @@ function detectCodebaseType(projectRoot) {
     const entries = readdirSync2(projectRoot).filter((f) => !f.startsWith("."));
     const fileCount = entries.filter((f) => {
       try {
-        return statSync2(join4(projectRoot, f)).isFile();
+        return statSync3(join5(projectRoot, f)).isFile();
       } catch {
         return false;
       }
@@ -16634,18 +16769,18 @@ function detectCodebaseType(projectRoot) {
 }
 
 // src/lib/agents-bundle.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
-import { dirname, join as join5, resolve } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { dirname, join as join6, resolve } from "path";
 import { fileURLToPath } from "url";
-var PROJECT_BUNDLE_REL = join5(".agents", "skills", "papi-cycle");
+var PROJECT_BUNDLE_REL = join6(".agents", "skills", "papi-cycle");
 function bundleDestRel(rel) {
-  return rel === "AGENTS.md" ? "AGENTS.md" : join5(PROJECT_BUNDLE_REL, rel);
+  return rel === "AGENTS.md" ? "AGENTS.md" : join6(PROJECT_BUNDLE_REL, rel);
 }
 function resolveBundleDir() {
   let dir = dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 5; i++) {
-    const candidate = join5(dir, "skills", "papi-cycle");
-    if (existsSync3(join5(candidate, "AGENTS.md"))) return candidate;
+    const candidate = join6(dir, "skills", "papi-cycle");
+    if (existsSync4(join6(candidate, "AGENTS.md"))) return candidate;
     const parent = resolve(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -16653,14 +16788,14 @@ function resolveBundleDir() {
   return void 0;
 }
 function readBundleFiles(bundleDir = resolveBundleDir()) {
-  if (!bundleDir || !existsSync3(bundleDir)) return [];
+  if (!bundleDir || !existsSync4(bundleDir)) return [];
   const files = [];
   const walk = (abs, rel) => {
     for (const entry of readdirSync3(abs, { withFileTypes: true })) {
-      const childAbs = join5(abs, entry.name);
-      const childRel = rel ? join5(rel, entry.name) : entry.name;
+      const childAbs = join6(abs, entry.name);
+      const childRel = rel ? join6(rel, entry.name) : entry.name;
       if (entry.isDirectory()) walk(childAbs, childRel);
-      else if (entry.isFile()) files.push({ rel: childRel, content: readFileSync2(childAbs, "utf8") });
+      else if (entry.isFile()) files.push({ rel: childRel, content: readFileSync3(childAbs, "utf8") });
     }
   };
   walk(bundleDir, "");
@@ -16669,8 +16804,8 @@ function readBundleFiles(bundleDir = resolveBundleDir()) {
 function planBundleInstall(projectRoot, projectName, opts = {}) {
   const out = {};
   for (const f of readBundleFiles()) {
-    const dest = join5(projectRoot, bundleDestRel(f.rel));
-    if (opts.skipExisting && existsSync3(dest) && statSync3(dest).isFile()) continue;
+    const dest = join6(projectRoot, bundleDestRel(f.rel));
+    if (opts.skipExisting && existsSync4(dest) && statSync4(dest).isFile()) continue;
     const content = f.rel === "AGENTS.md" ? f.content.replace(/\{\{project_name\}\}/g, projectName) : f.content;
     out[dest] = content;
   }
@@ -16678,20 +16813,20 @@ function planBundleInstall(projectRoot, projectName, opts = {}) {
 }
 
 // src/lib/design-bundle.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync4 } from "fs";
-import { dirname as dirname2, join as join6, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync5 } from "fs";
+import { dirname as dirname2, join as join7, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var DESIGN_ASSETS = [
-  { srcRel: join6("agents", "frontend-design-engineer.md"), destRel: join6(".claude", "agents", "frontend-design-engineer.md"), executable: false },
-  { srcRel: join6("skills", "design-critique", "SKILL.md"), destRel: join6(".claude", "skills", "design-critique", "SKILL.md"), executable: false },
-  { srcRel: join6("hooks", "frontend-design-guard.sh"), destRel: join6(".claude", "hooks", "frontend-design-guard.sh"), executable: true }
+  { srcRel: join7("agents", "frontend-design-engineer.md"), destRel: join7(".claude", "agents", "frontend-design-engineer.md"), executable: false },
+  { srcRel: join7("skills", "design-critique", "SKILL.md"), destRel: join7(".claude", "skills", "design-critique", "SKILL.md"), executable: false },
+  { srcRel: join7("hooks", "frontend-design-guard.sh"), destRel: join7(".claude", "hooks", "frontend-design-guard.sh"), executable: true }
 ];
 var DESIGN_HOOK_COMMAND = ".claude/hooks/frontend-design-guard.sh";
 function resolveDesignAssetsDir() {
   let dir = dirname2(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 5; i++) {
-    const candidate = join6(dir, "design-assets");
-    if (existsSync4(join6(candidate, "agents", "frontend-design-engineer.md"))) return candidate;
+    const candidate = join7(dir, "design-assets");
+    if (existsSync5(join7(candidate, "agents", "frontend-design-engineer.md"))) return candidate;
     const parent = resolve2(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -16703,23 +16838,23 @@ function planDesignInstall(projectRoot, opts = {}) {
   if (!assetsDir) return [];
   const out = [];
   for (const asset of DESIGN_ASSETS) {
-    const srcAbs = join6(assetsDir, asset.srcRel);
-    if (!existsSync4(srcAbs)) continue;
-    const dest = projectRoot ? join6(projectRoot, asset.destRel) : asset.destRel;
-    if (opts.skipExisting && projectRoot && existsSync4(dest) && statSync4(dest).isFile()) continue;
-    out.push({ dest, content: readFileSync3(srcAbs, "utf8"), executable: asset.executable });
+    const srcAbs = join7(assetsDir, asset.srcRel);
+    if (!existsSync5(srcAbs)) continue;
+    const dest = projectRoot ? join7(projectRoot, asset.destRel) : asset.destRel;
+    if (opts.skipExisting && projectRoot && existsSync5(dest) && statSync5(dest).isFile()) continue;
+    out.push({ dest, content: readFileSync4(srcAbs, "utf8"), executable: asset.executable });
   }
   return out;
 }
 
 // src/lib/skill-detection.ts
-import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync5 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync6 } from "fs";
+import { join as join8 } from "path";
 function readPackageJson(projectRoot) {
-  const path7 = join7(projectRoot, "package.json");
-  if (!existsSync5(path7)) return null;
+  const path7 = join8(projectRoot, "package.json");
+  if (!existsSync6(path7)) return null;
   try {
-    const raw = readFileSync4(path7, "utf-8");
+    const raw = readFileSync5(path7, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -16740,8 +16875,8 @@ function detectsFrontendStack(projectRoot) {
   return hasDependencyMatching(allDeps(readPackageJson(projectRoot)), FRONTEND_DEP_PATTERN);
 }
 function hasGitHubWorkflows(projectRoot) {
-  const dir = join7(projectRoot, ".github", "workflows");
-  if (!existsSync5(dir)) return false;
+  const dir = join8(projectRoot, ".github", "workflows");
+  if (!existsSync6(dir)) return false;
   try {
     const entries = readdirSync4(dir);
     return entries.some((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
@@ -16750,21 +16885,21 @@ function hasGitHubWorkflows(projectRoot) {
   }
 }
 function envExampleMentionsStaging(projectRoot) {
-  const path7 = join7(projectRoot, ".env.example");
-  if (!existsSync5(path7)) return false;
+  const path7 = join8(projectRoot, ".env.example");
+  if (!existsSync6(path7)) return false;
   try {
-    const raw = readFileSync4(path7, "utf-8");
+    const raw = readFileSync5(path7, "utf-8");
     return /\b(STAGING_URL|STAGING_API|STAGING_HOST|NEXT_PUBLIC_STAGING)/i.test(raw);
   } catch {
     return false;
   }
 }
 function hasVercelConfig(projectRoot) {
-  if (existsSync5(join7(projectRoot, "vercel.json"))) return true;
-  const vercelDir = join7(projectRoot, ".vercel");
-  if (!existsSync5(vercelDir)) return false;
+  if (existsSync6(join8(projectRoot, "vercel.json"))) return true;
+  const vercelDir = join8(projectRoot, ".vercel");
+  if (!existsSync6(vercelDir)) return false;
   try {
-    return statSync5(vercelDir).isDirectory();
+    return statSync6(vercelDir).isDirectory();
   } catch {
     return false;
   }
@@ -17250,7 +17385,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
       await mkdir(config2.papiDir, { recursive: true });
       for (const [filename, template] of Object.entries(FILE_TEMPLATES)) {
         const content = substitute(template, vars);
-        await writeFile2(join8(config2.papiDir, filename), content, "utf-8");
+        await writeFile2(join9(config2.papiDir, filename), content, "utf-8");
       }
     }
   } else {
@@ -17268,13 +17403,13 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
   const useCollector = config2.adapterType === "proxy";
   const docsRel = "docs";
   const commandsRel = ".claude/commands";
-  const commandsDir = useCollector ? commandsRel : join8(config2.projectRoot, ".claude", "commands");
-  const docsDir = useCollector ? docsRel : join8(config2.projectRoot, "docs");
+  const commandsDir = useCollector ? commandsRel : join9(config2.projectRoot, ".claude", "commands");
+  const docsDir = useCollector ? docsRel : join9(config2.projectRoot, "docs");
   if (!useCollector) {
     await mkdir(commandsDir, { recursive: true });
     await mkdir(docsDir, { recursive: true });
   }
-  const claudeMdPath = useCollector ? "CLAUDE.md" : join8(config2.projectRoot, "CLAUDE.md");
+  const claudeMdPath = useCollector ? "CLAUDE.md" : join9(config2.projectRoot, "CLAUDE.md");
   let claudeMdExists = false;
   if (!useCollector) {
     try {
@@ -17283,7 +17418,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
     } catch {
     }
   }
-  const docsIndexPath = useCollector ? `${docsRel}/INDEX.md` : join8(docsDir, "INDEX.md");
+  const docsIndexPath = useCollector ? `${docsRel}/INDEX.md` : join9(docsDir, "INDEX.md");
   let docsIndexExists = false;
   if (!useCollector) {
     try {
@@ -17293,9 +17428,9 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
     }
   }
   const scaffoldFiles = {
-    [useCollector ? `${commandsRel}/papi-audit.md` : join8(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
-    [useCollector ? `${commandsRel}/test.md` : join8(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
-    [useCollector ? `${docsRel}/README.md` : join8(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
+    [useCollector ? `${commandsRel}/papi-audit.md` : join9(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
+    [useCollector ? `${commandsRel}/test.md` : join9(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
+    [useCollector ? `${docsRel}/README.md` : join9(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
   };
   if (!docsIndexExists) {
     scaffoldFiles[docsIndexPath] = substitute(DOCS_INDEX_TEMPLATE, vars);
@@ -17322,7 +17457,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
   if (useCollector) {
     scaffoldFiles[".cursor/rules/papi.mdc"] = substitute(CURSOR_RULES_TEMPLATE, vars);
   } else {
-    const cursorDir = join8(config2.projectRoot, ".cursor");
+    const cursorDir = join9(config2.projectRoot, ".cursor");
     let cursorDetected = false;
     try {
       await access2(cursorDir);
@@ -17330,8 +17465,8 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
     } catch {
     }
     if (cursorDetected) {
-      const cursorRulesDir = join8(cursorDir, "rules");
-      const cursorRulesPath = join8(cursorRulesDir, "papi.mdc");
+      const cursorRulesDir = join9(cursorDir, "rules");
+      const cursorRulesPath = join9(cursorRulesDir, "papi.mdc");
       await mkdir(cursorRulesDir, { recursive: true });
       try {
         await access2(cursorRulesPath);
@@ -17386,7 +17521,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
 }
 var PAPI_PERMISSION = "mcp__papi__*";
 async function ensurePapiPermission(projectRoot) {
-  const settingsPath = join8(projectRoot, ".claude", "settings.json");
+  const settingsPath = join9(projectRoot, ".claude", "settings.json");
   try {
     let settings = {};
     try {
@@ -17405,13 +17540,13 @@ async function ensurePapiPermission(projectRoot) {
     if (!allow.includes(PAPI_PERMISSION)) {
       allow.push(PAPI_PERMISSION);
     }
-    await mkdir(join8(projectRoot, ".claude"), { recursive: true });
+    await mkdir(join9(projectRoot, ".claude"), { recursive: true });
     await writeFile2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 async function ensureDesignHookRegistered(projectRoot) {
-  const settingsPath = join8(projectRoot, ".claude", "settings.json");
+  const settingsPath = join9(projectRoot, ".claude", "settings.json");
   try {
     let settings = {};
     try {
@@ -17441,7 +17576,7 @@ async function ensureDesignHookRegistered(projectRoot) {
         chain.push({ type: "command", command: DESIGN_HOOK_COMMAND });
       }
     }
-    await mkdir(join8(projectRoot, ".claude"), { recursive: true });
+    await mkdir(join9(projectRoot, ".claude"), { recursive: true });
     await writeFile2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   } catch {
   }
@@ -17545,7 +17680,7 @@ ${conventionsText.trim()}
       );
     } else {
       try {
-        const claudeMdPath = join8(config2.projectRoot, "CLAUDE.md");
+        const claudeMdPath = join9(config2.projectRoot, "CLAUDE.md");
         const existing = await readFile4(claudeMdPath, "utf-8");
         if (existing.includes(CONVENTIONS_SENTINEL) || existing.includes(CONVENTIONS_HEADING)) {
           warnings.push(
@@ -17632,13 +17767,13 @@ async function scanCodebase(projectRoot) {
   }
   let packageJson;
   try {
-    const content = await readFile4(join8(projectRoot, "package.json"), "utf-8");
+    const content = await readFile4(join9(projectRoot, "package.json"), "utf-8");
     packageJson = JSON.parse(content);
   } catch {
   }
   let readme;
   for (const name of ["README.md", "readme.md", "README.txt", "README"]) {
-    const content = await safeReadFile(join8(projectRoot, name), 5e3);
+    const content = await safeReadFile(join9(projectRoot, name), 5e3);
     if (content) {
       readme = content;
       break;
@@ -17648,7 +17783,7 @@ async function scanCodebase(projectRoot) {
   let totalFiles = topLevelFiles.length;
   for (const dir of topLevelDirs) {
     try {
-      const entries = await readdir(join8(projectRoot, dir), { withFileTypes: true });
+      const entries = await readdir(join9(projectRoot, dir), { withFileTypes: true });
       const files = entries.filter((e) => e.isFile());
       const extensions = [...new Set(files.map((f) => extname(f.name).toLowerCase()).filter(Boolean))];
       totalFiles += files.length;
@@ -17995,7 +18130,7 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
       collector.add({ path: "CLAUDE.md", content: dogfoodSection, mode: "append" });
     } else {
       try {
-        const claudeMdPath = join8(config2.projectRoot, "CLAUDE.md");
+        const claudeMdPath = join9(config2.projectRoot, "CLAUDE.md");
         const existing = await readFile4(claudeMdPath, "utf-8");
         if (!existing.includes("Dogfood Logging")) {
           await writeFile2(claudeMdPath, existing + dogfoodSection, "utf-8");
@@ -18040,7 +18175,7 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
     cursorScaffolded = true;
   } else {
     try {
-      await access2(join8(config2.projectRoot, ".cursor", "rules", "papi.mdc"));
+      await access2(join9(config2.projectRoot, ".cursor", "rules", "papi.mdc"));
       cursorScaffolded = true;
     } catch {
     }
@@ -18060,11 +18195,11 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
 }
 async function ensureMcpJsonGitignored(projectRoot) {
   try {
-    await access2(join8(projectRoot, ".git"));
+    await access2(join9(projectRoot, ".git"));
   } catch {
     return void 0;
   }
-  const gitignorePath = join8(projectRoot, ".gitignore");
+  const gitignorePath = join9(projectRoot, ".gitignore");
   let existing = "";
   try {
     existing = await readFile4(gitignorePath, "utf-8");
@@ -18579,8 +18714,8 @@ PAPI never runs this command itself (AD-58) \u2014 you run it in your own enviro
 
 // 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";
-import { join as join10 } from "path";
+import { readdirSync as readdirSync5, existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join11 } from "path";
 
 // src/lib/harness-capability.ts
 var HARNESS_REGISTRY = {
@@ -18656,7 +18791,7 @@ init_git();
 // src/services/release.ts
 init_telemetry();
 import { writeFile as writeFile3, readFile as readFile5 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { execFileSync as execFileSync4 } from "child_process";
 init_git();
 var INITIAL_RELEASE_NOTES = `# Changelog
@@ -19087,20 +19222,40 @@ async function createRelease(config2, branch, version, adapter2, cycleNum, optio
   if (adapter2 && resolvedCycleNum > 0) {
     try {
       const stampedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const resolvedBase = resolveBaseBranch(config2.projectRoot, branch);
       const doneCycleTasks = (await adapter2.queryBoard()).filter(
         (t) => t.cycle === resolvedCycleNum && t.status === "Done"
       );
+      const canVerify = isGitAvailable() && isGitRepo(config2.projectRoot);
+      const landed = canVerify ? findTaskCommitsOnBase(
+        config2.projectRoot,
+        resolvedBase,
+        doneCycleTasks.map((t) => t.displayId)
+      ) : /* @__PURE__ */ new Map();
+      const unverified = [];
       for (const t of doneCycleTasks) {
+        const hit = landed.get(t.displayId);
+        if (canVerify && !hit) {
+          unverified.push(
+            `${t.displayId}${t.branchName ? ` (branch \`${t.branchName}\`)` : " (no branch recorded)"}`
+          );
+          continue;
+        }
         try {
           await adapter2.updateTask(t.id, { mergedAt: stampedAt });
         } catch {
         }
       }
+      if (unverified.length > 0) {
+        warnings.push(
+          `\u26A0\uFE0F DATA-INTEGRITY \u2014 ${unverified.length} task(s) are marked **Done** in cycle ${resolvedCycleNum} but their work is NOT on ${resolvedBase}: ${unverified.join("; ")}. They were NOT stamped as merged. Held ad-hoc work is the usual cause (\`ad_hoc\` + \`board_edit\` leaves the branch unmerged by design). Merge the branch(es), or move the task(s) to the next cycle \u2014 do not leave Done unbacked by git.`
+        );
+      }
     } catch {
     }
   }
   const latestTag = getLatestTag(config2.projectRoot);
-  const changelogPath = join9(config2.projectRoot, "CHANGELOG.md");
+  const changelogPath = join10(config2.projectRoot, "CHANGELOG.md");
   if (!latestTag) {
     const initialContent = INITIAL_RELEASE_NOTES.replace("v0.1.0-alpha", version);
     if (config2.adapterType === "proxy") {
@@ -19155,6 +19310,44 @@ async function createRelease(config2, branch, version, adapter2, cycleNum, optio
   };
 }
 
+// src/services/release-bookkeeping.ts
+async function beginRelease(tracker, cycleNum) {
+  tracker.setStreamScope({ cycle: cycleNum ?? null });
+  await tracker.recordStep("release_starting");
+}
+async function recordReadinessVerified(tracker) {
+  await tracker.recordStep("readiness_verified");
+}
+async function recordQualityGate(tracker, decision, caps) {
+  await tracker.recordStep("quality_gate", {
+    status: decision.stepStatus,
+    capabilityKey: "releaseGate",
+    capabilityEnabled: isCapabilityEnabled(caps, "releaseGate"),
+    metadata: decision.metadata
+  });
+}
+async function completeRelease(tracker, opts) {
+  tracker.setStreamScope({ cycle: opts.cycleClosed ?? null });
+  await tracker.recordStep("cycle_complete", { metadata: { version: opts.version } });
+  for (const m of opts.branchMerges ?? []) {
+    await tracker.recordStep("branch_merged", {
+      metadata: { branch: m.branch, prUrl: m.prUrl ?? null }
+    });
+  }
+  await tracker.recordStep("changelog", {
+    capabilityKey: "changelog",
+    capabilityEnabled: isCapabilityEnabled(opts.caps, "changelog"),
+    status: opts.changelogEmitted ? "complete" : "active"
+  });
+  if (opts.deployHookEmitted) {
+    await tracker.recordStep("deploy_hook", {
+      capabilityKey: "deployHook",
+      capabilityEnabled: isCapabilityEnabled(opts.caps, "deployHook")
+    });
+  }
+  await tracker.recordStep("released", { metadata: { version: opts.version } });
+}
+
 // src/tools/release.ts
 init_git();
 
@@ -19444,9 +19637,16 @@ async function handleRelease(adapter2, config2, 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);
+    let cycleToClose = null;
+    try {
+      const resolved = await resolveCycleToClose(adapter2, version, gate.callerUserId);
+      cycleToClose = resolved > 0 ? resolved : null;
+    } catch {
+      cycleToClose = null;
+    }
+    await beginRelease(tracker, cycleToClose);
     const productionBaseBranch = resolveBaseBranch(config2.projectRoot, config2.baseBranch);
     if (branch === productionBaseBranch) {
       if (gate.enforced && !gate.callerIsOwner) {
@@ -19511,6 +19711,13 @@ Next: run \`plan\` to start your next cycle.`
         }
       }
     }
+    let caps = {};
+    try {
+      const info = adapter2.getProjectInfo ? await adapter2.getProjectInfo() : null;
+      caps = info?.capabilities ?? {};
+    } catch {
+      caps = {};
+    }
     if (isHostedTransport()) {
       tracker.mark("hosted-close-cycle");
       let closed;
@@ -19523,6 +19730,16 @@ Next: run \`plan\` to start your next cycle.`
         const message = err instanceof Error ? err.message : String(err);
         return errorResponse(message);
       }
+      await recordReadinessVerified(tracker);
+      const hostedGate = evaluateReleaseGate(caps, config2.gateCommand, gateResult);
+      await recordQualityGate(tracker, hostedGate, caps);
+      await completeRelease(tracker, {
+        cycleClosed: closed.resolvedCycleNum > 0 ? closed.resolvedCycleNum : null,
+        version,
+        caps,
+        branchMerges: [],
+        changelogEmitted: false
+      });
       const tagAnnotation = `Release ${version}`;
       const cyclePart = closed.resolvedCycleNum > 0 ? `Cycle ${closed.resolvedCycleNum}` : "The cycle";
       const warningsBlock = closed.warnings.length > 0 ? `
@@ -19583,22 +19800,10 @@ 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 = {};
-    }
+    await recordReadinessVerified(tracker);
     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
-    });
+    await recordQualityGate(tracker, gateDecision, caps);
     if (gateDecision.action === "directive") {
       return textResponse(gateDecision.message);
     }
@@ -19611,13 +19816,6 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
       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)" : ""}`,
       "",
@@ -19672,21 +19870,16 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
       buildCycleUpdateCurationDirective(result.version, result.cycleClosed ?? 0)
     );
     if (cycleUpdateDirective) lines.push(cycleUpdateDirective);
-    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 }
-      });
-    }
+    if (deployDirective) lines.push(deployDirective);
+    await completeRelease(tracker, {
+      cycleClosed: result.cycleClosed ?? null,
+      version: result.version,
+      caps,
+      branchMerges: result.groupedBranchMerges ?? [],
+      changelogEmitted: Boolean(cycleUpdateDirective),
+      deployHookEmitted: Boolean(deployDirective)
+    });
     const publishEnabled = isCapabilityEnabled(caps, "publishDirective");
     if (publishEnabled) {
       try {
@@ -19714,7 +19907,6 @@ Run \`project_switch <slug>\` to switch the active PAPI project, or verify your
     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) {
@@ -19874,32 +20066,94 @@ function capitalizeCompleted(value) {
   };
   return map[value] ?? "No";
 }
+function stripAnnotations(text) {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === ")") {
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      let depth = 0;
+      let j = i;
+      for (; j < text.length; j++) {
+        if (text[j] === "(") depth++;
+        else if (text[j] === ")") {
+          depth--;
+          if (depth === 0) {
+            j++;
+            break;
+          }
+        }
+      }
+      if (depth !== 0) {
+        break;
+      }
+      const inner = text.slice(i + 1, j - 1);
+      const prev = i > 0 ? text[i - 1] : "/";
+      const next = text[j] ?? "";
+      const isRouteGroup = (prev === "/" || i === 0) && !/\s/.test(inner) && next === "/";
+      if (isRouteGroup) {
+        out += text.slice(i, j);
+        i = j;
+        continue;
+      }
+      i = j;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
 function sanitisePredictedFiles(raw) {
   const out = [];
   for (const entry of raw) {
     if (typeof entry !== "string") continue;
-    for (const segment of entry.split(";")) {
-      const altMatches = segment.match(/\(\s*or\s+`([^`]+)`\s*\)/gi) ?? [];
-      for (const alt of altMatches) {
-        const inner = alt.match(/`([^`]+)`/);
-        if (inner) out.push(inner[1].trim());
-      }
-      const cleaned = segment.replace(/`/g, "").replace(/\s*\(.*$/, "").trim();
-      if (cleaned) out.push(cleaned);
+    let working = entry;
+    const altMatches = working.match(/\(\s*or\s+`([^`]+)`\s*\)/gi) ?? [];
+    for (const alt of altMatches) {
+      const inner = alt.match(/`([^`]+)`/);
+      if (inner) out.push(inner[1].trim());
+      working = working.replace(alt, " ");
+    }
+    const cleanedEntry = stripAnnotations(working.replace(/`/g, ""));
+    for (const segment of cleanedEntry.split(/[;,]/)) {
+      const cleaned = segment.trim();
+      if (!cleaned) continue;
+      if (/\s/.test(cleaned)) continue;
+      if (!/[A-Za-z0-9]/.test(cleaned)) continue;
+      out.push(cleaned);
     }
   }
   return Array.from(new Set(out));
 }
+function globToRegExp(entry) {
+  const source = entry.split(/(\*\*|\*)/).map((part) => {
+    if (part === "**") return ".*";
+    if (part === "*") return "[^/]*";
+    return part.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  }).join("");
+  return new RegExp(`^${source}$`, "i");
+}
 function pathBasename(p) {
   const parts = p.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
   return parts[parts.length - 1] ?? p;
 }
 function isPathInPredictedScope(changedPath, predicted) {
-  const changedLower = changedPath.replace(/\\/g, "/").toLowerCase();
+  const changed = changedPath.replace(/\\/g, "/");
+  const changedLower = changed.toLowerCase();
   const changedBase = pathBasename(changedPath);
   for (const raw of predicted) {
     const entry = raw.replace(/\\/g, "/").replace(/\/+$/, "").trim();
     if (!entry) continue;
+    if (entry.includes("*")) {
+      if (globToRegExp(entry).test(changed)) return true;
+      if (!entry.includes("/") && globToRegExp(entry).test(changedBase)) return true;
+      continue;
+    }
     if (pathBasename(entry) === changedBase) return true;
     const entryLower = entry.toLowerCase();
     if (changedLower === entryLower || changedLower.startsWith(`${entryLower}/`)) {
@@ -19943,23 +20197,27 @@ function autoCommit(config2, taskId, taskTitle, predictedFiles) {
     };
     const cleanedPredicted = sanitisePredictedFiles(predictedFiles);
     const scoped = modified.filter((p) => isPathInPredictedScope(p, cleanedPredicted));
-    if (scoped.length === 0) {
+    const untracked = getUntrackedFiles(cwd);
+    const scopedSet = new Set(scoped);
+    const untrackedInScope = untracked.filter(
+      (p) => !scopedSet.has(p) && isPathInPredictedScope(p, cleanedPredicted)
+    );
+    if (scoped.length === 0 && untrackedInScope.length === 0) {
       const modSample = modified.slice(0, 5).join(", ");
       const predSample = cleanedPredicted.slice(0, 5).join(", ");
       return `Auto-commit: refused \u2014 none of the ${modified.length} modified file(s) intersect FILES LIKELY TOUCHED. Modified: ${modSample}. Expected: ${predSample}. Stage the intended files manually (\`git add <paths>\`) then re-run, or set PAPI_AUTO_COMMIT=false.`;
     }
-    const untracked = getUntrackedFiles(cwd);
     const scopedDirs = [...new Set(scoped.map(dirname7).filter((d) => d.length > 0))];
     const isUnderScopedDir = (p) => scopedDirs.some((d) => p === d || p.startsWith(`${d}/`) || p.startsWith(`${d}\\`));
-    const scopedSet = new Set(scoped);
+    const inScopeSet = /* @__PURE__ */ new Set([...scoped, ...untrackedInScope]);
     const adjacentUntracked = untracked.filter(
-      (p) => !scopedSet.has(p) && isUnderScopedDir(p)
+      (p) => !inScopeSet.has(p) && isUnderScopedDir(p)
     );
-    const toStage = [...scoped, ...adjacentUntracked];
+    const toStage = [...scoped, ...untrackedInScope, ...adjacentUntracked];
     const toStageSet = new Set(toStage);
     const droppedUntracked = untracked.filter((p) => !toStageSet.has(p));
     const droppedModified = modified.filter((p) => !scopedSet.has(p));
-    let line = safeRun(() => stagePathsAndCommit(cwd, toStage, message)) + ` (scoped to ${scoped.length}/${modified.length} files via FILES LIKELY TOUCHED` + (adjacentUntracked.length > 0 ? ` + ${adjacentUntracked.length} untracked under scoped dir(s)` : "") + `).`;
+    let line = safeRun(() => stagePathsAndCommit(cwd, toStage, message)) + ` (scoped to ${scoped.length}/${modified.length} files via FILES LIKELY TOUCHED` + (untrackedInScope.length > 0 ? ` + ${untrackedInScope.length} new file(s) named in the handoff` : "") + (adjacentUntracked.length > 0 ? ` + ${adjacentUntracked.length} untracked under scoped dir(s)` : "") + `).`;
     if (droppedModified.length > 0) {
       const sample = droppedModified.slice(0, 10).join(", ");
       const more = droppedModified.length > 10 ? ` (+${droppedModified.length - 10} more)` : "";
@@ -20434,17 +20692,17 @@ function writeActiveTaskScope(projectRoot, taskId, filesLikelyTouched, adapterTy
     collector.add({ path: ".papi/active-task-scope.txt", content, mode: "overwrite" });
     return;
   }
-  const papiDir = join10(projectRoot, ".papi");
-  if (!existsSync6(papiDir)) {
+  const papiDir = join11(projectRoot, ".papi");
+  if (!existsSync7(papiDir)) {
     mkdirSync2(papiDir, { recursive: true });
   }
-  const scopePath = join10(papiDir, "active-task-scope.txt");
-  writeFileSync2(scopePath, content, "utf-8");
+  const scopePath = join11(papiDir, "active-task-scope.txt");
+  writeFileSync3(scopePath, content, "utf-8");
 }
 function clearActiveTaskScope(projectRoot) {
-  const scopePath = join10(projectRoot, ".papi", "active-task-scope.txt");
-  if (existsSync6(scopePath)) {
-    unlinkSync(scopePath);
+  const scopePath = join11(projectRoot, ".papi", "active-task-scope.txt");
+  if (existsSync7(scopePath)) {
+    unlinkSync2(scopePath);
   }
 }
 function sanitiseResponseExcerpt(raw) {
@@ -20463,7 +20721,7 @@ function extractDocMeta(absolutePath, relativePath, cycleNumber) {
   else if (relativePath.startsWith("docs/architecture/")) type = "architecture";
   else if (relativePath.startsWith("docs/audits/")) type = "audit";
   try {
-    const content = readFileSync5(absolutePath, "utf-8").slice(0, 2e3);
+    const content = readFileSync6(absolutePath, "utf-8").slice(0, 2e3);
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
       const fm = fmMatch[1];
@@ -20842,14 +21100,14 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}, cli
   let docWarning;
   try {
     if (adapter2.searchDocs && hasLocalWorkspace() && await ownsLocalWorkspace(adapter2, config2.projectRoot)) {
-      const docsDir = join10(config2.projectRoot, "docs");
-      if (existsSync6(docsDir)) {
+      const docsDir = join11(config2.projectRoot, "docs");
+      if (existsSync7(docsDir)) {
         const scanDir = (dir, depth = 0) => {
           if (depth > 8) return [];
           const entries = readdirSync5(dir, { withFileTypes: true });
           const files = [];
           for (const e of entries) {
-            const full = join10(dir, e.name);
+            const full = join11(dir, e.name);
             if (e.isDirectory() && !e.isSymbolicLink()) files.push(...scanDir(full, depth + 1));
             else if (e.name.endsWith(".md")) files.push(full.replace(config2.projectRoot + "/", ""));
           }
@@ -20864,7 +21122,7 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}, cli
           const failed = [];
           for (const docPath of unregistered) {
             try {
-              const meta = extractDocMeta(join10(config2.projectRoot, docPath), docPath, cycleNumber);
+              const meta = extractDocMeta(join11(config2.projectRoot, docPath), docPath, cycleNumber);
               await adapter2.registerDoc({
                 title: meta.title,
                 type: meta.type,
@@ -21013,8 +21271,8 @@ ${instructions}`;
 }
 
 // src/tools/doc-registry.ts
-import { readdirSync as readdirSync6, existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join11, relative } from "path";
+import { readdirSync as readdirSync6, existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join12, relative } from "path";
 import { homedir as homedir3 } from "os";
 import { randomUUID as randomUUID12 } from "crypto";
 var docRegisterTool = {
@@ -21211,7 +21469,7 @@ async function handleDocSearch(adapter2, args, config2) {
   const lines = docs.map((d) => {
     const actionCount = d.actions?.filter((a) => a.status === "pending").length ?? 0;
     const actionNote = actionCount > 0 ? ` | ${actionCount} pending action(s)` : "";
-    const missingNote = root && d.path && !existsSync7(join11(root, d.path)) ? `
+    const missingNote = root && d.path && !existsSync8(join12(root, d.path)) ? `
 > \u26A0\uFE0F **File missing on disk** \u2014 the registry points at \`${d.path}\` but nothing is there. Check \`git stash list\` for a papi-autostash entry, or re-create/deregister the doc.` : "";
     return `### ${d.title}
 **Type:** ${d.type} | **Status:** ${d.status} | **Cycle:** ${d.cycleCreated}${d.cycleUpdated ? `\u2192${d.cycleUpdated}` : ""}${actionNote}
@@ -21225,12 +21483,12 @@ ${d.summary}
 ${lines.join("\n---\n\n")}`);
 }
 function scanMdFiles(dir, rootDir) {
-  if (!existsSync7(dir)) return [];
+  if (!existsSync8(dir)) return [];
   const files = [];
   try {
     const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join11(dir, entry.name);
+      const full = join12(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...scanMdFiles(full, rootDir));
       } else if (entry.name.endsWith(".md")) {
@@ -21243,7 +21501,7 @@ function scanMdFiles(dir, rootDir) {
 }
 function extractTitle(filePath) {
   try {
-    const content = readFileSync6(filePath, "utf-8").slice(0, 1e3);
+    const content = readFileSync7(filePath, "utf-8").slice(0, 1e3);
     const fmMatch = content.match(/^---[\s\S]*?title:\s*(.+?)$/m);
     if (fmMatch) return fmMatch[1].trim().replace(/^["']|["']$/g, "");
     const headingMatch = content.match(/^#+\s+(.+)$/m);
@@ -21255,7 +21513,7 @@ function extractTitle(filePath) {
 async function detectUnregisteredDocsNote(adapter2, config2) {
   try {
     if (!adapter2.searchDocs || !hasLocalWorkspace()) return "";
-    const docsDir = join11(config2.projectRoot, "docs");
+    const docsDir = join12(config2.projectRoot, "docs");
     const docsFiles = scanMdFiles(docsDir, config2.projectRoot);
     if (docsFiles.length === 0) return "";
     const registered = await adapter2.searchDocs({ limit: 500, status: "all" });
@@ -21281,17 +21539,17 @@ async function handleDocScan(adapter2, config2, args) {
   const includePlans = args.include_plans ?? false;
   const registered = await adapter2.searchDocs({ limit: 500, status: "all" });
   const registeredPaths = new Set(registered.map((d) => d.path));
-  const docsDir = join11(config2.projectRoot, "docs");
+  const docsDir = join12(config2.projectRoot, "docs");
   const docsFiles = scanMdFiles(docsDir, config2.projectRoot);
   const unregisteredDocs = docsFiles.filter((f) => !registeredPaths.has(f));
   let unregisteredPlans = [];
   if (includePlans) {
-    const plansDir = join11(homedir3(), ".claude", "plans");
-    if (existsSync7(plansDir)) {
+    const plansDir = join12(homedir3(), ".claude", "plans");
+    if (existsSync8(plansDir)) {
       const planFiles = scanMdFiles(plansDir, plansDir);
       unregisteredPlans = planFiles.map((f) => `plans/${f}`).filter((f) => !registeredPaths.has(f)).map((f) => ({
         path: f,
-        title: extractTitle(join11(plansDir, f.replace("plans/", "")))
+        title: extractTitle(join12(plansDir, f.replace("plans/", "")))
       }));
     }
   }
@@ -21302,7 +21560,7 @@ async function handleDocScan(adapter2, config2, args) {
   if (unregisteredDocs.length > 0) {
     lines.push(`## Unregistered Docs (${unregisteredDocs.length})`);
     for (const f of unregisteredDocs) {
-      const title = extractTitle(join11(config2.projectRoot, f));
+      const title = extractTitle(join12(config2.projectRoot, f));
       lines.push(`- \`${f}\`${title ? ` \u2014 ${title}` : ""}`);
     }
   }
@@ -22732,13 +22990,13 @@ _To correct: board_edit ${result.task.id} with updated fields._`
 init_git();
 
 // src/services/reconcile.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join13 } from "path";
 function loadDocsIndex(projectRoot) {
   if (!hasLocalWorkspace()) return "";
   try {
-    const indexPath = join12(projectRoot, "docs", "INDEX.md");
-    const raw = readFileSync7(indexPath, "utf8");
+    const indexPath = join13(projectRoot, "docs", "INDEX.md");
+    const raw = readFileSync8(indexPath, "utf8");
     const rows = raw.split("\n").filter((l) => l.startsWith("| ["));
     if (rows.length === 0) return "";
     const entries = rows.map((row) => {
@@ -23313,8 +23571,8 @@ Produce your analysis and structured output above. Present Part 1 to the user an
 }
 
 // src/tools/review.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join14 } from "path";
 init_git();
 
 // src/services/review.ts
@@ -23536,11 +23794,11 @@ ${task.buildReport}` : "### Build Report\n(none recorded)";
 ${diff}
 \`\`\`` : "### Branch diff vs base\n(no diff resolved \u2014 not a git repo, no base ref, or no committed changes)";
   let projectContext = "";
-  const ctxPath = join13(config2.projectRoot, ".agents", "papi-context.md");
-  if (existsSync8(ctxPath)) {
+  const ctxPath = join14(config2.projectRoot, ".agents", "papi-context.md");
+  if (existsSync9(ctxPath)) {
     try {
       projectContext = `### Project context (.agents/papi-context.md)
-${readFileSync8(ctxPath, "utf-8")}
+${readFileSync9(ctxPath, "utf-8")}
 
 `;
     } catch {
@@ -23695,8 +23953,8 @@ function mergeAfterAccept(config2, taskId) {
     };
   }
   const details = [];
-  const papiDir = join13(config2.projectRoot, ".papi");
-  if (existsSync8(papiDir)) {
+  const papiDir = join14(config2.projectRoot, ".papi");
+  if (existsSync9(papiDir)) {
     try {
       const commitResult = stageDirAndCommit(
         config2.projectRoot,
@@ -24035,11 +24293,38 @@ Merge or squash those PRs first, then run \`release\` manually.`;
             } catch {
             }
             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 = `
+            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 = `
 
 ---
 
@@ -24049,9 +24334,15 @@ Merge or squash those PRs first, then run \`release\` manually.`;
 - ${releaseResult.commitNote}
 - ${releaseResult.tagMessage}
 - ${pushInfo}` + groupedMergeNote + (releaseResult.warnings?.length ? `
-- Warnings: ${releaseResult.warnings.join(", ")}` : "") + `
+- 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 ? `
+${autoChangelogDirective}` : "") + (autoDeployDirective ? `
+${autoDeployDirective}` : "") + `
 
 Run \`plan\` to create Cycle ${result.currentCycle + 1}.`;
+            }
           }
         }
       } catch (err) {
@@ -25207,7 +25498,7 @@ function formatDeferredGateSection(sweep) {
 
 // src/tools/agent-list.ts
 import { readdir as readdir2, readFile as readFile7 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var NO_AGENTS_HINT = "No project sub-agents found in `.claude/agents/`. Add a `*.md` file with `name` + `description` frontmatter \u2014 see the 1926-Census marketing sub-agent for a reference implementation.";
 function parseAgentFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -25219,7 +25510,7 @@ function parseAgentFrontmatter(content) {
   return { name: nameMatch?.[1].trim(), description };
 }
 async function listAgents(projectRoot) {
-  const agentsDir = join14(projectRoot, ".claude", "agents");
+  const agentsDir = join15(projectRoot, ".claude", "agents");
   let files;
   try {
     files = await readdir2(agentsDir);
@@ -25230,7 +25521,7 @@ async function listAgents(projectRoot) {
   for (const file of files.filter((f) => f.endsWith(".md"))) {
     let content;
     try {
-      content = await readFile7(join14(agentsDir, file), "utf-8");
+      content = await readFile7(join15(agentsDir, file), "utf-8");
     } catch {
       continue;
     }
@@ -25238,7 +25529,7 @@ async function listAgents(projectRoot) {
     agents.push({
       name: meta?.name ?? file.replace(/\.md$/, ""),
       description: meta?.description ?? "",
-      path: join14(".claude", "agents", file)
+      path: join15(".claude", "agents", file)
     });
   }
   agents.sort((a, b2) => a.name.localeCompare(b2.name));
@@ -25379,8 +25670,8 @@ async function verifyProject(adapter2) {
 // src/tools/orient.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync3, existsSync as existsSync9 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync4, existsSync as existsSync10 } from "fs";
+import { join as join16 } from "path";
 var execFileAsync2 = promisify2(execFile2);
 var GIT_DEPENDENT_ENVS = /* @__PURE__ */ new Set(["hosted", "api"]);
 var VALID_ENVS = /* @__PURE__ */ new Set(["local-cli", "hosted", "api", "unknown"]);
@@ -25695,8 +25986,8 @@ async function getLatestGitTag(projectRoot) {
 }
 async function checkNpmVersionDrift() {
   try {
-    const pkgPath = join15(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkgPath = join16(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
     const localVersion = pkg.version;
     const packageName = pkg.name;
     const { stdout } = await execFileAsync2("npm", ["view", packageName, "version"], {
@@ -26366,9 +26657,9 @@ function enrichClaudeMd(projectRoot, cycleNumber, adapterType, collector, client
 
 \u{1F4DD} **CLAUDE.md enriched** \u2014 added ${tierNames2.join(" + ")} guidance for cycle ${cycleNumber}+ projects.`;
   }
-  const claudeMdPath = join15(projectRoot, "CLAUDE.md");
-  if (!existsSync9(claudeMdPath)) return "";
-  const content = readFileSync9(claudeMdPath, "utf-8");
+  const claudeMdPath = join16(projectRoot, "CLAUDE.md");
+  if (!existsSync10(claudeMdPath)) return "";
+  const content = readFileSync10(claudeMdPath, "utf-8");
   const additions = [];
   if (cycleNumber >= 6 && !content.includes(CLAUDE_MD_ENRICHMENT_SENTINEL_T1)) {
     additions.push(dedupeEnrichmentBlob(content, CLAUDE_MD_TIER_1));
@@ -26377,7 +26668,7 @@ function enrichClaudeMd(projectRoot, cycleNumber, adapterType, collector, client
     additions.push(dedupeEnrichmentBlob(content, CLAUDE_MD_TIER_2));
   }
   if (additions.length === 0) return "";
-  writeFileSync3(claudeMdPath, content + additions.join(""), "utf-8");
+  writeFileSync4(claudeMdPath, content + additions.join(""), "utf-8");
   const tierNames = [];
   if (additions.some((a) => a.includes(CLAUDE_MD_ENRICHMENT_SENTINEL_T1))) tierNames.push("Established (batch building, strategy reviews, AD lifecycle)");
   if (additions.some((a) => a.includes(CLAUDE_MD_ENRICHMENT_SENTINEL_T2))) tierNames.push("Mature (idea pipeline, doc registry, advanced patterns)");
@@ -27100,8 +27391,8 @@ ${result.userMessage}
 }
 
 // src/services/scope-brief.ts
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join16, dirname as dirname4 } from "path";
+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.
 
@@ -27156,14 +27447,14 @@ async function runScopeBrief(adapter2, input) {
   }
   const slug = input.taskId.replace(/[^a-z0-9-]/g, "-").toLowerCase();
   const relPath = `docs/scopes/${slug}.md`;
-  const absPath = join16(input.projectRoot, relPath);
+  const absPath = join17(input.projectRoot, relPath);
   const docBody = addFrontmatter(docContent, task, input.cycleNumber);
   const collector = new FileWriteCollector();
   if (input.adapterType === "proxy") {
     collector.add({ path: relPath, content: docBody, mode: "overwrite" });
   } else {
     mkdirSync3(dirname4(absPath), { recursive: true });
-    writeFileSync4(absPath, docBody, "utf-8");
+    writeFileSync5(absPath, docBody, "utf-8");
   }
   const taskCount = countSubTasks(docContent);
   const summary = buildSummary(task, taskCount);
@@ -27987,19 +28278,19 @@ Its build reports, comments, and history moved with it; the cycle assignment was
 
 // src/services/harness-inventory.ts
 import { readdir as readdir3, readFile as readFile8, stat as stat3 } from "fs/promises";
-import { join as join17 } from "path";
-import { createHash as createHash3 } from "crypto";
+import { join as join18 } from "path";
+import { createHash as createHash4 } from "crypto";
 var RECOMMENDED_HOOKS = ["stop-release-check.sh", "claude-md-size-guard.sh"];
 async function computeFingerprint(root) {
   const parts = [];
   for (const sub of [".claude/skills", ".claude/agents", ".claude/hooks"]) {
-    const dir = join17(root, sub);
+    const dir = join18(root, sub);
     try {
       const names = (await readdir3(dir)).sort((a, b2) => a.localeCompare(b2));
       for (const name of names) {
         let mtime = "";
         try {
-          mtime = String(Math.floor((await stat3(join17(dir, name))).mtimeMs));
+          mtime = String(Math.floor((await stat3(join18(dir, name))).mtimeMs));
         } catch {
         }
         parts.push(`${sub}/${name}:${mtime}`);
@@ -28014,11 +28305,11 @@ async function computeFingerprint(root) {
   } catch {
     parts.push("manifest:none");
   }
-  return createHash3("sha256").update(parts.join("|")).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(parts.join("|")).digest("hex").slice(0, 16);
 }
 async function readSkillDescription(skillDir) {
   try {
-    const content = await readFile8(join17(skillDir, "SKILL.md"), "utf-8");
+    const content = await readFile8(join18(skillDir, "SKILL.md"), "utf-8");
     const fm = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fm) return void 0;
     const desc = fm[1].match(/^description:\s*[>|]?\s*\n?([\s\S]*?)(?=\n\w+:|\n---|$)/m);
@@ -28038,17 +28329,17 @@ async function scanInventory(root, toolDefs) {
     version = loadManifest().packageVersion;
   } catch {
   }
-  const skillsDir = join17(root, ".claude", "skills");
+  const skillsDir = join18(root, ".claude", "skills");
   try {
     const dirents = await readdir3(skillsDir, { withFileTypes: true });
     for (const d of dirents.filter((e) => e.isDirectory())) {
       entries.push({
         kind: "skill",
         name: d.name,
-        description: await readSkillDescription(join17(skillsDir, d.name)),
+        description: await readSkillDescription(join18(skillsDir, d.name)),
         version,
         status: stale.has(d.name) ? "stale_fork" : "ok",
-        path: join17(".claude", "skills", d.name)
+        path: join18(".claude", "skills", d.name)
       });
     }
   } catch {
@@ -28064,9 +28355,9 @@ async function scanInventory(root, toolDefs) {
   }
   const present = /* @__PURE__ */ new Set();
   try {
-    for (const f of (await readdir3(join17(root, ".claude", "hooks"))).filter((n) => n.endsWith(".sh"))) {
+    for (const f of (await readdir3(join18(root, ".claude", "hooks"))).filter((n) => n.endsWith(".sh"))) {
       present.add(f);
-      entries.push({ kind: "hook", name: f, status: "ok", path: join17(".claude", "hooks", f) });
+      entries.push({ kind: "hook", name: f, status: "ok", path: join18(".claude", "hooks", f) });
     }
   } catch {
   }
@@ -28506,7 +28797,7 @@ function createServer(adapter2, config2) {
   const __pkgDir = dirname5(__pkgFilename);
   let serverVersion = "unknown";
   try {
-    const pkg = JSON.parse(readFileSync10(join18(__pkgDir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync11(join19(__pkgDir, "..", "package.json"), "utf-8"));
     serverVersion = pkg.version ?? "unknown";
   } catch {
   }
@@ -28524,7 +28815,7 @@ function createServer(adapter2, config2) {
   }
   const __filename = fileURLToPath3(import.meta.url);
   const __dirname2 = dirname5(__filename);
-  const skillsDir = join18(__dirname2, "..", "skills");
+  const skillsDir = join19(__dirname2, "..", "skills");
   function parseSkillFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
@@ -28542,7 +28833,7 @@ function createServer(adapter2, config2) {
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       const prompts = [];
       for (const file of mdFiles) {
-        const content = await readFile9(join18(skillsDir, file), "utf-8");
+        const content = await readFile9(join19(skillsDir, file), "utf-8");
         const meta = parseSkillFrontmatter(content);
         if (meta) {
           prompts.push({ name: meta.name, description: meta.description });
@@ -28558,7 +28849,7 @@ function createServer(adapter2, config2) {
     try {
       const files = await readdir4(skillsDir);
       for (const file of files.filter((f) => f.endsWith(".md"))) {
-        const content = await readFile9(join18(skillsDir, file), "utf-8");
+        const content = await readFile9(join19(skillsDir, file), "utf-8");
         const meta = parseSkillFrontmatter(content);
         if (meta?.name === name) {
           const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "");
@@ -29228,7 +29519,7 @@ async function dispatchRequest(args) {
 var __dirname = dirname6(fileURLToPath4(import.meta.url));
 var pkgVersion = "unknown";
 try {
-  const pkg = JSON.parse(readFileSync15(join23(__dirname, "..", "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync16(join24(__dirname, "..", "package.json"), "utf-8"));
   pkgVersion = pkg.version;
 } catch {
 }