cclaw-cli 7.4.0 → 7.6.0

package/dist/artifact-linter/plan.js

@@ -1,13 +1,19 @@
-import { evaluateInvestigationTrace, evaluateLayeredDocumentReviewStatus, extractAuthoredBody, headingPresent, sectionBodyByName, collectPatternHits, PLACEHOLDER_PATTERNS, extractDecisionIds, SCOPE_REDUCTION_PATTERNS } from "./shared.js";
+import { evaluateInvestigationTrace, evaluateLayeredDocumentReviewStatus, extractAcceptanceCriterionIdsFromMarkdown, extractAuthoredBody, extractH2Sections, headingPresent, sectionBodyByName, collectPatternHits, PLACEHOLDER_PATTERNS, extractDecisionIds, SCOPE_REDUCTION_PATTERNS } from "./shared.js";
 import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
 import { exists } from "../fs-utils.js";
 import { FORBIDDEN_PLACEHOLDER_TOKENS, CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits, parseImplementationUnitParallelFields } from "../internal/plan-split-waves.js";
+import { compareSliceIds, parseSliceId } from "../util/slice-id.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { loadStackAdapter } from "../stack-detection.js";
+const execFileAsync = promisify(execFile);
 const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
 const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
 const TASK_ID_PATTERN = /\bT-\d{3}[a-z]?(?:\.\d{1,3})?\b/giu;
+const ACCEPTANCE_ID_PATTERN = /\bAC-\d+\b/giu;
 const PLAN_LANE_WHITELIST = new Set([
     "production",
     "test",
@@ -30,6 +36,21 @@ function extractTaskIds(body) {
     }
     return ids;
 }
+function extractAcceptanceTaskLinks(body) {
+    const links = [];
+    for (const line of body.split(/\r?\n/u)) {
+        const acIds = [...line.matchAll(ACCEPTANCE_ID_PATTERN)].map((match) => match[0].toUpperCase());
+        const taskIds = [...line.matchAll(TASK_ID_PATTERN)].map((match) => match[0]);
+        if (acIds.length === 0 || taskIds.length === 0)
+            continue;
+        for (const acId of acIds) {
+            for (const taskId of taskIds) {
+                links.push({ acId, taskId });
+            }
+        }
+    }
+    return links;
+}
 /**
  * Return the body between the parallel-exec managed comment markers, or
  * an empty string if the block is absent. The TDD wave parser uses the
@@ -104,13 +125,15 @@ function parseParallelWaveTableMetadata(planMarkdown) {
             continue;
         }
         const sliceCell = cells[0];
-        if (!/^S-\d+$/iu.test(sliceCell))
+        const parsedSlice = parseSliceId(sliceCell);
+        if (!parsedSlice)
             continue;
         const idx = headerIdx ?? new Map();
         const unitIdx = idx.get("unit") ?? idx.get("taskid") ?? 1;
         const pathsIdx = idx.get("claimedpaths");
         const parallelizableIdx = idx.get("parallelizable");
         const laneIdx = idx.get("lane");
+        const dependsOnIdx = idx.get("dependson");
         const rawPaths = pathsIdx !== undefined ? (cells[pathsIdx] ?? "") : "";
         const claimedPaths = rawPaths.length === 0
             ? []
@@ -125,12 +148,22 @@ function parseParallelWaveTableMetadata(planMarkdown) {
         if (rawParallel === "false" || rawParallel === "no")
             parallelizable = false;
         const laneRaw = laneIdx !== undefined ? (cells[laneIdx] ?? "").trim().toLowerCase() : "";
+        const rawDeps = dependsOnIdx !== undefined ? (cells[dependsOnIdx] ?? "") : "";
+        const dependsOn = rawDeps.length === 0
+            ? []
+            : rawDeps
+                .replace(/^\[|\]$/gu, "")
+                .split(/[,\s]+/u)
+                .map((token) => token.trim().replace(/^`|`$/gu, ""))
+                .map((token) => parseSliceId(token)?.id ?? "")
+                .filter((id) => id.length > 0);
         current.rows.push({
-            sliceId: sliceCell.toUpperCase(),
+            sliceId: parsedSlice.id,
             unit: (cells[unitIdx] ?? "").trim(),
             claimedPaths,
             parallelizable,
-            lane: laneRaw.length > 0 ? laneRaw : null
+            lane: laneRaw.length > 0 ? laneRaw : null,
+            dependsOn
         });
     }
     flush();
@@ -140,6 +173,65 @@ function waveHasSequentialModeHint(wave) {
     const noteText = wave.notes.join("\n").toLowerCase();
     return /mode\s*:\s*sequential/iu.test(noteText) || /\bsequential\b/iu.test(noteText) || /\bserial\b/iu.test(noteText);
 }
+/**
+ * Capture the set of repo-relative paths tracked at HEAD. Returns an
+ * empty set when the project root is not a git repo or `git ls-files`
+ * fails — the wiring linter degrades to "no aggregator required" in
+ * that case rather than crashing the whole stage check.
+ */
+async function readHeadFiles(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["ls-files", "-z"], { cwd: projectRoot, maxBuffer: 64 * 1024 * 1024 });
+        const out = new Set();
+        for (const segment of stdout.split("\u0000")) {
+            const trimmed = segment.trim();
+            if (trimmed.length === 0)
+                continue;
+            out.add(trimmed.replace(/\\/gu, "/"));
+        }
+        return out;
+    }
+    catch {
+        return new Set();
+    }
+}
+function buildSliceClaimGraph(waves) {
+    const bySliceId = new Map();
+    for (const wave of waves) {
+        for (const row of wave.rows) {
+            bySliceId.set(row.sliceId, row);
+        }
+    }
+    return { bySliceId };
+}
+/**
+ * Walk the dependsOn graph from `sliceId` and return the set of
+ * predecessor slice ids (transitive). Skips ids that aren't in the
+ * graph and handles cycles via a `visiting` set so a malformed plan
+ * doesn't lock the linter.
+ */
+function transitivePredecessors(sliceId, graph) {
+    const out = new Set();
+    const stack = [sliceId];
+    const visiting = new Set();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (visiting.has(current))
+            continue;
+        visiting.add(current);
+        const row = graph.bySliceId.get(current);
+        if (!row)
+            continue;
+        for (const predecessor of row.dependsOn) {
+            const normalized = parseSliceId(predecessor)?.id ?? predecessor;
+            if (out.has(normalized))
+                continue;
+            out.add(normalized);
+            stack.push(normalized);
+        }
+    }
+    return out;
+}
 export async function lintPlanStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     evaluateInvestigationTrace(ctx, "Implementation Units");
