@papi-ai/server 0.6.0 → 0.6.1

package/dist/index.js

@@ -6071,6 +6071,38 @@ EXCEPTION WHEN duplicate_object THEN NULL; END $$;
           count: parseInt(r.count, 10)
         }));
       }
+      async getModuleEstimationStats() {
+        const rows = await this.sql`
+      SELECT
+        ct.module,
+        COUNT(*)::text AS total,
+        COUNT(*) FILTER (WHERE br.actual_effort = br.estimated_effort)::text AS accurate_count,
+        COUNT(*) FILTER (WHERE br.scope_accuracy = 'accurate')::text AS scope_accurate
+      FROM build_reports br
+      JOIN cycle_tasks ct ON br.task_id = ct.uuid
+      WHERE br.project_id = ${this.projectId}
+        AND ct.project_id = ${this.projectId}
+        AND br.cycle > (SELECT COALESCE(MAX(cycle), 0) FROM build_reports WHERE project_id = ${this.projectId}) - 20
+        AND br.actual_effort IS NOT NULL
+        AND br.estimated_effort IS NOT NULL
+        AND ct.module IS NOT NULL
+        AND ct.module != ''
+      GROUP BY ct.module
+      HAVING COUNT(*) >= 3
+      ORDER BY COUNT(*) DESC
+    `;
+        return rows.map((r) => {
+          const total = parseInt(r.total, 10);
+          const accurate = parseInt(r.accurate_count, 10);
+          const scopeAccurate = parseInt(r.scope_accurate, 10);
+          return {
+            module: r.module,
+            total,
+            accuracyPct: total > 0 ? Math.round(accurate / total * 100) : 0,
+            scopeAccuratePct: total > 0 ? Math.round(scopeAccurate / total * 100) : 0
+          };
+        });
+      }
       async getRecommendationEffectiveness() {
         const rows = await this.sql`
       SELECT type, total::text, actioned::text, dismissed::text, pending::text,
@@ -6387,6 +6419,7 @@ ${newParts.join("\n")}` : newParts.join("\n");
       }
       async searchDocs(input) {
         const status = input.status ?? "active";
+        const matchAllStatuses = status === "all";
         const limit = input.limit ?? 10;
         const keyword = input.keyword ? `%${input.keyword}%` : null;
         const sinceCycle = input.sinceCycle ?? 0;
@@ -6394,7 +6427,7 @@ ${newParts.join("\n")}` : newParts.join("\n");
         const rows = await this.sql`
       SELECT * FROM doc_registry
       WHERE project_id = ${this.projectId}
-        AND status = ${status}
+        AND (${matchAllStatuses} OR status = ${status})
         AND (${input.type ?? null}::text IS NULL OR type = ${input.type ?? null})
         AND (${keyword}::text IS NULL OR (title ILIKE ${keyword} OR summary ILIKE ${keyword}))
         AND (${sinceCycle} = 0 OR COALESCE(cycle_updated, cycle_created) >= ${sinceCycle})
@@ -6569,6 +6602,14 @@ ${newParts.join("\n")}` : newParts.join("\n");
       WHERE project_id = ${this.projectId} AND display_id = ${id}
     `;
       }
+      async confirmPendingActiveDecisions(cycleNumber) {
+        await this.sql`
+      UPDATE active_decisions
+      SET outcome = 'confirmed'
+      WHERE project_id = ${this.projectId} AND outcome = 'pending'
+    `;
+        void cycleNumber;
+      }
       // -------------------------------------------------------------------------
       // Board (Tasks)
       // -------------------------------------------------------------------------
@@ -6837,6 +6878,15 @@ ${newParts.join("\n")}` : newParts.join("\n");
           createdAt: r.created_at ? r.created_at.toISOString() : void 0
         }));
       }
+      async updateCycleLearningActionRef(learningId, taskDisplayId) {
+        await this.sql`
+      UPDATE cycle_learnings
+      SET action_ref = ${taskDisplayId}
+      WHERE id = ${learningId}
+        AND project_id = ${this.projectId}
+        AND action_ref IS NULL
+    `;
+      }
       async getCycleLearningPatterns() {
         const rows = await this.sql`
       SELECT tag,
