peaks-loop 4.0.53 → 4.1.0

package/dist/services/evolution/evolution-types.js

@@ -1,21 +1,6 @@
-import { z } from "zod";
-/* ---------------------------------------------------------------------- */
-/* PRD-002b slice 2 — schema-limit constants extracted from inline         */
-/* `.max(N)` calls so the no-magic-numbers rule stops flagging the        */
-/* constraint values. Names describe the field, not just the number.     */
-/* ---------------------------------------------------------------------- */
-const EVO_TARGET_RELEASE_ID_MAX = 256;
-const EVO_OPTIMIZATION_DIMENSION_MAX = 200;
-const EVO_AUTHOR_ID_MAX = 200;
-const EVO_RISK_TAG_MAX = 200;
-const EVO_RED_LINE_MAX = 2000;
-const EVO_SOURCE_TRACE_MAX = 256;
-const EVO_EVAL_ID_MAX = 128;
-const EVO_DIMENSION_ITEM_MAX = 200;
-const EVO_SCORING_SCALE_MAX = 10;
-const EVO_REFUTE_PARAGRAPH_MAX = 8000;
-const EVO_SKEPTIC_RISK_MAX = 2000;
-const EVO_POINTER_MAX = 512;
+import { z } from 'zod';
+import { EVO_AUTHOR_ID_MAX, EVO_DIMENSION_ITEM_MAX, EVO_EVAL_ID_MAX, EVO_OPTIMIZATION_DIMENSION_MAX, EVO_POINTER_MAX, EVO_RED_LINE_MAX, EVO_SCORING_SCALE_MAX, EVO_SOURCE_TRACE_MAX, EVO_TARGET_RELEASE_ID_MAX, IndependentEvaluatorResultSchema, RegressionSkepticResultSchema } from './evolution-constraints.js';
+export { IndependentEvaluatorResultSchema, RegressionSkepticResultSchema } from './evolution-constraints.js';
 /**
  * EvolutionEvaluation — spec §4.4 / §6.
  *
@@ -43,32 +28,22 @@ const EVO_POINTER_MAX = 512;
 /* ---------------------------------------------------------------------- */
 /* Target kind — §4.4                                                      */
 /* ---------------------------------------------------------------------- */
-export const EvolutionTargetKindSchema = z.enum([
-    "loop",
-    "bee",
-    "policy",
-    "gate",
-    "evaluator",
-]);
+export const EvolutionTargetKindSchema = z.enum(['loop', 'bee', 'policy', 'gate', 'evaluator']);
 export const EVOLUTION_TARGET_KINDS = [
-    "loop",
-    "bee",
-    "policy",
-    "gate",
-    "evaluator",
+    'loop',
+    'bee',
+    'policy',
+    'gate',
+    'evaluator'
 ];
 /* ---------------------------------------------------------------------- */
 /* Verdict — §4.4                                                          */
 /* ---------------------------------------------------------------------- */
-export const EvolutionVerdictSchema = z.enum([
-    "keep",
-    "revert",
-    "needs-user-decision",
-]);
+export const EvolutionVerdictSchema = z.enum(['keep', 'revert', 'needs-user-decision']);
 export const EVOLUTION_VERDICTS = [
-    "keep",
-    "revert",
-    "needs-user-decision",
+    'keep',
+    'revert',
+    'needs-user-decision'
 ];
 /* ---------------------------------------------------------------------- */
 /* Proposal — the create payload. AC-8 enforces single object / dim.     */