@@ -190,6 +282,59 @@ export async function lintPlanStage(ctx) {
                 ? "No scope-reduction phrases detected in Task List."
                 : `Detected scope-reduction phrase(s) in Task List: ${reductionHits.join(", ")}.`
     });
+    const authoredTaskIds = extractTaskIds(taskListBody);
+    const acceptanceMappingBody = sectionBodyByName(sections, "Acceptance Mapping") ?? "";
+    const acTaskLinks = [
+        ...extractAcceptanceTaskLinks(taskListBody),
+        ...extractAcceptanceTaskLinks(acceptanceMappingBody)
+    ];
+    const mappedTaskToAcs = new Map();
+    const mappedAcToTasks = new Map();
+    for (const link of acTaskLinks) {
+        const taskSet = mappedTaskToAcs.get(link.taskId) ?? new Set();
+        taskSet.add(link.acId);
+        mappedTaskToAcs.set(link.taskId, taskSet);
+        const acSet = mappedAcToTasks.get(link.acId) ?? new Set();
+        acSet.add(link.taskId);
+        mappedAcToTasks.set(link.acId, acSet);
+    }
+    const tasksMissingAc = [...authoredTaskIds].filter((taskId) => !mappedTaskToAcs.has(taskId));
+    let specAcIds = [];
+    const specArtifact = await resolveStageArtifactPath("spec", {
+        projectRoot,
+        track,
+        intent: "read"
+    });
+    if (await exists(specArtifact.absPath)) {
+        try {
+            const specRaw = await fs.readFile(specArtifact.absPath, "utf8");
+            const specSections = extractH2Sections(specRaw);
+            const acceptanceBody = sectionBodyByName(specSections, "Acceptance Criteria") ?? specRaw;
+            specAcIds = extractAcceptanceCriterionIdsFromMarkdown(acceptanceBody);
+        }
+        catch {
+            specAcIds = [];
+        }
+    }
+    const acsMissingTask = specAcIds.filter((acId) => !mappedAcToTasks.has(acId));
+    const mappingFound = authoredTaskIds.size > 0 &&
+        tasksMissingAc.length === 0 &&
+        acsMissingTask.length === 0;
+    findings.push({
+        section: "plan_acceptance_mapped",
+        required: authoredTaskIds.size > 0,
+        rule: "Every T-NNN task must reference >=1 AC-N, and every AC-N from spec must be referenced by >=1 plan task.",
+        found: mappingFound,
+        details: authoredTaskIds.size === 0
+            ? "Task List has no T-NNN ids; acceptance mapping check skipped."
+            : tasksMissingAc.length > 0
+                ? `Task(s) missing AC mapping: ${tasksMissingAc.join(", ")}. Add AC-N references in Task List or Acceptance Mapping.`
+                : acsMissingTask.length > 0
+                    ? `Spec AC(s) missing task coverage: ${acsMissingTask.join(", ")}.`
+                    : specAcIds.length === 0
+                        ? `Mapped ${authoredTaskIds.size} task(s) to AC ids; spec artifact AC list is empty or unavailable.`
+                        : `Mapped ${authoredTaskIds.size} task(s) across ${specAcIds.length} spec AC(s).`
+    });
     // Universal Layer 2.5 structural checks (superpowers writing-plans + ce-plan).
     // Plan-wide placeholder scan (broader than Task List) using the
     // FORBIDDEN_PLACEHOLDER_TOKENS list shared with the cross-cutting block.
