@gobing-ai/spur 0.3.94 → 0.3.96

package/plugins/sp/scripts/workflow-step-profile.ts

@@ -2,311 +2,31 @@
 /**
  * workflow-step-profile — per-node step evidence for `sp:spur-doctor` (task 0827, feature I21).
  *
- * ADR-115 sets step boundaries by the provider cache window, not the clock, and satellite §10 owns
- * the four budgets that follow from it. Trace already records each action event's `durationMs`,
- * `startedAt`/`completedAt`, `invocation` and `cost`, but nothing aggregates it per node. This
- * read-only plugin script (ADR-065) composes the existing `spur workflow trace --json` surface
- * (governance §2) into per-node/action-kind rows so doctor maps flag ids to proposals instead of
- * re-deriving numbers from prose.
- *
- * Statelessness: the script computes the flags arithmetically and holds no thresholds of its own
- * beyond the §10 window `W` (default 300 s). Unknown evidence stays `null` and never becomes zero:
- * a step with no recorded `cost.exact.cacheHit` reports `{p50: null, known: 0}`, not a 0 hit rate.
- * `cost.estimated` (retroactive mappings) never mixes into `cacheHit`.
+ * IO glue only (task 1005 R4, ADR-130 lib rule): argv parsing, `spur workflow trace --json`
+ * spawning and the two output modes. The aggregation core (nearestRankP50, extractExecutions,
+ * rowFlags, buildRows, buildStepProfile, nonDryRuns, formatStepProfileHuman and their types) lives
+ * in packages/app/src/workflow/step-profile.ts and reaches this script through the generated
+ * standalone bundle `plugins/sp/lib/step-profile.generated.mjs` — node-builtin only, so the
+ * committed `.mjs` twin runs under bare `node`. Regenerate with `bun run build:scripts`.
  *
  * Exit: 0 whenever a profile is produced (including `sampledRuns: 0` and flagged rows). Flags are
  * evidence, not a gate. 1, with a stderr message, only when a `spur` call fails, its JSON does not
  * parse, or the workflow argument is missing.
- *
- * Node-builtin imports only; the pure builders are exported for unit testing, `runStepProfileCli`
- * and `main` do the I/O (mirrors the batch-preflight / feature-sync-bounded script shape).
  */
-
 import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { getEnvVar } from '../lib/env';
