@gobing-ai/spur 0.4.2 → 0.4.4

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

@@ -2,7 +2,13 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// plugins/sp/scripts/batch-preflight.ts
+// plugins/sp/lib/plan-projection.generated.mjs
+function isTaskFrozen(status) {
+  return status?.toLowerCase() === "deprecated";
+}
+function undeprecateTaskCommand(wbs) {
+  return `spur task update ${wbs} todo`;
+}
 var NON_ABORTING_PREFLIGHT_CODES = new Set([
   "L4.scenario-unverified",
   "L4.verifying-incomplete-tasks"
@@ -53,6 +59,13 @@ function quickReadiness(input) {
       };
     }
   }
+  if (isTaskFrozen(status)) {
+    return {
+      action: "skipped",
+      code: "DEPRECATED",
+      reason: `quick-readiness: deprecated (frozen) — no ${operation} hop; un-deprecate with \`${undeprecateTaskCommand(input.wbs)}\` (${input.wbs})`
+    };
+  }
   if (status === "cancelled" || status === "done") {
     if (operation === "verify" && input.force === true) {
       return {
@@ -77,10 +90,12 @@ function quickReadiness(input) {
   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) {
+      const frozen = unmet.filter((d) => isTaskFrozen(input.depStatuses?.[d]));
+      const hint = frozen.length > 0 ? ` — ${frozen.map((d) => `${d} deprecated (frozen); re-point the edge or un-deprecate: \`${undeprecateTaskCommand(d)}\``).join("; ")}` : "";
       return {
         action: "blocked",
         code: "DEP",
-        reason: `quick-readiness: unmet deps — ${unmet.join(", ")} (${input.wbs})`,
+        reason: `quick-readiness: unmet deps — ${unmet.join(", ")} (${input.wbs})${hint}`,
         unmetDeps: unmet
       };
     }
@@ -165,6 +180,13 @@ function preflightTask(input) {
       reason: `dev-next: blocked — do not launch pipeline; human/handover first (${input.wbs})`
     };
   }
+  if (isTaskFrozen(status)) {
+    return {
+      action: "skip",
+      code: "DEPRECATED",
+      reason: `dev-next: deprecated (frozen) — un-deprecate first: ${undeprecateTaskCommand(input.wbs)} (${input.wbs})`
+    };
+  }
   if (status === "todo" || status === "backlog") {
     const unmet = deps.filter((d) => {
       const st = (depStatuses[d] ?? "missing").toLowerCase();
@@ -181,6 +203,28 @@ function preflightTask(input) {
   }
   return { action: "run", code: "OK", reason: `preflight clear — launch task-pipeline for ${input.wbs}` };
 }
+var OPERATOR_TOOLS = new Set(["AskUserQuestion", "ask_user_question"]);
+var SHELL_TOOLS = new Set(["bash", "shell", "exec", "exec_command", "run_command", "command"]);
+var SUBAGENT_TOOLS = new Set(["agent", "task", "invoke_subagent", "subagent", "dispatch_agent"]);
+var LOWERCASE_OPERATOR_TOOLS = new Set(["askuserquestion", "ask_user_question"]);
+var SENSITIVE_PREFIXES = ["drizzle/", "packages/config/", ".github/", "plugins/sp/hooks/"];
+var SENSITIVE_GLOBS = ["apps/server/src/**/auth*", "**/*secret*", "**/*.sql"];
+function globToRegex(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*");
+  return new RegExp(`^${escaped}$`, "s");
+}
+var SENSITIVE_MATCHERS = [
+  ...SENSITIVE_PREFIXES.map((prefix) => ({
+    label: prefix,
+    test: (path) => path.startsWith(prefix)
+  })),
+  ...SENSITIVE_GLOBS.map((glob) => {
+    const regex = globToRegex(glob);
+    return { label: glob, test: (path) => regex.test(path) };
+  })
+];
+
+// plugins/sp/scripts/batch-preflight.ts
 function recoveryHint(status, wbs) {
   const st = (status ?? "").toLowerCase();
   switch (st) {
@@ -310,7 +354,7 @@ function runPreflightCli(argv) {
     return { exitCode: 0, stdout: body, stderr: "" };
   }
   if (args.operation !== null) {
-    const result2 = quickReadiness({
+    const result = quickReadiness({
       wbs: args.wbs,
       status: args.status,
       operation: args.operation,
@@ -321,14 +365,14 @@ function runPreflightCli(argv) {
       ...args.presentSections.length > 0 ? { presentSections: args.presentSections } : {},
       ...args.force ? { force: true } : {}
     });
-    const runnable = result2.action === "runnable" || result2.action === "needs-refinement";
+    const runnable = result.action === "runnable" || result.action === "needs-refinement";
     if (args.json) {
-      return { exitCode: runnable ? 0 : 2, stdout: `${JSON.stringify(result2, null, 2)}
+      return { exitCode: runnable ? 0 : 2, stdout: `${JSON.stringify(result, null, 2)}
 `, stderr: "" };
     }
     return {
       exitCode: runnable ? 0 : 2,
-      stdout: `${result2.action}${result2.code ? ` ${result2.code}` : ""}: ${result2.reason}
+      stdout: `${result.action}${result.code ? ` ${result.code}` : ""}: ${result.reason}
 `,
       stderr: ""
     };
@@ -368,12 +412,12 @@ function runPreflightCli(argv) {
   process.exit(exitCode);
 }
 export {
-  runPreflightCli,
-  recoveryHint,
-  quickReadiness,
-  preflightTask,
-  parsePreflightCliArgs,
-  classifyFeaturePreflightFindings,
+  NON_ABORTING_PREFLIGHT_CODES,
   PREFLIGHT_CLI_USAGE,
-  NON_ABORTING_PREFLIGHT_CODES
+  classifyFeaturePreflightFindings,
+  parsePreflightCliArgs,
+  preflightTask,
+  quickReadiness,
+  recoveryHint,
+  runPreflightCli
 };

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/commit-guard.mjs

@@ -206,11 +206,11 @@ function main(argv, options = {}) {
   process.exit(main(process.argv.slice(2)));
 }
 export {
-  runStart,
-  runStage,
-  runCheck,
-  parsePorcelainZ,
-  main,
+  COMMIT_GUARD_USAGE,
   conflictMarkerLine,
-  COMMIT_GUARD_USAGE
+  main,
+  parsePorcelainZ,
+  runCheck,
+  runStage,
+  runStart
 };