peaks-loop 4.0.54 → 4.1.1

package/dist/services/context/memory-index-reader.js

@@ -45,13 +45,9 @@ export class MemoryIndexReader {
             const raw = JSON.parse(readFileSync(indexPath, 'utf8'));
             const tiers = {
                 hot: flattenBucket(raw, 'hot'),
-                warm: flattenBucket(raw, 'warm'),
+                warm: flattenBucket(raw, 'warm')
             };
-            const entries = [
-                ...tiers.hot,
-                ...tiers.warm,
-                ...flattenBucket(raw, 'cold'),
-            ];
+            const entries = [...tiers.hot, ...tiers.warm, ...flattenBucket(raw, 'cold')];
             this.cache = { mtimeMs, entries, tiers };
             return this.cache;
         }
@@ -67,9 +63,7 @@ function bucketOf(raw, layer) {
     if (!raw || typeof raw !== 'object')
         return null;
     const bucket = raw[layer];
-    return bucket && typeof bucket === 'object'
-        ? bucket
-        : null;
+    return bucket && typeof bucket === 'object' ? bucket : null;
 }
 function flattenBucket(raw, layer) {
     const bucket = bucketOf(raw, layer);

package/dist/services/context/memory-preflight-config.js

@@ -7,7 +7,7 @@ const DEFAULTS = Object.freeze({
     warmItemCap: 4,
     warmMinTokenHits: 1,
     selectionTimeBudgetMs: 200,
-    includeBodies: false,
+    includeBodies: false
 });
 const LIST_CAP_MIN = 1;
 const LIST_CAP_MAX = 50;
@@ -18,9 +18,7 @@ function asFiniteInt(value, fallback) {
         : fallback;
 }
 function asFiniteNumber(value, fallback) {
-    return typeof value === 'number' && Number.isFinite(value) && value >= 0
-        ? value
-        : fallback;
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : fallback;
 }
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
@@ -50,6 +48,6 @@ export function resolveMemoryPreflightConfig(prefs) {
         warmItemCap: clamp(asFiniteInt(m.warmItemCap, DEFAULTS.warmItemCap), 0, ITEM_CAP_MAX),
         warmMinTokenHits: clamp(asFiniteInt(m.warmMinTokenHits, DEFAULTS.warmMinTokenHits), 1, ITEM_CAP_MAX),
         selectionTimeBudgetMs: clamp(asFiniteNumber(m.selectionTimeBudgetMs, DEFAULTS.selectionTimeBudgetMs), 0, 10_000),
-        includeBodies: m.includeBodies === true ? true : DEFAULTS.includeBodies,
+        includeBodies: m.includeBodies === true ? true : DEFAULTS.includeBodies
     };
 }

package/dist/services/context/memory-preflight-service.d.ts

@@ -1,24 +1,6 @@
 import { type MemoryPreflightPrefsInput } from './memory-preflight-config.js';