@@ -102,31 +77,27 @@ export const EvolutionProposalInputSchema = z.object({
     optimization_dimension: z
         .string()
         .trim()
-        .min(1, "optimization_dimension is required (single dimension per round)")
+        .min(1, 'optimization_dimension is required (single dimension per round)')
         .max(EVO_OPTIMIZATION_DIMENSION_MAX),
     before_snapshot: z.record(z.string(), z.unknown()).default({}),
     after_snapshot: z.record(z.string(), z.unknown()).default({}),
     diff: z.record(z.string(), z.unknown()).default({}),
     before_score: z
         .number()
-        .finite("before_score must be a finite number")
-        .min(0, "before_score must be >= 0")
-        .max(EVO_SCORING_SCALE_MAX, "before_score must be <= 10"),
+        .finite('before_score must be a finite number')
+        .min(0, 'before_score must be >= 0')
+        .max(EVO_SCORING_SCALE_MAX, 'before_score must be <= 10'),
     after_score: z
         .number()
-        .finite("after_score must be a finite number")
-        .min(0, "after_score must be >= 0")
-        .max(EVO_SCORING_SCALE_MAX, "after_score must be <= 10"),
+        .finite('after_score must be a finite number')
+        .min(0, 'after_score must be >= 0')
+        .max(EVO_SCORING_SCALE_MAX, 'after_score must be <= 10'),
     score_delta_min: z
         .number()
-        .finite("score_delta_min must be a finite number")
-        .min(0, "score_delta_min must be >= 0")
+        .finite('score_delta_min must be a finite number')
+        .min(0, 'score_delta_min must be >= 0')
         .default(1.0),
-    author_id: z
-        .string()
-        .trim()
-        .min(1, "author_id is required")
-        .max(EVO_AUTHOR_ID_MAX),
+    author_id: z.string().trim().min(1, 'author_id is required').max(EVO_AUTHOR_ID_MAX),
     /**
      * The LLM-side marker that this proposal targets a SINGLE object
      * (AC-8). Multi-object proposals must be split into multiple
@@ -134,7 +105,7 @@ export const EvolutionProposalInputSchema = z.object({
      * `single_object !== true`.
      */
     single_object: z.literal(true, {
-        error: () => "single_object must be true (multi-object proposals must be split into multiple rounds)",
+        error: () => 'single_object must be true (multi-object proposals must be split into multiple rounds)'
     }),
     /**
      * The LLM-side marker that this proposal targets a SINGLE
@@ -142,11 +113,11 @@ export const EvolutionProposalInputSchema = z.object({
      * proposals with `single_optimization_dimension !== true`.
      */
     single_optimization_dimension: z.literal(true, {
-        error: () => "single_optimization_dimension must be true (multi-dimension proposals must be split into multiple rounds)",
+        error: () => 'single_optimization_dimension must be true (multi-dimension proposals must be split into multiple rounds)'
     }),
     rubric: z.record(z.string(), z.unknown()).default({}),
     red_lines: z.array(z.string().min(1).max(EVO_RED_LINE_MAX)).default([]),
-    source_traces: z.array(z.string().min(1).max(EVO_SOURCE_TRACE_MAX)).default([]),
+    source_traces: z.array(z.string().min(1).max(EVO_SOURCE_TRACE_MAX)).default([])
 });
 /**
  * The PERSISTED proposal shape — adds `dimensions` (a length-1
@@ -160,48 +131,19 @@ export const EvolutionProposalSchema = EvolutionProposalInputSchema.extend({
         .min(1)
         .max(EVO_EVAL_ID_MAX)
         .regex(/^eval-[0-9a-f-]{8,}$/, {
-        message: "id must start with 'eval-' followed by a hex/UUID-ish suffix",
+        message: "id must start with 'eval-' followed by a hex/UUID-ish suffix"
     }),
     dimensions: z
         .array(z.string().min(1).max(EVO_DIMENSION_ITEM_MAX))
-        .length(1, "dimensions must be exactly length 1 (AC-8)"),
+        .length(1, 'dimensions must be exactly length 1 (AC-8)'),
     target_count: z.literal(1),
-    schema_version: z
-        .literal("peaks.evolution/1")
-        .default("peaks.evolution/1"),
+    schema_version: z.literal('peaks.evolution/1').default('peaks.evolution/1'),
     created_at: z.string().datetime(),
-    score_delta: z.number().finite(),
+    score_delta: z.number().finite()
 });
 /* ---------------------------------------------------------------------- */
 /* Evaluation — post-skeptic aggregation.                                   */
 /* ---------------------------------------------------------------------- */
