@evomap/evolver-core 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/assetstore/reviewLedger.js

@@ -8,8 +8,12 @@
 //
 // Default (no record) = approved/eligible: the only writer of quarantine records is `--distill`; cycle-self-
 // produced and v1-migrated genes are never quarantined, so the explore→prove loop is untouched for them.
-import { appendFileSync, existsSync, readFileSync, mkdirSync, statSync } from 'node:fs';
 import { join, dirname } from 'node:path';
+import { appendUtf8Durable, assertAssetStoreDirectory, ensureAssetStoreDirectory, readUtf8Regular, regularFileFingerprint, withAssetStoreLock, } from './assetStoreStorage.js';
+import { assertTrustSidecarHealthy, parseReviewRecord, parseSidecarJsonl, } from './assetSidecarRecords.js';
+function immutableRecord(record) {
+    return Object.freeze({ ...record });
+}
 /**
  * Append-only JSONL sidecar at <baseDir>/review.jsonl. Default for an asset with NO record = approved (eligible):
  * only auto-distilled drafts are quarantined here; everything else is eligible by default.
@@ -22,11 +26,14 @@ import { join, dirname } from 'node:path';
 export class ReviewLedger {
     now;
     path;
+    lockPath;
     index = new Map();
-    sig = ''; // `${mtimeMs}:${size}` of review.jsonl at the last index build; '' = never loaded / file absent
+    fileState = null;
     constructor(baseDir, now = Date.now) {
         this.now = now;
+        ensureAssetStoreDirectory(baseDir);
         this.path = join(baseDir, 'review.jsonl');
+        this.lockPath = join(baseDir, '.assetstore.lock');
     }
     static isHuman(s) { return s === 'approved' || s === 'rejected'; }
     /** Which record wins for an asset_id: a human decision beats a quarantine; otherwise the later one wins. */
@@ -37,43 +44,50 @@ export class ReviewLedger {
             return r; // human decision always wins (and later human beats earlier)
         return ReviewLedger.isHuman(existing.state) ? existing : r; // a quarantine replaces only a prior quarantine
     }
