pan-wizard 3.21.1 → 3.24.0

package/hooks/dist/pan-trace-logger.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 // pan-trace-logger — SubagentStop hook (v3.5+).
 //
-// Fires alongside pan-cost-logger on every SubagentStop event. If a trace
-// session is active (.planning/optimization/current-session exists), this
-// hook appends a completion event to the trace. This is the automatic
-// instrumentation layer of the circular optimization loop — no extra user
-// action required.
+// Fires alongside pan-cost-logger on every SubagentStop event. In a PAN project
+// (see isPanProject — M62) it ensures a day-scoped trace session exists and
+// appends a completion event to it. This is the automatic instrumentation layer
+// of the circular optimization loop — no extra user action required. Outside a
+// PAN project the hook no-ops, so a global install does not create .planning/
+// trace artifacts in every repo the user opens.
 //
 // Events logged per subagent:
 //   - completion: agent finished, tokens used, exit status
@@ -16,6 +17,31 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
+
+// Runtime config dirs a local PAN install lands in (mirrors installer getDirName).
+const PAN_RUNTIME_DIRS = ['.claude', '.codex', '.gemini', '.opencode', '.github'];
+
+// M62: only instrument actual PAN projects. A global-install hook fires in EVERY
+// repo the user opens; without this gate it silently creates .planning/
+// optimization + trace artifacts in non-PAN repos. A project counts as PAN if it
+// already has a .planning/ tree (a /pan command created it) OR carries a local
+// PAN install (a manifest / core payload under a runtime config dir — covers a
+// fresh local install before any .planning/ exists). Global installs in a plain
+// repo match neither, so the hook no-ops. Best-effort — never throws.
+function isPanProject(cwd) {
+  try {
+    if (!cwd) return false;
+    if (fs.existsSync(path.join(cwd, '.planning'))) return true;
+    for (const d of PAN_RUNTIME_DIRS) {
+      if (fs.existsSync(path.join(cwd, d, 'pan-file-manifest.json'))) return true;
+      if (fs.existsSync(path.join(cwd, d, 'pan-wizard-core'))) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 
 const PLANNING_DIR = '.planning';
 const OPTIMIZE_DIR = 'optimization';
@@ -23,9 +49,10 @@ const TRACES_DIR = 'traces';
 const CURRENT_SESSION_FILE = 'current-session';
 const TRACE_EVENT_FILE = 'trace.jsonl';
 
-// Trace event schema version — kept in sync by hand with pan-cost-logger.js +
-// cost.cjs (standalone zero-dep hooks can't share a module). See that file.
-const SCHEMA_V = 2;
+// Trace event schema version — kept in sync by hand with pan-cost-logger.js
+// (standalone zero-dep hooks can't share a module). v3 added the per-invocation
+// `event_sig` discriminator to the completion event's context. See that file.
+const SCHEMA_V = 3;
 
 // YYYYMMDD stamp for a Date (the day-scope of an auto-session id).
 function dayStamp(d) {
@@ -114,9 +141,145 @@ function readTraceCursor(cwd) {
   try { const c = JSON.parse(fs.readFileSync(traceCursorPath(cwd), 'utf-8')); return c && typeof c === 'object' ? c : {}; }
   catch { return {}; }
 }
+
+// N17/N25-N27: reserved key in the cursor map recording, per transcript, the
+// SIGNATURES of recently-seen SubagentStop events. Mirrors pan-cost-logger —
+// an empty-slice event is a true re-fire / dual registration ONLY when its
+// full-payload signature was already seen for that transcript; a parallel
+// sibling (any payload difference) or a first-fire (missing/unreadable
+// transcript) carries a new signature and must be recorded, not dropped.
+// Bounded FIFO SET rather than a single slot (N25) so an interleaved sibling
+// can't evict the signature identifying an earlier event's re-fire; bounded by
+// COUNT, not transcript existence, so the L40 prune can't erase the live marker
+// of a missing-transcript first fire (N27). See pan-cost-logger.js for the full
+// design rationale (the two hooks are standalone and must stay in sync by hand).
+const SEEN_EVENTS = '__seenEvents';
+// Pre-N25 single-slot marker — no longer read; dropped on the next write.
+const LEGACY_CONSUME_KEYS = '__consumeKeys';
+// This window is the ONLY layer that recognizes a re-fire which is no longer the
+// LATEST completion in the trace file: the dedup below compares against that one
+// completion and nothing further. A sibling wave wider than this bound on one
+// transcript therefore evicts the earliest sibling's signature, and a late
+// re-fire of THAT sibling is emitted as a phantom completion. That residual is
+// accepted deliberately, not overlooked — see eventSignature below for what
+// widening either window was measured to cost.
+const MAX_SEEN_SIGS = 8;
+const MAX_SEEN_TRANSCRIPTS = 16;
+
+// Full-payload hash: byte-identical for a dual-registration re-fire, different
+// for a sibling whose payload differs in ANY field, with no hardcoding of which
+// field a given runtime provides (N26).
+//
+// WHICH fields actually differ on real payloads is only partly established, so
+// the sibling-admission benefit is CONDITIONAL. What this repo has observed:
+//   • `agent_type` / `subagent_type` is supplied and does vary between siblings
+//     of DIFFERENT type — the trace rows recorded under
+//     experiments/*/.planning/optimization/traces/ were written by THIS hook
+//     from real payloads and carry real agent names.
+//   • `session_id` is SHARED with the parent, and so is the session transcript
+//     (docs/FIELD-REPORT-army-2026-06.md, root cause 1).
+//   • `model` and `phase` came out null in those recorded rows — the payload
+//     carried neither; `usage` is absent entirely in headless mode
+//     (docs/HOOKS.md, P-1805).
+//   • No recorded payload in this repo carries an `agent_id` or any other
+//     per-invocation id; the hook tests inject one as a stand-in.
+// So for two CONCURRENT SAME-TYPE siblings no varying payload field is confirmed
+// on any host: where the host supplies one, both spawns are admitted; where it
+// supplies none the payloads are the same bytes, hence indistinguishable from a
+// re-fire, and the second stays suppressed.
+//
+// What the guards promise, stated as narrowly as they hold: a re-fire is
+// suppressed while it is still RECOGNIZABLE — its signature is in this
+// transcript's seen-event window (MAX_SEEN_SIGS), or it is byte-identical modulo
+// `ts` to the LATEST completion already in the trace file. Nothing further. A
+// re-fire arriving after its signature has been evicted from the marker window,
+// and no longer adjacent to the completion it duplicates, IS emitted as a phantom
+// completion. That is the residual; it is documented rather than engineered away.
+//
+// It was engineered away once, and the cure destroyed data. The dedup was widened
+// to scan a tail of recent completions, with a second prong matching on a
+// repeated signature alone for completions carrying no tokens. Both prongs delete
+// real spawns. Five genuine spawns X,Y,X,Y,X on one shared transcript — the
+// ordinary shared-session topology of docs/FIELD-REPORT-army-2026-06.md, where
+// sequential same-type subagents deliver byte-identical payloads and therefore
+// one signature — collapsed to TWO completions; when their slices carried real
+// usage the collapsed completions' token counts vanished with them. Deleting real
+// telemetry is strictly worse than the occasional phantom completion it prevents.
+// The invariant that justified the contentless prong ("an event that consumed a
+// real transcript slice never looks contentless") is also false: a slice of
+// records that carry no `usage` and no `timestamp` yields zero on every axis and
+// a null duration. So the dedup stays adjacent-only, and this comment states the
+// residual instead of an invariant the code does not hold. Pinned in
+// tests/trace-logger.test.cjs — `grep -n 'no genuine spawn' tests/trace-logger.test.cjs`.
+//
+// The NO-transcript path carries a wider residual: it never consults the marker
+// layer at all (there is no transcript to key it by), so an INTERLEAVED dual
+// registration there — A, B, A′, B′ — puts A′ and B′ out of adjacency reach and
+// both are emitted as phantom completions. Closing that needs a lookback, and a
+// lookback is the window whose failure mode is the data loss above, so it stays
+// open.
+//
+// Where the guards CAN distinguish two events (payloads differ, so signatures
+// differ) both are emitted — that is what the completion's `event_sig` is for.
+// Where they CANNOT (identical bytes), the second is suppressed. The bias falls
+// on the indistinguishable case only, deliberately: an undercount beats a
+// phantom completion (N29).
+//
+// Its cost, stated because no other comment admits it: two SEQUENTIAL genuine
+// spawns whose completions coincide in every field but `ts` collapse to one,
+// losing the second's real counts. Inherent to an adjacent whole-record dedup,
+// identical in the pre-`event_sig` code, and the alternative (no dedup)
+// reinstates the duplicate-record bug. It is the one UNDER-count residual —
+// distinct from the evicted-marker phantom (over-count) and from N29.
+//
+// Null when unserializable → fail open.
+function eventSignature(data) {
+  try {
+    return crypto.createHash('sha1').update(JSON.stringify(data)).digest('hex');
+  } catch { return null; }
+}
+
+function getSeenSigs(cursor, transcriptPath) {
+  const se = cursor && cursor[SEEN_EVENTS];
+  const arr = se && typeof se === 'object' ? se[transcriptPath] : null;
+  return Array.isArray(arr) ? arr : [];
+}
+function addSeenSig(cursor, transcriptPath, sig) {
+  if (!sig) return; // unhashable payload → never mark (fail open to recording)
+  if (!cursor[SEEN_EVENTS] || typeof cursor[SEEN_EVENTS] !== 'object') cursor[SEEN_EVENTS] = {};
+  const se = cursor[SEEN_EVENTS];
+  const arr = Array.isArray(se[transcriptPath]) ? se[transcriptPath].filter((s) => s !== sig) : [];
+  arr.push(sig);
+  while (arr.length > MAX_SEEN_SIGS) arr.shift(); // FIFO — evict the oldest signature
+  delete se[transcriptPath]; // re-insert so key order tracks recency for the transcript cap
+  se[transcriptPath] = arr;
+  const keys = Object.keys(se);
+  for (let i = 0; i < keys.length - MAX_SEEN_TRANSCRIPTS; i++) delete se[keys[i]];
+}
+
 function writeTraceCursor(cwd, cursor) {
-  try { fs.mkdirSync(path.dirname(traceCursorPath(cwd)), { recursive: true }); fs.writeFileSync(traceCursorPath(cwd), JSON.stringify(cursor), 'utf-8'); }
-  catch { /* best-effort — never block the agent loop */ }
+  try {
+    // Prune dead-transcript keys so the cursor map stays bounded (L40, ADR audit 2026-08).
+    const pruned = {};
+    for (const [tp, v] of Object.entries(cursor)) {
+      if (tp === SEEN_EVENTS || tp === LEGACY_CONSUME_KEYS) continue; // reserved markers — not paths
+      if (tp && fs.existsSync(tp)) pruned[tp] = v;
+    }
+    // Preserve the seen-event marker (N17/N25-N27). Deliberately NOT pruned by
+    // transcript existence — a missing-transcript first fire's marker must
+    // survive this very write (N27); bounded by count instead (L40).
+    const se = cursor[SEEN_EVENTS];
+    if (se && typeof se === 'object') {
+      const bounded = {};
+      for (const tp of Object.keys(se).slice(-MAX_SEEN_TRANSCRIPTS)) {
+        const arr = se[tp];
+        if (Array.isArray(arr) && arr.length) bounded[tp] = arr.slice(-MAX_SEEN_SIGS);
+      }
+      if (Object.keys(bounded).length) pruned[SEEN_EVENTS] = bounded;
+    }
+    fs.mkdirSync(path.dirname(traceCursorPath(cwd)), { recursive: true });
+    fs.writeFileSync(traceCursorPath(cwd), JSON.stringify(pruned), 'utf-8');
+  } catch { /* best-effort — never block the agent loop */ }
 }
 
 /**
@@ -275,6 +438,11 @@ function buildTraceEvents(data, sessionId, cwd) {
 
   const ts = new Date().toISOString();
   const agent = data.agent_type || data.subagent_type || 'unknown';
+  // This event's per-invocation identity, hashed once and used by BOTH layers:
+  // the seen-event marker below and the completion's `event_sig` context field.
+  // buildTraceEvents never mutates `data`, so hoisting the hash here yields the
+  // same value the marker calls used when they each computed it themselves.
+  const eventSig = eventSignature(data);
 
   // Per-call tokens come from the transcript SLICE. The SubagentStop `data.usage`,
   // when present, is a CUMULATIVE session counter — not this subagent's delta — so
@@ -298,7 +466,35 @@ function buildTraceEvents(data, sessionId, cwd) {
     durationMs = durationFromSpan(fromTranscript.first_ts, fromTranscript.last_ts);
     if (!model) model = fromTranscript.model;
     if (cwd && fromTranscript.lineCount > since) {
+      // A real slice. Advance the cursor and remember this event's signature
+      // (N17/N25) so a later empty-slice event can tell its re-fire from a
+      // parallel sibling — even when other siblings are recorded in between (N25).
       cursor[data.transcript_path] = fromTranscript.lineCount;
+      addSeenSig(cursor, data.transcript_path, eventSig);
+      writeTraceCursor(cwd, cursor);
+    } else if (cwd && fromTranscript.lineCount <= since) {
+      // No transcript records past the cursor: this event consumed NO slice of its
+      // own. Two situations land here (N17):
+      //   • A re-fire / dual global+local hook registration — the SAME event
+      //     delivered again (byte-identical payload). Its all-zero completion row
+      //     is a phantom the dedup cannot catch (zeros differ from the real row
+      //     it follows), so emit nothing (M61). This marker is the ONLY layer
+      //     that catches that case; there is no signature-matching backstop below
+      //     it, by design (see eventSignature).
+      //   • A PARALLEL SIBLING (another subagent — same or different type — whose
+      //     sibling already consumed the shared transcript to EOF and advanced
+      //     this shared cursor) or a FIRST FIRE with a missing/unreadable
+      //     transcript. These are legitimate spawns that must be RECORDED (zero
+      //     tokens), not dropped.
+      // The full-payload signature distinguishes them (N25/N26): emit nothing
+      // ONLY when this exact payload was already seen for this transcript;
+      // otherwise fall through and emit the completion.
+      if (eventSig && getSeenSigs(cursor, data.transcript_path).includes(eventSig)) {
+        return []; // already-seen event → re-fire; emit nothing (M61)
+      }
+      // Sibling / first-fire: remember this event's signature so its own re-fire
+      // is subsequently dropped, then fall through to emit the completion.
+      addSeenSig(cursor, data.transcript_path, eventSig);
       writeTraceCursor(cwd, cursor);
     }
   } else {
@@ -341,6 +537,22 @@ function buildTraceEvents(data, sessionId, cwd) {
       exit_code: data.exit_code || 0,
       token_source: tokenSource,
       clamped,
+      // This spawn's per-invocation discriminator: the event signature,
+      // persisted. The signature was already hashed for the seen-event marker
+      // but never written into the event, so two parallel same-type siblings
+      // produced completions byte-identical modulo `ts` and the dedup dropped the
+      // second one even though the marker layer had correctly admitted it (N26).
+      // Persisting it gives both layers ONE notion of event identity: siblings
+      // differ here even when every other field matches, while a re-fire carries
+      // the same signature and still matches the completion it duplicates.
+      // It is a field the dedup COMPARES as part of whole-event identity — never
+      // a key the dedup searches the trace file by. Two sequential subagents on a
+      // shared growing transcript share one payload and therefore one signature
+      // while holding different real token counts, so matching on the signature
+      // alone deletes genuine completions (see eventSignature). Mirrors
+      // pan-cost-logger's ledger-row field of the same name. null when the
+      // payload could not be hashed.
+      event_sig: eventSig,
     },
     impact: 'trivial',
     correction: null,
@@ -383,10 +595,12 @@ function appendTraceEvents(cwd, events, sessionId) {
     const sessionDir = path.join(getTracesDir(cwd), sessionId);
     fs.mkdirSync(sessionDir, { recursive: true });
     const file = path.join(sessionDir, TRACE_EVENT_FILE);
-    // Idempotency guard: a re-fired SubagentStop must not double-log. If this
-    // batch's completion event duplicates the last agent_completion already in
-    // the file (every field but ts), skip the whole batch — the source of the
-    // ~57% duplicate completion rows in the field (2026-07).
+    // Idempotency guard: a re-fired SubagentStop must not double-log — the
+    // source of the ~57% duplicate completion rows in the field (2026-07). If
+    // this batch's completion event duplicates the LAST agent_completion already
+    // in the file (every field but `ts`), skip the whole batch — its redundancy
+    // event, if any, is derived from the same numbers. Adjacent-only on purpose;
+    // see isDuplicateCompletion.
     const completion = events.find(e => e && e.category === 'agent_completion');
     if (completion && isDuplicateCompletion(file, completion)) return false;
     const lines = events.map(e => JSON.stringify(e)).join('\n') + '\n';
@@ -397,14 +611,37 @@ function appendTraceEvents(cwd, events, sessionId) {
   }
 }
 
-/** True when `completion` matches the file's last agent_completion row, ignoring ts. */
+/**
+ * True when `completion` matches the file's LAST agent_completion, ignoring `ts`.
+ *
+ * Adjacent-only, and that is the design rather than an oversight. The comparison
+ * covers every field including the `event_sig` discriminator in `context`, so a
+ * true re-fire (same payload → same signature → same completion) still matches
+ * the one it follows, while two siblings the payload can distinguish both survive
+ * (N26).
+ *
+ * It deliberately does NOT scan back over a tail of recent completions, and does
+ * not match on a repeated signature. Both of those were tried and both delete
+ * real spawns: an identity scan over a window collapses genuine repeat spawns
+ * whose completions coincide, and a signature prong collapses genuine spawns that
+ * share a payload — the ordinary shared-transcript topology. eventSignature
+ * carries the measured reproduction and the residual this leaves standing;
+ * tests/trace-logger.test.cjs pins both
+ * (`grep -n 'no genuine spawn' tests/trace-logger.test.cjs`).
+ *
+ * Completions written before the discriminator existed hold no `event_sig` and an
+ * older `v`, so one written now never equals them. The bounded consequence: the
+ * first append after a schema bump can land beside a pre-bump completion without
+ * matching it, and the guard resumes on the following same-shape pair. Those
+ * older events still parse and still analyse — optimize.cjs reads a trace event
+ * field by field and requires no particular version or field to be present.
+ */
 function isDuplicateCompletion(file, completion) {
   let last;
   try {
-    const raw = fs.readFileSync(file, 'utf-8');
-    for (const line of raw.split('\n')) {
+    for (const line of fs.readFileSync(file, 'utf-8').split('\n')) {
       if (!line) continue;
-      let e; try { e = JSON.parse(line); } catch { continue; }
+      let e; try { e = JSON.parse(line); } catch { continue; } // skip malformed rows
       if (e && e.category === 'agent_completion') last = e;
     }
   } catch {
@@ -425,7 +662,11 @@ if (require.main === module) {
     try {
       const data = JSON.parse(input);
       const cwd = data.cwd || data.workspace?.current_dir || process.cwd();
-      // Always ensure a session exists — creates a day-scoped auto-session if needed
+      // M62: a global-install hook fires in every repo; skip non-PAN projects so
+      // we don't create .planning/ optimization + trace artifacts in them.
+      if (!isPanProject(cwd)) return;
+      // In a PAN project, ensure a session exists — creates a day-scoped
+      // auto-session if needed.
       const sessionId = ensureSessionId(cwd);
       const events = buildTraceEvents(data, sessionId, cwd);
       appendTraceEvents(cwd, events, sessionId);
@@ -440,6 +681,7 @@ module.exports = {
   appendTraceEvents,
   getCurrentSessionId,
   ensureSessionId,
+  isPanProject,
   PLANNING_DIR,
   OPTIMIZE_DIR,
   TRACES_DIR,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pan-wizard",
-  "version": "3.21.1",
+  "version": "3.24.0",
   "description": "Command a bot army for your codebase: an Opus 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"
@@ -68,7 +68,7 @@
     "test:all": "node scripts/run-tests.cjs tests tests/scenarios",
     "test:e2e": "node scripts/run-tests.cjs tests/scenarios",
     "test:vscode": "npx playwright test --config tests/e2e/playwright.config.mjs",
-    "test:watch": "node --test --watch tests/*.test.cjs",
+    "test:watch": "node scripts/run-tests.cjs --watch tests tests/scenarios",
     "build:plugin": "node scripts/build-plugin.js"
   }
 }

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

@@ -216,7 +216,7 @@ function recommendForPhase(cwd, phaseNum, opts) {
 
   return {
     phase: String(phaseNum),
-    phase_name: phaseInfo.name || null,
+    phase_name: phaseInfo.phase_name || null,
     runtime: cache.runtime,
     total_candidates: tools.length,
     recommendations: scored.map(t => ({

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

@@ -11,7 +11,8 @@
  *   Each line: {ts, source, payload}
  *
  * Channels are created on first publish. Readers use cursor-based drain
- * (read N lines from an offset) or consume-all drain (read + truncate).
+ * (read N lines from an offset) or partial-consume drain (read the drained
+ * window, splice just those lines out, and write the remainder back).
  *
  * Concurrent-write safety: each publish opens the file with append flag
  * (`a`) which the OS treats atomically for writes <PIPE_BUF on POSIX and
@@ -135,11 +136,15 @@ function readChannel(cwd, channel, opts) {
 }
 
 /**
- * Drain (read + optionally truncate) messages from a channel.
+ * Drain (read + optionally mutate) messages from a channel.
  *
  * Three drain modes:
  *  - `peek` (default): read entries, leave file untouched
- *  - `consume`: read entries, truncate file to zero bytes
+ *  - `consume`: read entries, then splice out ONLY the drained window
+ *    (offset .. offset+consumed) and write the remainder back — messages
+ *    outside that window (before the offset, or beyond the read limit / the
+ *    1000-message default on large channels) survive. The file is emptied only
+ *    when the drained window covers every line.
  *  - `archive`: read entries, rename file to `<channel>-<ts>.archive.jsonl` so
  *    historical data is preserved while the channel restarts empty
  *
@@ -158,7 +163,17 @@ function drain(cwd, channel, opts) {
   const file = channelFile(cwd, channel);
   if (mode === 'consume') {
     try {
-      fs.writeFileSync(file, '', 'utf-8');
+      // Consume ONLY the drained window (offset .. offset+limit). Truncating the
+      // whole file to empty silently destroyed every message outside that window
+      // — anything before the offset, or beyond the read limit / the 1000-message
+      // default on large channels (H2, ADR audit 2026-08). Splice out the consumed
+      // lines and write the remainder back.
+      let allLines = [];
+      try { allLines = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean); } catch { allLines = []; }
+      const offset = Math.max(0, Number(opts?.offset) || 0);
+      const consumed = read.entries.length; // raw lines actually returned by readChannel
+      const remaining = allLines.slice(0, offset).concat(allLines.slice(offset + consumed));
+      fs.writeFileSync(file, remaining.length ? remaining.join('\n') + '\n' : '', 'utf-8');
     } catch (e) {
       return { ...read, mode, drain_error: e.message };
     }

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

@@ -152,7 +152,11 @@ function isDreamDue(schedule, now) {
   if (!schedule.last_run) return false;
   const last = new Date(schedule.last_run);
   if (isNaN(last)) return false;
-  return !sameUtcDay(last, at) || (schedule.history || []).length > 0;
+  // Due only once the last run rolled over into a NEW calendar day AND there is
+  // recorded activity to reflect on. The old `||` made this permanently true
+  // after the first run (history is never empty once a run is recorded), which
+  // contradicted the "once per calendar day that had activity" contract.
+  return !sameUtcDay(last, at) && (schedule.history || []).length > 0;
 }
 
 // ─── CLI ─────────────────────────────────────────────────────────────────────
@@ -190,8 +194,9 @@ function cmdCampaignStatus(cwd, raw) {
 function cmdCampaignDue(cwd, raw) {
   const schedule = readSchedule(cwd);
   const d = isRunDue(schedule, new Date());
-  // exit-coded so a host scheduler can gate: 0 = due, 1 = not due
-  output({ due: d.due, reason: d.reason, next_due: d.next_due }, raw, d.due ? 'due' : `not due (${d.reason})`);
+  // exit-coded so a host scheduler can gate: 0 = due, 1 = not due (M9 — output()
+  // used to hard-exit 0, so the documented gate always fired the run).
+  output({ due: d.due, reason: d.reason, next_due: d.next_due }, raw, d.due ? 'due' : `not due (${d.reason})`, d.due ? 0 : 1);
 }
 
 module.exports = {

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

@@ -98,8 +98,20 @@ function detectLanguages(cwd) {
     } catch { /* manifest not found */ }
   }
 
-  // TypeScript subsumes javascript if tsconfig.json exists
-  if (files_by_language.typescript && files_by_language.javascript) {
+  // TypeScript subsumes javascript only in a genuine TS project: there must be
+  // actual .ts source files AND a tsconfig.json. A bare tsconfig.json (common for
+  // editor type-checking of plain JS) or a manifest-promoted empty typescript array
+  // must NOT relabel a JS codebase as TypeScript.
+  let hasTsconfig = false;
+  try {
+    fs.accessSync(path.join(cwd, 'tsconfig.json'));
+    hasTsconfig = true;
+  } catch { /* no tsconfig */ }
+  if (
+    hasTsconfig &&
+    files_by_language.typescript && files_by_language.typescript.length > 0 &&
+    files_by_language.javascript && files_by_language.javascript.length > 0
+  ) {
     // Merge JS files under TypeScript project
     files_by_language.typescript = files_by_language.typescript.concat(files_by_language.javascript);
     delete files_by_language.javascript;
@@ -546,7 +558,6 @@ function detectErrorHandling(samples) {
 }
 
 function detectTestingPractices(cwd, sourceFileCount) {
-  const patterns = ['*.test.*', '*.spec.*', '__tests__/**'];
   let testFileCount = 0;
 
   try {
@@ -690,9 +701,8 @@ function cmdDetectLanguages(cwd, raw) {
  * CLI: Analyze imports and build dependency graph.
  * @param {string} cwd - Project root
  * @param {boolean} raw - Raw output flag
- * @param {string[]} args - Additional arguments (--files f1,f2)
  */
-function cmdAnalyzeImports(cwd, raw, args) {
+function cmdAnalyzeImports(cwd, raw) {
   const graph = buildDependencyGraph(cwd);
   const circularDeps = findCircularDeps(graph);
   const entryPoints = findEntryPoints(graph);