peaks-loop 4.0.0-beta.9 → 4.0.1

package/dist/services/loop/loop-bee-relation-types.d.ts

@@ -47,15 +47,15 @@ export declare const LoopBeeRelationInputSchema: z.ZodObject<{
     role: z.ZodEnum<["main", "supporting", "candidate", "retired"]>;
     reason: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    role: "main" | "candidate" | "retired" | "supporting";
-    reason: string;
     bee_release_id: number;
     loop_release_id: string;
-}, {
     role: "main" | "candidate" | "retired" | "supporting";
     reason: string;
+}, {
     bee_release_id: number;
     loop_release_id: string;
+    role: "main" | "candidate" | "retired" | "supporting";
+    reason: string;
 }>;
 export type LoopBeeRelationInput = z.input<typeof LoopBeeRelationInputSchema>;
 /**
@@ -80,19 +80,19 @@ export declare const LoopBeeRelationSchema: z.ZodObject<{
     created_at: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     schema_version: "peaks.loop-bee-relation/1";
-    role: "main" | "candidate" | "retired" | "supporting";
-    reason: string;
     id: number;
     created_at: string;
     bee_release_id: number;
     loop_release_id: string;
-}, {
     role: "main" | "candidate" | "retired" | "supporting";
     reason: string;
+}, {
     id: number;
     created_at: string;
     bee_release_id: number;
     loop_release_id: string;
+    role: "main" | "candidate" | "retired" | "supporting";
+    reason: string;
     schema_version?: "peaks.loop-bee-relation/1" | undefined;
 }>;
 export type LoopBeeRelation = z.infer<typeof LoopBeeRelationSchema>;

package/dist/services/loop/loop-release-types.d.ts

@@ -69,15 +69,15 @@ export declare const LoopReleaseM3ExtensionSchema: z.ZodObject<{
     desktop_visible: z.ZodDefault<z.ZodBoolean>;
     export_bundle_format: z.ZodDefault<z.ZodLiteral<"peaks.bundle/1">>;
 }, "strip", z.ZodTypeAny, {
-    export_bundle_format: "peaks.bundle/1";
     shareable: boolean;
     share_excluded_paths: string[];
     desktop_visible: boolean;
+    export_bundle_format: "peaks.bundle/1";
 }, {
-    export_bundle_format?: "peaks.bundle/1" | undefined;
     shareable?: boolean | undefined;
     share_excluded_paths?: string[] | undefined;
     desktop_visible?: boolean | undefined;
+    export_bundle_format?: "peaks.bundle/1" | undefined;
 }>;
 /** Convenience type for the M3 share / desktop subset. */
 export type LoopReleaseM3Extension = z.infer<typeof LoopReleaseM3ExtensionSchema>;
@@ -110,41 +110,41 @@ export declare const LoopReleaseInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     version: string;
     name: string;
+    lifecycle_status: "candidate" | "stable" | "retired";
     id: string;
+    shareable: boolean;
+    share_excluded_paths: string[];
+    desktop_visible: boolean;
+    export_bundle_format: "peaks.bundle/1";
     scenario: string;
     trigger_policy: string;
+    success_criteria: string[];
     interaction_policy: string;
     feedback_policy: string;
     evolution_policy: string;
-    lifecycle_status: "candidate" | "stable" | "retired";
-    export_bundle_format: "peaks.bundle/1";
-    success_criteria: string[];
     evaluator_policy: string[];
     linked_bees: string[];
     run_history: string[];
     crystallization_evidence: string[];