-/**
- * The independent evaluator's verdict. AC-12 / AC-13: the evaluator
- * is a SEPARATE sub-agent that only sees the evaluation package.
- */
-export const IndependentEvaluatorResultSchema = z.object({
-    score: z
-        .number()
-        .finite()
-        .min(0, "evaluator score must be >= 0")
-        .max(EVO_SCORING_SCALE_MAX, "evaluator score must be <= 10"),
-    riskTags: z.array(z.string().min(1).max(EVO_RISK_TAG_MAX)).default([]),
-    refuteParagraph: z
-        .string()
-        .trim()
-        .min(1, "refuteParagraph is required (one paragraph of independent-context rebuttal)")
-        .max(EVO_REFUTE_PARAGRAPH_MAX),
-});
-/**
- * The regression skeptic's verdict. AC-14: a separate sub-agent
- * that attempts to refute the proposal.
- */
-export const RegressionSkepticResultSchema = z.object({
-    driftRisks: z.array(z.string().min(1).max(EVO_SKEPTIC_RISK_MAX)).default([]),
-    overfitRisks: z.array(z.string().min(1).max(EVO_SKEPTIC_RISK_MAX)).default([]),
-    safetyRegressionRisks: z.array(z.string().min(1).max(EVO_SKEPTIC_RISK_MAX)).default([]),
-    blocker: z.string().trim().min(1).max(EVO_SKEPTIC_RISK_MAX).optional(),
-});
 /**
  * The full evolution evaluation row as persisted. Differs from the
  * proposal in that it carries the evaluator + skeptic verdicts, the
@@ -222,18 +164,18 @@ export const EvolutionEvaluationInputSchema = z.object({
         .min(1)
         .max(EVO_EVAL_ID_MAX)
         .regex(/^eval-[0-9a-f-]{8,}$/, {
-        message: "id must start with 'eval-' followed by a hex/UUID-ish suffix",
+        message: "id must start with 'eval-' followed by a hex/UUID-ish suffix"
     }),
     proposal: EvolutionProposalSchema,
     evaluator_id: z
         .string()
         .trim()
-        .min(1, "evaluator_id is required (independent scorer; AC-12)")
+        .min(1, 'evaluator_id is required (independent scorer; AC-12)')
         .max(EVO_AUTHOR_ID_MAX),
     skeptic_id: z
         .string()
         .trim()
-        .min(1, "skeptic_id is required (regression skeptic; AC-14)")
+        .min(1, 'skeptic_id is required (regression skeptic; AC-14)')
         .max(EVO_AUTHOR_ID_MAX),
     evaluator_result: IndependentEvaluatorResultSchema,
     skeptic_result: RegressionSkepticResultSchema,
@@ -241,26 +183,24 @@ export const EvolutionEvaluationInputSchema = z.object({
     user_confirmation_pointer: z
         .string()
         .trim()
-        .min(1, "user_confirmation_pointer is required (AC-15)")
+        .min(1, 'user_confirmation_pointer is required (AC-15)')
         .max(EVO_POINTER_MAX)
         .optional(),
     brief_pointer: z
         .string()
         .trim()
-        .min(1, "brief_pointer is required (spec §4.4)")
+        .min(1, 'brief_pointer is required (spec §4.4)')
         .max(EVO_POINTER_MAX)
         .optional(),
-    schema_version: z
-        .literal("peaks.evolution/1")
-        .default("peaks.evolution/1"),
-    created_at: z.string().datetime(),
+    schema_version: z.literal('peaks.evolution/1').default('peaks.evolution/1'),
+    created_at: z.string().datetime()
 });
 /**
  * The PERSISTED evolution evaluation row. Differs from the input
  * in that `score_delta` is computed and stored.
  */
 export const EvolutionEvaluationSchema = EvolutionEvaluationInputSchema.extend({
-    score_delta: z.number().finite(),
+    score_delta: z.number().finite()
 });
 /**
  * Default for `score_delta_min` per spec §6.1 #5.
@@ -285,9 +225,9 @@ export function safeParseEvolutionEvaluation(input) {
     return {
         ok: false,
         findings: r.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
-        })),
+            path: i.path.join('.'),
+            message: i.message
+        }))
     };
 }
 /**

package/dist/services/evolution/independent-evaluator-runner.d.ts

@@ -1,4 +1,4 @@
-import type { EvolutionProposal, IndependentEvaluatorResult } from "./evolution-types.js";
+import type { EvolutionProposal, IndependentEvaluatorResult } from './evolution-types.js';
 /**
  * IndependentEvaluatorRunner — spec §6.2 / AC-12 / AC-13.
  *
@@ -39,8 +39,8 @@ import type { EvolutionProposal, IndependentEvaluatorResult } from "./evolution-
  *   }
  */
 export interface EvaluationPackage {
-    readonly target_kind: EvolutionProposal["target_kind"];
-    readonly target_release_id: EvolutionProposal["target_release_id"];
+    readonly target_kind: EvolutionProposal['target_kind'];
+    readonly target_release_id: EvolutionProposal['target_release_id'];
     readonly optimization_dimension: string;
     readonly before_snapshot: Readonly<Record<string, unknown>>;
     readonly after_snapshot: Readonly<Record<string, unknown>>;

package/dist/services/evolution/independent-evaluator-runner.js

@@ -14,7 +14,7 @@ export function buildEvaluationPackage(proposal) {
         diff: Object.freeze({ ...proposal.diff }),
         rubric: Object.freeze({ ...proposal.rubric }),
         red_lines: Object.freeze([...proposal.red_lines]),
-        source_traces: Object.freeze([...proposal.source_traces]),
+        source_traces: Object.freeze([...proposal.source_traces])
     });
 }
 /**
@@ -26,16 +26,16 @@ export function buildEvaluationPackage(proposal) {
 export function buildEvaluatorPrompt(pkg) {
     // Stringify in a deterministic order for test stability.
     return [
-        "You are the INDEPENDENT scorer for a Darwin-style ratchet.",
-        "You see ONLY the evaluation package below.",
+        'You are the INDEPENDENT scorer for a Darwin-style ratchet.',
+        'You see ONLY the evaluation package below.',
         "You MUST NOT see the author, the author's reasoning, or any",
         "framing of the proposal as a 'rec' (with -o-m-m-e-n-d appended).",
-        "",
-        "Rule (AC-13): produce a score in [0, 10] for the AFTER state on",
-        "the declared single optimization dimension. The AUTHOR claims",
-        "the after_score below; you MUST refute if you disagree and",
-        "produce a refute paragraph of independent-context evidence.",
-        "",
+        '',
+        'Rule (AC-13): produce a score in [0, 10] for the AFTER state on',
+        'the declared single optimization dimension. The AUTHOR claims',
+        'the after_score below; you MUST refute if you disagree and',
+        'produce a refute paragraph of independent-context evidence.',
+        '',
         `target_kind: ${pkg.target_kind}`,
         `target_release_id: ${pkg.target_release_id}`,
         `optimization_dimension: ${pkg.optimization_dimension}`,
@@ -44,8 +44,8 @@ export function buildEvaluatorPrompt(pkg) {
         `diff: ${JSON.stringify(pkg.diff)}`,
         `rubric: ${JSON.stringify(pkg.rubric)}`,
         `red_lines: ${JSON.stringify(pkg.red_lines)}`,
-        `source_traces: ${JSON.stringify(pkg.source_traces)}`,
-    ].join("\n");
+        `source_traces: ${JSON.stringify(pkg.source_traces)}`
+    ].join('\n');
 }
 /**
  * Default LLM call: deterministic, no LLM dependency. Produces a
@@ -61,10 +61,8 @@ export const deterministicInvokeLlm = async (pkg) => {
     // ONLY IF it is present as a numeric field named `after_score`.
     // Otherwise default to 5.0 (mid-scale). The scorer MAY disagree
     // by emitting riskTags + a refuteParagraph.
-    const afterScoreRaw = pkg.after_snapshot["after_score"];
-    const authorClaim = typeof afterScoreRaw === "number" && Number.isFinite(afterScoreRaw)
-        ? afterScoreRaw
-        : 5.0;
+    const afterScoreRaw = pkg.after_snapshot['after_score'];
+    const authorClaim = typeof afterScoreRaw === 'number' && Number.isFinite(afterScoreRaw) ? afterScoreRaw : 5.0;
     // Deterministic adjustment: -0.5 if the diff has 0 changes (no-op
     // change), -0.1 per red_line that the author flagged. This is a
     // placeholder; the real LLM replaces it in M5.
@@ -74,17 +72,17 @@ export const deterministicInvokeLlm = async (pkg) => {
     score = Math.max(0, score - 0.1 * pkg.red_lines.length);
     const riskTags = [];
     if (diffKeys.length === 0)
-        riskTags.push("noop_change");
-    if (dim === "full_rewrite")
-        riskTags.push("full_rewrite_blessing_required");
+        riskTags.push('noop_change');
+    if (dim === 'full_rewrite')
+        riskTags.push('full_rewrite_blessing_required');
     if (pkg.red_lines.length > 0)
-        riskTags.push("red_line_pressure");
+        riskTags.push('red_line_pressure');
     const refuteParagraph = [
         `Independent-context scorer reports on dimension '${pkg.optimization_dimension}':`,
         `observed ${diffKeys.length} diff key(s), ${pkg.red_lines.length} red-line(s), ${pkg.source_traces.length} source trace(s).`,
         `Author claim was ${authorClaim.toFixed(2)}; scorer emits ${score.toFixed(2)}.`,
-        `Risk tags: ${riskTags.length === 0 ? "(none)" : riskTags.join(", ")}.`,
-    ].join(" ");
+        `Risk tags: ${riskTags.length === 0 ? '(none)' : riskTags.join(', ')}.`
+    ].join(' ');
     return { score, riskTags, refuteParagraph };
 };
 /**
@@ -101,6 +99,6 @@ export async function runIndependentEvaluator(proposal, invokeLlm = deterministi
     return {
         score: Math.max(0, Math.min(10, score)),
         riskTags,
-        refuteParagraph,
+        refuteParagraph
     };
 }

package/dist/services/evolution/regression-skeptic-runner.d.ts

@@ -1,5 +1,5 @@
-import type { EvolutionProposal, EvolutionVerdict, IndependentEvaluatorResult, RegressionSkepticResult } from "./evolution-types.js";
-import { type EvaluationPackage } from "./independent-evaluator-runner.js";
+import type { EvolutionProposal, EvolutionVerdict, IndependentEvaluatorResult, RegressionSkepticResult } from './evolution-types.js';
+import { type EvaluationPackage } from './independent-evaluator-runner.js';
 /**
  * RegressionSkepticRunner — spec §6.1 #4 / AC-14.
  *

package/dist/services/evolution/regression-skeptic-runner.js

@@ -1,4 +1,4 @@
-import { buildEvaluationPackage, } from "./independent-evaluator-runner.js";
+import { buildEvaluationPackage } from './independent-evaluator-runner.js';
 /**
  * Build the prompt handed to the skeptic LLM. By construction
  * this contains the SAME evaluation package the scorer saw
@@ -7,19 +7,19 @@ import { buildEvaluationPackage, } from "./independent-evaluator-runner.js";
  */
 export function buildSkepticPrompt(pkg, verdict, evaluatorResult) {
     return [
-        "You are the REGRESSION SKEPTIC for a Darwin-style ratchet.",
-        "Your job is to REFUTE the proposal. Find drift, overfit,",
-        "and safety regression risks. A `blocker` you emit is a HARD",
-        "REVERT signal: the proposal cannot be promoted while any",
-        "blocker stands (AC-14).",
-        "",
-        "Inputs:",
+        'You are the REGRESSION SKEPTIC for a Darwin-style ratchet.',
+        'Your job is to REFUTE the proposal. Find drift, overfit,',
+        'and safety regression risks. A `blocker` you emit is a HARD',
+        'REVERT signal: the proposal cannot be promoted while any',
+        'blocker stands (AC-14).',
+        '',
+        'Inputs:',
         `verdict (post-evaluator): ${verdict}`,
         `evaluator_score: ${evaluatorResult.score.toFixed(2)}`,
         `evaluator_riskTags: ${JSON.stringify(evaluatorResult.riskTags)}`,
         `evaluator_refuteParagraph: ${evaluatorResult.refuteParagraph}`,
-        "",
-        "Evaluation package:",
+        '',
+        'Evaluation package:',
         `target_kind: ${pkg.target_kind}`,
         `target_release_id: ${pkg.target_release_id}`,
         `optimization_dimension: ${pkg.optimization_dimension}`,
@@ -28,8 +28,8 @@ export function buildSkepticPrompt(pkg, verdict, evaluatorResult) {
         `diff: ${JSON.stringify(pkg.diff)}`,
         `rubric: ${JSON.stringify(pkg.rubric)}`,
         `red_lines: ${JSON.stringify(pkg.red_lines)}`,
-        `source_traces: ${JSON.stringify(pkg.source_traces)}`,
-    ].join("\n");
+        `source_traces: ${JSON.stringify(pkg.source_traces)}`
+    ].join('\n');
 }
 /**
  * Default skeptic LLM call: deterministic, no LLM dependency.
@@ -57,24 +57,24 @@ export const deterministicInvokeSkepticLlm = async (pkg, prompt) => {
     // did not pass through. The deterministic stub treats any
     // package red_line as a drift signal.
     if (pkg.red_lines.length > 0) {
-        driftRisks.push(`red_line(s) present but not addressed: ${pkg.red_lines.join("; ")}`);
+        driftRisks.push(`red_line(s) present but not addressed: ${pkg.red_lines.join('; ')}`);
     }
     // (2) Overfit: a diff with `prompt_template` or `gates_weakening`
     // keys without a rubric entry is a prompt-inflation / gate-
     // weakening signal.
     const diffKeys = Object.keys(pkg.diff);
-    const hasPromptTemplateChange = diffKeys.includes("prompt_template") || diffKeys.includes("gates_weakening");
+    const hasPromptTemplateChange = diffKeys.includes('prompt_template') || diffKeys.includes('gates_weakening');
     const rubricHasCounter = Object.keys(pkg.rubric).length > 0;
     if (hasPromptTemplateChange && !rubricHasCounter) {
-        overfitRisks.push("diff touches prompt_template or gates_weakening without an explicit rubric counter — possible prompt inflation / gate weakening");
+        overfitRisks.push('diff touches prompt_template or gates_weakening without an explicit rubric counter — possible prompt inflation / gate weakening');
     }
     // (3) Safety regression: dropped red_line is the canonical
     // signal; the stub flags it when the after_snapshot carries a
     // `dropped_red_lines` array.
-    const dropped = pkg.after_snapshot["dropped_red_lines"];
+    const dropped = pkg.after_snapshot['dropped_red_lines'];
     if (Array.isArray(dropped) && dropped.length > 0) {
         for (const entry of dropped) {
-            if (typeof entry === "string") {
+            if (typeof entry === 'string') {
                 safetyRegressionRisks.push(`red_line dropped from after_snapshot: ${entry}`);
             }
         }
@@ -97,7 +97,7 @@ export const deterministicInvokeSkepticLlm = async (pkg, prompt) => {
         driftRisks,
         overfitRisks,
         safetyRegressionRisks,
-        ...(blocker !== undefined ? { blocker } : {}),
+        ...(blocker !== undefined ? { blocker } : {})
     };
 };
 /**

package/dist/services/feedback/feedback-promotion-service.js

@@ -42,9 +42,21 @@ const RULE_BODY_PREVIEW_LINES = 5;
 const STDERR_TRUNCATE_BYTES = 2000;
 export const PROMOTION_LAYERS = ['A', 'B', 'C'];
 export const PROMOTION_LAYER_DETAILS = [
-    { layer: 'A', label: 'peaks-sop gate', description: 'Append to sops/*.md and reference from a peaks-sop check. Procedural rules.' },
-    { layer: 'B', label: 'peaks-hooks PreToolUse', description: 'Append a matcher to .peaks/.claude-settings-template.json. Tool-call interception.' },
-    { layer: 'C', label: 'mode-gate hardFloorCategory', description: 'Extend HardFloorCategory + shouldPauseAtGate. Always pauses regardless of mode.' }
+    {
+        layer: 'A',
+        label: 'peaks-sop gate',
+        description: 'Append to sops/*.md and reference from a peaks-sop check. Procedural rules.'
+    },
+    {
+        layer: 'B',
+        label: 'peaks-hooks PreToolUse',
+        description: 'Append a matcher to .peaks/.claude-settings-template.json. Tool-call interception.'
+    },
+    {
+        layer: 'C',
+        label: 'mode-gate hardFloorCategory',
+        description: 'Extend HardFloorCategory + shouldPauseAtGate. Always pauses regardless of mode.'
+    }
 ];
 /**
  * rid 2026-09-14-gate-h-promotion — what actually backs a promotion.
@@ -102,9 +114,17 @@ export function promotionArtifactChecks(memoryName, layer) {
         ];
     }
     if (layer === 'B') {
-        return [{ path: '.peaks/.claude-settings-template.json', evidence: 'hook-registration', id: memoryName }];
+        return [
+            {
+                path: '.peaks/.claude-settings-template.json',
+                evidence: 'hook-registration',
+                id: memoryName
+            }
+        ];
     }
-    return [{ path: 'src/services/code/mode-gate.ts', evidence: 'hard-floor-category', id: memoryName }];
+    return [
+        { path: 'src/services/code/mode-gate.ts', evidence: 'hard-floor-category', id: memoryName }
+    ];
 }
 /**
  * Which of `checks` are not satisfied under `projectRoot`. Empty means the
@@ -188,7 +208,9 @@ export function parseFeedbackMemory(filePath) {
         raw = readFileSync(filePath, 'utf8');
     }
     catch (err) {
-        throw new Error(`failed to read feedback memory at ${filePath}: ${err.message}`, { cause: err });
+        throw new Error(`failed to read feedback memory at ${filePath}: ${err.message}`, {
+            cause: err
+        });
     }
     const normalized = raw.replace(/\r\n/g, '\n');
     if (!normalized.startsWith('---\n'))
@@ -415,8 +437,8 @@ function corroborates(code, frontmatter) {
             return true;
         return frontmatterValue(frontmatter, 'nonActionable') === 'true';
     }
-    return frontmatterValue(frontmatter, 'sourceArtifact') !== null
-        || frontmatterValue(frontmatter, 'source') !== null;
+    return (frontmatterValue(frontmatter, 'sourceArtifact') !== null ||
+        frontmatterValue(frontmatter, 'source') !== null);
 }
 /**
  * Read the memory's not-to-promote declaration. `invalid` is returned rather than
@@ -432,7 +454,10 @@ export function readNotToPromote(filePath) {
     if (code === null && reason === null)
         return { kind: 'none' };
     if (code === null) {
-        return { kind: 'invalid', reason: '`notToPromoteReason` is set but the `notToPromote` code is missing' };
+        return {
+            kind: 'invalid',
+            reason: '`notToPromoteReason` is set but the `notToPromote` code is missing'
+        };
     }
     if (!NOT_TO_PROMOTE_CODES.includes(code)) {
         return {
@@ -441,7 +466,10 @@ export function readNotToPromote(filePath) {
         };
     }
     if (reason === null) {
-        return { kind: 'invalid', reason: `\`notToPromote: ${code}\` has no \`notToPromoteReason\` — an exemption must state its own reason` };
+        return {
+            kind: 'invalid',
+            reason: `\`notToPromote: ${code}\` has no \`notToPromoteReason\` — an exemption must state its own reason`
+        };
     }
     const typedCode = code;
     if (!corroborates(typedCode, frontmatter)) {
@@ -474,7 +502,12 @@ export function listPromotionExempt(opts) {
             continue;
         if (parsed.promotion !== null)
             continue; // contradiction — reported as a violation instead
-        out.push({ name: parsed.name, path: parsed.path, code: declaration.code, reason: declaration.reason });
+        out.push({
+            name: parsed.name,
+            path: parsed.path,
+            code: declaration.code,
+            reason: declaration.reason
+        });
     }
     return out;
 }
@@ -501,7 +534,10 @@ export function generatePromotionStub(opts) {
     // layer === 'C'
     return {
         snippet: `// src/services/code/mode-gate.ts\n// 1. Add to HardFloorCategory union: '${feedbackName}-rule'\n// 2. Add to HARD_FLOOR_CATEGORIES\n// 3. Wire shouldPauseAtGate to recognise the new category\n// Tests: tests/unit/services/code/<name>-hard-floor.test.ts (≥6 cases per AC-4)`,
-        targetFiles: ['src/services/code/mode-gate.ts', `tests/unit/services/code/${feedbackName}-hard-floor.test.ts`]
+        targetFiles: [
+            'src/services/code/mode-gate.ts',
+            `tests/unit/services/code/${feedbackName}-hard-floor.test.ts`
+        ]
     };
 }
 /**

package/dist/services/feedback/promotion-artifact-evidence.d.ts

@@ -46,22 +46,8 @@
  * to the category, and this repo documents `commit-boundary-side-effect` beside
  * the union member while the array enforces it.
  */
-export type PromotionEvidence = 
-/** A SOP manifest: a JSON object whose `id` is the SOP's and whose `gates` is an array. */
-'sop-manifest'
-/** An entry with the SOP's `id` inside `<registry>.sops[]` — what `readRegistry()` enumerates. */
- | 'sop-registry-entry'
-/** A hook registration (hook command) inside `hooks` that runs something named after the rule. */
- | 'hook-registration'
-/** A member of `HARD_FLOOR_CATEGORIES` — the array `isHardFloorCategory` reads — that names the rule. */
- | 'hard-floor-category';
-export type PromotionArtifactCheck = {
-    /** Project-relative POSIX path whose CONTENT must carry the evidence. */
-    path: string;
-    evidence: PromotionEvidence;
-    /** The rule id the evidence must name (a SOP id for layer A, a memory name for B and C). */
-    id: string;
-};
+import { type PromotionArtifactCheck } from './promotion-artifact-json-evidence.js';
+export type { PromotionArtifactCheck, PromotionEvidence } from './promotion-artifact-json-evidence.js';
 /**
  * The reason `check` is unsatisfied by `text`, or `null` when it is satisfied.
  * Never throws: a file that cannot be parsed yields the reason it could not be.