peaks-loop 4.0.54 → 4.1.0

package/dist/services/context/harness-context-witness.js

@@ -107,7 +107,11 @@ const FRACTION_MAX = 1;
 /** Upper bound of a sane percentage scale; above this the payload is not a percent. */
 const PERCENT_SCALE_MAX = 100;
 /** The three prompt-side components peaks-loop's own `rawTokens` sums. */
-const USAGE_TOKEN_KEYS = ['input_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens'];
+const USAGE_TOKEN_KEYS = [
+    'input_tokens',
+    'cache_read_input_tokens',
+    'cache_creation_input_tokens'
+];
 function finiteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
@@ -284,7 +288,10 @@ export function writeHarnessWitness(input) {
     if (!existsSync(dirname(path)))
         return false;
     if (witness.usedPercentage === null) {
-        const existing = readHarnessWitness({ projectRoot: input.projectRoot, sessionId: input.sessionId });
+        const existing = readHarnessWitness({
+            projectRoot: input.projectRoot,
+            sessionId: input.sessionId
+        });
         if (existing.kind === 'valid' && existing.witness.usedPercentage !== null)
             return false;
     }
@@ -356,8 +363,8 @@ export function readHarnessWitness(input) {
  * ratio difference are the same number — see `compareHarnessWitness`.
  */
 export function witnessToleranceTokens(input) {
-    return WITNESS_PERCENT_ROUNDING_FRACTION * input.windowTokens
-        + WITNESS_NUMERATOR_FRACTION * input.usedTokens;
+    return (WITNESS_PERCENT_ROUNDING_FRACTION * input.windowTokens +
+        WITNESS_NUMERATOR_FRACTION * input.usedTokens);
 }
 /**
  * Whether this sample can support an `agree`.
@@ -382,7 +389,8 @@ export function witnessToleranceTokens(input) {
  * the one answer that was honest there could not be produced there.
  */
 function sampleSupportsAgreement(harnessPct, tolerance) {
-    const smallestGapSignal = (MIN_DETECTABLE_WINDOW_DIFFERENCE * Math.abs(harnessPct)) / (1 + MIN_DETECTABLE_WINDOW_DIFFERENCE);
+    const smallestGapSignal = (MIN_DETECTABLE_WINDOW_DIFFERENCE * Math.abs(harnessPct)) /
+        (1 + MIN_DETECTABLE_WINDOW_DIFFERENCE);
     return smallestGapSignal > 2 * tolerance;
 }
 /** Which of the three `absent` states applies, in the reader's own words. */
@@ -391,8 +399,8 @@ function absentReason(cause) {
         return 'this session has no runtime directory yet, so nothing has been captured for it';
     }
     if (cause === 'unreadable') {
-        return 'a witness file exists for this session but could not be read as a record — the statusline DID '
-            + 'render here, and its record is unreadable, malformed, or not the shape this reader expects';
+        return ('a witness file exists for this session but could not be read as a record — the statusline DID ' +
+            'render here, and its record is unreadable, malformed, or not the shape this reader expects');
     }
     return 'no render has been recorded for this session — the statusline has not rendered through peaks-loop here';
 }
@@ -402,12 +410,12 @@ function unusableReason(witness) {
         return 'the payload carried no `used_percentage`, so this render recorded nothing to compare';
     }
     if (witness.usedPercentageUnit === 'unestablished') {
-        return `the payload reported used_percentage ${witness.usedPercentageRaw} and carried no token snapshot `
-            + 'to settle whether that is a fraction or a percent; the raw value is recorded, and no comparison is '
-            + 'made from it';
+        return (`the payload reported used_percentage ${witness.usedPercentageRaw} and carried no token snapshot ` +
+            'to settle whether that is a fraction or a percent; the raw value is recorded, and no comparison is ' +
+            'made from it');
     }
-    return `the payload reported used_percentage ${witness.usedPercentageRaw}, which is on neither scale `
-        + '(a 0..1 fraction or a 0..100 percent); the raw value is recorded, and no comparison is made from it';
+    return (`the payload reported used_percentage ${witness.usedPercentageRaw}, which is on neither scale ` +
+        '(a 0..1 fraction or a 0..100 percent); the raw value is recorded, and no comparison is made from it');
 }
 /**
  * Compare peaks-loop's ratio with the harness's own percentage.
@@ -480,9 +488,9 @@ export function compareHarnessWitness(input) {
         return {
             ...base,
             verdict: 'unverifiable',
-            reason: `this witness was recorded under schema v${witness.schemaVersion} and this revision reads `
-                + `v${WITNESS_SCHEMA_VERSION}, which do not agree on what the recorded percentage means; it is not `
-                + 'compared, and the next render replaces it',
+            reason: `this witness was recorded under schema v${witness.schemaVersion} and this revision reads ` +
+                `v${WITNESS_SCHEMA_VERSION}, which do not agree on what the recorded percentage means; it is not ` +
+                'compared, and the next render replaces it',
             harnessPct: null,
             deviation: null,
             residual: null,
@@ -517,7 +525,10 @@ export function compareHarnessWitness(input) {
             tolerance: null
         };
     }
-    if (windowTokens === null || windowTokens <= 0 || peaksTokens === null || witnessTokens === null) {
+    if (windowTokens === null ||
+        windowTokens <= 0 ||
+        peaksTokens === null ||
+        witnessTokens === null) {
         return {
             ...base,
             verdict: 'unverifiable',
@@ -539,7 +550,15 @@ export function compareHarnessWitness(input) {
     // `disagree` only claims that SOME difference exists, and a residual past the
     // budget is exactly that claim — sound at any ratio, any witness age.
     if (Math.abs(residual) > tolerance) {
-        return { ...base, verdict: 'disagree', reason: null, harnessPct, deviation, residual, tolerance };
+        return {
+            ...base,
+            verdict: 'disagree',
+            reason: null,
+            harnessPct,
+            deviation,
+            residual,
+            tolerance
+        };
     }
     // `agree` claims there is no difference, which needs the sample to be sharp
     // enough to support it — see `sampleSupportsAgreement`.
@@ -576,13 +595,13 @@ export function describeHarnessWitness(comparison) {
     const readAs = comparison.witnessPercentageUnit === null
         ? ''
         : ` (raw ${comparison.witnessRawPercentage}, read as a ${comparison.witnessPercentageUnit})`;
-    return `Harness context witness disagrees: the harness reports ${pct(comparison.harnessPct ?? 0)} used${readAs}, `
-        + `peaks-loop computes ${pct(comparison.peaksRatio)} (deviation ${pct(Math.abs(comparison.deviation ?? 0))}`
-        + `${skew === null ? '' : `, of which the measured sampling skew explains ${pct(Math.abs(skew))}`}, `
-        + `leaving ${pct(Math.abs(comparison.residual ?? 0))} against a budget of ${pct(comparison.tolerance ?? 0)}). `
-        + 'The two ratios do not share a denominator: '
-        + 'peaks-loop\'s configured auto-compact window and the harness\'s effective auto-compact window are '
-        + 'different numbers. Nothing is blocked.';
+    return (`Harness context witness disagrees: the harness reports ${pct(comparison.harnessPct ?? 0)} used${readAs}, ` +
+        `peaks-loop computes ${pct(comparison.peaksRatio)} (deviation ${pct(Math.abs(comparison.deviation ?? 0))}` +
+        `${skew === null ? '' : `, of which the measured sampling skew explains ${pct(Math.abs(skew))}`}, ` +
+        `leaving ${pct(Math.abs(comparison.residual ?? 0))} against a budget of ${pct(comparison.tolerance ?? 0)}). ` +
+        'The two ratios do not share a denominator: ' +
+        "peaks-loop's configured auto-compact window and the harness's effective auto-compact window are " +
+        'different numbers. Nothing is blocked.');
 }
 /** Convenience for the CLI: read + compare in one call. */
 export function readAndCompareHarnessWitness(input) {

package/dist/services/context/harness-window-config.js

@@ -99,7 +99,7 @@ export const HARNESS_WINDOW_MAX_TOKENS = 1_000_000;
  * `null` (absent / unparseable) is NOT in band — there is no window at all.
  */
 export function isHarnessWindowInRange(tokens) {
-    return tokens !== null && tokens >= HARNESS_WINDOW_MIN_TOKENS && tokens <= HARNESS_WINDOW_MAX_TOKENS;
+    return (tokens !== null && tokens >= HARNESS_WINDOW_MIN_TOKENS && tokens <= HARNESS_WINDOW_MAX_TOKENS);
 }
 /**
  * The BAND SENTENCE, in one place: both the write refusal and the read
@@ -248,7 +248,9 @@ function harnessWindowConflictClause(result) {
  * different window and the disk keeps claiming `500k` on every probe after it.
  */
 function unreadableWindowValueClause(result) {
-    if (result.action !== 'skipped' || result.previousTokens !== null || result.previousRawValue === undefined)
+    if (result.action !== 'skipped' ||
+        result.previousTokens !== null ||
+        result.previousRawValue === undefined)
         return '';
     const raw = JSON.stringify(result.previousRawValue);
     return ` The value in ${result.settingsPath} is ${raw}, which is not a plain token count: peaks-loop cannot read a window from it, so it resolved this ratio against its own fallback while the file keeps saying ${raw}. peaks-loop cannot align the two without overwriting a value it did not write — set the value to a plain token count, or run \`peaks compact harness-window --reset\` to remove the key and let the next probe write peaks-loop's number.`;
@@ -345,16 +347,34 @@ export function readHarnessWindow(input) {
     const fromEnv = input.env?.[input.location.envVar];
     if (fromEnv !== undefined) {
         return {
-            tokens: parseHarnessWindowTokens(fromEnv), raw: fromEnv, source: 'process-env',
-            optedOut, peakWritten, fileTokens, fileRaw
+            tokens: parseHarnessWindowTokens(fromEnv),
+            raw: fromEnv,
+            source: 'process-env',
+            optedOut,
+            peakWritten,
+            fileTokens,
+            fileRaw
         };
     }
     if (fileRaw !== undefined) {
-        return { tokens: fileTokens, raw: fileRaw, source: 'settings-file', optedOut, peakWritten, fileTokens, fileRaw };
+        return {
+            tokens: fileTokens,
+            raw: fileRaw,
+            source: 'settings-file',
+            optedOut,
+            peakWritten,
+            fileTokens,
+            fileRaw
+        };
     }
     return {
-        tokens: null, raw: undefined, source: null, optedOut, peakWritten: false,
-        fileTokens: null, fileRaw: undefined
+        tokens: null,
+        raw: undefined,
+        source: null,
+        optedOut,
+        peakWritten: false,
+        fileTokens: null,
+        fileRaw: undefined
     };
 }
 /**

package/dist/services/context/ide-detect.js

@@ -8,7 +8,8 @@ export function isIdeKind(value) {
     return IDE_KINDS.includes(value);
 }
 export function detectIdeFromEnv(env = process.env) {
-    if (typeof env['CLAUDE_CODE_ENTRYPOINT'] === 'string' && env['CLAUDE_CODE_ENTRYPOINT'].length > 0) {
+    if (typeof env['CLAUDE_CODE_ENTRYPOINT'] === 'string' &&
+        env['CLAUDE_CODE_ENTRYPOINT'].length > 0) {
         return 'claude-code';
     }
     if (typeof env['CLAUDE_SESSION_ID'] === 'string' && env['CLAUDE_SESSION_ID'].length > 0) {

package/dist/services/context/index.d.ts

@@ -4,4 +4,4 @@ export { tokenize } from './tokenizer.js';
 export { render, type RenderInput } from './renderer.js';
 export { ContextJsonSchema } from './context-schema.js';
 export { buildContext, type BuildInput } from './context-builder.js';
-export type { ContextJson, Audience, DepsMode, FileKind, CollectedFile, GitStatus, MemoryEntry, DepInfo, DocSection, FetchedDoc, SkippedDoc, TokenizedItem, CollectorOutput, DocRetrieverOutput, TokenizerOutput, RendererOutput, } from './types.js';
+export type { ContextJson, Audience, DepsMode, FileKind, CollectedFile, GitStatus, MemoryEntry, DepInfo, DocSection, FetchedDoc, SkippedDoc, TokenizedItem, CollectorOutput, DocRetrieverOutput, TokenizerOutput, RendererOutput } from './types.js';

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