@planu/cli 5.3.2 → 5.3.4

package/dist/engine/planu-core.linux-x64-musl.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.2",
-  "engineVersion": "5.3.2",
-  "buildId": "1-5.3.2-x86_64-unknown-linux-musl",
+  "cliVersion": "5.3.4",
+  "engineVersion": "5.3.4",
+  "buildId": "1-5.3.4-x86_64-unknown-linux-musl",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "linux",
   "arch": "x64",
   "libc": "musl",
-  "artifactSha256": "d44f03ecaed34427ca6ed682ce695f432d25eac3366fc5e779cfa78fe39d504b",
+  "artifactSha256": "84a3ad58be73c7b2c75a1b15252e557644c80bf66e6484781107300b6b0aec91",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.linux-x64-musl.node.sbom.json",
-    "sha256": "86d8219cdb5f5205d458cfa205ef619f68997f7a414f04a3a30f53704650b488"
+    "sha256": "dd6d811714f3dbe94427c0e66399f779dd9d9c194af589ae143bd16dc929b31a"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "30226657c1e66411b6ff233c2ea82e47573d533a",
+    "sourceCommit": "7f78cd615083c4284cab36c05f11dc2ce76e5cbd",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "O6Ay8rgviCK8bLJJbkQAsX9msRJoCxB2jkgpY6+v+7oyVohsZ3hKly1kFnQ35WRbibF4l2TBchxZI7IlKbAgCg=="
+    "value": "DUxITC22qKLQyVQNvklBEPM4TRryjTl4v3QM6mz+4f46GEkcMEOJ+6K3kH4/U425xnQH3fKBuqtpvWpj9Er8Aw=="
   }
 }

package/dist/engine/planu-core.linux-x64-musl.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.2",
+      "bom-ref": "pkg:cargo/planu-core@5.3.4",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.2",
+      "version": "5.3.4",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "d44f03ecaed34427ca6ed682ce695f432d25eac3366fc5e779cfa78fe39d504b"
+          "content": "84a3ad58be73c7b2c75a1b15252e557644c80bf66e6484781107300b6b0aec91"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.2",
+      "ref": "pkg:cargo/planu-core@5.3.4",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.win32-arm64-msvc.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.2",
-  "engineVersion": "5.3.2",
-  "buildId": "1-5.3.2-aarch64-pc-windows-msvc",
+  "cliVersion": "5.3.4",
+  "engineVersion": "5.3.4",
+  "buildId": "1-5.3.4-aarch64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "arm64",
   "libc": null,
-  "artifactSha256": "9a10e393e1b0aad7856de5973ea8efb018513bcb4e2c47ddb013be9bda7e3bda",
+  "artifactSha256": "d3f8633e9c7014a9163666c20dcd016f64b362e575ffb26afa9e8f51393cc8ba",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-arm64-msvc.node.sbom.json",
-    "sha256": "38f38493f6013f50daff7808dcbbab81133b141bce61cba430e7a07fe9a89fc2"
+    "sha256": "cb8c0c1f6567d471967a019e14fd7834b359c8a423626129bb8b01d404df9f5d"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "30226657c1e66411b6ff233c2ea82e47573d533a",
+    "sourceCommit": "7f78cd615083c4284cab36c05f11dc2ce76e5cbd",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "ktHCgTSn2Br8NhGf6Pjz5fCP38a9sGluOqs617pwRXymMiUBu2GNjvyp7mLqk2gY/L8KAbzvF6FHoqEVDzb9AA=="
+    "value": "R9tg5e4kK1p1AOy5RPA/HvLo5GwymlNQsCDMiGePRFZVetj8GumU1QAjBxF+B/yYCvaMa0YmuKCRrbpI4raNBQ=="
   }
 }