-export interface MemoryPreflightResult {
-    available: boolean;
-    block?: string;
-    /** Back-compat: total items emitted (hot + warm). */
-    feedbackListItems?: number;
-    cachedItemCount?: number;
-    reason?: string;
-    truncated?: boolean | undefined;
-    droppedCount?: number | undefined;
-    /** Slice 2026-09-09: hot items emitted. */
-    hotSelected?: number | undefined;
-    /** Slice 2026-09-09: warm items emitted. */
-    warmSelected?: number | undefined;
-    /** Slice 2026-09-09: bytes of the emitted block (utf8). */
-    bytesEmitted?: number | undefined;
-    /** Slice 2026-09-09: true when ANY budget (items / bytes / time) cut content. */
-    budgetTruncated?: boolean | undefined;
-    /** Slice 2026-09-09: true when the soft selection time budget was hit. */
-    timedOut?: boolean | undefined;
-}
+import { type MemoryPreflightResult } from './memory-preflight-support.js';
+export type { MemoryPreflightResult };
 export declare class MemoryPreflightService {
     private readonly reader;
     private readonly config;

package/dist/services/context/memory-preflight-service.js

@@ -28,19 +28,41 @@
 import { performance } from 'node:perf_hooks';
 import { fuzzyMatchWithKey } from '../fuzzy-matching/fuzzy-match-service.js';
 import { MemoryIndexReader } from './memory-index-reader.js';
-import { resolveMemoryPreflightConfig, } from './memory-preflight-config.js';
+import { resolveMemoryPreflightConfig } from './memory-preflight-config.js';
+import { MIN_TOKEN_LENGTH, countItemsInBlock, renderEntry, tokenHits } from './memory-preflight-support.js';
 /** Function words carry no selection signal. */
 const STOPWORDS = new Set([
-    'the', 'and', 'for', 'with', 'from', 'that', 'this', 'not', 'are', 'was',
-    'but', 'you', 'all', 'any', 'can', 'has', 'its', 'our', 'out', 'use', 'via',
-    'per', 'into', 'when', 'then', 'than', 'they', 'their', 'should', 'must',
+    'the',
+    'and',
+    'for',
+    'with',
+    'from',
+    'that',
+    'this',
+    'not',
+    'are',
+    'was',
+    'but',
+    'you',
+    'all',
+    'any',
+    'can',
+    'has',
+    'its',
+    'our',
+    'out',
+    'use',
+    'via',
+    'per',
+    'into',
+    'when',
+    'then',
+    'than',
+    'they',
+    'their',
+    'should',
+    'must'
 ]);
-/**
- * Tokens shorter than 4 chars are too promiscuous for literal containment
- * ("add" is a substring of "padding"), so they rank but do not gate.
- */
-const MIN_TOKEN_LENGTH = 4;
-const CJK_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
 function queryTokens(query) {
     const seen = new Set();
     const out = [];
@@ -52,32 +74,6 @@ function queryTokens(query) {
     }
     return out;
 }
-/**
- * Absolute relevance gate: does the token literally occur in the entry?
- *
- * The fuzzy kernel's score is normalized per batch (best match = 1.0), so
- * it cannot distinguish a strong match from the best of a bad lot — an
- * absolute check is required for the warm gate. CJK titles have no word
- * boundaries, so those tokens fall back to 2-char gram overlap.
- */
-function tokenHits(text, tokens) {
-    let hits = 0;
-    for (const token of tokens) {
-        if (text.includes(token)) {
-            hits += 1;
-            continue;
-        }
-        if (!CJK_RE.test(token))
-            continue;
-        for (let i = 0; i + 2 <= token.length; i += 1) {
-            if (text.includes(token.slice(i, i + 2))) {
-                hits += 1;
-                break;
-            }
-        }
-    }
-    return hits;
-}
 function truncateToCap(text, capBytes) {
     if (Buffer.byteLength(text, 'utf8') <= capBytes) {
         return { text, truncated: false };
@@ -114,7 +110,7 @@ export class MemoryPreflightService {
             // Fail-soft: a selection failure must never block a dispatch.
             return {
                 available: false,
-                reason: `SELECTION_ERROR: ${err.message ?? String(err)}`,
+                reason: `SELECTION_ERROR: ${err.message ?? String(err)}`
             };
         }
     }
@@ -145,8 +141,7 @@ export class MemoryPreflightService {
             for (const candidate of warmRanked) {
                 if (warmSelected.length >= this.config.warmItemCap)
                     break;
-                if (performance.now() - startedAt >=
-                    this.config.selectionTimeBudgetMs) {
+                if (performance.now() - startedAt >= this.config.selectionTimeBudgetMs) {
                     timedOut = true;
                     break;
                 }
@@ -182,9 +177,7 @@ export class MemoryPreflightService {
         const { text, truncated } = truncateToCap(composed, this.config.maxBytes);
         const selectedCount = hotSelected.length + warmSelected.length;
         const droppedByItemCap = hotRanked.length - hotSelected.length + (warmEligibleCount - warmSelected.length);
-        const droppedByBytes = truncated
-            ? Math.max(0, selectedCount - countItemsInBlock(text))
-            : 0;
+        const droppedByBytes = truncated ? Math.max(0, selectedCount - countItemsInBlock(text)) : 0;
         const droppedCount = droppedByItemCap + droppedByBytes;
         return {
             available: true,
@@ -197,7 +190,7 @@ export class MemoryPreflightService {
             budgetTruncated: truncated || droppedByItemCap > 0 || timedOut,
             timedOut,
             truncated,
-            droppedCount: droppedCount > 0 ? droppedCount : undefined,
+            droppedCount: droppedCount > 0 ? droppedCount : undefined
         };
     }
 }
@@ -239,7 +232,7 @@ function rankByRelevance(query, entries) {
         const matches = fuzzyMatchWithKey(token, entries, {
             keyFn: (e) => `${e.name} ${e.description}`,
             limit: entries.length,
-            caseSensitive: false,
+            caseSensitive: false
         });
         for (const match of matches) {
             accumulated.set(match.item, (accumulated.get(match.item) ?? 0) + match.score);
@@ -250,27 +243,3 @@ function rankByRelevance(query, entries) {
         .map((entry) => ({ entry, score: accumulated.get(entry) ?? 0 }))
         .sort((a, b) => b.score - a.score);
 }
-function renderEntry(entry) {
-    return `- * ${entry.name}\n    Path: ${entry.sourcePath}\n    One-line: ${summarize(entry.description)}`;
-}
-function summarize(description) {
-    // Drop the <!-- peaks-feedback-promoted: layer=A --> marker, take the next 1 line.
-    const cleaned = description.replace(/<!--[^>]*-->/g, '').trim();
-    return cleaned.split('\n')[0] ?? cleaned;
-}
-function countItemsInBlock(text) {
-    // Count `- * ` markers ONLY in the list portion (between the
-    // `## Project memory relevant to this task` header and the
-    // `## Requested memory details:` sub-section, if present). Memo
-    // bodies appended under `## Requested memory details:` may
-    // legitimately contain their own `- * ` markdown bullets, which
-    // would otherwise inflate the count and produce a wrong
-    // `droppedCount` in the truncated case.
-    const headerEnd = text.indexOf('\n## ');
-    if (headerEnd === -1) {
-        return (text.match(/- \* /g) ?? []).length;
-    }
-    const tailStart = text.indexOf('\n## Requested memory details:', headerEnd + 1);
-    const listEnd = tailStart === -1 ? text.length : tailStart;
-    return (text.slice(0, listEnd).match(/- \* /g) ?? []).length;
-}

package/dist/services/context/memory-preflight-support.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Declarations extracted from `memory-preflight-service.ts` by the b1
+ * file-size campaign: the result/ranking types, the token/CJK constants,
+ * and the pure selection helpers (token gate, entry renderer, one-line
+ * summariser, block item counter). The service re-exports the public type
+ * and imports the helpers back, so importers keep the original path.
+ */
+import type { MemoryIndexEntry } from '../memory/memory-search-service.js';
+export interface MemoryPreflightResult {
+    available: boolean;
+    block?: string;
+    /** Back-compat: total items emitted (hot + warm). */
+    feedbackListItems?: number;
+    cachedItemCount?: number;
+    reason?: string;
+    truncated?: boolean | undefined;
+    droppedCount?: number | undefined;
+    /** Slice 2026-09-09: hot items emitted. */
+    hotSelected?: number | undefined;
+    /** Slice 2026-09-09: warm items emitted. */
+    warmSelected?: number | undefined;
+    /** Slice 2026-09-09: bytes of the emitted block (utf8). */
+    bytesEmitted?: number | undefined;
+    /** Slice 2026-09-09: true when ANY budget (items / bytes / time) cut content. */
+    budgetTruncated?: boolean | undefined;
+    /** Slice 2026-09-09: true when the soft selection time budget was hit. */
+    timedOut?: boolean | undefined;
+}
+export interface RankedEntry {
+    entry: MemoryIndexEntry;
+    score: number;
+}
+/**
+ * Tokens shorter than 4 chars are too promiscuous for literal containment
+ * ("add" is a substring of "padding"), so they rank but do not gate.
+ */
+export declare const MIN_TOKEN_LENGTH = 4;
+/**
+ * Absolute relevance gate: does the token literally occur in the entry?
+ *
+ * The fuzzy kernel's score is normalized per batch (best match = 1.0), so
+ * it cannot distinguish a strong match from the best of a bad lot — an
+ * absolute check is required for the warm gate. CJK titles have no word
+ * boundaries, so those tokens fall back to 2-char gram overlap.
+ */
+export declare function tokenHits(text: string, tokens: string[]): number;
+export declare function renderEntry(entry: MemoryIndexEntry): string;
+export declare function countItemsInBlock(text: string): number;

package/dist/services/context/memory-preflight-support.js

@@ -0,0 +1,56 @@
+/**
+ * Tokens shorter than 4 chars are too promiscuous for literal containment
+ * ("add" is a substring of "padding"), so they rank but do not gate.
+ */
+export const MIN_TOKEN_LENGTH = 4;
+const CJK_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+/**
+ * Absolute relevance gate: does the token literally occur in the entry?
+ *
+ * The fuzzy kernel's score is normalized per batch (best match = 1.0), so
+ * it cannot distinguish a strong match from the best of a bad lot — an
+ * absolute check is required for the warm gate. CJK titles have no word
+ * boundaries, so those tokens fall back to 2-char gram overlap.
+ */
+export function tokenHits(text, tokens) {
+    let hits = 0;
+    for (const token of tokens) {
+        if (text.includes(token)) {
+            hits += 1;
+            continue;
+        }
+        if (!CJK_RE.test(token))
+            continue;
+        for (let i = 0; i + 2 <= token.length; i += 1) {
+            if (text.includes(token.slice(i, i + 2))) {
+                hits += 1;
+                break;
+            }
+        }
+    }
+    return hits;
+}
+export function renderEntry(entry) {
+    return `- * ${entry.name}\n    Path: ${entry.sourcePath}\n    One-line: ${summarize(entry.description)}`;
+}
+function summarize(description) {
+    // Drop the <!-- peaks-feedback-promoted: layer=A --> marker, take the next 1 line.
+    const cleaned = description.replace(/<!--[^>]*-->/g, '').trim();
+    return cleaned.split('\n')[0] ?? cleaned;
+}
+export function countItemsInBlock(text) {
+    // Count `- * ` markers ONLY in the list portion (between the
+    // `## Project memory relevant to this task` header and the
+    // `## Requested memory details:` sub-section, if present). Memo
+    // bodies appended under `## Requested memory details:` may
+    // legitimately contain their own `- * ` markdown bullets, which
+    // would otherwise inflate the count and produce a wrong
+    // `droppedCount` in the truncated case.
+    const headerEnd = text.indexOf('\n## ');
+    if (headerEnd === -1) {
+        return (text.match(/- \* /g) ?? []).length;
+    }
+    const tailStart = text.indexOf('\n## Requested memory details:', headerEnd + 1);
+    const listEnd = tailStart === -1 ? text.length : tailStart;
+    return (text.slice(0, listEnd).match(/- \* /g) ?? []).length;
+}

package/dist/services/context/post-compact-reinjection.js

@@ -63,7 +63,7 @@
 import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { readJobShapeDecision } from '../code/job-shape-decision.js';
-import { tryReadJobProgress } from '../job/job-progress-store.js';
+import { describeNextSlice, tryReadJobProgress } from '../job/job-progress-store.js';
 import { getSessionIdCanonical } from '../session/session-manager.js';
 /**
  * Hard ceiling on the card's size, in UTF-8 bytes.
@@ -110,7 +110,7 @@ export const POST_COMPACT_REINJECTION_BYTE_BUDGET = 3072;
 export const AGENT_RUNTIME_RULES = Object.freeze([
     'CLI: run `node --import tsx src/cli/index.ts <cmd>`, never `pnpm exec tsx` — on Windows the latter truncates any argument at its first newline.',
     'Test scope: one file or pattern per run; the full suite requires PEAKS_FULL_TEST=1.',
-    'Exit codes: never read a test result through a pipe (`| tail` reports tail\'s status); read ${PIPESTATUS[0]}.',
+    "Exit codes: never read a test result through a pipe (`| tail` reports tail's status); read ${PIPESTATUS[0]}.",
     'Never write `.claude/settings.local.json` from a slice — reproduce against a temp project copy via `--project <tmpdir>`.',
     'Git: commit / push policy is per-dispatch and is NOT inherited from this card — re-read the dispatch record before any state-mutating git command.',
     'No interactive questions: decide, act, and record the decision in the artifact.'
@@ -404,7 +404,7 @@ function buildBlocks(facts) {
     // Rank 3 — next action.
     const next = [];
     if (facts.progress !== null) {
-        next.push(`job ${facts.jobId ?? '?'}: slice ${facts.progress.done + 1}/${facts.progress.total} (${facts.progress.currentSlice})`);
+        next.push(`job ${facts.jobId ?? '?'}: ${describeNextSlice(facts.progress, facts.jobId)}`);
     }
     else if (facts.isJob) {
         next.push(`job ${facts.jobId ?? '?'}: no progress.json yet — resume at the first unfinished slice`);

package/dist/services/context/renderer.js

@@ -13,8 +13,12 @@ export function render(input) {
     const serialized = JSON.stringify({
         goal: input.goal,
         audience: input.audience,
-        docs: docs.map((d) => ({ dep: d.dep, version: d.version, excerpt: d.sections.map((s) => s.excerpt).join(' ') })),
-        skipped: input.docRetriever.skipped,
+        docs: docs.map((d) => ({
+            dep: d.dep,
+            version: d.version,
+            excerpt: d.sections.map((s) => s.excerpt).join(' ')
+        })),
+        skipped: input.docRetriever.skipped
     });
     const sizeBytes = Buffer.byteLength(serialized, 'utf8');
     const approxTokens = Math.ceil(sizeBytes / 4);
@@ -24,7 +28,7 @@ export function render(input) {
         renderedAt: now().toISOString(),
         sizeBytes,
         truncated,
-        ...(truncated ? { truncatedReason: 'doc_budget_exceeded' } : {}),
+        ...(truncated ? { truncatedReason: 'doc_budget_exceeded' } : {})
     };
     return Object.freeze(result);
 }

package/dist/services/context/spillover-store.js

@@ -10,7 +10,9 @@ function assertSafeSegment(value, name) {
 }
 function assertInside(base, target) {
     const rel = relative(base, target);
-    if (rel === '..' || rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) || isAbsolute(rel)) {
+    if (rel === '..' ||
+        rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) ||
+        isAbsolute(rel)) {
         throw new Error('Spill path must stay inside the session spill directory');
     }
 }

package/dist/services/context/summary-view.js

@@ -44,7 +44,7 @@ function clipName(name, maxChars) {
 export function boundedNames(names) {
     return {
         count: names.length,
-        names: names.slice(0, SUMMARY_INITIAL_NAMES).map((n) => clipName(n, SUMMARY_NAME_MAX_CHARS)),
+        names: names.slice(0, SUMMARY_INITIAL_NAMES).map((n) => clipName(n, SUMMARY_NAME_MAX_CHARS))
     };
 }
 /**

package/dist/services/context/threshold.js

@@ -8,8 +8,8 @@
 export const CONTEXT_CAPACITY_DEFAULT_BYTES = 256 * 1024; // 256K
 export const THRESHOLD_SOFT_WARN_RATIO = 0.5; // 50%
 export const THRESHOLD_NEAR_LIMIT_RATIO = 0.75; // 75% — user red line
-export const THRESHOLD_HARD_REJECT_RATIO = 0.80; // 80%
-export const THRESHOLD_EMERGENCY_RATIO = 0.90; // 90%
+export const THRESHOLD_HARD_REJECT_RATIO = 0.8; // 80%
+export const THRESHOLD_EMERGENCY_RATIO = 0.9; // 90%
 /**
  * Compute the threshold tier for a given prompt size. Pure function
  * (no IO, no side effects). The `capacityBytes` parameter lets callers

package/dist/services/context/tokenizer.js

@@ -16,7 +16,7 @@ export function tokenize(collector, docRetriever, now = new Date()) {
             blastRadius: doc.sections.map((s) => s.title),
             conflictScore: 0, // v1: no cross-source conflict detection yet
             timeDecayScore: freshDecayScore(doc.fetchedAt, now),
-            tags: ['fetched', doc.source, doc.stale ? 'stale' : 'fresh'],
+            tags: ['fetched', doc.source, doc.stale ? 'stale' : 'fresh']
         });
     }
     for (const mem of collector.memoryEntries) {
@@ -26,7 +26,7 @@ export function tokenize(collector, docRetriever, now = new Date()) {
             blastRadius: [mem.title],
             conflictScore: 0,
             timeDecayScore: mem.relevanceScore,
-            tags: ['memory'],
+            tags: ['memory']
         });
     }
     for (const file of collector.files) {
@@ -36,7 +36,7 @@ export function tokenize(collector, docRetriever, now = new Date()) {
             blastRadius: [file.path],
             conflictScore: 0,
             timeDecayScore: 1,
-            tags: [file.kind],
+            tags: [file.kind]
         });
     }
     return Object.freeze({ metadata: Object.freeze(metadata) });

package/dist/services/crystallization/crystallization-brief-schema.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Crystallization evidence-brief schema — hoisted VERBATIM out of
+ * `crystallization-types.ts` so that file clears the 300 raw-line cap.
+ * Nothing here was rewritten: same constraints, same `.superRefine`
+ * guard, same issue message, same MISSING_BRIEF_SECTION mapping.
+ *
+ * `crystallization-types.ts` re-exports every public name from this
+ * path, so `EvidenceBriefSchema` / `EvidenceBrief` /
+ * `hasAllFourBriefSections` / `parseEvidenceBrief` /
+ * `safeParseEvidenceBrief` stay importable from their original module
+ * and from `crystallization/index.js`.
+ */
+import { z } from 'zod';
+/** Brief-section cap; the event-level free-text columns in
+ *  `crystallization-types.ts` reuse the same bound. */
+export declare const CRYS_BRIEF_SECTION_MAX = 4000;
+/**
+ * EvidenceBrief — the 4-section brief (spec §4.7).
+ *
+ * Hard shape invariant: ALL FOUR KEYS must be present at parse
+ * time, with non-empty NL content. The `.refine(...)` guard is
+ * what makes a brief a "brief" — without it, the projection is
+ * not a brief and the recommendation MUST NOT be rendered
+ * (service layer enforces this; Zod makes it a parse-time
+ * guarantee).
+ *
+ * Field semantics:
+ *   - what_happened   — 1-2 sentence factual account of the run.
+ *   - why_it_matters  — 1-2 sentence explanation of why this is
+ *                       worth promoting.
+ *   - what_learned    — 1-2 sentence learning: failure modes
+ *                       encoded, preferences extracted.
+ *   - what_action     — 1-sentence recommended action with
+ *                       rationale.
+ */
+export declare const EvidenceBriefSchema: z.ZodObject<{
+    what_happened: z.ZodString;
+    why_it_matters: z.ZodString;
+    what_learned: z.ZodString;
+    what_action: z.ZodString;
+}, z.core.$strict>;
+export type EvidenceBrief = z.infer<typeof EvidenceBriefSchema>;
+/**
+ * Helper for downstream code that needs to know whether a parsed
+ * brief satisfies the 4-section rule. Useful for the CLI when a
+ * payload arrived from the LLM and the brief-section guard has
+ * already passed — it returns the section count, always 4 here.
+ */
+export declare function hasAllFourBriefSections(brief: EvidenceBrief): boolean;
+/**
+ * Convenience: strict-parse an unknown payload as a standalone
+ * EvidenceBrief. Throws ZodError on failure.
+ */
+export declare function parseEvidenceBrief(input: unknown): EvidenceBrief;
+/**
+ * Safe-parse twin of parseEvidenceBrief. Same Result-like envelope
+ * shape; same MISSING_BRIEF_SECTION code mapping (covers both
+ * refine-guard failures and per-section missing/empty failures).
+ */
+export declare function safeParseEvidenceBrief(input: unknown): {
+    ok: true;
+    row: EvidenceBrief;
+} | {
+    ok: false;
+    code?: 'MISSING_BRIEF_SECTION';
+    findings: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+/**
+ * Decide whether a ZodIssue[] is a "brief section" failure: every
+ * issue points at one of the four required keys (the section is
+ * missing, or empty after trim), OR the explicit refine-guard issue
+ * is present. Used by both `safeParseCrystallizationEvent` and
+ * `safeParseEvidenceBrief` so callers see a single
+ * `MISSING_BRIEF_SECTION` code regardless of which Zod boundary
+ * caught the failure.
+ */
+export declare function isBriefSectionFailure(issues: ReadonlyArray<z.ZodIssue>): boolean;