@@ -8626,6 +8676,28 @@ function formatBuildReports(reports) {
 - **Dead Ends:** ${r.deadEnds}` : "")
   ).join("\n\n---\n\n");
 }
+function formatRecentlyShippedCapabilities(reports) {
+  const completed = reports.filter((r) => r.completed === "Yes" || r.completed === "Partial");
+  if (completed.length === 0) return void 0;
+  const lines = completed.map((r) => {
+    const parts = [`- **${r.taskId}:** ${r.taskName}`];
+    if (r.architectureNotes && r.architectureNotes !== "None") {
+      const trimmed = r.architectureNotes.length > 150 ? r.architectureNotes.slice(0, 150) + "..." : r.architectureNotes;
+      parts.push(`  _Delivered:_ ${trimmed}`);
+    }
+    if (r.filesChanged && r.filesChanged.length > 0) {
+      parts.push(`  _Files:_ ${r.filesChanged.slice(0, 5).join(", ")}${r.filesChanged.length > 5 ? ` (+${r.filesChanged.length - 5} more)` : ""}`);
+    }
+    return parts.join("\n");
+  });
+  return [
+    `${completed.length} task(s) completed in recent cycles:`,
+    "",
+    ...lines,
+    "",
+    "Cross-reference candidate tasks against this list. If >80% of a candidate task's scope appears here, recommend cancellation or scope reduction instead of scheduling."
+  ].join("\n");
+}
 function formatCycleLog(entries) {
   if (entries.length === 0) return "No cycle log entries yet.";
   return entries.map(
@@ -9279,6 +9351,39 @@ function resolveBaseBranch(cwd, preferred) {
   if (preferred !== "master" && branchExists(cwd, "master")) return "master";
   return preferred;
 }
+function detectBoardMismatches(cwd, tasks) {
+  const empty = { codeAhead: [], staleInProgress: [] };
+  if (!isGitAvailable() || !isGitRepo(cwd)) return empty;
+  try {
+    const mergedOutput = execFileSync("git", ["branch", "--merged", "HEAD"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const allOutput = execFileSync("git", ["branch"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const parseBranches = (raw) => new Set(raw.split("\n").map((l) => l.trim().replace(/^\* /, "")).filter(Boolean));
+    const mergedBranches = parseBranches(mergedOutput);
+    const allBranches = parseBranches(allOutput);
+    const codeAhead = [];
+    const staleInProgress = [];
+    for (const task of tasks) {
+      const branch = `feat/${task.displayId}`;
+      if (task.status === "Backlog" && mergedBranches.has(branch)) {
+        codeAhead.push({ displayId: task.displayId, title: task.title, branch });
+      }
+      if (task.status === "In Progress" && !allBranches.has(branch)) {
+        staleInProgress.push({ displayId: task.displayId, title: task.title });
+      }
+    }
+    return { codeAhead, staleInProgress };
+  } catch {
+    return empty;
+  }
+}
 function taskBranchName(taskId) {
   return `feat/${taskId}`;
 }
@@ -9621,13 +9726,19 @@ Standard planning cycle with full board review.
 
 ### Steps:
 1. **Cycle Health Check** \u2014 Flag issues: >7 day gaps, unprocessed discovered issues, AD conflicts, stale In Progress tasks (3+ cycles).
-   **\u26A0\uFE0F CARRY-FORWARD STALENESS:** Check the latest carry-forward text for items containing "stale", "already exists", "already implemented", or "already built". For each such item that references a specific task ID, check whether the task is still in Backlog. If a carry-forward says a task's deliverables already exist but the task is still Backlog, emit a \`boardCorrections\` entry setting it to Done with \`closureReason: "Auto-closed \u2014 carry-forward indicates deliverables already exist"\`. Log in the cycle log: "Auto-closed task-XXX \u2014 carry-forward confirmed deliverables exist." This prevents scheduling already-shipped tasks.
+   **\u26A0\uFE0F CARRY-FORWARD STALENESS (already-built):** Check the latest carry-forward text for items containing "stale", "already exists", "already implemented", or "already built". For each such item that references a specific task ID, check whether the task is still in Backlog. If a carry-forward says a task's deliverables already exist but the task is still Backlog, emit a \`boardCorrections\` entry setting it to Done with \`closureReason: "Auto-closed \u2014 carry-forward indicates deliverables already exist"\`. Log in the cycle log: "Auto-closed task-XXX \u2014 carry-forward confirmed deliverables exist." This prevents scheduling already-shipped tasks.
+   **\u26A0\uFE0F CARRY-FORWARD FORCED RESOLUTION:** If a "Carry-Forward Staleness" section is provided in the context below, it lists task IDs that have been deferred for 3+ consecutive cycles. For each listed task, you MUST take one of these actions \u2014 deferring again without justification is not acceptable:
+   - **Escalate:** Emit a \`boardCorrections\` entry upgrading the task to P1 High (if currently P2+) and include a "Carry-Forward Escalation" paragraph in the cycle log: list each escalated task by ID with a 1-sentence rationale.
+   - **Cancel:** Emit a \`boardCorrections\` entry setting status to "Cancelled" with a \`closureReason\` explaining why the task is no longer worth pursuing.
+   - **Schedule:** Include the task in this cycle's BUILD HANDOFFs. If scheduled, no further action needed.
+   If you defer a stale task again, you MUST provide an explicit justification in the cycle log \u2014 e.g. "task-XXX deferred again: blocked on task-YYY which must ship first."
 
 2. **Inbox Triage** \u2014 Find unreviewed tasks (reviewed = false). For each: clean title, fill all fields, check for duplicates, verify alignment with Active Decisions. You MUST set priority on unreviewed tasks during triage using these criteria:
    - **P0 Critical** \u2014 Broken, blocking, or data-loss risk. Fix now.
    - **P1 High** \u2014 Strategically aligned: directly advances the current horizon/phase goals or Active Decisions.
    - **P2 Medium** \u2014 Valuable but not strategically urgent: quality improvements, efficiency, polish, infrastructure.
    - **P3 Low** \u2014 Nice-to-have, speculative, or future-horizon work.
+   **\u26A0\uFE0F PRIORITY RECALIBRATION \u2014 do NOT rubber-stamp the submitted priority.** The priority set at idea submission reflects the submitter's view at that time, which may be outdated by the time the planner runs. For EVERY unreviewed task, evaluate its priority FROM SCRATCH against: (a) current horizon/stage/phase goals, (b) recent Active Decision changes, (c) recently shipped functionality that makes this task more or less urgent. If your assessed priority differs from the submitted one, set the new priority in \`boardCorrections\` and include the change in a **Priority Recalibration** paragraph in your cycle log (Step 8): list each changed task by ID, old priority \u2192 new priority, and a 1-sentence rationale. This paragraph is how the user sees what the planner recalibrated and why. If no priorities changed during triage, omit the paragraph.
    Also set complexity using the full range \u2014 **XS, Small, Medium, Large, XL** \u2014 based on actual scope, not conservatively. XS = single-line or config change. Small = one file, < 50 lines. Medium = 2-5 files. Large = cross-module, multiple components. XL = architectural, multi-day.
    If a task is clearly obsolete, duplicated, or rejected, set its status to "Cancelled" with a \`closureReason\` explaining why.
    **\u2192 PERSIST:** For each task you set reviewed: true, corrected fields on, or marked "Cancelled", include it in \`boardCorrections\` in Part 2.
@@ -9635,6 +9746,7 @@ Standard planning cycle with full board review.
 3. **Board Integrity** \u2014 All tasks have complete fields? Priority still accurate? Duplicates? Stale In Progress tasks?
    **\u2192 PERSIST:** Include any field corrections (status updates, field fixes) in \`boardCorrections\` in Part 2.
    **\u26A0\uFE0F PRIORITY LOCK RULE:** Do NOT change the priority of any task that has \`reviewed: true\`. Reviewed tasks have had their priority confirmed by a human. If you believe a reviewed task's priority should change, note your recommendation in the cycle log but do NOT include a priority change in \`boardCorrections\`. You may only set priority on unreviewed tasks (during triage) or on newly created tasks (\`newTasks\` array). Priority values: P0 Critical, P1 High, P2 Medium, P3 Low.
+   **Priority Drift Check:** For reviewed Backlog tasks, check whether their priority still reflects strategic reality. A task submitted as P2 six cycles ago may now be P1 (strategic context shifted) or P3 (redundant, superseded, or de-prioritised by an AD). For each task where drift is detected, check three signals: (1) Does it still align with the current horizon/stage/phase? (2) Has a recent AD changed the strategic importance of this area? (3) Has a recent build shipped functionality that makes this task redundant or more urgent? If drift is found on 1+ tasks, include a **Priority Drift Suggestions** paragraph in your cycle log: list each drifted task by ID, current priority, suggested priority, and a 1-sentence rationale. Do NOT include priority changes in \`boardCorrections\` \u2014 these are suggestions requiring human confirmation, not auto-corrections. Omit this paragraph entirely if no drift is detected.
 
 4. **Security Posture Check** \u2014 Review recently completed tasks and current board state for security concerns. Only flag genuine issues \u2014 do not add boilerplate security notes every cycle. Look for:
    - Data exposure risks introduced by recent builds (PII in logs, secrets in storage/config)
@@ -9652,7 +9764,8 @@ Standard planning cycle with full board review.
    - **Task maturity:** Tasks with \`maturity: "raw"\` are unscoped ideas from the idea tool. The planner IS the scoping mechanism \u2014 scope them as part of planning. For raw tasks selected for a cycle: (a) derive clear scope, acceptance criteria, and effort from the title, notes, and project context, (b) upgrade them to \`maturity: "investigated"\` via a \`boardCorrections\` entry, and (c) generate a BUILD HANDOFF as normal. For research-type raw tasks, scope the handoff as an investigation task \u2014 the deliverable is findings + follow-up backlog tasks, not code. Only leave a raw task unscheduled if you genuinely cannot derive scope from the available context \u2014 note why in the cycle log. Tasks with \`maturity: "ready"\` or no maturity field are considered cycle-ready. Tasks with \`maturity: "investigated"\` have been scoped but may still need refinement \u2014 schedule them if priority warrants it.
    - **What to do with premature tasks:** Leave them in Backlog. Do NOT generate BUILD HANDOFFs for them. If a high-priority task fails the maturity gate due to phase prerequisites or dependencies, note it in the cycle log: "task-XXX deferred \u2014 Phase N prerequisites not met". Raw tasks are NOT premature \u2014 they just need scoping (see Task maturity above).
 
-7. **Recommendation** \u2014 Pick ONE task to recommend:
+7. **Recommendation** \u2014 Select tasks for this cycle:
+   **Pre-assigned tasks:** If a "Pre-Assigned Tasks" section is provided in the context below, those tasks are ALREADY committed to this cycle by the user. Include them automatically \u2014 do NOT re-evaluate whether they belong. Generate BUILD HANDOFFs for each. Count their effort toward the cycle budget. Then fill remaining slots (up to 5 total) from the backlog using the priority rules below.
    **If USER DIRECTION is provided above:** Follow the user's stated focus. Pick the highest-impact task that aligns with their direction. The user knows what they need. Only deviate if a genuine P0 Critical fix exists (broken builds, data loss).
    **Otherwise, select by priority level then impact:**
    - **P0 Critical** \u2014 Broken, blocking, or data-loss risk. Always first.
@@ -9664,7 +9777,7 @@ Standard planning cycle with full board review.
    **Cycle sizing:** Size the cycle based on what the selected tasks actually require \u2014 not a fixed budget. Select the highest-priority unblocked tasks, estimate each one's effort from its scope, and let the total emerge from the tasks themselves. The historical average effort from Methodology Trends is a reference point for calibration, not a target or floor. A healthy cycle has 4-6 tasks. Cycles with fewer than 4 tasks require explicit justification in the cycle log \u2014 explain why more tasks could not be included. When the backlog has 10+ tasks, the cycle SHOULD have 5+ tasks \u2014 undersized cycles waste planning overhead relative to the available work. If fewer than 4 tasks qualify after filtering (blocked, deferred, raw), check Deferred tasks \u2014 some may be ready to un-defer via a \`boardCorrections\` entry. A 1-task cycle is almost never correct.
    **Theme coherence:** After selecting candidate tasks, check whether they form a coherent theme \u2014 all serving one goal, phase, or module. Single-theme cycles produce better build quality and less context switching. If the top candidates touch 3+ unrelated modules or epics, prefer regrouping around the highest-priority theme and deferring the outliers. Mixed-theme cycles are acceptable when justified (e.g. a P0 fix alongside P1 feature work), but the justification must appear in the cycle log. Name the theme in 3-5 words \u2014 it becomes the \`cycleLogTitle\`.
 
-8. **Cycle Log** \u2014 Write 5-10 line entry: what was triaged, what was recommended and why, observations, AD updates.
+8. **Cycle Log** \u2014 Write 5-10 line entry: what was triaged, what was recommended and why, observations, AD updates. Include a **Priority Recalibration** paragraph if any unreviewed task priorities were changed during triage (Step 2) \u2014 list each by ID with old \u2192 new priority and rationale. Include a **Priority Drift Suggestions** paragraph if reviewed task drift was detected (Step 3).
    **Cycle Notes** \u2014 Optionally include 1-3 lines of cycle-level observations in \`cycleLogNotes\`: estimation accuracy patterns, recurring blockers, velocity trends, or dependency signals. These notes persist across cycles so future planning runs can learn from them. Use null if there are no noteworthy observations this cycle.
 
 9. **Active Decisions** \u2014 If any AD needs updating: Type A (confidence change), Type B (modification), or Type C (reversal/supersede).
@@ -9678,7 +9791,7 @@ Standard planning cycle with full board review.
 
 10. **BUILD HANDOFFs** \u2014 Generate a full BUILD HANDOFF block for the recommended task and up to 4 additional high-priority unblocked tasks (5 total max). Include each handoff in the \`cycleHandoffs\` array in the structured output. The handoffs are written to each task on the board for durability. Remaining tasks will get handoffs in subsequent plans \u2014 do NOT try to cover the entire backlog.
    **SKIP existing handoffs:** Tasks marked with "Has BUILD HANDOFF: yes" or "\u2713 handoff" on the board already have a valid handoff from a previous plan. Do NOT regenerate handoffs for these tasks \u2014 omit them from the \`cycleHandoffs\` array entirely. Only generate handoffs for tasks that do NOT have one yet. Exception: if a task's dependencies have been completed since its handoff was written, or a relevant Active Decision has changed, you MAY regenerate its handoff \u2014 but note this explicitly in the cycle log.
-   **Scope pre-check:** Before writing the SCOPE section of each handoff, check whether the described functionality already exists based on the task's context, recent build reports, and the FILES LIKELY TOUCHED. If the infrastructure likely exists (e.g. a status type, a DB constraint, an API route), reduce the scope to only the missing pieces and explicitly note what already exists. C126 task-728 was over-scoped because the planner assumed Blocked status needed creating from scratch \u2014 it already existed in types, DB, orient, and build_list. Over-scoped handoffs waste builder time on verification and cause estimation mismatches.
+   **Scope pre-check:** Before writing the SCOPE section of each handoff, cross-reference the task against the "Recently Shipped Capabilities" section in the context below (if present). For each candidate task: (1) check if the task's title or scope overlaps with any recently shipped task, (2) check if the FILES LIKELY TOUCHED overlap with files already modified in recent builds, (3) check the architecture notes from recent builds for patterns that already cover this task's scope. If >80% of a task's scope appears in recently shipped capabilities, recommend cancellation via \`boardCorrections\` or reduce the handoff scope to only the missing pieces \u2014 explicitly note what already exists. C126 task-728 was over-scoped because the planner assumed Blocked status needed creating from scratch \u2014 it already existed in types, DB, orient, and build_list. Over-scoped handoffs waste builder time on verification and cause estimation mismatches.
    **Simplest Viable Path rule:** Before writing each BUILD HANDOFF, identify the simplest approach that satisfies the task's goal \u2014 the minimum change, fewest new abstractions, and smallest blast radius. Write the SCOPE (DO THIS) section for that simplest path FIRST. If you believe a more complex approach is warranted (new abstractions, multi-file refactors, framework changes), you MUST include a "WHY NOT SIMPLER" line in the handoff explaining why the simple path is insufficient. If you cannot articulate a concrete reason, use the simpler path. Pay special attention to tasks involving auth, data access, multi-user features, and infrastructure \u2014 these are the most common over-engineering targets.
    **Maturity gate applies here:** Do NOT generate BUILD HANDOFFs for tasks that failed the maturity gate in step 6 (phase prerequisites not met, dependency chain incomplete). Raw tasks that the planner has scoped and upgraded to "investigated" in step 6 ARE eligible for handoffs.
    **Security section guidance:** Each handoff includes a SECURITY CONSIDERATIONS section. Populate it when the task involves: data exposure risks (PII, secrets in logs/storage), secrets or credentials handling (API keys, tokens, env vars), auth/access control changes, or dependency security risks (new packages, version changes). For pure refactoring, documentation, prompt-text, or UI-only tasks, write "None \u2014 no security-relevant changes".
@@ -9714,7 +9827,7 @@ Standard planning cycle with full board review.
    - **Surprises:** If a surprise reveals a gap (e.g. "schema assumed but not verified"), propose a task to close it.
    - **Architecture Notes:** If a pattern was established that needs follow-up (e.g. "shared service layer created, MCP migration needed"), propose the follow-up.
    - **Strategy gaps:** If an Active Decision has no board tasks supporting it, propose one.
-   - **Dogfood observations:** If unactioned dogfood entries are listed in context (with IDs), check if any map to existing tasks. If not, propose a new task. Include \`dogfood:ID\` in the new task's notes so the pipeline can link them.
+   - **Dogfood observations:** If unactioned dogfood entries are listed in context (with IDs), check if any map to existing tasks. If not, propose a new task. **CRITICAL: Include \`dogfood:<uuid>\` in the new task's \`notes\` field** (e.g. \`"notes": "Addresses recurring friction. dogfood:abc12345-..."\`). This links the task to the observation so the pipeline can track what was actioned. Without this annotation, the observation stays unactioned forever.
    Create new tasks via the \`newTasks\` array in Part 2. Use \`new-N\` IDs in \`cycleHandoffs\` to reference them. **Limit: 3 new tasks per cycle** to prevent backlog bloat.
    **\u26A0\uFE0F DUPLICATE CHECK:** Before adding a task to \`newTasks\`, scan the Cycle Board above for any existing task with the same or very similar title/scope. If a matching task already exists (even with slightly different wording), do NOT create a duplicate \u2014 reference the existing task ID instead. The board already contains all active tasks; re-creating them wastes IDs and bloats the board.
    **\u26A0\uFE0F ALREADY-BUILT CHECK:** Before creating a task, check the recent build reports and cycle log for evidence that this capability was already shipped. If a recent build report shows this feature was completed (even under a different task name), do NOT create a new task for it. This is especially important for UI features, data models, and integrations that may already exist.
@@ -9734,6 +9847,151 @@ Standard planning cycle with full board review.
    If the Forward Horizon context is absent or there are no meaningful decisions to surface, omit this section entirely. Do NOT generate generic advice like "plan ahead" or "consider testing".
 
 **CRITICAL: Review your Part 2 JSON before finishing. Every action from Part 1 must have a corresponding entry in Part 2. If Part 1 mentions corrections, new tasks, AD changes, or handoffs but Part 2 has empty arrays \u2014 you have a persistence bug.**`;
+var PLAN_FRAGMENT_DISCOVERY_GAPS = `
+5. **Discovery Gaps** \u2014 If a Discovery Canvas section is provided in the context below, check which sections are populated vs empty. In cycles 1-10, or whenever canvas sections have been empty for 5+ cycles, include a "Discovery Gaps" paragraph in your cycle log suggesting what context would improve planning. Examples: "Your project context would benefit from MVP boundary definition" or "Consider documenting key user journeys." Keep suggestions conversational \u2014 do NOT create tasks for discovery gaps. If all canvas sections are populated, or no Discovery Canvas is provided, skip this step entirely.`;
+var PLAN_FRAGMENT_RESEARCH = `
+   **Research task detection:** When a task's title starts with "Research:" or the task type is "research", add a RESEARCH OUTPUT section to the BUILD HANDOFF after ACCEPTANCE CRITERIA:
+
+   RESEARCH OUTPUT
+   Deliverable: docs/research/[topic]-findings.md (draft path)
+   Review status: pending owner approval
+   Follow-up tasks: DO NOT submit to backlog until owner confirms findings are actionable
+
+   Also add to ACCEPTANCE CRITERIA: "[ ] Findings doc drafted and saved to docs/research/ before submitting any follow-up ideas"`;
+var PLAN_FRAGMENT_BUG = `
+   **Bug task detection:** When a task's task type is "bug" or the title starts with "Bug:" or "Fix:", apply these rules:
+   - **Auto-P1:** If the task's current priority is P2 or lower, upgrade it to "P1 High" via a boardCorrections entry in Part 2. Note the upgrade in Part 1 analysis.
+   - Add a BLAST RADIUS note to the BUILD HANDOFF SCOPE section: "Bug fix \u2014 minimal blast radius. Change only what is necessary to fix the reported behaviour. Do not refactor surrounding code or expand scope."
+   - Add to ACCEPTANCE CRITERIA: "[ ] Fix is targeted \u2014 no unrelated code changed"`;
+var PLAN_FRAGMENT_IDEA = `
+   **Idea task detection:** When a task's task type is "idea", add a scope clarification note to the BUILD HANDOFF:
+   - Add to SCOPE (DO THIS): "This task originated as an idea. Confirm the exact deliverable before implementing \u2014 check task notes and any referenced docs for intent. If scope is unclear, flag it in the build report surprises."`;
+var PLAN_FRAGMENT_UI = `
+   **UI/visual task detection:** When a task's title or notes contain keywords suggesting frontend visual work (e.g. "visual", "design", "UI", "styling", "refresh", "frontend", "landing page", "hero", "carousel", "theme", "layout", "cockpit", "dashboard", "page"), apply these handoff additions:
+   - Add to SCOPE: "Read \`.impeccable.md\` for brand palette, design principles, and audience context before writing any code. Use the \`frontend-design\` skill for implementation."
+   - For M/L UI tasks, add to SCOPE: "Use the full UI toolchain: Playground (design preview) \u2192 Frontend-design (build) \u2192 Playwright (verify). The playground is the quality bar. Expect 2-3 iterations."
+   - Add to ACCEPTANCE CRITERIA: "[ ] Visually verify rendered output in browser \u2014 provide localhost URL or screenshot to user for review." and "[ ] No raw IDs, abbreviations, or jargon visible without human-readable labels or tooltips."
+   - If the task involves image selection, add to SCOPE: "Include brand/theme direction constraints for image selection."
+   The planner's job is scoping, not design direction. Design decisions happen at build time via \`.impeccable.md\` and the frontend-design skill \u2014 don't try to write design specs in the handoff.`;
+var PLAN_FRAGMENT_PRODUCT_BRIEF = `
+12. **Product Brief** \u2014 Check whether the product brief still reflects reality. Update the brief when ANY of these apply:
+   - A new AD was created or an existing AD was superseded that changes product scope, target user, or positioning
+   - The North Star changed or was validated in a way that the brief doesn't reflect
+   - A phase completed that shifts what the product IS (not just what was built)
+   - The brief describes capabilities, architecture, or direction that are no longer accurate
+   - **DRIFT CHECK:** Compare the brief's content against current reality. The brief is drifted if: (a) it describes capabilities that don't exist or have been removed, (b) it references user types, architecture, or positioning that ADs have since changed, (c) the current phase/stage has shifted from what the brief describes, or (d) key metrics or success criteria no longer match the project's direction. Cycle count since last update is a secondary signal only \u2014 a brief updated 15 cycles ago that still accurately describes the product is NOT stale. A brief updated 3 cycles ago that contradicts a recent AD IS drifted.
+   If any of these apply, include an updated \`productBrief\` in the structured output. Include the FULL updated brief (not a diff). Preserve all existing sections and user-added content; update facts, numbers, and status to reflect current reality. Do not regenerate the brief every cycle \u2014 but do not let it go stale either.`;
+var PLAN_FRAGMENT_FORWARD_HORIZON = `
+13. **Forward Horizon** \u2014 If a Forward Horizon section is provided in the context below, write a "## Forward Horizon" section in Part 1. Surface 2-3 decisions the team should make before the next phase starts. Each item must be:
+   - **Specific** \u2014 reference the upcoming phase by name and the architectural fork or tradeoff involved
+   - **Actionable** \u2014 frame as a decision to make, not a vague warning (e.g. "Decide whether to use WebSockets or SSE for real-time updates before starting Phase 4: Real-Time Features")
+   - **Tied to trajectory** \u2014 based on current board state, ADs, and velocity, not generic advice
+   If the Forward Horizon context is absent or there are no meaningful decisions to surface, omit this section entirely. Do NOT generate generic advice like "plan ahead" or "consider testing".`;
+function buildPlanFullInstructionsConditional(flags, ctx) {
+  if (!flags || !ctx) return PLAN_FULL_INSTRUCTIONS;
+  const parts = [
+    `## FULL MODE
+
+Standard planning cycle with full board review.
+
+### Steps:
+1. **Cycle Health Check** \u2014 Flag issues: >7 day gaps, unprocessed discovered issues, AD conflicts, stale In Progress tasks (3+ cycles).
+   **\u26A0\uFE0F CARRY-FORWARD STALENESS (already-built):** Check the latest carry-forward text for items containing "stale", "already exists", "already implemented", or "already built". For each such item that references a specific task ID, check whether the task is still in Backlog. If a carry-forward says a task's deliverables already exist but the task is still Backlog, emit a \`boardCorrections\` entry setting it to Done with \`closureReason: "Auto-closed \u2014 carry-forward indicates deliverables already exist"\`. Log in the cycle log: "Auto-closed task-XXX \u2014 carry-forward confirmed deliverables exist." This prevents scheduling already-shipped tasks.
+   **\u26A0\uFE0F CARRY-FORWARD FORCED RESOLUTION:** If a "Carry-Forward Staleness" section is provided in the context below, it lists task IDs that have been deferred for 3+ consecutive cycles. For each listed task, you MUST take one of these actions \u2014 deferring again without justification is not acceptable:
+   - **Escalate:** Emit a \`boardCorrections\` entry upgrading the task to P1 High (if currently P2+) and include a "Carry-Forward Escalation" paragraph in the cycle log: list each escalated task by ID with a 1-sentence rationale.
+   - **Cancel:** Emit a \`boardCorrections\` entry setting status to "Cancelled" with a \`closureReason\` explaining why the task is no longer worth pursuing.
+   - **Schedule:** Include the task in this cycle's BUILD HANDOFFs. If scheduled, no further action needed.
+   If you defer a stale task again, you MUST provide an explicit justification in the cycle log \u2014 e.g. "task-XXX deferred again: blocked on task-YYY which must ship first."
+
+2. **Inbox Triage** \u2014 Find unreviewed tasks (reviewed = false). For each: clean title, fill all fields, check for duplicates, verify alignment with Active Decisions. You MUST set priority on unreviewed tasks during triage using these criteria:
+   - **P0 Critical** \u2014 Broken, blocking, or data-loss risk. Fix now.
+   - **P1 High** \u2014 Strategically aligned: directly advances the current horizon/phase goals or Active Decisions.
+   - **P2 Medium** \u2014 Valuable but not strategically urgent: quality improvements, efficiency, polish, infrastructure.
+   - **P3 Low** \u2014 Nice-to-have, speculative, or future-horizon work.
+   **\u26A0\uFE0F PRIORITY RECALIBRATION \u2014 do NOT rubber-stamp the submitted priority.** The priority set at idea submission reflects the submitter's view at that time, which may be outdated by the time the planner runs. For EVERY unreviewed task, evaluate its priority FROM SCRATCH against: (a) current horizon/stage/phase goals, (b) recent Active Decision changes, (c) recently shipped functionality that makes this task more or less urgent. If your assessed priority differs from the submitted one, set the new priority in \`boardCorrections\` and include the change in a **Priority Recalibration** paragraph in your cycle log (Step 8): list each changed task by ID, old priority \u2192 new priority, and a 1-sentence rationale. This paragraph is how the user sees what the planner recalibrated and why. If no priorities changed during triage, omit the paragraph.
+   Also set complexity using the full range \u2014 **XS, Small, Medium, Large, XL** \u2014 based on actual scope, not conservatively. XS = single-line or config change. Small = one file, < 50 lines. Medium = 2-5 files. Large = cross-module, multiple components. XL = architectural, multi-day.
+   If a task is clearly obsolete, duplicated, or rejected, set its status to "Cancelled" with a \`closureReason\` explaining why.
+   **\u2192 PERSIST:** For each task you set reviewed: true, corrected fields on, or marked "Cancelled", include it in \`boardCorrections\` in Part 2.
+
+3. **Board Integrity** \u2014 All tasks have complete fields? Priority still accurate? Duplicates? Stale In Progress tasks?
+   **\u2192 PERSIST:** Include any field corrections (status updates, field fixes) in \`boardCorrections\` in Part 2.
+   **\u26A0\uFE0F PRIORITY LOCK RULE:** Do NOT change the priority of any task that has \`reviewed: true\`. Reviewed tasks have had their priority confirmed by a human. If you believe a reviewed task's priority should change, note your recommendation in the cycle log but do NOT include a priority change in \`boardCorrections\`. You may only set priority on unreviewed tasks (during triage) or on newly created tasks (\`newTasks\` array). Priority values: P0 Critical, P1 High, P2 Medium, P3 Low.
+   **Priority Drift Check:** For reviewed Backlog tasks, check whether their priority still reflects strategic reality. A task submitted as P2 six cycles ago may now be P1 (strategic context shifted) or P3 (redundant, superseded, or de-prioritised by an AD). For each task where drift is detected, check three signals: (1) Does it still align with the current horizon/stage/phase? (2) Has a recent AD changed the strategic importance of this area? (3) Has a recent build shipped functionality that makes this task redundant or more urgent? If drift is found on 1+ tasks, include a **Priority Drift Suggestions** paragraph in your cycle log: list each drifted task by ID, current priority, suggested priority, and a 1-sentence rationale. Do NOT include priority changes in \`boardCorrections\` \u2014 these are suggestions requiring human confirmation, not auto-corrections. Omit this paragraph entirely if no drift is detected.
+
+4. **Security Posture Check** \u2014 Review recently completed tasks and current board state for security concerns. Only flag genuine issues \u2014 do not add boilerplate security notes every cycle. Look for:
+   - Data exposure risks introduced by recent builds (PII in logs, secrets in storage/config)
+   - Unprotected endpoints or missing auth/access control in new features
+   - Undocumented secrets or environment variables added without documentation
+   - New dependencies with known vulnerabilities or excessive permissions
+   **\u2192 PERSIST:** If concerns exist, include them in \`cycleLogNotes\` with a \`[SECURITY]\` tag prefix (e.g. "[SECURITY] New /admin endpoint in task-042 has no auth middleware"). If no concerns, omit \u2014 do not write "[SECURITY] No issues found".`
+  ];
+  if (ctx.hasDiscoveryCanvas) {
+    parts.push(PLAN_FRAGMENT_DISCOVERY_GAPS);
+  }
+  parts.push(`
+6. **Maturity Gate** \u2014 Before scheduling any task, check whether the project is ready for it:
+   - **Cycle number as signal:** A Cycle 3 project should not be scheduling OAuth, billing, or analytics tasks. Early cycles focus on core functionality and proving the concept works.
+   - **Phase prerequisites:** If the board has phases, tasks from later phases should only be scheduled when earlier phases have completed tasks (check Done count per phase). A task in "Phase 4: Monetisation" is premature if Phase 2 tasks are still in Backlog.
+   - **Dependency chain:** If a task's \`dependsOn\` references incomplete tasks, it cannot be scheduled regardless of priority.
+   - **Task maturity:** Tasks with \`maturity: "raw"\` are unscoped ideas from the idea tool. The planner IS the scoping mechanism \u2014 scope them as part of planning. For raw tasks selected for a cycle: (a) derive clear scope, acceptance criteria, and effort from the title, notes, and project context, (b) upgrade them to \`maturity: "investigated"\` via a \`boardCorrections\` entry, and (c) generate a BUILD HANDOFF as normal. For research-type raw tasks, scope the handoff as an investigation task \u2014 the deliverable is findings + follow-up backlog tasks, not code. Only leave a raw task unscheduled if you genuinely cannot derive scope from the available context \u2014 note why in the cycle log. Tasks with \`maturity: "ready"\` or no maturity field are considered cycle-ready. Tasks with \`maturity: "investigated"\` have been scoped but may still need refinement \u2014 schedule them if priority warrants it.
+   - **What to do with premature tasks:** Leave them in Backlog. Do NOT generate BUILD HANDOFFs for them. If a high-priority task fails the maturity gate due to phase prerequisites or dependencies, note it in the cycle log: "task-XXX deferred \u2014 Phase N prerequisites not met". Raw tasks are NOT premature \u2014 they just need scoping (see Task maturity above).
+
+7. **Recommendation** \u2014 Select tasks for this cycle:
+   **Pre-assigned tasks:** If a "Pre-Assigned Tasks" section is provided in the context below, those tasks are ALREADY committed to this cycle by the user. Include them automatically \u2014 do NOT re-evaluate whether they belong. Generate BUILD HANDOFFs for each. Count their effort toward the cycle budget. Then fill remaining slots (up to 5 total) from the backlog using the priority rules below.
+   **If USER DIRECTION is provided above:** Follow the user's stated focus. Pick the highest-impact task that aligns with their direction. The user knows what they need. Only deviate if a genuine P0 Critical fix exists (broken builds, data loss).
+   **Otherwise, select by priority level then impact:**
+   - **P0 Critical** \u2014 Broken, blocking, or data-loss risk. Always first.
+   - **P1 High** \u2014 Strategically aligned: directly advances the current horizon, phase, or Active Decision goals.
+   - **P2 Medium** \u2014 Valuable but not strategically urgent: quality improvements, efficiency, polish, infra.
+   - **P3 Low** \u2014 Nice-to-have, speculative, or future-horizon work.
+   Within the same priority level, prefer tasks with the highest **impact-to-effort ratio**. Impact is measured by: (a) strategic alignment \u2014 does it advance the current horizon/phase? (b) unlocks other work \u2014 are tasks blocked by this? (c) user-facing \u2014 does it change what users see? (d) compounds over time \u2014 does it make future cycles faster? A high-impact Medium task beats a low-impact Small task at the same priority level. Justify in 2-3 sentences.
+   **Blocked tasks:** Tasks with status "Blocked" MUST be skipped during task selection \u2014 they are waiting on external dependencies or gates and cannot be built. Do NOT generate BUILD HANDOFFs for blocked tasks. Do NOT recommend blocked tasks. If a blocked task's gate has been resolved (check the notes and recent build reports), emit a \`boardCorrections\` entry to move it back to Backlog. Report blocked task count in the cycle log.
+   **Cycle sizing:** Size the cycle based on what the selected tasks actually require \u2014 not a fixed budget. Select the highest-priority unblocked tasks, estimate each one's effort from its scope, and let the total emerge from the tasks themselves. The historical average effort from Methodology Trends is a reference point for calibration, not a target or floor. A healthy cycle has 4-6 tasks. Cycles with fewer than 4 tasks require explicit justification in the cycle log \u2014 explain why more tasks could not be included. When the backlog has 10+ tasks, the cycle SHOULD have 5+ tasks \u2014 undersized cycles waste planning overhead relative to the available work. If fewer than 4 tasks qualify after filtering (blocked, deferred, raw), check Deferred tasks \u2014 some may be ready to un-defer via a \`boardCorrections\` entry. A 1-task cycle is almost never correct.
+   **Theme coherence:** After selecting candidate tasks, check whether they form a coherent theme \u2014 all serving one goal, phase, or module. Single-theme cycles produce better build quality and less context switching. If the top candidates touch 3+ unrelated modules or epics, prefer regrouping around the highest-priority theme and deferring the outliers. Mixed-theme cycles are acceptable when justified (e.g. a P0 fix alongside P1 feature work), but the justification must appear in the cycle log. Name the theme in 3-5 words \u2014 it becomes the \`cycleLogTitle\`.
+
+8. **Cycle Log** \u2014 Write 5-10 line entry: what was triaged, what was recommended and why, observations, AD updates. Include a **Priority Recalibration** paragraph if any unreviewed task priorities were changed during triage (Step 2) \u2014 list each by ID with old \u2192 new priority and rationale. Include a **Priority Drift Suggestions** paragraph if reviewed task drift was detected (Step 3).
+   **Cycle Notes** \u2014 Optionally include 1-3 lines of cycle-level observations in \`cycleLogNotes\`: estimation accuracy patterns, recurring blockers, velocity trends, or dependency signals. These notes persist across cycles so future planning runs can learn from them. Use null if there are no noteworthy observations this cycle.
+
+9. **Active Decisions** \u2014 If any AD needs updating: Type A (confidence change), Type B (modification), or Type C (reversal/supersede).
+   **AD Quality Bar:** ADs are for product and architecture choices that constrain future work \u2014 technology selections, data model designs, UX principles, strategic positioning. They are NOT for: process preferences (commit style, PR size), configuration choices (linter rules, tab width), or temporary workarounds. If a decision doesn't affect what gets built or how it's architected, it's not an AD. Apply this bar when proposing new ADs and when triaging existing ones.
+   **\u2192 PERSIST:** EVERY AD you created, updated, or confirmed with changes MUST appear in \`activeDecisions\` array in Part 2. Include the full replacement body with ### heading.
+
+### Operational Quality Rules
+- **Idea similarity pause:** When the idea tool finds similar tasks during planning, stop and explain the overlap \u2014 do not silently ignore the similarity warning. Duplicates bloat the board and waste build slots.
+- **Backlog as steering wheel:** Task priority and notes in the backlog are the user's primary control mechanism over what gets planned. Respect the priority rankings and read task notes carefully \u2014 they contain user intent that shapes scope and scheduling.
+- **Planning quality is the bar:** Strategy review depth and plan quality set the standard for the product. Do not cut corners on analysis depth, triage thoroughness, or handoff specificity \u2014 these are what users experience as PAPI's value.
+
+10. **BUILD HANDOFFs** \u2014 Generate a full BUILD HANDOFF block for the recommended task and up to 4 additional high-priority unblocked tasks (5 total max). Include each handoff in the \`cycleHandoffs\` array in the structured output. The handoffs are written to each task on the board for durability. Remaining tasks will get handoffs in subsequent plans \u2014 do NOT try to cover the entire backlog.
+   **SKIP existing handoffs:** Tasks marked with "Has BUILD HANDOFF: yes" or "\u2713 handoff" on the board already have a valid handoff from a previous plan. Do NOT regenerate handoffs for these tasks \u2014 omit them from the \`cycleHandoffs\` array entirely. Only generate handoffs for tasks that do NOT have one yet. Exception: if a task's dependencies have been completed since its handoff was written, or a relevant Active Decision has changed, you MAY regenerate its handoff \u2014 but note this explicitly in the cycle log.
+   **Scope pre-check:** Before writing the SCOPE section of each handoff, cross-reference the task against the "Recently Shipped Capabilities" section in the context below (if present). For each candidate task: (1) check if the task's title or scope overlaps with any recently shipped task, (2) check if the FILES LIKELY TOUCHED overlap with files already modified in recent builds, (3) check the architecture notes from recent builds for patterns that already cover this task's scope. If >80% of a task's scope appears in recently shipped capabilities, recommend cancellation via \`boardCorrections\` or reduce the handoff scope to only the missing pieces \u2014 explicitly note what already exists. C126 task-728 was over-scoped because the planner assumed Blocked status needed creating from scratch \u2014 it already existed in types, DB, orient, and build_list. Over-scoped handoffs waste builder time on verification and cause estimation mismatches.
+   **Simplest Viable Path rule:** Before writing each BUILD HANDOFF, identify the simplest approach that satisfies the task's goal \u2014 the minimum change, fewest new abstractions, and smallest blast radius. Write the SCOPE (DO THIS) section for that simplest path FIRST. If you believe a more complex approach is warranted (new abstractions, multi-file refactors, framework changes), you MUST include a "WHY NOT SIMPLER" line in the handoff explaining why the simple path is insufficient. If you cannot articulate a concrete reason, use the simpler path. Pay special attention to tasks involving auth, data access, multi-user features, and infrastructure \u2014 these are the most common over-engineering targets.
+   **Maturity gate applies here:** Do NOT generate BUILD HANDOFFs for tasks that failed the maturity gate in step 6 (phase prerequisites not met, dependency chain incomplete). Raw tasks that the planner has scoped and upgraded to "investigated" in step 6 ARE eligible for handoffs.
+   **Security section guidance:** Each handoff includes a SECURITY CONSIDERATIONS section. Populate it when the task involves: data exposure risks (PII, secrets in logs/storage), secrets or credentials handling (API keys, tokens, env vars), auth/access control changes, or dependency security risks (new packages, version changes). For pure refactoring, documentation, prompt-text, or UI-only tasks, write "None \u2014 no security-relevant changes".
+   **Estimation calibration:** Estimate **XS** for: copy/text-only changes, single string replacements, config tweaks, and any task where the scope is "change words in an existing file" with no logic changes. Estimate **S** for: wiring existing adapter methods, adding API routes following established patterns, modifying prompts, or documentation-only changes. Default to S for pattern-following work. Only use M when genuine new architecture, new DB tables, or multi-file architectural changes are needed. Historical data shows systematic over-estimation (198 over vs 8 under out of 528 tasks) \u2014 when in doubt, estimate smaller. If an "Estimation Calibration (Historical)" section is provided in the context below, use its data to adjust your estimates \u2014 it shows how often each estimated size matched the actual effort. Pay special attention to systematic over/under-estimation patterns (e.g. if M\u2192S happens frequently, estimate S instead of M for similar work).
+   **Reference docs:** If a task's notes include a \`Reference:\` path (e.g. \`Reference: docs/architecture/papi-brain-v1.md\`), include a REFERENCE DOCS section in the BUILD HANDOFF with those paths. This tells the builder to read the referenced doc for background context before implementing. Do NOT omit or summarise the reference \u2014 pass it through so the builder can access the full document. Only tasks with explicit \`Reference:\` paths in their notes should have this section.
+   **Pre-build verification:** EVERY handoff MUST include a PRE-BUILD VERIFICATION section listing 2-5 specific file paths the builder should read before implementing. Derive these from FILES LIKELY TOUCHED \u2014 pick the files most likely to already contain the target functionality. This is the #1 prevention mechanism for wasted build slots (C120, C125, C126 all scheduled already-shipped work). If the builder finds >80% of the scope already implemented, they report "already built" instead of re-implementing.`);
+  if (flags.hasResearchTasks) parts.push(PLAN_FRAGMENT_RESEARCH);
+  if (flags.hasBugTasks) parts.push(PLAN_FRAGMENT_BUG);
+  if (flags.hasIdeaTasks) parts.push(PLAN_FRAGMENT_IDEA);
+  if (flags.hasUITasks) parts.push(PLAN_FRAGMENT_UI);
+  parts.push(`
+11. **New Tasks (max 3 per cycle)** \u2014 Actively mine the Recent Build Reports for task candidates. For each report, check:
+   - **Discovered Issues:** If a build report lists a discovered issue and no existing board task covers it, propose a new task.
+   - **Surprises:** If a surprise reveals a gap (e.g. "schema assumed but not verified"), propose a task to close it.
+   - **Architecture Notes:** If a pattern was established that needs follow-up (e.g. "shared service layer created, MCP migration needed"), propose the follow-up.
+   - **Strategy gaps:** If an Active Decision has no board tasks supporting it, propose one.
+   - **Dogfood observations:** If unactioned dogfood entries are listed in context (with IDs), check if any map to existing tasks. If not, propose a new task. **CRITICAL: Include \`dogfood:<uuid>\` in the new task's \`notes\` field** (e.g. \`"notes": "Addresses recurring friction. dogfood:abc12345-..."\`). This links the task to the observation so the pipeline can track what was actioned. Without this annotation, the observation stays unactioned forever.
+   Create new tasks via the \`newTasks\` array in Part 2. Use \`new-N\` IDs in \`cycleHandoffs\` to reference them. **Limit: 3 new tasks per cycle** to prevent backlog bloat.
+   **\u26A0\uFE0F DUPLICATE CHECK:** Before adding a task to \`newTasks\`, scan the Cycle Board above for any existing task with the same or very similar title/scope. If a matching task already exists (even with slightly different wording), do NOT create a duplicate \u2014 reference the existing task ID instead. The board already contains all active tasks; re-creating them wastes IDs and bloats the board.
+   **\u26A0\uFE0F ALREADY-BUILT CHECK:** Before creating a task, check the recent build reports and cycle log for evidence that this capability was already shipped. If a recent build report shows this feature was completed (even under a different task name), do NOT create a new task for it. This is especially important for UI features, data models, and integrations that may already exist.`);
+  parts.push(PLAN_FRAGMENT_PRODUCT_BRIEF);
+  if (ctx.hasHorizonContext) {
+    parts.push(PLAN_FRAGMENT_FORWARD_HORIZON);
+  }
+  parts.push(`
+**CRITICAL: Review your Part 2 JSON before finishing. Every action from Part 1 must have a corresponding entry in Part 2. If Part 1 mentions corrections, new tasks, AD changes, or handoffs but Part 2 has empty arrays \u2014 you have a persistence bug.**`);
+  return parts.join("\n");
+}
 function buildPlanUserMessage(ctx) {
   const modeLabel = ctx.mode.toUpperCase();
   const parts = [
@@ -9754,7 +10012,11 @@ function buildPlanUserMessage(ctx) {
   if (ctx.mode === "bootstrap") {
     parts.push(PLAN_BOOTSTRAP_INSTRUCTIONS);
   } else {
-    parts.push(PLAN_FULL_INSTRUCTIONS);
+    const instructions = ctx.boardFlags ? buildPlanFullInstructionsConditional(ctx.boardFlags, {
+      hasDiscoveryCanvas: !!ctx.discoveryCanvas,
+      hasHorizonContext: !!ctx.horizonContext
+    }) : PLAN_FULL_INSTRUCTIONS;
+    parts.push(instructions);
   }
   parts.push("", "---", "", "## PROJECT CONTEXT", "");
   parts.push("### Product Brief", "", ctx.productBrief, "");
@@ -9768,12 +10030,18 @@ function buildPlanUserMessage(ctx) {
     if (ctx.recentBuildReports) {
       parts.push("### Recent Build Reports", "", ctx.recentBuildReports, "");
     }
+    if (ctx.recentlyShippedCapabilities) {
+      parts.push("### Recently Shipped Capabilities", "", ctx.recentlyShippedCapabilities, "");
+    }
     if (ctx.cycleLog) {
       parts.push("### Cycle Log", "", ctx.cycleLog, "");
     }
     if (ctx.board) {
       parts.push("### Board", "", ctx.board, "");
     }
+    if (ctx.preAssignedTasks) {
+      parts.push("### Pre-Assigned Tasks", "", ctx.preAssignedTasks, "");
+    }
     if (ctx.buildPatterns) {
       parts.push("### Build Patterns", "", ctx.buildPatterns, "");
     }
@@ -9804,6 +10072,71 @@ function buildPlanUserMessage(ctx) {
     if (ctx.discoveryCanvas) {
       parts.push("### Discovery Canvas", "", ctx.discoveryCanvas, "");
     }
+    if (ctx.registeredDocs) {
+      parts.push("### Relevant Research Docs", "", ctx.registeredDocs, "");
+    }
+    if (ctx.carryForwardStaleness) {
+      parts.push("### Carry-Forward Staleness", "", ctx.carryForwardStaleness, "");
+    }
+  }
+  return parts.join("\n");
+}
+function buildHandoffsOnlyUserMessage(inputs) {
+  const targetCycle = inputs.cycleNumber + 1;
+  const taskLines = inputs.preAssignedTasks.map((t) => {
+    const notes = t.notes ? `
+  Notes: ${t.notes.slice(0, 300)}` : "";
+    const hasHandoff = t.hasHandoff;
+    return `- **${t.id}:** ${t.title}
+  Priority: ${t.priority} | Complexity: ${t.complexity} | Module: ${t.module}
+  Phase: ${t.phase} | Epic: ${t.epic}${hasHandoff ? " | Has BUILD HANDOFF: yes" : ""}${notes}`;
+  });
+  const parts = [
+    `## MODE: HANDOFFS-ONLY`,
+    `## Cycle Number: ${targetCycle}`,
+    "",
+    `## HANDOFFS-ONLY MODE`,
+    "",
+    `The user has pre-assigned ${inputs.preAssignedTasks.length} task(s) to Cycle ${targetCycle} and wants BUILD HANDOFFs generated without full backlog analysis.`,
+    "",
+    `**Skip these steps entirely:** Inbox Triage, Board Integrity, Security Posture Check, Discovery Gaps, Maturity Gate, Recommendation (task selection), New Tasks, Product Brief update.`,
+    "",
+    `**Do these steps only:**`,
+    `1. Generate a BUILD HANDOFF for each pre-assigned task listed below.`,
+    `2. Write a brief Cycle Log entry (3-5 lines) noting this was a handoffs-only cycle and listing the tasks.`,
+    `3. If any task already has a BUILD HANDOFF (marked "Has BUILD HANDOFF: yes"), skip it \u2014 do NOT regenerate.`,
+    "",
+    `Follow the BUILD HANDOFF format from the system prompt. Include SCOPE, SCOPE BOUNDARY, ACCEPTANCE CRITERIA, SECURITY CONSIDERATIONS, PRE-BUILD VERIFICATION, FILES LIKELY TOUCHED, and EFFORT for each task.`,
+    "",
+    `Your output MUST have TWO parts:`,
+    `1. Natural language markdown with BUILD HANDOFF blocks`,
+    `2. After \`<!-- PAPI_STRUCTURED_OUTPUT -->\`, a JSON block with structured data`,
+    "",
+    `The structured output format is the same as full mode. Use empty arrays for \`newTasks\`, \`boardCorrections\`, and \`activeDecisions\`. Populate \`cycleHandoffs\` with your handoffs.`,
+    "",
+    `---`,
+    "",
+    `## PRE-ASSIGNED TASKS`,
+    "",
+    ...taskLines,
+    "",
+    `---`,
+    "",
+    `## PROJECT CONTEXT`,
+    "",
+    `### Product Brief`,
+    "",
+    inputs.productBrief,
+    ""
+  ];
+  if (inputs.northStar) {
+    parts.push("### North Star (current)", "", inputs.northStar, "");
+  }
+  if (inputs.activeDecisions) {
+    parts.push("### Active Decisions", "", inputs.activeDecisions, "");
+  }
+  if (inputs.recentBuildReports) {
+    parts.push("### Recent Build Reports", "", inputs.recentBuildReports, "");
   }
   return parts.join("\n");
 }
@@ -10612,6 +10945,45 @@ function buildPlanSlackSummary(cycleNumber, mode, data) {
   }
   return parts.join("\n");
 }
+function computeCarryForwardStaleness(log) {
+  if (log.length === 0) return void 0;
+  const sorted = [...log].sort((a, b2) => a.cycleNumber - b2.cycleNumber);
+  const taskCounts = /* @__PURE__ */ new Map();
+  for (const entry of sorted) {
+    if (!entry.carryForward) continue;
+    const matches = entry.carryForward.match(/task-\d+/g) ?? [];
+    const seen = new Set(matches);
+    for (const id of seen) {
+      taskCounts.set(id, (taskCounts.get(id) ?? 0) + 1);
+    }
+  }
+  const stale = [...taskCounts.entries()].filter(([, count]) => count >= 3);
+  if (stale.length === 0) return void 0;
+  const lines = stale.map(([id, count]) => `- **${id}** \u2014 deferred ${count} consecutive cycle(s)`);
+  return [
+    `\u26A0\uFE0F ${stale.length} task(s) have been in carry-forward for 3+ consecutive cycles. The planner must resolve each \u2014 either escalate to P1 High or recommend cancellation with a closure reason. Deferring again without justification is not acceptable.`,
+    "",
+    ...lines
+  ].join("\n");
+}
+function formatPreAssignedTasks(tasks, targetCycle) {
+  if (tasks.length === 0) return void 0;
+  const lines = tasks.map((t) => {
+    const notes = t.notes ? ` \u2014 ${t.notes.slice(0, 200)}` : "";
+    return `- **${t.id}:** ${t.title} [${t.priority} | ${t.complexity} | ${t.module}]${notes}`;
+  });
+  const effort = tasks.reduce((sum, t) => {
+    const map = { XS: 1, S: 2, Small: 2, M: 3, Medium: 3, L: 5, Large: 5, XL: 8 };
+    return sum + (map[t.complexity] ?? 3);
+  }, 0);
+  return [
+    `${tasks.length} task(s) pre-assigned to Cycle ${targetCycle} (~${effort} effort points):`,
+    "",
+    ...lines,
+    "",
+    "These tasks MUST be included in the cycle. Generate BUILD HANDOFFs for each. Fill remaining slots (up to 5 total) from the backlog."
+  ].join("\n");
+}
 function pushAfterCommit(config2) {
   if (!isGitAvailable() || !isGitRepo(config2.projectRoot)) {
     return "";
@@ -10771,6 +11143,28 @@ function stripTasksForPlan(tasks) {
     hasHandoff: !!buildHandoff
   }));
 }
+function detectBoardFlags(tasks) {
+  let hasBugTasks = false;
+  let hasResearchTasks = false;
+  let hasIdeaTasks = false;
+  let hasUITasks = false;
+  const uiKeywords = /\b(visual|design|UI|styling|refresh|frontend|landing page|hero|carousel|theme|layout|cockpit|dashboard|page)\b/i;
+  for (const t of tasks) {
+    if (t.taskType === "bug" || /^(Bug:|Fix:)/i.test(t.title)) hasBugTasks = true;
+    if (t.taskType === "research" || /^Research:/i.test(t.title)) hasResearchTasks = true;
+    if (t.taskType === "idea") hasIdeaTasks = true;
+    if (uiKeywords.test(t.title) || uiKeywords.test(t.notes ?? "")) hasUITasks = true;
+  }
+  return { hasBugTasks, hasResearchTasks, hasIdeaTasks, hasUITasks };
+}
+function detectBoardFlagsFromText(boardText) {
+  return {
+    hasBugTasks: /\b(bug|Bug:|Fix:)\b/i.test(boardText),
+    hasResearchTasks: /\b(research|Research:)\b/i.test(boardText),
+    hasIdeaTasks: /\bidea\b/i.test(boardText),
+    hasUITasks: /\b(visual|design|UI|styling|refresh|frontend|landing page|hero|carousel|theme|layout|cockpit|dashboard|page)\b/i.test(boardText)
+  };
+}
 function hashSection(content) {
   return createHash("sha256").update(content).digest("hex").slice(0, 12);
 }
@@ -10780,7 +11174,13 @@ function applyContextDiff(ctx, prevHashes) {
   const sections = [
     { key: "productBrief", hashKey: "productBrief" },
     { key: "activeDecisions", hashKey: "activeDecisions" },
-    { key: "recentReviews", hashKey: "reviews" }
+    { key: "recentReviews", hashKey: "reviews" },
+    { key: "board", hashKey: "board" },
+    { key: "recentBuildReports", hashKey: "buildReports" },
+    { key: "cycleLog", hashKey: "cycleLog" },
+    { key: "discoveryCanvas", hashKey: "discoveryCanvas" },
+    { key: "estimationCalibration", hashKey: "estimationCalibration" },
+    { key: "methodologyMetrics", hashKey: "methodologyMetrics" }
   ];
   for (const { key, hashKey } of sections) {
     const content = ctx[key];
@@ -10914,10 +11314,54 @@ async function assembleContext(adapter2, mode, _config, filters, focus) {
     const discoveryCanvasText = await assembleDiscoveryCanvasText(adapter2);
     let estimationCalibrationText;
     try {
-      const calibrationRows = await adapter2.getEstimationCalibration?.();
+      const [calibrationRows, moduleStats] = await Promise.all([
+        adapter2.getEstimationCalibration?.(),
+        adapter2.getModuleEstimationStats?.()
+      ]);
       if (calibrationRows && calibrationRows.length > 0) {
         estimationCalibrationText = formatEstimationCalibration(calibrationRows);
       }
+      if (moduleStats && moduleStats.length > 0) {
+        const moduleLines = [
+          "",
+          "**By module (last 20 cycles, min 3 builds):**",
+          "| Module | Builds | Effort match | Scope accurate |",
+          "|--------|--------|--------------|----------------|",
+          ...moduleStats.map((r) => `| ${r.module} | ${r.total} | ${r.accuracyPct}% | ${r.scopeAccuratePct}% |`)
+        ].join("\n");
+        estimationCalibrationText = (estimationCalibrationText ?? "") + moduleLines;
+      }
+    } catch {
+    }
+    let registeredDocsText;
+    try {
+      const docs = await adapter2.searchDocs?.({ status: "active", limit: 5 });
+      if (docs && docs.length > 0) {
+        const lines = docs.map((d) => `- **${d.title}** (${d.type}) \u2014 ${d.summary}`);
+        registeredDocsText = `${docs.length} active research doc(s):
+${lines.join("\n")}`;
+      }
+    } catch {
+    }
+    const boardFlags = detectBoardFlagsFromText(leanSummary.board);
+    let carryForwardStalenessLean;
+    try {
+      const recentLog = await adapter2.getCycleLog(5);
+      carryForwardStalenessLean = computeCarryForwardStaleness(recentLog);
+    } catch {
+    }
+    const leanTargetCycle = health.totalCycles + 1;
+    let preAssignedTextLean;
+    try {
+      const preAssignedTasks = await adapter2.queryBoard({ status: ["Backlog", "In Cycle", "Ready"] });
+      const preAssigned2 = preAssignedTasks.filter((t2) => t2.cycle === leanTargetCycle);
+      preAssignedTextLean = formatPreAssignedTasks(preAssigned2, leanTargetCycle);
+    } catch {
+    }
+    let recentlyShippedLean;
+    try {
+      const reportsForCaps = await adapter2.getRecentBuildReports(10);
+      recentlyShippedLean = formatRecentlyShippedCapabilities(reportsForCaps);
     } catch {
     }
     let ctx2 = {
@@ -10936,7 +11380,12 @@ async function assembleContext(adapter2, mode, _config, filters, focus) {
       taskComments: taskCommentsText,
       discoveryCanvas: discoveryCanvasText,
       estimationCalibration: estimationCalibrationText,
-      focus
+      registeredDocs: registeredDocsText,
+      focus,
+      boardFlags,
+      carryForwardStaleness: carryForwardStalenessLean,
+      preAssignedTasks: preAssignedTextLean,
+      recentlyShippedCapabilities: recentlyShippedLean
     };
     t = startTimer();
     const prevHashes2 = await adapter2.getContextHashes?.(health.totalCycles) ?? null;
@@ -11001,25 +11450,53 @@ async function assembleContext(adapter2, mode, _config, filters, focus) {
   console.error(`[plan-perf] assembleContext (full): ${JSON.stringify(timings)}ms`);
   const discoveryCanvasTextFull = await assembleDiscoveryCanvasText(adapter2);
   const taskCommentsTextFull = await assembleTaskComments(adapter2);
+  let registeredDocsTextFull;
+  try {
+    const docs = await adapter2.searchDocs?.({ status: "active", limit: 5 });
+    if (docs && docs.length > 0) {
+      const lines = docs.map((d) => `- **${d.title}** (${d.type}) \u2014 ${d.summary}`);
+      registeredDocsTextFull = `${docs.length} active research doc(s):
+${lines.join("\n")}`;
+    }
+  } catch {
+  }
+  const MAX_PLAN_BUILD_REPORT_CYCLES = 3;
+  const cappedReports = reports.length > 0 ? (() => {
+    const maxCycle = Math.max(...reports.map((r) => r.cycle ?? 0));
+    const cutoff = maxCycle - MAX_PLAN_BUILD_REPORT_CYCLES + 1;
+    const filtered = reports.filter((r) => (r.cycle ?? 0) >= cutoff);
+    return filtered.length > 0 ? filtered : reports.slice(0, 5);
+  })() : reports;
+  const strippedTasks = stripTasksForPlan(tasks);
+  const boardFlagsFull = detectBoardFlags(tasks);
+  const horizonCtx = buildHorizonContext(phases, tasks) ?? void 0;
+  const targetCycle = health.totalCycles + 1;
+  const preAssigned = strippedTasks.filter((t2) => t2.cycle === targetCycle);
+  const preAssignedText = formatPreAssignedTasks(preAssigned, targetCycle);
   let ctx = {
     mode,
     cycleNumber: health.totalCycles,
     productBrief,
     activeDecisions: formatActiveDecisionsForPlan(decisions),
-    recentBuildReports: formatBuildReports(reports),
+    recentBuildReports: formatBuildReports(cappedReports),
     cycleLog: formatCycleLog(log),
-    board: formatBoardForPlan(stripTasksForPlan(tasks), filters, health.totalCycles),
+    board: formatBoardForPlan(strippedTasks, filters, health.totalCycles),
     northStar,
     methodologyMetrics: formatCycleMetrics(metricsSnapshots),
     recentReviews: formatReviews(reviews),
     buildPatterns: buildPatternsText,
     reviewPatterns: reviewPatternsText,
-    horizonContext: buildHorizonContext(phases, tasks) ?? void 0,
+    horizonContext: horizonCtx,
     strategyRecommendations: strategyRecommendationsText,
     dogfoodEntries,
     taskComments: taskCommentsTextFull,
     discoveryCanvas: discoveryCanvasTextFull,
-    focus
+    registeredDocs: registeredDocsTextFull,
+    focus,
+    boardFlags: boardFlagsFull,
+    carryForwardStaleness: computeCarryForwardStaleness(log),
+    preAssignedTasks: preAssignedText,
+    recentlyShippedCapabilities: formatRecentlyShippedCapabilities(allReportsForPatterns)
   };
   const prevHashes = await adapter2.getContextHashes?.(health.totalCycles) ?? null;
   const { ctx: diffedCtx, newHashes, savedBytes } = applyContextDiff(ctx, prevHashes);
@@ -11236,12 +11713,45 @@ ${cleanContent}`;
         notes: task.notes || ""
       });
       newTaskIdMap.set(`new-${i + 1}`, created.id);
-      if (adapter2.updateDogfoodEntryStatus && task.notes) {
-        const dogfoodRefs = task.notes.match(/dogfood:([a-f0-9-]+)/gi);
-        if (dogfoodRefs) {
-          for (const ref of dogfoodRefs) {
-            const entryId = ref.split(":")[1];
-            await adapter2.updateDogfoodEntryStatus(entryId, "backlog-created", created.id);
+      if (adapter2.updateCycleLearningActionRef && task.notes) {
+        const learningRefs = task.notes.match(/learning:([a-f0-9-]+)/gi);
+        if (learningRefs) {
+          for (const ref of learningRefs) {
+            const learningId = ref.split(":")[1];
+            try {
+              await adapter2.updateCycleLearningActionRef(learningId, created.id);
+            } catch {
+            }
+          }
+        }
+      }
+      if (adapter2.updateDogfoodEntryStatus) {
+        let linked = false;
+        if (task.notes) {
+          const dogfoodRefs = task.notes.match(/dogfood:([a-f0-9-]+)/gi);
+          if (dogfoodRefs) {
+            for (const ref of dogfoodRefs) {
+              const entryId = ref.split(":")[1];
+              await adapter2.updateDogfoodEntryStatus(entryId, "backlog-created", created.id);
+            }
+            linked = true;
+          }
+        }
+        if (!linked && adapter2.getUnactionedDogfoodEntries) {
+          try {
+            const unactioned = await adapter2.getUnactionedDogfoodEntries(50);
+            if (unactioned.length > 0) {
+              const taskText = normalise(`${task.title} ${task.notes || ""} ${task.why || ""}`);
+              const taskWords = new Set(taskText.split(/\s+/).filter((w) => w.length >= 4));
+              for (const entry of unactioned) {
+                const entryWords = normalise(entry.content).split(/\s+/).filter((w) => w.length >= 4);
+                const overlap = entryWords.filter((w) => taskWords.has(w)).length;
+                if (overlap >= 3 && entry.id) {
+                  await adapter2.updateDogfoodEntryStatus(entry.id, "backlog-created", created.id);
+                }
+              }
+            }
+          } catch {
           }
         }
       }
@@ -11537,11 +12047,49 @@ async function processLlmOutput(adapter2, config2, rawOutput, mode, cycleNumber,
     writeSummary
   };
 }
-async function preparePlan(adapter2, config2, filters, focus, force) {
+async function preparePlan(adapter2, config2, filters, focus, force, handoffsOnly) {
   const prepareTimer = startTimer();
   let t = startTimer();
   const { mode, cycleNumber, strategyReviewWarning } = await validateAndPrepare(adapter2, force);
   const validateMs = t();
+  if (handoffsOnly) {
+    t = startTimer();
+    const targetCycle = cycleNumber + 1;
+    const allTasks = await adapter2.queryBoard({ status: ["Backlog", "In Cycle", "Ready", "In Progress"] });
+    const preAssigned = allTasks.filter((task) => task.cycle === targetCycle);
+    if (preAssigned.length === 0) {
+      throw new Error(`No tasks assigned to Cycle ${targetCycle}. Assign tasks first (set cycle = ${targetCycle} via SQL) or run plan without handoffs_only.`);
+    }
+    const [decisions, reports, brief] = await Promise.all([
+      adapter2.getActiveDecisions(),
+      adapter2.getRecentBuildReports(10),
+      adapter2.getProductBrief()
+    ]);
+    const northStar = await adapter2.getCurrentNorthStar?.() ?? "";
+    const userMessage2 = buildHandoffsOnlyUserMessage({
+      cycleNumber,
+      preAssignedTasks: preAssigned,
+      activeDecisions: formatActiveDecisionsForPlan(decisions),
+      recentBuildReports: formatBuildReports(reports),
+      productBrief: brief,
+      northStar
+    });
+    const assembleMs2 = t();
+    const totalMs2 = prepareTimer();
+    console.error(`[plan-perf] preparePlan (handoffs-only): validate=${validateMs}ms assemble=${assembleMs2}ms total=${totalMs2}ms`);
+    const contextBytes2 = Buffer.byteLength(userMessage2, "utf-8");
+    console.error(`[plan-perf] contextBytes=${contextBytes2} (handoffs-only)`);
+    const planSystemPrompt2 = await getPrompt("plan-system");
+    return {
+      mode: "full",
+      // apply phase treats it the same
+      cycleNumber,
+      systemPrompt: planSystemPrompt2,
+      userMessage: userMessage2,
+      strategyReviewWarning,
+      contextBytes: contextBytes2
+    };
+  }
   t = startTimer();
   const { context, contextHashes } = await assembleContext(adapter2, mode, config2, filters, focus);
   const assembleMs = t();
@@ -11723,7 +12271,7 @@ var lastPrepareUserMessage;
 var lastPrepareContextBytes;
 var planTool = {
   name: "plan",
-  description: 'Run once per cycle to generate BUILD HANDOFFs for up to 10 tasks. Call after setup (first time) or after completing all builds from the previous cycle. Returns prioritised task recommendations with detailed implementation specs. Do not call between builds \u2014 use build_execute to work through existing handoffs first. First call returns a planning prompt for you to execute (prepare phase). Then call again with mode "apply" and your output to write results.',
+  description: 'Run once per cycle to generate BUILD HANDOFFs for up to 5 tasks. Call after setup (first time) or after completing all builds AND running release for the previous cycle. Returns prioritised task recommendations with detailed implementation specs. NEVER call when unbuilt cycle tasks exist \u2014 build and release first. First call returns a planning prompt for you to execute (prepare phase). Then call again with mode "apply" and your output to write results.',
   inputSchema: {
     type: "object",
     properties: {
@@ -11772,6 +12320,10 @@ var planTool = {
       force: {
         type: "boolean",
         description: "Bypass planning guards (unreleased cycle block, strategy review hard-block). Only use when explicitly requested by the user."
+      },
+      handoffs_only: {
+        type: "boolean",
+        description: "Skip backlog analysis and task selection. Only generate BUILD HANDOFFs for tasks already assigned to the target cycle. Requires pre-assigned tasks (set cycle number on tasks first). ~30% of normal plan cost."
       }
     },
     required: []
@@ -11811,6 +12363,10 @@ function formatPlanResult(result) {
   if (result.slackWarning) lines.push(result.slackWarning);
   if (result.autoCommitNote) lines.push(result.autoCommitNote.trim());
   lines.push("", `Next: run \`build_list\` to see your cycle tasks, then \`build_execute <task_id>\` to start building.`);
+  if (result.contextBytes !== void 0) {
+    const kb = (result.contextBytes / 1024).toFixed(1);
+    lines.push(`---`, `Context: ${kb}KB`);
+  }
   const response = textResponse(lines.join("\n"));
   if (result.contextUtilisation !== void 0) {
     return { ...response, _contextUtilisation: result.contextUtilisation };
@@ -11826,6 +12382,7 @@ async function handlePlan(adapter2, config2, args) {
   if (typeof args.priority === "string") filters.priority = args.priority;
   const focus = typeof args.focus === "string" ? args.focus : void 0;
   const force = args.force === true;
+  const handoffsOnly = args.handoffs_only === true;
   try {
     if (toolMode === "apply") {
       const llmResponse = args.llm_response;
@@ -11849,7 +12406,7 @@ async function handlePlan(adapter2, config2, args) {
         } catch {
         }
       }
-      const response = formatPlanResult({ ...result, contextUtilisation: utilisation });
+      const response = formatPlanResult({ ...result, contextUtilisation: utilisation, contextBytes });
       return {
         ...response,
         ...contextBytes !== void 0 ? { _contextBytes: contextBytes } : {},
@@ -11861,7 +12418,7 @@ async function handlePlan(adapter2, config2, args) {
         await propagatePhaseStatus(adapter2);
       } catch {
       }
-      const result = await preparePlan(adapter2, config2, filters, focus, force);
+      const result = await preparePlan(adapter2, config2, filters, focus, force, handoffsOnly);
       lastPrepareContextHashes = result.contextHashes;
       lastPrepareUserMessage = result.userMessage;
       lastPrepareContextBytes = result.contextBytes;
@@ -12008,7 +12565,9 @@ function extractRecommendations(data, cycleNumber) {
     }
   }
   if (!data.actionItems?.length && data.strategicRecommendations) {
-    const lines = data.strategicRecommendations.split("\n");
+    const recsValue = data.strategicRecommendations;
+    const recsStr = Array.isArray(recsValue) ? recsValue.join("\n") : String(recsValue);
+    const lines = recsStr.split("\n");
     for (const line of lines) {
       const bullet = line.replace(/^[\s*-]+/, "").trim();
       if (!bullet) continue;
@@ -12605,6 +13164,12 @@ ${cleanContent}`;
       }
     }));
   }
+  try {
+    if (adapter2.confirmPendingActiveDecisions) {
+      await adapter2.confirmPendingActiveDecisions(cycleNumber);
+    }
+  } catch {
+  }
   if (data.decisionScores && data.decisionScores.length > 0) {
     await Promise.all(data.decisionScores.map(async (score) => {
       try {
@@ -12663,6 +13228,17 @@ ${cleanContent}`;
     } catch {
     }
   }
+  if (adapter2.getUnactionedDogfoodEntries && adapter2.updateDogfoodEntryStatus) {
+    try {
+      const staleThreshold = cycleNumber - 10;
+      const unactioned = await adapter2.getUnactionedDogfoodEntries(100);
+      const stale = unactioned.filter((e) => e.cycleNumber <= staleThreshold);
+      await Promise.all(
+        stale.map((e) => adapter2.updateDogfoodEntryStatus(e.id, "dismissed"))
+      );
+    } catch {
+    }
+  }
   try {
     const canvas = await adapter2.readDiscoveryCanvas();
     const updates = {};
@@ -13213,7 +13789,7 @@ var lastReviewUserMessage;
 var lastReviewContextBytes;
 var strategyReviewTool = {
   name: "strategy_review",
-  description: 'Run a Strategy Review \u2014 assesses project direction, velocity, and Active Decisions. Auto-triggered every 5 cycles. First call returns a review prompt for you to execute (prepare phase). Then call again with mode "apply" and your output. If the review is not yet due, pass `force: true` to bypass the cadence gate and run an early review.',
+  description: 'Run a Strategy Review \u2014 assesses project direction, velocity, and Active Decisions. Produces recommendations and potential AD updates that feed into the next plan. Offered every 5 cycles; hard-blocked at 7+ overdue cycles. Run in its own dedicated session \u2014 do not mix with building. First call returns a review prompt for you to execute (prepare phase). Then call again with mode "apply" and your output. Pass `force: true` to run before the cadence gate.',
   inputSchema: {
     type: "object",
     properties: {
@@ -14055,6 +14631,21 @@ When updating a doc, add or update a review header immediately below the title:
 
 Replace \`task-NNN\` with the task ID that triggered the update, and \`DD-MM-YYYY\` with today's date.
 
+## Session Start
+
+When a conversation starts \u2014 fresh window, new session, or after context compression \u2014 orient before doing anything else:
+
+1. **Run \`orient\`** \u2014 single call that returns cycle number, task counts, in-progress/in-review tasks, strategy review cadence, trends, and recommended next action.
+2. **Fix orphaned tasks silently** \u2014 check for feat/task-XXX branches that don't match board status. Fix and report after.
+3. **Summarise:** "You're on Cycle N. X tasks to build, Y builds pending review." or "Cycle N is complete \u2014 ready for the next plan."
+4. **Run \`build_list\` when picking a task** \u2014 \`orient\` shows counts only. \`build_list\` shows the full task list with handoffs.
+
+**CRITICAL: Check task statuses before acting.**
+- **In Review** = already built. Suggest \`review_list\` \u2192 \`review_submit\`. **NEVER re-build an In Review task.**
+- **In Progress** = build started but not completed. Check the branch and existing changes before writing new code.
+- **Backlog** = not started. But first check if a \`feat/task-XXX\` branch already exists with commits \u2014 fix it, don't rebuild.
+- If all cycle tasks are Done, suggest \`release\` or next \`plan\`.
+
 ## Workflow Sequences
 
 PAPI tools follow structured flows. The agent manages the cycle workflow automatically \u2014 the user should never need to type tool names or remember the flow. Handle the plumbing, surface the summaries.
@@ -14100,6 +14691,15 @@ strategy_review \u2192 strategy_change
   Next: \`strategy_change\` if the review recommends adjustments.
 - **strategy_change** \u2014 Updates active decisions, north star, or project direction based on review findings.
 
+### Detect Strategic Decisions in Conversation
+
+Watch for: direction changes, architecture shifts, deprioritisation with reasoning, new principles, competitive positioning decisions.
+
+When detected:
+1. Flag it: "That sounds like a strategic direction change \u2014 should I run \`strategy_change\`?"
+2. If confirmed, run \`strategy_change\` immediately.
+3. If mid-build, finish the current task first.
+
 ### Idea Capture
 
 \`\`\`
@@ -14199,6 +14799,7 @@ When the system compresses prior messages, immediately:
 - **XS/S tasks in the same cycle and module:** Group on shared branch. One PR, one merge.
 - **M/L tasks or different modules:** Own branch per task. Isolated PRs.
 - **Commit per task within grouped branches** \u2014 traceable git history.
+- **Never use \`build_execute\` with \`light=true\` on shared branches.** Light mode commits directly to the current branch without creating a PR. When a shared branch is squash-merged, those commits are collapsed \u2014 any CLAUDE.md or documentation changes are stripped. Use light mode only on isolated single-task branches where no squash-merge will occur.
 
 ## Quick Work vs PAPI Work
 
@@ -14211,6 +14812,9 @@ PAPI is for planned work. Quick fixes \u2014 just do them. No need for plan or b
 - **Use MCP tools for all project data operations.** DB is the source of truth when using the pg adapter.
 - Do NOT read \`.papi/\` files for context \u2014 use MCP tools.
 - \`.papi/\` files may be stale when using pg adapter. This is expected.
+- **\`board_edit\` never updates the \`cycle\` field.** When moving a task into or out of a cycle, always run a SQL update alongside \`board_edit\`:
+  - Adding to current cycle: \`UPDATE cycle_tasks SET cycle = <N> WHERE display_id = '<task-id>';\`
+  - Removing from cycle (backlog): \`UPDATE cycle_tasks SET cycle = null WHERE display_id = '<task-id>';\`
 
 ## Code Before Claims \u2014 No Assumptions
 
@@ -14244,6 +14848,9 @@ These rules come from 80+ cycles of dogfooding. They prevent the most common sou
 - **Telemetry opt-out.** PAPI collects anonymous usage data (tool name, duration, project ID). To disable, add \`"PAPI_TELEMETRY": "off"\` to the \`env\` block in your \`.mcp.json\`.
 
 ### Planning & Scope
+- **NEVER run \`plan\` more than once per cycle.** Adjust the cycle with \`board_deprioritise\` or \`idea\` instead.
+- **NEVER skip cycles.** Complete and release the current cycle before running the next \`plan\`.
+- **Only build tasks assigned to the current cycle.** Use \`build_list\` \u2014 it filters to current-cycle tasks with handoffs.
 - **Don't ask premature questions.** If the project is in early cycles, don't ask about deployment accounts, hosting providers, OAuth setup, or commercial features. Focus on building core functionality first.
 - **Split large ideas.** If an idea has 3+ concerns, submit it as 2-3 separate ideas so the planner creates properly scoped tasks \u2014 not kitchen-sink handoffs.
 - **Auto-release completed cycles.** When all cycle tasks are Done and reviews accepted, run \`release\` immediately. Forgetting causes cycle number drift and merge conflicts in the next session.
@@ -14475,6 +15082,17 @@ async function scaffoldPapiDir(adapter2, config2, input) {
         await writeFile2(join3(config2.papiDir, filename), content, "utf-8");
       }
     }
+  } else {
+    try {
+      const existingBrief = await adapter2.readProductBrief();
+      if (!existingBrief.trim()) {
+        const templateContent = substitute(PRODUCT_BRIEF_TEMPLATE, vars);
+        await adapter2.updateProductBrief(templateContent);
+      } else {
+        return false;
+      }
+    } catch {
+    }
   }
   const commandsDir = join3(config2.projectRoot, ".claude", "commands");
   const docsDir = join3(config2.projectRoot, "docs");
@@ -14786,7 +15404,7 @@ async function prepareSetup(adapter2, config2, input) {
     );
   }
   const TEMPLATE_MARKER = "*Describe your project's core value proposition here.*";
-  if (!existingBrief.includes(TEMPLATE_MARKER) && !input.force) {
+  if (existingBrief.trim() && !existingBrief.includes(TEMPLATE_MARKER) && !input.force) {
     throw new Error("PRODUCT_BRIEF.md already contains a generated Product Brief. Running setup again would overwrite it.\n\nTo proceed anyway, run setup with force: true.");
   }
   let codebaseSummary;
@@ -15200,7 +15818,7 @@ init_dist2();
 
 // src/services/build.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import { readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { readdirSync as readdirSync2, existsSync as existsSync2, readFileSync } from "fs";
 import { join as join4 } from "path";
 function capitalizeCompleted(value) {
   const map = {
@@ -15414,6 +16032,34 @@ async function startBuild(adapter2, config2, taskId, options = {}) {
   }
   return { task, branchLines, phaseChanges };
 }
+var VALID_DOC_TYPES = /* @__PURE__ */ new Set(["research", "audit", "spec", "guide", "architecture", "positioning", "framework", "reference"]);
+function extractDocMeta(absolutePath, relativePath, cycleNumber) {
+  let title = relativePath.split("/").pop()?.replace(".md", "") ?? relativePath;
+  let type = "reference";
+  let cycle = cycleNumber;
+  let summary = "Auto-registered \u2014 no summary available. Update via doc_register.";
+  if (relativePath.startsWith("docs/research/")) type = "research";
+  else if (relativePath.startsWith("docs/architecture/")) type = "architecture";
+  else if (relativePath.startsWith("docs/audits/")) type = "audit";
+  try {
+    const content = readFileSync(absolutePath, "utf-8").slice(0, 2e3);
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      const fm = fmMatch[1];
+      const titleMatch = fm.match(/^title:\s*["']?(.+?)["']?\s*$/m);
+      if (titleMatch) title = titleMatch[1].trim();
+      const typeMatch = fm.match(/^type:\s*(\S+)/m);
+      if (typeMatch && VALID_DOC_TYPES.has(typeMatch[1])) type = typeMatch[1];
+      const cycleMatch = fm.match(/^cycle:\s*(\d+)/m);
+      if (cycleMatch) cycle = parseInt(cycleMatch[1], 10);
+    } else {
+      const headingMatch = content.match(/^#+\s+(.+)$/m);
+      if (headingMatch) title = headingMatch[1].trim();
+    }
+  } catch {
+  }
+  return { title, type, cycle, summary, tags: [] };
+}
 async function completeBuild(adapter2, config2, taskId, input, options = {}) {
   const task = await adapter2.getTask(taskId);
   if (!task) {
@@ -15497,6 +16143,18 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
       }
     }
   }
+  if (adapter2.updateCycleLearningActionRef && task.notes) {
+    const learningRefs = task.notes.match(/learning:([a-f0-9-]+)/gi);
+    if (learningRefs) {
+      for (const ref of learningRefs) {
+        const learningId = ref.split(":")[1];
+        try {
+          await adapter2.updateCycleLearningActionRef(learningId, task.id);
+        } catch {
+        }
+      }
+    }
+  }
   if (report.relatedDecisions && report.relatedDecisions.length > 0) {
     for (const adId of report.relatedDecisions) {
       try {
@@ -15564,21 +16222,51 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
     if (adapter2.searchDocs) {
       const docsDir = join4(config2.projectRoot, "docs");
       if (existsSync2(docsDir)) {
-        const scanDir = (dir) => {
+        const scanDir = (dir, depth = 0) => {
+          if (depth > 8) return [];
           const entries = readdirSync2(dir, { withFileTypes: true });
           const files = [];
           for (const e of entries) {
             const full = join4(dir, e.name);
-            if (e.isDirectory()) files.push(...scanDir(full));
+            if (e.isDirectory() && !e.isSymbolicLink()) files.push(...scanDir(full, depth + 1));
             else if (e.name.endsWith(".md")) files.push(full.replace(config2.projectRoot + "/", ""));
           }
           return files;
         };
         const mdFiles = scanDir(docsDir);
-        const registered = await adapter2.searchDocs({ status: "active", limit: 500 });
+        const registered = await adapter2.searchDocs({ status: "all", limit: 500 });
         const registeredPaths = new Set(registered.map((d) => d.path));
         const unregistered = mdFiles.filter((f) => !registeredPaths.has(f));
-        if (unregistered.length > 0) {
+        if (unregistered.length > 0 && adapter2.registerDoc) {
+          const autoRegistered = [];
+          const failed = [];
+          for (const docPath of unregistered) {
+            try {
+              const meta = extractDocMeta(join4(config2.projectRoot, docPath), docPath, cycleNumber);
+              await adapter2.registerDoc({
+                title: meta.title,
+                type: meta.type,
+                path: docPath,
+                status: "active",
+                summary: meta.summary,
+                tags: meta.tags,
+                cycleCreated: meta.cycle,
+                cycleUpdated: meta.cycle
+              });
+              autoRegistered.push(docPath);
+            } catch {
+              failed.push(docPath);
+            }
+          }
+          const parts = [];
+          if (autoRegistered.length > 0) {
+            parts.push(`\u{1F4C4} Auto-registered ${autoRegistered.length} doc(s): ${autoRegistered.slice(0, 3).join(", ")}${autoRegistered.length > 3 ? ` (+${autoRegistered.length - 3} more)` : ""}`);
+          }
+          if (failed.length > 0) {
+            parts.push(`${failed.length} doc(s) failed auto-registration \u2014 run doc_register manually: ${failed.slice(0, 3).join(", ")}`);
+          }
+          docWarning = parts.join(" | ") || void 0;
+        } else if (unregistered.length > 0) {
           docWarning = `${unregistered.length} unregistered doc(s) in docs/ \u2014 consider running \`doc_register\` for: ${unregistered.slice(0, 5).join(", ")}${unregistered.length > 5 ? ` (+${unregistered.length - 5} more)` : ""}`;
         }
       }
@@ -15712,7 +16400,7 @@ var buildDescribeTool = {
 };
 var buildExecuteTool = {
   name: "build_execute",
-  description: "Start or complete a build task. Call with just task_id to start (returns BUILD HANDOFF, creates feature branch, marks In Progress). After implementing the task, you MUST call build_execute again with all report fields (completed, effort, estimated_effort, surprises, discovered_issues, architecture_notes) to finish \u2014 do not wait for user confirmation between start and complete. Does not call the Anthropic API. Set light=true to skip branch/PR creation (commits to current branch). Set PAPI_LIGHT_MODE=true in env to default all builds to light mode.",
+  description: "Start or complete a build task. Call with just task_id to start (returns BUILD HANDOFF, creates feature branch, marks In Progress). After implementing the task, you MUST call build_execute again with all report fields (completed, effort, estimated_effort, surprises, discovered_issues, architecture_notes) to finish \u2014 do not wait for user confirmation between start and complete. Never call on tasks that are already In Review or Done. Does not call the Anthropic API. Set light=true to skip branch/PR creation (commits to current branch). Set PAPI_LIGHT_MODE=true in env to default all builds to light mode.",
   inputSchema: {
     type: "object",
     properties: {
@@ -16374,10 +17062,25 @@ ${lines.join("\n")}
   const VALID_COMPLEXITIES2 = /* @__PURE__ */ new Set(["XS", "Small", "Medium", "Large", "XL"]);
   const priority = input.priority && VALID_PRIORITIES2.has(input.priority) ? input.priority : "P2 Medium";
   const complexity = input.complexity && VALID_COMPLEXITIES2.has(input.complexity) ? input.complexity : "Small";
+  const PREFIX_MAP = {
+    bug: "bug",
+    research: "research",
+    feedback: "feedback"
+  };
+  let taskTitle = input.text;
+  let taskType = "idea";
+  const prefixMatch = input.text.match(/^\[([a-zA-Z]+)\]\s*/);
+  if (prefixMatch) {
+    const key = prefixMatch[1].toLowerCase();
+    if (key in PREFIX_MAP) {
+      taskType = PREFIX_MAP[key];
+      taskTitle = input.text.slice(prefixMatch[0].length);
+    }
+  }
   const task = await adapter2.createTask({
     uuid: randomUUID10(),
     displayId: "",
-    title: input.text,
+    title: taskTitle,
     status: "Backlog",
     priority,
     complexity,
@@ -16388,10 +17091,22 @@ ${lines.join("\n")}
     reviewed: false,
     createdCycle: health.totalCycles,
     notes: input.notes || "",
-    taskType: "idea",
+    taskType,
     maturity: "raw",
     docRef: input.docRef
   });
+  if (input.notes && adapter2.updateCycleLearningActionRef) {
+    const learningRefs = input.notes.match(/learning:([a-f0-9-]+)/gi);
+    if (learningRefs) {
+      for (const ref of learningRefs) {
+        const learningId = ref.split(":")[1];
+        try {
+          await adapter2.updateCycleLearningActionRef(learningId, task.id);
+        } catch {
+        }
+      }
+    }
+  }
   if (input.notes && adapter2.updateDogfoodEntryStatus) {
     const dogfoodRefs = input.notes.match(/dogfood:([a-f0-9-]+)/gi);
     if (dogfoodRefs) {
@@ -17234,13 +17949,37 @@ async function handleBoardReconcile(adapter2, config2, args) {
     if (context === "No backlog tasks to reconcile.") {
       return textResponse(context);
     }
+    let mismatchSection = "";
+    try {
+      const allTasks = await adapter2.queryBoard();
+      const mismatches = detectBoardMismatches(config2.projectRoot, allTasks);
+      if (mismatches.codeAhead.length > 0 || mismatches.staleInProgress.length > 0) {
+        const lines = ["### Code-Ahead-of-Status Mismatches", ""];
+        if (mismatches.codeAhead.length > 0) {
+          lines.push("**Branch merged but task still Backlog** \u2014 these tasks likely built outside PAPI tracking:");
+          for (const m of mismatches.codeAhead) {
+            lines.push(`- **${m.displayId}**: ${m.title} (branch \`${m.branch}\` merged to main)`);
+          }
+          lines.push("");
+        }
+        if (mismatches.staleInProgress.length > 0) {
+          lines.push("**In Progress but no feature branch** \u2014 may be stale or built without build_execute:");
+          for (const m of mismatches.staleInProgress) {
+            lines.push(`- **${m.displayId}**: ${m.title}`);
+          }
+          lines.push("");
+        }
+        mismatchSection = lines.join("\n") + "\n";
+      }
+    } catch {
+    }
     return textResponse(
       `${RECONCILE_PROMPT}
 ---
 
 ### Backlog Context
 
-${context}
+${mismatchSection}${context}
 ---
 
 Analyze the backlog above and produce your reconciliation output. Then call \`board_reconcile\` with mode "apply".`
@@ -17978,7 +18717,7 @@ var reviewListTool = {
 };
 var reviewSubmitTool = {
   name: "review_submit",
-  description: "Record your feedback on a task plan (handoff-review) or completed build (build-acceptance). Approve it, suggest changes, or reject it. Updates task status based on your decision. On handoff-review with suggested changes, returns a prompt to revise the BUILD HANDOFF.",
+  description: "Record a review verdict on a completed build (build-acceptance) or task plan (handoff-review). ALWAYS ask the human for their verdict before calling \u2014 never auto-submit without human input. Accept moves the task to Done, request-changes sends it back for rework, reject discards the build. Updates task status based on the verdict. On handoff-review with suggested changes, returns a prompt to revise the BUILD HANDOFF.",
   inputSchema: {
     type: "object",
     properties: {
@@ -18367,21 +19106,22 @@ Path: ${mcpJsonPath}`
 
 // src/tools/orient.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4 } from "fs";
 import { join as join7 } from "path";
 var orientTool = {
   name: "orient",
-  description: "Session orientation \u2014 single call that replaces build_list + health. Returns: cycle number, task counts by status, in-progress/in-review tasks, strategy review cadence, velocity snapshot, and recommended next action. Read-only, does not modify any files.",
+  description: "Session orientation \u2014 run this FIRST at session start before any other tool. Single call that replaces build_list + health. Returns: cycle number, task counts by status, in-progress/in-review tasks, strategy review cadence, velocity snapshot, recommended next action, and a release reminder when all cycle tasks are Done but release has not run. Read-only, does not modify any files.",
   inputSchema: {
     type: "object",
     properties: {},
     required: []
   }
 };
-function formatOrientSummary(health, buildInfo, hierarchy) {
+function formatOrientSummary(health, buildInfo, hierarchy, latestTag) {
   const lines = [];
   const cycleIsComplete = health.latestCycleStatus === "complete";
-  lines.push(`# Cycle ${health.cycleNumber}${cycleIsComplete ? " (complete)" : ""} \u2014 Orient`);
+  const tagSuffix = latestTag ? ` \u2014 ${latestTag}` : "";
+  lines.push(`# Cycle ${health.cycleNumber}${cycleIsComplete ? " (complete)" : ""}${tagSuffix} \u2014 Orient`);
   lines.push("");
   if (health.connectionStatus !== "offline") {
     const statusIcon = health.connectionStatus === "connected" ? "\u2713" : "\u26A0\uFE0F";
@@ -18517,10 +19257,22 @@ async function getHierarchyPosition(adapter2) {
     return void 0;
   }
 }
+function getLatestGitTag(projectRoot) {
+  try {
+    return execFileSync3("git", ["describe", "--tags", "--abbrev=0"], {
+      encoding: "utf-8",
+      cwd: projectRoot,
+      timeout: 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
 function checkNpmVersionDrift() {
   try {
     const pkgPath = join7(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     const localVersion = pkg.version;
     const packageName = pkg.name;
     const published = execFileSync3("npm", ["view", packageName, "version"], {
@@ -18556,6 +19308,10 @@ async function handleOrient(adapter2, config2) {
     const cycleInCycle = cycleIsComplete ? 0 : allTasks.filter((t) => t.cycle === currentCycle && t.status === "In Cycle").length;
     const cycleReady = cycleIsComplete ? 0 : allTasks.filter((t) => t.cycle === currentCycle && t.status === "Ready").length;
     const cycleTotal = cycleInProgress + cycleInReview + cycleBacklog + cycleInCycle + cycleReady;
+    const cycleDone = cycleIsComplete ? 0 : allTasks.filter((t) => t.cycle === currentCycle && t.status === "Done").length;
+    if (!cycleIsComplete && cycleTotal === 0 && cycleDone > 0) {
+      buildResult.warnings.unshift(`\u26A0\uFE0F Cycle ${currentCycle} is complete \u2014 all ${cycleDone} task${cycleDone !== 1 ? "s" : ""} Done. Release has not been run. Run \`release\` now.`);
+    }
     const inProgressItems = buildResult.inProgress.map(
       (t) => `- **${t.id}:** ${t.title} (${t.priority} | ${t.complexity})`
     );
@@ -18588,9 +19344,25 @@ async function handleOrient(adapter2, config2) {
       } catch {
       }
     }
+    const latestTag = getLatestGitTag(config2.projectRoot);
     const versionDrift = checkNpmVersionDrift();
     const versionNote = versionDrift ? `
 ${versionDrift}` : "";
+    let reconciliationNote = "";
+    try {
+      const mismatches = detectBoardMismatches(config2.projectRoot, allTasks);
+      if (mismatches.codeAhead.length > 0 || mismatches.staleInProgress.length > 0) {
+        const lines = ["\n\n## Reconciliation"];
+        for (const m of mismatches.codeAhead) {
+          lines.push(`\u26A0\uFE0F **${m.displayId}** \u2014 branch \`${m.branch}\` merged to main but task is still Backlog. Run \`board_edit\` to mark Done.`);
+        }
+        for (const m of mismatches.staleInProgress) {
+          lines.push(`\u26A0\uFE0F **${m.displayId}** \u2014 In Progress but no feature branch found. May be stale or built without \`build_execute\`.`);
+        }
+        reconciliationNote = lines.join("\n");
+      }
+    } catch {
+    }
     let recsNote = "";
     try {
       const pendingRecs = await adapter2.getPendingRecommendations();
@@ -18624,7 +19396,7 @@ ${versionDrift}` : "";
       }
     } catch {
     }
-    return textResponse(formatOrientSummary(healthResult, buildInfo, hierarchy) + ttfvNote + recsNote + pendingReviewNote + patternsNote + versionNote + enrichmentNote);
+    return textResponse(formatOrientSummary(healthResult, buildInfo, hierarchy, latestTag) + ttfvNote + reconciliationNote + recsNote + pendingReviewNote + patternsNote + versionNote + enrichmentNote);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return errorResponse(`Orient failed: ${message}`);
@@ -18633,7 +19405,7 @@ ${versionDrift}` : "";
 function enrichClaudeMd(projectRoot, cycleNumber) {
   const claudeMdPath = join7(projectRoot, "CLAUDE.md");
   if (!existsSync4(claudeMdPath)) return "";
-  const content = readFileSync(claudeMdPath, "utf-8");
+  const content = readFileSync2(claudeMdPath, "utf-8");
   const additions = [];
   if (cycleNumber >= 6 && !content.includes(CLAUDE_MD_ENRICHMENT_SENTINEL_T1)) {
     additions.push(CLAUDE_MD_TIER_1);
@@ -19119,7 +19891,7 @@ ${result.userMessage}
 }
 
 // src/tools/doc-registry.ts
-import { readdirSync as readdirSync3, existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { readdirSync as readdirSync3, existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import { join as join8, relative } from "path";
 import { homedir as homedir2 } from "os";
 var docRegisterTool = {
@@ -19279,7 +20051,7 @@ function scanMdFiles(dir, rootDir) {
 }
 function extractTitle(filePath) {
   try {
-    const content = readFileSync2(filePath, "utf-8").slice(0, 1e3);
+    const content = readFileSync3(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);
@@ -19293,7 +20065,7 @@ async function handleDocScan(adapter2, config2, args) {
     return errorResponse("Doc registry not available \u2014 requires pg adapter.");
   }
   const includePlans = args.include_plans ?? false;
-  const registered = await adapter2.searchDocs({ limit: 500 });
+  const registered = await adapter2.searchDocs({ limit: 500, status: "all" });
   const registeredPaths = new Set(registered.map((d) => d.path));
   const docsDir = join8(config2.projectRoot, "docs");
   const docsFiles = scanMdFiles(docsDir, config2.projectRoot);