@gobing-ai/spur 0.4.1 → 0.4.3

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

@@ -9,6 +9,10 @@
  * Modes:
  *   waves --tasks <file>  file: JSON array of {wbs, name}; prints `{ waves: [...] }` — waves
  *                         of 24 tasks as A Prepare batch + A1..A4 + B..Y task rows + Z Batch report.
+ *   order --tasks <file> [--concurrency <n>]
+ *                         file: JSON array of {wbs, dependencies?, files?}; prints the scheduleBatch
+ *                         result `{ order, waves, cycle, overlaps, mode, reason }` (dev-runall §2.4
+ *                         order + the --mode auto recommendation). A cycle is data, not an error.
  *   task-children --letter <A-Z> --plan <file>
  *                         file: a `workflow show --format todo --json` payload (or a bare plan
  *                         array); prints the task's phase digits as a JSON array.
@@ -16,13 +20,13 @@
  * `node batch-plan.mjs` (committed twin) — keep the twin in lockstep.
  */
 import { readFileSync } from 'node:fs';
-import type { BatchTask, PhasedPlanItem } from '../lib/plan-projection.generated.mjs';
-import { buildBatchPlan, taskPhaseChildren } from '../lib/plan-projection.generated.mjs';
+import type { BatchTask, PhasedPlanItem, ScheduleTask } from '../lib/plan-projection.generated.mjs';
+import { buildBatchPlan, scheduleBatch, taskPhaseChildren } from '../lib/plan-projection.generated.mjs';
 
 export * from '../lib/plan-projection.generated.mjs';
 
 export const BATCH_PLAN_USAGE =
-    'usage: batch-plan.ts waves --tasks <tasks.json> | task-children --letter <A-Z> --plan <plan.json>';
+    'usage: batch-plan.ts waves --tasks <tasks.json> | order --tasks <tasks.json> [--concurrency <n>] | task-children --letter <A-Z> --plan <plan.json>';
 
 function readJsonFile(path: string): unknown {
     return JSON.parse(readFileSync(path, 'utf8'));
@@ -37,6 +41,20 @@ function isBatchTask(value: unknown): value is BatchTask {
     );
 }
 
+function isStringArray(value: unknown): value is string[] {
+    return Array.isArray(value) && value.every((v) => typeof v === 'string');
+}
+
+function isScheduleTask(value: unknown): value is ScheduleTask {
+    if (typeof value !== 'object' || value === null) return false;
+    const t = value as ScheduleTask;
+    return (
+        typeof t.wbs === 'string' &&
+        (t.dependencies === undefined || isStringArray(t.dependencies)) &&
+        (t.files === undefined || isStringArray(t.files))
+    );
+}
+
 export function main(argv: string[]): number {
     const mode = argv[0];
     if (mode === 'waves') {
@@ -60,6 +78,33 @@ export function main(argv: string[]): number {
         process.stdout.write(`${JSON.stringify({ waves: buildBatchPlan(tasks) })}\n`);
         return 0;
     }
+    if (mode === 'order') {
+        let tasksPath = '';
+        let concurrency = 2;
+        for (let i = 1; i + 1 < argv.length; i += 2) {
+            if (argv[i] === '--tasks') tasksPath = argv[i + 1] ?? '';
+            else if (argv[i] === '--concurrency') concurrency = Number(argv[i + 1]);
+        }
+        if (tasksPath === '' || !Number.isInteger(concurrency) || concurrency < 1) {
+            process.stderr.write(`${BATCH_PLAN_USAGE}\n`);
+            return 2;
+        }
+        let tasks: unknown;
+        try {
+            tasks = readJsonFile(tasksPath);
+        } catch (error) {
+            process.stderr.write(
+                `batch-plan: cannot read ${tasksPath} — ${error instanceof Error ? error.message : String(error)}\n`,
+            );
+            return 1;
+        }
+        if (!Array.isArray(tasks) || !tasks.every(isScheduleTask)) {
+            process.stderr.write('batch-plan: --tasks file must be a JSON array of {wbs, dependencies?, files?}\n');
+            return 1;
+        }
+        process.stdout.write(`${JSON.stringify(scheduleBatch(tasks, { concurrency }))}\n`);
+        return 0;
+    }
     if (mode === 'task-children') {
         let letter = '';
         let planPath = '';

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

@@ -2,7 +2,7 @@
 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
 var NON_ABORTING_PREFLIGHT_CODES = new Set([
   "L4.scenario-unverified",
   "L4.verifying-incomplete-tasks"
@@ -181,6 +181,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) {

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).