chainlesschain 0.166.17 → 0.166.20

package/src/lib/evolution-system.js

@@ -108,7 +108,7 @@ export function loadFromDb(db) {
     } catch {
       parameters = {};
     }
-    // keyed by id (matches trainIncremental modelId)
+    // keyed by id (matches recordIncrementalModelMetrics modelId)
     models.set(row.id, {
       id: row.id,
       name: row.name,
@@ -220,10 +220,19 @@ export function assessCapability(db, name, score, category = "general") {
 }
 
 /**
- * Incremental learning — train a model with new data.
- * Accuracy formula: min(0.99, accuracy + 0.01 * log(1 + dataPoints))
+ * Record a synthetic model metric projection.
+ *
+ * This does not load a model, execute a trainer, update weights, or evaluate
+ * predictions. The legacy `accuracy` column is retained for database
+ * compatibility and stores only this formula estimate:
+ * min(0.99, previousEstimate + 0.01 * log(1 + dataPoints)).
  */
-export function trainIncremental(db, modelId, newData, options = {}) {
+export function recordIncrementalModelMetrics(
+  db,
+  modelId,
+  newData,
+  options = {},
+) {
   ensureEvolutionTables(db);
   loadFromDb(db);
 
@@ -261,11 +270,11 @@ export function trainIncremental(db, modelId, newData, options = {}) {
     JSON.stringify(model.parameters),
   );
 
-  // Log growth event
+  // Record an observation, not evidence that training or evaluation occurred.
   const logEntry = {
     id: crypto.randomUUID(),
-    eventType: "model-training",
-    description: `Trained ${modelId}: +${dataSize} data points, accuracy=${model.accuracy.toFixed(4)}`,
+    eventType: "model-metrics-recorded",
+    description: `Recorded formula metrics for ${modelId}: +${dataSize} data points, estimate=${model.accuracy.toFixed(4)}`,
     capabilityId: null,
     delta: dataSize,
     timestamp: new Date().toISOString(),
@@ -284,7 +293,20 @@ export function trainIncremental(db, modelId, newData, options = {}) {
     logEntry.timestamp,
   );
 
-  return { ...model };
+  return {
+    ...model,
+    metricKind: "synthetic-formula-estimate",
+    status: "metrics_recorded",
+    performedTraining: false,
+  };
+}
+
+/**
+ * @deprecated Use recordIncrementalModelMetrics. This compatibility alias does
+ * not train a model and returns the same metrics-only record.
+ */
+export function trainIncremental(db, modelId, newData, options = {}) {
+  return recordIncrementalModelMetrics(db, modelId, newData, options);
 }
 
 /**
@@ -435,7 +457,7 @@ export function selfRepair(db, issue) {
       break;
     }
     case "degraded-model": {
-      // Reset low-accuracy models to retrain
+      // Reset low formula estimates for fresh metric collection.
       for (const [, model] of models) {
         if (model.accuracy < 0.6) {
           model.accuracy = 0.5;
@@ -446,7 +468,7 @@ export function selfRepair(db, issue) {
           db.prepare(
             `UPDATE evolution_models SET accuracy = ?, data_points = ?, updated_at = datetime('now') WHERE id = ?`,
           ).run(model.accuracy, model.dataPoints, model.id);
-          actions.push(`Reset model ${model.id} for retraining`);
+          actions.push(`Reset metric record ${model.id} for reassessment`);
         }
       }
       break;
@@ -486,6 +508,7 @@ export function selfRepair(db, issue) {
  * Predict user behavior based on historical patterns.
  */
 export function predictBehavior(db, userId, options = {}) {
+  void options;
   ensureEvolutionTables(db);
   loadFromDb(db);
 
@@ -641,7 +664,7 @@ const TRAIN_STRATEGY = Object.freeze({
 });
 
 const _v2CapabilitiesByDim = new Map(); // dimension → { id, dimension, score, previousScore, trend, sampleCount, assessedAt, metadata }
-const _v2TrainingLog = []; // { id, strategy, dataSize, lossBefore, lossAfter, knowledgeRetention, durationMs, status, createdAt }
+const _v2TrainingMetricRecords = []; // caller-supplied losses plus derived retention assessment
 const _v2DiagnosisById = new Map(); // diagnosisId → { id, scope, severity, anomaliesDetected, rootCause, repairSuggestion, repairStatus, repairedAt, createdAt }
 const _v2Milestones = []; // { id, type, description, capabilityId?, details, timestamp }
 const _v2Config = {
@@ -721,7 +744,11 @@ export function listCapabilitiesV2() {
     .sort((a, b) => a.dimension.localeCompare(b.dimension));
 }
 
-export function trainIncrementalV2({
+/**
+ * Record caller-supplied before/after loss metrics and derive a retention
+ * ratio. No training, model mutation, or independent evaluation occurs.
+ */
+export function recordTrainingMetricsV2({
   strategy,
   dataSize,
   lossBefore,
@@ -750,31 +777,39 @@ export function trainIncrementalV2({
     lossAfter,
     knowledgeRetention,
     durationMs,
-    status:
+    retentionAssessment:
       knowledgeRetention >= _v2Config.knowledgeRetentionThreshold
-        ? "completed"
+        ? "threshold_met"
         : "retention_low",
+    status: "metrics_recorded",
+    performedTraining: false,
     createdAt: Date.now(),
   };
-  _v2TrainingLog.push(entry);
-  if (entry.status === "completed" && lossAfter < lossBefore) {
-    recordMilestone({
-      type: GROWTH_MILESTONE.KNOWLEDGE_EXPANSION,
-      description: `${strategy} training reduced loss ${lossBefore}→${lossAfter}`,
-      details: { strategy, dataSize, knowledgeRetention },
-    });
-  }
+  _v2TrainingMetricRecords.push(entry);
   return { ...entry };
 }
 
-export function listTrainingLogV2({ strategy, limit } = {}) {
-  let list = [..._v2TrainingLog];
+/**
+ * @deprecated Use recordTrainingMetricsV2. This compatibility alias records
+ * metrics only and never reports training completion.
+ */
+export function trainIncrementalV2(options) {
+  return recordTrainingMetricsV2(options);
+}
+
+export function listTrainingMetricRecordsV2({ strategy, limit } = {}) {
+  let list = [..._v2TrainingMetricRecords];
   if (strategy) list = list.filter((e) => e.strategy === strategy);
   list.sort((a, b) => b.createdAt - a.createdAt);
   if (Number.isFinite(limit) && limit > 0) list = list.slice(0, limit);
   return list;
 }
 
+/** @deprecated Use listTrainingMetricRecordsV2. */
+export function listTrainingLogV2({ strategy, limit } = {}) {
+  return listTrainingMetricRecordsV2({ strategy, limit });
+}
+
 export function selfDiagnoseV2({ scope = "system", depth = "shallow" } = {}) {
   const anomalies = [];
   let severity = DIAGNOSIS_SEVERITY.NORMAL;
@@ -793,9 +828,9 @@ export function selfDiagnoseV2({ scope = "system", depth = "shallow" } = {}) {
     }
   }
 
-  // Training retention anomalies
-  const recentTrain = _v2TrainingLog.slice(-10);
-  const lowRetention = recentTrain.filter(
+  // Retention anomalies in caller-supplied metric records.
+  const recentMetricRecords = _v2TrainingMetricRecords.slice(-10);
+  const lowRetention = recentMetricRecords.filter(
     (t) => t.knowledgeRetention < _v2Config.knowledgeRetentionThreshold,
   );
   if (lowRetention.length >= 3) {
@@ -814,7 +849,7 @@ export function selfDiagnoseV2({ scope = "system", depth = "shallow" } = {}) {
       rootCause = `Capability ${top.dimension} dropped sharply`;
       repairSuggestion = REPAIR_STRATEGY.PARAMETER_TUNE;
     } else if (top.type === "catastrophic_forgetting") {
-      rootCause = "Knowledge retention below threshold in recent training";
+      rootCause = "Derived retention below threshold in recent metric records";
       repairSuggestion = REPAIR_STRATEGY.MODEL_ROLLBACK;
     }
   }
@@ -1028,7 +1063,7 @@ export function getEvolutionStatsV2() {
   }
   return {
     capabilityCount: _v2CapabilitiesByDim.size,
-    trainingRuns: _v2TrainingLog.length,
+    trainingMetricRecords: _v2TrainingMetricRecords.length,
     diagnoses: { total: _v2DiagnosisById.size, bySeverity },
     milestones: { total: _v2Milestones.length, byType: byMilestone },
   };
@@ -1036,7 +1071,7 @@ export function getEvolutionStatsV2() {
 
 export function _resetV2State() {
   _v2CapabilitiesByDim.clear();
-  _v2TrainingLog.length = 0;
+  _v2TrainingMetricRecords.length = 0;
   _v2DiagnosisById.clear();
   _v2Milestones.length = 0;
   _v2Config.enabled = true;

package/src/lib/mcp-lifecycle-authority.js

@@ -10,6 +10,7 @@
  */
 
 import crypto from "node:crypto";
+import fs from "node:fs";
 import path from "node:path";
 import { getStatePath } from "./paths.js";
 import {
@@ -454,8 +455,26 @@ export class McpLifecycleAuthority {
 
   _read() {
     if (!this.statePath) return validateStore(structuredClone(this._memory));
-    const value = readSecurityStore(this.statePath, "MCP lifecycle authority");
-    return validateStore(value, { missing: Object.keys(value).length === 0 });
+    // A Windows replace can briefly make the destination path unobservable to
+    // an unlocked reader. Treating that ENOENT as an empty authority loses the
+    // server snapshot even though the replacement is about to become visible.
+    // Durable reads therefore share the exact strict lock used by mutations.
+    if (!fs.existsSync(path.dirname(this.statePath))) {
+      return validateStore({}, { missing: true });
+    }
+    return this._lock(
+      this.statePath,
+      () => {
+        const value = readSecurityStore(
+          this.statePath,
+          "MCP lifecycle authority",
+        );
+        return validateStore(value, {
+          missing: Object.keys(value).length === 0,
+        });
+      },
+      { timeoutMs: 2000, staleMs: 30000, failIfUnavailable: true },
+    );
   }
 
   _mutate(mutator) {

package/src/lib/remote-approval-bridge.js

@@ -53,6 +53,7 @@ import {
 } from "./remote-control.js";
 import { logger } from "./logger.js";
 import { normalizeRemoteApprovalDecision } from "./remote-approval-decision.js";
+import { captureStructuredMemoryPolicyReceiptWriter } from "./evolution/structured-memory-policy-receipt-writer.js";
 
 const DEFAULT_DECISION_TIMEOUT_MS = 5 * 60 * 1000;
 const REMOTE_LEASE_AUTHORIZATION_KIND =
@@ -102,6 +103,7 @@ export class RemoteApprovalBridge {
     membershipHostAuthorityLockFile = null,
     expectedCoordinatorPublicKeySha256 = null,
     onSecurityError = null,
+    memoryPolicyReceiptWriter = null,
   } = {}) {
     if (!wsUrl) throw new Error("wsUrl is required");
     if (!agentSessionId) throw new Error("agentSessionId is required");
@@ -122,6 +124,10 @@ export class RemoteApprovalBridge {
     this._securityErrors = [];
     this._onSecurityError =
       typeof onSecurityError === "function" ? onSecurityError : null;
+    this._memoryPolicyReceiptWriter =
+      memoryPolicyReceiptWriter === null
+        ? null
+        : captureStructuredMemoryPolicyReceiptWriter(memoryPolicyReceiptWriter);
     this._membershipHostStore =
       membershipHostStore === undefined
         ? () =>
@@ -1090,6 +1096,22 @@ export class RemoteApprovalBridge {
     ) {
       throw new Error("Consumed Remote approval statement binding changed");
     }
+    if (this._memoryPolicyReceiptWriter !== null) {
+      await this._memoryPolicyReceiptWriter.retainConsumedApproval({
+        adopted,
+        operation: {
+          requestId: durableLease.requestId,
+          fingerprint: durableLease.fingerprint,
+          binding: durableLease.binding,
+          toolName: descriptor.toolName,
+          action: context.action ?? null,
+          workspace: descriptor.workspace,
+          session: descriptor.session,
+          targetEnv: descriptor.targetEnv,
+          policyVersion: descriptor.policyVersion,
+        },
+      });
+    }
     return true;
   }
 
@@ -1310,6 +1332,7 @@ export async function startHeadlessRemoteApproval({
   writeErr = () => {},
   isText = false,
   decisionTimeoutMs = undefined,
+  memoryPolicyReceiptWriter = null,
   deps = {},
 } = {}) {
   let effectiveConfig = config;
@@ -1374,6 +1397,7 @@ export async function startHeadlessRemoteApproval({
       agentSessionId,
       scopes: ["observe", "approve"],
       decisionTimeoutMs,
+      memoryPolicyReceiptWriter,
     });
     try {
       await bridge.start();

package/src/lib/scheduler-kernel/store.js

@@ -37,6 +37,7 @@ const STORAGE_FAILURE_CODE_SET = new Set(STORAGE_FAILURE_CODES);
 export const SCHEDULER_APPLICATION_ID = 0x4343534b; // "CCSK"
 export const SCHEDULER_STORE_SCHEMA_VERSION = 6;
 export const DEFAULT_BUSY_TIMEOUT_MS = 5_000;
+const SQLITE_BUSY_TRANSACTION_ATTEMPTS = 3;
 export const MAX_LEASE_MS = 24 * 60 * 60 * 1_000;
 export const MIN_AUTHORITY_WINDOW_MS = 60_000;
 export const MAX_AUTHORITY_WINDOW_MS = 31 * 24 * 60 * 60 * 1_000;
@@ -748,6 +749,26 @@ function findStorageFailureCode(error) {
   return null;
 }
 
+function isSqliteBusy(error) {
+  const visited = new Set();
+  let current = error;
+  while (
+    current !== null &&
+    (typeof current === "object" || typeof current === "function") &&
+    !visited.has(current)
+  ) {
+    visited.add(current);
+    if (
+      typeof current.code === "string" &&
+      current.code.trim().toUpperCase().startsWith("SQLITE_BUSY")
+    ) {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+
 function storageUnavailableError({ phase, storageCode, commitState }) {
   return new SchedulerKernelError(
     "SCHEDULER_STORAGE_UNAVAILABLE",
@@ -2316,20 +2337,7 @@ export class SchedulerStore {
     this._assertOpen();
     let bodyState = "not_started";
     let bodyObservedTransaction = false;
-    try {
-      const transaction = this.db.transaction((...args) => {
-        bodyState = "running";
-        try {
-          bodyObservedTransaction = this.db.inTransaction === true;
-        } catch {
-          bodyObservedTransaction = false;
-        }
-        const result = callback(...args);
-        bodyState = "returned";
-        return result;
-      });
-      return transaction.immediate();
-    } catch (cause) {
+    const failWrite = (cause) => {
       if (cause instanceof SchedulerKernelError) throw cause;
       const storageCode = findStorageFailureCode(cause);
       if (!storageCode) throw cause;
@@ -2353,7 +2361,47 @@ export class SchedulerStore {
             ? "not_committed"
             : "unknown",
       });
+    };
+    let transaction;
+    try {
+      transaction = this.db.transaction((...args) => {
+        bodyState = "running";
+        try {
+          bodyObservedTransaction = this.db.inTransaction === true;
+        } catch {
+          bodyObservedTransaction = false;
+        }
+        const result = callback(...args);
+        bodyState = "returned";
+        return result;
+      });
+    } catch (cause) {
+      return failWrite(cause);
+    }
+    for (
+      let attempt = 1;
+      attempt <= SQLITE_BUSY_TRANSACTION_ATTEMPTS;
+      attempt += 1
+    ) {
+      bodyState = "not_started";
+      bodyObservedTransaction = false;
+      try {
+        return transaction.immediate();
+      } catch (cause) {
+        // BEGIN IMMEDIATE can lose a cross-process writer race even after the
+        // native busy timeout. Retrying is safe only while the callback has
+        // never started, so application writes and side effects cannot repeat.
+        if (
+          bodyState === "not_started" &&
+          isSqliteBusy(cause) &&
+          attempt < SQLITE_BUSY_TRANSACTION_ATTEMPTS
+        ) {
+          continue;
+        }
+        return failWrite(cause);
+      }
     }
+    throw new Error("unreachable Scheduler transaction retry state");
   }
 
   _appendEvent({

package/src/repl/agent-repl.js

@@ -171,6 +171,8 @@ import { resolveSlashMacro } from "./slash-macro.js";
 import { expandMcpPrompt, renderMcpSurface } from "./mcp-prompt.js";
 import { newCostStore, addUsage } from "./session-cost.js";
 import { extractPluginUsageAttribution } from "../lib/plugin-usage-attribution.js";
+import { captureStructuredMemoryAgentControlPlane } from "../lib/evolution/structured-memory-agent-control-plane.js";
+import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
 import { formatManagedCheckpointEvent } from "../lib/managed-checkpoint-render.js";
 import { parseThinkCommand, parseEffortCommand } from "./think-command.js";
 import {
@@ -610,6 +612,10 @@ async function executeTool(name, args, context = {}) {
  * unit-testable via the `options._coreLoop` injection seam.
  */
 export async function agentLoop(messages, options) {
+  const evolutionIngress =
+    options.evolutionIngress == null
+      ? null
+      : captureAgentEvolutionIngress(options.evolutionIngress);
   const writeOut =
     options.writeOut || ((text) => process.stdout.write(String(text)));
   const waitForOutput = options.waitForOutput;
@@ -637,6 +643,13 @@ export async function agentLoop(messages, options) {
     collapseValidatedPlainReplTailInPlace(messages);
   }
   const usageEvents = [];
+  const currentUserMessage = messages.at(-1);
+  if (evolutionIngress !== null && currentUserMessage?.role === "user") {
+    await evolutionIngress.ingestUserPrompt({
+      content: currentUserMessage.content,
+      sessionId: options.sessionId || null,
+    });
+  }
   // Visible cross-vendor fallback notice: a silent switch from the configured
   // provider onto another vendor (or a baseUrl relabel) is surfaced as a yellow
   // line, so "configured X but it ran Y" never happens quietly. Callers may
@@ -757,6 +770,9 @@ export async function agentLoop(messages, options) {
     onToolCallSettlement,
     onProviderFallback,
   })) {
+    if (evolutionIngress !== null) {
+      await evolutionIngress.ingestAgentEvent(event);
+    }
     // P1 explicit turn→checkpoint binding — the REPL as PRODUCER: fold every
     // loop event into the live table (checkpoint / tool / policy / child
     // agent), mirroring the headless runner's feed. Advisory: a feeder failure
@@ -2909,10 +2925,38 @@ export function resolveReplPermanentMemoryStorage(
 
 /** Start the agentic REPL with non-overridable production bindings. */
 export async function startAgentRepl(options = {}) {
+  const evolutionIngress =
+    options.evolutionIngress == null
+      ? null
+      : captureAgentEvolutionIngress(options.evolutionIngress);
+  const structuredMemoryControlPlane =
+    options.structuredMemoryControlPlane == null
+      ? null
+      : captureStructuredMemoryAgentControlPlane(
+          options.structuredMemoryControlPlane,
+        );
+  if (
+    structuredMemoryControlPlane !== null &&
+    options.memoryPolicyReceiptWriter != null &&
+    options.memoryPolicyReceiptWriter !==
+      structuredMemoryControlPlane.policyReceiptWriter
+  ) {
+    throw new Error(
+      "Agent REPL received conflicting structured memory policy capabilities",
+    );
+  }
   const sessionHostLeaseScope = { lease: null };
   const sessionBudgetRootScope = { root: null };
   const runtimeOptions = {
     ...options,
+    ...(evolutionIngress === null ? {} : { evolutionIngress }),
+    ...(structuredMemoryControlPlane === null
+      ? {}
+      : {
+          structuredMemoryControlPlane,
+          memoryPolicyReceiptWriter:
+            structuredMemoryControlPlane.policyReceiptWriter,
+        }),
     _sessionHostLeaseScope: sessionHostLeaseScope,
     _sessionBudgetRootScope: sessionBudgetRootScope,
   };
@@ -3949,6 +3993,7 @@ async function startAgentReplInWorkspaceOwned(
       isText: false, // the REPL prints its own pairing lines below
       allowLan: options.remoteControlAllowLan === true,
       env: process.env,
+      memoryPolicyReceiptWriter: options.memoryPolicyReceiptWriter ?? null,
     });
     _remoteApproval = {
       bridge: started.bridge,

package/src/runtime/agent-runtime.js

@@ -31,6 +31,9 @@ import { loadConfig } from "../lib/config-manager.js";
 import { collectWorkspacePluginBinSandboxPolicy } from "../lib/plugin-runtime/bin.js";
 import { issueMcpStdioExecutionAuthority } from "../lib/mcp-stdio-execution-authority.js";
 import { registerHostHooksV2Workspace } from "../lib/hooks-v2-workspace-context.js";
+import { captureStructuredMemoryPolicyReceiptWriter } from "../lib/evolution/structured-memory-policy-receipt-writer.js";
+import { captureStructuredMemoryAgentControlPlane } from "../lib/evolution/structured-memory-agent-control-plane.js";
+import { captureAgentEvolutionIngress } from "../lib/evolution/agent-evolution-ingress.js";
 
 const {
   DEFAULT_ALLOWED_MCP_SERVER_NAMES,
@@ -62,6 +65,41 @@ export class AgentRuntime {
     this.config = config;
     this.context = createRuntimeContext({ kind, policy, config });
     this.events = deps.events || new RuntimeEventEmitter();
+    this.evolutionIngress =
+      deps.evolutionIngress == null
+        ? null
+        : captureAgentEvolutionIngress(deps.evolutionIngress);
+    this.structuredMemoryControlPlane =
+      deps.structuredMemoryControlPlane == null
+        ? null
+        : captureStructuredMemoryAgentControlPlane(
+            deps.structuredMemoryControlPlane,
+          );
+    if (
+      this.structuredMemoryControlPlane !== null &&
+      deps.memoryPolicyReceiptWriter != null
+    ) {
+      throw new Error(
+        "structured memory control plane and standalone policy writer cannot both be configured",
+      );
+    }
+    this.memoryPolicyReceiptWriter =
+      this.structuredMemoryControlPlane?.policyReceiptWriter ??
+      (deps.memoryPolicyReceiptWriter == null
+        ? null
+        : captureStructuredMemoryPolicyReceiptWriter(
+            deps.memoryPolicyReceiptWriter,
+          ));
+    if (
+      this.evolutionIngress !== null &&
+      this.structuredMemoryControlPlane !== null &&
+      this.evolutionIngress.tenantId !==
+        this.structuredMemoryControlPlane.tenantId
+    ) {
+      throw new Error(
+        "Agent evolution ingress and structured memory must share one tenant",
+      );
+    }
     this.deps = {
       startAgentRepl: deps.startAgentRepl || startAgentRepl,
       startChatRepl: deps.startChatRepl || startChatRepl,
@@ -88,8 +126,18 @@ export class AgentRuntime {
       resolveAgentBundle: deps.resolveAgentBundle || null,
       openBrowser: deps.openBrowser || openBrowser,
       runTurn: deps.runTurn || null,
+      evolutionCompositionFactory:
+        deps.evolutionCompositionFactory == null
+          ? null
+          : deps.evolutionCompositionFactory,
       logger: deps.logger || logger,
     };
+    if (
+      this.deps.evolutionCompositionFactory !== null &&
+      typeof this.deps.evolutionCompositionFactory !== "function"
+    ) {
+      throw new TypeError("evolutionCompositionFactory must be a function");
+    }
   }
 
   on(eventName, listener) {
@@ -146,6 +194,14 @@ export class AgentRuntime {
     }
 
     const startedAt = Date.now();
+    if (this.evolutionIngress !== null) {
+      await this.evolutionIngress.ingestUserPrompt({
+        input,
+        meta,
+        sessionId: this.policy.sessionId || null,
+        startedAt,
+      });
+    }
     this.emit(
       RUNTIME_EVENTS.TURN_START,
       createAgentTurnRecord({
@@ -165,6 +221,16 @@ export class AgentRuntime {
       context: this.context,
     });
 
+    if (this.evolutionIngress !== null) {
+      await this.evolutionIngress.ingestAgentEvent({
+        type: "response-complete",
+        content: result,
+        sessionId: this.policy.sessionId || null,
+        startedAt,
+        endedAt: Date.now(),
+      });
+    }
+
     this.emit(
       RUNTIME_EVENTS.TURN_END,
       createAgentTurnRecord({
@@ -181,7 +247,35 @@ export class AgentRuntime {
     return result;
   }
 
+  _requireStructuredMemoryControlPlane() {
+    if (this.kind !== "agent" || this.structuredMemoryControlPlane === null) {
+      throw new Error(
+        "structured memory Agent control plane is not configured",
+      );
+    }
+    return this.structuredMemoryControlPlane;
+  }
+
+  async proposeSemanticMemory(input) {
+    return this._requireStructuredMemoryControlPlane().semantic.propose(input);
+  }
+
+  async reviewAndAcceptSemanticMemory(input) {
+    return this._requireStructuredMemoryControlPlane().semantic.reviewAndAccept(
+      input,
+    );
+  }
+
+  createEvolutionPromotionControlPlane(options) {
+    return this._requireStructuredMemoryControlPlane().createEvaluatedPromotionControlPlane(
+      options,
+    );
+  }
+
   async startAgentSession() {
+    if (this.evolutionIngress !== null) {
+      await this.evolutionIngress.start();
+    }
     this.emit(RUNTIME_EVENTS.RUNTIME_START, {
       kind: this.kind,
       policy: this.policy,
@@ -190,7 +284,24 @@ export class AgentRuntime {
       kind: this.kind,
       sessionId: this.policy.sessionId || null,
     });
-    return this.deps.startAgentRepl(this.policy);
+    const result = await this.deps.startAgentRepl({
+      ...this.policy,
+      ...(this.memoryPolicyReceiptWriter === null
+        ? {}
+        : { memoryPolicyReceiptWriter: this.memoryPolicyReceiptWriter }),
+      ...(this.structuredMemoryControlPlane === null
+        ? {}
+        : {
+            structuredMemoryControlPlane: this.structuredMemoryControlPlane,
+          }),
+      ...(this.evolutionIngress === null
+        ? {}
+        : { evolutionIngress: this.evolutionIngress }),
+    });
+    if (this.evolutionIngress !== null) {
+      await this.evolutionIngress.complete();
+    }
+    return result;
   }
 
   async startChatSession() {
@@ -356,6 +467,7 @@ export class AgentRuntime {
       remoteSessionRelayUrl,
       remoteSessionPeerId,
       envelopeBus,
+      evolutionCompositionFactory: this.deps.evolutionCompositionFactory,
     });
 
     server.on("connection", ({ clientId, ip }) => {
@@ -529,6 +641,7 @@ export class AgentRuntime {
           timeout: 60000,
           sessionManager,
           projectRoot: workspacePolicyCwd,
+          evolutionCompositionFactory: this.deps.evolutionCompositionFactory,
         });
         // ChainlessChainWSServer extends EventEmitter and emits "error"
         // synchronously on bind failure (in addition to rejecting start()).