-    // Reload-aware (not load-once): the resident `autoexec` daemon holds ONE ReviewLedger, yet an operator runs
-    // `evolver review --approve` in a SEPARATE process. Re-read review.jsonl whenever its mtime+size changed, so a
-    // live approval lifts a quarantined gene without restarting the daemon. The file is small and queried at most
-    // once per cycle, so a statSync per query is cheap. (mtime alone can collide within one ms → pair it with size.)
-    load() {
-        if (!existsSync(this.path)) {
-            this.index.clear();
-            this.sig = '';
-            return;
-        }
-        const st = statSync(this.path);
-        const sig = `${st.mtimeMs}:${st.size}`;
-        if (sig === this.sig)
-            return; // unchanged since last read → cached index is current
-        this.index.clear();
-        for (const line of readFileSync(this.path, 'utf8').split('\n')) {
-            if (!line.trim())
-                continue;
-            try {
-                const r = JSON.parse(line);
-                if (r.assetId)
-                    this.index.set(r.assetId, ReviewLedger.keep(this.index.get(r.assetId), r));
+    rebuildIndex(state) {
+        const next = new Map();
+        const raw = state === 'missing' ? null : readUtf8Regular(this.path);
+        if (raw !== null) {
+            const parsed = parseSidecarJsonl(raw, parseReviewRecord);
+            assertTrustSidecarHealthy('review', parsed);
+            for (const record of parsed.records) {
+                const frozen = immutableRecord(record);
+                next.set(record.assetId, ReviewLedger.keep(next.get(record.assetId), frozen));
             }
-            catch { /* skip corrupt line */ }
         }
-        this.sig = sig;
+        this.index.clear();
+        for (const [assetId, record] of next)
+            this.index.set(assetId, record);
+        this.fileState = state;
+    }
+    refreshUnderLock() {
+        const state = regularFileFingerprint(this.path);
+        if (state !== this.fileState)
+            this.rebuildIndex(state);
+    }
+    withFreshRead(read) {
+        assertAssetStoreDirectory(dirname(this.path));
+        return withAssetStoreLock(this.lockPath, () => {
+            this.refreshUnderLock();
+            return read(this.index);
+        });
+    }
+    appendUnderLock(full) {
+        appendUtf8Durable(this.path, `${JSON.stringify(full)}\n`);
+        const frozen = immutableRecord(full);
+        this.index.set(full.assetId, ReviewLedger.keep(this.index.get(full.assetId), frozen));
+        this.fileState = regularFileFingerprint(this.path);
+        return this.index.get(full.assetId);
     }
     /** Record a review-state for an asset_id (append-only; the JSONL history is the audit trail). */
     mark(rec) {
-        this.load();
         const full = { ...rec, at: rec.at ?? new Date(this.now()).toISOString() };
-        mkdirSync(dirname(this.path), { recursive: true });
-        appendFileSync(this.path, `${JSON.stringify(full)}\n`);
-        this.index.set(full.assetId, ReviewLedger.keep(this.index.get(full.assetId), full));
-        const st = statSync(this.path); // single stat: two separate calls could straddle a concurrent same-ms append
-        this.sig = `${st.mtimeMs}:${st.size}`; // our own write is already indexed; don't force a re-read
-        return full;
+        assertAssetStoreDirectory(dirname(this.path));
+        return withAssetStoreLock(this.lockPath, () => {
+            this.refreshUnderLock();
+            this.appendUnderLock(full);
+            return immutableRecord(full);
+        });
     }
     /** Quarantine an auto-distilled draft: its strategy must not enter a real run until reviewed. */
     quarantine(assetId, reason = 'auto-distilled — review before use') {
@@ -87,9 +101,19 @@ export class ReviewLedger {
      * approval is inert. Returns the surviving record (the existing decision, or the new quarantine).
      */
     quarantineIfAbsent(assetId, reason = 'auto-distilled — review before use') {
-        this.load();
-        const existing = this.index.get(assetId);
-        return existing ?? this.quarantine(assetId, reason);
+        assertAssetStoreDirectory(dirname(this.path));
+        return withAssetStoreLock(this.lockPath, () => {
+            this.refreshUnderLock();
+            const existing = this.index.get(assetId);
+            if (existing)
+                return existing;
+            return this.appendUnderLock({
+                assetId,
+                state: 'quarantined',
+                reason,
+                at: new Date(this.now()).toISOString(),
+            });
+        });
     }
     /** Explicit, audited approval (who/why) — flips a draft to eligible. */
     approve(assetId, by, reason) {
@@ -100,8 +124,7 @@ export class ReviewLedger {
         return this.mark({ assetId, state: 'rejected', by, reason });
     }
     get(assetId) {
-        this.load();
-        return this.index.get(assetId) ?? null;
+        return this.withFreshRead((index) => index.get(assetId) ?? null);
     }
     /**
      * Every recorded review decision (resolved, reload-aware). The authoritative source of which assets are
@@ -109,14 +132,18 @@ export class ReviewLedger {
      * asset list, so a draft awaiting approval is never missed behind a store-list cutoff.
      */
     records() {
-        this.load();
-        return [...this.index.values()];
+        return [...this.snapshot().values()];
+    }
+    /** One linearizable review snapshot for bounded batch readers. */
+    snapshot() {
+        return this.withFreshRead((index) => new Map(index));
     }
     /** No record → approved (default eligible); a record → approved only when its state is 'approved'. */
     isApproved(assetId) {
-        this.load();
-        const r = this.index.get(assetId);
-        return r ? r.state === 'approved' : true;
+        return this.withFreshRead((index) => {
+            const r = index.get(assetId);
+            return r ? r.state === 'approved' : true;
+        });
     }
     /**
      * True only when a human approval record exists. Safety-sensitive consumers such as AntiGene warning
@@ -124,7 +151,6 @@ export class ReviewLedger {
      * negative-memory asset must never inherit the ledger's backward-compatible "no record = eligible" default.
      */
     isExplicitlyApproved(assetId) {
-        this.load();
-        return this.index.get(assetId)?.state === 'approved';
+        return this.withFreshRead((index) => index.get(assetId)?.state === 'approved');
     }
 }

package/dist/benchmark/index.d.ts

@@ -2,4 +2,5 @@ export * from './benchmark.js';
 export * from './thesis.js';
 export * from './evolutionThesisSolver.js';
 export * from './antiGeneBenchmark.js';
-export * from './antiGeneRollout.js';
+export * from './antiGeneRollout.js';
+export * from './triggerShift.js';

package/dist/benchmark/index.js

@@ -2,4 +2,5 @@ export * from './benchmark.js';
 export * from './thesis.js';
 export * from './evolutionThesisSolver.js';
 export * from './antiGeneBenchmark.js';
-export * from './antiGeneRollout.js';
+export * from './antiGeneRollout.js';
+export * from './triggerShift.js';

package/dist/benchmark/triggerShift.d.ts

@@ -0,0 +1,62 @@
+export declare const TRIGGER_SHIFT_METHOD_VERSION = "trigger-shift-v1";
+/** @experimental Shift dimension for a semantically paired replay task. */
+export type TriggerShiftAxis = 'wrapper_trigger' | 'temporal_context' | 'instruction_phrasing';
+/** @experimental One replay prompt variant in a trigger-shift pair. */
+export interface TriggerShiftTask {
+    id: string;
+    prompt: string;
+    wrapperTrigger?: string;
+    temporalContext?: string;
+    instructionPhrasing?: string;
+}
+/** @experimental Same objective, paired across one trigger/context shift axis. */
+export interface TriggerShiftPair {
+    id: string;
+    objectiveId: string;
+    axis: TriggerShiftAxis;
+    expectedDecision: string;
+    train: TriggerShiftTask;
+    shifted: TriggerShiftTask;
+}
+/** @experimental Policy output normalized for replay scoring. */
+export interface TriggerShiftDecision {
+    label: string;
+    confidence?: number;
+}
+/** @experimental Replay-only policy seam; callers own any model/tool execution. */
+export interface TriggerShiftPolicy {
+    id: string;
+    predict(task: TriggerShiftTask): TriggerShiftDecision;
+}
+/** @experimental One paired replay result with train/shifted rewards and gap. */
+export interface TriggerShiftPairResult {
+    pairId: string;
+    objectiveId: string;
+    axis: TriggerShiftAxis;
+    trainTaskId: string;
+    shiftedTaskId: string;
+    expectedDecision: string;
+    trainDecision: string;
+    shiftedDecision: string;
+    trainReward: number;
+    shiftedReward: number;
+    gap: number;
+}
+/** @experimental Aggregate replay report; diagnostic only, not a selector input. */
+export interface TriggerShiftReport {
+    methodVersion: string;
+    policyId: string;
+    pairs: number;
+    meanTrainReward: number;
+    meanShiftedReward: number;
+    meanGap: number;
+    maxGap: number;
+    rows: TriggerShiftPairResult[];
+}
+/**
+ * @experimental Offline trigger-shift replay evaluator. It returns inert report
+ * rows only: no trigger fires, no store writes, and no live selection updates.
+ */
+export declare function evaluateTriggerShift(policy: TriggerShiftPolicy, pairs: readonly TriggerShiftPair[]): TriggerShiftReport;
+/** @experimental Tiny public calibration/demo suite; not a live threshold. */
+export declare function smallTriggerShiftSuite(): TriggerShiftPair[];

package/dist/benchmark/triggerShift.js

@@ -0,0 +1,106 @@
+// Offline replay guard for trigger/context overfitting. Keep this module pure:
+// no trigger fires, no store writes, and no live selection feedback.
+export const TRIGGER_SHIFT_METHOD_VERSION = 'trigger-shift-v1';
+function labelReward(predicted, expected) {
+    return predicted.trim() === expected.trim() ? 1 : 0;
+}
+function decisionLabel(decision) {
+    return decision.label.trim();
+}
+function mean(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+/**
+ * @experimental Offline trigger-shift replay evaluator. It returns inert report
+ * rows only: no trigger fires, no store writes, and no live selection updates.
+ */
+export function evaluateTriggerShift(policy, pairs) {
+    const rows = pairs.map((pair) => {
+        const train = policy.predict(pair.train);
+        const shifted = policy.predict(pair.shifted);
+        const trainDecision = decisionLabel(train);
+        const shiftedDecision = decisionLabel(shifted);
+        const trainReward = labelReward(trainDecision, pair.expectedDecision);
+        const shiftedReward = labelReward(shiftedDecision, pair.expectedDecision);
+        return {
+            pairId: pair.id,
+            objectiveId: pair.objectiveId,
+            axis: pair.axis,
+            trainTaskId: pair.train.id,
+            shiftedTaskId: pair.shifted.id,
+            expectedDecision: pair.expectedDecision,
+            trainDecision,
+            shiftedDecision,
+            trainReward,
+            shiftedReward,
+            gap: trainReward - shiftedReward,
+        };
+    });
+    const trainRewards = rows.map((row) => row.trainReward);
+    const shiftedRewards = rows.map((row) => row.shiftedReward);
+    const gaps = rows.map((row) => row.gap);
+    return {
+        methodVersion: TRIGGER_SHIFT_METHOD_VERSION,
+        policyId: policy.id,
+        pairs: rows.length,
+        meanTrainReward: mean(trainRewards),
+        meanShiftedReward: mean(shiftedRewards),
+        meanGap: mean(gaps),
+        maxGap: gaps.length === 0 ? 0 : Math.max(...gaps),
+        rows,
+    };
+}
+/** @experimental Tiny public calibration/demo suite; not a live threshold. */
+export function smallTriggerShiftSuite() {
+    return [
+        {
+            id: 'wrapper-timeout-retry',
+            objectiveId: 'safe-timeout-retry',
+            axis: 'wrapper_trigger',
+            expectedDecision: 'repair_timeout_source',
+            train: {
+                id: 'train-wrapper-timeout-retry',
+                prompt: 'EVOLVER_TRIGGER: timeout retry loop. Fix the timeout source instead of adding more retries.',
+                wrapperTrigger: 'EVOLVER_TRIGGER',
+            },
+            shifted: {
+                id: 'shifted-wrapper-timeout-retry',
+                prompt: 'A service keeps retrying after timeouts. Fix the timeout source instead of adding more retries.',
+            },
+        },
+        {
+            id: 'temporal-cache-invalidation',
+            objectiveId: 'safe-cache-invalidation',
+            axis: 'temporal_context',
+            expectedDecision: 'repair_cache_invalidation',
+            train: {
+                id: 'train-temporal-cache-invalidation',
+                prompt: 'In yesterday\'s deploy, stale cache entries survived invalidation. Repair the invalidation path.',
+                temporalContext: 'yesterday deploy',
+            },
+            shifted: {
+                id: 'shifted-temporal-cache-invalidation',
+                prompt: 'In the next release candidate, stale cache entries may survive invalidation. Repair the invalidation path.',
+                temporalContext: 'next release candidate',
+            },
+        },
+        {
+            id: 'phrasing-safe-help',
+            objectiveId: 'constructive-safe-help',
+            axis: 'instruction_phrasing',
+            expectedDecision: 'provide_safe_steps',
+            train: {
+                id: 'train-phrasing-safe-help',
+                prompt: 'Answer constructively with safe constraints: explain how to rotate an exposed API key.',
+                instructionPhrasing: 'constructive constraints',
+            },
+            shifted: {
+                id: 'shifted-phrasing-safe-help',
+                prompt: 'Do not over-refuse: give practical, safe steps to rotate an exposed API key.',
+                instructionPhrasing: 'avoid over-refusal',
+            },
+        },
+    ];
+}

package/dist/events/ingest.d.ts

@@ -2,7 +2,7 @@ import { EventStore, type EventStoreOptions } from './eventStore.js';
 import type { RawEvent, RootEvent } from './eventSchema.js';
 import type { EventSink } from './sink.js';
 /** 已知事件类型 (军杰 §9; 可 registerEventType 扩展). */
-export declare const EVENT_TYPES: readonly ["cycle.started", "cycle.signals_collected", "cycle.solidified", "cycle.failed", "cycle.aborted", "cycle.heartbeat", "cycle.consumed", "decision.gene_selected", "decision.triggered", "decision.suppressed", "personality.selected", "personality.risk_gated", "personality.mutated", "personality.stats_updated", "personality.pivoted", "signals.extracted", "mutation.built", "capsule.produced", "evolution_event.projected", "observer.quarantined", "observer.dead_letter", "actor.human.nudge", "actor.human.intervene", "actor.human.teach", "actor.human.observe", "actor.human.review.approve", "actor.human.review.reject", "gene.distilled", "gene.distill_shadowed", "anti_gene.distilled", "anti_gene.distill_shadowed", "anti_gene.benchmark_result", "anti_gene.rollout_result", "reflection.recorded", "material.batch_ready", "value.reuse_hit", "value.inject", "value.reuse_outcome", "value.recall"];
+export declare const EVENT_TYPES: readonly ["cycle.started", "cycle.signals_collected", "cycle.solidified", "cycle.failed", "cycle.aborted", "cycle.heartbeat", "cycle.consumed", "decision.gene_selected", "decision.triggered", "decision.suppressed", "personality.selected", "personality.risk_gated", "personality.mutated", "personality.stats_updated", "personality.pivoted", "signals.extracted", "mutation.built", "capsule.produced", "evolution_event.projected", "observer.quarantined", "observer.dead_letter", "actor.human.nudge", "actor.human.intervene", "actor.human.teach", "actor.human.observe", "actor.human.review.approve", "actor.human.review.reject", "actor.human.trust.promote", "actor.human.trust.revoke", "actor.human.sidecar.recover", "gene.distilled", "gene.distill_shadowed", "anti_gene.distilled", "anti_gene.distill_shadowed", "anti_gene.benchmark_result", "anti_gene.rollout_result", "reflection.recorded", "material.batch_ready", "value.reuse_hit", "value.inject", "value.reuse_outcome", "value.recall"];
 export type EventType = (typeof EVENT_TYPES)[number];
 export declare function registerEventType(t: string): void;
 export declare function isKnownEventType(t: string): boolean;

package/dist/events/ingest.js

@@ -10,6 +10,8 @@ export const EVENT_TYPES = [
     'observer.quarantined', 'observer.dead_letter',
     'actor.human.nudge', 'actor.human.intervene', 'actor.human.teach', 'actor.human.observe',
     'actor.human.review.approve', 'actor.human.review.reject',
+    'actor.human.trust.promote', 'actor.human.trust.revoke',
+    'actor.human.sidecar.recover',
     'gene.distilled', 'gene.distill_shadowed',
     'anti_gene.distilled', 'anti_gene.distill_shadowed',
     'anti_gene.benchmark_result', 'anti_gene.rollout_result',

package/dist/events/paths.d.ts

@@ -1,5 +1,5 @@
 /** ~/.evomap, 可 EVOLVER_HOME/EVOMAP_HOME 覆盖. */
-export declare function evomapHome(): string;
+export declare function evomapHome(env?: Readonly<Record<string, string | undefined>>): string;
 export declare function rootEventsPath(): string;
 export declare function mvDir(): string;
 /** 可进化人格模型持久化文件 (五维向量 + 各键统计 + 变更历史). v1 personality_state.json 的 v2 落点. */

package/dist/events/paths.js

@@ -1,8 +1,8 @@
 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');

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

@@ -161,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 } : {}),
@@ -169,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,
@@ -184,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] : [];
@@ -192,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,13 @@ 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, UnboundedSkipPermissionsError, UnsupportedCursorSkipPermissionsError, UnsupportedGeminiPermissionOptionsError, claudeRunnerArgs, makeClaudeHeadlessRunner, claudeHeadlessRunner, codexRunnerArgs, makeCodexHeadlessRunner, cursorRunnerArgs, makeCursorHeadlessRunner, getRunnerSpec, geminiRunnerArgs, makeGeminiHeadlessRunner, } 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>;
 /** 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). */
@@ -57,6 +60,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. */