package/dist/engine/planu-core.win32-arm64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.2",
+      "bom-ref": "pkg:cargo/planu-core@5.3.4",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.2",
+      "version": "5.3.4",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "9a10e393e1b0aad7856de5973ea8efb018513bcb4e2c47ddb013be9bda7e3bda"
+          "content": "d3f8633e9c7014a9163666c20dcd016f64b362e575ffb26afa9e8f51393cc8ba"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.2",
+      "ref": "pkg:cargo/planu-core@5.3.4",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/planu-core.win32-x64-msvc.node.manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
-  "cliVersion": "5.3.2",
-  "engineVersion": "5.3.2",
-  "buildId": "1-5.3.2-x86_64-pc-windows-msvc",
+  "cliVersion": "5.3.4",
+  "engineVersion": "5.3.4",
+  "buildId": "1-5.3.4-x86_64-pc-windows-msvc",
   "protocolAbi": 1,
   "capabilityAbi": 2,
   "nodeApiAbi": 4,
@@ -16,15 +16,15 @@
   "platform": "win32",
   "arch": "x64",
   "libc": null,
-  "artifactSha256": "4a41383ea29c9dd64a668143e206b4af1859ba6f35b79fdeb7ea8f812113811c",
+  "artifactSha256": "a1ffe9cf1c0fa69ad29543b70dc3e6af72993f4ac3b770b5ed8f1794b5082020",
   "sbom": {
     "format": "CycloneDX-1.5",
     "path": "planu-core.win32-x64-msvc.node.sbom.json",
-    "sha256": "f96dbf4fd6d9cab1aa9b90057325829de42e018dfa2bf4220c78c9bbfab0f9c5"
+    "sha256": "76c83934b4a0fb50e59919c6d27723a395f5387af0c467674f5eeb0bb328a3a3"
   },
   "provenance": {
     "builder": "scripts/build-rust-local.sh",
-    "sourceCommit": "30226657c1e66411b6ff233c2ea82e47573d533a",
+    "sourceCommit": "7f78cd615083c4284cab36c05f11dc2ce76e5cbd",
     "sourceTreeDirty": false,
     "sourceDateEpoch": 1,
     "rustToolchain": "rustc 1.95.0 (59807616e 2026-04-14)",
@@ -33,6 +33,6 @@
   "signature": {
     "algorithm": "Ed25519",
     "keyId": "e2ee765cb5ad9fbdc433ece332bce26d746d5e350b3acde0721a4c8c6337ff7b",
-    "value": "vZ49hewESnK5idVecQPyBFUD+GPcbfa0ihzAKkxuqBSsyVEWNFGaGU4c/rzvXD6D3SKnApFEM3vZ9D2uCfSjDA=="
+    "value": "/yNziQ2dBYLR9Qg13plc/CanSa9RXWtBP8E8TDNsJYuZ+jLV1dnHksyG0zlVrGw/guegmsNe/LRC6fREdCFMCA=="
   }
 }

package/dist/engine/planu-core.win32-x64-msvc.node.sbom.json

@@ -4,14 +4,14 @@
   "version": 1,
   "metadata": {
     "component": {
-      "bom-ref": "pkg:cargo/planu-core@5.3.2",
+      "bom-ref": "pkg:cargo/planu-core@5.3.4",
       "type": "library",
       "name": "planu-core",
-      "version": "5.3.2",
+      "version": "5.3.4",
       "hashes": [
         {
           "alg": "SHA-256",
-          "content": "4a41383ea29c9dd64a668143e206b4af1859ba6f35b79fdeb7ea8f812113811c"
+          "content": "a1ffe9cf1c0fa69ad29543b70dc3e6af72993f4ac3b770b5ed8f1794b5082020"
         }
       ]
     }
@@ -1106,7 +1106,7 @@
       "dependsOn": []
     },
     {
-      "ref": "pkg:cargo/planu-core@5.3.2",
+      "ref": "pkg:cargo/planu-core@5.3.4",
       "dependsOn": [
         "pkg:cargo/core-foundation@0.10.1",
         "pkg:cargo/hmac@0.12.1",

package/dist/engine/runtime-policy.js

@@ -100,6 +100,20 @@ const runtimePolicySchema = z
         minimumHeartbeatMs: z.number().int().positive(),
     })
         .strict(),
