@gobing-ai/spur 0.4.2 → 0.4.3

package/plugins/sp/scripts/batch-preflight.ts

@@ -1,303 +1,43 @@
 /**
- * batch-preflight — pure TABLE A STOP evaluation for sp:super-planner (task 0279).
+ * batch-preflight — planner adapter over the pure admission policy (task 0279; task 1176 move).
  *
- * Mirrors routing-table.md TABLE A hard-STOP preconditions so the batch driver can
- * skip doomed pipeline launches without spawning a Skill subprocess. Happy-path
- * statuses still return `action: 'run'` — the caller launches task-pipeline.yaml
- * verbatim (preflight is readiness only, never a pipeline substitute).
+ * The decisions — TABLE A STOP evaluation, quick command-aware readiness and feature-finding
+ * classification — are application policy in `packages/app/src/services/planning-admission.ts`,
+ * reached through the generated pure bundle. This entry keeps what belongs to the planner: the CLI
+ * surface, its argv/usage/error contracts, and the one-shot recovery hints the batch driver prints.
  *
- * Recovery hints (one-shot after FAIL) map stuck statuses to a single /sp:dev-* hop
- * per TABLE A; the batch driver prints or dispatches at most once per WBS.
+ * Recovery hints (one-shot after FAIL) map stuck statuses to a single /sp:dev-* hop per TABLE A; the
+ * batch driver prints or dispatches at most once per WBS.
  */
 
