@dzhechkov/harness-core 0.8.38 → 0.8.39

package/src/index.ts

@@ -116,6 +116,7 @@ export * from './trace-bundle.js';
 export { BLOBS as LOOP_BLOBS, LOOP_BLOB_NAMES, BLOB_COVERAGE_MANIFEST } from './loop-blobs.generated.js';
 export type { LoopBlob } from './loop-blobs.generated.js';
 export * from './sign.js';
+export * from './publish-source-scope.js';
 export * from './swarm-brief.js';
 export * from './skill-schema.js';
 export { createSkill } from './create-skill.js';
@@ -144,7 +145,7 @@ export { tokenize, stemToken, stems } from './stem.js';
 export * from './package-skill-layouts.js';
 export { recommend } from './recommend.js';
 export { pretrain } from './pretrain.js';
-export { loadPatterns, loadSessions, computePatternBoost, readLearningConfig, readMemoryLearningConfig, BOOST_CAP, recordPattern, recordLessonForms, loadStorePatternsSync, loadStoreRecords, findExactLesson, patternToRecord, recordToPattern, patternRecordId, patternIdentityOf, dreamRecordId, isMirrorableLearning, consolidateSessions, recallPatterns, pruneNoisePatterns, removePatternsByIds, snapshotStore, readReinforcementState, encodeReinforcementState, reinforcePattern, updateReinforcementState, storeStats, lessonDeltaReport, lessonDeltaMap, readQuarantineState, encodeQuarantineState, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns } from './patterns.js';
+export { loadPatterns, loadSessions, computePatternBoost, readLearningConfig, readMemoryLearningConfig, BOOST_CAP, recordPattern, recordLessonForms, loadStorePatternsSync, loadStoreRecords, findExactLesson, patternToRecord, recordToPattern, patternRecordId, patternIdentityOf, dreamRecordId, isMirrorableLearning, consolidateSessions, recallPatterns, pruneNoisePatterns, removePatternsByIds, snapshotStore, readReinforcementState, encodeReinforcementState, reinforcePattern, resolveReinforceTarget, updateReinforcementState, storeStats, lessonDeltaReport, lessonDeltaMap, readQuarantineState, encodeQuarantineState, promotePatterns, quarantineExpiryCandidates, pruneQuarantinePatterns } from './patterns.js';
 export { normalizeLessonForms, validateClassTemplate, lessonPairIdOf, mergeLessonFormHits, mergeLessonMatchedForms } from './lesson-generalization.js';
 export { withStoreLock, withStoreLockSync, storeLockPath, StoreLockTimeoutError, StoreLockCompromisedError, STALE_LOCK_MS, LOCK_TIMEOUT_MS } from './store-lock.js';
 export type { StoreLockOptions } from './store-lock.js';
@@ -304,6 +305,13 @@ export type {
   StoreMarkWriteOptions,
   StoreResetReceipt,
 } from './store-guard.js';