@@ -531,7 +676,7 @@ export async function lintPlanStage(ctx) {
                 : `Serial slice(s) found without sequential wave mode hints in: ${inconsistentParallelizable.join(", ")}. Add a wave mode/note indicating sequential execution.`
         });
         const mermaidBlocks = raw.match(/```mermaid[\s\S]*?```/giu) ?? [];
-        const hasParallelExecMermaid = mermaidBlocks.some((block) => /(flowchart|gantt)/iu.test(block) && /\bW-\d+\b/iu.test(block) && /\bS-\d+\b/iu.test(block));
+        const hasParallelExecMermaid = mermaidBlocks.some((block) => /(flowchart|gantt)/iu.test(block) && /\bW-\d+\b/iu.test(block) && /\bS-\d+(?:[a-z][a-z0-9]*)?\b/iu.test(block));
         findings.push({
             section: "plan_parallel_exec_mermaid_present",
             required: false,
@@ -541,5 +686,68 @@ export async function lintPlanStage(ctx) {
                 ? "Mermaid visualization for parallel execution waves is present."
                 : "No mermaid parallel-execution visualization found (advisory). Add a ` ```mermaid ` flowchart or gantt with W-* and S-* nodes."
         });
+        // 7.6.0 — plan_module_introducing_slice_wires_root.
+        // Stack-aware: stack-adapter exposes a `wiringAggregator` contract
+        // for stacks where introducing a new module file requires a
+        // sibling aggregator update (Rust lib.rs, Python __init__.py,
+        // optional Node-TS index.ts). For each NEW path in a slice's
+        // claim, if the adapter says an aggregator is required, the
+        // aggregator path must appear in the slice's own claim or in any
+        // transitive predecessor's claim within the same flow.
+        //
+        // For unknown stacks (Go, Java, Ruby, Swift, .NET, Elixir, …)
+        // the adapter returns `wiringAggregator: undefined`, so this
+        // gate is a no-op and `found: true`.
+        const stackAdapter = await loadStackAdapter(projectRoot);
+        const headFiles = await readHeadFiles(projectRoot);
+        const wiringIssues = [];
+        if (stackAdapter.wiringAggregator) {
+            const claimGraph = buildSliceClaimGraph(waveMeta);
+            for (const wave of waveMeta) {
+                for (const row of [...wave.rows].sort((a, b) => compareSliceIds(a.sliceId, b.sliceId))) {
+                    const predecessors = transitivePredecessors(row.sliceId, claimGraph);
+                    const predecessorClaims = new Set();
+                    for (const predId of predecessors) {
+                        const predRow = claimGraph.bySliceId.get(predId);
+                        if (!predRow)
+                            continue;
+                        for (const claim of predRow.claimedPaths) {
+                            predecessorClaims.add(normalizePathToken(claim));
+                        }
+                    }
+                    const ownClaims = new Set(row.claimedPaths.map(normalizePathToken));
+                    for (const rawClaim of row.claimedPaths) {
+                        const claim = normalizePathToken(rawClaim);
+                        if (claim.length === 0)
+                            continue;
+                        // Only NEW paths (not present at HEAD) require an
+                        // aggregator update — existing modules are already wired.
+                        if (headFiles.size > 0 && headFiles.has(claim))
+                            continue;
+                        const required = stackAdapter.wiringAggregator.resolveAggregatorFor(claim, { headFiles });
+                        if (!required)
+                            continue;
+                        const aggregatorPath = normalizePathToken(required);
+                        if (ownClaims.has(aggregatorPath))
+                            continue;
+                        if (predecessorClaims.has(aggregatorPath))
+                            continue;
+                        wiringIssues.push(`${wave.waveId}/${row.sliceId} introduces ${claim} but wiring aggregator ${aggregatorPath} is not in its claim or any predecessor's claim`);
+                    }
+                }
+            }
+        }
+        const wiringApplies = stackAdapter.wiringAggregator !== undefined;
+        findings.push({
+            section: "plan_module_introducing_slice_wires_root",
+            required: taskListPresent && wiringApplies,
+            rule: "When a slice introduces a new module file, the stack-adapter's wiring aggregator (e.g. Rust `lib.rs`, Python `__init__.py`, Node-TS barrel `index.*` when present) must be in the same slice's claim or in a transitive predecessor's claim, otherwise the new module is dead code and RED can't be expressed.",
+            found: !wiringApplies || wiringIssues.length === 0,
+            details: !wiringApplies
+                ? `Stack adapter (id=${stackAdapter.id}) does not declare a wiring aggregator; gate is a no-op for this stack.`
+                : wiringIssues.length === 0
+                    ? `Stack adapter (id=${stackAdapter.id}) wiring aggregator coverage verified across all wave slices.`
+                    : `Wiring aggregator coverage gaps: ${wiringIssues.slice(0, 12).join(" | ")}${wiringIssues.length > 12 ? ` | … (${wiringIssues.length - 12} more)` : ""}.`
+        });
     }
 }