+    outbox: z
+        .object({
+        sliceRecordBudget: z.number().int().positive(),
+        sliceTimeBudgetMs: z.number().int().positive(),
+        backoffBaseMs: z.number().int().positive(),
+        backoffCapMs: z.number().int().positive(),
+        maxAttempts: z.number().int().positive(),
+        diagnosticMaxLength: z.number().int().positive(),
+        continuationDelayMs: z.number().int().positive(),
+    })
+        .strict()
+        .refine((value) => value.backoffBaseMs <= value.backoffCapMs, {
+        message: 'backoffBaseMs must not exceed backoffCapMs',
+    }),
 })
     .strict();
 const require = createRequire(import.meta.url);

package/dist/engine/spec-format/unified-spec-builder.js

@@ -2,6 +2,7 @@
 // Closes the SPEC-630 residue: every new spec is born unified, never written as a
 // two-file spec.md + technical.md pair only to be merged on the next list_specs run.
 import { stripFrontmatter } from '../frontmatter-parser.js';
+import { extractAcceptanceCriteriaTexts } from './acceptance-criteria.js';
 const REQUIRED_SECTIONS = [
     'Problem',
     'Goal',
@@ -254,18 +255,41 @@ function firstSentence(text) {
         .find((part) => part.length > 0 && !part.startsWith('#'));
     return sentence ?? null;
 }
-function extractExecutableCriteria(source, criteria) {
-    const explicit = /\bGIVEN\b[\s\S]*?(?=(?:\n##|\bFILES:|\bFUNCTIONS:|\bTEST:|$))/i
-        .exec(source)?.[0]
-        ?.trim()
-        .replace(/[.\s]+$/, '.');
-    if (explicit) {
-        return `- ${explicit}`;
-    }
+function fallbackCriteriaBullets(criteria) {
     return criteria
         .map((criterion) => `- GIVEN the requested change is implemented WHEN the behavior is exercised THEN ${criterion.text}`)
         .join('\n');
 }
+// Same BDD step vocabulary `acceptance-criteria.ts` recognizes (English + Spanish).
+// A criterion already starting with one of these is a genuine BDD fragment
+// (a full GIVEN/WHEN/THEN block, or an AND continuation of one) — leave it as-is.
+const BDD_STEP_START = /^(GIVEN|WHEN|THEN|AND|DADO|CUANDO|ENTONCES|Y)\b/i;
+/**
+ * Render one real criterion as an executable bullet. Criteria already
+ * written in BDD form pass through untouched; plain-text criteria (e.g.
+ * checkbox items) are wrapped in the same GIVEN/WHEN/THEN scaffold
+ * `fallbackCriteriaBullets` uses, so every bullet stays BDD-executable
+ * without ever discarding a real criterion.
+ */
+function toExecutableBullet(text) {
+    const cleaned = text.trim().replace(/[.\s]+$/, '.');
+    if (BDD_STEP_START.test(cleaned)) {
+        return `- ${cleaned}`;
+    }
+    return `- GIVEN the requested change is implemented WHEN the behavior is exercised THEN ${cleaned}`;
+}
+/**
+ * Criteria resolve through the canonical parser in `acceptance-criteria.ts`
+ * so the renderer and `readiness-checker.ts` can never disagree about how
+ * many criteria a spec has.
+ */
+function extractExecutableCriteria(source, criteria) {
+    const parsed = extractAcceptanceCriteriaTexts(source);
+    if (parsed.length === 0) {
+        return fallbackCriteriaBullets(criteria);
+    }
+    return parsed.map(toExecutableBullet).join('\n');
+}
 function renderOwnedFiles(files) {
     const sections = [];
     for (const [title, entries] of [

package/dist/engine/spec-generator/fallback-generator.js

@@ -22,9 +22,11 @@ export class FallbackGenerator {
                 method: 'deterministic',
                 generatedAt: new Date().toISOString(),
             },
-            qualityWarnings: [
-                'Fallback generator used. Source description was preserved; missing decisions require explicit user input.',
-            ],
+            // SPEC-1406 (DEFECT 4, round 2): this generator is the only one wired into
+            // production (create-spec.ts:1430), so this warning fired unconditionally on
+            // every spec ever created — a warning with 100% incidence and no gate consumer
+            // carries no signal. Only qualityWarnings from actual quality issues remain.
+            qualityWarnings: [],
             fallbackReason: 'No external model generator is configured for create_spec.',
         });
     }

package/dist/engine/spec-quality/generic-output-gate.d.ts

@@ -1,3 +1,9 @@
-import type { GenericSpecOutputGateResult } from '../../types/index.js';
+import type { GenericSpecOutputGateResult, GenericSpecOutputIssueKind } from '../../types/index.js';
+/**
+ * SPEC-1406 (DEFECT 2 fix): the constant kind reused to mark structural-interpolation
+ * findings so callers can tell them apart from the other generic-output issue kinds and
+ * decide, per call site, whether that finding blocks or only warns.
+ */
+export declare const STRUCTURAL_INTERPOLATION_KIND: GenericSpecOutputIssueKind;
 export declare function checkGenericSpecOutput(content: string): GenericSpecOutputGateResult;
 //# sourceMappingURL=generic-output-gate.d.ts.map

package/dist/engine/spec-quality/generic-output-gate.js

@@ -1,6 +1,45 @@
-const CRITERIA_SECTION_RE = /^criteria:\n([\s\S]*?)(?=^[a-zA-Z_][\w-]*:|\n---|\s*$)/m;
+/** Bounds the search for criteria to the frontmatter block only (between the two `---`
+ * delimiters), so criterion-shaped lines never leak in from the rendered body below it. */
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
+/**
+ * SPEC-1406 (DEFECT 1, round 4 — detector was inert on real specs): matches a criterion's
+ * `- text: "..."` line regardless of nesting depth, so it covers BOTH shapes this generator
+ * renders (`lean-spec-generator.ts`): the top-level checkbox `criteria:` list AND the BDD
+ * `grounding: criteria:` list nested under `grounding:` (see
+ * `contract.ts:renderGroundingFrontmatter`, `    - text: "..."`). The previous version only
+ * looked inside a slice bounded by a single-line lookahead that matched line-end (`\s*$`
+ * under `/m`) after the FIRST criterion, so multi-criterion checkbox specs (e.g. SPEC-001,
+ * 6 criteria) only ever contributed their first entry — and it never ran at all against
+ * `scenarios:`-shaped (BDD) specs, which have no top-level `criteria:` key, so criteria was
+ * always `[]` there and `isInterpolatedTemplate`'s `criteria.length === 0` guard made every
+ * BDD spec's filler unflaggable by construction. Scanning the whole frontmatter block with
+ * this regex (plus SCENARIO_TITLE_RE below) fixes both defects in one pass — no truncating
+ * section boundary is needed once matching isn't anchored to a single top-level key.
+ */
 const CRITERION_TEXT_RE = /^\s+- text:\s*"?(.+?)"?\s*$/gm;
+/** Matches a BDD scenario's `- title: "..."` line (`bdd-parser.ts:renderBddScenariosYaml`) —
+ * the criterion-equivalent for `scenarios:`-format specs, which have no `- text:` entries. */
+const SCENARIO_TITLE_RE = /^\s+- title:\s*"?(.+?)"?\s*$/gm;
 const FILE_LINE_RE = /^-\s+(.+?)\s+\((pending|done)\)\s*$/gm;
+const H3_HEADING_RE = /^###[ \t]+(.+?)[ \t]*$/gm;
+const BULLET_LINE_RE = /^[-*][ \t]+(.+)$/;
+/** A bullet that, once a leading `Label:`, wrapping backticks, and a trailing `(status)`
+ * marker are stripped, is just a file path: contains a `/` and ends in a short extension.
+ * File/artifact lists (`Files`, `Modify`, `Create`, `Test`, `File-Level Work Plan`, or any
+ * future heading with this shape) are legitimately parallel — the interpolation detector
+ * must not run on them. Detected structurally so no heading name needs hardcoding. */
+const BULLET_LABEL_PREFIX_RE = /^[\w-]+:\s*/;
+const STATUS_SUFFIX_RE = /\s*\([\w .-]+\)$/;
+const PATH_TOKEN_RE = /^[\w./-]+\/[\w.-]+\.[a-zA-Z0-9]{1,10}$/;
+/** Minimum normalized length before a variable substring can count as "restating" a
+ * criterion — guards against trivial short-string collisions. */
+const CRITERION_RESTATEMENT_MIN_LENGTH = 8;
+/**
+ * SPEC-1406 (DEFECT 2 fix): the constant kind reused to mark structural-interpolation
+ * findings so callers can tell them apart from the other generic-output issue kinds and
+ * decide, per call site, whether that finding blocks or only warns.
+ */
+export const STRUCTURAL_INTERPOLATION_KIND = 'structural-interpolation';
 const GENERIC_CRITERION_RULES = [
     {
         pattern: /\bimplementation (is )?complete\b/i,
@@ -50,24 +89,176 @@ const PLACEHOLDER_REFERENCE_RULES = [
     },
 ];
 export function checkGenericSpecOutput(content) {
+    const criteria = frontmatterCriteria(content);
     const issues = [
-        ...checkCriteria(frontmatterCriteria(content)),
+        ...checkCriteria(criteria),
         ...checkTechnicalReferences(content),
+        ...checkInterpolatedSections(content, criteria),
     ];
     return { passed: issues.length === 0, issues };
 }
+/**
+ * SPEC-1406 (DEFECT 2, round 2 — detector rebuilt around CRITERION RESTATEMENT): the
+ * previous prefix/suffix-length rule flagged `### File-Level Work Plan` (whose bullets
+ * legitimately share a `- Modify: \`...\` (pending)` frame around a file path) and missed
+ * the actual filler this spec exists to kill (`- AC1 failure: ...`, `- Expected behavior
+ * AC1: ...`), because the framing on those templates is interrupted by a digit
+ * (`AC1` vs `AC2`) that a plain character-by-character prefix scan treats as a mismatch.
+ * The real discriminator isn't frame length — it's whether the varying middle of each
+ * bullet is itself a restatement of a declared acceptance criterion. Digit runs are
+ * treated as mutually equal while locating the shared frame, then the extracted middle
+ * is compared against every criterion.
+ */
+function checkInterpolatedSections(content, criteria) {
+    const issues = [];
+    const headingMatches = [...content.matchAll(H3_HEADING_RE)];
+    for (let i = 0; i < headingMatches.length; i += 1) {
+        const heading = headingMatches[i];
+        if (!heading?.[1]) {
+            continue;
+        }
+        const start = heading.index + heading[0].length;
+        const end = headingMatches[i + 1]?.index ?? content.length;
+        const bullets = content
+            .slice(start, end)
+            .split('\n')
+            .map((line) => BULLET_LINE_RE.exec(line.trim())?.[1])
+            .filter((line) => Boolean(line));
+        if (isFileListSection(bullets)) {
+            continue;
+        }
+        if (isInterpolatedTemplate(bullets, criteria)) {
+            issues.push({
+                kind: STRUCTURAL_INTERPOLATION_KIND,
+                phrase: heading[1],
+                reason: `subsection "${heading[1]}" restates each criterion into the same template with no new information`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * SPEC-1406 (DEFECT 1, round 3 — file-list false positive): a section whose bullets are
+ * mostly file paths (`### Modify`, `### Files`, `### Create`, `### Test`, `### File-Level
+ * Work Plan`, ...) is an allowlisted shape, not prose — parallel paths under a shared
+ * directory/extension carry no information loss, even when a path also happens to appear
+ * inside a criterion's `FILES:` marker. Detected structurally (allowlist, not a heading
+ * name denylist) so an unanticipated heading defaults to safe.
+ */
+function isFileListSection(bullets) {
+    if (bullets.length === 0) {
+        return false;
+    }
+    const pathLikeCount = bullets.filter(isPathLikeBullet).length;
+    return pathLikeCount > bullets.length / 2;
+}
+function isPathLikeBullet(bullet) {
+    const stripped = bullet
+        .trim()
+        .replace(BULLET_LABEL_PREFIX_RE, '')
+        .replace(STATUS_SUFFIX_RE, '')
+        .trim()
+        .replace(/^`|`$/g, '');
+    return PATH_TOKEN_RE.test(stripped);
+}
+function isInterpolatedTemplate(bullets, criteria) {
+    if (bullets.length < 2 || criteria.length === 0) {
+        return false;
+    }
+    const first = bullets[0] ?? '';
+    const prefix = commonPrefixLength(bullets);
+    const suffix = commonSuffixLength(bullets, prefix);
+    if (prefix + suffix >= first.length) {
+        // Digit-tolerant framing consumed the entire bullet: the bullets are identical
+        // except for an index digit (e.g. `AC1` vs `AC2`) with no other variable content.
+        // The digit itself isn't the restated criterion — the digit-stripped body is.
+        return bullets.every((bullet) => restatesCriterion(stripDigits(bullet), criteria));
+    }
+    return bullets.every((bullet) => {
+        const variable = bullet.slice(prefix, bullet.length - suffix);
+        return restatesCriterion(variable, criteria);
+    });
+}
+function stripDigits(value) {
+    return value.replace(/\d+/g, '');
+}
+function restatesCriterion(variable, criteria) {
+    const normalizedVariable = normalizeForRestatementMatch(variable);
+    if (normalizedVariable.length < CRITERION_RESTATEMENT_MIN_LENGTH) {
+        return false;
+    }
+    return criteria.some((criterion) => {
+        const normalizedCriterion = normalizeForRestatementMatch(criterion);
+        if (normalizedCriterion.length < CRITERION_RESTATEMENT_MIN_LENGTH) {
+            return false;
+        }
+        return (normalizedVariable.includes(normalizedCriterion) ||
+            normalizedCriterion.includes(normalizedVariable));
+    });
+}
+function normalizeForRestatementMatch(value) {
+    return value
+        .replace(/[`*_"]/g, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+/** Digit runs are treated as mutually equal so a fixed template interrupted only by an
+ * `AC1`/`AC2`-style index still resolves to its true shared frame. */
+function charsMatch(a, b) {
+    if (a === undefined || b === undefined) {
+        return false;
+    }
+    return a === b || (isDigit(a) && isDigit(b));
+}
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+function commonPrefixLength(values) {
+    const first = values[0] ?? '';
+    let length = first.length;
+    for (const value of values.slice(1)) {
+        let i = 0;
+        while (i < length && i < value.length && charsMatch(value[i], first[i])) {
+            i += 1;
+        }
+        length = Math.min(length, i);
+    }
+    return length;
+}
+function commonSuffixLength(values, limit) {
+    const first = values[0] ?? '';
+    let length = first.length - limit;
+    for (const value of values.slice(1)) {
+        let i = 0;
+        while (i < length &&
+            i < value.length - limit &&
+            charsMatch(value[value.length - 1 - i], first[first.length - 1 - i])) {
+            i += 1;
+        }
+        length = Math.min(length, i);
+    }
+    return Math.max(length, 0);
+}
 function frontmatterCriteria(content) {
-    const criteriaSection = CRITERIA_SECTION_RE.exec(content)?.[1] ?? '';
-    const criteria = [];
-    let match = CRITERION_TEXT_RE.exec(criteriaSection);
+    const frontmatter = FRONTMATTER_RE.exec(content)?.[1] ?? '';
+    return [
+        ...collectMatches(frontmatter, CRITERION_TEXT_RE),
+        ...collectMatches(frontmatter, SCENARIO_TITLE_RE),
+    ];
+}
+function collectMatches(text, pattern) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    const values = [];
+    let match = re.exec(text);
     while (match) {
         const phrase = match[1]?.replace(/\\"/g, '"').trim() ?? '';
         if (phrase.length > 0) {
-            criteria.push(phrase);
+            values.push(phrase);
         }
-        match = CRITERION_TEXT_RE.exec(criteriaSection);
+        match = re.exec(text);
     }
-    return criteria;
+    return values;
 }
 function checkCriteria(criteria) {
     const issues = [];

package/dist/engine/spec-quality-scorer.js

@@ -1,6 +1,7 @@
 // engine/spec-quality-scorer.ts — Spec quality scoring logic (SPEC-314)
 import { readFile } from 'node:fs/promises';
 import { readSpecTechnicalSection } from './spec-format/read-technical-section.js';
+import { extractAcceptanceCriteriaTexts } from './spec-format/acceptance-criteria.js';
 import { stripFrontmatter } from './frontmatter-parser.js';
 // ── Constants ────────────────────────────────────────────────────────────────
 const MAX_DIMENSION_SCORE = 25;
@@ -67,11 +68,14 @@ async function readSpecContent(spec) {
 async function readTechnicalContent(spec) {
     return readSpecTechnicalSection(spec);
 }
+// Delegates to the canonical parser (SPEC-1410) instead of matching checkbox
+// lines only, which returned [] for every GIVEN/WHEN/THEN spec. Deliberately
+// does NOT reuse `readiness-checker.extractCriteriaLines`: that helper returns
+// every non-empty line in the section (including WHEN/THEN/FILES: lines),
+// which would inflate the denominator that scoreTestability/scoreAmbiguity
+// divide by.
 function extractCriteriaLines(content) {
-    return content
-        .split('\n')
-        .filter((line) => /^- \[[ x]\]/.test(line.trim()))
-        .map((line) => line.trim());
+    return extractAcceptanceCriteriaTexts(content);
 }
 // ── Dimension scorers ────────────────────────────────────────────────────────
 function scoreCompleteness(spec, content) {
@@ -107,7 +111,7 @@ function scoreCompleteness(spec, content) {
     }
     else {
         issues.push('No acceptance criteria found');
-        recommendations.push('Add acceptance criteria in checkbox format (- [ ] ...)');
+        recommendations.push('Add acceptance criteria in GIVEN/WHEN/THEN format');
     }
     // Scope set to non-default (5 pts) — cast to handle partial specs at runtime
     const scope = spec.scope;

package/dist/engine/workers/handlers/auto-drift.js

@@ -154,14 +154,6 @@ async function buildDriftFindings(projectDir, effectiveChanged, activeSpecs, pro
                 driftedFiles,
                 cachedAt: new Date().toISOString(),
             });
-            // Wire drift:detected event so autopilot trigger-rules can react
-            emitAutopilotEvent({
-                name: 'drift:detected',
-                projectPath: projectDir,
-                projectId,
-                specId: spec.id,
-                payload: { driftScore, driftLevel: driftScore >= 0.7 ? 'high' : 'warning' },
-            });
             findings.push({
                 severity: driftScore >= 0.7 ? 'high' : 'warning',
                 file: '',
@@ -171,6 +163,28 @@ async function buildDriftFindings(projectDir, effectiveChanged, activeSpecs, pro
             });
         }
     }
+    if (driftScore >= threshold) {
+        // Wire drift:detected event so autopilot trigger-rules can react.
+        // Emitted once per project run — driftScore is project-wide, not per-spec,
+        // so emitting inside the loop would fire N identical events for N specs.
+        //
+        // MUST run after the cache-persistence loop above: emitAutopilotEvent
+        // dispatches handlers in a microtask (event-bus.ts), and the enabled
+        // rule drift-detected:resolve_drift_violations calls resolveDriftViolations,
+        // which loads the drift cache as its first action. Emitting before the
+        // cache entries are persisted lets that microtask race ahead and read an
+        // empty cache, silently resolving nothing.
+        emitAutopilotEvent({
+            name: 'drift:detected',
+            projectPath: projectDir,
+            projectId,
+            payload: {
+                driftScore,
+                driftLevel: driftScore >= 0.7 ? 'high' : 'warning',
+                specIds: activeSpecs.map((s) => s.id),
+            },
+        });
+    }
     return findings;
 }
 // ---------------------------------------------------------------------------

package/dist/index.js

@@ -126,7 +126,9 @@ async function setupPostHandshake(handshakeGate, officialToolNames) {
     })();
     // SPEC-334: Sync planu/ YAML frontmatter status → data/ store (non-blocking)
     scheduleStartupStateRecovery(startupSync, recoverPendingPostCommitTasksAtStartup);
-    await startSpecCreatedOutboxConsumer().catch((err) => {
+    // SPEC-1271: bounded, fair, durable spec.created outbox recovery — fire-and-forget so a
+    // large or poisoned backlog never delays post-handshake completion (mirrors serve.ts).
+    void startSpecCreatedOutboxConsumer().catch((err) => {
         console.error('[Planu] Startup spec.created outbox recovery failed:', err);
     });
     try {