pan-wizard 3.32.0 → 3.34.0

package/hooks/dist/pan-state-reinject.js

@@ -18,11 +18,30 @@
 // `compact` matcher on both; the source is re-checked here so a registration
 // without the matcher stays inert on every other start.
 //
+// Gemini CLI and Copilot CLI (market-ideas M33) restart no session after a
+// compaction (Gemini's SessionStart sources: startup | resume | clear; Copilot's:
+// startup | resume | new), and their pre-compaction events cannot add context
+// (Gemini PreCompress and Copilot preCompact are advisory). So there the block
+// arrives in two steps:
+//   --mark            on PreCompress / preCompact: when a PAN phase is in flight,
+//                     leave a per-session marker in the per-user hook directory
+//                     under the OS temp directory (0700, written 0600);
+//   --inject <host>   on the next tool result (Gemini AfterTool, Copilot
+//                     postToolUse): consume the marker and return the block once,
+//                     in that host's output shape. With no marker it prints nothing.
+// A tool result is the first point after a compaction where both hosts take added
+// context, including an autonomous `-p` run that never sees another prompt (read
+// 2026-10-03: gemini-cli v0.61.0 docs/hooks/reference.md; the Copilot hooks
+// reference on docs.github.com). The marker modes need no R39 deferral: in a
+// project with both installs, Copilot also runs Claude's registration of this
+// script, but that one is the SessionStart mode, which a Copilot start never matches.
+//
 // Inert unless the project is a PAN project with work in flight: `.planning/`
 // holds a state.md that names a current phase AND a roadmap.md with an unticked
 // phase. Everywhere else — no planning tree, a focus-only project, a finished
-// milestone — it prints nothing. It never writes a file (field finding: hooks
-// that scaffolded `.planning/` in projects that never ran PAN).
+// milestone — it prints nothing. It never writes into the project (field finding:
+// hooks that scaffolded `.planning/` in projects that never ran PAN); the only
+// file it writes is the marker, outside the project.
 //
 // Fail-open everywhere: bad stdin, unreadable files — exit 0 silently. A missing
 // reminder costs a re-read; a crashed hook is a failing hook at every start.