package/dist/artifact-linter/shared.d.ts

@@ -560,6 +560,7 @@ export declare const SCOPE_REDUCTION_PATTERNS: Array<{
 export declare function parseFrontmatter(markdown: string): ParsedFrontmatter;
 export declare function extractDecisionIds(text: string): string[];
 export declare function extractRequirementIdsFromMarkdown(text: string): string[];
+export declare function extractAcceptanceCriterionIdsFromMarkdown(text: string): string[];
 export declare function collectPatternHits(text: string, patterns: Array<{
     label: string;
     regex: RegExp;

package/dist/artifact-linter/shared.js

@@ -2002,6 +2002,11 @@ export function extractRequirementIdsFromMarkdown(text) {
     const ids = text.match(/\bR\d+\b/gu) ?? [];
     return [...new Set(ids)];
 }
+export function extractAcceptanceCriterionIdsFromMarkdown(text) {
+    const ids = text.match(/\bAC-\d+\b/giu) ?? [];
+    const normalized = ids.map((id) => id.toUpperCase());
+    return [...new Set(normalized)];
+}
 // Cross-stage decision traceability uses stable D-XX IDs which the
 // agent can edit safely without recomputing content hashes.
 export function collectPatternHits(text, patterns) {

package/dist/artifact-linter/ship.js

@@ -1,5 +1,121 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
 import { readDelegationLedger } from "../delegation.js";
-import { sectionBodyByName } from "./shared.js";
+import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
+import { exists } from "../fs-utils.js";
+import { extractAcceptanceCriterionIdsFromMarkdown, extractH2Sections, sectionBodyByName } from "./shared.js";
+import { readFlowState } from "../run-persistence.js";
+const execFileAsync = promisify(execFile);
+function extractSliceCardClosedAcceptanceCriteria(content) {
+    const ids = new Set();
+    for (const match of content.matchAll(/^\s*(?:[-*]\s*)?closes\s*:\s*(.+)$/gimu)) {
+        const tail = match[1] ?? "";
+        for (const id of extractAcceptanceCriterionIdsFromMarkdown(tail)) {
+            ids.add(id);
+        }
+    }
+    return [...ids];
+}
+function escapeForRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function entryTimestamp(entry) {
+    return entry.startTs ?? entry.ts ?? entry.launchedTs ?? entry.ackTs ?? entry.completedTs ?? entry.endTs ?? "";
+}
+async function readSpecAcceptanceCriteriaIds(projectRoot, track) {
+    const specArtifact = await resolveStageArtifactPath("spec", {
+        projectRoot,
+        track,
+        intent: "read"
+    });
+    if (!(await exists(specArtifact.absPath))) {
+        return [];
+    }
+    try {
+        const specRaw = await fs.readFile(specArtifact.absPath, "utf8");
+        const sections = extractH2Sections(specRaw);
+        const acceptanceBody = sectionBodyByName(sections, "Acceptance Criteria") ?? specRaw;
+        return extractAcceptanceCriterionIdsFromMarkdown(acceptanceBody);
+    }
+    catch {
+        return [];
+    }
+}
+async function collectAcceptanceSlicesMap(tddSlicesDir) {
+    const map = new Map();
+    let names = [];
+    try {
+        names = await fs.readdir(tddSlicesDir);
+    }
+    catch {
+        return map;
+    }
+    for (const name of names) {
+        const match = /^(S-[A-Za-z0-9._-]+)\.md$/u.exec(name);
+        if (!match)
+            continue;
+        const sliceId = match[1];
+        let content = "";
+        try {
+            content = await fs.readFile(path.join(tddSlicesDir, name), "utf8");
+        }
+        catch {
+            continue;
+        }
+        const acIds = extractSliceCardClosedAcceptanceCriteria(content);
+        for (const acId of acIds) {
+            const set = map.get(acId) ?? new Set();
+            set.add(sliceId);
+            map.set(acId, set);
+        }
+    }
+    return map;
+}
+async function sliceHasManagedCommit(projectRoot, sliceId, sinceTs) {
+    const grepPattern = `^${escapeForRegex(sliceId)}/`;
+    const args = ["log", "--extended-regexp", "--grep", grepPattern, "--pretty=%H"];
+    if (sinceTs && sinceTs.length > 0) {
+        args.push(`--since=${sinceTs}`);
+    }
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd: projectRoot });
+        return stdout.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveActiveRunStartTs(projectRoot, runId) {
+    const ledger = await readDelegationLedger(projectRoot).catch(() => null);
+    const runRows = ledger
+        ? ledger.entries.filter((entry) => entry.runId === runId)
+        : [];
+    const stamps = runRows
+        .map((entry) => entryTimestamp(entry))
+        .filter((value) => typeof value === "string" && value.length > 0)
+        .sort();
+    if (stamps.length > 0) {
+        return stamps[0];
+    }
+    try {
+        const state = await readFlowState(projectRoot);
+        if (state.activeRunId === runId) {
+            const completed = Object.values(state.completedStageMeta ?? {})
+                .map((meta) => meta?.completedAt)
+                .filter((value) => typeof value === "string" && value.length > 0)
+                .sort();
+            if (completed.length > 0) {
+                return completed[0];
+            }
+        }
+    }
+    catch {
+        // no-op fallback
+    }
+    return null;
+}
 export async function lintShipStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     // Universal Layer 2.8 structural checks (superpowers finishing-a-development-branch).
@@ -79,4 +195,56 @@ export async function lintShipStage(ctx) {
             ? "Architect cross-stage verification reported DRIFT_DETECTED; ship must not proceed."
             : "No DRIFT_DETECTED signal found in ship artifact or architect delegation evidence."
     });
+    const specAcceptanceIds = await readSpecAcceptanceCriteriaIds(projectRoot, track);
+    const tddSlicesDir = path.join(path.dirname(absFile), "tdd-slices");
+    const acceptanceSlices = await collectAcceptanceSlicesMap(tddSlicesDir);
+    const gitPresent = await exists(path.join(projectRoot, ".git"));
+    const runStartTs = gitPresent
+        ? await resolveActiveRunStartTs(projectRoot, delegationLedger.runId)
+        : null;
+    const uncoveredCriteria = [];
+    if (specAcceptanceIds.length > 0 && gitPresent && runStartTs !== null) {
+        for (const acId of specAcceptanceIds) {
+            const slices = [...(acceptanceSlices.get(acId) ?? new Set())];
+            let covered = false;
+            if (slices.length > 0) {
+                for (const sliceId of slices) {
+                    if (await sliceHasManagedCommit(projectRoot, sliceId, runStartTs)) {
+                        covered = true;
+                        break;
+                    }
+                }
+            }
+            if (!covered) {
+                const reason = slices.length === 0
+                    ? `${acId} has no \`Closes: ${acId}\` slice mapping`
+                    : `${acId} mapped slices ${slices.join(", ")} have no managed commit since run start`;
+                uncoveredCriteria.push(reason);
+                findings.push({
+                    section: `acceptance_criterion_${acId}_uncovered`,
+                    required: true,
+                    rule: "Every acceptance criterion must map to at least one slice card and at least one managed slice commit.",
+                    found: false,
+                    details: reason
+                });
+            }
+        }
+    }
+    const allAcceptanceCovered = specAcceptanceIds.length === 0 ||
+        ((!gitPresent || runStartTs !== null) && uncoveredCriteria.length === 0);
+    findings.push({
+        section: "ship_all_acceptance_criteria_have_commits",
+        required: true,
+        rule: "For every spec AC-N, at least one `tdd-slices/S-*.md` card must declare `Closes: AC-N` and at least one managed slice commit (`^S-<id>/`) must exist since run start.",
+        found: allAcceptanceCovered,
+        details: specAcceptanceIds.length === 0
+            ? "Spec acceptance criteria list is empty or unreadable; AC commit coverage check is idle."
+            : !gitPresent
+                ? "No .git directory detected; AC-to-commit coverage check is skipped for no-VCS mode."
+                : runStartTs === null
+                    ? "Unable to resolve active run start timestamp from delegation ledger/flow-state."
+                    : uncoveredCriteria.length > 0
+                        ? `Uncovered acceptance criteria: ${uncoveredCriteria.join(" | ")}.`
+                        : `All ${specAcceptanceIds.length} acceptance criteria map to slice cards and managed commits since ${runStartTs}.`
+    });
 }

package/dist/artifact-linter/spec.js

@@ -1,4 +1,4 @@
-import { evaluateLayeredDocumentReviewStatus, sectionBodyByName, SPEC_MAX_MODULES } from "./shared.js";
+import { getMarkdownTableRows, evaluateLayeredDocumentReviewStatus, extractAcceptanceCriterionIdsFromMarkdown, sectionBodyByName, SPEC_MAX_MODULES } from "./shared.js";
 import { CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
 export async function lintSpecStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
@@ -128,6 +128,38 @@ export async function lintSpecStage(ctx) {
         });
     }
     const acceptanceCriteriaBody = sectionBodyByName(sections, "Acceptance Criteria");
