pan-wizard 3.27.0 → 3.29.0

package/pan-wizard-core/bin/lib/optimize.cjs

@@ -134,9 +134,82 @@ function getCurrentSessionId(cwd) {
   }
 }
 
+/**
+ * Day-scoped auto-session id, the same shape the trace hook mints
+ * (`sess_auto_YYYYMMDD`) so a day's hook-written and agent-reported events share one
+ * session instead of splitting into two.
+ */
+function autoSessionId(now = new Date()) {
+  const p = (n) => String(n).padStart(2, '0');
+  return `sess_auto_${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}`;
+}
+
+/**
+ * How long a `current-session` pointer is evidence of a live session. An explicit
+ * (non-auto) session used to stay "current" indefinitely — a July session was still
+ * current in September in a field project, so `readActiveSessionMeta` in the cost hook
+ * backfilled two-month-old command/phase onto today's ledger rows, and agent-reported
+ * events would have landed in a long-dead session's directory (field sweep 2026-09-17).
+ */
+const SESSION_STALE_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Last time anything was written to a session: its event log if it has one, else the
+ * moment it started. Null when the session cannot be read at all.
+ */
+function sessionLastActivityMs(cwd, sid) {
+  const dir = path.join(getTracesDir(cwd), sid);
+  try {
+    return fs.statSync(path.join(dir, TRACE_EVENT_FILE)).mtimeMs;
+  } catch { /* no events yet */ }
+  try {
+    const meta = JSON.parse(fs.readFileSync(path.join(dir, OPT_SESSION_FILE), 'utf-8'));
+    const t = new Date(meta.started_at).getTime();
+    return Number.isFinite(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Is this session finished, or too old to still be the one running? Read-only —
+ * finalizing a stale session is the writing path's job (the trace hook's rollover).
+ */
+function isSessionStale(cwd, sid, now = Date.now()) {
+  const dir = path.join(getTracesDir(cwd), sid);
+  try {
+    const meta = JSON.parse(fs.readFileSync(path.join(dir, OPT_SESSION_FILE), 'utf-8'));
+    if (meta && meta.ended_at) return true;
+  } catch { /* unreadable meta — fall through to the age test */ }
+  const last = sessionLastActivityMs(cwd, sid);
+  if (last === null) return true;
+  return now - last > SESSION_STALE_MS;
+}
+
+/**
+ * Append one trace event.
+ *
+ * Creates the day's auto-session when none is active. It used to return false instead,
+ * and the 16 `optimize trace log` call sites in the workflows are fire-and-forget
+ * (`2>/dev/null || true`), so on the phase pipeline — which never starts a trace
+ * session — every agent-reported event was silently discarded. Across fourteen field
+ * projects the instrument held 3,737 events, 99.7% of them the completion rows the hook
+ * writes, and not one error, gap or correction in its whole history (sweep 2026-09-17).
+ * An explicit `--session` is still honoured verbatim.
+ */
 function logTraceEvent(cwd, event, sessionId) {
-  const sid = sessionId || getCurrentSessionId(cwd);
-  if (!sid) return false;
+  // An explicit id is honoured verbatim. A POINTER, by contrast, is only evidence while
+  // the session it names is alive; a dead one is no session at all.
+  let sid = sessionId || null;
+  if (!sid) {
+    const current = getCurrentSessionId(cwd);
+    if (current && !isSessionStale(cwd, current)) sid = current;
+  }
+  if (!sid) {
+    const created = initTraceSession(cwd, { sessionId: autoSessionId(), description: 'auto-session (day-scoped)' });
+    if (!created || created.error) return false;
+    sid = created.session_id;
+  }
 
   try {
     const sessionDir = path.join(getTracesDir(cwd), sid);
@@ -1290,6 +1363,9 @@ module.exports = {
   TRACE_EVENT_FILE,
   OPT_SESSION_FILE,
   CURRENT_SESSION_FILE,
+  autoSessionId,
+  isSessionStale,
+  SESSION_STALE_MS,
   EVENT_TYPES,
   IMPACT_LEVELS,
   VALID_SCOPES,

package/pan-wizard-core/bin/lib/utils.cjs

@@ -182,10 +182,32 @@ function hasBraveSearchKey() {
   return fileAccessible(path.join(os.homedir(), '.pan-wizard', 'brave_api_key'));
 }
 
+/**
+ * Which workflow model a planning tree runs (PLANNING_MODEL_MARKERS). The phase model
+ * wins when its markers are present, since a phase project may also hold focus
+ * artifacts; `fragment` means entries exist but none of them mark a deliberate
+ * workflow, and `absent` that the directory could not be read.
+ *
+ * @param {string} planningDir - absolute path to the tree (e.g. planningPath(cwd))
+ * @returns {{model: 'phase'|'focus'|'campaign'|'fragment'|'empty'|'absent', evidence: string[], entries: number}}
+ */
+function detectPlanningModel(planningDir) {
+  const { PLANNING_MODEL_MARKERS } = require('./constants.cjs');
+  let entries;
+  try { entries = fs.readdirSync(planningDir); } catch { return { model: 'absent', evidence: [], entries: 0 }; }
+  const lower = new Set(entries.map(e => String(e).toLowerCase()));
+  for (const model of ['phase', 'focus', 'campaign']) {
+    const evidence = PLANNING_MODEL_MARKERS[model].filter(m => lower.has(m));
+    if (evidence.length) return { model, evidence, entries: entries.length };
+  }
+  return { model: entries.length ? 'fragment' : 'empty', evidence: [], entries: entries.length };
+}
+
 module.exports = {
   readJsonFile,
   removeQuotes,
   planningPath,
+  detectPlanningModel,
   planningRel,
   phasesPath,
   milestonesPath,

package/pan-wizard-core/bin/lib/verify.cjs

@@ -14,7 +14,8 @@ const {
   PLAN_SUFFIX, SUMMARY_SUFFIX, STANDARDS_FILE, STANDARDS_CATALOG, HEALTH_STATUS,
   BUILTIN_DRIFT_RULES, DRIFT_VERDICTS, BINARY_EXTENSIONS, DRIFT_MAX_FILES, DRIFT_MAX_FILE_SIZE, DRIFT_SEVERITY_WEIGHTS,
 } = require('./constants.cjs');
-const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles, fileAccessible } = require('./utils.cjs');
+const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles, fileAccessible, detectPlanningModel } = require('./utils.cjs');
+const { detectForeignPlanningTree } = require('./foreign-planning.cjs');
 // Drift detection lives in verify-drift.cjs; re-exported below so consumers of
 // verify.cjs are unaffected by the decomposition.
 const { runDriftCheck, parseConventionRules, checkFileConventions, calculateDriftScore, getChangedFiles, cmdDriftCheck } = require('./verify-drift.cjs');
@@ -1293,29 +1294,59 @@ function cmdValidateHealth(cwd, options, raw) {
 
   // Check 1: .planning/ exists (fatal if missing -- skip remaining checks)
   if (!checkPlanningDirExists(cwd, addIssue)) {
+    // A verdict payload carries `errors[]`, which is OUTSIDE output()'s error family
+    // (plural collections are detail, not a failure signal — see CLI-REFERENCE "Error
+    // Shape"), so the exit code must be set explicitly here, as `reconcile` does.
+    // `broken` → 1. Reality check RC2 (2026-09-10): this site exited 0 for a missing
+    // .planning/, so an orchestrator gating on the exit code read it as healthy.
     output({
       status: HEALTH_STATUS.BROKEN,
       errors,
       warnings,
       info,
       repairable_count: 0,
-    }, raw);
+    }, raw, undefined, 1);
     return;
   }
 
+  // Check 1b: the tree exists but belongs to another tool (gsd-core shares the
+  // directory name and PAN's legacy uppercase file names). Report that as its own
+  // error and stop: E002-E005 would describe a foreign layout as a broken PAN one,
+  // and --repair must never write into it. Reality check R15.
+  const foreign = detectForeignPlanningTree(planningPath(cwd));
+  if (foreign) {
+    addIssue('error', 'E006', `planning tree belongs to ${foreign.tool}: ${foreign.evidence.join(', ')}`, 'Run PAN with --planning-dir <dir> to use a separate tree (ADR-0043)');
+    output({ status: HEALTH_STATUS.BROKEN, errors, warnings, info, repairable_count: 0 }, raw, undefined, 1);
+    return;
+  }
+
+  // Check 1c: which workflow model is this tree running? Checks 2-8b below are the
+  // PHASE model's — a focus-model project (`/pan:focus`, no project/roadmap/state by
+  // design) and an orchestration campaign would each fail all of them and be called
+  // broken, which is what eight of fourteen field projects hit (sweep 2026-09-17).
+  // config.json is the one check every model shares.
+  const shape = detectPlanningModel(planningPath(cwd));
+  const phaseModel = shape.model === 'phase' || shape.model === 'fragment' || shape.model === 'empty';
+
   // Checks 2-8: individual structure and consistency checks
-  checkProjectFile(cwd, addIssue);
-  checkRoadmapFile(cwd, addIssue);
-  checkStateFile(cwd, addIssue, repairs);
+  if (phaseModel) {
+    checkProjectFile(cwd, addIssue);
+    checkRoadmapFile(cwd, addIssue);
+    checkStateFile(cwd, addIssue, repairs);
+  } else {
+    addIssue('info', 'I003', `${shape.model}-model project (${shape.evidence.join(', ')}) — the phase-model checks (project.md, roadmap.md, state.md, phases/) do not apply`, null);
+  }
   checkConfigFile(cwd, addIssue, repairs);
-  checkPhaseDirectories(cwd, addIssue);
-  checkPhaseContents(cwd, addIssue);
+  if (phaseModel) {
+    checkPhaseDirectories(cwd, addIssue);
+    checkPhaseContents(cwd, addIssue);
 
-  // Check 8b: cross-document state consistency
-  checkStateConsistency(cwd, addIssue, repairs);
+    // Check 8b: cross-document state consistency
+    checkStateConsistency(cwd, addIssue, repairs);
 
-  // Check 8c: verification gate (phases with verifier enabled need verification.md)
-  checkVerificationGate(cwd, addIssue);
+    // Check 8c: verification gate (phases with verifier enabled need verification.md)
+    checkVerificationGate(cwd, addIssue);
+  }
 
   // Check 9 (optional): standards compliance
   if (options.standards) {
@@ -1418,7 +1449,10 @@ function cmdValidateHealth(cwd, options, raw) {
     result.link_graph = linkGraphResult;
   }
 
-  output(result, raw);
+  // Explicit verdict exit: `broken` → 1; `degraded` and `healthy` → 0 (warnings are
+  // not failures). Computed AFTER --repair ran, so the code reflects the post-repair
+  // state the JSON reports. See the note at the early-return site above.
+  output(result, raw, undefined, status === HEALTH_STATUS.BROKEN ? 1 : 0);
 }
 
 /**

package/pan-wizard-core/bin/pan-tools.cjs

@@ -203,6 +203,7 @@ const codebase = require('./lib/codebase.cjs');
 const memory = require('./lib/memory.cjs');
 const bus = require('./lib/bus.cjs');
 const cost = require('./lib/cost.cjs');
+const costRebuild = require('./lib/cost-rebuild.cjs');
 const preview = require('./lib/preview.cjs');
 const reviewDeep = require('./lib/review-deep.cjs');
 const knowledge = require('./lib/knowledge.cjs');
@@ -1207,8 +1208,14 @@ async function main() {
         cost.cmdCostAppend(cwd, rec, raw);
       } else if (subcommand === 'clear') {
         cost.cmdCostClear(cwd, raw);
+      } else if (subcommand === 'rebuild') {
+        costRebuild.cmdCostRebuild(cwd, {
+          apply: args.includes('--apply'),
+          mainThread: !args.includes('--no-main-thread'),
+          claudeDir: getArgValue(args, '--claude-dir'),
+        }, raw);
       } else {
-        error('Unknown cost subcommand. Available: report, append, clear');
+        error('Unknown cost subcommand. Available: report, append, clear, rebuild');
       }
       break;
     }

package/pan-wizard-core/mcp/server.cjs

@@ -50,7 +50,36 @@ const META_SERVER_INFO_KEY = 'io.modelcontextprotocol/serverInfo';
 // claim to speak a version we don't. Newest first (the `server/discover` order).
 const SUPPORTED_VERSIONS_LIST = [MODERN_PROTOCOL_VERSION, '2025-06-18', '2025-03-26', '2024-11-05'];
 const SUPPORTED_PROTOCOL_VERSIONS = new Set(SUPPORTED_VERSIONS_LIST);
-const SERVER_INFO = { name: 'pan-mcp', version: '0.1.0' };
+/**
+ * The version the server reports in `initialize` / `server/discover`. Read from the
+ * package.json two levels up: the repository root in the source tree, the runtime
+ * directory in an install (the installer writes package.json beside pan-wizard-core/).
+ * The plugin bundles carry no package.json there, so fall back to the plugin manifest
+ * and finally to a marker that is visibly not a release. Never throws: a missing
+ * file must not stop the server from answering. Reality check R9: this was a literal
+ * '0.1.0' while the package shipped 3.x.
+ */
+function readPackageVersion(baseDir = path.join(__dirname, '..', '..')) {
+  // Order: the repo/runtime package.json when it carries a version; the install
+  // manifest every runtime writes (the runtime directory's package.json is a bare
+  // `{"type":"commonjs"}` marker with no version — measured on a fresh install,
+  // 2026-09-10, where the first version of this reader answered 0.0.0-unknown); the
+  // Claude plugin manifest; an Agent Plugins manifest.
+  const candidates = [
+    path.join(baseDir, 'package.json'),
+    path.join(baseDir, 'pan-file-manifest.json'),
+    path.join(baseDir, '.claude-plugin', 'plugin.json'),
+    path.join(baseDir, 'plugin.json'),
+  ];
+  for (const file of candidates) {
+    try {
+      const v = JSON.parse(fs.readFileSync(file, 'utf8')).version;
+      if (typeof v === 'string' && v.trim()) return v.trim();
+    } catch { /* try the next candidate */ }
+  }
+  return '0.0.0-unknown';
+}
+const SERVER_INFO = { name: 'pan-mcp', version: readPackageVersion() };
 
 /**
  * Default engine location: `bin/` is a sibling of this `mcp/` directory inside
@@ -75,6 +104,25 @@ function defaultPanToolsPath() {
   return path.join(__dirname, '..', 'bin', 'pan-tools.cjs');
 }
 
+/**
+ * A verdict payload: a JSON object with no error-family key. The family is `error`
+ * and any key ending in `_error` — the same definition core.cjs's reportsFailure()
+ * uses for the CLI exit code, mirrored here because the server stays engine-agnostic
+ * (it never requires the engine's modules; it spawns them). Plural collections such
+ * as `errors[]` are verdict DETAIL, not a failure signal. Returns the parsed object,
+ * or null when the text is not such a payload.
+ */
+function parseVerdict(text) {
+  if (typeof text !== 'string' || !text.trim()) return null;
+  let parsed;
+  try { parsed = JSON.parse(text); } catch { return null; }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+  for (const k of Object.keys(parsed)) {
+    if (k === 'error' || k.endsWith('_error')) { if (parsed[k]) return null; }
+  }
+  return parsed;
+}
+
 /** Real spawn: shell-less execFile of `node <argv...>`. */
 function defaultSpawn(nodeArgs) {
   try {
@@ -154,7 +202,7 @@ function createServer(opts = {}) {
   const gitImpl = opts.gitImpl || makeDefaultGit(cwd);
   const env = opts.env || process.env;
 
-  function runVerb(verb, extraArgs) {
+  function runVerb(verb, extraArgs, verbCwd = cwd) {
     // Defense in depth: the verb always comes from the registry, but re-check the
     // forbidden pattern here so no future caller can smuggle a force/reset op past it.
     if (reg.FORBIDDEN_VERB.test(verb)) {
@@ -163,22 +211,46 @@ function createServer(opts = {}) {
     // No --raw: pan-tools' default output is structured JSON (which is what the MCP
     // client wants); --raw would instead emit a bare human scalar. Large results
     // arrive via the @file: overflow protocol, resolved here.
-    const r = spawn([panToolsPath, verb, ...extraArgs, '--cwd', cwd]);
+    const r = spawn([panToolsPath, verb, ...extraArgs, '--cwd', verbCwd]);
     if (r && r.ok) r.stdout = resolveOverflow(r.stdout);
     return r;
   }
 
+  /**
+   * Per-call project root (ADR-0045 D6). Every TOOL accepts an optional `cwd`;
+   * it must be an absolute path to an existing directory. Returns
+   * { cwd, input } with the field removed from the input handed to the tool, or
+   * { error } shaped for a -32602 — a bad root is a bad REQUEST, and nothing is
+   * spawned. Resources never come through here: their argv is static.
+   */
+  function resolveCallCwd(input) {
+    const src = input || {};
+    if (src.cwd === undefined) return { cwd, input: src };
+    let candidate;
+    try { candidate = reg.validateProjectCwd(src.cwd); }
+    catch (e) { return { error: { code: -32602, message: String((e && e.message) || e) } }; }
+    let isDir = false;
+    try { isDir = fs.statSync(candidate).isDirectory(); } catch { /* absent → not a directory */ }
+    if (!isDir) return { error: { code: -32602, message: `Invalid "cwd": not an existing directory: ${candidate}` } };
+    const { cwd: _omit, ...rest } = src;
+    return { cwd: path.resolve(candidate), input: rest };
+  }
+
   // Returns { error:{code,message} } for JSON-RPC protocol errors (unknown tool /
   // invalid arguments — a bad *request*), or { result:{content,isError} } where
   // isError:true signals a genuine tool *execution* failure (the verb ran and failed).
   function callTool(name, input) {
     const tool = reg.byToolName[name];
     if (!tool) return { error: { code: -32602, message: `Unknown tool: ${name}` } };
+    const call = resolveCallCwd(input);
+    if (call.error) return { error: call.error };
     // Native, in-process tools (orchestrator / merge gate) run a handler; a thrown
     // Error means bad params (-32602), matching the spawn-tool validation path.
+    // The git executor follows the per-call root unless a test injected one.
     if (typeof tool.handler === 'function') {
       try {
-        const out = tool.handler({ cwd, input: input || {}, env, gitImpl });
+        const gitForCall = opts.gitImpl ? gitImpl : (call.cwd === cwd ? gitImpl : makeDefaultGit(call.cwd));
+        const out = tool.handler({ cwd: call.cwd, input: call.input, env, gitImpl: gitForCall });
         const text = (out && out.text != null) ? out.text : JSON.stringify(out && out.json);
         return { result: { content: [{ type: 'text', text }], isError: !!(out && out.isError) } };
       } catch (e) {
@@ -186,9 +258,9 @@ function createServer(opts = {}) {
       }
     }
     let extra;
-    try { extra = tool.args ? tool.args(input || {}) : []; }
+    try { extra = tool.args ? tool.args(call.input) : []; }
     catch (e) { return { error: { code: -32602, message: String((e && e.message) || e) } }; }
-    const r = runVerb(tool.verb, extra);
+    const r = runVerb(tool.verb, extra, call.cwd);
     return { result: { content: [{ type: 'text', text: r.ok ? r.stdout : (r.stderr || 'error') }], isError: !r.ok } };
   }
 
@@ -206,7 +278,19 @@ function createServer(opts = {}) {
     // non-array into the spawn.
     const tail = Array.isArray(res.args) ? res.args : [];
     const r = runVerb(res.verb, tail);
-    if (!r.ok) return { error: { code: -32603, message: r.stderr || 'resource read failed' } };
+    if (!r.ok) {
+      // A VERDICT is data, not a failed read. `validate health` (pan://health) exits
+      // non-zero when its verdict is `broken` — CLI-REFERENCE: verdict commands set
+      // their exit code explicitly, for shell gating — while still printing the full
+      // JSON report. Over MCP the report IS the resource, so accept stdout when it is
+      // a JSON object carrying no error-family key. Anything else (no JSON, or an
+      // `error`/`*_error` key) is a genuine read failure → JSON-RPC error.
+      const text = resolveOverflow(r.stdout);
+      if (parseVerdict(text) !== null) {
+        return { result: { contents: [{ uri, mimeType: 'application/json', text }] } };
+      }
+      return { error: { code: -32603, message: r.stderr || 'resource read failed' } };
+    }
     return { result: { contents: [{ uri, mimeType: 'application/json', text: r.stdout }] } };
   }
 
@@ -315,6 +399,6 @@ function main() {
 if (require.main === module) main();
 
 module.exports = {
-  createServer, defaultPanToolsPath, defaultSpawn, SERVER_INFO, toMcpTool, toMcpResource,
+  createServer, defaultPanToolsPath, defaultSpawn, parseVerdict, readPackageVersion, SERVER_INFO, toMcpTool, toMcpResource,
   PROTOCOL_VERSION, MODERN_PROTOCOL_VERSION, SUPPORTED_VERSIONS_LIST, META_PROTOCOL_VERSION_KEY,
 };

package/pan-wizard-core/mcp/tool-registry.cjs

@@ -39,7 +39,9 @@ const QUERY_RE = /^[\w .,:/&()-]{1,120}$/;    // find-phase query fragment
  *
  * THE RULE FOR ADDING ONE — a resource must be readable on ANY project, including
  * a bare directory with no `.planning/`. If "no data yet" is reported as an error
- * (non-zero exit / an error-family key), it is a TOOL, not a resource: a client
+ * (an error-family key in the JSON it prints, or no JSON at all — a non-zero exit BY
+ * ITSELF is a verdict signal for shell gating, and the reader accepts the JSON as data;
+ * see server.cjs readResource), it is a TOOL, not a resource: a client
  * that lists resources and reads them should not collect failures for a young
  * project. `preview` is the worked example — `preview phases` exits non-zero
  * without a roadmap, so it is exposed as a tool below rather than as a resource.
@@ -62,7 +64,7 @@ const RESOURCES = [
     description: 'Phase inventory: the phase directories present, with a count.' },
   { uri: 'pan://progress', name: 'Progress',      verb: 'progress', description: 'Requirement and plan completion progress.' },
   { uri: 'pan://health',   name: 'Project health', verb: 'validate', args: ['health'],
-    description: 'Health check over .planning/: issue codes with severities. Reports an unhealthy project as DATA (exit 0), so it is readable even on a broken or empty one.' },
+    description: 'Health check over .planning/: issue codes with severities. Reports an unhealthy project as DATA: the JSON verdict is the resource even when the CLI exits non-zero for shell gating, so it is readable on a broken or empty project.' },
   { uri: 'pan://links',    name: 'Doc-code links', verb: 'links',   args: ['validate'],
     description: 'Doc↔code link graph verdict: forward links, backlink contracts, and anchor targets, with finding codes.' },
   { uri: 'pan://cost',     name: 'Token cost',     verb: 'cost',    args: ['report'],
@@ -138,7 +140,51 @@ const FORBIDDEN_VERB = /(^|-)(push|reset|rebase|force)($|-)/;
 // tools into one advertised list. Required after SPAWN_TOOLS/FORBIDDEN_VERB so the
 // native module (which imports nothing back from here) composes cleanly — no cycle.
 const { NATIVE_TOOLS } = require('./native-tools.cjs');
-const TOOLS = [...SPAWN_TOOLS, ...NATIVE_TOOLS];
+
+// ─── Per-call project root (ADR-0045 D6, 2026-09) ───────────────────────────
+//
+// The server resolves its project as `opts.cwd || PAN_PROJECT_ROOT || process.cwd()`.
+// Under Claude Code the process cwd IS the project. Under an Agent Plugins client
+// the spec makes the PLUGIN ROOT the default working directory of a stdio server,
+// so every verb would read `.planning/` from inside the plugin cache and report an
+// empty project — cleanly, which is the worst kind of failure. So every TOOL takes
+// an optional `cwd`: the absolute path of the project to operate on, honoured for
+// that call only. Applied here, centrally, so a tool added later cannot miss it.
+//
+// Resources deliberately do NOT get it: their argv is a static array and the
+// safety argument of ADR-0041 is that no client input reaches it.
+const PROJECT_CWD_PROPERTY = Object.freeze({
+  type: 'string',
+  description: 'Absolute path of the PAN project to operate on. Optional: defaults to the directory the server was started in. Pass it when the server was launched from a plugin directory (Agent Plugins clients do this by default), or to address another project.',
+});
+
+const PROJECT_CWD_MAX = 1024;
+
+/**
+ * Shape-validate a per-call project root: a non-empty absolute path with no NUL,
+ * within a sane length. Existence is the SERVER's check (it has fs); this module
+ * stays pure. Throws a message fit for a -32602 on failure.
+ */
+function validateProjectCwd(value) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > PROJECT_CWD_MAX) {
+    throw new Error(`Invalid "cwd": must be a non-empty string of at most ${PROJECT_CWD_MAX} chars`);
+  }
+  if (value.includes('\0')) throw new Error('Invalid "cwd": contains a NUL byte');
+  // Absolute on either platform family: `/…`, `C:\…`, `C:/…`, or a UNC `\\host\share`.
+  if (!/^(?:\/|[A-Za-z]:[\\/]|\\\\)/.test(value)) throw new Error('Invalid "cwd": must be an absolute path');
+  return value;
+}
+
+/** Return a copy of a tool descriptor whose inputSchema also accepts `cwd`. Never mutates the source. */
+function withProjectCwd(tool) {
+  const schema = tool.inputSchema || { type: 'object', additionalProperties: false, properties: {} };
+  return {
+    ...tool,
+    inputSchema: { ...schema, properties: { ...(schema.properties || {}), cwd: PROJECT_CWD_PROPERTY } },
+  };
+}
+
+const TOOLS = [...SPAWN_TOOLS, ...NATIVE_TOOLS].map(withProjectCwd);
 
 const byToolName = Object.create(null);
 for (const t of TOOLS) byToolName[t.name] = t;
@@ -148,4 +194,5 @@ for (const r of RESOURCES) byResourceUri[r.uri] = r;
 module.exports = {
   TOOLS, SPAWN_TOOLS, NATIVE_TOOLS, RESOURCES, byToolName, byResourceUri, FORBIDDEN_VERB,
   AGENT_RE, PHASE_RE, QUERY_RE, str,
+  PROJECT_CWD_PROPERTY, validateProjectCwd, withProjectCwd,
 };

package/pan-wizard-core/references/model-profiles.md

@@ -11,8 +11,8 @@ PAN uses three abstract tiers instead of hardcoded model names:
 | Tier | Purpose | Anthropic | OpenAI | Google |
 |------|---------|-----------|--------|--------|
 | `reasoning` | Architecture, planning, complex decisions | inherit (your session's top-tier model) | inherit | inherit |
-| `mid` | Execution, research, verification | Sonnet | mid | mid |
-| `fast` | Read-only extraction, budget tasks | Haiku | fast | fast |
+| `mid` | Execution, research, verification | Sonnet | mid | gemini-2.5-flash |
+| `fast` | Read-only extraction, budget tasks | Haiku | fast | gemini-2.5-flash-lite |
 
 **Why `inherit` for reasoning?** Host runtimes map "opus" to a specific model version. PAN returns `inherit` for reasoning-tier agents, so they use whatever top-tier model the user has configured. This avoids version conflicts and silent fallbacks.
 

package/pan-wizard-core/workflows/health.md

@@ -152,6 +152,7 @@ Report final status.
 | E003 | error | roadmap.md not found | No |
 | E004 | error | state.md not found | Yes |
 | E005 | error | config.json parse error | Yes |
+| E006 | error | `.planning/` belongs to another tool (gsd-core markers found); PAN stops before E002-E005 and `--repair` writes nothing | No |
 | W001 | warning | project.md missing required section | No |
 | W002 | warning | state.md references invalid phase | Yes |
 | W003 | warning | config.json not found | Yes |
@@ -161,6 +162,7 @@ Report final status.
 | W007 | warning | Phase on disk but not in ROADMAP | No |
 | I001 | info | Plan without SUMMARY (may be in progress) | No |
 | I002 | info | Phase in ROADMAP ahead of current phase, not planned yet | No |
+| I003 | info | Focus-model or campaign tree — the phase-model checks do not apply | No |
 | STATE_REQ_DRIFT | warning | state.md complete but REQUIREMENTS.md has unchecked boxes | Yes |
 | STATE_ROADMAP_DRIFT | warning | state.md complete but roadmap.md has unchecked plan boxes | Yes |
 | VERIFICATION_GATE_MISSING | warning | Phase has completed plans but no verification record | No |

package/pan-zcode/README.md

@@ -13,7 +13,7 @@ ZCode through the one interface it speaks: **MCP**.
 
 ## How it fits
 
-```
+```text
 ZCode harness (GLM-5.2)          primary Agent drives everything; ported subagents fan out
         │  MCP · local stdio
 pan-wizard-core/mcp  (SHARED)    a thin, zero-dep bridge — verbs → MCP tools/resources