@@ -31,7 +50,9 @@
 // additionalContext; each field is truncated on its own.
 
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
+const crypto = require('crypto');
 
 /**
  * Which planning tree this hook acts on.
@@ -124,7 +145,99 @@ function readIfExists(p) {
   try { return fs.readFileSync(p, 'utf8'); } catch { return null; }
 }
 
+// ─── The marker (Gemini, Copilot) ─────────────────────────────────────────────
+
+// A marker older than this belongs to a session that never made another tool call.
+const MARKER_TTL_MS = 6 * 60 * 60 * 1000;
+
+/** Gemini sends `session_id`; Copilot's camelCase payloads send `sessionId`. */
+function sessionIdOf(payload) {
+  for (const k of ['session_id', 'sessionId']) {
+    if (typeof payload[k] === 'string' && payload[k]) return payload[k];
+  }
+  return '';
+}
+
+/** The per-user hook directory's name: the stop guard's and the context monitor's too. */
+function hookDirName() {
+  const uid = (typeof process.getuid === 'function' ? process.getuid() : process.env.USERNAME || 'win');
+  return `pan-hooks-${uid}`;
+}
+
+// Per-user hook state directory inside tmpdir, created 0700 — the same directory
+// and the same checks as hookStateDir() in pan-stop-guard.js (hooks are standalone
+// files and cannot require one another). Null when the directory is not provably
+// ours: on a shared host another user must not be able to plant a marker that
+// injects, or a symlink the marker is written through (M60).
+function hookStateDir() {
+  const dir = path.join(os.tmpdir(), hookDirName());
+  try {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const st = fs.lstatSync(dir);
+    if (st.isSymbolicLink()) return null;
+    // POSIX-only ownership and mode checks: Windows fakes mode bits (N15).
+    if (typeof process.getuid === 'function') {
+      if (st.uid !== process.getuid()) return null;
+      if ((st.mode & 0o077) !== 0) return null;
+    }
+    return dir;
+  } catch { return null; }
+}
+
+/** One marker per (session, project), named by a hash so neither leaks into a file name. Pure. */
+function markerName(sessionId, projectDir) {
+  const key = crypto.createHash('sha256').update(`${sessionId}\u0000${path.resolve(projectDir)}`).digest('hex').slice(0, 32);
+  return `state-reinject-${key}.json`;
+}
+
+// This hook's files in the shared directory: markers, and one a crash left mid-take.
+const MARKER_FILE_RE = /^state-reinject-[0-9a-f]{32}\.json(?:\.\d+\.taken)?$/;
+
+function writeMarker(file, now = Date.now()) {
+  fs.writeFileSync(file, JSON.stringify({ at: now }), { mode: 0o600 });
+  // Sweep markers no session came back for — only this hook's: the directory
+  // holds the other hooks' state too. Best effort.
+  try {
+    for (const name of fs.readdirSync(path.dirname(file))) {
+      if (!MARKER_FILE_RE.test(name)) continue;
+      const p = path.join(path.dirname(file), name);
+      try { if (now - fs.statSync(p).mtimeMs > MARKER_TTL_MS) fs.unlinkSync(p); } catch { /* raced */ }
+    }
+  } catch { /* unreadable dir */ }
+}
+
+/**
+ * Take the marker if there is a fresh one: rename it first, so two hooks racing on
+ * the same tool result cannot both inject. True when this call took it.
+ */
+function takeMarker(file, now = Date.now()) {
+  const taken = `${file}.${process.pid}.taken`;
+  try { fs.renameSync(file, taken); } catch { return false; }
+  let fresh = false;
+  try { fresh = now - JSON.parse(fs.readFileSync(taken, 'utf8')).at <= MARKER_TTL_MS; } catch { /* unreadable: stale */ }
+  try { fs.unlinkSync(taken); } catch { /* gone */ }
+  return fresh;
+}
+
+/** The block in the shape each host's tool-result event takes. */
+function injectOutput(host, context) {
+  if (host === 'gemini') return { hookSpecificOutput: { hookEventName: 'AfterTool', additionalContext: context } };
+  if (host === 'copilot') return { additionalContext: context };
+  return null;
+}
+
+function contextFor(projectDir) {
+  return buildReinjectContext({
+    stateContent: readIfExists(planningPath(projectDir, 'state.md')),
+    roadmapContent: readIfExists(planningPath(projectDir, 'roadmap.md')),
+    planningRel: planningDirName(),
+  });
+}
+
 function main() {
+  const argv = process.argv.slice(2);
+  const mode = argv.includes('--mark') ? 'mark' : argv.includes('--inject') ? 'inject' : 'session-start';
+  const host = mode === 'inject' ? argv[argv.indexOf('--inject') + 1] : null;
   let input = '';
   process.stdin.setEncoding('utf8');
   process.stdin.on('data', chunk => { input += chunk; });
@@ -133,20 +246,32 @@ function main() {
       let payload = {};
       try { payload = JSON.parse(input); } catch { /* fail open on bad stdin */ }
       if (!payload || typeof payload !== 'object') payload = {};
-      if (payload.source !== 'compact') { process.exit(0); return; }
-
       const projectDir = typeof payload.cwd === 'string' && payload.cwd ? payload.cwd : process.cwd();
-      const context = buildReinjectContext({
-        stateContent: readIfExists(planningPath(projectDir, 'state.md')),
-        roadmapContent: readIfExists(planningPath(projectDir, 'roadmap.md')),
-        planningRel: planningDirName(),
-      });
-      if (context) {
-        process.stdout.write(JSON.stringify({
-          hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: context },
-        }));
+
+      if (mode === 'session-start') {
+        if (payload.source !== 'compact') { process.exit(0); return; }
+        const context = contextFor(projectDir);
+        if (context) {
+          process.stdout.write(JSON.stringify({
+            hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: context },
+          }));
+        }
+      } else {
+        const sid = sessionIdOf(payload);
+        // An unknown host leaves the marker for a host that can use it.
+        if (!sid || (mode === 'inject' && !injectOutput(host, ''))) { process.exit(0); return; }
+        const dir = hookStateDir();
+        if (!dir) { process.exit(0); return; }
+        const file = path.join(dir, markerName(sid, projectDir));
+        if (mode === 'mark') {
+          if (contextFor(projectDir)) writeMarker(file);
+        } else if (takeMarker(file)) {
+          // Re-read now: the position after the compaction, not before it.
+          const context = contextFor(projectDir);
+          if (context) process.stdout.write(JSON.stringify(injectOutput(host, context)));
+        }
       }
-    } catch { /* fail open — never break a session start */ }
+    } catch { /* fail open — never break a session or a tool call */ }
     process.exit(0);
   });
 }