-export type TaskStatus = 'backlog' | 'todo' | 'wip' | 'testing' | 'blocked' | 'done' | 'cancelled' | string;
-
-export interface PreflightInput {
-    wbs: string;
-    status: TaskStatus;
-    /** Frontmatter dependencies[] WBS list. */
-    dependencies: string[];
-    /** Status of each dependency WBS (from spur task show). Missing → treated as unmet. */
-    depStatuses: Record<string, string>;
-}
-
-export type PreflightResult =
-    | { action: 'run'; code?: string; reason?: string }
-    | { action: 'skip'; code: string; reason: string; unmetDeps?: string[] };
-
-// ── Feature preflight classification (1132 R4) ──────────────────────────────
-/**
- * 1132 R4: Codes that are expected pre-run states under `feature check --strict`
- * and must not abort the batch. Structured classification in code (replaces prose-only).
- */
-export const NON_ABORTING_PREFLIGHT_CODES = new Set<string>([
-    'L4.scenario-unverified',
-    'L4.verifying-incomplete-tasks',
-]);
-
-export interface FeaturePreflightFinding {
-    layer: string;
-    code: string;
-    severity: string;
-    message: string;
-    section?: string;
-}
-
-export interface FeaturePreflightClassification {
-    aborting: FeaturePreflightFinding[];
-    nonAborting: FeaturePreflightFinding[];
-    shouldAbort: boolean;
-}
-
-export function classifyFeaturePreflightFindings(findings: FeaturePreflightFinding[]): FeaturePreflightClassification {
-    const aborting: FeaturePreflightFinding[] = [];
-    const nonAborting: FeaturePreflightFinding[] = [];
-    for (const f of findings) {
-        if (f.severity === 'error') {
-            if (NON_ABORTING_PREFLIGHT_CODES.has(f.code)) {
-                nonAborting.push(f);
-            } else {
-                aborting.push(f);
-            }
-        } else {
-            nonAborting.push(f);
-        }
-    }
-    return {
-        aborting,
-        nonAborting,
-        shouldAbort: aborting.length > 0,
-    };
-}
-
-// ── Command-aware quick readiness (task 0814 R2) ──────────────────────────────
-// Read-only admission decision for the requested dev operation. Distinguishes
-// runnable / needs-refinement / blocked / skipped / invalid outcomes without
-// LLM dispatch, full tests/lint, live-data probes, feature mutation, or
-// corpus-wide relational checking. Refinement gaps are work to do, not errors.
-
-export type ReadinessOperation = 'run' | 'refine' | 'verify';
-
-export interface QuickReadinessInput {
-    wbs: string;
-    status: TaskStatus;
-    operation: ReadinessOperation;
-    /** Frontmatter dependencies[] WBS list (run only). */
-    dependencies?: string[];
-    /** Status of each dependency WBS; missing → treated as unmet (run only). */
-    depStatuses?: Record<string, string>;
-    /** Size of the status-filtered candidate set after the selector resolved; 0 = empty set. */
-    filteredCount?: number;
-    /** Required planning sections for this variant+status; empty = not applicable. */
-    requiredSections?: string[];
-    /** Sections that are actually present (non-placeholder) in the task. */
-    presentSections?: string[];
-    /** L1/L2/L3 content-policy findings keyed by section; empty = clean. */
-    sectionFindings?: Record<string, string>;
-    /** Verify only: re-verification semantics (--force) — never a dirty-tree bypass. */
-    force?: boolean;
-}
-
-export type QuickReadinessResult =
-    | { action: 'runnable'; code: string; reason: string }
-    | { action: 'needs-refinement'; code: string; reason: string; gaps: string[] }
-    | { action: 'blocked'; code: string; reason: string; unmetDeps?: string[] }
-    | { action: 'skipped'; code: string; reason: string }
-    | { action: 'invalid'; code: string; reason: string };
-
-/**
- * Evaluate quick readiness for a requested dev operation (0814 R2). Read-only:
- * no model, no full tests/lint, no live-data probe, no feature mutation, no
- * corpus-wide relational check. An empty status-filtered set is `skipped`
- * (mirrors the zero-task rule), never an error. Refinement gaps under `refine`
- * are work to do, so they do not block; under `run` they are `needs-refinement`.
- */
-export function quickReadiness(input: QuickReadinessInput): QuickReadinessResult {
-    const status = (input.status ?? '').toLowerCase();
-    const operation = input.operation;
-
-    if (operation !== 'run' && operation !== 'refine' && operation !== 'verify') {
-        return {
-            action: 'invalid',
-            code: 'IV',
-            reason: `quick-readiness: unknown operation '${operation}' (${input.wbs})`,
-        };
-    }
-
-    if (input.filteredCount !== undefined) {
-        if (input.filteredCount < 0) {
-            return {
-                action: 'invalid',
-                code: 'IV',
-                reason: `quick-readiness: invalid negative filtered count '${input.filteredCount}' (${input.wbs})`,
-            };
-        }
-        if (input.filteredCount === 0) {
-            return {
-                action: 'skipped',
-                code: 'EMPTY',
-                reason: `quick-readiness: empty status-filtered set — nothing to ${operation} (${input.wbs})`,
-            };
-        }
-    }
-
-    if (status === 'cancelled' || status === 'done') {
-        // verify --force re-verification (R2 AC): an already-verified terminal task
-        // is re-checked, not skipped — but force never bypasses a dirty tree or the
-        // owning gates; it only re-admits a terminal task for re-verification.
-        if (operation === 'verify' && input.force === true) {
-            return {
-                action: 'runnable',
-                code: 'FORCE',
-                reason: `quick-readiness: verify --force re-verification of ${status} task ${input.wbs}`,
-            };
-        }
-        return {
-            action: 'skipped',
-            code: status === 'done' ? 'DONE' : 'CANCELLED',
-            reason: `quick-readiness: already ${status} — no ${operation} hop (${input.wbs})`,
-        };
-    }
-
-    if (status === 'blocked') {
-        return {
-            action: 'blocked',
-            code: 'BLK',
-            reason: `quick-readiness: blocked — human/handover first (${input.wbs})`,
-        };
-    }
-
-    // Unmet out-of-set dependency is a block for the operation that needs it.
-    if (operation === 'run' && input.dependencies && input.dependencies.length > 0) {
-        const unmet = input.dependencies.filter((d) => (input.depStatuses?.[d] ?? 'missing').toLowerCase() !== 'done');
-        if (unmet.length > 0) {
-            return {
-                action: 'blocked',
-                code: 'DEP',
-                reason: `quick-readiness: unmet deps — ${unmet.join(', ')} (${input.wbs})`,
-                unmetDeps: unmet,
-            };
-        }
-    }
-
-    const required = input.requiredSections ?? [];
-    const present = input.presentSections ?? [];
-    // A required section is a gap when it is absent from the present-set OR carries a
-    // content-policy finding (the caller-supplied `sectionFindings` from the matrix /
-    // `TaskCheckService.checkContentPolicy`). This lets the function detect a gap itself
-    // rather than depending on the caller to pre-enumerate every missing section.
-    const gaps = required.filter((s) => {
-        const finding = input.sectionFindings?.[s];
-        return !present.includes(s) || (finding !== undefined && finding !== '');
-    });
-
-    // refine: missing/incomplete planning sections are the work, not a failure.
-    if (operation === 'refine') {
-        if (status !== 'backlog' && status !== 'todo') {
-            return {
-                action: 'skipped',
-                code: 'NONPLAN',
-                reason: `quick-readiness: refine targets backlog/todo only, not '${status}' (${input.wbs})`,
-            };
-        }
-        return {
-            action: 'runnable',
-            code: 'OK',
-            reason: `quick-readiness: refine ready for ${input.wbs} (${gaps.length} planning gap(s) to fill)`,
-        };
-    }
-
-    if (operation === 'verify') {
-        if (status !== 'testing' && status !== 'wip') {
-            return {
-                action: 'invalid',
-                code: 'NOVERIFY',
-                reason: `quick-readiness: verify needs testing/wip, not '${status}' (${input.wbs})`,
-            };
-        }
-        return {
-            action: 'runnable',
-            code: 'OK',
-            reason: `quick-readiness: verify ready for ${input.wbs}`,
-        };
-    }
-
-    // run: implementation admission. Eligible statuses are todo/wip/testing;
-    // a backlog task needs the chain's auto-promotion first (step 0).
-    if (status !== 'todo' && status !== 'wip' && status !== 'testing') {
-        return {
-            action: 'invalid',
-            code: 'NORUN',
-            reason: `quick-readiness: run needs todo/wip/testing, not '${status}' (${input.wbs})`,
-        };
-    }
-    if (gaps.length > 0) {
-        return {
-            action: 'needs-refinement',
-            code: 'REFINE',
-            reason: `quick-readiness: implementation sections incomplete (${input.wbs})`,
-            gaps,
-        };
-    }
-    return {
-        action: 'runnable',
-        code: 'OK',
-        reason: `quick-readiness: run ready for ${input.wbs}`,
-    };
-}
-
-/**
- * Evaluate whether the batch should launch task-pipeline.yaml for this WBS.
- * STOP codes align with routing-table TABLE A row ids (A2, A7, A8, A9).
- */
-export function preflightTask(input: PreflightInput): PreflightResult {
-    const status = (input.status ?? '').toLowerCase();
-    const deps = input.dependencies ?? [];
-    const depStatuses = input.depStatuses ?? {};
-
-    if (status === 'cancelled') {
-        return {
-            action: 'skip',
-            code: 'A9',
-            reason: `dev-next: cancelled — nothing to advance (${input.wbs})`,
-        };
-    }
-
-    if (status === 'done') {
-        return {
-            action: 'skip',
-            code: 'A8',
-            reason: `dev-next: already done — batch does not auto-wrap (${input.wbs})`,
-        };
-    }
-
-    if (status === 'blocked') {
-        return {
-            action: 'skip',
-            code: 'A7',
-            reason: `dev-next: blocked — do not launch pipeline; human/handover first (${input.wbs})`,
-        };
-    }
-
-    // A2: todo/backlog with any dependency not done (mirrors TABLE A2 / ready filter).
-    if (status === 'todo' || status === 'backlog') {
-        const unmet = deps.filter((d) => {
-            const st = (depStatuses[d] ?? 'missing').toLowerCase();
-            return st !== 'done';
-        });
-        if (unmet.length > 0) {
-            return {
-                action: 'skip',
-                code: 'A2',
-                reason: `dev-next: blocked by deps — unmet: ${unmet.join(', ')} (${input.wbs})`,
-                unmetDeps: unmet,
-            };
-        }
-    }
-
-    // Ready for pipeline: backlog/todo (deps ok), wip, testing.
-    return { action: 'run', code: 'OK', reason: `preflight clear — launch task-pipeline for ${input.wbs}` };
-}
+import {
+    classifyFeaturePreflightFindings,
+    type FeaturePreflightClassification,
+    type FeaturePreflightFinding,
+    NON_ABORTING_PREFLIGHT_CODES,
+    type PreflightInput,
+    type PreflightResult,
+    preflightTask,
+    type QuickReadinessInput,
+    type QuickReadinessResult,
+    quickReadiness,
+    type ReadinessOperation,
+    type TaskStatus,
+} from '../lib/plan-projection.generated.mjs';
+
+export type {
+    FeaturePreflightClassification,
+    FeaturePreflightFinding,
+    PreflightInput,
+    PreflightResult,
+    QuickReadinessInput,
+    QuickReadinessResult,
+    ReadinessOperation,
+    TaskStatus,
+};
+// R1: existing plugin callers keep their import path — the moved names are re-exported, not relocated
+// out from under them.
+export { classifyFeaturePreflightFindings, NON_ABORTING_PREFLIGHT_CODES, preflightTask, quickReadiness };
 
 /**
  * One-shot recovery hint after a non-PASS pipeline or stuck status (TABLE A primary hop).

package/plugins/sp/scripts/daily-summary/daily-summary.mjs

@@ -5,8 +5,9 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // plugins/sp/scripts/daily-summary/daily-summary.ts
 import { spawn, spawnSync } from "child_process";
-import { existsSync, mkdirSync, readlinkSync, writeFileSync } from "fs";
-import { dirname, isAbsolute, join, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync, readlinkSync, writeFileSync } from "fs";
+import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // plugins/sp/lib/env.ts
 function getEnvVar(name, fallback) {
@@ -17,20 +18,54 @@ function getEnvVars() {
   return process.env;
 }
 
-// plugins/sp/scripts/daily-summary/logger.ts
-var state = { console: true, file: false };
-function emit(stream, message) {
-  if (!state.console)
+// plugins/sp/lib/inline-run-app.ts
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveAppEntry(spurBin) {
+  const fallback = fileURLToPath(new URL("../../../apps/cli/src/index.ts", import.meta.url));
+  const candidates = spurBin !== "" ? [spurBin] : [fallback];
+  for (const candidate of candidates) {
+    const tokens = candidate.split(/\s+/).filter(Boolean);
+    const mainModule = [...tokens].reverse().find((t) => t.endsWith(".ts"));
+    if (mainModule === undefined || !existsSync(mainModule))
+      continue;
+    const repoRoot = resolve(dirname(mainModule), "..", "..", "..");
+    const appEntry = join(repoRoot, "packages", "app", "src", "index.ts");
+    if (existsSync(appEntry))
+      return { entry: appEntry, portable: false };
+  }
+  const entry = fileURLToPath(new URL("../lib/inline-run.generated.mjs", import.meta.url));
+  if (!existsSync(entry)) {
+    throw new Error("inline application bundle is missing — rebuild/install the sp plugin before running inline");
+  }
+  return { entry, portable: true };
+}
+async function loadInlineApp(spurBin, resolveAppEntry2, required) {
+  const { entry, portable } = resolveAppEntry2(spurBin);
+  const app = await import(entry);
+  const missing = portable ? required.filter((name) => typeof app[name] !== "function") : [];
+  if (missing.length > 0) {
+    throw new Error(`inline application bundle ${entry} is older than its scripts — missing ${missing.join(", ")}. Reinstall sp with a superskill release that stages lib/ (commit b42961b), or pass --spur-bin <spur checkout>/apps/cli/src/index.ts.`);
+  }
+  return { app, portable };
+}
+
+// plugins/sp/scripts/daily-summary/daily-summary.ts
+var consoleEnabled = true;
+function enableLogger(consoleOn) {
+  consoleEnabled = consoleOn;
+}
+function logAt(stream, message) {
+  if (!consoleEnabled)
     return;
   console[stream](message);
 }
 var logger = {
-  info: (message) => emit("log", message),
-  warn: (message) => emit("warn", message),
-  error: (message) => emit("error", message)
+  info: (message) => logAt("log", message),
+  warn: (message) => logAt("warn", message),
+  error: (message) => logAt("error", message)
 };
-
-// plugins/sp/scripts/daily-summary/daily-summary.ts
 var DAILY_DIR = "docs/daily";
 var DEFAULT_DATE = "today";
 function parseArgs(argv = process.argv.slice(2)) {
@@ -108,7 +143,7 @@ function getDateRange(dateStr) {
   return { start, end };
 }
 var defaultProcessSpawner = (cmd, args, env) => {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     try {
       const proc = spawn(cmd, args, {
         stdio: ["ignore", "pipe", "pipe"],
@@ -119,7 +154,7 @@ var defaultProcessSpawner = (cmd, args, env) => {
       proc.stdout.on("data", (chunk) => stdoutChunks.push(Buffer.from(chunk)));
       proc.stderr.on("data", (chunk) => stderrChunks.push(Buffer.from(chunk)));
       proc.on("close", (exitCode) => {
-        resolve2({
+        resolve3({
           stdout: Buffer.concat(stdoutChunks).toString("utf8"),
           stderr: Buffer.concat(stderrChunks).toString("utf8"),
           exitCode: exitCode ?? 0
@@ -158,72 +193,49 @@ async function getCcusageData(date) {
     return null;
   }
 }
+function composeHistoryHealth(reading) {
+  const loops = reading.loops.map((row) => ({
+    toolName: row.toolName,
+    argsDigest: row.argsDigest || "repeated execution",
+    repeats: row.repeats,
+    sessionId: row.sessionId,
+    fromSeq: row.firstSeq,
+    toSeq: row.lastSeq,
+    wastedTokens: row.repeats * 250
+  }));
+  const remediationProposals = [];
+  for (const lp of loops.slice(0, 5)) {
+    const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
+    const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
+    const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
+    remediationProposals.push({ key, title, command });
+  }
+  if (reading.toolCalls > 0 && reading.errorRatePct > 10) {
+    remediationProposals.push({
+      key: "reliability:tooling:high-error-rate",
+      title: `Investigate high tool error rate (${reading.errorRatePct.toFixed(1)}%)`,
+      command: `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`
+    });
+  }
+  return {
+    toolCalls: reading.toolCalls,
+    toolErrors: reading.toolErrors,
+    errorRatePct: reading.errorRatePct,
+    loops,
+    redundantCalls: loops.reduce((acc, l) => acc + Math.max(0, l.repeats - 1), 0),
+    wastedTokens: loops.reduce((acc, l) => acc + l.wastedTokens, 0),
+    remediationProposals
+  };
+}
 async function getSpurHistoryHealth(date, dbPath = ".spur/spur.db") {
   try {
-    const resolvedPath = resolve(process.cwd(), dbPath);
-    if (!existsSync(resolvedPath)) {
-      return null;
-    }
-    const { Database } = await import("bun:sqlite");
-    const db = new Database(resolvedPath, { readonly: true });
-    try {
-      const loopTable = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get("history_board_loop_findings");
-      let loops = [];
-      if (loopTable) {
-        const rows = db.query(`SELECT tool_name, args_digest, repeats, session_id, first_seq, last_seq, started_at
-                         FROM history_board_loop_findings
-                         WHERE started_at IS NULL OR started_at LIKE ?
-                         ORDER BY repeats DESC
-                         LIMIT 20`).all(`${date}%`);
-        loops = rows.map((r) => ({
-          toolName: r.tool_name,
-          argsDigest: r.args_digest || "repeated execution",
-          repeats: r.repeats,
-          sessionId: r.session_id,
-          fromSeq: r.first_seq,
-          toSeq: r.last_seq,
-          wastedTokens: r.repeats * 250
-        }));
-      }
-      let toolCalls = 0;
-      let toolErrors = 0;
-      const toolTable = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get("history_board_tool_5m");
-      if (toolTable) {
-        const stats = db.query(`SELECT SUM(calls) AS calls, SUM(errors) AS errors
-                         FROM history_board_tool_5m
-                         WHERE bucket_start LIKE ?`).get(`${date}%`);
-        toolCalls = stats?.calls ?? 0;
-        toolErrors = stats?.errors ?? 0;
-      }
-      const redundantCalls = loops.reduce((acc, l) => acc + Math.max(0, l.repeats - 1), 0);
-      const wastedTokens = loops.reduce((acc, l) => acc + l.wastedTokens, 0);
-      const errorRatePct = toolCalls > 0 ? toolErrors / toolCalls * 100 : 0;
-      const remediationProposals = [];
-      for (const lp of loops.slice(0, 5)) {
-        const cleanTool = lp.toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const key = `repetition:${cleanTool}:${lp.argsDigest.slice(0, 16)}`;
-        const title = `Break execution loop in ${lp.toolName} (${lp.repeats} repeats)`;
-        const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
-        remediationProposals.push({ key, title, command });
-      }
-      if (toolCalls > 0 && errorRatePct > 10) {
-        const key = "reliability:tooling:high-error-rate";
-        const title = `Investigate high tool error rate (${errorRatePct.toFixed(1)}%)`;
-        const command = `spur task create "<title>" --feature <id> && spur task update <wbs> --section Plan --from-file <path>`;
-        remediationProposals.push({ key, title, command });
-      }
-      return {
-        toolCalls,
-        toolErrors,
-        errorRatePct,
-        loops,
-        redundantCalls,
-        wastedTokens,
-        remediationProposals
-      };
-    } finally {
-      db.close();
-    }
+    const resolvedPath = resolve2(process.cwd(), dbPath);
+    const { app } = await loadInlineApp(getEnvVar("SPUR_BIN") ?? "", resolveAppEntry, [
+      "readHistoryHealth"
+    ]);
+    const reading = await app.readHistoryHealth({ date, dbPath: resolvedPath });
+    return reading === null ? null : composeHistoryHealth(reading);
   } catch {
     return null;
   }
@@ -320,9 +332,9 @@ Please provide the following (press Enter to skip):
     input: process.stdin,
     output: process.stdout
   });
-  const question = (prompt) => new Promise((resolve2) => {
+  const question = (prompt) => new Promise((resolve3) => {
     rl.question(prompt, (answer) => {
-      resolve2(answer.trim());
+      resolve3(answer.trim());
     });
   });
   const learnings = await question(`1. What did you learn today? (optional)
@@ -468,26 +480,26 @@ function generateMarkdown(summary) {
 `);
 }
 function ensureDir(path) {
-  if (!existsSync(path)) {
+  if (!existsSync2(path)) {
     mkdirSync(path, { recursive: true });
   }
 }
 function writeSummary(markdown, options) {
   const filename = `summary_${options.date.replace(/-/g, "")}.md`;
-  const outputPath = options.outputPath || join(DAILY_DIR, filename);
-  ensureDir(join(outputPath, ".."));
+  const outputPath = options.outputPath || join2(DAILY_DIR, filename);
+  ensureDir(join2(outputPath, ".."));
   writeFileSync(outputPath, markdown, "utf-8");
   return outputPath;
 }
 function resolveHistoryReportPath() {
-  const pointer = resolve(process.cwd(), ".spur", "reports", "history", "latest.json");
-  if (!existsSync(pointer)) {
+  const pointer = resolve2(process.cwd(), ".spur", "reports", "history", "latest.json");
+  if (!existsSync2(pointer)) {
     return;
   }
   try {
     const target = readlinkSync(pointer);
-    const resolved = isAbsolute(target) ? target : resolve(dirname(pointer), target);
-    return existsSync(resolved) ? resolved : undefined;
+    const resolved = isAbsolute(target) ? target : resolve2(dirname2(pointer), target);
+    return existsSync2(resolved) ? resolved : undefined;
   } catch {
     return;
   }
@@ -540,13 +552,21 @@ async function buildDailySummary(options) {
     result.gitActivity = gitActivity;
   }
   const historyHealth = await getSpurHistoryHealth(options.date);
-  if (historyHealth && (historyHealth.loops.length > 0 || historyHealth.toolCalls > 0)) {
+  if (historyHealth) {
     result.historyHealth = historyHealth;
     platforms.push("Spur History");
   }
   return result;
 }
 async function main() {
+  if (!process.versions.bun) {
+    const child = spawnSync("bun", [fileURLToPath2(import.meta.url), ...process.argv.slice(2)], {
+      stdio: "inherit"
+    });
+    if (!child.error)
+      process.exit(child.status ?? 1);
+    console.error(`daily-summary: Bun not on PATH (${child.error.message}); history health unavailable`);
+  }
   const options = parseArgs();
   logger.info(`Generating daily summary for ${options.date}...`);
   try {
@@ -602,6 +622,7 @@ export {
   getCcusageData,
   generateMarkdown,
   ensureDir,
+  enableLogger,
   defaultProcessSpawner,
   buildDailySummary
 };