peaks-loop 4.0.0-beta.9 → 4.0.1

package/dist/services/context/context-schema.d.ts

@@ -16,13 +16,13 @@ export declare const ContextJsonSchema: z.ZodObject<{
             hash: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             path: string;
-            kind: "doc" | "source" | "test" | "config";
             lines: number;
+            kind: "doc" | "source" | "config" | "test";
             hash: string;
         }, {
             path: string;
-            kind: "doc" | "source" | "test" | "config";
             lines: number;
+            kind: "doc" | "source" | "config" | "test";
             hash: string;
         }>, "many">;
         gitStatus: z.ZodObject<{
@@ -68,6 +68,12 @@ export declare const ContextJsonSchema: z.ZodObject<{
             resolved: string;
         }>>;
     }, "strip", z.ZodTypeAny, {
+        files: {
+            path: string;
+            lines: number;
+            kind: "doc" | "source" | "config" | "test";
+            hash: string;
+        }[];
         deps: Record<string, {
             version: string;
             source: "package.json" | "pnpm-lock.yaml" | "yarn.lock";
@@ -78,12 +84,6 @@ export declare const ContextJsonSchema: z.ZodObject<{
             branch: string;
             lastCommit: string;
         };
-        files: {
-            path: string;
-            kind: "doc" | "source" | "test" | "config";
-            lines: number;
-            hash: string;
-        }[];
         memoryEntries: {
             path: string;
             title: string;
@@ -91,6 +91,12 @@ export declare const ContextJsonSchema: z.ZodObject<{
             excerptHash: string;
         }[];
     }, {
+        files: {
+            path: string;
+            lines: number;
+            kind: "doc" | "source" | "config" | "test";
+            hash: string;
+        }[];
         deps: Record<string, {
             version: string;
             source: "package.json" | "pnpm-lock.yaml" | "yarn.lock";
@@ -101,12 +107,6 @@ export declare const ContextJsonSchema: z.ZodObject<{
             branch: string;
             lastCommit: string;
         };
-        files: {
-            path: string;
-            kind: "doc" | "source" | "test" | "config";
-            lines: number;
-            hash: string;
-        }[];
         memoryEntries: {
             path: string;
             title: string;
@@ -138,8 +138,8 @@ export declare const ContextJsonSchema: z.ZodObject<{
             stale: z.ZodBoolean;
         }, "strip", z.ZodTypeAny, {
             version: string;
-            source: "local-cache" | "remote-fetch";
             stale: boolean;
+            source: "local-cache" | "remote-fetch";
             dep: string;
             fetchedAt: string;
             contentHash: string;
@@ -151,8 +151,8 @@ export declare const ContextJsonSchema: z.ZodObject<{
             url?: string | undefined;
         }, {
             version: string;
-            source: "local-cache" | "remote-fetch";
             stale: boolean;
+            source: "local-cache" | "remote-fetch";
             dep: string;
             fetchedAt: string;
             contentHash: string;
@@ -167,21 +167,21 @@ export declare const ContextJsonSchema: z.ZodObject<{
             dep: z.ZodString;
             reason: z.ZodEnum<["unconfigured", "network_error", "version_unknown"]>;
         }, "strip", z.ZodTypeAny, {
-            dep: string;
             reason: "unconfigured" | "network_error" | "version_unknown";
-        }, {
             dep: string;
+        }, {
             reason: "unconfigured" | "network_error" | "version_unknown";
+            dep: string;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         skipped: {
-            dep: string;
             reason: "unconfigured" | "network_error" | "version_unknown";
+            dep: string;
         }[];
         fetchedDocs: {
             version: string;
-            source: "local-cache" | "remote-fetch";
             stale: boolean;
+            source: "local-cache" | "remote-fetch";
             dep: string;
             fetchedAt: string;
             contentHash: string;
@@ -194,13 +194,13 @@ export declare const ContextJsonSchema: z.ZodObject<{
         }[];
     }, {
         skipped: {
-            dep: string;
             reason: "unconfigured" | "network_error" | "version_unknown";
+            dep: string;
         }[];
         fetchedDocs: {
             version: string;
-            source: "local-cache" | "remote-fetch";
             stale: boolean;
+            source: "local-cache" | "remote-fetch";
             dep: string;
             fetchedAt: string;
             contentHash: string;
@@ -222,17 +222,17 @@ export declare const ContextJsonSchema: z.ZodObject<{
             timeDecayScore: z.ZodNumber;
             tags: z.ZodArray<z.ZodString, "many">;
         }, "strip", z.ZodTypeAny, {
+            id: string;
             kind: "git" | "code" | "doc" | "memory";
             tags: string[];
-            id: string;
             blastRadius: string[];
             conflictScore: number;
             timeDecayScore: number;
             version?: string | undefined;
         }, {
+            id: string;
             kind: "git" | "code" | "doc" | "memory";
             tags: string[];
-            id: string;
             blastRadius: string[];
             conflictScore: number;
             timeDecayScore: number;
@@ -240,9 +240,9 @@ export declare const ContextJsonSchema: z.ZodObject<{
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         metadata: {
+            id: string;
             kind: "git" | "code" | "doc" | "memory";
             tags: string[];
-            id: string;
             blastRadius: string[];
             conflictScore: number;
             timeDecayScore: number;
@@ -250,9 +250,9 @@ export declare const ContextJsonSchema: z.ZodObject<{
         }[];
     }, {
         metadata: {
+            id: string;
             kind: "git" | "code" | "doc" | "memory";
             tags: string[];
-            id: string;
             blastRadius: string[];
             conflictScore: number;
             timeDecayScore: number;
@@ -267,15 +267,15 @@ export declare const ContextJsonSchema: z.ZodObject<{
         truncatedReason: z.ZodOptional<z.ZodEnum<["doc_budget_exceeded", "section_count_exceeded"]>>;
     }, "strip", z.ZodTypeAny, {
         sizeBytes: number;
+        truncated: boolean;
         audience: "all" | "peaks-rd" | "peaks-qa" | "peaks-mut";
         renderedAt: string;
-        truncated: boolean;
         truncatedReason?: "doc_budget_exceeded" | "section_count_exceeded" | undefined;
     }, {
         sizeBytes: number;
+        truncated: boolean;
         audience: "all" | "peaks-rd" | "peaks-qa" | "peaks-mut";
         renderedAt: string;
-        truncated: boolean;
         truncatedReason?: "doc_budget_exceeded" | "section_count_exceeded" | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
@@ -284,6 +284,12 @@ export declare const ContextJsonSchema: z.ZodObject<{
     sha256: string;
     generatedAt: string;
     collector: {
+        files: {
+            path: string;
+            lines: number;
+            kind: "doc" | "source" | "config" | "test";
+            hash: string;
+        }[];
         deps: Record<string, {
             version: string;
             source: "package.json" | "pnpm-lock.yaml" | "yarn.lock";
@@ -294,12 +300,6 @@ export declare const ContextJsonSchema: z.ZodObject<{
             branch: string;
             lastCommit: string;
         };
-        files: {
-            path: string;
-            kind: "doc" | "source" | "test" | "config";
-            lines: number;
-            hash: string;
-        }[];
         memoryEntries: {
             path: string;
             title: string;
@@ -309,13 +309,13 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
     docRetriever: {
         skipped: {
-            dep: string;
             reason: "unconfigured" | "network_error" | "version_unknown";
+            dep: string;
         }[];
         fetchedDocs: {
             version: string;
-            source: "local-cache" | "remote-fetch";
             stale: boolean;
+            source: "local-cache" | "remote-fetch";
             dep: string;
             fetchedAt: string;
             contentHash: string;
@@ -329,9 +329,9 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
     tokenizer: {
         metadata: {
+            id: string;
             kind: "git" | "code" | "doc" | "memory";
             tags: string[];
-            id: string;
             blastRadius: string[];
             conflictScore: number;
             timeDecayScore: number;
@@ -340,9 +340,9 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
     renderer: {
         sizeBytes: number;
+        truncated: boolean;
         audience: "all" | "peaks-rd" | "peaks-qa" | "peaks-mut";
         renderedAt: string;
-        truncated: boolean;
         truncatedReason?: "doc_budget_exceeded" | "section_count_exceeded" | undefined;
     };
 }, {
@@ -351,6 +351,12 @@ export declare const ContextJsonSchema: z.ZodObject<{
     sha256: string;
     generatedAt: string;
     collector: {
+        files: {
+            path: string;
+            lines: number;
+            kind: "doc" | "source" | "config" | "test";
+            hash: string;
+        }[];
         deps: Record<string, {
             version: string;
             source: "package.json" | "pnpm-lock.yaml" | "yarn.lock";
@@ -361,12 +367,6 @@ export declare const ContextJsonSchema: z.ZodObject<{
             branch: string;
             lastCommit: string;
         };
-        files: {
-            path: string;
-            kind: "doc" | "source" | "test" | "config";
-            lines: number;
-            hash: string;
-        }[];
         memoryEntries: {
             path: string;
             title: string;
@@ -376,13 +376,13 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
     docRetriever: {
         skipped: {
-            dep: string;
             reason: "unconfigured" | "network_error" | "version_unknown";
+            dep: string;
         }[];
         fetchedDocs: {
             version: string;
-            source: "local-cache" | "remote-fetch";
             stale: boolean;
+            source: "local-cache" | "remote-fetch";
             dep: string;
             fetchedAt: string;
             contentHash: string;
@@ -396,9 +396,9 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
     tokenizer: {
         metadata: {
+            id: string;
             kind: "git" | "code" | "doc" | "memory";
             tags: string[];
-            id: string;
             blastRadius: string[];
             conflictScore: number;
             timeDecayScore: number;
@@ -407,9 +407,9 @@ export declare const ContextJsonSchema: z.ZodObject<{
     };
     renderer: {
         sizeBytes: number;
+        truncated: boolean;
         audience: "all" | "peaks-rd" | "peaks-qa" | "peaks-mut";
         renderedAt: string;
-        truncated: boolean;
         truncatedReason?: "doc_budget_exceeded" | "section_count_exceeded" | undefined;
     };
 }>;

package/dist/services/context/ide-detect.d.ts

@@ -0,0 +1,4 @@
+export type IdeKind = 'claude-code' | 'trae' | 'opencode' | 'unknown';
+export declare const IDE_KINDS: readonly IdeKind[];
+export declare function isIdeKind(value: string): value is IdeKind;
+export declare function detectIdeFromEnv(env?: NodeJS.ProcessEnv): IdeKind;

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

@@ -0,0 +1,24 @@
+export const IDE_KINDS = [
+    'claude-code',
+    'trae',
+    'opencode',
+    'unknown'
+];
+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) {
+        return 'claude-code';
+    }
+    if (typeof env['CLAUDE_SESSION_ID'] === 'string' && env['CLAUDE_SESSION_ID'].length > 0) {
+        return 'claude-code';
+    }
+    if (typeof env['TRAE_CLI'] === 'string' && env['TRAE_CLI'].length > 0) {
+        return 'trae';
+    }
+    if (typeof env['OPENCODE'] === 'string' && env['OPENCODE'].length > 0) {
+        return 'opencode';
+    }
+    return 'unknown';
+}

package/dist/services/context/main-session-monitor.d.ts

@@ -20,12 +20,11 @@
  * No inline `promptSize / 256K > 0.75` checks scattered across
  * SKILL.md or other services.
  */
+import { type IdeKind } from './ide-detect.js';
 export type MainSessionTier = 'ok' | 'soft-warn' | 'near-limit' | 'emergency';
 export declare const MAIN_SESSION_THRESHOLD_RATIOS: {
     readonly [K in MainSessionTier]: number;
 };
-export type IdeKind = 'claude-code' | 'trae' | 'opencode' | 'unknown';
-export declare const IDE_KINDS: readonly IdeKind[];
 export type MainSessionTrigger = {
     readonly kind: 'none';
 } | {
@@ -50,8 +49,6 @@ export interface MainSessionEvaluation {
     readonly capacityBytes: number;
     readonly warnings: readonly string[];
 }
-export declare function isIdeKind(value: string): value is IdeKind;
-export declare function detectIdeFromEnv(env?: NodeJS.ProcessEnv): IdeKind;
 /**
  * Threshold check. Pure function (no IO). `capacityBytes` is injectable
  * for tests and future per-IDE capacity overrides. Defaults to the

package/dist/services/context/main-session-monitor.js

@@ -21,36 +21,13 @@
  * SKILL.md or other services.
  */
 import { CONTEXT_CAPACITY_DEFAULT_BYTES, THRESHOLD_SOFT_WARN_RATIO, THRESHOLD_NEAR_LIMIT_RATIO, THRESHOLD_EMERGENCY_RATIO, evaluateThresholdTier } from './threshold.js';
+import { detectIdeFromEnv } from './ide-detect.js';
 export const MAIN_SESSION_THRESHOLD_RATIOS = {
     ok: 0,
     'soft-warn': THRESHOLD_SOFT_WARN_RATIO,
     'near-limit': THRESHOLD_NEAR_LIMIT_RATIO,
     emergency: THRESHOLD_EMERGENCY_RATIO
 };
-export const IDE_KINDS = [
-    'claude-code',
-    'trae',
-    'opencode',
-    'unknown'
-];
-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) {
-        return 'claude-code';
-    }
-    if (typeof env['CLAUDE_SESSION_ID'] === 'string' && env['CLAUDE_SESSION_ID'].length > 0) {
-        return 'claude-code';
-    }
-    if (typeof env['TRAE_CLI'] === 'string' && env['TRAE_CLI'].length > 0) {
-        return 'trae';
-    }
-    if (typeof env['OPENCODE'] === 'string' && env['OPENCODE'].length > 0) {
-        return 'opencode';
-    }
-    return 'unknown';
-}
 /**
  * Threshold check. Pure function (no IO). `capacityBytes` is injectable
  * for tests and future per-IDE capacity overrides. Defaults to the

package/dist/services/context/memory-index-reader.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryIndexEntry } from '../memory/memory-search-service.js';
+export declare class MemoryIndexReader {
+    private readonly projectRoot;
+    private cache;
+    constructor(projectRoot: string);
+    loadIfStale(): MemoryIndexEntry[];
+    selectFeedbackLayerA(cap: number): MemoryIndexEntry[];
+}

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

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const LAYER_A_RE = /peaks-feedback-promoted:\s*layer=A\b/;
+export class MemoryIndexReader {
+    projectRoot;
+    cache = null;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+    }
+    loadIfStale() {
+        const indexPath = join(this.projectRoot, '.peaks', 'memory', 'index.json');
+        if (!existsSync(indexPath))
+            return [];
+        const { mtimeMs } = statSync(indexPath);
+        if (this.cache && this.cache.mtimeMs === mtimeMs)
+            return this.cache.entries;
+        let raw;
+        try {
+            raw = JSON.parse(readFileSync(indexPath, 'utf8'));
+        }
+        catch {
+            this.cache = null;
+            return [];
+        }
+        const entries = flattenIndex(raw);
+        this.cache = { mtimeMs, entries };
+        return entries;
+    }
+    selectFeedbackLayerA(cap) {
+        const all = this.loadIfStale();
+        return all
+            .filter((e) => e.kind === 'feedback')
+            .filter((e) => LAYER_A_RE.test(e.description))
+            .slice(0, Math.max(1, Math.trunc(cap)));
+    }
+}
+function flattenIndex(raw) {
+    if (!raw || typeof raw !== 'object')
+        return [];
+    const out = [];
+    const obj = raw;
+    for (const layer of ['hot', 'warm', 'cold']) {
+        const bucket = obj[layer];
+        if (!bucket || typeof bucket !== 'object')
+            continue;
+        for (const k of ['feedback', 'project', 'reference', 'user']) {
+            const list = bucket[k];
+            if (!Array.isArray(list))
+                continue;
+            for (const item of list) {
+                if (item && typeof item === 'object')
+                    out.push(item);
+            }
+        }
+    }
+    return out;
+}

package/dist/services/context/memory-lru-cache.d.ts

@@ -0,0 +1,12 @@
+export declare class MemoryLruCache {
+    private readonly budgetBytes;
+    private readonly store;
+    private currentBytes;
+    constructor(budgetBytes: number);
+    set(key: string, body: string): void;
+    get(key: string): string | undefined;
+    delete(key: string): void;
+    size(): number;
+    private evictIfOver;
+    private evictAll;
+}

package/dist/services/context/memory-lru-cache.js

@@ -0,0 +1,60 @@
+export class MemoryLruCache {
+    budgetBytes;
+    store = new Map();
+    currentBytes = 0;
+    constructor(budgetBytes) {
+        this.budgetBytes = budgetBytes;
+    }
+    set(key, body) {
+        if (this.store.has(key))
+            this.delete(key);
+        const bytes = Buffer.byteLength(body, 'utf8');
+        if (bytes > this.budgetBytes) {
+            // Oversized insert: evict ALL existing entries (LRU order) so only
+            // the newly inserted key remains in the cache. This prevents the
+            // unbounded growth that a naive "single oversized exception" would
+            // allow when oversized values are inserted consecutively.
+            this.evictAll();
+            this.store.set(key, { body, bytes });
+            this.currentBytes += bytes;
+            return;
+        }
+        this.store.set(key, { body, bytes });
+        this.currentBytes += bytes;
+        this.evictIfOver();
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        // refresh recency
+        this.store.delete(key);
+        this.store.set(key, entry);
+        return entry.body;
+    }
+    delete(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return;
+        this.store.delete(key);
+        this.currentBytes -= entry.bytes;
+    }
+    size() {
+        return this.currentBytes;
+    }
+    evictIfOver() {
+        while (this.currentBytes > this.budgetBytes && this.store.size > 0) {
+            // Map preserves insertion order — first key is least-recently-touched
+            const oldestKey = this.store.keys().next().value;
+            if (oldestKey === undefined)
+                break;
+            this.delete(oldestKey);
+        }
+    }
+    evictAll() {
+        // Empty the store; called before an oversized insert so only the new
+        // entry remains, per the eviction contract documented above.
+        this.store.clear();
+        this.currentBytes = 0;
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { ProjectPreferences } from '../preferences/preferences-types.js';
+export interface MemoryPreflightConfig {
+    readonly enabled: boolean;
+    readonly maxTokens: number;
+    readonly listCap: number;
+    readonly contentCacheBytes: number;
+}
+/**
+ * Loose input type for `resolveMemoryPreflightConfig`. Accepts either a
+ * full `ProjectPreferences` (e.g. the output of `loadPreferences()`) or
+ * any object that at minimum carries `memoryPreflight`. Lets callers
+ * pass a partial overlay literal — e.g. `{}` or `{ memoryPreflight: {...} }`
+ * — without having to construct a fully-populated preferences fixture.
+ *
+ * Downstream tasks (orchestrator service, dispatch hook) should import
+ * this alias rather than re-deriving the structural type.
+ */
+export type MemoryPreflightPrefsInput = ProjectPreferences | Pick<ProjectPreferences, 'memoryPreflight'>;
+export declare function resolveMemoryPreflightConfig(prefs: MemoryPreflightPrefsInput): MemoryPreflightConfig;

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

@@ -0,0 +1,25 @@
+const DEFAULTS = Object.freeze({
+    enabled: true,
+    maxTokens: 1200,
+    listCap: 12,
+    contentCacheBytes: 6000,
+});
+const LIST_CAP_MIN = 1;
+const LIST_CAP_MAX = 50;
+function asFiniteInt(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? Math.trunc(value)
+        : fallback;
+}
+export function resolveMemoryPreflightConfig(prefs) {
+    const m = prefs.memoryPreflight ?? {};
+    const listCapRaw = asFiniteInt(m.listCap, DEFAULTS.listCap);
+    return {
+        enabled: m.enabled === false ? false : DEFAULTS.enabled,
+        maxTokens: m.maxTokens && m.maxTokens > 0 ? m.maxTokens : DEFAULTS.maxTokens,
+        listCap: Math.min(LIST_CAP_MAX, Math.max(LIST_CAP_MIN, listCapRaw)),
+        contentCacheBytes: m.contentCacheBytes && m.contentCacheBytes > 0
+            ? m.contentCacheBytes
+            : DEFAULTS.contentCacheBytes,
+    };
+}

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

@@ -0,0 +1,19 @@
+import { type MemoryPreflightPrefsInput } from './memory-preflight-config.js';
+export interface MemoryPreflightResult {
+    available: boolean;
+    block?: string;
+    feedbackListItems?: number;
+    cachedItemCount?: number;
+    reason?: string;
+    truncated?: boolean | undefined;
+    droppedCount?: number | undefined;
+}
+export declare class MemoryPreflightService {
+    private readonly reader;
+    private readonly config;
+    /** path -> body; sub-agent-requested memo contents (Task 4 deviation, see module header). */
+    private readonly cachedMemoContents;
+    constructor(projectRoot: string, prefs: MemoryPreflightPrefsInput);
+    cacheMemoContent(path: string, content: string): void;
+    fetchBlock(_taskTitle: string): Promise<MemoryPreflightResult>;
+}