@gobing-ai/spur 0.4.2 → 0.4.4

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

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 // @bun
-import { createRequire } from "node:module";
-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 +16,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, resolveAppEntry, required) {
+  const { entry, portable } = resolveAppEntry(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 +141,7 @@ function getDateRange(dateStr) {
   return { start, end };
 }
 var defaultProcessSpawner = (cmd, args, env) => {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve, reject) => {
     try {
       const proc = spawn(cmd, args, {
         stdio: ["ignore", "pipe", "pipe"],
@@ -119,7 +152,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({
+        resolve({
           stdout: Buffer.concat(stdoutChunks).toString("utf8"),
           stderr: Buffer.concat(stderrChunks).toString("utf8"),
           exitCode: exitCode ?? 0
@@ -158,72 +191,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;
   }
@@ -307,12 +317,12 @@ Please provide the following (press Enter to skip):
       chunks.push(chunk);
     }
     const buffered = Buffer.concat(chunks).toString("utf-8");
-    const [learnings2 = "", issuesFixed2 = "", pending2 = ""] = buffered.split(`
+    const [learnings = "", issuesFixed = "", pending = ""] = buffered.split(`
 `);
     return {
-      learnings: learnings2.trim(),
-      issuesFixed: issuesFixed2.trim(),
-      pending: pending2.trim()
+      learnings: learnings.trim(),
+      issuesFixed: issuesFixed.trim(),
+      pending: pending.trim()
     };
   }
   const readline = await import("readline");
@@ -320,9 +330,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((resolve) => {
     rl.question(prompt, (answer) => {
-      resolve2(answer.trim());
+      resolve(answer.trim());
     });
   });
   const learnings = await question(`1. What did you learn today? (optional)
@@ -468,26 +478,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 +550,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 {
@@ -588,20 +606,21 @@ ${markdown}
   });
 }
 export {
-  yesterdayLocal,
-  writeSummary,
-  todayLocal,
-  setProcessSpawner,
-  promptUser,
-  printUsage,
-  parseArgs,
-  main,
-  getSpurHistoryHealth,
-  getGitCommits,
-  getDateRange,
-  getCcusageData,
-  generateMarkdown,
-  ensureDir,
+  buildDailySummary,
   defaultProcessSpawner,
-  buildDailySummary
+  enableLogger,
+  ensureDir,
+  generateMarkdown,
+  getCcusageData,
+  getDateRange,
+  getGitCommits,
+  getSpurHistoryHealth,
+  main,
+  parseArgs,
+  printUsage,
+  promptUser,
+  setProcessSpawner,
+  todayLocal,
+  writeSummary,
+  yesterdayLocal
 };

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

@@ -11,9 +11,31 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readlinkSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { getEnvVar, getEnvVars } from '../../lib/env';
+import { loadInlineApp, resolveAppEntry } from '../../lib/inline-run-app';
 
-import { logger } from './logger';
+// ─── In-script logger ────────────────────────────────────────────────────────
+
+// The former `logger.ts` helper exposed a file channel nothing ever implemented, so the used part
+// — a console toggle the tests need — lives here instead of a one-caller module (task 1173, plan P7).
+let consoleEnabled = true;
+
+/** Silence or restore this script's console output (test hook). */
+export function enableLogger(consoleOn: boolean): void {
+    consoleEnabled = consoleOn;
+}
+
+function logAt(stream: 'log' | 'warn' | 'error', message: string): void {
+    if (!consoleEnabled) return;
+    console[stream](message);
+}
+
+const logger = {
+    info: (message: string): void => logAt('log', message),
+    warn: (message: string): void => logAt('warn', message),
+    error: (message: string): void => logAt('error', message),
+};
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -287,113 +309,85 @@ export async function getCcusageData(date: string): Promise<CcusageData | null>
 
 // ─── Spur History Health Integration ──────────────────────────────────────────
 
+/** The day's raw history health read back across the generated inline app entry (task 1178 R3). */
+interface HistoryHealthReading {
+    toolCalls: number;
+    toolErrors: number;
+    errorRatePct: number;
+    loops: Array<{
+        toolName: string;
+        argsDigest: string;
+        repeats: number;
+        sessionId: string;
+        firstSeq: number;
+        lastSeq: number;
+        startedAt: string | null;
+    }>;
+}
+
+/** The generated inline app entry's history-health export. */
+interface InlineHistoryApp {
+    readHistoryHealth(input: { date: string; dbPath: string }): Promise<HistoryHealthReading | null>;
+}
+
+/**
+ * Compose the daily report's health summary from the app reading. `wastedTokens` stays an
+ * explicit `repeats * 250` estimate; remediation proposals stay plain text (task 1178 R3).
+ */
+function composeHistoryHealth(reading: HistoryHealthReading): HistoryHealthSummary {
+    const loops: HistoryLoopFinding[] = 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: Array<{ key: string; title: string; command: string }> = [];
+    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,
+    };
+}
+
+/**
+ * Read the day's history health through the app owner (task 1178 R3): this adapter opens no
+ * SQLite and carries no SQL. A missing database file or required table returns `null`
+ * (unavailable); an existing empty table returns a measured-zero summary, never `n/a`.
+ */
 export async function getSpurHistoryHealth(
     date: string,
     dbPath = '.spur/spur.db',
 ): Promise<HistoryHealthSummary | null> {
     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 {
-            // 1. Query execution loop findings
-            const loopTable = db
-                .query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
-                .get('history_board_loop_findings');
-
-            let loops: HistoryLoopFinding[] = [];
-            if (loopTable) {
-                const rows = db
-                    .query<
-                        {
-                            tool_name: string;
-                            args_digest: string;
-                            repeats: number;
-                            session_id: string;
-                            first_seq: number;
-                            last_seq: number;
-                            started_at: string | null;
-                        },
-                        [string]
-                    >(
-                        `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,
-                }));
-            }
-
-            // 2. Query tool calls and errors
-            let toolCalls = 0;
-            let toolErrors = 0;
-            const toolTable = db
-                .query<{ name: string }, [string]>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
-                .get('history_board_tool_5m');
-
-            if (toolTable) {
-                const stats = db
-                    .query<{ calls: number | null; errors: number | null }, [string]>(
-                        `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;
-
-            // 3. Generate auto-healing remediation proposals
-            const remediationProposals: Array<{ key: string; title: string; command: string }> = [];
-
-            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 { app } = await loadInlineApp<InlineHistoryApp>(getEnvVar('SPUR_BIN') ?? '', resolveAppEntry, [
+            'readHistoryHealth',
+        ]);
+        const reading = await app.readHistoryHealth({ date, dbPath: resolvedPath });
+        return reading === null ? null : composeHistoryHealth(reading);
     } catch {
         return null;
     }
@@ -795,9 +789,11 @@ export async function buildDailySummary(options: CliOptions): Promise<DailySumma
         result.gitActivity = gitActivity;
     }
 
-    // Query Spur history health (loops, tool errors, and auto-healing proposals)
+    // Query Spur history health (loops, tool errors, and auto-healing proposals). A measured
+    // empty day is a real zero and keeps its "Clean" section; an unavailable database (missing
+    // file/table) stays absent — absence and zero never collapse (task 1178 R3).
     const historyHealth = await getSpurHistoryHealth(options.date);
-    if (historyHealth && (historyHealth.loops.length > 0 || historyHealth.toolCalls > 0)) {
+    if (historyHealth) {
         result.historyHealth = historyHealth;
         platforms.push('Spur History');
     }
@@ -806,6 +802,17 @@ export async function buildDailySummary(options: CliOptions): Promise<DailySumma
 }
 
 export async function main(): Promise<void> {
+    // The generated app entry read by getSpurHistoryHealth needs Bun (SQLite); the installed
+    // `.mjs` twin may be launched with plain node, so re-enter Bun before any app import.
+    // Without Bun on PATH, keep running under node: the history reader degrades to unavailable
+    // (n/a) instead of failing the whole report (task 1178 review P4).
+    if (!process.versions.bun) {
+        const child = spawnSync('bun', [fileURLToPath(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}...`);

package/plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.mjs

@@ -2,7 +2,7 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts
+// plugins/sp/lib/dogfood-pipeline.ts
 var PIPELINE_TOKENS = [
   "--next",
   "dev-runall",
@@ -125,6 +125,7 @@ function evaluateDogfoodGate(testee, options = {}) {
     exitCode: 0
   };
 }
+// plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts
 function parseCliArgs(argv) {
   let testee = null;
   let maxRetryPresent = false;
@@ -195,16 +196,16 @@ function runCli(argv) {
   process.exit(exitCode);
 }
 export {
-  runCli,
-  parseCliArgs,
-  isImplementHeavyStep,
-  hasMutatingFixMode,
-  evaluateDogfoodGate,
-  detectPipelineDriving,
-  detectImplementHeavy,
-  PIPELINE_TOKENS,
-  PIPELINE_DRIVING_REFUSE_MESSAGE,
-  MUTATING_FIX_REFUSE_MESSAGE,
+  CLI_USAGE,
   IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
-  CLI_USAGE
+  MUTATING_FIX_REFUSE_MESSAGE,
+  PIPELINE_DRIVING_REFUSE_MESSAGE,
+  PIPELINE_TOKENS,
+  detectImplementHeavy,
+  detectPipelineDriving,
+  evaluateDogfoodGate,
+  hasMutatingFixMode,
+  isImplementHeavyStep,
+  parseCliArgs,
+  runCli
 };