@evomap/evolver-core 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/events/paths.js

@@ -1,44 +1,44 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 /** ~/.evomap, 可 EVOLVER_HOME/EVOMAP_HOME 覆盖. */
-export function evomapHome() {
-    return process.env['EVOLVER_HOME'] ?? process.env['EVOMAP_HOME'] ?? join(homedir(), '.evomap');
+export function evomapHome(env = process.env) {
+    return env['EVOLVER_HOME'] ?? env['EVOMAP_HOME'] ?? join(homedir(), '.evomap');
 }
-export function rootEventsPath() {
-    return join(evomapHome(), 'evolution', 'root_events.jsonl');
+export function rootEventsPath(env = process.env) {
+    return join(evomapHome(env), 'evolution', 'root_events.jsonl');
 }
-export function mvDir() {
-    return join(evomapHome(), 'evolution', 'mv');
+export function mvDir(env = process.env) {
+    return join(evomapHome(env), 'evolution', 'mv');
 }
 /** 可进化人格模型持久化文件 (五维向量 + 各键统计 + 变更历史). v1 personality_state.json 的 v2 落点. */
-export function personalityStatePath() {
-    return join(evomapHome(), 'evolution', 'personality_state.json');
+export function personalityStatePath(env = process.env) {
+    return join(evomapHome(env), 'evolution', 'personality_state.json');
 }
-export function assetsDir() {
-    return join(evomapHome(), 'assets');
+export function assetsDir(env = process.env) {
+    return join(evomapHome(env), 'assets');
 }
 /** M1 raw-material substrate (append-only jsonl consumed by the cycle). */
-export function materialDir() {
-    return join(evomapHome(), 'evolution', 'material');
+export function materialDir(env = process.env) {
+    return join(evomapHome(env), 'evolution', 'material');
 }
 /** MaterialStore backing file. */
-export function materialStorePath() {
-    return join(materialDir(), 'material.jsonl');
+export function materialStorePath(env = process.env) {
+    return join(materialDir(env), 'material.jsonl');
 }
 /** Per-source watermark cursor used to make re-ingest idempotent (file-level dedup). */
-export function materialWatermarkPath() {
-    return join(materialDir(), 'watermark.json');
+export function materialWatermarkPath(env = process.env) {
+    return join(materialDir(env), 'watermark.json');
 }
 /** Proxy LLM-trace day-files dir (`llm-trace-YYYYMMDD.jsonl`), the route-savings source for the value ledger.
  *  Mirrors the proxy's EVOLVER_LLM_TRACE_DIR default so the outreach layer reads what the proxy wrote. */
-export function tracesDir() {
-    return process.env['EVOLVER_LLM_TRACE_DIR'] ?? join(evomapHome(), 'proxy', 'traces');
+export function tracesDir(env = process.env) {
+    return env['EVOLVER_LLM_TRACE_DIR'] ?? join(evomapHome(env), 'proxy', 'traces');
 }
 /** Hub-asset audit trail (`asset_call_log.jsonl`): one JSONL line per hub-asset interaction (search hit/miss,
  *  reuse/reference, publish, review). Written best-effort by AssetCallLog; the desktop's RecallHistory / 召回历程
  *  reads it. Defaults to the evomap home root, beside assets/ + evolution/.
  *  NOTE(reuse/#234): confirm this matches where the proxy/RecallHistory reads — best-effort append, so a path
  *  mismatch degrades the audit line, never the reuse write itself. */
-export function assetCallLogPath() {
-    return join(evomapHome(), 'asset_call_log.jsonl');
+export function assetCallLogPath(env = process.env) {
+    return join(evomapHome(env), 'asset_call_log.jsonl');
 }

package/dist/events/public.d.ts

@@ -5,10 +5,12 @@ export type { Projector } from './replayer.js';
 export { eventCountsProjector, DEFAULT_PROJECTORS } from './projectors.js';
 export type { EventCountsMV } from './projectors.js';
 export { LineTooLargeError, MAX_LINE_BYTES } from './eventStore.js';
+export { ArchiveSegmentConflictError, InvalidRootEventArchiveError, InvalidRootEventLogError, RootEventHistoryGapError, archiveRootEvents, inspectRootEventArchive, planRootEventArchive, readRootEventHistory, rootEventArchiveDir, rootEventArchiveSegmentName, validateRootEventHistory, ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS, } from './eventArchive.js';
+export type { RootEventArchiveOptions, RootEventArchivePlan, RootEventArchiveResult, RootEventArchiveStats, } from './eventArchive.js';
 export { rootEventsPath, evomapHome, mvDir, personalityStatePath, assetsDir, materialDir, materialStorePath, materialWatermarkPath, tracesDir, assetCallLogPath } from './paths.js';
 export { EVENT_SCHEMA_VERSION } from './eventSchema.js';
 export type { RootEvent, RawEvent, HumanNarrative, Actor, Replayability } from './eventSchema.js';
 export { readEvents, statusReport, listCycles, showCycle, listTriggers, dailySummary, buildNarrativeSnapshot, NARRATIVE_DEFAULT_LIMIT, NARRATIVE_MAX_LIMIT, } from './reports.js';
-export { buildRetentionReport, defaultMaterialCursorPath, RETENTION_DEFAULT_MAX_MATERIAL_BYTES, RETENTION_DEFAULT_MAX_MATERIAL_RECORDS, RETENTION_DEFAULT_MAX_ROOT_BYTES, RETENTION_DEFAULT_MAX_ROOT_EVENTS, RETENTION_DEFAULT_ROOT_TAIL_EVENTS, RETENTION_DEFAULT_WATCH_RATIO, } from './retention.js';
+export { buildRetentionReport, defaultMaterialCursorPath, defaultMaterialCursorPaths, RETENTION_DEFAULT_MAX_MATERIAL_BYTES, RETENTION_DEFAULT_MAX_MATERIAL_RECORDS, RETENTION_DEFAULT_MAX_ROOT_BYTES, RETENTION_DEFAULT_MAX_ROOT_EVENTS, RETENTION_DEFAULT_ROOT_TAIL_EVENTS, RETENTION_DEFAULT_WATCH_RATIO, } from './retention.js';
 export type { ReportEvent, StatusReport, CycleSummary, CycleTimeline, TriggerRow, DailySummary, NarrativeEntry, NarrativeOutcome, NarrativeSnapshot, NarrativeSnapshotOptions, } from './reports.js';
 export type { MaterialRetentionSnapshot, RetentionReport, RetentionReportOptions, RetentionState, RetentionThresholds, RootRetentionSnapshot, } from './retention.js';

package/dist/events/public.js

@@ -2,7 +2,8 @@ export { Ingestor, EVENT_TYPES, registerEventType, isKnownEventType, IngestValid
 export { Replayer } from './replayer.js';
 export { eventCountsProjector, DEFAULT_PROJECTORS } from './projectors.js';
 export { LineTooLargeError, MAX_LINE_BYTES } from './eventStore.js';
+export { ArchiveSegmentConflictError, InvalidRootEventArchiveError, InvalidRootEventLogError, RootEventHistoryGapError, archiveRootEvents, inspectRootEventArchive, planRootEventArchive, readRootEventHistory, rootEventArchiveDir, rootEventArchiveSegmentName, validateRootEventHistory, ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS, } from './eventArchive.js';
 export { rootEventsPath, evomapHome, mvDir, personalityStatePath, assetsDir, materialDir, materialStorePath, materialWatermarkPath, tracesDir, assetCallLogPath } from './paths.js';
 export { EVENT_SCHEMA_VERSION } from './eventSchema.js';
 export { readEvents, statusReport, listCycles, showCycle, listTriggers, dailySummary, buildNarrativeSnapshot, NARRATIVE_DEFAULT_LIMIT, NARRATIVE_MAX_LIMIT, } from './reports.js';
-export { buildRetentionReport, defaultMaterialCursorPath, RETENTION_DEFAULT_MAX_MATERIAL_BYTES, RETENTION_DEFAULT_MAX_MATERIAL_RECORDS, RETENTION_DEFAULT_MAX_ROOT_BYTES, RETENTION_DEFAULT_MAX_ROOT_EVENTS, RETENTION_DEFAULT_ROOT_TAIL_EVENTS, RETENTION_DEFAULT_WATCH_RATIO, } from './retention.js';
+export { buildRetentionReport, defaultMaterialCursorPath, defaultMaterialCursorPaths, RETENTION_DEFAULT_MAX_MATERIAL_BYTES, RETENTION_DEFAULT_MAX_MATERIAL_RECORDS, RETENTION_DEFAULT_MAX_ROOT_BYTES, RETENTION_DEFAULT_MAX_ROOT_EVENTS, RETENTION_DEFAULT_ROOT_TAIL_EVENTS, RETENTION_DEFAULT_WATCH_RATIO, } from './retention.js';

package/dist/events/retention.d.ts

@@ -4,7 +4,7 @@ export declare const RETENTION_DEFAULT_MAX_ROOT_BYTES: number;
 export declare const RETENTION_DEFAULT_MAX_MATERIAL_RECORDS = 10000;
 export declare const RETENTION_DEFAULT_MAX_MATERIAL_BYTES: number;
 export declare const RETENTION_DEFAULT_WATCH_RATIO = 0.8;
-export declare const RETENTION_DEFAULT_ROOT_TAIL_EVENTS: number;
+export declare const RETENTION_DEFAULT_ROOT_TAIL_EVENTS = 10000;
 export interface RetentionThresholds {
     maxRecords: number;
     maxBytes: number;
@@ -22,6 +22,17 @@ export interface RootRetentionSnapshot {
     lastSeq: number | null;
     firstTs: string | null;
     lastTs: string | null;
+    archiveSegments: number;
+    archiveRecords: number;
+    archiveBytes: number;
+    archiveInvalidLines: number;
+    historyRecords: number;
+    historyBytes: number;
+    historyConflicts: number;
+    historyGaps: number;
+    historyIntegrityErrors: number;
+    archiveRotationSupported: true;
+    archiveRotationSafe: boolean;
     protectTailEvents: number;
     destructivePruneSafe: false;
     reason: string;
@@ -36,12 +47,22 @@ export interface MaterialRetentionSnapshot {
     thresholds: RetentionThresholds;
     firstCapturedAt: string | null;
     lastCapturedAt: string | null;
+    archiveSegments: number;
+    archiveRecords: number;
+    archiveBytes: number;
+    archiveInvalidLines: number;
+    historyRecords: number;
+    historyBytes: number;
+    cursorCount: number;
+    minCursor: number;
     cursorValid: boolean;
     cursorInRange: boolean;
     cursor: number;
     effectiveCursor: number;
     consumedPrefix: number;
     pending: number;
+    archiveRotationSupported: true;
+    archiveRotationSafe: boolean;
     destructivePruneSafe: false;
     reason: string;
 }
@@ -58,6 +79,7 @@ export interface RetentionReportOptions {
     rootEventsPath?: string;
     materialStorePath?: string;
     materialCursorPath?: string;
+    materialCursorPaths?: readonly string[];
     now?: () => number;
     maxRootEvents?: number;
     maxRootBytes?: number;
@@ -67,4 +89,5 @@ export interface RetentionReportOptions {
     protectRootTailEvents?: number;
 }
 export declare function defaultMaterialCursorPath(path?: string): string;
+export declare function defaultMaterialCursorPaths(path?: string): string[];
 export declare function buildRetentionReport(opts?: RetentionReportOptions): RetentionReport;

package/dist/events/retention.js

@@ -1,24 +1,29 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { material } from '../schema/material.js';
+import { inspectMaterialArchive, planMaterialArchive, readMaterialHistory, } from '../material/materialArchive.js';
 import { rootEvent } from './eventSchema.js';
+import { ArchiveSegmentConflictError, inspectRootEventArchive, readRootEventHistory, RootEventHistoryGapError, ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS, validateRootEventHistory, } from './eventArchive.js';
 import { materialStorePath as defaultMaterialStorePath, rootEventsPath as defaultRootEventsPath } from './paths.js';
-import { NARRATIVE_MAX_LIMIT } from './reports.js';
 export const RETENTION_DEFAULT_MAX_ROOT_EVENTS = 100_000;
 export const RETENTION_DEFAULT_MAX_ROOT_BYTES = 64 * 1024 * 1024;
 export const RETENTION_DEFAULT_MAX_MATERIAL_RECORDS = 10_000;
 export const RETENTION_DEFAULT_MAX_MATERIAL_BYTES = 64 * 1024 * 1024;
 export const RETENTION_DEFAULT_WATCH_RATIO = 0.8;
-export const RETENTION_DEFAULT_ROOT_TAIL_EVENTS = Math.max(1_000, NARRATIVE_MAX_LIMIT);
+export const RETENTION_DEFAULT_ROOT_TAIL_EVENTS = ROOT_EVENT_ARCHIVE_DEFAULT_KEEP_EVENTS;
 export function defaultMaterialCursorPath(path = defaultMaterialStorePath()) {
     return join(dirname(path), 'cycle-consumer.json');
 }
+export function defaultMaterialCursorPaths(path = defaultMaterialStorePath()) {
+    return [defaultMaterialCursorPath(path), join(dirname(path), 'distill-consumer.json')];
+}
 export function buildRetentionReport(opts = {}) {
     const now = new Date((opts.now ?? Date.now)()).toISOString();
     const watchRatio = ratioOf(opts.watchRatio, RETENTION_DEFAULT_WATCH_RATIO);
     const rootPath = opts.rootEventsPath ?? defaultRootEventsPath();
     const materialPath = opts.materialStorePath ?? defaultMaterialStorePath();
-    const cursorPath = opts.materialCursorPath ?? defaultMaterialCursorPath(materialPath);
+    const cursorPaths = opts.materialCursorPaths
+        ?? (opts.materialCursorPath !== undefined ? [opts.materialCursorPath] : defaultMaterialCursorPaths(materialPath));
     const rootThresholds = {
         maxRecords: positiveInt(opts.maxRootEvents, RETENTION_DEFAULT_MAX_ROOT_EVENTS),
         maxBytes: positiveInt(opts.maxRootBytes, RETENTION_DEFAULT_MAX_ROOT_BYTES),
@@ -30,7 +35,7 @@ export function buildRetentionReport(opts = {}) {
         watchRatio,
     };
     const rootEvents = rootSnapshot(rootPath, rootThresholds, positiveInt(opts.protectRootTailEvents, RETENTION_DEFAULT_ROOT_TAIL_EVENTS));
-    const material = materialSnapshot(materialPath, cursorPath, materialThresholds);
+    const material = materialSnapshot(materialPath, cursorPaths, materialThresholds);
     const warnings = buildWarnings(rootEvents, material);
     const nextActions = buildNextActions(rootEvents, material);
     return {
@@ -45,6 +50,22 @@ export function buildRetentionReport(opts = {}) {
 }
 function rootSnapshot(path, thresholds, protectTailEvents) {
     const stats = readJsonl(path, (value) => rootEvent.parse(value));
+    const archive = inspectRootEventArchive(path);
+    const historyRecords = readRootEventHistory(path).length;
+    let historyConflicts = 0;
+    let historyGaps = 0;
+    let historyIntegrityErrors = 0;
+    try {
+        validateRootEventHistory(path);
+    }
+    catch (error) {
+        if (error instanceof ArchiveSegmentConflictError)
+            historyConflicts = 1;
+        else if (error instanceof RootEventHistoryGapError)
+            historyGaps = 1;
+        else
+            historyIntegrityErrors = 1;
+    }
     return {
         name: 'root_events',
         exists: stats.exists,
@@ -57,34 +78,67 @@ function rootSnapshot(path, thresholds, protectTailEvents) {
         lastSeq: stats.last?.seq ?? null,
         firstTs: stats.first?.ts ?? null,
         lastTs: stats.last?.ts ?? null,
+        archiveSegments: archive.segments,
+        archiveRecords: archive.records,
+        archiveBytes: archive.bytes,
+        archiveInvalidLines: archive.invalidLines,
+        historyRecords,
+        historyBytes: archive.bytes + stats.bytes,
+        historyConflicts,
+        historyGaps,
+        historyIntegrityErrors,
+        archiveRotationSupported: true,
+        archiveRotationSafe: stats.invalidLines === 0 && archive.invalidLines === 0 && historyConflicts === 0 && historyGaps === 0 && historyIntegrityErrors === 0,
         protectTailEvents: Math.min(stats.records, protectTailEvents),
         destructivePruneSafe: false,
-        reason: 'root_events is the replay and audit source; archive readers must exist before destructive prune is safe',
+        reason: 'archive rotation preserves replay history; destructive archive deletion remains disabled',
     };
 }
-function materialSnapshot(path, cursorPath, thresholds) {
+function materialSnapshot(path, cursorPaths, thresholds) {
     const stats = readJsonl(path, (value) => material.parse(value));
-    const cursor = readCycleCursor(cursorPath);
-    const cursorInRange = cursor.value >= 0 && cursor.value <= stats.records;
-    const effectiveCursor = cursorInRange ? cursor.value : clampCursor(cursor.value, stats.records);
+    const archive = inspectMaterialArchive(path);
+    const history = readMaterialHistory(path);
+    const historyRecords = history.length;
+    const cursors = readMaterialCursors(cursorPaths, historyRecords, archive.records);
+    const effectiveCursor = cursors.inRange ? cursors.cycle : clampCursor(cursors.cycle, historyRecords);
+    const effectiveMinimum = cursors.inRange ? cursors.min : clampCursor(cursors.min, historyRecords);
+    let archiveRotationSafe = stats.invalidLines === 0 && archive.invalidLines === 0 && cursors.valid && cursors.inRange;
+    if (archiveRotationSafe) {
+        try {
+            planMaterialArchive({ path, cursorPaths, keepRecords: 1 });
+        }
+        catch {
+            archiveRotationSafe = false;
+        }
+    }
     return {
         name: 'material',
-        exists: stats.exists,
+        exists: stats.exists || archive.exists,
         bytes: stats.bytes,
         records: stats.records,
         invalidLines: stats.invalidLines,
         state: retentionState(stats.records, stats.bytes, thresholds),
         thresholds,
-        firstCapturedAt: stats.first?.capturedAt ?? null,
-        lastCapturedAt: stats.last?.capturedAt ?? null,
-        cursorValid: cursor.valid,
-        cursorInRange,
-        cursor: cursor.value,
+        firstCapturedAt: history[0]?.capturedAt ?? null,
+        lastCapturedAt: history[history.length - 1]?.capturedAt ?? null,
+        archiveSegments: archive.segments,
+        archiveRecords: archive.records,
+        archiveBytes: archive.bytes,
+        archiveInvalidLines: archive.invalidLines,
+        historyRecords,
+        historyBytes: archive.bytes + stats.bytes,
+        cursorCount: cursors.count,
+        minCursor: effectiveMinimum,
+        cursorValid: cursors.valid,
+        cursorInRange: cursors.inRange,
+        cursor: cursors.cycle,
         effectiveCursor,
-        consumedPrefix: effectiveCursor,
-        pending: Math.max(0, stats.records - effectiveCursor),
+        consumedPrefix: effectiveMinimum,
+        pending: Math.max(0, historyRecords - effectiveCursor),
+        archiveRotationSupported: true,
+        archiveRotationSafe,
         destructivePruneSafe: false,
-        reason: 'material cursor is index-based; prune requires atomic archive plus cursor rewrite',
+        reason: 'archive rotation preserves absolute consumer cursors and full material history; destructive archive deletion remains disabled',
     };
 }
 function readJsonl(path, parse) {
@@ -111,19 +165,49 @@ function readJsonl(path, parse) {
     }
     return { exists: true, bytes, records, invalidLines, first, last };
 }
-function readCycleCursor(path) {
-    if (!existsSync(path))
-        return { exists: false, valid: true, value: 0 };
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        if (typeof parsed.cycle === 'number' && Number.isFinite(parsed.cycle)) {
-            return { exists: true, valid: true, value: Math.floor(parsed.cycle) };
+function readMaterialCursors(paths, historyRecords, archiveRecords) {
+    let valid = true;
+    let inRange = true;
+    let cycle = 0;
+    let cycleFound = false;
+    const values = [];
+    for (const path of paths) {
+        if (!existsSync(path))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            valid = false;
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            valid = false;
+            continue;
+        }
+        for (const [group, value] of Object.entries(parsed)) {
+            if (!Number.isSafeInteger(value) || value < 0) {
+                valid = false;
+                continue;
+            }
+            const position = value;
+            values.push(position);
+            if (position > historyRecords)
+                inRange = false;
+            if (group === 'cycle' && !cycleFound) {
+                cycle = position;
+                cycleFound = true;
+            }
         }
-        return { exists: true, valid: false, value: 0 };
-    }
-    catch {
-        return { exists: true, valid: false, value: 0 };
     }
+    return {
+        valid,
+        inRange,
+        count: values.length,
+        cycle,
+        min: values.length === 0 ? archiveRecords : Math.min(...values),
+    };
 }
 function retentionState(records, bytes, thresholds) {
     if (records > thresholds.maxRecords || bytes > thresholds.maxBytes)
@@ -136,30 +220,42 @@ function buildWarnings(root, mat) {
     const out = [];
     if (root.invalidLines > 0)
         out.push(`root_events has ${root.invalidLines} invalid jsonl line(s); recover before rotating`);
+    if (root.archiveInvalidLines > 0)
+        out.push(`root_events archive has ${root.archiveInvalidLines} invalid jsonl line(s); repair archive integrity before rotating again`);
+    if (root.historyConflicts > 0)
+        out.push('root_events active/archive history has conflicting seq records; repair audit integrity before rotating');
+    if (root.historyGaps > 0)
+        out.push('root_events active/archive history has a seq gap; restore the missing audit segment before rotating');
+    if (root.historyIntegrityErrors > 0)
+        out.push('root_events history fails structural integrity checks; repair event ordering before rotating');
     if (mat.invalidLines > 0)
         out.push(`material store has ${mat.invalidLines} invalid jsonl line(s); inspect before rotating`);
     if (!mat.cursorValid)
         out.push('material cursor is unreadable; retention uses effectiveCursor=0 until the cursor is repaired');
     if (mat.cursorValid && !mat.cursorInRange)
-        out.push(`material cursor ${mat.cursor} is outside material record range 0..${mat.records}; retention uses effectiveCursor=${mat.effectiveCursor}`);
+        out.push(`material cursor ${mat.cursor} is outside material record range 0..${mat.historyRecords}; retention uses effectiveCursor=${mat.effectiveCursor}`);
     if (root.state === 'over_limit')
-        out.push('root_events exceeds retention thresholds; plan archive support before deleting audit lines');
+        out.push('root_events exceeds retention thresholds for the active log; preview archive rotation before writing');
+    if (mat.archiveInvalidLines > 0)
+        out.push(`material archive has ${mat.archiveInvalidLines} invalid jsonl line(s); repair archive integrity before rotating again`);
+    if (!mat.archiveRotationSafe)
+        out.push('material active/archive/cursor state is not safe for rotation; run archive-material preview after repairing integrity');
     if (mat.state === 'over_limit')
-        out.push('material store exceeds retention thresholds; archive consumed prefix only with cursor rewrite');
+        out.push('material active store exceeds retention thresholds; preview absolute-cursor archive rotation before writing');
     if (mat.pending > 0)
         out.push(`material store has ${mat.pending} pending record(s); do not prune pending material`);
     return out;
 }
 function buildNextActions(root, mat) {
     const out = [
-        'keep destructive prune disabled until archive readers are wired into reports, replay and cycle recovery',
+        'archive rotation is available; keep destructive prune disabled for archive deletion',
     ];
     if (root.state !== 'ok')
-        out.push(`root_events ${root.state}: keep at least the last ${root.protectTailEvents} event(s) active after future archive`);
+        out.push(`root_events ${root.state}: run retention archive-root preview, then keep at least the last ${root.protectTailEvents} active event(s)`);
     if (!mat.cursorValid || !mat.cursorInRange)
-        out.push('material: repair the cycle cursor before archiving consumed material');
-    if (mat.consumedPrefix > 0)
-        out.push(`material: ${mat.consumedPrefix} consumed prefix record(s) are archive candidates after atomic cursor rewrite exists`);
+        out.push('material: repair the cycle cursor and any other durable consumer cursor before archiving consumed material');
+    if (mat.consumedPrefix > mat.archiveRecords)
+        out.push(`material: ${mat.consumedPrefix - mat.archiveRecords} consumed prefix record(s) may be archived with archive-material without rewriting cursors`);
     if (mat.pending > 0)
         out.push('material: process or inspect pending records before any future prune');
     return out;

package/dist/exec/autoExec.d.ts

@@ -2,13 +2,14 @@ import type { AssetStoreProvider } from '../assetstore/provider.js';
 import { type ProvenanceStore } from '../assetstore/provenance.js';
 import type { ReviewLedger } from '../assetstore/reviewLedger.js';
 import type { GeneCandidateInput } from '../algo/geneSelection.js';
-import type { CycleEngine, SolidifyPermitGate } from '../algo/cycleEngine.js';
+import type { CycleEngine, ExecutionFailureKind, SolidifyPermitGate } from '../algo/cycleEngine.js';
 import { type AutonomousSafety } from './autonomousCycle.js';
 import type { GitRunner, ValidateHook } from './claudeBridge.js';
 import type { AgentRunner } from './runnerRegistry.js';
 import { type OpenPrLister } from './openPrRegistry.js';
 import type { ReuseOutcomeSummary, ReuseOutcomeEvent } from '../ops/reuseOutcomes.js';
 import type { PersonalityStore } from '../personality/store.js';
+import type { MemoryGraphProvider } from '../algo/memoryGraph.js';
 export interface AutoExecTask {
     id: string;
     repo: string;
@@ -39,6 +40,8 @@ export interface AutoExecVerdict {
         score: number;
     };
     proofOfWork?: unknown;
+    failureKind?: ExecutionFailureKind;
+    exitCode?: number | null;
     usedAssetIds?: readonly string[];
 }
 /**
@@ -97,6 +100,8 @@ export interface AutoExecDeps {
     /** Observed `value.recall` events (#274 slice 3): folded into the same soft re-order as reuseOutcomes (lower
      *  weight) so transcript-observed recall influences selection. Forwarded to runEvolutionCycle. Omit → none. */
     recallEvents?: readonly ReuseOutcomeEvent[];
+    /** Scoped local MemoryGraph seam. Queries and records structured outcome data only. */
+    memoryGraph?: MemoryGraphProvider;
     /** Optional daemon-level explicit strategy preset name, e.g. EVOLVE_STRATEGY. */
     strategyName?: string;
     /** Optional evolvable personality store shared with CycleEngine and the exec prompt. */

package/dist/exec/autoExec.js

@@ -122,6 +122,9 @@ export async function runAutoExecTask(deps, rawTask, safety) {
         const gi = intakeGene({
             category: 'repair', signals_match: cycleSignals, strategy: [...task.strategy],
             summary: task.expectedEffect.slice(0, 80), ...(task.validationCmds ? { validation: [...task.validationCmds] } : {}),
+            // A task's seeded strategy is an execution-entry seed (the operator/daemon supplied a learned strategy to
+            // run/evolve), not a skill/session transcription → `evolved` per V1 #302 classifyProvenance.
+            generation_meta: { source: 'evolved' },
         });
         if (gi.ok && gi.gene) {
             await deps.store.put(gi.gene);
@@ -158,6 +161,15 @@ export async function runAutoExecTask(deps, rawTask, safety) {
     // The forced pick still passes every hard gate downstream (candidate pool, ban, epigenetic
     // suppression), so this never bypasses trust/review/inert filtering.
     const cycleForcedGeneId = task.forcedGeneId ?? seededStrategyGeneId;
+    let memoryGraphAdvice;
+    if (deps.memoryGraph) {
+        try {
+            memoryGraphAdvice = await deps.memoryGraph.query({ workspace: task.repo, signals: cycleSignals });
+        }
+        catch {
+            memoryGraphAdvice = undefined;
+        }
+    }
     const res = await runEvolutionCycle(deps.engine, deps.store, {
         ...(deps.provenance ? { provenance: deps.provenance } : {}),
         ...(deps.review ? { review: deps.review } : {}),
@@ -166,6 +178,7 @@ export async function runAutoExecTask(deps, rawTask, safety) {
         ...(deps.solidifyPermit ? { solidifyPermit: deps.solidifyPermit } : {}),
         ...(deps.reuseOutcomes ? { reuseOutcomes: deps.reuseOutcomes } : {}),
         ...(deps.recallEvents ? { recallEvents: deps.recallEvents } : {}),
+        ...(memoryGraphAdvice ? { memoryGraphAdvice } : {}),
         ...(strategyName !== undefined ? { strategyName } : {}),
         ...(cycleForcedGeneId !== undefined ? { forcedGeneId: cycleForcedGeneId } : {}),
         cycleId,
@@ -181,6 +194,25 @@ export async function runAutoExecTask(deps, rawTask, safety) {
     });
     const status = res.finalStage === 'solidified' ? 'solidified' : res.finalStage === 'failed' ? 'failed' : 'innovated';
     const cap = res.capsule;
+    if (deps.memoryGraph && res.decision?.selectedGeneId && (res.finalStage === 'solidified' || res.finalStage === 'failed')) {
+        const producedSuccess = res.finalStage === 'solidified' && res.producedValue === true;
+        try {
+            await deps.memoryGraph.recordOutcome({
+                workspace: task.repo,
+                signals: cycleSignals,
+                geneId: res.decision.selectedGeneId,
+                // MemoryGraph has no inert status yet, so record a no-op as conservative failed evidence instead of reward.
+                status: producedSuccess ? 'success' : 'failed',
+                score: res.finalStage === 'solidified' && !res.producedValue
+                    ? 0
+                    : cap?.outcome?.score ?? (producedSuccess ? 1 : 0),
+                at: new Date().toISOString(),
+            });
+        }
+        catch {
+            // Memory persistence is advisory and must never fail the autonomous task.
+        }
+    }
     const hubAssetIds = new Set(hubCandidates.map((c) => c.assetId).filter((id) => typeof id === 'string' && id.length > 0));
     const selectedAssetId = res.decision?.selectedAssetId;
     const usedAssetIds = selectedAssetId && hubAssetIds.has(selectedAssetId) ? [selectedAssetId] : [];
@@ -189,6 +221,8 @@ export async function runAutoExecTask(deps, rawTask, safety) {
         ...(res.reasons.length > 0 && status !== 'solidified' ? { reason: res.reasons.join('; ') } : {}),
         ...(cap?.outcome ? { outcome: cap.outcome } : {}),
         ...(cap?.proof_of_work ? { proofOfWork: cap.proof_of_work } : {}),
+        ...(res.failureKind !== undefined ? { failureKind: res.failureKind } : {}),
+        ...(res.exitCode !== undefined ? { exitCode: res.exitCode } : {}),
         ...(usedAssetIds.length > 0 ? { usedAssetIds } : {}),
     };
 }

package/dist/exec/autonomousCycle.d.ts

@@ -29,6 +29,8 @@ export interface AutonomousSafety {
     /** Only embed trusted gene strategies (#45). Default true. */
     requireTrustedGene?: boolean;
     timeoutMs?: number;
+    /** Cooperative cancellation propagated to the spawned runner process tree. */
+    signal?: AbortSignal;
 }
 /**
  * Build the fully-hardened `execute` for an autonomous run against `repo`. Composes every exec-bridge control

package/dist/exec/autonomousCycle.js

@@ -43,12 +43,16 @@ const CODEX_DEFAULT_AGENT_OPTIONS = {};
 // auto-approve shell+write, but Cursor has no verified per-run allowlist/sandbox mapping yet, so skipPermissions
 // is refused outright. Use default cursor with worktree isolation until the CLI is run-verified.
 const CURSOR_DEFAULT_AGENT_OPTIONS = {};
+// Gemini's verified safe default is `--approval-mode auto_edit`; shell remains gated and --yolo is refused.
+const GEMINI_DEFAULT_AGENT_OPTIONS = {};
 /** Per-runner safe default agent options — claude bypasses-with-bounds; codex + cursor stay non-bypassing (codex sandboxed; cursor skip refused, #66). */
 function defaultAgentOptions(runner) {
     if (runner === 'codex')
         return CODEX_DEFAULT_AGENT_OPTIONS;
     if (runner === 'cursor')
         return CURSOR_DEFAULT_AGENT_OPTIONS;
+    if (runner === 'gemini')
+        return GEMINI_DEFAULT_AGENT_OPTIONS;
     return CLAUDE_DEFAULT_AGENT_OPTIONS;
 }
 /**
@@ -70,6 +74,7 @@ export function makeSafeExecute(repo, store, safety, opts = {}) {
         requireTrustedGene: safety.requireTrustedGene ?? true,
         agentOptions: safety.agentOptions ?? defaultAgentOptions(safety.runner),
         ...(safety.timeoutMs !== undefined ? { timeoutMs: safety.timeoutMs } : {}),
+        ...(safety.signal ? { signal: safety.signal } : {}),
         resolveGene: makeTrustedGeneResolver(store, opts.provenance, opts.review, opts.includeProbation ?? false),
         ...(opts.validate ? { validate: opts.validate } : {}),
         ...(opts.validationCmds ? { validationCmds: opts.validationCmds } : {}),

package/dist/exec/claudeBridge.d.ts

@@ -4,10 +4,16 @@ import type { ExecutionResult } from '../algo/cycleEngine.js';
 import { type GeneStrategyInfo } from './prompt.js';
 import type { PersonalityStore } from '../personality/store.js';
 import { type AgentRunner, type AgentRunnerOptions, type RunnerName } from './runnerRegistry.js';
-export { resolveSpawnCommand, spawnCapture, UnboundedSkipPermissionsError, UnsupportedCursorSkipPermissionsError, claudeRunnerArgs, makeClaudeHeadlessRunner, claudeHeadlessRunner, codexRunnerArgs, makeCodexHeadlessRunner, cursorRunnerArgs, makeCursorHeadlessRunner, getRunnerSpec, } from './runnerRegistry.js';
+export { resolveSpawnCommand, spawnCapture, DEFAULT_MAX_CAPTURE_BYTES, UnboundedSkipPermissionsError, UnsupportedCursorSkipPermissionsError, UnsupportedGeminiPermissionOptionsError, claudeRunnerArgs, makeClaudeHeadlessRunner, claudeHeadlessRunner, codexRunnerArgs, makeCodexHeadlessRunner, cursorRunnerArgs, makeCursorHeadlessRunner, getRunnerSpec, geminiRunnerArgs, makeGeminiHeadlessRunner, classifyGeminiRunnerResult, } from './runnerRegistry.js';
 export type { AgentRunContext, AgentRunResult, AgentRunner, RunnerName, AgentRunnerOptions, ClaudeRunnerOptions, CodexRunnerOptions, AgentRunnerSpec, } from './runnerRegistry.js';
+export interface GitRunnerOptions {
+    processSignalMode?: 'cancel' | 'ignore';
+}
 /** Run a git subcommand in cwd and return its stdout. */
-export type GitRunner = (args: readonly string[], cwd: string) => Promise<string>;
+export type GitRunner = (args: readonly string[], cwd: string, signal?: AbortSignal, options?: GitRunnerOptions) => Promise<string>;
+export type GitPatchWriter = (args: readonly string[], cwd: string, destination: string, signal?: AbortSignal, 
+/** Call immediately after this writer exclusively creates `destination`. */
+onDestinationOpened?: () => void) => Promise<void>;
 /** Resolve the selected gene's learned strategy (for prompt enrichment). */
 export type GeneResolver = (geneId: string) => Promise<GeneStrategyInfo | null> | GeneStrategyInfo | null;
 /** Decide success from the post-run working tree (e.g. run the gene's validation plan). */
@@ -29,6 +35,12 @@ export interface ExecBridgeOptions {
     agentOptions?: AgentRunnerOptions;
     /** Default: spawns `git`. Inject a fake in tests. */
     git?: GitRunner;
+    /** Optional complete-patch sink. The default streams built-in git output directly to disk. */
+    gitPatchWriter?: GitPatchWriter;
+    /** Test seam for fallback patch persistence; production callers should use the exclusive private writer. */
+    writePatchFile?: (path: string, patch: string) => void;
+    /** Test seam for temporary patch cleanup; production callers should use the filesystem default. */
+    removePatchFile?: (path: string) => void;
     /** Default: EVOLVE_EXEC_BRIDGE === '1'. Set true to force-enable (e.g. integration tests). */
     enabled?: boolean;
     /**
@@ -57,6 +69,8 @@ export interface ExecBridgeOptions {
     requireTrustedGene?: boolean;
     /** Per-run agent timeout. Default 600_000ms (10 min). */
     timeoutMs?: number;
+    /** Cooperative cancellation propagated to the runner process tree. */
+    signal?: AbortSignal;
     /** Optional: enrich the prompt with the selected gene's strategy. */
     resolveGene?: GeneResolver;
     /** Optional: validation commands surfaced in the prompt's done-criteria. */
@@ -94,6 +108,9 @@ export declare class ExecBridgeForbiddenError extends Error {
 export declare class UnsandboxedFullAccessRequiresIsolationError extends Error {
     constructor();
 }
+export declare class UnsafeWorktreePathError extends Error {
+    constructor(reason: string);
+}
 /**
  * Whitelist-filter `env` for a spawned agent/tool: keep ONLY the minimal runtime env + the caller-declared
  * extras (the runner's own auth via allowPrefixes/allowKeys); drop everything else. Fail-safe by construction —
@@ -103,8 +120,9 @@ export declare function scrubAgentEnv(env: NodeJS.ProcessEnv, opts?: {
     allowKeys?: readonly string[];
     allowPrefixes?: readonly string[];
 }): NodeJS.ProcessEnv;
-/** Default git runner: spawn `git <args>` in cwd, return stdout (empty string on error). Env scrubbed — git never needs evolver/hub secrets. */
+/** Default git runner: every incomplete command result fails closed. */
 export declare const defaultGitRunner: GitRunner;
+export declare const defaultGitPatchWriter: GitPatchWriter;
 /**
  * Build the `execute` function CycleEngine/runEvolutionCycle consume. Default-off: throws
  * ExecBridgeDisabledError on first call unless enabled.