@@ -155,4 +280,4 @@ if (require.main === module) {
   main();
 }
 
-module.exports = { buildReinjectContext, UNTICKED_PHASE_RE };
+module.exports = { buildReinjectContext, UNTICKED_PHASE_RE, markerName, hookDirName, sessionIdOf, injectOutput, MARKER_TTL_MS };

package/hooks/dist/pan-statusline.js

@@ -30,6 +30,54 @@ function buildStatuslineOutput(data, deps) {
   const session = data.session_id || '';
   const remaining = data.context_window?.remaining_percentage;
 
+  // The per-user 0700 bridge directory, or null when it is not safe to write into.
+  // Mirrors bridgeDir() in pan-context-monitor.js (the reader).
+  let bridgeSubdirMemo;
+  const secureBridgeDir = () => {
+    if (bridgeSubdirMemo !== undefined) return bridgeSubdirMemo;
+    bridgeSubdirMemo = null;
+    const uid = (typeof process.getuid === 'function' ? process.getuid() : process.env.USERNAME || 'win');
+    const sub = pathMod.join(tmpDir, `pan-hooks-${uid}`);
+    // Fail CLOSED if the per-user dir is pre-planted/symlinked/owned by someone
+    // else: mkdirSync{recursive} silently no-ops on an existing dir, so verify
+    // ownership+mode before writing (M60).
+    try {
+      fsMod.mkdirSync(sub, { recursive: true, mode: 0o700 });
+      const st = fsMod.lstatSync(sub);
+      // Symlink check is cross-platform; POSIX ownership/mode checks apply only
+      // where getuid exists (Windows fakes mode bits; gating on them there
+      // disabled the bridge entirely, N15).
+      let secure = !st.isSymbolicLink();
+      if (secure && typeof process.getuid === 'function') {
+        secure = st.uid === process.getuid() && (st.mode & 0o077) === 0;
+      }
+      if (secure) bridgeSubdirMemo = sub;
+    } catch { /* not safe */ }
+    return bridgeSubdirMemo;
+  };
+
+  // Usage limits (Claude Code subscriptions: `rate_limits.five_hour` / `seven_day`).
+  // Account-wide, so one file for every session; `pan-tools cost limits` and the
+  // focus-auto weekly stop read it. Written only when the host sent the block.
+  const limits = data.rate_limits && typeof data.rate_limits === 'object' ? data.rate_limits : null;
+  const limitWin = (w) => (w && Number.isFinite(Number(w.used_percentage))
+    ? { used_percentage: Number(w.used_percentage), ...(Number.isFinite(Number(w.resets_at)) ? { resets_at: Number(w.resets_at) } : {}) }
+    : null);
+  const fiveHour = limits ? limitWin(limits.five_hour) : null;
+  const sevenDay = limits ? limitWin(limits.seven_day) : null;
+  if ((fiveHour || sevenDay) && d.skipBridge !== true) {
+    try {
+      const sub = secureBridgeDir();
+      if (sub) {
+        fsMod.writeFileSync(pathMod.join(sub, 'claude-limits.json'), JSON.stringify({
+          ...(fiveHour ? { five_hour: fiveHour } : {}),
+          ...(sevenDay ? { seven_day: sevenDay } : {}),
+          timestamp: Math.floor(Date.now() / 1000),
+        }), { mode: 0o600 });
+      }
+    } catch { /* best-effort */ }
+  }
+
   // Context window bar — shows USED percentage scaled so 80% real = 100% shown.
   let ctx = '';
   if (remaining != null) {
@@ -39,34 +87,23 @@ function buildStatuslineOutput(data, deps) {
 
     if (session && d.skipBridge !== true) {
       try {
-        // Write the bridge file into a per-user 0700 subdir so another user on
+        // The session bridge goes into the per-user 0700 subdir so another user on
         // a shared host can't symlink-attack the predictable session path.
-        // Mirrors bridgeDir() in pan-context-monitor.js (the reader).
-        const uid = (typeof process.getuid === 'function' ? process.getuid() : process.env.USERNAME || 'win');
-        const bridgeSubdir = pathMod.join(tmpDir, `pan-hooks-${uid}`);
-        // Fail CLOSED if the per-user dir is pre-planted/symlinked/owned by
-        // someone else — mkdirSync{recursive} silently no-ops on an existing dir,
-        // so verify ownership+mode before writing the session bridge (M60).
-        let secure = false;
-        try {
-          fsMod.mkdirSync(bridgeSubdir, { recursive: true, mode: 0o700 });
-          const st = fsMod.lstatSync(bridgeSubdir);
-          // Symlink check is cross-platform; POSIX ownership/mode checks apply
-          // only where getuid exists (Windows fakes mode bits — gating on them
-          // there disabled the bridge entirely, N15).
-          secure = !st.isSymbolicLink();
-          if (secure && typeof process.getuid === 'function') {
-            secure = st.uid === process.getuid() && (st.mode & 0o077) === 0;
-          }
-        } catch { secure = false; }
-        if (secure) {
+        const bridgeSubdir = secureBridgeDir();
+        if (bridgeSubdir) {
           const bridgePath = pathMod.join(bridgeSubdir, `claude-ctx-${session}.json`);
+          // Token counts and the model id let the context monitor measure against
+          // the window the host compacts at, not the model window (O7).
+          const cw = data.context_window || {};
           fsMod.writeFileSync(bridgePath, JSON.stringify({
             session_id: session,
             remaining_percentage: remaining,
             used_pct: used,
+            ...(Number.isFinite(cw.total_input_tokens) ? { total_input_tokens: cw.total_input_tokens } : {}),
+            ...(Number.isFinite(cw.context_window_size) ? { context_window_size: cw.context_window_size } : {}),
+            ...(data.model && data.model.id ? { model_id: data.model.id } : {}),
             timestamp: Math.floor(Date.now() / 1000),
-          }));
+          }), { mode: 0o600 });
         }
       } catch { /* bridge is best-effort */ }
     }
@@ -154,7 +191,16 @@ function buildStatuslineOutput(data, deps) {
   const head = `${panUpdate}\x1b[2m${model}\x1b[0m`;
   const taskSegment = task ? ` │ \x1b[1m${task}\x1b[0m` : '';
   const dirSegment = ` │ \x1b[2m${dirname}\x1b[0m`;
-  return `${head}${taskSegment}${dirSegment}${ctx}${cacheBadge}${thinkingBadge}`;
+  // Usage-limit badge: the window closer to its cap, green below 70%, yellow below
+  // 90%, red from 90% (focus-auto's default weekly stop).
+  let limitBadge = '';
+  const shown = [fiveHour && ['5h', fiveHour.used_percentage], sevenDay && ['7d', sevenDay.used_percentage]].filter(Boolean);
+  if (shown.length) {
+    const worst = Math.max(...shown.map(([, v]) => v));
+    const color = worst >= 90 ? '' : worst >= 70 ? '' : '';
+    limitBadge = ` ${color}${shown.map(([k, v]) => `${k} ${Math.round(v)}%`).join(' · ')}`;
+  }
+  return `${head}${taskSegment}${dirSegment}${ctx}${cacheBadge}${thinkingBadge}${limitBadge}`;
 }
 
 // ─── Stdin driver ───────────────────────────────────────────────────────────

package/hooks/dist/pan-stop-guard.js

@@ -73,6 +73,10 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+// The CLI the block reason tells the agent to run. Installs and the plugin put the
+// core beside hooks/; no `pan-tools` bin is on PATH.
+const PAN_TOOLS = `node "${path.join(__dirname, '..', 'pan-wizard-core', 'bin', 'pan-tools.cjs').split(path.sep).join('/')}"`;
+
 // ─── R39: one run per hook when Claude and Copilot share a project ───────────
 // Copilot CLI also runs the hooks in a repository's .claude/settings.json and
 // .claude/settings.local.json. Measured 2026-09-26 (Copilot CLI 1.0.88, repository
@@ -205,8 +209,9 @@ function buildStopDecision({ stopHookActive, config, stateContent, roadmapConten
       `Continue the chain now: if the current phase is finished, follow transition.md's ` +
       `offer_next_phase Route A and spawn Phase ${nextPhase} as a Task subagent ` +
       `(plan-phase orchestrator, ARGUMENTS='${nextPhase} --auto'); if the current phase is ` +
-      `mid-flight, resume it instead. If the user explicitly asked to stop, first run: ` +
-      `pan-tools config-set workflow.auto_advance false — then stop. ` +
+      `mid-flight, resume it instead. If the user explicitly asked to stop, first run ` +
+      `\`${PAN_TOOLS} config-set workflow.auto_advance false\` (under mode: yolo, which arms this ` +
+      `guard by itself, set \`workflow.stop_guard false\` the same way instead) — then stop. ` +
       `(Disable this guard permanently with workflow.stop_guard: false.)`
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pan-wizard",
-  "version": "3.32.0",
+  "version": "3.34.0",
   "description": "Command a bot army for your codebase: a reasoning-tier Mission Control delegates whole-project goals to specialist squads and ships behind a human merge gate. Five AI CLIs, zero context rot.",
   "bin": {
     "pan-wizard": "bin/install.js"

package/pan-wizard-core/bin/lib/agents-md.cjs

@@ -29,7 +29,10 @@ function buildAgentsMdSection() {
     'This project uses PAN Wizard for structured, phase-based planning and execution.',
     '',
     '- `.planning/` is PAN\'s state directory (state.md, roadmap.md, phase directories). Treat it as the source of truth for planning state and modify it through PAN commands, not by hand.',
-    '- PAN commands install as `pan-*` skills/commands (for example `/pan-help`, `/pan-new-project`, `/pan-exec-phase`). Start with `/pan-help`.',
+    // One section serves every runtime in the project, so it names each one's form
+    // (the README's list); `/pan-help` alone sent Claude Code users to a command
+    // that does not exist there (prompt audit, market-ideas M34).
+    '- PAN\'s commands are named per runtime: `/pan:help`, `/pan:new-project`, `/pan:exec-phase` in Claude Code and Gemini CLI; `/pan-help` and so on in OpenCode, Copilot CLI and unified-skills Claude installs; `$pan-help` in Codex. Start with the help command.',
     '- The `pan-tools` dispatcher backs every command; it lives under `pan-wizard-core/` inside the runtime\'s config directory (or `.agents/` for unified installs).',
     PAN_AGENTS_END,
   ].join('\n');
@@ -79,19 +82,56 @@ function removeAgentsMdSection(existing) {
 }
 
 /**
- * Ensure CLAUDE.md bridges to AGENTS.md via a marker-fenced @AGENTS.md import
- * (Claude Code's documented pattern for adopting the universal rules file).
- * Idempotent; preserves all user content.
+ * PAN's block in CLAUDE.md: the @AGENTS.md import, and Claude Code's "Compact
+ * instructions" section (memory optimisation O8). Claude Code reads a section of
+ * that name in the project-root CLAUDE.md when it summarises a conversation, and
+ * re-reads CLAUDE.md from disk after compaction. The section names what the summary
+ * must keep for PAN work to resume where it stopped.
+ *
+ * Codex is deliberately left out: its `compact_prompt` replaces the built-in
+ * compaction prompt rather than adding to it, and the default OpenAI provider
+ * ignores it (read 2026-10-04), so PAN would be swapping a tuned prompt for one
+ * that may never run. PAN's state re-injection after compaction covers Codex.
+ */
+function buildClaudeMdBridge() {
+  return [
+    PAN_AGENTS_BEGIN,
+    '@AGENTS.md',
+    '',
+    '# Compact instructions',
+    '',
+    'When this conversation is compacted, keep what PAN work needs to resume where it stopped:',
+    '- the current phase and plan, and the task in progress with its stopping point (`.planning/state.md` records them; keep that path);',
+    '- decisions made in this session that `.planning/state.md` does not yet hold;',
+    '- the files changed since the last commit.',
+    'Leave out file contents and command output: they can be read again.',
+    PAN_AGENTS_END,
+  ].join('\n');
+}
+
+/**
+ * Ensure CLAUDE.md carries PAN's block: the marker-fenced @AGENTS.md import
+ * (Claude Code's documented pattern for adopting the universal rules file) and
+ * the compact instructions. Idempotent; preserves all user content. An older PAN
+ * bridge (the import alone) is replaced in place, so a reinstall or `memory
+ * rebuild` brings existing projects up to date.
  * @param {string|null} existing - Current CLAUDE.md content, or null if absent
  * @returns {string} New file content
  */
 function ensureClaudeMdImport(existing) {
-  const block = `${PAN_AGENTS_BEGIN}\n@AGENTS.md\n${PAN_AGENTS_END}`;
+  const block = buildClaudeMdBridge();
   if (!existing || !existing.trim()) {
     return block + '\n';
   }
-  if (existing.includes(PAN_AGENTS_BEGIN)) {
-    return existing; // bridge (or another PAN block) already present
+  const beginIdx = existing.indexOf(PAN_AGENTS_BEGIN);
+  const endIdx = existing.indexOf(PAN_AGENTS_END);
+  if (beginIdx !== -1) {
+    // PAN's own bridge: bring it up to date. Any other PAN block is left alone.
+    if (endIdx > beginIdx && /^@AGENTS\.md\s*$/m.test(existing.slice(beginIdx, endIdx))) {
+      const eol = existing.includes('\r\n') ? '\r\n' : '\n';
+      return existing.slice(0, beginIdx) + block.replace(/\n/g, eol) + existing.slice(endIdx + PAN_AGENTS_END.length);
+    }
+    return existing;
   }
   if (/^@AGENTS\.md\s*$/m.test(existing)) {
     return existing; // user already imports AGENTS.md themselves
@@ -115,6 +155,7 @@ module.exports = {
   buildAgentsMdSection,
   upsertAgentsMdSection,
   removeAgentsMdSection,
+  buildClaudeMdBridge,
   ensureClaudeMdImport,
   removeClaudeMdImport,
 };

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

@@ -23,8 +23,9 @@
  *     ]
  *   }
  *
- * Populating this file is the host runtime's responsibility (Claude Code's
- * MCP list API, etc.). This module reads the cache and reasons over it.
+ * Nothing populates this file on its own: no hook or host writes it.
+ * `bridge cache --servers <json>` (or an external script) seeds it; this module
+ * reads the cache and reasons over it.
  */
 
 const fs = require('fs');
@@ -184,7 +185,7 @@ function recommendForPhase(cwd, phaseNum, opts) {
       phase: String(phaseNum),
       runtime: cache.runtime,
       recommendations: [],
-      reason: 'no MCP tools cached — run `pan-tools bridge cache` or ensure host runtime populates .planning/bridge/available-tools.json',
+      reason: 'no MCP tools cached — seed .planning/bridge/available-tools.json with `pan-tools bridge cache --servers <json>`; no hook or host writes it',
     };
   }
 
@@ -240,8 +241,8 @@ function cmdBridgeRecommend(cwd, phaseNum, opts, raw) {
 }
 
 function cmdBridgeCache(cwd, serversJson, runtime, raw) {
-  // For scripted cache writes. Normally the host runtime writes the file,
-  // but this CLI path lets users seed it for testing or from external scripts.
+  // The cache's only writer: no hook or host runtime populates the file, so this
+  // CLI path (or an external script) is how users seed it.
   if (!serversJson) {
     // No payload — just echo the current cache path/state.
     output(listTools(cwd), raw);

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

@@ -66,12 +66,14 @@ function writeScheduleFile(cwd, schedule) {
  * @returns {object|{error}} the written descriptor
  */
 function writeSchedule(cwd, opts, now) {
-  const cadence = opts.cadence || 'daily';
+  // An update keeps the stored cadence like every other field: `--pause` on an
+  // hourly campaign used to set it back to daily.
+  const existing = readSchedule(cwd) || {};
+  const cadence = opts.cadence || existing.cadence || 'daily';
   if (parseCadence(cadence) === null) {
     return { error: `Invalid cadence "${cadence}". Use hourly | daily | weekly | Nh | Nd.` };
   }
   const at = now || new Date();
-  const existing = readSchedule(cwd) || {};
   const schedule = {
     goal: opts.goal ?? existing.goal ?? null,
     source: opts.source ?? existing.source ?? 'backlog',

package/pan-wizard-core/bin/lib/commands-learnings.cjs

@@ -299,6 +299,23 @@ function formatLearningEntry(learning) {
   return lines.join('\n');
 }
 
+/**
+ * A summary's `key-files` as one list. The summary templates write `{created, modified}`;
+ * older summaries carry a flat list. Only the flat list was read, so summaries PAN writes
+ * gave no co-change learnings, and one beside a flat-list summary crashed on `.includes`.
+ * @param {Object} fm - Summary frontmatter
+ * @returns {string[]}
+ */
+function keyFileList(fm) {
+  const kf = fm['key-files'] || fm.key_files;
+  if (Array.isArray(kf)) return kf.map(String);
+  if (kf && typeof kf === 'object') {
+    const list = (v) => (Array.isArray(v) ? v : (v ? [v] : []));
+    return [...new Set([...list(kf.created), ...list(kf.modified)].map(String))];
+  }
+  return [];
+}
+
 /**
  * Extract learnings from session summaries and error patterns.
  * Reads session history + error patterns, extracts file co-change patterns
@@ -347,7 +364,7 @@ function cmdLearningsExtract(cwd, raw) {
   const fileCoChanges = new Map(); // file -> Set of co-changed files
 
   for (const { frontmatter } of summaries) {
-    const keyFiles = Array.isArray(frontmatter['key-files']) ? frontmatter['key-files'] : [];
+    const keyFiles = keyFileList(frontmatter);
     if (keyFiles.length < 2) continue;
     for (const file of keyFiles) {
       if (!fileCoChanges.has(file)) fileCoChanges.set(file, new Set());
@@ -368,7 +385,7 @@ function cmdLearningsExtract(cwd, raw) {
       // Count co-occurrences
       let count = 0;
       for (const { frontmatter } of summaries) {
-        const kf = frontmatter['key-files'] || [];
+        const kf = keyFileList(frontmatter);
         if (kf.includes(file) && kf.includes(coFile)) count++;
       }
       if (count < 2) continue;