@dzhechkov/harness-core 0.8.37 → 0.8.39

package/src/feature-adr-checkpoints.ts

@@ -267,11 +267,11 @@ export function decideCheckpointResume(opts: {
 /** Serialize one checkpoint line, or null when the result is null/oversize/unserializable —
  * the caller logs the skip loudly; a missing checkpoint only costs a re-run, never corrupts.
  * A null result is never persisted (Codex QE #8: it would later parse as a resumable entry). */
-export function serializeCheckpoint(stage: string, inputHash: string, result: unknown): string | null {
+export function serializeCheckpoint(stage: string, inputHash: string, result: unknown, ts?: string): string | null {
   if (result === null || result === undefined) return null;
   let line: string;
   try {
-    line = JSON.stringify({ stage, inputHash, result });
+    line = JSON.stringify({ stage, inputHash, result, ...(ts === undefined ? {} : { ts }) });
   } catch {
     return null;
   }
@@ -289,6 +289,9 @@ export interface ParsedCheckpointRead {
  * command's stdout. */
 export const CHECKPOINT_LS_SENTINEL = '---FA-CKPT-LS---';
 
+/** A writer-produced UTC instant. A malformed supplied value is unmeasured, not a bad record. */
+const CHECKPOINT_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+
 /** Parse the read-back agent's stdout: JSONL entries (LAST occurrence of a stage wins — a re-run
  * overwrites by append), then the sentinel ON ITS OWN LINE, then one artifact path per line
  * (relative to the feature dir). The sentinel match is LINE-ANCHORED: JSON.stringify never emits
@@ -308,7 +311,11 @@ export function parseCheckpointRead(text: string): ParsedCheckpointRead {
     try {
       const e = JSON.parse(t) as CheckpointEntry;
       if (e && typeof e === 'object' && typeof e.stage === 'string' && typeof e.inputHash === 'string' && 'result' in e && e.result !== null && e.result !== undefined) {
-        out.entries[e.stage] = e;
+        const { ts, ...entry } = e;
+        // Narrow to `string` before the spread: under exactOptionalPropertyTypes an optional
+        // `ts?: string` refuses `string | undefined`, and an unmeasured record must carry NO key
+        // rather than an explicit undefined.
+        out.entries[e.stage] = typeof ts === 'string' && CHECKPOINT_TIMESTAMP.test(ts) ? { ...entry, ts } : entry;
       } else {
         // last-wins holds for BAD records too: a stage-identifiable null/invalid record ERASES the
         // older entry for that stage instead of silently reactivating it (Codex QE r2 #6).
@@ -345,11 +352,19 @@ export function checkpointReadCmd(fdirAbs: string): string {
 
 /** The one Bash command the write agent runs: mkdir the state dir, then append ONE line. The line
  * is single-quote-escaped as a whole — JSON.stringify output never contains literal newlines, so
- * printf '%s\n' emits exactly one record. */
+ * printf '%s\n' emits exactly one record.
+ *
+ * The record's `ts` is stamped SHELL-SIDE (`date -u`), the same idiom the decision-recall ledger
+ * uses, because the workflow sandbox forbids `Date` and this function must stay pure. A line that
+ * is not a JSON object falls back to the plain append: an unstamped record beats a lost one, and
+ * the return type stays `string` so no caller grows a new failure path. */
 export function checkpointAppendCmd(fdirAbs: string, line: string): string {
   const dir = shellQuote(fdirAbs + '/.fa-state');
   const file = shellQuote(fdirAbs + '/.fa-state/checkpoints.jsonl');
-  return 'mkdir -p ' + dir + " && printf '%s\\n' " + shellQuote(line) + ' >> ' + file;
+  const plain = 'mkdir -p ' + dir + " && printf '%s\\n' " + shellQuote(line) + ' >> ' + file;
+  if (typeof line !== 'string' || !line.startsWith('{')) return plain;
+  return 'ts=$(date -u +%Y-%m-%dT%H:%M:%SZ); mkdir -p ' + dir
+    + ' && { printf \'{"ts":"%s",\' "$ts"; printf \'%s\\n\' ' + shellQuote(line.slice(1)) + '; } >> ' + file;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────

package/src/feature-adr-envelope.ts

@@ -34,6 +34,18 @@ export interface ExperimentEnvelopeChosen {
    * (usage-override, session-inherited fallback) is recorded HERE explicitly — arms stay the set that
    * was actually offered; the winner is never appended to them after the fact. */
   readonly overrides?: Readonly<Record<string, string>>;
+  /**
+   * ablation-c-start (ADR-001, T3; fix-round-1 BLOCKER #2): the pre-registered ablation-C arm
+   * (`direct` | `reference`) for THIS run, filled only when `args.experiment`/`args.taskId` were
+   * given AND the workflow successfully RESOLVED an existing assignment for that task via
+   * `dz experiment resolve` — never taken from a caller-supplied arm option (that was the BLOCKER
+   * fix-round-1 found: a caller could set the arm to anything, with zero journal entry). Deliberately
+   * a SEPARATE field from `mode` — `mode` already means "same-family vs cross-family reviewer" (a
+   * different axis) — so setting `qeMode` never redefines what `mode` has always meant. Absent (not
+   * `null`) when no arm was resolved, so `JSON.stringify` drops the key and an unflagged run's
+   * envelope stays byte-identical to before this feature (NFR-2).
+   */
+  readonly qeMode?: string;
 }
 
 export interface ExperimentEnvelopePolicy {
@@ -104,7 +116,12 @@ export function buildExperimentEnvelope(input: BuildExperimentEnvelopeInput): Ex
     treeSha: input.treeSha,
     treeShaReason: input.treeSha === null ? (input.treeShaReason ?? 'unavailable') : null,
     arms: { mode: [...input.arms.mode], stages: { ...input.arms.stages } },
-    chosen: { mode: input.chosen.mode, stages: { ...input.chosen.stages }, overrides: { ...(input.chosen.overrides ?? {}) } },
+    chosen: {
+      mode: input.chosen.mode,
+      stages: { ...input.chosen.stages },
+      overrides: { ...(input.chosen.overrides ?? {}) },
+      ...(input.chosen.qeMode !== undefined ? { qeMode: input.chosen.qeMode } : {}),
+    },
     policy: { ...input.policy },
     evaluator: { ...input.evaluator },
   };
@@ -217,6 +234,12 @@ export function validateExperimentEnvelope(value: unknown): { ok: true } | { ok:
       return { ok: false, reason: `chosen.stages.${stage}: "${String(spec)}" is not a member of arms.stages.${stage} (${offered.join('|')}) and not declared in chosen.overrides` };
     }
   }
+  // ablation-c-start (ADR-001, T3): qeMode is OPTIONAL — absent on every run this feature does not
+  // touch — but when present must be a non-empty string, same shape rule as every other envelope
+  // field (never a silently-accepted empty label).
+  if (chosen.qeMode !== undefined && !isNonEmptyString(chosen.qeMode)) {
+    return { ok: false, reason: 'chosen.qeMode: expected a non-empty string when present' };
+  }
 
   if (!isPlainObject(v.policy)) return { ok: false, reason: 'policy: expected an object' };
   const policy = v.policy;

package/src/feature-adr-routing.ts

@@ -1675,6 +1675,10 @@ export function codexDispatchMode(stage: string): CodexDispatch {
  * SCOPE — `codexReviewCommand` (the diff defines it) and `scopedQePrompt` ("read ONLY these files").
  * This constant is retained as a sanity bound on an absurd payload, and is no longer claimed as the
  * thing that prevents a stall.
+ *
+ * THIS IS THE ONLY DEFINITION. `workflow-run-dispatch.ts` re-exports it rather than declaring its
+ * own twin (it used to, and nothing compared the two). The direction is forced: this module is
+ * lifted verbatim into the workflow sandbox by `scripts/gen-loop-blobs.mjs`, so it may not import.
  */
 export const CODEX_EXEC_PROMPT_CEILING_CHARS = 24_000;
 
@@ -2190,7 +2194,11 @@ export function gradeFromReviewFindings(findings: readonly CodexQeFinding[] | nu
  * The LOCKED decline taxonomy. A `kind` outside this set is a bug, not a new case — which is why
  * {@link codexQeDeclineReason} throws on one rather than rendering something plausible.
  */
-export const CODEX_QE_DECLINE_KINDS: readonly string[] = ['timeout', 'no-verdict', 'tool-error', 'unusable-output', 'unavailable', 'over-ceiling', 'wrong-tree'];
+// 'scope-not-established' and 'base-ref-not-established' joined the set 2026-09-17 (feature
+// codex-review-scope + its fix-round-1, finding #7): the workflow's two inline mirrors grew both
+// kinds; this export copy diverged behind them until now. Appended, never reordered — the SAME
+// order the two workflow-twin mirrors carry.
+export const CODEX_QE_DECLINE_KINDS: readonly string[] = ['timeout', 'no-verdict', 'tool-error', 'unusable-output', 'unavailable', 'over-ceiling', 'wrong-tree', 'scope-not-established', 'base-ref-not-established'];
 
 export interface ClassifyCodexQeInput {
   readonly exit?: number | null;
@@ -2350,6 +2358,12 @@ export function codexQeDeclineReason(kind: string | null | undefined, detail?: C
   if (canonical === 'over-ceiling') {
     return 'prompt is ' + chars + ' chars / unscoped — refused before dispatch';
   }
+  if (canonical === 'scope-not-established') {
+    return 'review scope NOT ESTABLISHED for uncommitted QE — ' + (d.reason === undefined || d.reason === null || String(d.reason) === '' ? 'the change set could not be measured' : String(d.reason)) + ' — refusing to fall back to --uncommitted on the shared tree';
+  }
+  if (canonical === 'base-ref-not-established') {
+    return 'base ref for the isolated review scope NOT ESTABLISHED — ' + (d.reason === undefined || d.reason === null || String(d.reason) === '' ? 'the base-ref probe failed or was unparseable' : String(d.reason)) + ' — refusing to silently fall back to HEAD';
+  }
   throw new Error('codexQeDeclineReason: unknown kind ' + k);
 }
 

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,10 +509,12 @@ export {
 } from './amendment-trace.js';
 export {
   RECORD_MAX_LINE_CHARS,
+  INCOMPLETE_REASON_CODES,
   decideRecordWrite,
   decideReadBack,
   recordVerdictLine,
   parseModelSpec,
+  applyTaskId,
 } from './run-records.js';
 export {
   ENVELOPE_SCHEMA,
@@ -527,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 } 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.
@@ -754,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';
@@ -1147,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.
@@ -1317,8 +1332,12 @@ export * from './run-registry.js';
 
 export { JOURNAL_KINDS, formatLine, parseLine, selectWindow, appendWitnessed } from './journal.js';
 export type { JournalKind, JournalEvent, JournalLine, JournalIo } from './journal.js';
-export { openRound, closeRound, listRounds, validateClosedRoundLedgerRow } from './round.js';
+export { openRound, closeRound, listRounds, validateClosedRoundLedgerRow, readOpenRoundTaskId } from './round.js';
 export type { RoundState, RoundExecState, RoundLedgerRow, RoundReviewSidecar } from './round.js';
+
+// review-cost-ledger T1/FR-1 (ADR-001 п.1): the pure qe-bridge stdout cost parser.
+export { parseQeBridgeStdoutCost } from './review-cost.js';
+export type { QeBridgeCost, QeBridgeCostTokens } from './review-cost.js';
 export { parseCodexTokens, classifyRoundExecOutcome, buildRoundExecRow } from './round-exec.js';
 export type { RoundExecOutcome, RoundExecLedgerRow } from './round-exec.js';
 export * from './run-cleanup.js';

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);
+}