+export { planStoreGuardPrune } from './store-guard-prune.js';
+export type {
+  StoreGuardPruneBucket,
+  StoreGuardPruneEntry,
+  StoreGuardPrunePlan,
+  StoreGuardPruneDeps,
+} from './store-guard-prune.js';
 export { statuslineData, readFeatureAdrState, writeFeatureAdrState, featureAdrStateDir, featureAdrStatePath, writeFeatureAdrStateDetailed, renderFeatureAdrPhaseLine } from './statusline.js';
 export type { StatuslineData, StatuslineStoreHealth, FeatureAdrState, WriteFeatureAdrStateInput, WriteFeatureAdrStateResult } from './statusline.js';
 export {
@@ -501,6 +509,7 @@ export {
 } from './amendment-trace.js';
 export {
   RECORD_MAX_LINE_CHARS,
+  INCOMPLETE_REASON_CODES,
   decideRecordWrite,
   decideReadBack,
   recordVerdictLine,
@@ -528,7 +537,7 @@ export type {
 } from './feature-adr-envelope.js';
 export { decidePublishSigning, decidePostSigningVerification, decideSignableSet, publishSigningLine, signableSetLine } from './publish-signing.js';
 export type { PublishSigningVerdict, PublishSigningDecision, SignableSetDecision } from './publish-signing.js';
-export type { RecordKind, RecordVerdict, RecordDecision, LedgerEnrichInput, LedgerPriceEntry, ParsedModelSpec, TaskIdLookup } from './run-records.js';
+export type { RecordKind, RecordVerdict, RecordDecision, LedgerEnrichInput, LedgerPriceEntry, ParsedModelSpec, TaskIdLookup, IncompleteReasonCode } from './run-records.js';
 export type { AmendmentAmbiguity, AmendmentRow, AmendmentVerdict, AmendmentResolution, AmendmentOutcome, AmendmentDecision, PlanCoverageGap } from './amendment-trace.js';
 // contract-checklist (ADR-001): pure extraction, canonical rendering, typed report parsing, and
 // exact per-item verification. Filesystem discovery/containment stays in harness-cli.
@@ -755,7 +764,7 @@ export type {
   ChainDefectAges,
   ChainedJournal,
 } from './event-chain.js';
-export { decideProvenance, environmentCanMintProvenance, publishArgv, discoverPackages, publishPackages, bumpPatch, compareVersions, findUnpackagedSkills, findUnpublishedWorkspaceFloors, rewriteWorkspaceSpecs, orderByDependencies, syncReadmeVersion, isChangelogEntryLine, changelogRegion, planReadmeVersionSync } from './publish.js';
+export { decideProvenance, environmentCanMintProvenance, publishArgv, matchesPublishFilter, discoverPackages, publishPackages, bumpPatch, compareVersions, findUnpackagedSkills, findUnpublishedWorkspaceFloors, rewriteWorkspaceSpecs, orderByDependencies, syncReadmeVersion, isChangelogEntryLine, changelogRegion, planReadmeVersionSync } from './publish.js';
 export type { ReadmeVersionSyncPlan, ReadmeSyncRewrite } from './publish.js';
 export { RELEASE_LINE_RE, findReleaseLine, rewriteReleaseLine } from './release-line.js';
 export * from './course-staleness.js';
@@ -1148,6 +1157,11 @@ export * from './compounding.js';
 // Advisory command-invocation telemetry + deadwood report (feature dz-deadwood).
 export * from './cmd-usage.js';
 
+// Deterministic, blocked arm assignment for a prospective ablation (feature ablation-c-start,
+// ADR-001): pure — no fs, no clock, reuses `mulberry32` (the repo's only PRNG).
+export { assignArm, readAssignments, verifyAssignmentRecord } from './experiment-assign.js';
+export type { AssignArmInput, AssignArmResult, AssignmentRecord, ReadAssignmentsResult, VerifyAssignmentResult } from './experiment-assign.js';
+
 // Cold-vs-warm EPOCH RUNNER (feature epoch-replay, scout idea #4) — the RESULT leg to compounding's
 // readiness leg. Orchestrates + scores; never calls a model. SUPPORTED requires two DISJOINT Wilson
 // intervals; INCONCLUSIVE is a first-class honest outcome.

package/src/loop-blobs.generated.ts

@@ -52,11 +52,11 @@ export const BLOBS: Record<string, LoopBlob> = {
   "checkpoints": {
     name: "checkpoints",
     version: "1.2.0",
-    contentHash: "a44560c6036fd143b7a3f125fec00fa8b91c3c06ac5b9e1ecfb83d27a5211e9b",
+    contentHash: "b602357649042d6b8aa68b5ca5593f7f5c483fdb36a287742e7b27bda8a2a6c7",
     sourcePath: "packages/@dzhechkov/harness-core/src/feature-adr-checkpoints.ts",
     requires: [],
     exports: ["CHECKPOINT_STAGES","STAGE_ARTIFACTS","CHECKPOINT_MAX_RESULT_CHARS","CKPT_SCHEMA_VERSION","fnv1a","fnv1a64","checkpointInputHash","resumeMode","decideCheckpointResume","serializeCheckpoint","CHECKPOINT_LS_SENTINEL","parseCheckpointRead","shellQuote","checkpointReadCmd","checkpointAppendCmd","DESIGN_SUBSTAGES","designStageKey","decideDesignFanResume","parseArtifactProbe","ROUTER_CONTRACT_TOKEN"],
-    code: "const CHECKPOINT_STAGES = ['router', 'design', 'plan', 'code', 'qe', 'fleet'];\nconst STAGE_ARTIFACTS = {\n    router: '00_complexity_assessment.md',\n    design: '01_requirements.md',\n    plan: '06_implementation_plan.md',\n    code: '07_code_changes/change_manifest.md',\n    qe: '08_qe_report.md',\n    fleet: '09_fleet_qe_assessment.md',\n};\nconst CHECKPOINT_MAX_RESULT_CHARS = 12000;\nconst CKPT_SCHEMA_VERSION = 'fa-ckpt-3';\nconst ROUTER_CONTRACT_TOKEN = 'router-writes-00-v1';\nfunction fnv1a(str) {\n    let h = 0x811c9dc5;\n    for (let i = 0; i < str.length; i++) {\n        h ^= str.charCodeAt(i);\n        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;\n    }\n    return h.toString(16).padStart(8, '0');\n}\nfunction fnv1a64(str) {\n    return fnv1a(str) + fnv1a('fa-ckpt-salt' + str);\n}\nfunction checkpointInputHash(stage, parts) {\n    return fnv1a64(JSON.stringify([CKPT_SCHEMA_VERSION, stage, ...parts.map((p) => (p === undefined ? null : p))]));\n}\nfunction resumeMode(raw) {\n    return raw === 'never' ? 'never' : raw === 'force' ? 'force' : 'auto';\n}\nconst DESIGN_SUBSTAGES = ['requirements', 'adr', 'qcsd', 'architecture'];\nfunction designStageKey(sub) {\n    return 'design:' + sub;\n}\nfunction decideDesignFanResume(opts) {\n    const missingSubstages = [];\n    opts.required.forEach((sub, i) => {\n        const r = opts.results[i];\n        if (r === null || r === undefined)\n            missingSubstages.push(sub);\n    });\n    const missingArtifacts = [];\n    let probeMissing = false;\n    if (opts.artifacts.length > 0) {\n        if (opts.postRunListing === null)\n            probeMissing = true;\n        else\n            for (const rel of opts.artifacts)\n                if (!opts.postRunListing.has(rel))\n                    missingArtifacts.push(rel);\n    }\n    const reason = missingSubstages.length > 0 ? 'substage-missing'\n        : probeMissing ? 'probe-not-established'\n            : missingArtifacts.length > 0 ? 'artifact-missing'\n                : 'ok';\n    return { complete: reason === 'ok', missingSubstages, missingArtifacts, reason };\n}\nfunction decideCheckpointResume(opts) {\n    if (opts.mode === 'never')\n        return { resume: false, reason: 'mode-never' };\n    if (!opts.entry || opts.entry.result === null || opts.entry.result === undefined) {\n        return { resume: false, reason: 'no-checkpoint' };\n    }\n    if (opts.entry.inputHash !== opts.inputHash)\n        return { resume: false, reason: 'stale-input' };\n    if (opts.mode === 'force')\n        return { resume: true, reason: 'resumed-force' };\n    const required = opts.artifactRel === null ? [] : (typeof opts.artifactRel === 'string' ? [opts.artifactRel] : opts.artifactRel);\n    for (const rel of required) {\n        if (!opts.listing.has(rel))\n            return { resume: false, reason: 'artifact-missing' };\n    }\n    return { resume: true, reason: 'resumed' };\n}\nfunction serializeCheckpoint(stage, inputHash, result) {\n    if (result === null || result === undefined)\n        return null;\n    let line;\n    try {\n        line = JSON.stringify({ stage, inputHash, result });\n    }\n    catch {\n        return null;\n    }\n    if (typeof line !== 'string' || line.length > CHECKPOINT_MAX_RESULT_CHARS)\n        return null;\n    return line;\n}\nconst CHECKPOINT_LS_SENTINEL = '---FA-CKPT-LS---';\nfunction parseCheckpointRead(text) {\n    const out = { entries: {}, listing: new Set(), malformedLines: 0 };\n    const raw = String(text ?? '');\n    const lines = raw.split('\\n');\n    const sentinelAt = lines.findIndex((l) => l.trim() === CHECKPOINT_LS_SENTINEL);\n    const body = sentinelAt === -1 ? lines : lines.slice(0, sentinelAt);\n    const ls = sentinelAt === -1 ? [] : lines.slice(sentinelAt + 1);\n    for (const line of body) {\n        const t = line.trim();\n        if (t === '')\n            continue;\n        try {\n            const e = JSON.parse(t);\n            if (e && typeof e === 'object' && typeof e.stage === 'string' && typeof e.inputHash === 'string' && 'result' in e && e.result !== null && e.result !== undefined) {\n                out.entries[e.stage] = e;\n            }\n            else {\n                if (e && typeof e === 'object' && typeof e.stage === 'string')\n                    delete out.entries[e.stage];\n                out.malformedLines++;\n            }\n        }\n        catch {\n            out.malformedLines++;\n        }\n    }\n    for (const line of ls) {\n        const t = line.trim();\n        if (t !== '')\n            out.listing.add(t);\n    }\n    return out;\n}\nfunction shellQuote(s) {\n    return \"'\" + String(s).replace(/'/g, \"'\\\\''\") + \"'\";\n}\nfunction checkpointReadCmd(fdirAbs) {\n    const q = shellQuote(fdirAbs);\n    return ('cat ' + q + '/.fa-state/checkpoints.jsonl 2>/dev/null || true; ' +\n        \"echo '\" + CHECKPOINT_LS_SENTINEL + \"'; \" +\n        'cd ' + q + ' 2>/dev/null && find . -maxdepth 2 -type f 2>/dev/null | sed \"s|^\\\\./||\" || true');\n}\nfunction checkpointAppendCmd(fdirAbs, line) {\n    const dir = shellQuote(fdirAbs + '/.fa-state');\n    const file = shellQuote(fdirAbs + '/.fa-state/checkpoints.jsonl');\n    return 'mkdir -p ' + dir + \" && printf '%s\\\\n' \" + shellQuote(line) + ' >> ' + file;\n}\nfunction parseArtifactProbe(opts) {\n    if (opts.stdout === null || opts.stdout === undefined)\n        return null;\n    const known = new Map();\n    for (const rel of opts.required)\n        known.set('HAVE:' + rel, rel);\n    const found = new Set();\n    let sentinels = 0;\n    for (const raw of String(opts.stdout).split('\\n')) {\n        const line = raw.trim();\n        if (line === '')\n            continue;\n        if (line === opts.sentinel) {\n            sentinels++;\n            continue;\n        }\n        if (sentinels > 0)\n            return null;\n        const rel = known.get(line);\n        if (rel === undefined)\n            return null;\n        found.add(rel);\n    }\n    if (sentinels !== 1)\n        return null;\n    return found;\n}",
+    code: "const CHECKPOINT_STAGES = ['router', 'design', 'plan', 'code', 'qe', 'fleet'];\nconst STAGE_ARTIFACTS = {\n    router: '00_complexity_assessment.md',\n    design: '01_requirements.md',\n    plan: '06_implementation_plan.md',\n    code: '07_code_changes/change_manifest.md',\n    qe: '08_qe_report.md',\n    fleet: '09_fleet_qe_assessment.md',\n};\nconst CHECKPOINT_MAX_RESULT_CHARS = 12000;\nconst CKPT_SCHEMA_VERSION = 'fa-ckpt-3';\nconst ROUTER_CONTRACT_TOKEN = 'router-writes-00-v1';\nfunction fnv1a(str) {\n    let h = 0x811c9dc5;\n    for (let i = 0; i < str.length; i++) {\n        h ^= str.charCodeAt(i);\n        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;\n    }\n    return h.toString(16).padStart(8, '0');\n}\nfunction fnv1a64(str) {\n    return fnv1a(str) + fnv1a('fa-ckpt-salt' + str);\n}\nfunction checkpointInputHash(stage, parts) {\n    return fnv1a64(JSON.stringify([CKPT_SCHEMA_VERSION, stage, ...parts.map((p) => (p === undefined ? null : p))]));\n}\nfunction resumeMode(raw) {\n    return raw === 'never' ? 'never' : raw === 'force' ? 'force' : 'auto';\n}\nconst DESIGN_SUBSTAGES = ['requirements', 'adr', 'qcsd', 'architecture'];\nfunction designStageKey(sub) {\n    return 'design:' + sub;\n}\nfunction decideDesignFanResume(opts) {\n    const missingSubstages = [];\n    opts.required.forEach((sub, i) => {\n        const r = opts.results[i];\n        if (r === null || r === undefined)\n            missingSubstages.push(sub);\n    });\n    const missingArtifacts = [];\n    let probeMissing = false;\n    if (opts.artifacts.length > 0) {\n        if (opts.postRunListing === null)\n            probeMissing = true;\n        else\n            for (const rel of opts.artifacts)\n                if (!opts.postRunListing.has(rel))\n                    missingArtifacts.push(rel);\n    }\n    const reason = missingSubstages.length > 0 ? 'substage-missing'\n        : probeMissing ? 'probe-not-established'\n            : missingArtifacts.length > 0 ? 'artifact-missing'\n                : 'ok';\n    return { complete: reason === 'ok', missingSubstages, missingArtifacts, reason };\n}\nfunction decideCheckpointResume(opts) {\n    if (opts.mode === 'never')\n        return { resume: false, reason: 'mode-never' };\n    if (!opts.entry || opts.entry.result === null || opts.entry.result === undefined) {\n        return { resume: false, reason: 'no-checkpoint' };\n    }\n    if (opts.entry.inputHash !== opts.inputHash)\n        return { resume: false, reason: 'stale-input' };\n    if (opts.mode === 'force')\n        return { resume: true, reason: 'resumed-force' };\n    const required = opts.artifactRel === null ? [] : (typeof opts.artifactRel === 'string' ? [opts.artifactRel] : opts.artifactRel);\n    for (const rel of required) {\n        if (!opts.listing.has(rel))\n            return { resume: false, reason: 'artifact-missing' };\n    }\n    return { resume: true, reason: 'resumed' };\n}\nfunction serializeCheckpoint(stage, inputHash, result, ts) {\n    if (result === null || result === undefined)\n        return null;\n    let line;\n    try {\n        line = JSON.stringify({ stage, inputHash, result, ...(ts === undefined ? {} : { ts }) });\n    }\n    catch {\n        return null;\n    }\n    if (typeof line !== 'string' || line.length > CHECKPOINT_MAX_RESULT_CHARS)\n        return null;\n    return line;\n}\nconst CHECKPOINT_LS_SENTINEL = '---FA-CKPT-LS---';\nconst CHECKPOINT_TIMESTAMP = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,3})?Z$/;\nfunction parseCheckpointRead(text) {\n    const out = { entries: {}, listing: new Set(), malformedLines: 0 };\n    const raw = String(text ?? '');\n    const lines = raw.split('\\n');\n    const sentinelAt = lines.findIndex((l) => l.trim() === CHECKPOINT_LS_SENTINEL);\n    const body = sentinelAt === -1 ? lines : lines.slice(0, sentinelAt);\n    const ls = sentinelAt === -1 ? [] : lines.slice(sentinelAt + 1);\n    for (const line of body) {\n        const t = line.trim();\n        if (t === '')\n            continue;\n        try {\n            const e = JSON.parse(t);\n            if (e && typeof e === 'object' && typeof e.stage === 'string' && typeof e.inputHash === 'string' && 'result' in e && e.result !== null && e.result !== undefined) {\n                const { ts, ...entry } = e;\n                out.entries[e.stage] = typeof ts === 'string' && CHECKPOINT_TIMESTAMP.test(ts) ? { ...entry, ts } : entry;\n            }\n            else {\n                if (e && typeof e === 'object' && typeof e.stage === 'string')\n                    delete out.entries[e.stage];\n                out.malformedLines++;\n            }\n        }\n        catch {\n            out.malformedLines++;\n        }\n    }\n    for (const line of ls) {\n        const t = line.trim();\n        if (t !== '')\n            out.listing.add(t);\n    }\n    return out;\n}\nfunction shellQuote(s) {\n    return \"'\" + String(s).replace(/'/g, \"'\\\\''\") + \"'\";\n}\nfunction checkpointReadCmd(fdirAbs) {\n    const q = shellQuote(fdirAbs);\n    return ('cat ' + q + '/.fa-state/checkpoints.jsonl 2>/dev/null || true; ' +\n        \"echo '\" + CHECKPOINT_LS_SENTINEL + \"'; \" +\n        'cd ' + q + ' 2>/dev/null && find . -maxdepth 2 -type f 2>/dev/null | sed \"s|^\\\\./||\" || true');\n}\nfunction checkpointAppendCmd(fdirAbs, line) {\n    const dir = shellQuote(fdirAbs + '/.fa-state');\n    const file = shellQuote(fdirAbs + '/.fa-state/checkpoints.jsonl');\n    const plain = 'mkdir -p ' + dir + \" && printf '%s\\\\n' \" + shellQuote(line) + ' >> ' + file;\n    if (typeof line !== 'string' || !line.startsWith('{'))\n        return plain;\n    return 'ts=$(date -u +%Y-%m-%dT%H:%M:%SZ); mkdir -p ' + dir\n        + ' && { printf \\'{\"ts\":\"%s\",\\' \"$ts\"; printf \\'%s\\\\n\\' ' + shellQuote(line.slice(1)) + '; } >> ' + file;\n}\nfunction parseArtifactProbe(opts) {\n    if (opts.stdout === null || opts.stdout === undefined)\n        return null;\n    const known = new Map();\n    for (const rel of opts.required)\n        known.set('HAVE:' + rel, rel);\n    const found = new Set();\n    let sentinels = 0;\n    for (const raw of String(opts.stdout).split('\\n')) {\n        const line = raw.trim();\n        if (line === '')\n            continue;\n        if (line === opts.sentinel) {\n            sentinels++;\n            continue;\n        }\n        if (sentinels > 0)\n            return null;\n        const rel = known.get(line);\n        if (rel === undefined)\n            return null;\n        found.add(rel);\n    }\n    if (sentinels !== 1)\n        return null;\n    return found;\n}",
   },
   "training-pairs": {
     name: "training-pairs",

package/src/mutation-gate.ts

@@ -1488,6 +1488,65 @@ export function summarizeMutationResults(results: readonly MutationEntryResult[]
   };
 }
 
+// ── Durable verdicts (instrument-round-b T3/FR-3/A3/A4, ADR-001 D3) ────────────────────────────
+//
+// The registry (`test/mutation-registry.json`) is the gate's INPUT — what to mutate. A verdict is
+// its OUTPUT — what happened the last time the gate ran. Mixing them means the input would change
+// on every run and every reader of the registry (mutation-registry-freshness included) would have
+// to start tolerating a moving file; A4 keeps them apart on purpose. `dz mutation-gate` (the CLI
+// executor) appends one JSON line per classified entry to a SEPARATE durable file
+// (`.dz/mutation-gate/verdicts.jsonl`) so a verdict survives the executor's own scratch-dir
+// teardown and the host's next reboot — today it lives only in `DZ_MUTGATE_OUTPUT_DIR`, a temp
+// directory (00_complexity_assessment.md: 0 of 377 registry entries carry a persisted verdict).
+
+/** Everything the CLI knows that this pure module does not: when, in which package, and under
+ *  which run. `runId` is honest-absent (`null`) when the caller has none to offer — never guessed. */
+export interface MutationVerdictMeta {
+  readonly ts: string;
+  readonly package: string;
+  readonly runId: string | null;
+}
+
+/** One durable line — append-only, one per classified registry entry. `observed` is the
+ *  registry's OWN anchor (copied, never recomputed) so a reader can see the historical coverage
+ *  claim next to the fresh verdict without re-opening the registry. */
+export interface MutationVerdictRow {
+  readonly ts: string;
+  readonly package: string;
+  readonly entryId: string;
+  readonly verdict: MutationVerdict;
+  readonly failingCount: number | null;
+  readonly observed: number | null;
+  readonly drop: boolean;
+  readonly dropComparable: boolean;
+  readonly runId: string | null;
+}
+
+/**
+ * Pure: payload in, row out — no filesystem (NFR-2; the CLI owns the append). `entry` is `null`
+ * for a result that never resolved to a valid registry entry (`ENTRY_INVALID` / `COVERAGE_GAP` —
+ * `parseMutationRegistry` excludes those from `registry.entries` by construction, so the CALLER
+ * cannot always hand one in) — `observed` then stays `null`, honestly, rather than the caller
+ * inventing a fallback entry object just to satisfy this signature.
+ */
+export function mutationVerdictRow(
+  entry: MutationRegistryEntry | null,
+  result: MutationEntryResult,
+  meta: MutationVerdictMeta,
+): MutationVerdictRow {
+  return {
+    ts: meta.ts,
+    package: meta.package,
+    entryId: result.id,
+    verdict: result.verdict,
+    failingCount: result.failingCount,
+    observed: entry !== null && typeof entry.observed === 'number' ? entry.observed : null,
+    drop: result.drop,
+    dropComparable: result.dropComparable,
+    runId: meta.runId,
+  };
+}
+
 const VERDICT_MARK: Record<MutationVerdict, string> = {
   PROVEN: '✓',
   ENTRY_INVALID: '✗',

package/src/name-check.ts

@@ -127,7 +127,37 @@ export function decideNameCheck(queries: readonly NameQuery[], facts: NameFacts)
   return { outcome: 'free', exit: 0, results, reason: `all ${results.length} name(s) are free` };
 }
 
-export function renderNameCheck(decision: NameDecision, scanned?: NameFacts['scanned']): string[] {
+/**
+ * Имена того же вида, ДЕЛЯЩИЕ СЛОВО с запрошенным.
+ *
+ * ЗАЧЕМ ЭТО ЗДЕСЬ. `name-check` отвечает на вопрос «занято ли ИМЯ», и отвечает верно. Но у
+ * него есть соседний вопрос, которого он не задаёт: «а нет ли уже ПРИБОРА для этой работы».
+ * ИЗМЕРЕНО 2026-09-19: `dz name-check --module ledger-cost-fill` честно ответил FREE, и по
+ * этому ответу был построен модуль, дублирующий существующий `ledger-backfill` — подключённый
+ * к CLI, с тем же измерением в шапке, заполняющий 47 строк против 31 у дубля и вдобавок
+ * намеренно НЕ делающий того, что дубль сделал (вывод минут и агентов, тихо переопределивший
+ * две колонки).
+ *
+ * Поэтому здесь НЕ вердикт и НЕ отказ — свободное имя остаётся свободным. Это СВЕДЕНИЯ в точке
+ * решения: список соседей по корню слова, которые оператор увидит ровно тогда, когда ещё не
+ * написал ни строки. Разница между «занято» и «рядом есть похожее» сохранена намеренно:
+ * превратить второе в отказ значило бы запретить `publish-order` рядом с `publish-signing`.
+ *
+ * Слова короче четырёх букв игнорируются: `fa`, `dz`, `to`, `run` роднят почти всё со всем.
+ */
+export function nearNames(query: NameQuery, facts: NameFacts, limit = 5): string[] {
+  const words = (n: string): string[] =>
+    n.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length >= 4);
+  const asked = new Set(words(query.name));
+  if (asked.size === 0) return [];
+  const pool: string[] = query.kind === 'command'
+    ? [...facts.commands]
+    : query.kind === 'module' ? [...facts.modules.keys()] : [...facts.exports.keys()];
+  const hits = pool.filter((n) => n !== query.name && words(n).some((w) => asked.has(w)));
+  return hits.sort().slice(0, limit);
+}
+
+export function renderNameCheck(decision: NameDecision, scanned?: NameFacts['scanned'], facts?: NameFacts): string[] {
   const out: string[] = [];
   if (scanned !== undefined) {
     // Printed always, pass or fail: the operator must be able to see that the sweep looked at a real
@@ -145,6 +175,18 @@ export function renderNameCheck(decision: NameDecision, scanned?: NameFacts['sca
     // Said on the passing path, because that is where the limit gets forgotten: the scan reads
     // declarations, so a re-export under a different name (`export { a as b }`) is invisible to it.
     out.push('  note: this reads declarations in source. A re-export under a different name is not visible here — the build still owns that case.');
+    if (facts !== undefined) {
+      // Свободное имя — не доказательство отсутствия прибора. Соседи печатаются СВЕДЕНИЯМИ,
+      // вердикт при этом не меняется: отказывать за сходство значило бы запретить
+      // `publish-order` рядом с `publish-signing`.
+      for (const r of decision.results) {
+        const near = nearNames({ kind: r.kind, name: r.name }, facts);
+        if (near.length > 0) {
+          out.push(`  рядом уже есть ${r.kind}(s), делящие слово с «${r.name}»: ${near.join(', ')}`);
+          out.push('    прочитайте их ПЕРЕД тем, как писать: свободное ИМЯ не означает отсутствия ПРИБОРА для этой работы');
+        }
+      }
+    }
   }
   return out;
 }

package/src/no-stubs.ts

@@ -118,6 +118,8 @@ export interface StubFinding {
   readonly detail: string;
 }
 
+import { maskMarkdown } from './markdown-masker.js';
+
 /** A config waiver: path-keyed, reason MANDATORY. A reasonless entry is refused, never honoured. */
 export interface StubWaiver {
   readonly path?: string;
@@ -141,18 +143,25 @@ function maskInlineCode(line: string): string {
  * clean, while a naked stub line in doc prose still fires. Code files are scanned in full: a marker
  * a code file must legitimately carry (another gate's source, a fixture) takes an inline
  * `no-stubs: <reason>` waiver — visible, reasoned, greppable.
+ *
+ * Block scoping is DELEGATED to the canonical masker, not re-implemented here. The hand-rolled
+ * `inFence = !inFence` toggle it replaces broke two CommonMark rules and produced MEASURED false
+ * positives (2026-09-20): a fence closes only on its OWN marker, so a `~~~` line inside a backtick
+ * block is content — the toggle read it as a close and scanned the rest of the code block as prose;
+ * and a closing fence may carry NO info string, so a second info-string line closed the block.
+ * `unclosed: 'hide'` preserves THIS reader's existing policy — an unclosed opener hides the tail
+ * rather than restoring it, because a gate must not invent findings out of a half-written block.
+ * Four-space indented code stays unmasked (the masker default): unchanged from the toggle era, a
+ * known limit rather than a new one.
  */
 export function scanStubs(path: string, text: unknown): StubFinding[] {
   if (typeof text !== 'string' || text.length === 0) return [];
   const md = isMarkdown(path);
   const out: StubFinding[] = [];
-  let inFence = false;
   const lines = text.split('\n');
+  const scanLines = md ? String(maskMarkdown(text, { unclosed: 'hide' })).split('\n') : lines;
   for (let i = 0; i < lines.length; i++) {
-    const raw = lines[i]!;
-    if (md && /^\s*(```|~~~)/.test(raw)) { inFence = !inFence; continue; }
-    if (md && inFence) continue;
-    const line = md ? maskInlineCode(raw) : raw;
+    const line = md ? maskInlineCode(scanLines[i] ?? '') : lines[i]!;
 
     // Inline waiver first: with a reason ⇒ the line is exempt; without one ⇒ refuse loudly AND
     // leave the marker finding in place (a refused waiver must not half-work).

package/src/patterns.ts

@@ -755,10 +755,52 @@ export async function reinforcePattern(projectRoot: string, dzIdOrText: string,
   return result;
 }
 
+/**
+ * Which learned pattern does `--reinforce <arg>` mean? PURE, so the branch that REFUSES has a test.
+ *
+ * Order: the full id, then the exact text, then a BARE id suffix.
+ *
+ * The suffix step exists because an id is PRINTED as `<namespace>:<suffix>` — `teach:1a4a9bdd…` —
+ * by every surface that emits one (`dz teach`'s own `ID:` line, `dz recall --json`'s `dzId`), and a
+ * caller who kept only the hex got `no learned pattern matches`. The advisory then pointed at
+ * `dz recall`, which cannot surface a QUARANTINED lesson by its own text, so a lesson taught
+ * minutes ago had no reachable path at all (MEASURED 2026-09-20, backlog 2d3059fc). The report's
+ * wider claim — that ids are rejected outright — is REFUTED: the full printed id has always worked.
+ *
+ * An ambiguous suffix is refused BY NAME, never guessed. Reinforcing the wrong lesson writes
+ * silently and leaves no signal afterwards that the wrong record moved, so a wrong guess here is
+ * strictly worse than a refusal the caller can act on. Today only `teach:` ids exist, but `dream:`
+ * is a second canonical namespace this store already documents, so the collision is reachable.
+ */
+export function resolveReinforceTarget(
+  records: readonly MemoryRecord[],
+  dzIdOrText: string,
+): { rec: MemoryRecord; matchedBy: 'id' | 'text' | 'suffix' } | { rec: undefined; error: string } {
+  // The KIND of match is part of the answer, not a detail: the caller prints it in a receipt, and a
+  // receipt that says "matched by text" about a suffix match is a receipt that lies. MEASURED
+  // 2026-09-20: the CLI inferred the kind from `resolved !== input`, which is true for BOTH a text
+  // match and a suffix match, so the suffix path reported the wrong one.
+  const byId = records.find((r) => r.id === dzIdOrText);
+  if (byId !== undefined) return { rec: byId, matchedBy: 'id' };
+  const byText = records.find((r) => r.text === dzIdOrText);
+  if (byText !== undefined) return { rec: byText, matchedBy: 'text' };
+  const bare = records.filter((r) => typeof r.id === 'string' && r.id.endsWith(':' + dzIdOrText));
+  if (bare.length > 1) {
+    return {
+      rec: undefined,
+      error: `${JSON.stringify(dzIdOrText)} is a bare id suffix shared by ${bare.length} learned patterns (${bare.map((r) => r.id).join(', ')}) — pass the full id`,
+    };
+  }
+  const only = bare[0];
+  if (only !== undefined) return { rec: only, matchedBy: 'suffix' };
+  return { rec: undefined, error: `no learned pattern matches ${JSON.stringify(dzIdOrText)}` };
+}
+
 async function reinforcePatternLocked(projectRoot: string, dzIdOrText: string, opts: { reward?: number; ts?: string; mergedFrom?: readonly string[]; exposure?: boolean }): Promise<ReinforcePatternResult> {
   const records = loadStoreRecords(projectRoot);
-  const rec = records.find((r) => r.id === dzIdOrText || r.text === dzIdOrText);
-  if (rec === undefined) return { ok: false, error: `no learned pattern matches ${JSON.stringify(dzIdOrText)}` };
+  const resolved = resolveReinforceTarget(records, dzIdOrText);
+  if (resolved.rec === undefined) return { ok: false, error: resolved.error };
+  const rec = resolved.rec;
   const pairId = typeof rec.metadata?.['lessonPairId'] === 'string' ? rec.metadata['lessonPairId'] : undefined;
   const targets = pairId === undefined
     ? [rec]
@@ -781,14 +823,14 @@ async function reinforcePatternLocked(projectRoot: string, dzIdOrText: string, o
   for (const target of targets) {
     const promotedMeta = { ...(target.metadata ?? {}), ...encodeReinforcementState(nextState) };
     if (opts.exposure !== true) {
-      delete promotedMeta['qStatus'];
-      delete promotedMeta['quarantinedAt'];
+      promotedMeta['qStatus'] = 'promoted';
+      promotedMeta['promotedAt'] = ts;
     }
     const put = await putStoreRecord(projectRoot, { ...target, metadata: promotedMeta });
     if ('error' in put) return { ok: false, dzId: rec.id, error: put.error };
   }
   try {
-    appendFileSync(join(projectRoot, '.dz', 'sessions.jsonl'), JSON.stringify({ event: 'reinforce', ts, dzId: rec.id, uses: nextState.uses }) + '\n');
+    appendFileSync(join(projectRoot, '.dz', 'sessions.jsonl'), JSON.stringify({ event: 'reinforce', ts, dzId: rec.id, uses: nextState.uses, exposure: opts.exposure === true }) + '\n');
   } catch { /* best-effort */ }
   return { ok: true, dzId: rec.id, uses: nextState.uses, reward: observed };
 }
@@ -845,10 +887,9 @@ export async function promotePatterns(projectRoot: string, dzIds: readonly strin
         const targets = pairId === undefined ? [rec] : records.filter((r) => r.metadata?.['lessonPairId'] === pairId);
         const pending = targets.filter((target) => !handled.has(target.id) && readQuarantineState(target).quarantined);
         if (pending.length === 0) { notQuarantined.push(id); continue; }
+        const promotedAt = new Date().toISOString();
         for (const target of pending) {
-          const meta = { ...(target.metadata ?? {}) };
-          delete meta['qStatus'];
-          delete meta['quarantinedAt'];
+          const meta = { ...(target.metadata ?? {}), qStatus: 'promoted', promotedAt };
           const put = await putStoreRecord(projectRoot, { ...target, metadata: meta });
           if ('error' in put) return { ok: false, promoted, notFound, notQuarantined, error: put.error };
           handled.add(target.id);

package/src/publish-source-scope.ts

@@ -0,0 +1,53 @@
+/**
+ * Что считается ПУБЛИКУЕМЫМ ИСХОДНИКОМ для гейта review-round.
+ *
+ * ЗАЧЕМ ЭТО ВЫНЕСЕНО. Правило `review-round` — единственный жёсткий гейт, спрашивающий, читал ли
+ * изменённый код кто-то, кроме автора. Его сборщик фактов жил одной строкой в `cli.ts` и помечал
+ * изменение исходником только по пути `^(src|lib|bin|skills)/`.
+ *
+ * ИЗМЕРЕНО (запись 5be1bee1, релиз 2026-08-25): пак навыков возит своё содержимое из `templates/`
+ * и `<имя-навыка>/`, поэтому `skills-feature-adr` мог поднять версию, изменить сам конвейер
+ * `templates/.claude/workflows/feature-adr.js` и гейт `feature-adr/scripts/*.mjs` — и правило НЕ
+ * СРАБАТЫВАЛО, а гейт печатал PASS. То есть пакеты, несущие ВЕСЬ конвейер, лежали вне
+ * единственной проверки на прочитанность. Страж, который не может сработать, хуже отсутствующего:
+ * он создаёт видимость защиты.
+ *
+ * ПОЧЕМУ НЕ «ВСЁ, ЧТО ПУБЛИКУЕТСЯ». Комментарий прежней строки защищал осознанное решение:
+ * «SOURCE = то, что ОТГРУЖАЕТСЯ и может ОШИБИТЬСЯ В РАНТАЙМЕ. Тесты, документация и фикстуры
+ * исключены… расширение области — это то, из-за чего жёсткий гейт выключают». Взять список
+ * публикуемых файлов целиком значило бы затянуть в гейт всю документацию пака и вернуть ровно ту
+ * переусердствующую форму, от которой это решение защищает.
+ *
+ * ПОЭТОМУ КРИТЕРИЙ — ИСПОЛНИМОСТЬ, А НЕ РАСПОЛОЖЕНИЕ: файл считается исходником, если он либо
+ * лежит в одном из исторических каталогов, либо ИСПОЛНЯЕТСЯ у потребителя по своему расширению —
+ * где бы он ни лежал. Документация, данные и тесты исключены в обоих случаях.
+ */
+
+/** Каталоги, чьё содержимое отгружается, но исходником для этого гейта не считается. */
+const NOT_SOURCE_DIR = /(^|\/)(test|tests|__tests__|fixtures|__fixtures__|dist|node_modules|coverage)(\/|$)/;
+
+/** Исторические каталоги исходников — сохранены дословно, чтобы поведение не поехало. */
+const LEGACY_SOURCE_DIR = /^(src|lib|bin|skills)\//;
+
+/** Расширения, которые исполняются у потребителя. Разметка и данные сюда НЕ входят. */
+const EXECUTABLE_EXT = /\.(?:[cm]?js|[cm]?ts|sh|bash|py)$/;
+
+/** Расширения, которые исторически исключались даже внутри каталогов исходников. */
+const NEVER_SOURCE_EXT = /\.(?:md|json|txt|yaml|yml)$/;
+
+/**
+ * Изменение этого файла означает, что пакет отгружает НОВЫЙ ИСПОЛНЯЕМЫЙ код?
+ *
+ * @param relPath путь ВНУТРИ каталога пакета (`templates/.claude/workflows/feature-adr.js`),
+ *                а не от корня репозитория
+ */
+export function isShippedSource(relPath: string): boolean {
+  if (typeof relPath !== 'string' || relPath === '') return false;
+  const p = relPath.replace(/\\/g, '/');
+  // Порядок важен: исключение каталога сильнее любого включения, иначе `test/helper.ts`
+  // и пересобранный `dist/index.js` начали бы требовать круг ревью.
+  if (NOT_SOURCE_DIR.test(p)) return false;
+  if (NEVER_SOURCE_EXT.test(p)) return false;
+  if (LEGACY_SOURCE_DIR.test(p)) return true;
+  return EXECUTABLE_EXT.test(p);
+}

package/src/publish.ts

@@ -5,8 +5,9 @@
  * @packageDocumentation
  */
 
+import { maskMarkdown } from './markdown-masker.js';
 import { existsSync, readFileSync, writeFileSync, readdirSync, renameSync } from 'node:fs';
-import { join as pathJoin, relative as pathRelative, resolve as pathResolve } from 'node:path';
+import { join as pathJoin, relative as pathRelative, resolve as pathResolve, isAbsolute as pathIsAbsolute, sep as pathSep } from 'node:path';
 
 import { decidePublishSigning, decidePostSigningVerification } from './publish-signing.js';
 import { join } from 'node:path';
@@ -381,6 +382,24 @@ export function publishArgv(mode: ProvenanceMode, env: NodeJS.ProcessEnv): strin
   return decideProvenance(mode, env).useProvenance ? base + ' --provenance' : base;
 }
 
+/** Match substrings against package identity and path without including the checkout root. */
+export function matchesPublishFilter(
+  pkg: { name: string; dir: string },
+  filter: string,
+  monorepoRoot: string,
+): boolean {
+  const normalizedFilter = filter.replace(/\\/g, '/');
+  const relativeDir = pathRelative(pathResolve(monorepoRoot), pathResolve(pkg.dir));
+  // A foreign path must not reintroduce checkout ancestors into the match.
+  const outsideRoot = relativeDir === '..' || relativeDir.startsWith(`..${pathSep}`) || pathIsAbsolute(relativeDir);
+  // Only Windows spells separators with a backslash. On POSIX a backslash is a legal character
+  // INSIDE a directory name, so rewriting it here would invent a separator the filesystem does
+  // not have and over-select that package — the same class as the root-substring defect.
+  const comparableDir = pathSep === '\\' ? relativeDir.replace(/\\/g, '/') : relativeDir;
+  return pkg.name.includes(normalizedFilter)
+    || (!outsideRoot && comparableDir.includes(normalizedFilter));
+}
+
 /** Discover all publishable @dzhechkov packages. */
 export function discoverPackages(monorepoRoot: string): { name: string; dir: string; version: string }[] {
   const baseDir = join(monorepoRoot, 'packages', '@dzhechkov');
@@ -741,21 +760,20 @@ const REGION_END = /^ {0,3}#{1,2}\s/;
 
 /** Blank out fenced-code lines while PRESERVING line numbering, so a `## Status` or an entry-shaped
  *  line inside an example neither starts nor ends the region (the same fence blindness was found in
- *  another checker on the same day). */
+ *  another checker on the same day).
+ *
+ *  Scoping is DELEGATED to the canonical masker, not re-implemented. The local version this replaces
+ *  tracked only the marker CHARACTER and closed on any run of three or more, ignoring CommonMark's
+ *  rule that a closing fence may not be SHORTER than the opening one. MEASURED 2026-09-20: in a
+ *  README whose entry body quotes a markdown example as ````markdown … ```` , the inner ``` closed
+ *  the outer block early, the quoted `## Status` became visible, the region ENDED there, and the
+ *  body line below — `В `1.2.2` эта строка тела …` — lost protection. That is exactly the
+ *  2026-08-25 incident this function exists to stop: a record's body relabelled forward and shipped
+ *  to npm. `unclosed: 'hide'` preserves the local version's policy — an unclosed opener masks to
+ *  end of file, which is also the CommonMark reading.
+ */
 function maskFences(lines: readonly string[]): string[] {
-  const out: string[] = [];
-  let fence: string | null = null;
-  for (const line of lines) {
-    const open = /^ {0,3}(```+|~~~+)/.exec(line);
-    if (fence === null && open !== null && open[1] !== undefined) { fence = open[1][0] as string; out.push(''); continue; }
-    if (fence !== null) {
-      out.push('');
-      if (new RegExp('^ {0,3}' + fence + '{3,}\\s*$').test(line)) fence = null;
-      continue;
-    }
-    out.push(line);
-  }
-  return out;
+  return String(maskMarkdown(lines.join('\n'), { unclosed: 'hide' })).split('\n');
 }
 
 /**
@@ -883,10 +901,14 @@ export function publishPackages(
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
   });
 
+  if (opts.filter?.some((filter) => filter.length === 0)) {
+    throw new Error('publish: --filter requires non-empty package-name substrings (empty would match ALL packages)');
+  }
+
   const packages = discoverPackages(monorepoRoot);
   const results: PublishResult[] = [];
   const filtered = opts.filter && opts.filter.length > 0
-    ? packages.filter((p) => opts.filter!.some((f) => p.name.includes(f) || p.dir.includes(f)))
+    ? packages.filter((p) => opts.filter!.some((f) => matchesPublishFilter(p, f, monorepoRoot)))
     : packages;
   // Publish dependencies before dependents so pnpm rewrites workspace:* to the
   // freshly-bumped version, never a stale one (the harness-cli@0.3.122 breakage).

package/src/qe-bridge.ts

@@ -50,7 +50,10 @@ export const CLAUDE_BRIDGE_PROMPT_CEILING_CHARS = 200_000;
  */
 export const KNOWN_CLAUDE: Record<string, 1> = { opus: 1, sonnet: 1, haiku: 1 };
 
-/** The terminal verdict grammar: `QE-BRIDGE-SIGNOFF grade=<A-F> findings=<n>`. */
+/** The terminal verdict grammar: `QE-BRIDGE-SIGNOFF grade=<A-F, optionally + or -> findings=<n>`.
+ *  bridge-grade-grammar (ddf83072): a live Sonnet review wrote `grade=B-` in all three channels on
+ *  2026-09-17 06:52 and the whole 145-second review was discarded as no-grade-marker, while every
+ *  other consumer (round close, score, recap) already accepted modifiers. */
 export const BRIDGE_MARKER = 'QE-BRIDGE-SIGNOFF';
 
 /** The fenced block's info string. */
@@ -345,7 +348,7 @@ export function defangSignoffEchoes(text: string): string {
   out = out.replace(/qe-bridge-signoff/gi, '[quoted-fence-label]');
   out = out.split(BRIDGE_EXTRACT_END).join('[quoted-boundary]');
   // Line-anchored verdict lines only — prose such as "upgrade the grade later" is untouched.
-  out = out.replace(/^([ \t>*~-]*)(?:\*{0,2}#{0,4}[ \t]*)?GRADE[ \t]*[:=—–-]?[ \t]*([A-F])\b/gim, '$1[quoted-grade] $2');
+  out = out.replace(/^([ \t>*~-]*)(?:\*{0,2}#{0,4}[ \t]*)?GRADE[ \t]*[:=—–-]?[ \t]*([A-F](?:[+-](?![ \t]*[A-F]\b))?)(?![A-Za-z])/gim, '$1[quoted-grade] $2');
   return out;
 }
 
@@ -410,13 +413,14 @@ export function buildBridgePrompt(
     'happen in this environment.',
     '',
     'Output format — ALL THREE parts are required, in this order, at the END of your answer:',
-    '  (a) your review prose, containing exactly ONE line that reads:  GRADE: <A-F>',
+    '  (a) your review prose, containing exactly ONE line that reads:  GRADE: ' + GRADE_PLACEHOLDER,
     '  (b) a fenced code block labelled ' + BRIDGE_FENCE_LABEL + ' whose body is JSON:',
-    '      {"grade":"<A-F>","findings":[{"n":1,"severity":"major","title":"…","file":"path","line":12}]}',
+    '      {"grade":"' + GRADE_PLACEHOLDER + '","findings":[{"n":1,"severity":"major","title":"…","file":"path","line":12}]}',
     '      A genuinely clean review writes "findings": [] — but it must WRITE it.',
-    '  (c) a final line, on its own:  ' + BRIDGE_MARKER + ' grade=<A-F> findings=<n>',
-    'The grade in all three places must be the SAME letter — ONE capital letter A, B, C, D, E or F,',
-    'with NO + or - suffix (write B, never B- or B+; a modifier makes the whole answer unparseable).',
+    '  (c) a final line, on its own:  ' + BRIDGE_MARKER + ' grade=' + GRADE_PLACEHOLDER + ' findings=<n>',
+    'The grade in all three places must be the SAME grade, character for character — one capital',
+    'letter A, B, C, D, E or F, optionally followed by + or -.',
+    'A modifier is fine (B+, B, B-) and is carried through verbatim; what breaks the parse is a RANGE (A-F), prose in place of the letter, or two channels disagreeing.',
     'Anything else is discarded as a failed call — an unparseable answer is treated as no review at',
     'all, never as a passing one.',
     '',
@@ -447,7 +451,14 @@ export function buildBridgePrompt(
 
 /** Line-anchored marker. Leading quote/list decoration is allowed on purpose: a planted marker
  * SHOULD match the grammar — and then lose to the LAST one. Anchoring is the defence, not evasion. */
-const MARKER_LINE = /^[ \t>*~-]*QE-BRIDGE-SIGNOFF[ \t]+grade=([A-F])[ \t]+findings=(\d{1,6})[ \t]*$/gim;
+/** The grade placeholder the reviewer prompt shows in ALL THREE output slots. It lives in one
+ * constant because round-2 review (2026-09-18, HIGH #1 partial) found the opposite: the marker slot
+ * invited a modifier while the prose and JSON slots still read `<A-F>` — which is also the exact
+ * spelling of the RANGE the parser refuses, so the template taught the reviewer to write the one
+ * thing that breaks the parse. One spelling, three slots, no drift. */
+const GRADE_PLACEHOLDER = '<A-F, optionally with + or ->';
+
+const MARKER_LINE = /^[ \t>*~-]*QE-BRIDGE-SIGNOFF[ \t]+grade=([A-F][+-]?)[ \t]+findings=(\d{1,6})[ \t]*$/gim;
 
 /** Fenced `qe-bridge-signoff` block. */
 const SIGNOFF_FENCE = /^[ \t]*(?:`{3,}|~{3,})[ \t]*qe-bridge-signoff[ \t]*\r?\n([\s\S]*?)^[ \t]*(?:`{3,}|~{3,})[ \t]*$/gim;
@@ -538,7 +549,7 @@ export function parseBridgeOutput(
   // channel 1 — the LAST terminal marker line, which must be the FINAL content of the answer
   const marker = lastMatch(MARKER_LINE, text);
   if (marker === null) {
-    return fail('no-grade-marker', 'no `' + BRIDGE_MARKER + ' grade=<A-F> findings=<n>` line anywhere in ' + text.length + ' chars of reviewer output — text without a verdict marker is not a verdict');
+    return fail('no-grade-marker', 'no `' + BRIDGE_MARKER + ' grade=<A-F, optionally with + or -> findings=<n>` line anywhere in ' + text.length + ' chars of reviewer output — text without a verdict marker is not a verdict');
   }
   const markerGrade = String(marker[1]).toUpperCase();
   const markerCount = Number(marker[2]);
@@ -576,8 +587,8 @@ export function parseBridgeOutput(
   }
   const obj = parsedJson as Record<string, unknown>;
   const jsonGradeRaw = obj['grade'];
-  if (typeof jsonGradeRaw !== 'string' || !/^[A-Fa-f]$/.test(jsonGradeRaw.trim())) {
-    return fail('no-signoff-json', 'the fenced JSON block names no `grade` letter A-F (saw ' + JSON.stringify(jsonGradeRaw) + ')');
+  if (typeof jsonGradeRaw !== 'string' || !/^[A-Fa-f][+-]?$/.test(jsonGradeRaw.trim())) {
+    return fail('no-signoff-json', 'the fenced JSON block names no `grade` letter A-F (optionally with + or -) (saw ' + JSON.stringify(jsonGradeRaw) + ')');
   }
   const jsonGrade = jsonGradeRaw.trim().toUpperCase();
   const validated = validateFindings(obj['findings']);