@gobing-ai/spur 0.3.23 → 0.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/spur",
-    "version": "0.3.23",
+    "version": "0.3.24",
     "description": "Spur CLI — local-first harness for mainstream coding agents: constraint checking, workflow orchestration, agent health, and history analytics. Bun-native; exposes the `spur` command.",
     "keywords": [
         "spur",

package/spur.js

@@ -37077,6 +37077,8 @@ var init_finding_codes = __esm(() => {
     "L2.forbidden-section",
     "L2.disallowed-section",
     "L3.requirements-format",
+    "L3.requirements-empty",
+    "L3.ac-empty",
     "L3.solution-file-line",
     "L3.review-priority-table",
     "L3.testing-coverage",
@@ -37108,7 +37110,8 @@ var init_finding_codes = __esm(() => {
     "L4.uncovered-task-scenario",
     "L4.uncovered-feature-scenario",
     "L4.verifying-incomplete-tasks",
-    "L4.dogfood-missing"
+    "L4.dogfood-missing",
+    "L4.scenario-unverified"
   ];
   FINDING_CODES = {
     L1_MARKDOWN_PARSE: "L1.markdown-parse",
@@ -37117,6 +37120,8 @@ var init_finding_codes = __esm(() => {
     L2_FORBIDDEN_SECTION: "L2.forbidden-section",
     L2_DISALLOWED_SECTION: "L2.disallowed-section",
     L3_REQUIREMENTS_FORMAT: "L3.requirements-format",
+    L3_REQUIREMENTS_EMPTY: "L3.requirements-empty",
+    L3_AC_EMPTY: "L3.ac-empty",
     L3_SOLUTION_FILE_LINE: "L3.solution-file-line",
     L3_REVIEW_PRIORITY_TABLE: "L3.review-priority-table",
     L3_TESTING_COVERAGE: "L3.testing-coverage",
@@ -37148,7 +37153,8 @@ var init_finding_codes = __esm(() => {
     L4_UNCOVERED_TASK_SCENARIO: "L4.uncovered-task-scenario",
     L4_UNCOVERED_FEATURE_SCENARIO: "L4.uncovered-feature-scenario",
     L4_VERIFYING_INCOMPLETE_TASKS: "L4.verifying-incomplete-tasks",
-    L4_DOGFOOD_MISSING: "L4.dogfood-missing"
+    L4_DOGFOOD_MISSING: "L4.dogfood-missing",
+    L4_SCENARIO_UNVERIFIED: "L4.scenario-unverified"
   };
 });
 
@@ -60050,7 +60056,7 @@ class AgentService {
     const raw = stringFlag(flags, "agent", "auto");
     if (raw === "auto")
       return this.resolveAgentAuto(prompt, flags, doctorRunner);
-    return this.resolveAgentExplicit(raw, doctorRunner, "explicit");
+    return this.resolveExecutorSelector(raw, doctorRunner, "explicit");
   }
   async resolveAgentAuto(prompt, flags, doctorRunner) {
     const config4 = this.ctx.agentConfig;
@@ -60175,16 +60181,6 @@ class AgentService {
       return usable.result;
     return { ok: true, agent: canonical, source };
   }
-  async resolveAgentExplicit(name, doctorRunner, source) {
-    const canonical = resolveAgentName(name);
-    if (canonical === undefined) {
-      return { ok: false, exitCode: 2, message: `Unknown agent: ${name}` };
-    }
-    const usable = await this.checkUsable(canonical, doctorRunner);
-    if (!usable.ok)
-      return usable.result;
-    return { ok: true, agent: canonical, source };
-  }
   async checkUsable(canonical, doctorRunner) {
     const result = await doctorRunner.runOne(canonical);
     if (!result.installed) {
@@ -61245,7 +61241,8 @@ var init_feature_check = __esm(() => {
         await this.checkChildrenLimit(featureId2, options.featuresDir, findings);
       }
       const dogfoodDir = options?.dogfoodDir ?? (options?.featuresDir ? join7(dirname8(options.featuresDir), "dogfood") : undefined);
-      await this.runL4(doc2, featureId2, status, options?.tasksDir, dogfoodDir, findings);
+      const runDir = options?.runDir ?? (options?.tasksDir ? join7(dirname8(options.tasksDir), ".spur", "run") : undefined);
+      await this.runL4(doc2, featureId2, status, options?.tasksDir, dogfoodDir, runDir, findings);
       return { id: featureId2, ...this.summarizeWithStatus(status, findings, strict, options?.severityOverrides) };
     }
     runL3(doc2, findings) {
@@ -61377,13 +61374,14 @@ var init_feature_check = __esm(() => {
         });
       }
     }
-    async runL4(doc2, featureId2, status, tasksDir, dogfoodDir, findings) {
+    async runL4(doc2, featureId2, status, tasksDir, dogfoodDir, runDir, findings) {
       if (tasksDir === undefined)
         return;
       let linkedTasks = 0;
       const incompleteTasks = [];
       const linkedTaskAc = [];
       const linkedTaskSolutions = [];
+      const linkedTaskRecords = [];
       try {
         const entries = await this.fs.readDir(tasksDir);
         for (const entry of entries) {
@@ -61398,13 +61396,15 @@ var init_feature_check = __esm(() => {
               continue;
             linkedTasks += 1;
             const tStatus = tfm.status ?? "backlog";
+            const wbs = entry.match(/^(\d{4})_/)?.[1] ?? entry;
             if (tStatus !== "done" && tStatus !== "cancelled") {
-              incompleteTasks.push(entry.match(/^(\d{4})_/)?.[1] ?? entry);
+              incompleteTasks.push(wbs);
             }
             const tac = stripAcFence(taskDoc.getSection("Acceptance Criteria") ?? "");
             if (tac.trim().length > 0)
               linkedTaskAc.push(tac);
             linkedTaskSolutions.push(taskDoc.getSection("Solution") ?? "");
+            linkedTaskRecords.push({ wbs, status: tStatus, ac: tac });
           } catch {
             findings.push({
               layer: "L4",
@@ -61446,6 +61446,7 @@ var init_feature_check = __esm(() => {
           });
         }
       }
+      await this.checkScenarioSatisfaction(acBody, linkedTaskRecords, runDir, findings);
       if (status === "verifying" && incompleteTasks.length > 0) {
         findings.push({
           layer: "L4",
@@ -61481,6 +61482,77 @@ var init_feature_check = __esm(() => {
         }
       }
     }
+    async checkScenarioSatisfaction(featureAc, linkedTasks, runDir, findings) {
+      if (linkedTasks.length === 0 || runDir === undefined)
+        return;
+      const parsed = parseFeature(featureAc);
+      if (parsed === null)
+        return;
+      if (parsed.scenarios.length === 0)
+        return;
+      const scenarioAliases = parsed.scenarios.map((s, i2) => ({
+        title: s.name,
+        normalized: normalizeTitle(s.name),
+        alias: `AC-${i2 + 1}`
+      }));
+      const covers = {};
+      for (const sc of scenarioAliases) {
+        const linked = [];
+        for (const task of linkedTasks) {
+          const taskCov = checkAcCoverage(`Feature: x
+  Scenario: ${sc.title}
+    Given x`, task.ac);
+          if (!taskCov.orphans.includes(sc.title)) {
+            linked.push({ wbs: task.wbs, status: task.status });
+          }
+        }
+        covers[sc.title] = linked;
+      }
+      for (const sc of scenarioAliases) {
+        const linked = covers[sc.title] ?? [];
+        if (linked.length === 0)
+          continue;
+        const verified = await this.isScenarioVerified(sc, linked, runDir);
+        if (!verified) {
+          findings.push({
+            layer: "L4",
+            code: FINDING_CODES.L4_SCENARIO_UNVERIFIED,
+            severity: "warning",
+            section: "Acceptance Criteria",
+            message: `Feature scenario "${sc.title}" is linked but unverified: covering task(s) ` + `${linked.map((l) => l.wbs).join(", ")} have no PASS verdict with MET requirement`
+          });
+        }
+      }
+    }
+    async isScenarioVerified(sc, linked, runDir) {
+      for (const task of linked) {
+        if (task.status !== "done")
+          continue;
+        const artifact = await this.readVerdictArtifact(runDir, task.wbs);
+        if (artifact === null)
+          continue;
+        if (artifact.verdict !== "PASS")
+          continue;
+        const matched = artifact.requirements.find((r) => normalizeTitle(r.id) === sc.normalized || normalizeTitle(r.alias ?? r.id) === sc.normalized || r.id === sc.alias);
+        if (matched !== undefined && matched.status === "MET")
+          return true;
+      }
+      return false;
+    }
+    async readVerdictArtifact(runDir, wbs) {
+      try {
+        const raw = await this.fs.readFile(join7(runDir, `${wbs}-verdict.json`));
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.verdict !== "string")
+          return null;
+        if (!Array.isArray(parsed.requirements))
+          return null;
+        const requirements = parsed.requirements.filter((r) => typeof r?.id === "string" && typeof r?.status === "string").map((r) => ({ id: r.id, status: r.status }));
+        return { verdict: parsed.verdict, requirements };
+      } catch {
+        return null;
+      }
+    }
   };
 });
 
@@ -63754,7 +63826,7 @@ var init_task_check = __esm(() => {
       this.runL3(doc2, entry, status, findings);
       const tasksDir = dirname9(filePath);
       const featuresDir = join9(dirname9(tasksDir), "features");
-      await this.runL4(doc2, fm, findings, featuresDir, tasksDir);
+      await this.runL4(doc2, fm, status, findings, featuresDir, tasksDir);
       await this.runL4Rollup(doc2, wbs, status, findings, tasksDir);
       if (status !== "done" && status !== "cancelled") {
         await this.runL4Readiness(doc2, fm, wbs, status, findings, tasksDir);
@@ -63762,6 +63834,26 @@ var init_task_check = __esm(() => {
       return { wbs, ...this.summarizeWithStatus(status, findings, strict, options?.severityOverrides) };
     }
     runL3(doc2, entry, status, findings) {
+      const reqBodyRaw = doc2.getSection("Requirements");
+      if (reqBodyRaw !== null && isPlaceholderBody(reqBodyRaw)) {
+        findings.push({
+          layer: "L3",
+          code: FINDING_CODES.L3_REQUIREMENTS_EMPTY,
+          severity: "error",
+          section: "Requirements",
+          message: "Requirements is placeholder-only \u2014 a task with no requirements is unverifiable"
+        });
+      }
+      const acBodyRaw = doc2.getSection("Acceptance Criteria");
+      if (acBodyRaw !== null && isPlaceholderBody(stripAcFence(acBodyRaw))) {
+        findings.push({
+          layer: "L3",
+          code: FINDING_CODES.L3_AC_EMPTY,
+          severity: "error",
+          section: "Acceptance Criteria",
+          message: "Acceptance Criteria is placeholder-only \u2014 populate with real scenarios"
+        });
+      }
       const reqBody = doc2.getSection("Requirements");
       if (reqBody !== null && !isPlaceholderBody(reqBody)) {
         const blocks = reqBody.trim().split(/\n\s*\n/).filter((b) => b.trim().length > 0);
@@ -63853,7 +63945,7 @@ var init_task_check = __esm(() => {
         }
       }
     }
-    async runL4(doc2, fm, findings, featuresDir, tasksDir) {
+    async runL4(doc2, fm, status, findings, featuresDir, tasksDir) {
       const template = typeof fm.template === "string" ? fm.template : DEFAULT_TASK_VARIANT;
       if (template === DEFAULT_TASK_VARIANT) {
         const designBody = doc2.getSection("Design");
@@ -63882,7 +63974,9 @@ var init_task_check = __esm(() => {
           });
         } else {
           const featureStatus = await this.readFeatureStatus(featurePath);
-          if (featureStatus === "done" || featureStatus === "cancelled") {
+          const featureTerminal = featureStatus === "done" || featureStatus === "cancelled";
+          const taskTerminal = status === "done" || status === "cancelled";
+          if (featureTerminal && !taskTerminal) {
             findings.push({
               layer: "L4",
               code: FINDING_CODES.L4_FEATURE_TERMINAL,
@@ -64586,6 +64680,26 @@ class TaskService {
     const templateBodies = this.ctx.resolveTemplateBodies?.(variant) ?? {};
     return { ...templateBodies, ...taskBodies };
   }
+  async findDuplicateFollowUp(featureId2, title, withinSec) {
+    const siblings = await this.list({ featureId: featureId2 });
+    const now = Date.now();
+    const lowerTitle = title.toLowerCase();
+    for (const t of siblings) {
+      if ((t.name ?? "").toLowerCase() !== lowerTitle)
+        continue;
+      const createdAt = t.frontmatter?.created_at;
+      if (typeof createdAt !== "string")
+        continue;
+      const createdMs = Date.parse(createdAt);
+      if (Number.isNaN(createdMs))
+        continue;
+      const ageSec = (now - createdMs) / 1000;
+      if (ageSec >= 0 && ageSec <= withinSec) {
+        return { wbs: t.wbs, name: t.name };
+      }
+    }
+    return null;
+  }
   async create(params) {
     const folder = this.ctx.tasksDir;
     let background = "";
@@ -64595,6 +64709,12 @@ class TaskService {
     const variant = params.template ?? (params.featureId !== undefined ? "feature-impl" : DEFAULT_TASK_VARIANT);
     const status = params.status ?? (params.featureId !== undefined ? "todo" : "backlog");
     return this.writeService.createAllocated(folder, async () => {
+      if (params.dedupeWithinSec !== undefined && params.featureId !== undefined) {
+        const collision = await this.findDuplicateFollowUp(params.featureId, params.title, params.dedupeWithinSec);
+        if (collision !== null) {
+          throw new DuplicateFollowUpError(collision.wbs, collision.name, params.title);
+        }
+      }
       const wbs = await this.allocateWbs();
       const slug = this.slugify(params.title);
       const filePath = this.resolveTaskPath(wbs, slug);
@@ -65223,7 +65343,7 @@ ${block}` : block);
     return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
   }
 }
-var DependencyMutationError, SectionMutationError, ROSTER_START = "<!-- AUTO-GENERATED by spur task refresh-roster -->", ROSTER_END = "<!-- END AUTO-GENERATED -->", ROSTER_REGION_RE, TASK_ACTION_COMMANDS, DEFAULT_CREATION_SECTIONS;
+var DependencyMutationError, SectionMutationError, DuplicateFollowUpError, ROSTER_START = "<!-- AUTO-GENERATED by spur task refresh-roster -->", ROSTER_END = "<!-- END AUTO-GENERATED -->", ROSTER_REGION_RE, TASK_ACTION_COMMANDS, DEFAULT_CREATION_SECTIONS;
 var init_task_service = __esm(() => {
   init_src2();
   init_task_locator();
@@ -65244,6 +65364,18 @@ var init_task_service = __esm(() => {
       this.code = code;
     }
   };
+  DuplicateFollowUpError = class DuplicateFollowUpError extends Error {
+    existingWbs;
+    existingName;
+    attemptedName;
+    constructor(existingWbs, existingName, attemptedName) {
+      super(`duplicate-follow-up: task ${existingWbs} ("${existingName}") already exists under this feature ` + `with an identical name. Reuse ${existingWbs} or pass --allow-duplicate-name to override.`);
+      this.name = "DuplicateFollowUpError";
+      this.existingWbs = existingWbs;
+      this.existingName = existingName;
+      this.attemptedName = attemptedName;
+    }
+  };
   ROSTER_REGION_RE = /<!--[ \t]*AUTO-GENERATED[^>]*-->[\s\S]*?<!--[ \t]*END[ \t]*AUTO-GENERATED[^>]*-->/g;
   TASK_ACTION_COMMANDS = {
     refine: (wbs) => `/sp:dev-refine ${wbs} --auto`,
@@ -65446,6 +65578,50 @@ function extractChecks(_text, taskCheckPassed, acceptanceCriteria) {
   }
   return checks4;
 }
+function classifyTaskOutcome(taskStatus, verdict) {
+  const status = String(taskStatus).toLowerCase();
+  if (NOT_STARTED_STATUSES[status]) {
+    return "NOT-STARTED";
+  }
+  const v = String(verdict ?? "UNKNOWN").toUpperCase();
+  if (v === "PASS" || v === "PARTIAL" || v === "FAIL")
+    return v;
+  return "UNKNOWN";
+}
+function aggregateBatchVerdicts(results) {
+  const notStarted = results.filter((r) => r.outcome === "NOT-STARTED");
+  const rolledUp = results.filter((r) => r.outcome !== "NOT-STARTED");
+  const counts = {
+    PASS: rolledUp.filter((r) => r.outcome === "PASS").length,
+    PARTIAL: rolledUp.filter((r) => r.outcome === "PARTIAL").length,
+    FAIL: rolledUp.filter((r) => r.outcome === "FAIL").length,
+    UNKNOWN: rolledUp.filter((r) => r.outcome === "UNKNOWN").length
+  };
+  let verdict;
+  if (rolledUp.length === 0) {
+    verdict = "UNKNOWN";
+  } else if (counts.FAIL > 0) {
+    verdict = "FAIL";
+  } else if (counts.PARTIAL > 0 || counts.UNKNOWN > 0) {
+    verdict = "PARTIAL";
+  } else {
+    verdict = "PASS";
+  }
+  const summary = `${counts.PASS} PASS, ${counts.PARTIAL} PARTIAL, ${counts.FAIL} FAIL, ${notStarted.length} NOT-STARTED (excluded)`;
+  return { verdict, rolledUp, notStarted, summary };
+}
+var NOT_STARTED_STATUSES;
+var init_task_verdict = __esm(() => {
+  NOT_STARTED_STATUSES = {
+    backlog: true,
+    todo: true,
+    wip: false,
+    testing: false,
+    blocked: true,
+    done: false,
+    cancelled: false
+  };
+});
 
 // ../../packages/app/src/services/team-service.ts
 import { join as join10 } from "path";
@@ -67538,8 +67714,10 @@ __export(exports_src2, {
   deriveVerdict: () => deriveVerdict,
   createPsProcessInspector: () => createPsProcessInspector,
   computeAggregate: () => computeAggregate,
+  classifyTaskOutcome: () => classifyTaskOutcome,
   clampToolUseLimit: () => clampToolUseLimit,
   bridgeEventBus: () => bridgeEventBus,
+  aggregateBatchVerdicts: () => aggregateBatchVerdicts,
   WorkflowAppService: () => WorkflowAppService,
   UnsupportedProcessPlatformError: () => UnsupportedProcessPlatformError,
   TokenLedgerWatcher: () => TokenLedgerWatcher,
@@ -67588,6 +67766,7 @@ __export(exports_src2, {
   FeatureCheckService: () => FeatureCheckService,
   FINDING_CODES: () => FINDING_CODES,
   FEATURE_LIFECYCLE_PROFILE: () => FEATURE_LIFECYCLE_PROFILE,
+  DuplicateFollowUpError: () => DuplicateFollowUpError,
   DependencyMutationError: () => DependencyMutationError,
   DEFAULT_FEATURE_MATRIX: () => DEFAULT_FEATURE_MATRIX,
   CorpusMigrator: () => CorpusMigrator,
@@ -67619,6 +67798,7 @@ var init_src3 = __esm(() => {
   init_task_record();
   init_task_scaffold();
   init_task_service();
+  init_task_verdict();
   init_team_service();
   init_token_ledger_service();
   init_token_ledger_watcher();
@@ -75628,7 +75808,7 @@ import { join as join15, resolve as resolve4 } from "path";
 var CLI_CONFIG = {
   binaryName: "spur",
   binaryLabel: "spur",
-  binaryVersion: "0.3.23",
+  binaryVersion: "0.3.24",
   configDir: ".spur",
   configFile: ".spur/config.yaml",
   databaseFile: ".spur/spur.db"
@@ -86201,7 +86381,7 @@ function renderMigrationReport(report, dryRun, corpusDir) {
 }
 function registerTaskCommand(program2, context4) {
   const task = program2.command("task").summary("manage tasks");
-  task.command("create").summary("Create a new task with race-safe WBS allocation.").argument("<title>", "Task title").option("--feature <id>", "Feature ID for traceability and Goal\u2192Background derivation").option("--parent <wbs>", "Parent WBS for sub-task grouping").option("--template <variant>", `Template variant (${TASK_VARIANTS.join("|")})`).option("--folder <path>", "Custom tasks folder").option("--json", "Output machine-readable JSON").action(async (title2, options) => {
+  task.command("create").summary("Create a new task with race-safe WBS allocation.").argument("<title>", "Task title").option("--feature <id>", "Feature ID for traceability and Goal\u2192Background derivation").option("--parent <wbs>", "Parent WBS for sub-task grouping").option("--template <variant>", `Template variant (${TASK_VARIANTS.join("|")})`).option("--folder <path>", "Custom tasks folder").option("--dedupe-within <seconds>", "Refuse creation if an existing task under the same feature has an identical name created within the last N seconds (task 0341 R4)", (v) => Number.parseInt(v, 10)).option("--allow-duplicate-name", "Override the --dedupe-within guard (creates anyway)").option("--json", "Output machine-readable JSON").action(async (title2, options) => {
     if (options.template !== undefined && !TASK_VARIANTS.includes(options.template)) {
       context4.output.error(`Unknown template variant "${options.template}". Valid: ${TASK_VARIANTS.join(", ")}`);
       context4.setExitCode(2);
@@ -86213,7 +86393,8 @@ function registerTaskCommand(program2, context4) {
         title: title2,
         featureId: options.feature,
         parentWbs: options.parent,
-        template: options.template
+        template: options.template,
+        dedupeWithinSec: options.allowDuplicateName ? undefined : options.dedupeWithin
       });
       if (options.json) {
         context4.output.write(toJson2(result));
@@ -86221,8 +86402,13 @@ function registerTaskCommand(program2, context4) {
         context4.output.write(`Created task ${result.ref.id}: ${result.ref.filePath}`);
       }
     } catch (err) {
-      context4.output.error(String(err));
-      context4.setExitCode(1);
+      if (err instanceof DuplicateFollowUpError) {
+        context4.output.error(err.message);
+        context4.setExitCode(3);
+      } else {
+        context4.output.error(String(err));
+        context4.setExitCode(1);
+      }
     }
   });
   task.command("show").summary("Show a task by WBS.").argument("<wbs>", "Task WBS number").option("--folder <path>", "Custom tasks folder").option("--json", "Output machine-readable JSON").action(async (wbs, options) => {
@@ -86605,6 +86791,53 @@ ${result.content}`);
       context4.setExitCode(1);
     }
   });
+  task.command("verifyall-aggregate").summary("Aggregate per-task verify outcomes into a deterministic batch verdict (verifyall).").description("Reads a JSON array of per-task outcomes ({wbs,outcome}) and emits the batch " + "verdict with NOT-STARTED tasks excluded from the rollup. Replaces agent-discretion " + "rollup prose (dev-operations.md \xA73a) with deterministic code (task 0341).").option("--from-file <path>", "Path to JSON array of {wbs,outcome[,reason]} rows").option("--json", "Output machine-readable JSON").action(async (options) => {
+    const inputPath = options.fromFile ?? ".spur/run/verifyall-batch-input.json";
+    let raw2;
+    try {
+      raw2 = readFileSync8(inputPath, "utf-8");
+    } catch {
+      context4.output.error(`Batch input file not found: ${inputPath}`);
+      context4.setExitCode(1);
+      return;
+    }
+    let rows;
+    try {
+      const parsed = JSON.parse(raw2);
+      if (!Array.isArray(parsed)) {
+        throw new Error("expected a JSON array");
+      }
+      rows = parsed;
+    } catch (err) {
+      context4.output.error(`Invalid batch input JSON: ${String(err)}`);
+      context4.setExitCode(1);
+      return;
+    }
+    const results = rows.map((r2) => {
+      const outcome = r2.outcome.toUpperCase();
+      if (!["PASS", "PARTIAL", "FAIL", "NOT-STARTED", "UNKNOWN"].includes(outcome)) {
+        throw new Error(`Invalid outcome for ${r2.wbs}: ${r2.outcome}`);
+      }
+      return {
+        wbs: r2.wbs,
+        outcome,
+        reason: r2.reason
+      };
+    });
+    const aggregation = aggregateBatchVerdicts(results);
+    if (options.json) {
+      context4.output.write(JSON.stringify(aggregation, null, 2));
+    } else {
+      context4.output.write(`Batch verdict: ${aggregation.verdict}`);
+      context4.output.write(aggregation.summary);
+      if (aggregation.notStarted.length > 0) {
+        context4.output.write(`NOT-STARTED (excluded from rollup): ${aggregation.notStarted.map((r2) => r2.wbs).join(", ")}`);
+      }
+    }
+    if (aggregation.verdict === "FAIL") {
+      context4.setExitCode(1);
+    }
+  });
   task.command("check").summary("Validate a task file through the four-layer check (design \xA73).").argument("[wbs]", "Task WBS number (validates all tasks in the folder when omitted)").option("--strict", "Elevate ALL warnings to failures").option("--strict-core", "Gate variant: fail only on hard-core errors (the testing\u2192done guard)").option("--folder <path>", "Custom tasks folder").option("--json", "Output machine-readable JSON").action(async (wbs, options) => {
     const svc = await makeCheckService(context4);
     const json3 = options.json === true;