+    if (acceptanceCriteriaBody === null) {
+        findings.push({
+            section: "spec_ac_ids_present",
+            required: true,
+            rule: "Acceptance Criteria must assign stable IDs in `AC-N` format for every criterion row.",
+            found: false,
+            details: "No ## heading matching required section \"Acceptance Criteria\"."
+        });
+    }
+    else {
+        const tableRows = getMarkdownTableRows(acceptanceCriteriaBody);
+        const bulletRows = acceptanceCriteriaBody
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => /^[-*]\s+/u.test(line));
+        const candidateRows = tableRows.length > 0
+            ? tableRows.map((row) => row.join(" | ").trim()).filter((row) => row.length > 0)
+            : bulletRows;
+        const missingIds = candidateRows.filter((row) => extractAcceptanceCriterionIdsFromMarkdown(row).length === 0);
+        const found = candidateRows.length > 0 && missingIds.length === 0;
+        findings.push({
+            section: "spec_ac_ids_present",
+            required: true,
+            rule: "Acceptance Criteria must assign stable IDs in `AC-N` format for every criterion row.",
+            found,
+            details: candidateRows.length === 0
+                ? "Acceptance Criteria has no populated criterion rows."
+                : missingIds.length === 0
+                    ? `All ${candidateRows.length} acceptance criterion row(s) include AC-N identifiers.`
+                    : `${missingIds.length} acceptance criterion row(s) are missing AC-N identifiers.`
+        });
+    }
     if (acceptanceCriteriaBody !== null && /\|/u.test(acceptanceCriteriaBody)) {
         const hasParallel = /\bparallelSafe\b/iu.test(acceptanceCriteriaBody);
         const hasTouch = /\btouchSurface\b/iu.test(acceptanceCriteriaBody);

package/dist/artifact-linter/tdd.d.ts

@@ -23,6 +23,11 @@ interface SliceFileInfo {
     sliceId: string;
     absPath: string;
 }
+interface SliceNoOrphanChangesResult {
+    ok: boolean;
+    details: string;
+}
+export declare function evaluateSliceNoOrphanChanges(projectRoot: string, rows: DelegationEntry[]): Promise<SliceNoOrphanChangesResult>;
 interface ParsedSliceCycleResult {
     ok: boolean;
     details: string;