-
-// ── Input shapes (a subset of the live `spur workflow trace --json` payload) ─────────────
-
-/** One `cost.exact` / `cost.estimated` bucket; only `cacheHit` is read. */
-export interface ActionCostLike {
-    cacheHit: number | null;
-}
-
-/**
- * `ActionCostAttribution` as trace emits it. Both classes are read structurally so the script
- * carries no import of the domain package (twins must stay self-contained).
- */
-export interface ActionCostAttributionLike {
-    exact: ActionCostLike | null;
-    estimated: ActionCostLike | null;
-}
-
-/** One timeline event. Non-`action` events are ignored; the rest is optional on purpose. */
-export interface TraceActionEvent {
-    kind: string;
-    node?: string;
-    actionKind?: string;
-    durationMs?: number | null;
-    startedAt?: string | null;
-    completedAt?: string | null;
-    invocation?: Record<string, string | number | boolean> | null;
-    cost?: ActionCostAttributionLike | null;
-}
-
-/** One sampled run: the run id plus its timeline events. */
-export interface StepProfileRun {
-    runId: string;
-    events: readonly TraceActionEvent[];
-}
-
-/** A `spur workflow trace --json` list entry (the fields the profile needs). */
-export interface TraceRunEntry {
-    runId: string;
-    isDryRun?: boolean;
-    status?: string;
-    workflowName?: string;
-}
-
-export type SessionMode = 'fresh' | 'resumed' | 'mixed';
-
-// ── Output shapes ──────────────────────────────────────────────────────────────────────
-
-/** One execution of a node's action kind inside one run. */
-export interface StepProfileExecution {
-    runId: string;
-    node: string;
-    actionKind: string;
-    durationMs: number | null;
-    idleGapMs: number | null;
-    /** `invocation.continue` as recorded; null when the event predates the field. */
-    session: 'fresh' | 'resumed' | null;
-    cacheHit: number | null;
-}
-
-/** One (node, actionKind) row — the R1 grain. */
-export interface StepProfileRow {
-    node: string;
-    actionKind: string;
-    runs: number;
-    executions: number;
-    durationMs: { p50: number | null; max: number | null };
-    idleGapMs: { p50: number | null };
-    session: SessionMode | null;
-    cacheHit: { p50: number | null; known: number; of: number };
-    flags: string[];
-}
-
-/** The `--json` envelope. */
-export interface StepProfile {
-    workflow: string;
-    windowSec: number;
-    sampledRuns: number;
-    rows: StepProfileRow[];
-}
-
-// ── Aggregation ────────────────────────────────────────────────────────────────────────
-
-export const DEFAULT_LAST = 20;
-/** §10 window `W`: the shortest common provider cache default, in seconds. */
-export const DEFAULT_WINDOW_SEC = 300;
-
-/**
- * Nearest-rank median: `sorted[Math.ceil(n / 2) - 1]`, so every reported value is one that was
- * actually observed. Empty input is unknown (`null`), never 0.
- */
-export function nearestRankP50(values: readonly number[]): number | null {
-    if (values.length === 0) return null;
-    const sorted = [...values].sort((a, b) => a - b);
-    return sorted[Math.ceil(sorted.length / 2) - 1] ?? null;
-}
-
-function numeric(value: number | null | undefined): number | null {
-    return typeof value === 'number' && Number.isFinite(value) ? value : null;
-}
-
-function msBetween(from: string | null | undefined, to: string | null | undefined): number | null {
-    if (typeof from !== 'string' || typeof to !== 'string') return null;
-    const start = Date.parse(from);
-    const end = Date.parse(to);
-    if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
-    return end - start;
-}
-
-function sessionOf(event: TraceActionEvent): 'fresh' | 'resumed' | null {
-    const value = event.invocation?.continue;
-    if (value === true) return 'resumed';
-    if (value === false) return 'fresh';
-    return null;
-}
-
-function cacheHitOf(event: TraceActionEvent): number | null {
-    // `cost.estimated` is deliberately unread: retroactive mappings never mix with exact evidence.
-    return numeric(event.cost?.exact?.cacheHit);
-}
-
-/** Sort key: a parseable `startedAt`, with the unknown (`unavailable` / null) ordering last. */
-function startKey(event: TraceActionEvent): number {
-    const parsed = typeof event.startedAt === 'string' ? Date.parse(event.startedAt) : Number.NaN;
-    return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
-}
-
-/**
- * The executions of one run: `kind === 'action'` events in `startedAt` order (trace emits them in
- * row-creation order), each carrying its idle gap (from the previous action's `completedAt` in the
- * same run), session mode and cacheHit. The run's first action has no previous action, so its gap
- * is unknown — never 0.
- */
-export function extractExecutions(runId: string, events: readonly TraceActionEvent[]): StepProfileExecution[] {
-    const actions = events
-        .filter((e) => e.kind === 'action')
-        .sort((a, b) => {
-            const left = startKey(a);
-            const right = startKey(b);
-            return left === right ? 0 : left - right;
-        });
-    const executions: StepProfileExecution[] = [];
-    for (const [index, event] of actions.entries()) {
-        const previous = index === 0 ? undefined : actions[index - 1];
-        executions.push({
-            runId,
-            node: event.node ?? '',
-            actionKind: event.actionKind ?? '',
-            durationMs: numeric(event.durationMs),
-            idleGapMs: msBetween(previous?.completedAt, event.startedAt),
-            session: sessionOf(event),
-            cacheHit: cacheHitOf(event),
-        });
-    }
-    return executions;
-}
-
-function foldSession(executions: readonly StepProfileExecution[]): SessionMode | null {
-    const known = new Set(executions.map((e) => e.session).filter((s): s is 'fresh' | 'resumed' => s !== null));
-    if (known.size === 0) return null;
-    if (known.size === 1) return [...known][0] ?? null;
-    return 'mixed';
-}
-
-/**
- * The four §10 cache-window flags for one row. `W` is in seconds and durations compare as
- * `ms > W * 1000`, so a step exactly at the budget is inside it.
- */
-export function rowFlags(row: StepProfileRow, windowSec: number): string[] {
-    const wMs = windowSec * 1000;
-    const flags: string[] = [];
-    const agentRun = row.actionKind === 'agent.run';
-    const resumed = row.session === 'resumed' || row.session === 'mixed';
-    const p50 = row.durationMs.p50;
-    if (!agentRun && p50 !== null && p50 > wMs) flags.push('step-over-window');
-    const idle = row.idleGapMs.p50;
-    if (agentRun && resumed && idle !== null && idle > wMs) flags.push('resume-after-idle');
-    const hit = row.cacheHit.p50;
-    if (agentRun && resumed && row.cacheHit.known > 0 && hit !== null && hit < 0.5) flags.push('resume-cold-cache');
-    if (agentRun && p50 !== null && p50 > 2 * wMs) flags.push('agent-run-over-2w');
-    return flags;
-}
-
-/** Fold per-run executions into the sorted (node, actionKind) rows. */
-export function buildRows(executions: readonly StepProfileExecution[], windowSec: number): StepProfileRow[] {
-    const grouped = new Map<string, StepProfileExecution[]>();
-    for (const execution of executions) {
-        const key = `${execution.node}\u0000${execution.actionKind}`;
-        const bucket = grouped.get(key);
-        if (bucket === undefined) grouped.set(key, [execution]);
-        else bucket.push(execution);
-    }
-
-    const rows: StepProfileRow[] = [];
-    for (const bucket of grouped.values()) {
-        const first = bucket[0];
-        if (first === undefined) continue;
-        const durations = bucket.map((e) => e.durationMs).filter((d): d is number => d !== null);
-        const gaps = bucket.map((e) => e.idleGapMs).filter((g): g is number => g !== null);
-        const hits = bucket.map((e) => e.cacheHit).filter((h): h is number => h !== null);
-        const row: StepProfileRow = {
-            node: first.node,
-            actionKind: first.actionKind,
-            runs: new Set(bucket.map((e) => e.runId)).size,
-            executions: bucket.length,
-            durationMs: {
-                p50: nearestRankP50(durations),
-                max: durations.length === 0 ? null : Math.max(...durations),
-            },
-            idleGapMs: { p50: nearestRankP50(gaps) },
-            session: first.actionKind === 'agent.run' ? foldSession(bucket) : null,
-            cacheHit: {
-                p50: nearestRankP50(hits),
-                known: hits.length,
-                of: bucket.length,
-            },
-            flags: [],
-        };
-        row.flags = rowFlags(row, windowSec);
-        rows.push(row);
-    }
-
-    return rows.sort((a, b) =>
-        a.node === b.node ? a.actionKind.localeCompare(b.actionKind) : a.node.localeCompare(b.node),
-    );
-}
-
-/** Build the profile over the sampled (already dry-run-filtered) runs. */
-export function buildStepProfile(input: {
-    workflow: string;
-    windowSec: number;
-    runs: readonly StepProfileRun[];
-}): StepProfile {
-    const executions = input.runs.flatMap((run) => extractExecutions(run.runId, run.events));
-    return {
-        workflow: input.workflow,
-        windowSec: input.windowSec,
-        sampledRuns: input.runs.length,
-        rows: buildRows(executions, input.windowSec),
-    };
-}
-
-/** Drop `isDryRun: true` entries (and anything without a run id) before sampling. */
-export function nonDryRuns(entries: readonly TraceRunEntry[]): TraceRunEntry[] {
-    return entries.filter((e) => e.isDryRun !== true && typeof e.runId === 'string' && e.runId.length > 0);
-}
-
-// ── Output rendering ───────────────────────────────────────────────────────────────────
-
-function seconds(value: number | null): string {
-    return value === null ? '?' : `${(value / 1000).toFixed(1)}s`;
-}
-
-function ratio(value: number | null): string {
-    return value === null ? '?' : value.toFixed(2);
-}
-
-/** One line per row; seconds carry one decimal and `?` marks an unknown value. */
-export function formatStepProfileHuman(profile: StepProfile): string {
-    const lines = [
-        `step profile — ${profile.workflow} (window ${profile.windowSec}s, ${profile.sampledRuns} sampled runs)`,
-    ];
-    for (const row of profile.rows) {
-        lines.push(
-            [
-                row.node.padEnd(20),
-                row.actionKind.padEnd(14),
-                `${row.runs}/${row.executions}`.padEnd(8),
-                `p50=${seconds(row.durationMs.p50)}`.padEnd(12),
-                `max=${seconds(row.durationMs.max)}`.padEnd(12),
-                `idle=${seconds(row.idleGapMs.p50)}`.padEnd(12),
-                `session=${row.session ?? '?'}`.padEnd(15),
-                `cacheHit=${ratio(row.cacheHit.p50)} (${row.cacheHit.known}/${row.cacheHit.of})`.padEnd(20),
-                `flags=${row.flags.length === 0 ? '-' : row.flags.join(',')}`,
-            ].join(' '),
-        );
-    }
-    return `${lines.join('\n')}\n`;
-}
-
-// ── CLI ────────────────────────────────────────────────────────────────────────────────
-
+import { defaultSpurBin, spurCommand } from '../lib/spur-bin';
+import {
+    buildStepProfile,
+    DEFAULT_LAST,
+    DEFAULT_WINDOW_SEC,
+    formatStepProfileHuman,
+    nonDryRuns,
+    type StepProfileRun,
+    type TraceActionEvent,
+    type TraceRunEntry,
+} from '../lib/step-profile.generated.mjs';
+
+export * from '../lib/step-profile.generated.mjs';
 export interface StepProfileCliArgs {
     workflow: string;
     last: number;
@@ -316,18 +36,6 @@ export interface StepProfileCliArgs {
     help: boolean;
 }
 
-/**
- * Resolve the spur CLI monorepo-safely (copied from feature-sync-bounded: twins stay
- * self-contained and no plugin script imports another):
- * --spur-bin > SPUR_BIN > monorepo-local CLI entry > PATH `spur`.
- */
-export function defaultSpurBin(): string {
-    if (getEnvVar('SPUR_BIN')) return getEnvVar('SPUR_BIN');
-    const local = fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url));
-    if (existsSync(local)) return `bun ${local}`;
-    return 'spur';
-}
-
 function positiveInt(raw: string | undefined, fallback: number): number {
     const parsed = Number.parseInt(raw ?? '', 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -343,6 +51,7 @@ export function parseStepProfileCliArgs(argv: string[]): StepProfileCliArgs {
 
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
+        if (a === undefined) continue;
         if (a === '--help' || a === '-h') help = true;
         else if (a === '--json') json = true;
         else if (a === '--last') last = positiveInt(argv[++i], last);
@@ -356,9 +65,8 @@ export function parseStepProfileCliArgs(argv: string[]): StepProfileCliArgs {
 type SpawnResult = { stdout: string; stderr: string; exitCode: number; ok: boolean };
 
 function runSpurJson(spurBin: string, args: string[]): SpawnResult {
-    const binParts = spurBin.split(/\s+/).filter(Boolean);
-    const cmd = binParts[0] ?? 'spur';
-    const cmdArgs = [...binParts.slice(1), ...args];
+    const { cmd, prefix } = spurCommand(spurBin);
+    const cmdArgs = [...prefix, ...args];
     const r = spawnSync(cmd, cmdArgs, { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' });
     const decode = (b: unknown): string =>
         typeof b === 'string' ? b : Buffer.from((b as Uint8Array) ?? []).toString('utf8');

package/plugins/sp/scripts/wrapup-drift-probe.mjs

@@ -11,6 +11,12 @@ function getEnvVars() {
   return process.env;
 }
 
+// plugins/sp/lib/spur-bin.ts
+function spurCommand(spurBin) {
+  const parts = (spurBin ?? "spur").trim().split(/\s+/).filter((p) => p.length > 0);
+  return { cmd: parts[0] ?? "spur", prefix: parts.slice(1) };
+}
+
 // plugins/sp/scripts/wrapup-drift-probe.ts
 var WORKFLOWS_GLOB = `${join("config", "workflows")}/**`;
 var DOC_OWNED_SURFACES = [
@@ -57,6 +63,8 @@ function changedPathsOf(section) {
   const paths = [];
   for (const match of section.matchAll(CHANGE_ENTRY)) {
     const path = match[1];
+    if (path === undefined)
+      continue;
     if (/\s/.test(path))
       continue;
     if (!path.includes("/") && !path.includes("."))
@@ -73,16 +81,17 @@ var SURFACE_MATCHERS = DOC_OWNED_SURFACES.map((glob) => ({ glob, regex: surfaceR
 function driftReasonForPath(path) {
   if (CORPUS_PREFIXES.some((prefix) => path.startsWith(prefix)))
     return null;
-  if (path.includes("/") && !KNOWN_TOP_LEVEL.has(path.split("/")[0])) {
+  const top = path.split("/")[0];
+  if (path.includes("/") && top !== undefined && !KNOWN_TOP_LEVEL.has(top)) {
     return "new top-level workspace directory";
   }
   const match = SURFACE_MATCHERS.find((entry) => entry.regex.test(path));
   return match ? `matches doc-owned surface ${match.glob}` : null;
 }
 function defaultSpurRunner(env, cwd) {
-  const parts = (env.spurBin ?? "spur").split(/\s+/).filter((part) => part.length > 0);
+  const { cmd, prefix } = spurCommand(env.spurBin);
   return (args) => {
-    const run = spawnSync(parts[0], [...parts.slice(1), ...args], {
+    const run = spawnSync(cmd, [...prefix, ...args], {
       cwd,
       encoding: "utf8",
       env: getEnvVars()

package/plugins/sp/scripts/wrapup-drift-probe.ts

@@ -28,6 +28,7 @@ import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getEnvVars } from '../lib/env';
+import { spurCommand } from '../lib/spur-bin';
 
 export interface DriftProbeEnv {
     __runId?: string;
@@ -125,6 +126,7 @@ export function changedPathsOf(section: string | null): string[] {
     const paths: string[] = [];
     for (const match of section.matchAll(CHANGE_ENTRY)) {
         const path = match[1];
+        if (path === undefined) continue;
         // Path-like: no whitespace and at least one separator or dotted suffix, so prose
         // backticks never masquerade as change-map entries.
         if (/\s/.test(path)) continue;
@@ -148,7 +150,8 @@ const SURFACE_MATCHERS = DOC_OWNED_SURFACES.map((glob) => ({ glob, regex: surfac
 /** 0944 R2 surface match: doc-owned glob, corpus exclusion, new top-level directory. */
 export function driftReasonForPath(path: string): string | null {
     if (CORPUS_PREFIXES.some((prefix) => path.startsWith(prefix))) return null;
-    if (path.includes('/') && !KNOWN_TOP_LEVEL.has(path.split('/')[0])) {
+    const top = path.split('/')[0];
+    if (path.includes('/') && top !== undefined && !KNOWN_TOP_LEVEL.has(top)) {
         return 'new top-level workspace directory';
     }
     const match = SURFACE_MATCHERS.find((entry) => entry.regex.test(path));
@@ -156,9 +159,9 @@ export function driftReasonForPath(path: string): string | null {
 }
 
 function defaultSpurRunner(env: DriftProbeEnv, cwd?: string): SpurRunner {
-    const parts = (env.spurBin ?? 'spur').split(/\s+/).filter((part) => part.length > 0);
+    const { cmd, prefix } = spurCommand(env.spurBin);
     return (args: string[]): SpurShowResult => {
-        const run = spawnSync(parts[0], [...parts.slice(1), ...args], {
+        const run = spawnSync(cmd, [...prefix, ...args], {
             cwd,
             encoding: 'utf8',
             env: getEnvVars(),

package/plugins/sp/scripts/wrapup-steps.mjs

@@ -3,7 +3,7 @@
 
 // plugins/sp/scripts/wrapup-steps.ts
 import { spawnSync } from "child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 
 // plugins/sp/lib/env.ts
@@ -11,6 +11,12 @@ function getEnvVars() {
   return process.env;
 }
 
+// plugins/sp/lib/spur-bin.ts
+function spurCommand(spurBin) {
+  const parts = (spurBin ?? "spur").trim().split(/\s+/).filter((p) => p.length > 0);
+  return { cmd: parts[0] ?? "spur", prefix: parts.slice(1) };
+}
+
 // plugins/sp/scripts/wrapup-steps.ts
 function jqPick(...values) {
   for (const value of values) {
@@ -23,10 +29,6 @@ function jqText(value) {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
 var WBS_PATTERN = /^[0-9]{4}$/;
-function spurCommand(spurBin) {
-  const parts = (spurBin ?? "spur").trim().split(/\s+/).filter((p) => p.length > 0);
-  return { cmd: parts[0] ?? "spur", prefix: parts.slice(1) };
-}
 function spur(env, args, options = {}) {
   const { cmd, prefix } = spurCommand(env.spurBin);
   const result = spawnSync(cmd, [...prefix, ...args], {
@@ -172,6 +174,31 @@ function readFileSyncSafe(path) {
     return null;
   }
 }
+function verdictFromTestingSection(content) {
+  const heading = /^#{1,6}\s+Testing\s*$/m.exec(content);
+  if (!heading)
+    return null;
+  const level = heading[0].match(/^#+/)?.[0]?.length ?? 2;
+  const rest = content.slice(heading.index + heading[0].length);
+  const next = new RegExp(`^#{1,${level}}\\s+\\S`, "m").exec(rest);
+  const section = next ? rest.slice(0, next.index) : rest;
+  for (const line of section.split(`
+`)) {
+    const m = /^(?:-\s*|\*\*)?Verdict:\s*(PASS|PARTIAL|FAIL|UNKNOWN)\b/i.exec(line.trim());
+    if (m?.[1] !== undefined)
+      return m[1].toUpperCase();
+  }
+  return null;
+}
+function verdictOfArtifact(verdictPath) {
+  try {
+    const raw = jqPick(JSON.parse(readFileSync(verdictPath, "utf8")).verdict, "");
+    const text = jqText(raw);
+    return text.length > 0 ? text : null;
+  } catch {
+    return null;
+  }
+}
 function runMetrics(env, options = {}) {
   const cwd = options.cwd;
   const runId = env.__runId ?? "";
@@ -212,15 +239,13 @@ function runMetrics(env, options = {}) {
     const frontmatter = parsed.frontmatter !== null && typeof parsed.frontmatter === "object" ? parsed.frontmatter : {};
     const featureId = String(jqPick(frontmatter.feature_id, parsed.feature_id, ""));
     const status2 = String(jqPick(frontmatter.status, parsed.status, "unknown"));
-    let verdict = "UNKNOWN";
     const verdictPath = join(".spur", "run", `${wbs}-verdict.json`);
-    if (existsSync(abs(verdictPath))) {
-      try {
-        const raw = jqPick(JSON.parse(readFileSync(abs(verdictPath), "utf8")).verdict, "UNKNOWN");
-        const text = raw === "UNKNOWN" ? "UNKNOWN" : jqText(raw);
-        if (text.length > 0)
-          verdict = text;
-      } catch {}
+    const artifactVerdict = verdictOfArtifact(abs(verdictPath));
+    const trackedVerdict = verdictFromTestingSection(typeof parsed.content === "string" ? parsed.content : "");
+    const verdict = artifactVerdict ?? trackedVerdict ?? "UNKNOWN";
+    if (verdict === "UNKNOWN") {
+      process.stderr.write(`metrics-record: task ${wbs} has no certifying verdict \u2014 ${verdictPath}: ${artifactVerdict ?? "missing or carries none"}, tracked Testing: ${trackedVerdict ?? "no Verdict: line"} \u2014 recording UNKNOWN telemetry
+`);
     }
     const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
     const row = { wbs, feature_id: featureId, status: status2, verdict, timestamp };
@@ -300,32 +325,9 @@ function runFeatureTransition(env, options = {}) {
   }
   let syncOutput = "";
   let syncRc = 1;
-  const boundedTs = join("plugins", "sp", "scripts", "feature-sync-bounded.ts");
-  const boundedArgs = [feature, "--spur-bin", env.spurBin ?? "spur", "--json"];
-  if (existsSync(cwd ? join(cwd, boundedTs) : boundedTs)) {
-    const result = spawnSync("bun", [boundedTs, ...boundedArgs], { cwd, encoding: "utf8" });
-    syncOutput = result.stdout ?? "";
-    syncRc = result.status ?? 1;
-    if (result.stderr !== null && result.stderr.length > 0)
-      process.stderr.write(result.stderr);
-  } else {
-    const probe = spawnSync("superskill", ["script", "path", "sp", "feature-sync-bounded.mjs"], {
-      cwd,
-      encoding: "utf8"
-    });
-    const twin = probe.status === 0 ? (probe.stdout ?? "").trim() : "";
-    if (twin.length > 0 && existsSync(twin)) {
-      const result = spawnSync("node", [twin, ...boundedArgs], { cwd, encoding: "utf8" });
-      syncOutput = result.stdout ?? "";
-      syncRc = result.status ?? 1;
-      if (result.stderr !== null && result.stderr.length > 0)
-        process.stderr.write(result.stderr);
-    } else {
-      const result = spur(env, ["feature", "sync", feature, "--json"], { cwd, stderr: "inherit" });
-      syncOutput = result.stdout;
-      syncRc = result.status;
-    }
-  }
+  const sync = spur(env, ["feature", "sync", feature, "--json"], { cwd, stderr: "inherit" });
+  syncOutput = sync.stdout;
+  syncRc = sync.status;
   process.stdout.write(`${syncOutput}
 `);
   const shown = spur(env, ["feature", "show", feature, "--json"], { cwd });
@@ -403,8 +405,8 @@ function main(argv, env = getEnvVars(), options = {}) {
 }
 export {
   writeRouteReason,
+  verdictFromTestingSection,
   taskStatusOf,
-  spurCommand,
   runMetrics,
   runFeatureTransition,
   resolveTasks,