@papi-ai/server 0.7.40 → 0.7.41

package/dist/index.js

@@ -22,6 +22,7 @@ __export(git_exports, {
   cycleBranchName: () => cycleBranchName,
   deleteLocalBranch: () => deleteLocalBranch,
   detectBoardMismatches: () => detectBoardMismatches,
+  detectMergedInProgress: () => detectMergedInProgress,
   detectUnrecordedCommits: () => detectUnrecordedCommits,
   ensureLatestDevelop: () => ensureLatestDevelop,
   ensureTagAtHead: () => ensureTagAtHead,
@@ -63,6 +64,7 @@ __export(git_exports, {
   normalizeGitUrl: () => normalizeGitUrl,
   pickModuleCycleBranch: () => pickModuleCycleBranch,
   resolveBaseBranch: () => resolveBaseBranch,
+  resolveDefaultBranch: () => resolveDefaultBranch,
   runAutoCommit: () => runAutoCommit,
   squashMergePullRequest: () => squashMergePullRequest,
   stageAllAndCommit: () => stageAllAndCommit,
@@ -660,6 +662,22 @@ function resolveBaseBranch(cwd, preferred) {
   if (preferred !== "master" && branchExists(cwd, "master")) return "master";
   return preferred;
 }
+function resolveDefaultBranch(cwd, preferred) {
+  try {
+    const ref = execFileSync(
+      "git",
+      ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+      { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    const name = ref.replace(/^origin\//, "");
+    if (name && branchExists(cwd, name)) return name;
+  } catch {
+  }
+  for (const candidate of [preferred, "main", "master", "trunk"]) {
+    if (candidate && branchExists(cwd, candidate)) return candidate;
+  }
+  return preferred;
+}
 function detectBoardMismatches(cwd, tasks) {
   const empty = { codeAhead: [], staleInProgress: [] };
   if (!isGitAvailable() || !isGitRepo(cwd)) return empty;
@@ -693,6 +711,46 @@ function detectBoardMismatches(cwd, tasks) {
     return empty;
   }
 }
+function escapeRegexLiteral(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function detectMergedInProgress(cwd, preferredBase, tasks) {
+  if (!isGitAvailable() || !isGitRepo(cwd)) return [];
+  const inProgress = tasks.filter((t) => t.status === "In Progress");
+  if (inProgress.length === 0) return [];
+  const base = resolveDefaultBranch(cwd, preferredBase);
+  if (!branchExists(cwd, base)) return [];
+  let raw;
+  try {
+    raw = execFileSync(
+      "git",
+      ["log", base, "--format=%h%x01%s", "-n", "1000"],
+      { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+  } catch {
+    return [];
+  }
+  const commits = raw.split("\n").map((line) => {
+    const idx = line.indexOf("
");
+    if (idx === -1) return null;
+    return { hash: line.slice(0, idx).trim(), subject: line.slice(idx + 1).trim() };
+  }).filter((c) => c !== null && c.hash !== "");
+  const hits = [];
+  for (const task of inProgress) {
+    const re = new RegExp(`(^|[^\\w-])${escapeRegexLiteral(task.displayId)}([^\\w-]|$)`);
+    const hit = commits.find((c) => re.test(c.subject));
+    if (!hit) continue;
+    const prMatch = hit.subject.match(/#(\d+)/);
+    hits.push({
+      displayId: task.displayId,
+      title: task.title,
+      commit: hit.hash,
+      subject: hit.subject,
+      pr: prMatch ? `#${prMatch[1]}` : null
+    });
+  }
+  return hits;
+}
 function detectUnrecordedCommits(cwd, baseBranch) {
   if (!isGitAvailable() || !isGitRepo(cwd)) return [];
   const latestTag = getLatestTag(cwd);
@@ -1256,6 +1314,13 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
       updateTaskStatus(id, status) {
         return this.invoke("updateTaskStatus", [id, status]);
       }
+      // task-2292: cross-project move. The bound projectId (set on this adapter) is
+      // the SOURCE; the target is passed in args. Ownership of BOTH projects is
+      // verified server-side in the edge function from the bearer — callerUserId is
+      // ignored here (cannot be spoofed). The edge resolves a target slug → UUID.
+      moveTask(taskId, targetProject, _callerUserId) {
+        return this.invoke("moveTask", [taskId, targetProject]);
+      }
       // task-2155 (MU-3 task B): hosted/proxy claim write-path. The data-proxy gates
       // these via WRITE_METHODS (active editor may write, viewer cannot) and binds the
       // assignee to the bearer-derived caller server-side — the assigneeId passed here
@@ -1712,9 +1777,9 @@ var init_query = __esm({
     CLOSE = {};
     Query = class extends Promise {
       constructor(strings, args, handler, canceller, options = {}) {
-        let resolve2, reject;
+        let resolve3, reject;
         super((a, b2) => {
-          resolve2 = a;
+          resolve3 = a;
           reject = b2;
         });
         this.tagged = Array.isArray(strings.raw);
@@ -1725,7 +1790,7 @@ var init_query = __esm({
         this.options = options;
         this.state = null;
         this.statement = null;
-        this.resolve = (x) => (this.active = false, resolve2(x));
+        this.resolve = (x) => (this.active = false, resolve3(x));
         this.reject = (x) => (this.active = false, reject(x));
         this.active = false;
         this.cancelled = null;
@@ -1773,12 +1838,12 @@ var init_query = __esm({
               if (this.executed && !this.active)
                 return { done: true };
               prev && prev();
-              const promise = new Promise((resolve2, reject) => {
+              const promise = new Promise((resolve3, reject) => {
                 this.cursorFn = (value) => {
-                  resolve2({ value, done: false });
+                  resolve3({ value, done: false });
                   return new Promise((r) => prev = r);
                 };
-                this.resolve = () => (this.active = false, resolve2({ done: true }));
+                this.resolve = () => (this.active = false, resolve3({ done: true }));
                 this.reject = (x) => (this.active = false, reject(x));
               });
               this.execute();
@@ -2376,12 +2441,12 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     x.on("drain", drain);
     return x;
   }
-  async function cancel({ pid, secret }, resolve2, reject) {
+  async function cancel({ pid, secret }, resolve3, reject) {
     try {
       cancelMessage = bytes_default().i32(16).i32(80877102).i32(pid).i32(secret).end(16);
       await connect();
       socket.once("error", reject);
-      socket.once("close", resolve2);
+      socket.once("close", resolve3);
     } catch (error2) {
       reject(error2);
     }
@@ -3398,7 +3463,7 @@ var init_subscribe = __esm({
 // ../../node_modules/postgres/src/large.js
 import Stream2 from "stream";
 function largeObject(sql, oid, mode = 131072 | 262144) {
-  return new Promise(async (resolve2, reject) => {
+  return new Promise(async (resolve3, reject) => {
     await sql.begin(async (sql2) => {
       let finish;
       !oid && ([{ oid }] = await sql2`select lo_creat(-1) as oid`);
@@ -3424,7 +3489,7 @@ function largeObject(sql, oid, mode = 131072 | 262144) {
           ) seek
         `
       };
-      resolve2(lo);
+      resolve3(lo);
       return new Promise(async (r) => finish = r);
       async function readable({
         highWaterMark = 2048 * 8,
@@ -3589,8 +3654,8 @@ function Postgres(a, b2) {
   }
   async function reserve() {
     const queue = queue_default();
-    const c = open.length ? open.shift() : await new Promise((resolve2, reject) => {
-      const query = { reserve: resolve2, reject };
+    const c = open.length ? open.shift() : await new Promise((resolve3, reject) => {
+      const query = { reserve: resolve3, reject };
       queries.push(query);
       closed.length && connect(closed.shift(), query);
     });
@@ -3627,9 +3692,9 @@ function Postgres(a, b2) {
       let uncaughtError, result;
       name && await sql2`savepoint ${sql2(name)}`;
       try {
-        result = await new Promise((resolve2, reject) => {
+        result = await new Promise((resolve3, reject) => {
           const x = fn2(sql2);
-          Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve2, reject);
+          Promise.resolve(Array.isArray(x) ? Promise.all(x) : x).then(resolve3, reject);
         });
         if (uncaughtError)
           throw uncaughtError;
@@ -3686,8 +3751,8 @@ function Postgres(a, b2) {
     return c.execute(query) ? move(c, busy) : move(c, full);
   }
   function cancel(query) {
-    return new Promise((resolve2, reject) => {
-      query.state ? query.active ? connection_default(options).cancel(query.state, resolve2, reject) : query.cancelled = { resolve: resolve2, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve2());
+    return new Promise((resolve3, reject) => {
+      query.state ? query.active ? connection_default(options).cancel(query.state, resolve3, reject) : query.cancelled = { resolve: resolve3, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve3());
     });
   }
   async function end({ timeout = null } = {}) {
@@ -3706,11 +3771,11 @@ function Postgres(a, b2) {
   async function close() {
     await Promise.all(connections.map((c) => c.end()));
   }
-  async function destroy(resolve2) {
+  async function destroy(resolve3) {
     await Promise.all(connections.map((c) => c.terminate()));
     while (queries.length)
       queries.shift().reject(Errors.connection("CONNECTION_DESTROYED", options));
-    resolve2();
+    resolve3();
   }
   function connect(c, query) {
     move(c, connecting);
@@ -3894,9 +3959,9 @@ __export(doctor_exports, {
   __testing: () => __testing,
   runDoctor: () => runDoctor
 });
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function redact(name, value) {
   if (!value) return "(empty)";
   if (SECRET_VARS.has(name)) {
@@ -3907,14 +3972,14 @@ function redact(name, value) {
 }
 function findMcpJson() {
   const candidates = [
-    join18(process.cwd(), ".mcp.json"),
-    join18(homedir4(), ".claude", ".mcp.json"),
-    join18(homedir4(), ".mcp.json")
+    join19(process.cwd(), ".mcp.json"),
+    join19(homedir4(), ".claude", ".mcp.json"),
+    join19(homedir4(), ".mcp.json")
   ];
   for (const path7 of candidates) {
-    if (!existsSync9(path7)) continue;
+    if (!existsSync10(path7)) continue;
     try {
-      const raw = readFileSync10(path7, "utf-8");
+      const raw = readFileSync11(path7, "utf-8");
       const parsed = JSON.parse(raw);
       const papiEntry = parsed.papi ?? parsed.mcpServers?.papi;
       if (!papiEntry) continue;
@@ -4188,17 +4253,17 @@ __export(reset_exports, {
   removePapiEntry: () => removePapiEntry,
   runReset: () => runReset
 });
-import { existsSync as existsSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 import { createInterface } from "readline/promises";
 function findResetTarget() {
   for (const path7 of CANDIDATE_PATHS()) {
-    if (!existsSync10(path7)) continue;
+    if (!existsSync11(path7)) continue;
     let raw;
     let parsed;
     try {
-      raw = readFileSync11(path7, "utf-8");
+      raw = readFileSync12(path7, "utf-8");
       parsed = JSON.parse(raw);
     } catch {
       continue;
@@ -4286,9 +4351,9 @@ var init_reset = __esm({
   "src/cli/reset.ts"() {
     "use strict";
     CANDIDATE_PATHS = () => [
-      join19(process.cwd(), ".mcp.json"),
-      join19(homedir5(), ".claude", ".mcp.json"),
-      join19(homedir5(), ".mcp.json")
+      join20(process.cwd(), ".mcp.json"),
+      join20(homedir5(), ".claude", ".mcp.json"),
+      join20(homedir5(), ".mcp.json")
     ];
   }
 });
@@ -4299,9 +4364,9 @@ __export(audit_exports, {
   __testing: () => __testing2,
   runAudit: () => runAudit
 });
-import { existsSync as existsSync11, readFileSync as readFileSync12, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync13, readdirSync as readdirSync7 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function safeListDirs(dir) {
   try {
     return readdirSync7(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort((a, b2) => a.localeCompare(b2));
@@ -4317,10 +4382,10 @@ function safeListFiles(dir, ext) {
   }
 }
 function readMcp(projectPath) {
-  const path7 = join20(projectPath, ".mcp.json");
-  if (!existsSync11(path7)) return { servers: [] };
+  const path7 = join21(projectPath, ".mcp.json");
+  if (!existsSync12(path7)) return { servers: [] };
   try {
-    const parsed = JSON.parse(readFileSync12(path7, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(path7, "utf-8"));
     const mcpServers = parsed.mcpServers ?? {};
     const servers = Object.keys(mcpServers);
     if (parsed.papi && !servers.includes("papi")) servers.push("papi");
@@ -4352,18 +4417,18 @@ function auditProjectSync(projectPath, name) {
     path: projectPath,
     papiProjectId,
     mcpServers: servers,
-    skills: safeListDirs(join20(projectPath, ".claude", "skills")),
-    agentSkills: safeListDirs(join20(projectPath, ".agents", "skills")),
-    agents: safeListFiles(join20(projectPath, ".claude", "agents"), ".md"),
-    hooks: safeListFiles(join20(projectPath, ".claude", "hooks"), ".sh")
+    skills: safeListDirs(join21(projectPath, ".claude", "skills")),
+    agentSkills: safeListDirs(join21(projectPath, ".agents", "skills")),
+    agents: safeListFiles(join21(projectPath, ".claude", "agents"), ".md"),
+    hooks: safeListFiles(join21(projectPath, ".claude", "hooks"), ".sh")
   };
 }
 function discoverProjects() {
   const out = [];
   for (const root of PROJECT_ROOTS) {
     for (const name of safeListDirs(root)) {
-      const path7 = join20(root, name);
-      if (existsSync11(join20(path7, ".mcp.json")) || existsSync11(join20(path7, ".claude"))) {
+      const path7 = join21(root, name);
+      if (existsSync12(join21(path7, ".mcp.json")) || existsSync12(join21(path7, ".claude"))) {
         out.push({ name, path: path7 });
       }
     }
@@ -4374,9 +4439,9 @@ function readGlobalSkills() {
   return safeListDirs(GLOBAL_SKILLS_DIR);
 }
 function readGlobalMcpServers() {
-  if (!existsSync11(GLOBAL_CLAUDE_JSON)) return [];
+  if (!existsSync12(GLOBAL_CLAUDE_JSON)) return [];
   try {
-    const parsed = JSON.parse(readFileSync12(GLOBAL_CLAUDE_JSON, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(GLOBAL_CLAUDE_JSON, "utf-8"));
     const servers = parsed.mcpServers ?? {};
     return Object.keys(servers).sort((a, b2) => a.localeCompare(b2));
   } catch {
@@ -4528,9 +4593,9 @@ var PROJECT_ROOTS, GLOBAL_SKILLS_DIR, GLOBAL_CLAUDE_JSON, IDLE_WINDOW_DAYS, GLOB
 var init_audit = __esm({
   "src/cli/audit.ts"() {
     "use strict";
-    PROJECT_ROOTS = [join20(homedir6(), "Ai-App-Projects"), join20(homedir6(), "android-projects")];
-    GLOBAL_SKILLS_DIR = join20(homedir6(), ".claude", "skills");
-    GLOBAL_CLAUDE_JSON = join20(homedir6(), ".claude.json");
+    PROJECT_ROOTS = [join21(homedir6(), "Ai-App-Projects"), join21(homedir6(), "android-projects")];
+    GLOBAL_SKILLS_DIR = join21(homedir6(), ".claude", "skills");
+    GLOBAL_CLAUDE_JSON = join21(homedir6(), ".claude.json");
     IDLE_WINDOW_DAYS = 30;
     GLOBALIZE_THRESHOLD = 3;
     __testing2 = { readMcp, computeFlags, formatReport: formatReport2, discoverProjects, auditProjectSync };
@@ -4542,8 +4607,8 @@ var setup_exports = {};
 __export(setup_exports, {
   runSetup: () => runSetup
 });
-import { existsSync as existsSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync6, chmodSync as chmodSync2, statSync as statSync5 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync6, chmodSync as chmodSync2, statSync as statSync6 } from "fs";
+import { join as join22 } from "path";
 function baseUrl() {
   const fromEnv = process.env["PAPI_HOST"] ?? process.env["PAPI_BASE_URL"];
   if (fromEnv) return fromEnv.replace(/\/$/, "");
@@ -4572,14 +4637,14 @@ async function postJson(url, body) {
   return { status: res.status, data };
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function writeMcpJson(opts) {
-  const path7 = join21(process.cwd(), ".mcp.json");
+  const path7 = join22(process.cwd(), ".mcp.json");
   let parsed = {};
-  if (existsSync12(path7)) {
+  if (existsSync13(path7)) {
     try {
-      parsed = JSON.parse(readFileSync13(path7, "utf-8"));
+      parsed = JSON.parse(readFileSync14(path7, "utf-8"));
     } catch {
       throw new Error(`.mcp.json at ${path7} is not valid JSON. Fix it or remove it before re-running setup.`);
     }
@@ -4602,7 +4667,7 @@ function writeMcpJson(opts) {
   parsed.mcpServers = mcpServers;
   writeFileSync6(path7, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
   try {
-    const mode = statSync5(path7).mode & 511;
+    const mode = statSync6(path7).mode & 511;
     if (mode !== 384) chmodSync2(path7, 384);
   } catch {
   }
@@ -4710,9 +4775,9 @@ var init_setup = __esm({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname5, join as join22 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname6, join as join23 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
 import {
@@ -4744,6 +4809,8 @@ var HELP_FOOTER_MD = `
 `;
 
 // src/config.ts
+var STRATEGY_REVIEW_OFFER_GAP = 5;
+var STRATEGY_REVIEW_BLOCK_GAP = 7;
 function loadConfig() {
   const projectArgIdx = process.argv.indexOf("--project");
   const configuredRoot = projectArgIdx !== -1 ? process.argv[projectArgIdx + 1] : process.env.PAPI_PROJECT_DIR;
@@ -7709,18 +7776,36 @@ Check PAPI_PROJECT_ID in your .mcp.json config. Find your project ID in the PAPI
 }
 
 // src/server.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { access as access4, readdir as readdir4, readFile as readFile9 } from "fs/promises";
-import { join as join17, dirname as dirname4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join18, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
   ListPromptsRequestSchema,
-  GetPromptRequestSchema
+  GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
+// src/universal-frame.ts
+var UNIVERSAL_FRAME = `PAPI gives this project a structured plan \u2192 build \u2192 review cycle, persisted across sessions. Follow it:
+
+1. ORIENT FIRST. At the start of every session, call \`orient\` (or \`papi\`) before anything else \u2014 it returns the current cycle, what's in flight, and the recommended next action. Re-run it after any context compression.
+
+2. THE CYCLE, IN ORDER: \`plan\` (once per cycle) \u2192 \`build_list\` (pick a task) \u2192 \`build_execute <task>\` to start \u2192 implement the task from its BUILD HANDOFF \u2192 \`build_execute\` again to complete with a build report \u2192 \`review_submit\` \u2192 \`release\` when every cycle task is done.
+
+3. STATUS DISCIPLINE. Check a task's status before acting. "In Review" = already built \u2014 never re-build it; submit a review instead. "In Progress" = a build started \u2014 check the existing branch before writing new code. "Backlog" = not started, but check for an existing feature branch first.
+
+4. STAY IN SCOPE. Build exactly what the BUILD HANDOFF specifies. Mechanical steps (branch creation, commits, status updates) are automatic \u2014 only "what to build" needs the user's confirmation.
+
+5. VERIFY BEFORE DONE. Test the change and confirm it works before reporting a task complete. Report failures honestly, with the output.
+
+PAPI reads and writes all project state through these tools \u2014 they are the source of truth, not local files.`;
+
 // src/lib/response.ts
 function textResponse(text, usage) {
   const result = {
@@ -11041,7 +11126,7 @@ ${lines.join("\n")}`;
     console.error(`[plan-perf] assembleContext (lean): ${JSON.stringify(timings)}ms`);
     const gap = health.cyclesSinceLastStrategyReview;
     const lastReviewCycle = health.totalCycles - gap;
-    const strategyReviewCadence = gap <= 0 ? `\u2713 Strategy review completed this cycle (C${health.totalCycles}). No carry-forward needed.` : gap < 5 ? `\u2713 Strategy review on track \u2014 last review was C${lastReviewCycle} (${gap} cycle(s) ago). Next due: C${lastReviewCycle + 5}.` : `\u26A0\uFE0F Strategy review overdue \u2014 last review was C${lastReviewCycle} (${gap} cycles ago). Due now.`;
+    const strategyReviewCadence = gap <= 0 ? `\u2713 Strategy review completed this cycle (C${health.totalCycles}). No carry-forward needed.` : gap < STRATEGY_REVIEW_OFFER_GAP ? `\u2713 Strategy review on track \u2014 last review was C${lastReviewCycle} (${gap} cycle(s) ago). Next due: C${lastReviewCycle + STRATEGY_REVIEW_OFFER_GAP}.` : gap < STRATEGY_REVIEW_BLOCK_GAP ? `\u25CB Strategy review available \u2014 last review was C${lastReviewCycle} (${gap} cycles ago). Offered now (optional); planning hard-blocks at ${STRATEGY_REVIEW_BLOCK_GAP} cycles.` : `\u26A0\uFE0F Strategy review overdue \u2014 last review was C${lastReviewCycle} (${gap} cycles ago). Planning is blocked until it runs (or \`force: true\`).`;
     let ctx2 = {
       mode,
       cycleNumber: health.totalCycles,
@@ -11231,7 +11316,7 @@ ${logLines}`);
   const preAssignedText = formatPreAssignedTasks(preAssigned, targetCycle);
   const gapFull = health.cyclesSinceLastStrategyReview;
   const lastReviewCycleFull = health.totalCycles - gapFull;
-  const strategyReviewCadenceFull = gapFull <= 0 ? `\u2713 Strategy review completed this cycle (C${health.totalCycles}). No carry-forward needed.` : gapFull < 5 ? `\u2713 Strategy review on track \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycle(s) ago). Next due: C${lastReviewCycleFull + 5}.` : `\u26A0\uFE0F Strategy review overdue \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycles ago). Due now.`;
+  const strategyReviewCadenceFull = gapFull <= 0 ? `\u2713 Strategy review completed this cycle (C${health.totalCycles}). No carry-forward needed.` : gapFull < STRATEGY_REVIEW_OFFER_GAP ? `\u2713 Strategy review on track \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycle(s) ago). Next due: C${lastReviewCycleFull + STRATEGY_REVIEW_OFFER_GAP}.` : gapFull < STRATEGY_REVIEW_BLOCK_GAP ? `\u25CB Strategy review available \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycles ago). Offered now (optional); planning hard-blocks at ${STRATEGY_REVIEW_BLOCK_GAP} cycles.` : `\u26A0\uFE0F Strategy review overdue \u2014 last review was C${lastReviewCycleFull} (${gapFull} cycles ago). Planning is blocked until it runs (or \`force: true\`).`;
   let ctx = {
     mode,
     cycleNumber: health.totalCycles,
@@ -11835,15 +11920,15 @@ Run \`review_submit\` to clear them, or pass \`force: true\` to bypass this bloc
       console.error(`[plan] ${note}`);
     }
     const gap = health.cyclesSinceLastStrategyReview;
-    if (gap >= 5 && !force) {
+    if (gap >= STRATEGY_REVIEW_BLOCK_GAP && !force) {
       const lastReviewCycle = cycleNumber - gap;
       throw new Error(
-        `Strategy Review gate \u2014 last review was Cycle ${lastReviewCycle}, current is Cycle ${cycleNumber} (${gap} cycles ago). A strategy review is required every 5 cycles before planning can continue.
+        `Strategy Review gate \u2014 last review was Cycle ${lastReviewCycle}, current is Cycle ${cycleNumber} (${gap} cycles ago). A strategy review is required at least every ${STRATEGY_REVIEW_BLOCK_GAP} cycles before planning can continue.
 
 Run \`strategy_review\` first, or pass \`force: true\` to bypass this gate.`
       );
     }
-    if (gap >= 5 && force) {
+    if (gap >= STRATEGY_REVIEW_BLOCK_GAP && force) {
       const lastReviewCycle = cycleNumber - gap;
       strategyReviewWarning = `> \u26A0\uFE0F **Strategy Review gate bypassed** (force: true) \u2014 last review was Cycle ${lastReviewCycle}, current is Cycle ${cycleNumber} (${gap} cycles ago). Run \`strategy_review\` after this cycle.
 
@@ -12416,8 +12501,6 @@ function getState(callerKey) {
 function callerKeyFromConfig(config2) {
   return config2.projectId ?? config2.userId ?? void 0;
 }
-var CONTEXT_BLOAT_CALL_THRESHOLD = 40;
-var ORIENT_GAP_MS = 3 * 60 * 60 * 1e3;
 var REVIEW_LIST_GUARD_WINDOW_MS = 15 * 60 * 1e3;
 var FAILURE_WINDOW_MS = 30 * 60 * 1e3;
 var FAILURE_RATE_THRESHOLD = 8;
@@ -12457,37 +12540,20 @@ function getProjectConnectionBanner(projectName, projectSlug) {
 function detectContextDegradation(now = Date.now(), callerKey) {
   const state = getState(callerKey);
   if (state.consecutiveFailures >= CONSECUTIVE_FAILURE_THRESHOLD) {
-    return `Context degradation (clash): ${state.consecutiveFailures} tool calls failed in a row \u2014 the session may be stuck on a contradiction. Consider a fresh window after this task.`;
+    return `${state.consecutiveFailures} tool calls failed in a row \u2014 the session may be stuck on a contradiction. Re-read the last error and re-check your assumptions before continuing.`;
   }
   const cutoff = now - FAILURE_WINDOW_MS;
   const recentFailures = state.failureTimestamps.filter((t) => t >= cutoff).length;
   if (recentFailures >= FAILURE_RATE_THRESHOLD) {
     const mins = Math.round(FAILURE_WINDOW_MS / 6e4);
-    return `Context degradation (distraction/confusion): ${recentFailures} tool failures in the last ${mins}min. A fresh window often clears this faster than pushing on.`;
+    return `${recentFailures} tool failures in the last ${mins}min \u2014 something's off. Re-read the last error and re-check your assumptions before continuing.`;
   }
   return null;
 }
 async function buildSessionGuidance(callerKey) {
-  const state = getState(callerKey);
   const signals = [];
   const degradation = detectContextDegradation(Date.now(), callerKey);
   if (degradation) signals.push(degradation);
-  if (state.toolCallCount > CONTEXT_BLOAT_CALL_THRESHOLD) {
-    signals.push(
-      `${state.toolCallCount} tool calls this session \u2014 context may be bloated. Consider starting a fresh window.`
-    );
-  }
-  if (state.lastOrientAt && Date.now() - state.lastOrientAt > ORIENT_GAP_MS) {
-    const hours = Math.round((Date.now() - state.lastOrientAt) / (60 * 60 * 1e3));
-    signals.push(
-      `${hours}h since last orient \u2014 session may be stale. Consider a fresh window for best results.`
-    );
-  }
-  if (state.releaseSinceLastOrient) {
-    signals.push(
-      "Release just ran \u2014 start a fresh session before the next `plan` to keep planning context clean."
-    );
-  }
   return signals.slice(0, 3);
 }
 
@@ -15906,8 +15972,8 @@ ${existing}` : entry;
 }
 
 // src/services/setup.ts
-import { mkdir, writeFile as writeFile2, readFile as readFile4, readdir, access as access2, stat as stat2 } from "fs/promises";
-import { join as join5, basename, extname, dirname as dirname2 } from "path";
+import { mkdir, writeFile as writeFile2, readFile as readFile4, readdir, access as access2, stat as stat2, chmod } from "fs/promises";
+import { join as join7, basename, extname, dirname as dirname3 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
 // src/lib/detect-codebase.ts
@@ -15992,6 +16058,159 @@ function planBundleInstall(projectRoot, projectName, opts = {}) {
   return out;
 }
 
+// src/lib/design-bundle.ts
+import { readFileSync as readFileSync2, existsSync as existsSync4, statSync as statSync4 } from "fs";
+import { dirname as dirname2, join as join5, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var DESIGN_ASSETS = [
+  { srcRel: join5("agents", "frontend-design-engineer.md"), destRel: join5(".claude", "agents", "frontend-design-engineer.md"), executable: false },
+  { srcRel: join5("skills", "design-critique", "SKILL.md"), destRel: join5(".claude", "skills", "design-critique", "SKILL.md"), executable: false },
+  { srcRel: join5("hooks", "frontend-design-guard.sh"), destRel: join5(".claude", "hooks", "frontend-design-guard.sh"), executable: true }
+];
+var DESIGN_HOOK_COMMAND = ".claude/hooks/frontend-design-guard.sh";
+function resolveDesignAssetsDir() {
+  let dir = dirname2(fileURLToPath2(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    const candidate = join5(dir, "design-assets");
+    if (existsSync4(join5(candidate, "agents", "frontend-design-engineer.md"))) return candidate;
+    const parent = resolve2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function planDesignInstall(projectRoot, opts = {}) {
+  const assetsDir = resolveDesignAssetsDir();
+  if (!assetsDir) return [];
+  const out = [];
+  for (const asset of DESIGN_ASSETS) {
+    const srcAbs = join5(assetsDir, asset.srcRel);
+    if (!existsSync4(srcAbs)) continue;
+    const dest = projectRoot ? join5(projectRoot, asset.destRel) : asset.destRel;
+    if (opts.skipExisting && projectRoot && existsSync4(dest) && statSync4(dest).isFile()) continue;
+    out.push({ dest, content: readFileSync2(srcAbs, "utf8"), executable: asset.executable });
+  }
+  return out;
+}
+
+// src/lib/skill-detection.ts
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync3, statSync as statSync5 } from "fs";
+import { join as join6 } from "path";
+function readPackageJson(projectRoot) {
+  const path7 = join6(projectRoot, "package.json");
+  if (!existsSync5(path7)) return null;
+  try {
+    const raw = readFileSync3(path7, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function allDeps(pkg) {
+  if (!pkg) return {};
+  return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+}
+function hasDependencyMatching(deps, pattern) {
+  for (const name of Object.keys(deps)) {
+    if (pattern.test(name)) return true;
+  }
+  return false;
+}
+var FRONTEND_DEP_PATTERN = /^(react|react-dom|next|vue|svelte|preact|solid-js|astro|nuxt|tailwindcss)$|^@(sveltejs|angular|remix-run)\//;
+function detectsFrontendStack(projectRoot) {
+  return hasDependencyMatching(allDeps(readPackageJson(projectRoot)), FRONTEND_DEP_PATTERN);
+}
+function hasGitHubWorkflows(projectRoot) {
+  const dir = join6(projectRoot, ".github", "workflows");
+  if (!existsSync5(dir)) return false;
+  try {
+    const entries = readdirSync4(dir);
+    return entries.some((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+  } catch {
+    return false;
+  }
+}
+function envExampleMentionsStaging(projectRoot) {
+  const path7 = join6(projectRoot, ".env.example");
+  if (!existsSync5(path7)) return false;
+  try {
+    const raw = readFileSync3(path7, "utf-8");
+    return /\b(STAGING_URL|STAGING_API|STAGING_HOST|NEXT_PUBLIC_STAGING)/i.test(raw);
+  } catch {
+    return false;
+  }
+}
+function hasVercelConfig(projectRoot) {
+  if (existsSync5(join6(projectRoot, "vercel.json"))) return true;
+  const vercelDir = join6(projectRoot, ".vercel");
+  if (!existsSync5(vercelDir)) return false;
+  try {
+    return statSync5(vercelDir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function scanForSkillSignals(projectRoot) {
+  const proposals = [];
+  const pkg = readPackageJson(projectRoot);
+  const deps = allDeps(pkg);
+  if (hasGitHubWorkflows(projectRoot)) {
+    proposals.push({
+      id: "gh-actions-debug",
+      name: "GitHub Actions debugger",
+      rationale: "Detected .github/workflows/ \u2014 a skill for inspecting CI failures and re-running jobs from Claude Code can shorten the debug loop.",
+      hint: 'Search Claude Code skill registry for "gh-actions" or install via `claude skills add gh-actions-debug`.'
+    });
+  }
+  if (hasDependencyMatching(deps, /^@sentry\//) || hasDependencyMatching(deps, /^@datadog\//)) {
+    proposals.push({
+      id: "error-tracking",
+      name: "Error tracking helper",
+      rationale: "Detected @sentry/* or @datadog/* in package.json \u2014 a skill that fetches recent error events into your context can speed up triage.",
+      hint: 'Search Claude Code skill registry for "sentry" or "datadog".'
+    });
+  }
+  if (hasVercelConfig(projectRoot)) {
+    proposals.push({
+      id: "read-vercel-logs",
+      name: "Vercel deploy logs",
+      rationale: "Detected vercel.json or .vercel/ \u2014 a skill for pulling deploy + runtime logs from Vercel directly into Claude Code helps when builds fail or runtime errors land.",
+      hint: 'Search Claude Code skill registry for "vercel" or install `vercel:logs`.'
+    });
+  }
+  if (envExampleMentionsStaging(projectRoot)) {
+    proposals.push({
+      id: "staging-environment",
+      name: "Staging-environment helper",
+      rationale: "Detected STAGING_* variables in .env.example \u2014 a skill for switching env contexts and seeding staging data can speed up pre-prod testing.",
+      hint: 'Search Claude Code skill registry for "staging" or define your own.'
+    });
+  }
+  if (detectsFrontendStack(projectRoot)) {
+    proposals.push({
+      id: "frontend-design-engineer",
+      name: "Frontend design engineer (agent + critique)",
+      rationale: "Detected a frontend stack (React/Next/Vue/Svelte/Tailwind) \u2014 PAPI ships a frontend-design-engineer sub-agent + a design-critique skill that isolate the visual layer, run a falsifiable anti-slop critique before and after building, and verify in-browser. They read your own DESIGN.md/PRODUCT.md for brand, so the output is yours, not generic.",
+      hint: "Re-run `setup` to install them into .claude/, or copy from the PAPI server package under design-assets/. A build-time guard hook is included (opt-in)."
+    });
+  }
+  return proposals;
+}
+function formatSkillProposals(proposals) {
+  if (proposals.length === 0) return "";
+  const lines = ["", "## Skill proposals", "_PAPI scanned your project once and noticed tooling that often pairs with a Claude Code skill. Each proposal is one-shot \u2014 they won't resurface._"];
+  for (const p of proposals) {
+    lines.push("");
+    lines.push(`### ${p.name}`);
+    lines.push(p.rationale);
+    if (p.hint) {
+      lines.push(`_${p.hint}_`);
+    }
+    lines.push("**[Yes]** install it now \xB7 **[Not now]** dismiss for this project");
+  }
+  return "\n" + lines.join("\n");
+}
+
 // src/templates.ts
 var PLANNING_LOG_TEMPLATE = `# PAPI Planning Log
 
@@ -16412,7 +16631,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
       await mkdir(config2.papiDir, { recursive: true });
       for (const [filename, template] of Object.entries(FILE_TEMPLATES)) {
         const content = substitute(template, vars);
-        await writeFile2(join5(config2.papiDir, filename), content, "utf-8");
+        await writeFile2(join7(config2.papiDir, filename), content, "utf-8");
       }
     }
   } else {
@@ -16430,13 +16649,13 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
   const useCollector = config2.adapterType === "proxy";
   const docsRel = "docs";
   const commandsRel = ".claude/commands";
-  const commandsDir = useCollector ? commandsRel : join5(config2.projectRoot, ".claude", "commands");
-  const docsDir = useCollector ? docsRel : join5(config2.projectRoot, "docs");
+  const commandsDir = useCollector ? commandsRel : join7(config2.projectRoot, ".claude", "commands");
+  const docsDir = useCollector ? docsRel : join7(config2.projectRoot, "docs");
   if (!useCollector) {
     await mkdir(commandsDir, { recursive: true });
     await mkdir(docsDir, { recursive: true });
   }
-  const claudeMdPath = useCollector ? "CLAUDE.md" : join5(config2.projectRoot, "CLAUDE.md");
+  const claudeMdPath = useCollector ? "CLAUDE.md" : join7(config2.projectRoot, "CLAUDE.md");
   let claudeMdExists = false;
   if (!useCollector) {
     try {
@@ -16445,7 +16664,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
     } catch {
     }
   }
-  const docsIndexPath = useCollector ? `${docsRel}/INDEX.md` : join5(docsDir, "INDEX.md");
+  const docsIndexPath = useCollector ? `${docsRel}/INDEX.md` : join7(docsDir, "INDEX.md");
   let docsIndexExists = false;
   if (!useCollector) {
     try {
@@ -16455,9 +16674,9 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
     }
   }
   const scaffoldFiles = {
-    [useCollector ? `${commandsRel}/papi-audit.md` : join5(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
-    [useCollector ? `${commandsRel}/test.md` : join5(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
-    [useCollector ? `${docsRel}/README.md` : join5(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
+    [useCollector ? `${commandsRel}/papi-audit.md` : join7(commandsDir, "papi-audit.md")]: PAPI_AUDIT_COMMAND_TEMPLATE,
+    [useCollector ? `${commandsRel}/test.md` : join7(commandsDir, "test.md")]: TEST_COMMAND_TEMPLATE,
+    [useCollector ? `${docsRel}/README.md` : join7(docsDir, "README.md")]: substitute(DOCS_README_TEMPLATE, vars)
   };
   if (!docsIndexExists) {
     scaffoldFiles[docsIndexPath] = substitute(DOCS_INDEX_TEMPLATE, vars);
@@ -16477,14 +16696,14 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
   const bundleRoot = useCollector ? "" : config2.projectRoot;
   for (const [dest, content] of Object.entries(planBundleInstall(bundleRoot, input.projectName, { skipExisting: true }))) {
     if (!useCollector) {
-      await mkdir(dirname2(dest), { recursive: true });
+      await mkdir(dirname3(dest), { recursive: true });
     }
     scaffoldFiles[dest] = content;
   }
   if (useCollector) {
     scaffoldFiles[".cursor/rules/papi.mdc"] = substitute(CURSOR_RULES_TEMPLATE, vars);
   } else {
-    const cursorDir = join5(config2.projectRoot, ".cursor");
+    const cursorDir = join7(config2.projectRoot, ".cursor");
     let cursorDetected = false;
     try {
       await access2(cursorDir);
@@ -16492,8 +16711,8 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
     } catch {
     }
     if (cursorDetected) {
-      const cursorRulesDir = join5(cursorDir, "rules");
-      const cursorRulesPath = join5(cursorRulesDir, "papi.mdc");
+      const cursorRulesDir = join7(cursorDir, "rules");
+      const cursorRulesPath = join7(cursorRulesDir, "papi.mdc");
       await mkdir(cursorRulesDir, { recursive: true });
       try {
         await access2(cursorRulesPath);
@@ -16511,6 +16730,19 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
       await writeFile2(filepath, content, "utf-8");
     }
   }
+  if (!useCollector && detectsFrontendStack(config2.projectRoot)) {
+    for (const entry of planDesignInstall(config2.projectRoot, { skipExisting: true })) {
+      await mkdir(dirname3(entry.dest), { recursive: true });
+      await writeFile2(entry.dest, entry.content, "utf-8");
+      if (entry.executable) {
+        try {
+          await chmod(entry.dest, 493);
+        } catch {
+        }
+      }
+    }
+    await ensureDesignHookRegistered(config2.projectRoot);
+  }
   if (!isPg) {
     await adapter2.writePhases([{
       id: "phase-0",
@@ -16535,7 +16767,7 @@ async function scaffoldPapiDir(adapter2, config2, input, collector) {
 }
 var PAPI_PERMISSION = "mcp__papi__*";
 async function ensurePapiPermission(projectRoot) {
-  const settingsPath = join5(projectRoot, ".claude", "settings.json");
+  const settingsPath = join7(projectRoot, ".claude", "settings.json");
   try {
     let settings = {};
     try {
@@ -16554,7 +16786,43 @@ async function ensurePapiPermission(projectRoot) {
     if (!allow.includes(PAPI_PERMISSION)) {
       allow.push(PAPI_PERMISSION);
     }
-    await mkdir(join5(projectRoot, ".claude"), { recursive: true });
+    await mkdir(join7(projectRoot, ".claude"), { recursive: true });
+    await writeFile2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+async function ensureDesignHookRegistered(projectRoot) {
+  const settingsPath = join7(projectRoot, ".claude", "settings.json");
+  try {
+    let settings = {};
+    try {
+      settings = JSON.parse(await readFile4(settingsPath, "utf-8"));
+    } catch {
+    }
+    if (!settings.hooks || typeof settings.hooks !== "object") {
+      settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    if (!Array.isArray(hooks.PreToolUse)) {
+      hooks.PreToolUse = [];
+    }
+    const pre = hooks.PreToolUse;
+    for (const matcher of ["Edit", "Write"]) {
+      let entry = pre.find((e) => e && e["matcher"] === matcher);
+      if (!entry) {
+        entry = { matcher, hooks: [] };
+        pre.push(entry);
+      }
+      if (!Array.isArray(entry["hooks"])) {
+        entry["hooks"] = [];
+      }
+      const chain = entry["hooks"];
+      const already = chain.some((h) => h && h["command"] === DESIGN_HOOK_COMMAND);
+      if (!already) {
+        chain.push({ type: "command", command: DESIGN_HOOK_COMMAND });
+      }
+    }
+    await mkdir(join7(projectRoot, ".claude"), { recursive: true });
     await writeFile2(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   } catch {
   }
@@ -16658,7 +16926,7 @@ ${conventionsText.trim()}
       );
     } else {
       try {
-        const claudeMdPath = join5(config2.projectRoot, "CLAUDE.md");
+        const claudeMdPath = join7(config2.projectRoot, "CLAUDE.md");
         const existing = await readFile4(claudeMdPath, "utf-8");
         if (existing.includes(CONVENTIONS_SENTINEL) || existing.includes(CONVENTIONS_HEADING)) {
           warnings.push(
@@ -16745,13 +17013,13 @@ async function scanCodebase(projectRoot) {
   }
   let packageJson;
   try {
-    const content = await readFile4(join5(projectRoot, "package.json"), "utf-8");
+    const content = await readFile4(join7(projectRoot, "package.json"), "utf-8");
     packageJson = JSON.parse(content);
   } catch {
   }
   let readme;
   for (const name of ["README.md", "readme.md", "README.txt", "README"]) {
-    const content = await safeReadFile(join5(projectRoot, name), 5e3);
+    const content = await safeReadFile(join7(projectRoot, name), 5e3);
     if (content) {
       readme = content;
       break;
@@ -16761,7 +17029,7 @@ async function scanCodebase(projectRoot) {
   let totalFiles = topLevelFiles.length;
   for (const dir of topLevelDirs) {
     try {
-      const entries = await readdir(join5(projectRoot, dir), { withFileTypes: true });
+      const entries = await readdir(join7(projectRoot, dir), { withFileTypes: true });
       const files = entries.filter((e) => e.isFile());
       const extensions = [...new Set(files.map((f) => extname(f.name).toLowerCase()).filter(Boolean))];
       totalFiles += files.length;
@@ -17108,7 +17376,7 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
       collector.add({ path: "CLAUDE.md", content: dogfoodSection, mode: "append" });
     } else {
       try {
-        const claudeMdPath = join5(config2.projectRoot, "CLAUDE.md");
+        const claudeMdPath = join7(config2.projectRoot, "CLAUDE.md");
         const existing = await readFile4(claudeMdPath, "utf-8");
         if (!existing.includes("Dogfood Logging")) {
           await writeFile2(claudeMdPath, existing + dogfoodSection, "utf-8");
@@ -17153,7 +17421,7 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
     cursorScaffolded = true;
   } else {
     try {
-      await access2(join5(config2.projectRoot, ".cursor", "rules", "papi.mdc"));
+      await access2(join7(config2.projectRoot, ".cursor", "rules", "papi.mdc"));
       cursorScaffolded = true;
     } catch {
     }
@@ -17173,11 +17441,11 @@ async function applySetup(adapter2, config2, input, briefText, adSeedText, conve
 }
 async function ensureMcpJsonGitignored(projectRoot) {
   try {
-    await access2(join5(projectRoot, ".git"));
+    await access2(join7(projectRoot, ".git"));
   } catch {
     return void 0;
   }
-  const gitignorePath = join5(projectRoot, ".gitignore");
+  const gitignorePath = join7(projectRoot, ".gitignore");
   let existing = "";
   try {
     existing = await readFile4(gitignorePath, "utf-8");
@@ -17560,10 +17828,127 @@ ${result.initialTasksPrompt.user}
   }
 }
 
+// src/lib/model-routing.ts
+var TIER_SPECS = {
+  cheap: {
+    label: "Cheap / fast",
+    rationale: "XS\u2013S work \u2014 single-file fixes, UI polish, mechanical edits. A small model is faster and cheaper with no quality loss here.",
+    examples: "Anthropic Claude Haiku \xB7 OpenAI GPT-5 mini \xB7 Google Gemini Flash \xB7 Mistral/Groq small"
+  },
+  capable: {
+    label: "Capable",
+    rationale: "M\u2013L work \u2014 multi-file features, data/plumbing, ambiguous handoffs. Needs a strong general-purpose model.",
+    examples: "Anthropic Claude Sonnet \xB7 OpenAI GPT-5 \xB7 Google Gemini Pro \xB7 Mistral Large"
+  },
+  frontier: {
+    label: "Frontier",
+    rationale: "XL work \u2014 architecture, cross-cutting refactors, the hardest reasoning. Reach for your most capable model.",
+    examples: "Anthropic Claude Opus \xB7 OpenAI GPT-5 Pro / o-series \xB7 Google Gemini Ultra"
+  }
+};
+function tierForComplexity(complexity) {
+  switch ((complexity ?? "").trim()) {
+    case "XS":
+    case "S":
+    case "Small":
+      return "cheap";
+    case "XL":
+      return "frontier";
+    case "M":
+    case "Medium":
+    case "L":
+    case "Large":
+      return "capable";
+    default:
+      return "capable";
+  }
+}
+function modelTierTag(complexity) {
+  return `\u{1F916} ${TIER_SPECS[tierForComplexity(complexity)].label}`;
+}
+function formatModelRecommendation(complexity) {
+  const spec = TIER_SPECS[tierForComplexity(complexity)];
+  return `
+
+---
+
+**\u{1F916} Suggested model tier: ${spec.label}**
+${spec.rationale}
+Examples (use whichever provider you have): ${spec.examples}.
+_Recommendation only \u2014 PAPI never selects or runs a model. Policy: XS/S \u2192 cheap, M/L \u2192 capable, XL \u2192 frontier._`;
+}
+
 // src/services/build.ts
 import { randomUUID as randomUUID11 } from "crypto";
-import { readdirSync as readdirSync4, existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join8 } from "path";
+import { readdirSync as readdirSync5, existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join10 } from "path";
+
+// src/lib/harness-capability.ts
+var HARNESS_REGISTRY = {
+  // Local stdio CLI agents — PAPI runs git on the user's machine. Confirmed in telemetry.
+  "claude-code": { build: true, label: "Claude Code" },
+  "opencode": { build: true, label: "opencode" },
+  "zcode": { build: true, label: "zcode" },
+  "codex": { build: true, label: "Codex" },
+  "cursor": { build: true, label: "Cursor" },
+  // Cloud harnesses with code sandboxes — their agent builds in-sandbox over HTTP+OAuth.
+  "lovable": { build: true, label: "Lovable" },
+  "bolt": { build: true, label: "Bolt" },
+  "replit": { build: true, label: "Replit" },
+  // Chat-only surfaces, no sandbox — planning only.
+  "chatgpt": { build: false, label: "ChatGPT" },
+  "claude.ai": { build: false, label: "Claude.ai" },
+  "claude-desktop": { build: false, label: "Claude Desktop" }
+};
+var UNKNOWN_DEFAULT = { build: false, label: "your tool" };
+function detectHarness(clientName) {
+  const raw = clientName?.trim() || null;
+  if (!raw) {
+    return { ...UNKNOWN_DEFAULT, raw: null, key: null, known: false };
+  }
+  const norm = raw.toLowerCase();
+  const key = HARNESS_REGISTRY[norm] ? norm : Object.keys(HARNESS_REGISTRY).find((k) => norm.includes(k)) ?? null;
+  if (!key) {
+    return { ...UNKNOWN_DEFAULT, label: raw, raw, key: null, known: false };
+  }
+  return { ...HARNESS_REGISTRY[key], raw, key, known: true };
+}
+
+// src/lib/harness-build-steps.ts
+init_git();
+function startBuildSteps(branch, base, taskId) {
+  return [
+    `PAPI is connected over HTTP and can't reach your files \u2014 your harness runs git in its own sandbox. To start ${taskId}:`,
+    `  git fetch origin`,
+    `  git checkout ${branch} 2>/dev/null || git checkout -b ${branch} origin/${base} 2>/dev/null || git checkout -b ${branch}`,
+    `Then implement the task on branch \`${branch}\`.`
+  ];
+}
+function completeBuildSteps(branch, base, taskId, title) {
+  const message = `${taskId}: ${title}`.replace(/["`\\]/g, "'");
+  return [
+    `To ship ${taskId} from your sandbox:`,
+    `  git add -A`,
+    `  git commit -m "${message}"`,
+    `  git push -u origin ${branch}`,
+    `Then open a PR from \`${branch}\` into \`${base}\`.`
+  ];
+}
+function hostedBranchName(taskId, module, cycleNumber) {
+  return module && cycleNumber > 0 ? cycleBranchName(cycleNumber, module) : taskBranchName(taskId);
+}
+function hostedStartSteps(clientName, taskId, module, cycleNumber, base) {
+  if (!detectHarness(clientName).build) return null;
+  const branch = hostedBranchName(taskId, module, cycleNumber);
+  return { branch, steps: startBuildSteps(branch, base, taskId) };
+}
+function hostedCompleteSteps(clientName, taskId, module, cycleNumber, base, title) {
+  if (!detectHarness(clientName).build) return null;
+  const branch = hostedBranchName(taskId, module, cycleNumber);
+  return completeBuildSteps(branch, base, taskId, title);
+}
+
+// src/services/build.ts
 init_git();
 
 // src/lib/owns-local-workspace.ts
@@ -17571,16 +17956,16 @@ init_git();
 
 // src/services/release.ts
 import { writeFile as writeFile3, readFile as readFile5 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import { execFileSync as execFileSync4 } from "child_process";
 
 // src/lib/install-id.ts
 import { randomUUID as randomUUID10 } from "crypto";
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync, chmodSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync4, writeFileSync, chmodSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
-var PAPI_HOME_DIR = join6(homedir2(), ".papi");
-var INSTALL_ID_FILE = join6(PAPI_HOME_DIR, "install-id.json");
+import { join as join8 } from "path";
+var PAPI_HOME_DIR = join8(homedir2(), ".papi");
+var INSTALL_ID_FILE = join8(PAPI_HOME_DIR, "install-id.json");
 var cachedInstallId = null;
 function isValidUuid(s) {
   return typeof s === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s);
@@ -17588,7 +17973,7 @@ function isValidUuid(s) {
 function getInstallId() {
   if (cachedInstallId) return cachedInstallId;
   try {
-    const raw = readFileSync2(INSTALL_ID_FILE, "utf-8");
+    const raw = readFileSync4(INSTALL_ID_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (isValidUuid(parsed.install_id)) {
       cachedInstallId = parsed.install_id;
@@ -18132,7 +18517,7 @@ async function createRelease(config2, branch, version, adapter2, cycleNum, optio
     }
   }
   const latestTag = getLatestTag(config2.projectRoot);
-  const changelogPath = join7(config2.projectRoot, "CHANGELOG.md");
+  const changelogPath = join9(config2.projectRoot, "CHANGELOG.md");
   if (!latestTag) {
     const initialContent = INITIAL_RELEASE_NOTES.replace("v0.1.0-alpha", version);
     if (config2.adapterType === "proxy") {
@@ -18827,7 +19212,7 @@ function autoCommit(config2, taskId, taskTitle, predictedFiles) {
     if (modified.length === 0) {
       return "Auto-commit: skipped (no working-tree changes).";
     }
-    const dirname6 = (p) => {
+    const dirname7 = (p) => {
       const idx = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
       return idx > 0 ? p.slice(0, idx) : "";
     };
@@ -18839,7 +19224,7 @@ function autoCommit(config2, taskId, taskTitle, predictedFiles) {
       return `Auto-commit: refused \u2014 none of the ${modified.length} modified file(s) intersect FILES LIKELY TOUCHED. Modified: ${modSample}. Expected: ${predSample}. Stage the intended files manually (\`git add <paths>\`) then re-run, or set PAPI_AUTO_COMMIT=false.`;
     }
     const untracked = getUntrackedFiles(cwd);
-    const scopedDirs = [...new Set(scoped.map(dirname6).filter((d) => d.length > 0))];
+    const scopedDirs = [...new Set(scoped.map(dirname7).filter((d) => d.length > 0))];
     const isUnderScopedDir = (p) => scopedDirs.some((d) => p === d || p.startsWith(`${d}/`) || p.startsWith(`${d}\\`));
     const scopedSet = new Set(scoped);
     const adjacentUntracked = untracked.filter(
@@ -18864,8 +19249,13 @@ function autoCommit(config2, taskId, taskTitle, predictedFiles) {
   }
   return safeRun(() => stageAllAndCommit(cwd, message));
 }
-function pushAndCreatePR(config2, taskId, taskTitle) {
+function pushAndCreatePR(config2, taskId, taskTitle, clientName, module, cycleNumber) {
   const lines = [];
+  if (!hasLocalWorkspace()) {
+    const steps = hostedCompleteSteps(clientName, taskId, module, cycleNumber ?? 0, config2.baseBranch, taskTitle);
+    if (steps) lines.push(...steps);
+    return lines;
+  }
   if (!isGitAvailable() || !isGitRepo(config2.projectRoot)) {
     return lines;
   }
@@ -19050,7 +19440,7 @@ async function describeTask(adapter2, taskId) {
   }
   return { task };
 }
-async function startBuild(adapter2, config2, taskId, options = {}) {
+async function startBuild(adapter2, config2, taskId, options = {}, clientName) {
   const task = await adapter2.getTask(taskId);
   if (!task) {
     throw new Error(`Task "${taskId}" not found on the Cycle Board.`);
@@ -19092,6 +19482,12 @@ async function startBuild(adapter2, config2, taskId, options = {}) {
   const branchLines = [];
   if (options.light) {
     branchLines.push("Light mode: skipping branch creation \u2014 working on current branch.");
+  } else if (!hasLocalWorkspace()) {
+    const cycleHealth = await adapter2.getCycleHealth().catch(() => null);
+    const hosted = hostedStartSteps(clientName, taskId, task.module, cycleHealth?.totalCycles ?? 0, config2.baseBranch);
+    if (hosted) {
+      branchLines.push(...hosted.steps);
+    }
   } else if (config2.autoCommit && isGitAvailable() && isGitRepo(config2.projectRoot)) {
     const cycleHealth = await adapter2.getCycleHealth().catch(() => null);
     const cycleNumber = cycleHealth?.totalCycles ?? 0;
@@ -19295,16 +19691,16 @@ function writeActiveTaskScope(projectRoot, taskId, filesLikelyTouched, adapterTy
     collector.add({ path: ".papi/active-task-scope.txt", content, mode: "overwrite" });
     return;
   }
-  const papiDir = join8(projectRoot, ".papi");
-  if (!existsSync4(papiDir)) {
+  const papiDir = join10(projectRoot, ".papi");
+  if (!existsSync6(papiDir)) {
     mkdirSync2(papiDir, { recursive: true });
   }
-  const scopePath = join8(papiDir, "active-task-scope.txt");
+  const scopePath = join10(papiDir, "active-task-scope.txt");
   writeFileSync2(scopePath, content, "utf-8");
 }
 function clearActiveTaskScope(projectRoot) {
-  const scopePath = join8(projectRoot, ".papi", "active-task-scope.txt");
-  if (existsSync4(scopePath)) {
+  const scopePath = join10(projectRoot, ".papi", "active-task-scope.txt");
+  if (existsSync6(scopePath)) {
     unlinkSync(scopePath);
   }
 }
@@ -19324,7 +19720,7 @@ function extractDocMeta(absolutePath, relativePath, cycleNumber) {
   else if (relativePath.startsWith("docs/architecture/")) type = "architecture";
   else if (relativePath.startsWith("docs/audits/")) type = "audit";
   try {
-    const content = readFileSync3(absolutePath, "utf-8").slice(0, 2e3);
+    const content = readFileSync5(absolutePath, "utf-8").slice(0, 2e3);
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     if (fmMatch) {
       const fm = fmMatch[1];
@@ -19371,7 +19767,7 @@ Fix the deploy first, then re-run build_execute complete with a 2xx verification
     );
   }
 }
-async function completeBuild(adapter2, config2, taskId, input, options = {}) {
+async function completeBuild(adapter2, config2, taskId, input, options = {}, clientName) {
   const task = await adapter2.getTask(taskId);
   if (!task) {
     throw new Error(`Task "${taskId}" not found on the Cycle Board.`);
@@ -19649,7 +20045,7 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
   if (options.light) {
     prLines.push("Light mode: skipping push and PR creation.");
   } else if (config2.autoCommit && input.completed === "yes") {
-    prLines = pushAndCreatePR(config2, taskId, task.title);
+    prLines = pushAndCreatePR(config2, taskId, task.title, clientName, task.module, cycleNumber);
   }
   const allTasks = await adapter2.queryBoard();
   warnIfEmpty("queryBoard (cycle progress)", allTasks);
@@ -19669,14 +20065,14 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
   let docWarning;
   try {
     if (adapter2.searchDocs && hasLocalWorkspace() && await ownsLocalWorkspace(adapter2, config2.projectRoot)) {
-      const docsDir = join8(config2.projectRoot, "docs");
-      if (existsSync4(docsDir)) {
+      const docsDir = join10(config2.projectRoot, "docs");
+      if (existsSync6(docsDir)) {
         const scanDir = (dir, depth = 0) => {
           if (depth > 8) return [];
-          const entries = readdirSync4(dir, { withFileTypes: true });
+          const entries = readdirSync5(dir, { withFileTypes: true });
           const files = [];
           for (const e of entries) {
-            const full = join8(dir, e.name);
+            const full = join10(dir, e.name);
             if (e.isDirectory() && !e.isSymbolicLink()) files.push(...scanDir(full, depth + 1));
             else if (e.name.endsWith(".md")) files.push(full.replace(config2.projectRoot + "/", ""));
           }
@@ -19691,7 +20087,7 @@ async function completeBuild(adapter2, config2, taskId, input, options = {}) {
           const failed = [];
           for (const docPath of unregistered) {
             try {
-              const meta = extractDocMeta(join8(config2.projectRoot, docPath), docPath, cycleNumber);
+              const meta = extractDocMeta(join10(config2.projectRoot, docPath), docPath, cycleNumber);
               await adapter2.registerDoc({
                 title: meta.title,
                 type: meta.type,
@@ -19768,6 +20164,9 @@ var OWNER_NAME = process.env["PAPI_OWNER"] ?? "cathalos92";
 var MODULE_INSTRUCTIONS = {
   Dashboard: `**\u26A0\uFE0F MANDATORY \u2014 Dashboard Module Rules (skip = rework)**
 
+**STEP 0 \u2014 Dispatch the design agent for the visual layer (do NOT hand-write UI in the main build context).**
+Any \`.tsx\` that renders visible UI must be built by the \`frontend-design-engineer\` subagent (dispatch via the Task tool), not inline here. It works in an isolated window loaded only with brand canon (DESIGN.md / PRODUCT.md / brand-book), runs design-critique before and after, builds via the \`frontend-design\` / \`impeccable\` skills, self-checks the falsifiable anti-slop blocklist, and verifies in-browser at populated / empty / mobile states. You remain responsible for data, routes, types, and tests \u2014 hand the visual layer to the agent and integrate the report it returns. Components hand-written in this context produce generic output that fails review. (If \`.claude/agents/frontend-design-engineer.md\` is absent \u2014 e.g. a fresh external install \u2014 run STEPs 1-4 below yourself.)
+
 **STEP 1 \u2014 BEFORE writing any code:**
 If you use the \`impeccable\` skill (recommended for dashboard work), it reads two root files for design context: **PRODUCT.md** (strategic \u2014 brand, users, product purpose, design principles) and **DESIGN.md** (visual tokens \u2014 palette, typography, elevation, components). Run \`impeccable init\` to create them if they don't exist yet. Every visual decision must align with these files; if your output contradicts them, it is wrong. (The legacy \`.impeccable.md\` is no longer read by the skill.)
 
@@ -20007,7 +20406,7 @@ function isResearchOrSpike(task) {
 }
 function formatListItem(task) {
   const base = `- **${task.id}:** ${task.title}
-  Status: ${task.status} | Priority: ${task.priority} | Complexity: ${task.complexity}`;
+  Status: ${task.status} | Priority: ${task.priority} | Complexity: ${task.complexity} | ${modelTierTag(task.complexity)}`;
   if (isResearchOrSpike(task)) {
     return base + "\n  _Research/spike \u2014 still needed?_ **(a)** build_execute | **(b)** fast-close (answered) | **(c)** deprioritise | **(d)** discuss";
   }
@@ -20129,7 +20528,7 @@ async function handleBuildDescribe(adapter2, args) {
     return errorResponse(err instanceof Error ? err.message : String(err));
   }
 }
-async function handleBuildExecute(adapter2, config2, args) {
+async function handleBuildExecute(adapter2, config2, args, clientName) {
   const taskId = args.task_id;
   if (!taskId) {
     return errorResponse("task_id is required.");
@@ -20153,11 +20552,11 @@ async function handleBuildExecute(adapter2, config2, args) {
     }
   }
   if (hasReportFields(args)) {
-    return handleExecuteComplete(adapter2, config2, taskId, args, light);
+    return handleExecuteComplete(adapter2, config2, taskId, args, light, clientName);
   }
   const tracker = new ProgressTracker("start_build");
   try {
-    const result = await startBuild(adapter2, config2, taskId, { light });
+    const result = await startBuild(adapter2, config2, taskId, { light }, clientName);
     tracker.mark("start_decorate_handoff");
     const branchInfo = result.branchLines.length > 0 ? result.branchLines.map((l) => `> ${l}`).join("\n") + "\n\n" : "";
     const phaseNote = result.phaseChanges.length > 0 ? "\n\n" + result.phaseChanges.map((c) => `Phase auto-updated: ${c.phaseId} ${c.oldStatus} \u2192 ${c.newStatus}`).join("\n") : "";
@@ -20209,7 +20608,8 @@ ${entries}`;
     const moduleInstructions = getModuleInstructions(result.task.module);
     const moduleContext = await getModuleContext(adapter2, result.task);
     const filesToWriteSection = result.filesToWrite ? formatFilesToWriteSection(result.filesToWrite) : "";
-    return textResponse(header + serializeBuildHandoff(result.task.buildHandoff) + adSection + moduleInstructions + moduleContext + dogfoodSection + verificationNote + chainInstruction + phaseNote + filesToWriteSection);
+    const modelNote = formatModelRecommendation(result.task.buildHandoff?.effort ?? result.task.complexity);
+    return textResponse(header + serializeBuildHandoff(result.task.buildHandoff) + modelNote + adSection + moduleInstructions + moduleContext + dogfoodSection + verificationNote + chainInstruction + phaseNote + filesToWriteSection);
   } catch (err) {
     if (isNoHandoffError(err)) {
       const lines = [
@@ -20245,7 +20645,7 @@ ${entries}`;
     }));
   }
 }
-async function handleExecuteComplete(adapter2, config2, taskId, args, light = false) {
+async function handleExecuteComplete(adapter2, config2, taskId, args, light = false, clientName) {
   const completed = args.completed;
   const effort = args.effort;
   const estimatedEffort = args.estimated_effort;
@@ -20323,7 +20723,7 @@ async function handleExecuteComplete(adapter2, config2, taskId, args, light = fa
       })),
       productionVerification,
       preview
-    }, { light });
+    }, { light }, clientName);
     tracker.mark("complete_format");
     if (resolvesLearnings && resolvesLearnings.length > 0 && adapter2.updateCycleLearningActionRef) {
       for (const learningId of resolvesLearnings) {
@@ -20454,14 +20854,12 @@ function formatCompleteResult(result) {
     } else {
       lines.push("", `Next: run \`build_list\` to see ${remaining} remaining cycle task${remaining === 1 ? "" : "s"}, then \`build_execute <task_id>\` to start the next one.`);
     }
-    lines.push("", "*Tip: Start a new chat for your next build to keep context fresh and avoid hitting context window limits.*");
   } else {
     if (hasDiscoveredIssues) {
       lines.push("", "All cycle tasks complete. Discovered issues logged \u2014 run `review_list` then `review_submit` to review builds, then `release` to close the cycle.");
     } else {
       lines.push("", "All cycle tasks complete. Run `review_list` then `review_submit` to review builds, then `release` to close the cycle.");
     }
-    lines.push("", "*Tip: Start a new chat for your next session to keep context fresh.*");
   }
   return lines.join("\n");
 }
@@ -21050,13 +21448,13 @@ _To correct: board_edit ${result.task.id} with updated fields._`
 init_git();
 
 // src/services/reconcile.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
 function loadDocsIndex(projectRoot) {
   if (!hasLocalWorkspace()) return "";
   try {
-    const indexPath = join9(projectRoot, "docs", "INDEX.md");
-    const raw = readFileSync4(indexPath, "utf8");
+    const indexPath = join11(projectRoot, "docs", "INDEX.md");
+    const raw = readFileSync6(indexPath, "utf8");
     const rows = raw.split("\n").filter((l) => l.startsWith("| ["));
     if (rows.length === 0) return "";
     const entries = rows.map((row) => {
@@ -21631,8 +22029,8 @@ Produce your analysis and structured output above. Present Part 1 to the user an
 }
 
 // src/tools/review.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join12 } from "path";
 init_git();
 
 // src/services/review.ts
@@ -21844,11 +22242,11 @@ ${task.buildReport}` : "### Build Report\n(none recorded)";
 ${diff}
 \`\`\`` : "### Branch diff vs base\n(no diff resolved \u2014 not a git repo, no base ref, or no committed changes)";
   let projectContext = "";
-  const ctxPath = join10(config2.projectRoot, ".agents", "papi-context.md");
-  if (existsSync5(ctxPath)) {
+  const ctxPath = join12(config2.projectRoot, ".agents", "papi-context.md");
+  if (existsSync7(ctxPath)) {
     try {
       projectContext = `### Project context (.agents/papi-context.md)
-${readFileSync5(ctxPath, "utf-8")}
+${readFileSync7(ctxPath, "utf-8")}
 
 `;
     } catch {
@@ -22003,8 +22401,8 @@ function mergeAfterAccept(config2, taskId) {
     };
   }
   const details = [];
-  const papiDir = join10(config2.projectRoot, ".papi");
-  if (existsSync5(papiDir)) {
+  const papiDir = join12(config2.projectRoot, ".papi");
+  if (existsSync7(papiDir)) {
     try {
       const commitResult = stageDirAndCommit(
         config2.projectRoot,
@@ -23034,8 +23432,9 @@ async function getHealthSummary(adapter2) {
   const cycleNumber = health.totalCycles;
   const cyclesSinceReview = health.cyclesSinceLastStrategyReview;
   const reviewDue = health.strategyReviewDue;
-  const reviewGateBlocking = cyclesSinceReview >= 5;
-  const reviewWarning = reviewGateBlocking ? `\u26A0\uFE0F  GATE \u2014 ${cyclesSinceReview} cycles since last Strategy Review. \`plan\` is blocked until \`strategy_review\` runs (or \`force: true\`).` : `\u2713 On track \u2014 ${cyclesSinceReview} cycle(s) since last review. Next due: ${reviewDue}`;
+  const reviewGateBlocking = cyclesSinceReview >= STRATEGY_REVIEW_BLOCK_GAP;
+  const reviewAvailable = cyclesSinceReview >= STRATEGY_REVIEW_OFFER_GAP && !reviewGateBlocking;
+  const reviewWarning = reviewGateBlocking ? `\u26A0\uFE0F  GATE \u2014 ${cyclesSinceReview} cycles since last Strategy Review. \`plan\` is blocked until \`strategy_review\` runs (or \`force: true\`).` : reviewAvailable ? `\u25CB Strategy review available \u2014 ${cyclesSinceReview} cycles since last review. Offered now (optional); \`plan\` hard-blocks at ${STRATEGY_REVIEW_BLOCK_GAP} cycles.` : `\u2713 On track \u2014 ${cyclesSinceReview} cycle(s) since last review. Next due: ${reviewDue}`;
   const deferredCount = activeTasks.filter((t) => t.status === "Deferred").length;
   const nonDeferredTasks = activeTasks.filter((t) => t.status !== "Deferred");
   const statusCounts = countByStatus(nonDeferredTasks);
@@ -23314,115 +23713,9 @@ function formatUnblockSection(candidates) {
   return lines.join("\n");
 }
 
-// src/lib/skill-detection.ts
-import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
-import { join as join11 } from "path";
-function readPackageJson(projectRoot) {
-  const path7 = join11(projectRoot, "package.json");
-  if (!existsSync6(path7)) return null;
-  try {
-    const raw = readFileSync6(path7, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function allDeps(pkg) {
-  if (!pkg) return {};
-  return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
-}
-function hasDependencyMatching(deps, pattern) {
-  for (const name of Object.keys(deps)) {
-    if (pattern.test(name)) return true;
-  }
-  return false;
-}
-function hasGitHubWorkflows(projectRoot) {
-  const dir = join11(projectRoot, ".github", "workflows");
-  if (!existsSync6(dir)) return false;
-  try {
-    const entries = readdirSync5(dir);
-    return entries.some((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
-  } catch {
-    return false;
-  }
-}
-function envExampleMentionsStaging(projectRoot) {
-  const path7 = join11(projectRoot, ".env.example");
-  if (!existsSync6(path7)) return false;
-  try {
-    const raw = readFileSync6(path7, "utf-8");
-    return /\b(STAGING_URL|STAGING_API|STAGING_HOST|NEXT_PUBLIC_STAGING)/i.test(raw);
-  } catch {
-    return false;
-  }
-}
-function hasVercelConfig(projectRoot) {
-  if (existsSync6(join11(projectRoot, "vercel.json"))) return true;
-  const vercelDir = join11(projectRoot, ".vercel");
-  if (!existsSync6(vercelDir)) return false;
-  try {
-    return statSync4(vercelDir).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function scanForSkillSignals(projectRoot) {
-  const proposals = [];
-  const pkg = readPackageJson(projectRoot);
-  const deps = allDeps(pkg);
-  if (hasGitHubWorkflows(projectRoot)) {
-    proposals.push({
-      id: "gh-actions-debug",
-      name: "GitHub Actions debugger",
-      rationale: "Detected .github/workflows/ \u2014 a skill for inspecting CI failures and re-running jobs from Claude Code can shorten the debug loop.",
-      hint: 'Search Claude Code skill registry for "gh-actions" or install via `claude skills add gh-actions-debug`.'
-    });
-  }
-  if (hasDependencyMatching(deps, /^@sentry\//) || hasDependencyMatching(deps, /^@datadog\//)) {
-    proposals.push({
-      id: "error-tracking",
-      name: "Error tracking helper",
-      rationale: "Detected @sentry/* or @datadog/* in package.json \u2014 a skill that fetches recent error events into your context can speed up triage.",
-      hint: 'Search Claude Code skill registry for "sentry" or "datadog".'
-    });
-  }
-  if (hasVercelConfig(projectRoot)) {
-    proposals.push({
-      id: "read-vercel-logs",
-      name: "Vercel deploy logs",
-      rationale: "Detected vercel.json or .vercel/ \u2014 a skill for pulling deploy + runtime logs from Vercel directly into Claude Code helps when builds fail or runtime errors land.",
-      hint: 'Search Claude Code skill registry for "vercel" or install `vercel:logs`.'
-    });
-  }
-  if (envExampleMentionsStaging(projectRoot)) {
-    proposals.push({
-      id: "staging-environment",
-      name: "Staging-environment helper",
-      rationale: "Detected STAGING_* variables in .env.example \u2014 a skill for switching env contexts and seeding staging data can speed up pre-prod testing.",
-      hint: 'Search Claude Code skill registry for "staging" or define your own.'
-    });
-  }
-  return proposals;
-}
-function formatSkillProposals(proposals) {
-  if (proposals.length === 0) return "";
-  const lines = ["", "## Skill proposals", "_PAPI scanned your project once and noticed tooling that often pairs with a Claude Code skill. Each proposal is one-shot \u2014 they won't resurface._"];
-  for (const p of proposals) {
-    lines.push("");
-    lines.push(`### ${p.name}`);
-    lines.push(p.rationale);
-    if (p.hint) {
-      lines.push(`_${p.hint}_`);
-    }
-    lines.push("**[Yes]** install it now \xB7 **[Not now]** dismiss for this project");
-  }
-  return "\n" + lines.join("\n");
-}
-
 // src/tools/agent-list.ts
 import { readdir as readdir2, readFile as readFile7 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var NO_AGENTS_HINT = "No project sub-agents found in `.claude/agents/`. Add a `*.md` file with `name` + `description` frontmatter \u2014 see the 1926-Census marketing sub-agent for a reference implementation.";
 function parseAgentFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -23434,7 +23727,7 @@ function parseAgentFrontmatter(content) {
   return { name: nameMatch?.[1].trim(), description };
 }
 async function listAgents(projectRoot) {
-  const agentsDir = join12(projectRoot, ".claude", "agents");
+  const agentsDir = join13(projectRoot, ".claude", "agents");
   let files;
   try {
     files = await readdir2(agentsDir);
@@ -23445,7 +23738,7 @@ async function listAgents(projectRoot) {
   for (const file of files.filter((f) => f.endsWith(".md"))) {
     let content;
     try {
-      content = await readFile7(join12(agentsDir, file), "utf-8");
+      content = await readFile7(join13(agentsDir, file), "utf-8");
     } catch {
       continue;
     }
@@ -23453,7 +23746,7 @@ async function listAgents(projectRoot) {
     agents.push({
       name: meta?.name ?? file.replace(/\.md$/, ""),
       description: meta?.description ?? "",
-      path: join12(".claude", "agents", file)
+      path: join13(".claude", "agents", file)
     });
   }
   agents.sort((a, b2) => a.name.localeCompare(b2.name));
@@ -23494,8 +23787,8 @@ ${formatted}`);
 }
 
 // src/tools/doc-registry.ts
-import { readdirSync as readdirSync6, existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
-import { join as join13, relative } from "path";
+import { readdirSync as readdirSync6, existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { join as join14, relative } from "path";
 import { homedir as homedir3 } from "os";
 import { randomUUID as randomUUID16 } from "crypto";
 var docRegisterTool = {
@@ -23692,7 +23985,7 @@ async function handleDocSearch(adapter2, args, config2) {
   const lines = docs.map((d) => {
     const actionCount = d.actions?.filter((a) => a.status === "pending").length ?? 0;
     const actionNote = actionCount > 0 ? ` | ${actionCount} pending action(s)` : "";
-    const missingNote = root && d.path && !existsSync7(join13(root, d.path)) ? `
+    const missingNote = root && d.path && !existsSync8(join14(root, d.path)) ? `
 > \u26A0\uFE0F **File missing on disk** \u2014 the registry points at \`${d.path}\` but nothing is there. Check \`git stash list\` for a papi-autostash entry, or re-create/deregister the doc.` : "";
     return `### ${d.title}
 **Type:** ${d.type} | **Status:** ${d.status} | **Cycle:** ${d.cycleCreated}${d.cycleUpdated ? `\u2192${d.cycleUpdated}` : ""}${actionNote}
@@ -23706,12 +23999,12 @@ ${d.summary}
 ${lines.join("\n---\n\n")}`);
 }
 function scanMdFiles(dir, rootDir) {
-  if (!existsSync7(dir)) return [];
+  if (!existsSync8(dir)) return [];
   const files = [];
   try {
     const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = join13(dir, entry.name);
+      const full = join14(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...scanMdFiles(full, rootDir));
       } else if (entry.name.endsWith(".md")) {
@@ -23724,7 +24017,7 @@ function scanMdFiles(dir, rootDir) {
 }
 function extractTitle(filePath) {
   try {
-    const content = readFileSync7(filePath, "utf-8").slice(0, 1e3);
+    const content = readFileSync8(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);
@@ -23745,17 +24038,17 @@ async function handleDocScan(adapter2, config2, args) {
   const includePlans = args.include_plans ?? false;
   const registered = await adapter2.searchDocs({ limit: 500, status: "all" });
   const registeredPaths = new Set(registered.map((d) => d.path));
-  const docsDir = join13(config2.projectRoot, "docs");
+  const docsDir = join14(config2.projectRoot, "docs");
   const docsFiles = scanMdFiles(docsDir, config2.projectRoot);
   const unregisteredDocs = docsFiles.filter((f) => !registeredPaths.has(f));
   let unregisteredPlans = [];
   if (includePlans) {
-    const plansDir = join13(homedir3(), ".claude", "plans");
-    if (existsSync7(plansDir)) {
+    const plansDir = join14(homedir3(), ".claude", "plans");
+    if (existsSync8(plansDir)) {
       const planFiles = scanMdFiles(plansDir, plansDir);
       unregisteredPlans = planFiles.map((f) => `plans/${f}`).filter((f) => !registeredPaths.has(f)).map((f) => ({
         path: f,
-        title: extractTitle(join13(plansDir, f.replace("plans/", "")))
+        title: extractTitle(join14(plansDir, f.replace("plans/", "")))
       }));
     }
   }
@@ -23766,7 +24059,7 @@ async function handleDocScan(adapter2, config2, args) {
   if (unregisteredDocs.length > 0) {
     lines.push(`## Unregistered Docs (${unregisteredDocs.length})`);
     for (const f of unregisteredDocs) {
-      const title = extractTitle(join13(config2.projectRoot, f));
+      const title = extractTitle(join14(config2.projectRoot, f));
       lines.push(`- \`${f}\`${title ? ` \u2014 ${title}` : ""}`);
     }
   }
@@ -23876,6 +24169,22 @@ ${userNotes}` : referenceLine;
   );
 }
 
+// src/lib/harness-guidance.ts
+function buildLoopRunsHere(i) {
+  if (i.forceLocal) return true;
+  if (i.harness.known) return i.harness.build;
+  if (i.envHintsNoGit) return false;
+  return i.localWorkspace;
+}
+function nextActionQualifier(harness) {
+  const where = harness.known ? harness.label : "your tool";
+  return `_Note: \`build_execute\`, \`review_submit\`, and \`release\` run where your project files live. From ${where} you can plan, log ideas, and steer the board \u2014 the build / review / release loop runs in the environment that holds your code._`;
+}
+function connectOnlyRoleNote(harness) {
+  if (harness.build || !harness.known) return null;
+  return `**You're connected as a planning surface.** ${harness.label} is a first-class place to plan, capture decisions, and steer the board. The code gets built wherever your build harness lives (a CLI like Codex, or a sandbox like Lovable or Bolt) and your plan + decisions travel with it. This is a full half of the loop, not a limited mode.`;
+}
+
 // src/lib/enrichment.ts
 function headingSlug(line) {
   const match = line.match(/^##\s+(.+?)(?:\s*\([^)]*\))?\s*$/);
@@ -23961,8 +24270,8 @@ async function verifyProject(adapter2) {
 // src/tools/orient.ts
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync3, existsSync as existsSync8 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync3, existsSync as existsSync9 } from "fs";
+import { join as join15 } from "path";
 var execFileAsync2 = promisify2(execFile2);
 var GIT_DEPENDENT_ENVS = /* @__PURE__ */ new Set(["hosted", "api"]);
 var VALID_ENVS = /* @__PURE__ */ new Set(["local-cli", "hosted", "api", "unknown"]);
@@ -24007,7 +24316,7 @@ async function runWithLimit(concurrency, tasks) {
 }
 var orientTool = {
   name: "orient",
-  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. Pass `environment` to qualify git-dependent recommendations (build_execute, release, review_submit) for non-Claude-Code callers.",
+  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. PAPI detects build capability from the connecting harness (clientInfo); pass `environment` only to override that detection for git-dependent recommendations (build_execute, release, review_submit).",
   annotations: { readOnlyHint: true, destructiveHint: false },
   inputSchema: {
     type: "object",
@@ -24015,7 +24324,7 @@ var orientTool = {
       environment: {
         type: "string",
         enum: ["local-cli", "hosted", "api", "unknown"],
-        description: 'Caller environment. "local-cli" (local CLI with git \u2014 Claude Code, Codex, or any local MCP client) sees all recommendations unchanged. "hosted" or "api" (no local git) suppresses/qualifies build_execute, release, and review_submit recommendations because those require a local session with git access. Default "unknown" = show everything (safe default). Legacy values "claude-code" and "cowork" are accepted as aliases (deprecated).'
+        description: `Caller environment OVERRIDE. By default PAPI branches git-dependent recommendations on the connecting harness's detected capability \u2014 a build-capable harness (local CLI like Codex/opencode, or a sandboxed cloud harness like Lovable/Bolt/Replit) sees the full loop; a connect-only chat surface sees planning-only framing. Pass this only to override: "local-cli" forces the full loop, "hosted"/"api" hints no local git for an UNRECOGNISED harness. Default "unknown" = trust detection. Legacy "claude-code"/"cowork" accepted as aliases (deprecated).`
       },
       deep_housekeeping: {
         type: "boolean",
@@ -24059,7 +24368,7 @@ function formatSynthesisParagraph(opts) {
   parts.push(`Next: ${cleanMode}`);
   return parts.join(" ");
 }
-function formatOrientSummary(health, buildInfo, hierarchy, latestTag, projectRoot, environment = "unknown", subAgents = [], projectName, teamSummary) {
+function formatOrientSummary(health, buildInfo, hierarchy, latestTag, projectRoot, environment = "unknown", subAgents = [], projectName, teamSummary, clientName) {
   const lines = [];
   const cycleIsComplete = health.latestCycleStatus === "complete";
   const tagSuffix = latestTag ? ` \u2014 ${latestTag}` : "";
@@ -24081,6 +24390,12 @@ function formatOrientSummary(health, buildInfo, hierarchy, latestTag, projectRoo
     lines.push(`**Connection:** ${statusIcon} ${statusLabel}`);
     lines.push("");
   }
+  const harness = detectHarness(clientName);
+  const roleNote = connectOnlyRoleNote(harness);
+  if (roleNote) {
+    lines.push(`> ${roleNote}`);
+    lines.push("");
+  }
   if (buildInfo.warnings.length > 0) {
     for (const w of buildInfo.warnings) {
       lines.push(`> ${w}`);
@@ -24092,11 +24407,15 @@ function formatOrientSummary(health, buildInfo, hierarchy, latestTag, projectRoo
     lines.push("");
   }
   const isGitDependentRec = /\*\*(Build|Review)\*\*/.test(health.recommendedMode);
-  if (GIT_DEPENDENT_ENVS.has(environment) && isGitDependentRec) {
-    lines.push(`> **Next action:** ${health.recommendedMode}`);
-    lines.push(`> _Note: \`build_execute\`, \`review_submit\`, and \`release\` require a local session in your AI coding tool with git access. From \`${environment}\` you can view state, log ideas, and edit the board \u2014 but the build/review/release loop must run through your local tool._`);
-  } else {
-    lines.push(`> **Next action:** ${health.recommendedMode}`);
+  const loopRunsHere = buildLoopRunsHere({
+    harness,
+    localWorkspace: hasLocalWorkspace(),
+    forceLocal: environment === "local-cli",
+    envHintsNoGit: GIT_DEPENDENT_ENVS.has(environment)
+  });
+  lines.push(`> **Next action:** ${health.recommendedMode}`);
+  if (isGitDependentRec && !loopRunsHere) {
+    lines.push(`> ${nextActionQualifier(harness)}`);
   }
   lines.push("");
   lines.push(`**Strategy Review:** ${health.reviewWarning}`);
@@ -24262,8 +24581,8 @@ async function getLatestGitTag(projectRoot) {
 }
 async function checkNpmVersionDrift() {
   try {
-    const pkgPath = join14(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkgPath = join15(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     const localVersion = pkg.version;
     const packageName = pkg.name;
     const { stdout } = await execFileAsync2("npm", ["view", packageName, "version"], {
@@ -24396,7 +24715,7 @@ function formatResolvedFeedback(items) {
   lines.push("_Thanks for the signal \u2014 it shaped what shipped._");
   return lines.join("\n");
 }
-async function handleOrient(adapter2, config2, args = {}) {
+async function handleOrient(adapter2, config2, args = {}, clientName) {
   const environment = normaliseEnvironment(args.environment);
   const deepHousekeeping = args.deep_housekeeping === true;
   const fullEnrichment = args.full === true || deepHousekeeping;
@@ -24720,7 +25039,7 @@ async function handleOrient(adapter2, config2, args = {}) {
       // task-1652: deep housekeeping — opt-in sweep (board, unrecorded commits, unregistered docs)
       // task-1865: also detects stale skill forks vs the @papi-ai/skills registry.
       tracked("deep-housekeeping", async () => {
-        if (!deepHousekeeping) return { reconciliationNote: "", unrecordedNote: "", unregisteredDocsNote: "", staleSkillsNote: "" };
+        if (!deepHousekeeping) return { reconciliationNote: "", mergedInProgressNote: "", unrecordedNote: "", unregisteredDocsNote: "", staleSkillsNote: "" };
         let reconciliationNote2 = "";
         try {
           const mismatches = detectBoardMismatches(config2.projectRoot, allTasks);
@@ -24732,6 +25051,22 @@ async function handleOrient(adapter2, config2, args = {}) {
           }
         } catch {
         }
+        let mergedInProgressNote2 = "";
+        try {
+          if (hasLocalWorkspace()) {
+            const merged = detectMergedInProgress(config2.projectRoot, config2.baseBranch, allTasks);
+            if (merged.length > 0) {
+              const lines = ["\n\n## Merged but In Progress"];
+              lines.push(`${merged.length} In-Progress task(s) already merged to the default branch \u2014 close them out with \`build_execute\` complete (or \`board_edit\` to mark Done):`);
+              for (const m of merged) {
+                const ref = m.pr ? `${m.pr} (\`${m.commit}\`)` : `\`${m.commit}\``;
+                lines.push(`- \u26A0\uFE0F **${m.displayId}** \u2014 merged via ${ref}: ${m.subject}`);
+              }
+              mergedInProgressNote2 = lines.join("\n");
+            }
+          }
+        } catch {
+        }
         let unrecordedNote2 = "";
         try {
           const unrecorded = detectUnrecordedCommits(config2.projectRoot, config2.baseBranch);
@@ -24756,7 +25091,7 @@ async function handleOrient(adapter2, config2, args = {}) {
         let unregisteredDocsNote2 = "";
         try {
           if (adapter2.searchDocs && hasLocalWorkspace()) {
-            const docsDir = join14(config2.projectRoot, "docs");
+            const docsDir = join15(config2.projectRoot, "docs");
             const docsFiles = scanMdFiles(docsDir, config2.projectRoot);
             if (docsFiles.length > 0) {
               const registered = await adapter2.searchDocs({ limit: 500, status: "all" });
@@ -24783,7 +25118,7 @@ async function handleOrient(adapter2, config2, args = {}) {
           }
         } catch {
         }
-        return { reconciliationNote: reconciliationNote2, unrecordedNote: unrecordedNote2, unregisteredDocsNote: unregisteredDocsNote2, staleSkillsNote: staleSkillsNote2 };
+        return { reconciliationNote: reconciliationNote2, mergedInProgressNote: mergedInProgressNote2, unrecordedNote: unrecordedNote2, unregisteredDocsNote: unregisteredDocsNote2, staleSkillsNote: staleSkillsNote2 };
       })
     ]);
     const proxyWarning = proxyVersionOutcome.status === "fulfilled" ? proxyVersionOutcome.value : void 0;
@@ -24825,7 +25160,7 @@ ${versionDrift}` : "";
       void adapter2.markFeedbackNotified(resolvedFeedback.map((f) => f.id), config2.userId).catch(() => {
       });
     }
-    const { reconciliationNote, unrecordedNote, unregisteredDocsNote, staleSkillsNote } = deepHousekeepingOutcome.status === "fulfilled" ? deepHousekeepingOutcome.value : { reconciliationNote: "", unrecordedNote: "", unregisteredDocsNote: "", staleSkillsNote: "" };
+    const { reconciliationNote, mergedInProgressNote, unrecordedNote, unregisteredDocsNote, staleSkillsNote } = deepHousekeepingOutcome.status === "fulfilled" ? deepHousekeepingOutcome.value : { reconciliationNote: "", mergedInProgressNote: "", unrecordedNote: "", unregisteredDocsNote: "", staleSkillsNote: "" };
     let enrichmentNote = "";
     const enrichmentCollector = new FileWriteCollector();
     try {
@@ -24872,8 +25207,8 @@ ${section}`;
       tracked("release-history", () => computeReleaseHistory(adapter2))().catch(() => void 0)
     ]);
     const teamSummary = [teamSummaryLine, releaseHistoryLine].filter(Boolean).join("\n") || void 0;
-    const deepHint = deepHousekeeping ? "" : "\n\n*Tip: pass `full: true` for Research Signals + version-drift, or `deep_housekeeping: true` to also check orphaned branches, unrecorded commits, unregistered docs, and stale skill forks (implies `full`).*";
-    return textResponse(projectBannerNote + formatOrientSummary(healthResult, buildInfo, hierarchy, latestTag, config2.projectRoot, environment, subAgents, projectName, teamSummary) + unblockNote + feedbackResolvedNote + alertsNote + ttfvNote + reconciliationNote + unrecordedNote + unregisteredDocsNote + staleSkillsNote + researchSignalsNote + recsNote + pendingReviewNote + patternsNote + unactionedIssuesNote + skillProposalsNote + sessionGuidanceNote + versionNote + enrichmentNote + deliveryShapeNote + preBuildCheckNote + deepHint + enrichmentFilesSection);
+    const deepHint = deepHousekeeping ? "" : "\n\n*Tip: pass `full: true` for Research Signals + version-drift, or `deep_housekeeping: true` to also check orphaned branches, merged-but-In-Progress tasks, unrecorded commits, unregistered docs, and stale skill forks (implies `full`).*";
+    return textResponse(projectBannerNote + formatOrientSummary(healthResult, buildInfo, hierarchy, latestTag, config2.projectRoot, environment, subAgents, projectName, teamSummary, clientName) + unblockNote + feedbackResolvedNote + alertsNote + ttfvNote + reconciliationNote + mergedInProgressNote + unrecordedNote + unregisteredDocsNote + staleSkillsNote + researchSignalsNote + recsNote + pendingReviewNote + patternsNote + unactionedIssuesNote + skillProposalsNote + sessionGuidanceNote + versionNote + enrichmentNote + deliveryShapeNote + preBuildCheckNote + deepHint + enrichmentFilesSection);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     const isKnownFriendly = /^(Orient failed|Project not found|No project|Setup required)/i.test(message);
@@ -24904,9 +25239,9 @@ function enrichClaudeMd(projectRoot, cycleNumber, adapterType, collector) {
 
 \u{1F4DD} **CLAUDE.md enriched** \u2014 added ${tierNames2.join(" + ")} guidance for cycle ${cycleNumber}+ projects.`;
   }
-  const claudeMdPath = join14(projectRoot, "CLAUDE.md");
-  if (!existsSync8(claudeMdPath)) return "";
-  const content = readFileSync8(claudeMdPath, "utf-8");
+  const claudeMdPath = join15(projectRoot, "CLAUDE.md");
+  if (!existsSync9(claudeMdPath)) return "";
+  const content = readFileSync9(claudeMdPath, "utf-8");
   const additions = [];
   if (cycleNumber >= 6 && !content.includes(CLAUDE_MD_ENRICHMENT_SENTINEL_T1)) {
     additions.push(dedupeEnrichmentBlob(content, CLAUDE_MD_TIER_1));
@@ -25612,7 +25947,7 @@ ${result.userMessage}
 
 // src/services/scope-brief.ts
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join15, dirname as dirname3 } from "path";
+import { join as join16, dirname as dirname4 } from "path";
 import Anthropic from "@anthropic-ai/sdk";
 var SCOPE_BRIEF_SYSTEM = `You are a technical scoping tool. You receive a brief-class task (too large to build directly) and decompose it into a structured scope document.
 
@@ -25667,13 +26002,13 @@ async function runScopeBrief(adapter2, input) {
   }
   const slug = input.taskId.replace(/[^a-z0-9-]/g, "-").toLowerCase();
   const relPath = `docs/scopes/${slug}.md`;
-  const absPath = join15(input.projectRoot, relPath);
+  const absPath = join16(input.projectRoot, relPath);
   const docBody = addFrontmatter(docContent, task, input.cycleNumber);
   const collector = new FileWriteCollector();
   if (input.adapterType === "proxy") {
     collector.add({ path: relPath, content: docBody, mode: "overwrite" });
   } else {
-    mkdirSync3(dirname3(absPath), { recursive: true });
+    mkdirSync3(dirname4(absPath), { recursive: true });
     writeFileSync4(absPath, docBody, "utf-8");
   }
   const taskCount = countSubTasks(docContent);
@@ -26411,21 +26746,90 @@ async function handleTaskUnclaim(adapter2, config2, args) {
   return textResponse(`\u2705 Released **${result.id}** (${result.title}) back to the shared Pool.`);
 }
 
+// src/tools/task-move.ts
+var taskMoveTool = {
+  name: "task_move",
+  description: "Move a task from the current project to another project you own. Reassigns the task a fresh id in the target (collision-free) and carries its build reports, comments, and history with it; the cycle assignment is cleared so it lands in the target project's backlog. You must own (or have write access to) BOTH projects. Destructive-ish and cross-project, so it requires confirm=true \u2014 without it you get a preview only. Does not call the Anthropic API.",
+  annotations: { readOnlyHint: false, destructiveHint: true },
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: 'The task to move, e.g. "task-2292".' },
+      target_project: {
+        type: "string",
+        description: 'The destination project \u2014 its slug (e.g. "papi-ui") or UUID. Must be a project you own.'
+      },
+      confirm: {
+        type: "boolean",
+        description: "Set true to perform the move. Omit (or false) to get a preview of what would happen."
+      }
+    },
+    required: ["task_id", "target_project"]
+  }
+};
+function requireStr(value) {
+  const s = typeof value === "string" ? value.trim() : "";
+  return s.length > 0 ? s : null;
+}
+async function handleTaskMove(adapter2, config2, args) {
+  const taskId = requireStr(args.task_id);
+  if (!taskId) return errorResponse('A task_id is required. Example: task_move task_id="task-42" target_project="other-project" confirm=true');
+  const targetProject = requireStr(args.target_project);
+  if (!targetProject) return errorResponse("A target_project (slug or UUID) is required \u2014 the project you want to move the task into.");
+  if (typeof adapter2.moveTask !== "function") {
+    return errorResponse("Cross-project move is not available on this adapter.");
+  }
+  const gate = await resolveOwnerGate(adapter2, config2);
+  const callerUserId = gate.callerUserId;
+  if (!callerUserId) {
+    const note = gate.resolutionError ? ` (${gate.resolutionError})` : "";
+    return errorResponse(
+      "Moving a task requires a resolvable user identity, but none was found" + note + ". Set PAPI_USER_ID to your account UUID (local) \u2014 hosted sessions derive it from your bearer token."
+    );
+  }
+  const task = await adapter2.getTask(taskId);
+  if (!task) return errorResponse(`Task "${taskId}" was not found on this project's board. task_move moves a task FROM the project you're connected to \u2014 switch to the source project first if needed.`);
+  if (args.confirm !== true) {
+    return textResponse(
+      `\u26A0\uFE0F **Preview \u2014 no changes made.**
+
+This will move **${taskId}** (${task.title}) into project \`${targetProject}\`:
+- it gets a NEW task id in the target (the current "${taskId}" is freed in this project)
+- its build reports, comments, and history move with it
+- its cycle assignment is cleared (it lands in the target's backlog)
+- you must own both this project and \`${targetProject}\`
+
+This is a cross-project write and cannot be auto-undone. To proceed:
+\`task_move task_id="${taskId}" target_project="${targetProject}" confirm=true\``
+    );
+  }
+  try {
+    const res = await adapter2.moveTask(taskId, targetProject, callerUserId);
+    return textResponse(
+      `\u2705 Moved **${taskId}** from ${res.sourceName} to ${res.targetName} as **${res.newDisplayId}**.
+
+Its build reports, comments, and history moved with it; the cycle assignment was cleared, so it sits in ${res.targetName}'s backlog. Switch to ${res.targetName} to plan or build it.`
+    );
+  } catch (err) {
+    return errorResponse(`Move failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
 // src/services/harness-inventory.ts
 import { readdir as readdir3, readFile as readFile8, stat as stat3 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { createHash as createHash3 } from "crypto";
 var RECOMMENDED_HOOKS = ["stop-release-check.sh", "claude-md-size-guard.sh"];
 async function computeFingerprint(root) {
   const parts = [];
   for (const sub of [".claude/skills", ".claude/agents", ".claude/hooks"]) {
-    const dir = join16(root, sub);
+    const dir = join17(root, sub);
     try {
       const names = (await readdir3(dir)).sort((a, b2) => a.localeCompare(b2));
       for (const name of names) {
         let mtime = "";
         try {
-          mtime = String(Math.floor((await stat3(join16(dir, name))).mtimeMs));
+          mtime = String(Math.floor((await stat3(join17(dir, name))).mtimeMs));
         } catch {
         }
         parts.push(`${sub}/${name}:${mtime}`);
@@ -26444,7 +26848,7 @@ async function computeFingerprint(root) {
 }
 async function readSkillDescription(skillDir) {
   try {
-    const content = await readFile8(join16(skillDir, "SKILL.md"), "utf-8");
+    const content = await readFile8(join17(skillDir, "SKILL.md"), "utf-8");
     const fm = content.match(/^---\n([\s\S]*?)\n---/);
     if (!fm) return void 0;
     const desc = fm[1].match(/^description:\s*[>|]?\s*\n?([\s\S]*?)(?=\n\w+:|\n---|$)/m);
@@ -26464,17 +26868,17 @@ async function scanInventory(root, toolDefs) {
     version = loadManifest().packageVersion;
   } catch {
   }
-  const skillsDir = join16(root, ".claude", "skills");
+  const skillsDir = join17(root, ".claude", "skills");
   try {
     const dirents = await readdir3(skillsDir, { withFileTypes: true });
     for (const d of dirents.filter((e) => e.isDirectory())) {
       entries.push({
         kind: "skill",
         name: d.name,
-        description: await readSkillDescription(join16(skillsDir, d.name)),
+        description: await readSkillDescription(join17(skillsDir, d.name)),
         version,
         status: stale.has(d.name) ? "stale_fork" : "ok",
-        path: join16(".claude", "skills", d.name)
+        path: join17(".claude", "skills", d.name)
       });
     }
   } catch {
@@ -26490,9 +26894,9 @@ async function scanInventory(root, toolDefs) {
   }
   const present = /* @__PURE__ */ new Set();
   try {
-    for (const f of (await readdir3(join16(root, ".claude", "hooks"))).filter((n) => n.endsWith(".sh"))) {
+    for (const f of (await readdir3(join17(root, ".claude", "hooks"))).filter((n) => n.endsWith(".sh"))) {
       present.add(f);
-      entries.push({ kind: "hook", name: f, status: "ok", path: join16(".claude", "hooks", f) });
+      entries.push({ kind: "hook", name: f, status: "ok", path: join17(".claude", "hooks", f) });
     }
   } catch {
   }
@@ -26571,6 +26975,130 @@ async function handleInventorySync(adapter2, config2, args, toolDefs) {
   return textResponse(lines.join("\n"));
 }
 
+// src/resources.ts
+var SCHEME = "mcp://papi";
+var RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: `${SCHEME}/decisions/{adId}`,
+    name: "Active Decision",
+    description: "A single Active Decision (e.g. AD-12) \u2014 title, confidence, body, and supersession status.",
+    mimeType: "text/markdown"
+  },
+  {
+    uriTemplate: `${SCHEME}/build-reports/cycle-{cycle}`,
+    name: "Cycle build reports",
+    description: "Every build report recorded for a given cycle number (e.g. cycle-310).",
+    mimeType: "text/markdown"
+  },
+  {
+    uriTemplate: `${SCHEME}/cycles/{cycle}`,
+    name: "Cycle summary",
+    description: "Summary, task count, effort, and carry-forward for a given cycle number.",
+    mimeType: "text/markdown"
+  },
+  {
+    uriTemplate: `${SCHEME}/handoffs/{taskId}`,
+    name: "Build handoff",
+    description: "The read-only BUILD HANDOFF for a task (e.g. task-1801).",
+    mimeType: "text/markdown"
+  }
+];
+async function listPapiResources(adapter2) {
+  const out = [];
+  try {
+    const ads = await adapter2.getActiveDecisions();
+    for (const d of ads.filter((d2) => !d2.superseded).slice(0, 50)) {
+      out.push({
+        uri: `${SCHEME}/decisions/${d.id}`,
+        name: `${d.id}: ${d.title}`,
+        description: `Active Decision [${d.confidence}]`,
+        mimeType: "text/markdown"
+      });
+    }
+  } catch {
+  }
+  try {
+    const log2 = await adapter2.getCycleLog(10);
+    for (const e of log2) {
+      out.push({
+        uri: `${SCHEME}/cycles/${e.cycleNumber}`,
+        name: `Cycle ${e.cycleNumber} summary`,
+        description: e.title,
+        mimeType: "text/markdown"
+      });
+      out.push({
+        uri: `${SCHEME}/build-reports/cycle-${e.cycleNumber}`,
+        name: `Cycle ${e.cycleNumber} build reports`,
+        mimeType: "text/markdown"
+      });
+    }
+  } catch {
+  }
+  return out;
+}
+function parseCycleNumber(raw) {
+  const m = raw.match(/(\d+)\s*$/);
+  return m ? parseInt(m[1], 10) : NaN;
+}
+async function readPapiResource(adapter2, uri) {
+  if (!uri.startsWith(`${SCHEME}/`)) {
+    throw new Error(`Unknown resource URI: ${uri}. Expected ${SCHEME}/...`);
+  }
+  const path7 = uri.slice(`${SCHEME}/`.length);
+  const slash = path7.indexOf("/");
+  const kind = slash === -1 ? path7 : path7.slice(0, slash);
+  const rest = slash === -1 ? "" : path7.slice(slash + 1);
+  const md = (text) => ({ uri, mimeType: "text/markdown", text });
+  switch (kind) {
+    case "decisions": {
+      const adId = rest.trim();
+      if (!adId) throw new Error(`Resource URI missing an AD id: ${uri}`);
+      const ads = await adapter2.getActiveDecisions({ includeRetired: true });
+      const target = ads.find((d) => d.id === adId);
+      if (!target) throw new Error(`Active Decision not found in this project: ${adId}`);
+      const supersededNote = target.superseded ? ` [SUPERSEDED by ${target.supersededBy ?? "unknown"}]` : "";
+      const supersedes = ads.filter((d) => d.supersededBy === target.id).map((d) => d.id);
+      const chain = supersedes.length > 0 ? `
+
+_Supersedes: ${supersedes.join(", ")}_` : "";
+      return md(`## ${target.id}: ${target.title} [${target.confidence}]${supersededNote}
+
+${target.body}${chain}`);
+    }
+    case "build-reports": {
+      const cycle = parseCycleNumber(rest);
+      if (Number.isNaN(cycle)) throw new Error(`Resource URI missing a cycle number: ${uri}`);
+      const reports = (await adapter2.getBuildReportsSince(cycle)).filter((r) => r.cycle === cycle);
+      return md(`# Build Reports \u2014 Cycle ${cycle} (${reports.length})
+
+${formatBuildReports(reports)}`);
+    }
+    case "cycles": {
+      const cycle = parseCycleNumber(rest);
+      if (Number.isNaN(cycle)) throw new Error(`Resource URI missing a cycle number: ${uri}`);
+      const entry = (await adapter2.getCycleLogSince(cycle)).find((e) => e.cycleNumber === cycle);
+      if (!entry) throw new Error(`No cycle log entry found in this project for cycle ${cycle}`);
+      return md(formatCycleLog([entry]));
+    }
+    case "handoffs": {
+      const taskId = rest.trim();
+      if (!taskId) throw new Error(`Resource URI missing a task id: ${uri}`);
+      const task = await adapter2.getTask(taskId);
+      if (!task) throw new Error(`Task not found in this project: ${taskId}`);
+      if (!task.buildHandoff) {
+        return md(`# ${taskId}: ${task.title}
+
+_No BUILD HANDOFF recorded for this task._`);
+      }
+      return md(`# BUILD HANDOFF \u2014 ${taskId}: ${task.title}
+
+${serializeBuildHandoff(task.buildHandoff)}`);
+    }
+    default:
+      throw new Error(`Unknown resource family "${kind}" in ${uri}. Known: decisions, build-reports, cycles, handoffs.`);
+  }
+}
+
 // src/services/metering.ts
 var TIER_ALLOWANCES = {
   free: 1e3,
@@ -26791,32 +27319,36 @@ var PAPI_TOOLS = [
   contributorListTool,
   taskClaimTool,
   taskUnclaimTool,
+  taskMoveTool,
   inventorySyncTool
 ];
 function getToolMetadata() {
   return PAPI_TOOLS.map((t) => ({ name: t.name, description: t.description }));
 }
 function createServer(adapter2, config2) {
-  const __pkgFilename = fileURLToPath2(import.meta.url);
-  const __pkgDir = dirname4(__pkgFilename);
+  const __pkgFilename = fileURLToPath3(import.meta.url);
+  const __pkgDir = dirname5(__pkgFilename);
   let serverVersion = "unknown";
   try {
-    const pkg = JSON.parse(readFileSync9(join17(__pkgDir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync10(join18(__pkgDir, "..", "package.json"), "utf-8"));
     serverVersion = pkg.version ?? "unknown";
   } catch {
   }
   const server2 = new Server(
     { name: "papi", version: serverVersion },
-    { capabilities: { tools: {}, prompts: {} } }
+    // task-2305: `instructions` is surfaced in the MCP initialize response, so every
+    // connecting host LLM gets PAPI's cycle frame on connect — zero config, any harness.
+    // task-1801: `resources` capability for the PAPI read surface exposed as MCP resources.
+    { capabilities: { tools: {}, prompts: {}, resources: {} }, instructions: UNIVERSAL_FRAME }
   );
   if (config2.adapterType === "md") {
     process.stderr.write(
       "\n\u26A0 PAPI is running in md mode \u2014 your cycles are not visible on the hosted dashboard.\n  Configure DATABASE_URL or sign up at https://getpapi.ai/setup to enable observability.\n\n"
     );
   }
-  const __filename = fileURLToPath2(import.meta.url);
-  const __dirname2 = dirname4(__filename);
-  const skillsDir = join17(__dirname2, "..", "skills");
+  const __filename = fileURLToPath3(import.meta.url);
+  const __dirname2 = dirname5(__filename);
+  const skillsDir = join18(__dirname2, "..", "skills");
   function parseSkillFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match) return null;
@@ -26834,7 +27366,7 @@ function createServer(adapter2, config2) {
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       const prompts = [];
       for (const file of mdFiles) {
-        const content = await readFile9(join17(skillsDir, file), "utf-8");
+        const content = await readFile9(join18(skillsDir, file), "utf-8");
         const meta = parseSkillFrontmatter(content);
         if (meta) {
           prompts.push({ name: meta.name, description: meta.description });
@@ -26850,7 +27382,7 @@ function createServer(adapter2, config2) {
     try {
       const files = await readdir4(skillsDir);
       for (const file of files.filter((f) => f.endsWith(".md"))) {
-        const content = await readFile9(join17(skillsDir, file), "utf-8");
+        const content = await readFile9(join18(skillsDir, file), "utf-8");
         const meta = parseSkillFrontmatter(content);
         if (meta?.name === name) {
           const body = content.replace(/^---\n[\s\S]*?\n---\n*/, "");
@@ -26864,6 +27396,15 @@ function createServer(adapter2, config2) {
     }
     throw new Error(`Prompt not found: ${name}`);
   });
+  server2.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: await listPapiResources(adapter2)
+  }));
+  server2.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates: RESOURCE_TEMPLATES
+  }));
+  server2.setRequestHandler(ReadResourceRequestSchema, async (request) => ({
+    contents: [await readPapiResource(adapter2, request.params.uri)]
+  }));
   server2.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [...PAPI_TOOLS]
   }));
@@ -26921,7 +27462,7 @@ function createServer(adapter2, config2) {
         case "build_describe":
           return handleBuildDescribe(adapter2, safeArgs);
         case "build_execute":
-          return handleBuildExecute(adapter2, config2, safeArgs);
+          return handleBuildExecute(adapter2, config2, safeArgs, server2.getClientVersion()?.name);
         case "build_cancel":
           return handleBuildCancel(adapter2, safeArgs);
         case "idea":
@@ -26943,9 +27484,9 @@ function createServer(adapter2, config2) {
         case "init":
           return handleInit(config2, safeArgs);
         case "orient":
-          return handleOrient(adapter2, config2, safeArgs);
+          return handleOrient(adapter2, config2, safeArgs, server2.getClientVersion()?.name);
         case "papi":
-          return handleOrient(adapter2, config2, safeArgs);
+          return handleOrient(adapter2, config2, safeArgs, server2.getClientVersion()?.name);
         // alias (task-2223)
         case "hierarchy_update":
           return handleHierarchyUpdate(adapter2, safeArgs);
@@ -26987,6 +27528,8 @@ function createServer(adapter2, config2) {
           return handleContributorList(adapter2, config2, safeArgs);
         case "task_claim":
           return handleTaskClaim(adapter2, config2, safeArgs);
+        case "task_move":
+          return handleTaskMove(adapter2, config2, safeArgs);
         case "task_unclaim":
           return handleTaskUnclaim(adapter2, config2, safeArgs);
         case "inventory_sync":
@@ -27506,10 +28049,10 @@ async function dispatchRequest(args) {
 }
 
 // src/index.ts
-var __dirname = dirname5(fileURLToPath3(import.meta.url));
+var __dirname = dirname6(fileURLToPath4(import.meta.url));
 var pkgVersion = "unknown";
 try {
-  const pkg = JSON.parse(readFileSync14(join22(__dirname, "..", "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync15(join23(__dirname, "..", "package.json"), "utf-8"));
   pkgVersion = pkg.version;
 } catch {
 }