-    shareable: boolean;
-    share_excluded_paths: string[];
-    desktop_visible: boolean;
 }, {
     version: string;
     name: string;
+    lifecycle_status: "candidate" | "stable" | "retired";
     id: string;
     scenario: string;
     trigger_policy: string;
+    success_criteria: string[];
     interaction_policy: string;
     feedback_policy: string;
     evolution_policy: string;
-    lifecycle_status: "candidate" | "stable" | "retired";
-    success_criteria: string[];
     evaluator_policy: string[];
+    shareable?: boolean | undefined;
+    share_excluded_paths?: string[] | undefined;
+    desktop_visible?: boolean | undefined;
     export_bundle_format?: "peaks.bundle/1" | undefined;
     linked_bees?: string[] | undefined;
     run_history?: string[] | undefined;
     crystallization_evidence?: string[] | undefined;
-    shareable?: boolean | undefined;
-    share_excluded_paths?: string[] | undefined;
-    desktop_visible?: boolean | undefined;
 }>;
 /**
  * `LoopReleaseInput` is the *input* shape clients supply: defaulted
@@ -191,42 +191,42 @@ export declare const LoopReleaseSchema: z.ZodObject<{
     schema_version: "peaks.loop/1";
     version: string;
     name: string;
+    lifecycle_status: "candidate" | "stable" | "retired";
     id: string;
+    shareable: boolean;
+    share_excluded_paths: string[];
+    desktop_visible: boolean;
+    export_bundle_format: "peaks.bundle/1";
     scenario: string;
     trigger_policy: string;
+    success_criteria: string[];
     interaction_policy: string;
     feedback_policy: string;
     evolution_policy: string;
-    lifecycle_status: "candidate" | "stable" | "retired";
-    export_bundle_format: "peaks.bundle/1";
-    success_criteria: string[];
     evaluator_policy: string[];
     linked_bees: string[];
     run_history: string[];
     crystallization_evidence: string[];
-    shareable: boolean;
-    share_excluded_paths: string[];
-    desktop_visible: boolean;
 }, {
     version: string;
     name: string;
+    lifecycle_status: "candidate" | "stable" | "retired";
     id: string;
     scenario: string;
     trigger_policy: string;
+    success_criteria: string[];
     interaction_policy: string;
     feedback_policy: string;
     evolution_policy: string;
-    lifecycle_status: "candidate" | "stable" | "retired";
-    success_criteria: string[];
     evaluator_policy: string[];
     schema_version?: "peaks.loop/1" | undefined;
+    shareable?: boolean | undefined;
+    share_excluded_paths?: string[] | undefined;
+    desktop_visible?: boolean | undefined;
     export_bundle_format?: "peaks.bundle/1" | undefined;
     linked_bees?: string[] | undefined;
     run_history?: string[] | undefined;
     crystallization_evidence?: string[] | undefined;
-    shareable?: boolean | undefined;
-    share_excluded_paths?: string[] | undefined;
-    desktop_visible?: boolean | undefined;
 }>;
 export type LoopRelease = z.infer<typeof LoopReleaseSchema>;
 /**

package/dist/services/loop/monotonic-runner.d.ts

@@ -26,23 +26,29 @@ export interface RunMonotonicResult {
     readonly persistedAt: string | null;
     readonly rows: readonly MonotonicScoreRow[];
     readonly report: MonotonicReport;
-    /** Additive surface for non-fatal persistence warnings (e.g. mkdir
+    /** Additive surface for non-fatal persistence warnings (e.g. append
      *  failure). Optional so existing destructures keep compiling. */
     readonly warnings?: readonly string[];
 }
-/** Resolve the slice dir used by both writer + reader — keeps tests
- *  insulated from real sessions. */
+/** Resolve the slice dir — kept for API/BC (run-driver.ts uses it to
+ *  derive `cyclesDir`). The monotonic-runner writer no longer writes
+ *  here; the jsonl-store is the new persistence layer. */
 export declare function sliceDir(projectRoot: string, sid: string, rid: string): string;
-/** Load the most recent prior cycle (highest-N `cycle-N.json`) for
- *  `(sid, rid)` from the slice dir; falls back to the
- *  `.peaks/_sub_agents/<sid>/shared/` dir when no slice-level prior
- *  cycle exists. Returns `null` on any read error. */
+/** Load the most recent prior cycle for `(sid, rid)` from the
+ *  per-session jsonl store (tail scan, O(N) where N = total jsonl
+ *  lines, ~50-100 for a 24h run). Falls back to the legacy
+ *  `.peaks/_sub_agents/<sid>/shared/` dir for cross-session signal.
+ *  Returns `null` on any read error. */
 export declare function loadPreviousCycle(projectRoot: string, sid: string, rid: string): MonotonicCycle | null;
-/** Determine the next cycle index — `max(prior) + 1`, or `1` when none exist. */
+/** Determine the next cycle index — reads the most recent jsonl
+ *  cycle line's `cycle` field + 1 (or `1` when none exist). `rid`
+ *  retained for API compatibility — the jsonl-store is per-session,
+ *  but the line tag carries `rid` so the reader filters to this rid.
+ */
 export declare function nextCycleIndex(projectRoot: string, sid: string, rid: string): number;
-/** Run the guard end-to-end: walk the 4 evaluators, persist the current
- *  cycle score rows, compare against the prior cycle, return a
- *  structured report. */
+/** Run the guard end-to-end: walk the 4 evaluators, persist the
+ *  current cycle to the jsonl store, compare against the prior cycle,
+ *  return a structured report. */
 export declare function runMonotonicCheck(options: RunMonotonicOptions): RunMonotonicResult;
 /** Helper for tests + CLI — resolve project root + sid consistently. */
 export declare function resolveMonotonicContext(opts: {

package/dist/services/loop/monotonic-runner.js

@@ -5,22 +5,26 @@
  * cycle's score rows (per evaluator), invokes each evaluator against
  * the current rid + project, then compares adjacent cycles.
  *
- *  - current cycle score rows are stored at
- *      .peaks/_runtime/<sid>/loop/<rid>/cycle-<N>.json
- *  - previous cycle rows are loaded from the same directory
- *    (or from `.peaks/_sub_agents/<sid>/shared/cycle-<M>.json`
- *    if the slice directory is empty).
+ *  - current cycle score rows are appended to the per-session jsonl
+ *    store at `.peaks/_runtime/<sid>/metrics/slices.jsonl` with the
+ *    tag `{"kind":"monotonic-cycle","rid":"<rid>","cycle":N,"scores":[...]}`.
+ *  - previous cycle rows are read from the same jsonl store (last
+ *    matching tag, O(1) tail scan). When no jsonl record exists, the
+ *    reader falls back to the legacy `.peaks/_sub_agents/<sid>/shared/`
+ *    dir (still reads cycle-N.json) for cross-batch/session signal.
  *  - missing previous cycle → skip (not abort).
  *
- * Karpathy §2 Simplicity First: shell-out to existing
- * `dispatchEvaluator`, persist JSON to disk; no new deps.
+ * Karpathy §2 Simplicity First: reuse `appendMetricLine` +
+ * `readMetricLines` from `observability/jsonl-store.ts`. One append per
+ * cycle replaces N cycle-N.json files; tail scan replaces readdirSync +
+ * regex.
  *
  * File budget: ≤ 800 lines (Karpathy §2).
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { dispatchEvaluator } from './evaluator-dispatcher.js';
 import { checkMonotonicImprovement, toScoreRow, DEFAULT_MONOTONIC_THRESHOLD } from './monotonic-guard.js';
+import { appendMetricLine, readMetricLines } from '../observability/jsonl-store.js';
 import { findProjectRoot } from '../config/config-safety.js';
 function classifyFsError(err) {
     const code = err?.code;
@@ -28,6 +32,8 @@ function classifyFsError(err) {
         return 'NOT_FOUND';
     return 'IO_ERROR';
 }
+/** Tag for cycle lines in the jsonl-store. */
+const MONOTONIC_CYCLE_KIND = 'monotonic-cycle';
 /** Set of evaluator kinds the loop walker actually scores — keeps the
  *  guard surface tight (the verdict-aggregate is the cross-source merge
  *  and not a per-cycle input). */
@@ -37,29 +43,94 @@ const WALKED_EVALUATORS = [
     'security-review',
     'perf-baseline'
 ];
-/** Resolve the slice dir used by both writer + reader — keeps tests
- *  insulated from real sessions. */
+/** Resolve the slice dir — kept for API/BC (run-driver.ts uses it to
+ *  derive `cyclesDir`). The monotonic-runner writer no longer writes
+ *  here; the jsonl-store is the new persistence layer. */
 export function sliceDir(projectRoot, sid, rid) {
     return join(projectRoot, '.peaks', '_runtime', sid, 'loop', rid);
 }
-/** Load the most recent prior cycle (highest-N `cycle-N.json`) for
- *  `(sid, rid)` from the slice dir; falls back to the
- *  `.peaks/_sub_agents/<sid>/shared/` dir when no slice-level prior
- *  cycle exists. Returns `null` on any read error. */
+/** Load the most recent prior cycle for `(sid, rid)` from the
+ *  per-session jsonl store (tail scan, O(N) where N = total jsonl
+ *  lines, ~50-100 for a 24h run). Falls back to the legacy
+ *  `.peaks/_sub_agents/<sid>/shared/` dir for cross-session signal.
+ *  Returns `null` on any read error. */
 export function loadPreviousCycle(projectRoot, sid, rid) {
-    return loadMostRecentCycle(sliceDir(projectRoot, sid, rid))
-        ?? loadMostRecentCycleFromSubAgents(projectRoot, sid);
+    return loadMostRecentCycleFromJsonl(projectRoot, sid, rid)
+        ?? loadMostRecentCycleFromSubAgents(projectRoot, sid, rid);
 }
-function loadMostRecentCycleFromSubAgents(projectRoot, sid) {
+/** Scan the jsonl-store from tail backwards for the most recent
+ *  `monotonic-cycle` line matching `rid`. Returns `null` when no
+ *  matching line exists or any line is malformed. */
+function loadMostRecentCycleFromJsonl(projectRoot, sid, rid) {
+    const lines = readMetricLines(projectRoot, sid);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i] ?? '';
+        const parsed = parseCycleLine(line, rid);
+        if (parsed !== null)
+            return parsed;
+    }
+    return null;
+}
+function parseCycleLine(raw, rid) {
+    let obj;
+    try {
+        const v = JSON.parse(raw);
+        if (v === null || typeof v !== 'object')
+            return null;
+        obj = v;
+    }
+    catch {
+        return null;
+    }
+    if (obj['kind'] !== MONOTONIC_CYCLE_KIND)
+        return null;
+    if (typeof obj['rid'] !== 'string' || obj['rid'] !== rid)
+        return null;
+    const cycle = typeof obj['cycle'] === 'number' ? obj['cycle'] : 0;
+    const scores = parseScoreRows(obj['scores']);
+    return { cycle, scores };
+}
+function parseScoreRows(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const s of raw) {
+        if (s === null || typeof s !== 'object')
+            continue;
+        const r = s;
+        if (typeof r['evaluator'] !== 'string')
+            continue;
+        const gate = r['gateAction'];
+        if (gate !== 'pass' && gate !== 'warn' && gate !== 'block')
+            continue;
+        const observedAt = typeof r['observedAt'] === 'string' ? r['observedAt'] : new Date(0).toISOString();
+        out.push({
+            evaluator: r['evaluator'],
+            score: typeof r['score'] === 'number' ? r['score'] : (gate === 'pass' ? 1.0 : gate === 'warn' ? 0.5 : 0.0),
+            gateAction: gate,
+            degraded: r['degraded'] === true,
+            observedAt
+        });
+    }
+    return out;
+}
+/** Legacy fallback: read the most recent `cycle-N.json` from the
+ *  `.peaks/_sub_agents/<sid>/shared/` dir (cross-session signal).
+ *  Kept verbatim so existing cross-batch signals remain readable. */
+function loadMostRecentCycleFromSubAgents(projectRoot, sid, rid) {
     const dir = join(projectRoot, '.peaks', '_sub_agents', sid, 'shared');
-    return loadMostRecentCycle(dir);
+    return loadMostRecentCycleFromDir(dir, rid);
 }
-function loadMostRecentCycle(dir) {
-    if (!existsSync(dir))
+function loadMostRecentCycleFromDir(dir, rid) {
+    // Lazily import so unit tests in non-windows environments don't pull
+    // node:fs through a static `import`.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const fs = require('node:fs');
+    if (!fs.existsSync(dir))
         return null;
     const readdir = (() => {
         try {
-            return { ok: true, value: require('node:fs').readdirSync(dir) };
+            return { ok: true, value: fs.readdirSync(dir) };
         }
         catch (err) {
             return { ok: false, reason: classifyFsError(err) };
@@ -82,7 +153,7 @@ function loadMostRecentCycle(dir) {
     const target = join(dir, `cycle-${bestCycle}.json`);
     const readFile = (() => {
         try {
-            return { ok: true, value: readFileSync(target, 'utf8') };
+            return { ok: true, value: fs.readFileSync(target, 'utf8') };
         }
         catch (err) {
             return { ok: false, reason: classifyFsError(err) };
@@ -90,9 +161,14 @@ function loadMostRecentCycle(dir) {
     })();
     if (!readFile.ok)
         return null;
-    return parseCycle(readFile.value, bestCycle);
+    const parsed = parseLegacyCycleFile(readFile.value, bestCycle);
+    // `rid` param retained for BC with the legacy dir shape (legacy
+    // files are shared across rids); include it in the parsed object so
+    // future cross-rid reads stay consistent.
+    void rid;
+    return parsed;
 }
-function parseCycle(raw, fallbackCycle) {
+function parseLegacyCycleFile(raw, fallbackCycle) {
     const parse = (() => {
         try {
             return { ok: true, value: JSON.parse(raw) };
@@ -107,38 +183,23 @@ function parseCycle(raw, fallbackCycle) {
     if (parsed === null || typeof parsed !== 'object')
         return null;
     const obj = parsed;
-    const scores = Array.isArray(obj['scores']) ? obj['scores'] : [];
-    const rows = [];
-    for (const s of scores) {
-        if (s === null || typeof s !== 'object')
-            continue;
-        const r = s;
-        if (typeof r['evaluator'] !== 'string')
-            continue;
-        const gate = r['gateAction'];
-        if (gate !== 'pass' && gate !== 'warn' && gate !== 'block')
-            continue;
-        const observedAt = typeof r['observedAt'] === 'string' ? r['observedAt'] : new Date(0).toISOString();
-        rows.push({
-            evaluator: r['evaluator'],
-            score: typeof r['score'] === 'number' ? r['score'] : (gate === 'pass' ? 1.0 : gate === 'warn' ? 0.5 : 0.0),
-            gateAction: gate,
-            degraded: r['degraded'] === true,
-            observedAt
-        });
-    }
-    return { cycle: typeof obj['cycle'] === 'number' ? obj['cycle'] : fallbackCycle, scores: rows };
+    const scores = parseScoreRows(obj['scores']);
+    return { cycle: typeof obj['cycle'] === 'number' ? obj['cycle'] : fallbackCycle, scores };
 }
-/** Determine the next cycle index — `max(prior) + 1`, or `1` when none exist. */
+/** Determine the next cycle index — reads the most recent jsonl
+ *  cycle line's `cycle` field + 1 (or `1` when none exist). `rid`
+ *  retained for API compatibility — the jsonl-store is per-session,
+ *  but the line tag carries `rid` so the reader filters to this rid.
+ */
 export function nextCycleIndex(projectRoot, sid, rid) {
     const prev = loadPreviousCycle(projectRoot, sid, rid);
     if (prev === null)
         return 1;
     return prev.cycle + 1;
 }
-/** Run the guard end-to-end: walk the 4 evaluators, persist the current
- *  cycle score rows, compare against the prior cycle, return a
- *  structured report. */
+/** Run the guard end-to-end: walk the 4 evaluators, persist the
+ *  current cycle to the jsonl store, compare against the prior cycle,
+ *  return a structured report. */
 export function runMonotonicCheck(options) {
     const threshold = options.threshold ?? DEFAULT_MONOTONIC_THRESHOLD;
     const persist = options.persist !== false;
@@ -174,42 +235,20 @@ export function runMonotonicCheck(options) {
     let persistedAt = null;
     const envelopeWarns = [];
     if (persist) {
-        const dir = sliceDir(options.projectRoot, options.sid, options.rid);
-        const mkdir = (() => {
-            try {
-                mkdirSync(dir, { recursive: true });
-                return { ok: true, value: undefined };
-            }
-            catch (err) {
-                return { ok: false, reason: classifyFsError(err) };
-            }
-        })();
-        if (!mkdir.ok) {
-            envelopeWarns.push(`mkdir-failed: ${dir} (${mkdir.reason})`);
-        }
-        const path = join(dir, `cycle-${cycle}.json`);
-        const payload = JSON.stringify({
-            cycle,
+        const line = {
+            kind: MONOTONIC_CYCLE_KIND,
             rid: options.rid,
-            sid: options.sid,
+            cycle,
             persistedAt: new Date().toISOString(),
             scores: rows
-        });
-        const writeFile = (() => {
-            try {
-                writeFileSync(path, payload, 'utf8');
-                return { ok: true, value: undefined };
-            }
-            catch (err) {
-                return { ok: false, reason: classifyFsError(err) };
-            }
-        })();
-        if (writeFile.ok) {
-            persistedAt = path;
+        };
+        const ok = appendMetricLine(options.projectRoot, options.sid, JSON.stringify(line));
+        if (ok) {
+            persistedAt = `jsonl:${options.sid}#cycle=${cycle}`;
         }
         else {
             persistedAt = null;
-            envelopeWarns.push(`write-failed: ${path} (${writeFile.reason})`);
+            envelopeWarns.push(`append-failed: jsonl-store for sid=${options.sid} cycle=${cycle}`);
         }
     }
     return {

package/dist/services/memory/project-memory-service/index/kind-dispatch.d.ts

@@ -0,0 +1,8 @@
+import type { BackupPlanOptions, ExtractPlanOptions, ExtractSessionMemoriesOptions, ExtractSessionMemoriesResult, ProjectMemoryBackupPlan, ProjectMemoryBackupResult, ProjectMemoryBackupSummary, ProjectMemoryExtractPlan, ProjectMemoryExtractResult, ProjectMemoryExtractSummary } from '../types.js';
+export declare function createProjectMemoryExtractPlan(options: ExtractPlanOptions): ProjectMemoryExtractPlan;
+export declare function executeProjectMemoryExtract(options: ExtractPlanOptions): ProjectMemoryExtractResult;
+export declare function createProjectMemoryBackupPlan(options: BackupPlanOptions): ProjectMemoryBackupPlan;
+export declare function executeProjectMemoryBackup(options: BackupPlanOptions): ProjectMemoryBackupResult;
+export declare function summarizeProjectMemoryExtractResult(result: ProjectMemoryExtractResult): ProjectMemoryExtractSummary;
+export declare function summarizeProjectMemoryBackupResult(result: ProjectMemoryBackupResult): ProjectMemoryBackupSummary;
+export declare function extractSessionMemories(options: ExtractSessionMemoriesOptions): ExtractSessionMemoriesResult;