chainlesschain 0.166.16 → 0.166.18

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/graph-kernel/evolution-run-runtime-adapter.js

@@ -0,0 +1,5 @@
+import evolutionRun from "@chainlesschain/session-core/evolution-run";
+
+export function projectGraphEvolutionRun(events, options) {
+  return evolutionRun.projectEvolutionRun(events, options);
+}

package/src/lib/hooks-v2-runtime.js

@@ -872,6 +872,26 @@ class HooksV2Runtime extends EventEmitter {
       }
     }
     for (const hook of asyncHooks) {
+      if (
+        options.skipAsyncWithoutDispatcher === true &&
+        typeof options.asyncDispatcher !== "function"
+      ) {
+        results.push({
+          execId: crypto.randomUUID(),
+          hookId: hook.id,
+          sourceHookId: hook.databaseHookId || hook.id,
+          hookName: hook.databaseHookName || hook.description || hook.id,
+          event: eventName,
+          type: hook.type,
+          priority: normalizeHookPriority(hook.priority),
+          executionMode: HOOK_EXECUTION_MODE.ASYNC,
+          status: "skipped",
+          decision: "continue",
+          deferred: false,
+          skipReason: "async_dispatcher_unavailable",
+        });
+        continue;
+      }
       const queued = {
         execId: crypto.randomUUID(),
         hookId: hook.id,

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-core.js

@@ -19,7 +19,10 @@ import path from "path";
 import broker from "../lib/process-execution-broker/index.js";
 import os from "os";
 import { createHash, randomUUID } from "node:crypto";
+import skillInvocationReceipt from "@chainlesschain/session-core/skill-invocation-receipt";
 import { isProxy } from "node:util/types";
+
+const { startSkillInvocation, settleSkillInvocation } = skillInvocationReceipt;
 import sharedCodingAgentPolicy from "./coding-agent-policy.cjs";
 import sharedShellPolicy from "./coding-agent-shell-policy.cjs";
 import sharedPermissionRules from "../lib/permission-rules.cjs";
@@ -3570,6 +3573,8 @@ export async function executeTool(name, args, context = {}) {
       onProviderReceipt: context.onProviderReceipt || null,
       onToolCallBoundary: context.onToolCallBoundary || null,
       onToolCallSettlement: context.onToolCallSettlement || null,
+      hookTraceId: context.hookTraceId || null,
+      skillLifecycleMode: context.skillLifecycleMode || "active",
       backgroundUsageFailureState: context.backgroundUsageFailureState || null,
       planManager,
       permissionRules: context.permissionRules || null,
@@ -3707,6 +3712,7 @@ export async function executeTool(name, args, context = {}) {
                     { cwd, broker },
                   )
               : null,
+          skipAsyncWithoutDispatcher: true,
         },
       );
       for (const hookResult of outcome.results || []) {
@@ -5151,6 +5157,7 @@ async function executeToolInner(
     // Hook-envelope tracing: this run's trace id, threaded into child loops
     // (spawn_sub_agent / isolated run_skill) as their parent_id.
     hookTraceId = null,
+    skillLifecycleMode = "active",
   },
 ) {
   const localToolDescriptor =
@@ -7866,6 +7873,63 @@ async function executeToolInner(
         });
       }
 
+      const selectedSkillDigest =
+        match.executionIdentity?.contentDigest ||
+        `sha256:${createHash("sha256").update(admittedSkillBody).digest("hex")}`;
+      const toolSetDigest = `sha256:${createHash("sha256")
+        .update(
+          JSON.stringify(
+            [...(effectiveAllowedToolNames || [])].map(String).sort(),
+          ),
+        )
+        .digest("hex")}`;
+      const policyDigest = `sha256:${createHash("sha256")
+        .update(
+          JSON.stringify({
+            hasApprovalGate: Boolean(approvalGate),
+            hasPermissionRules: Boolean(permissionRules),
+            hasSandbox: Boolean(sandbox),
+            hermeticExecution: hermeticExecution === true,
+          }),
+        )
+        .digest("hex")}`;
+      const invocationStartedAt = Date.now();
+      const invocationStart = startSkillInvocation({
+        attributionRequired: ["automatic-candidate", "canary"].includes(
+          skillLifecycleMode,
+        ),
+        evolutionRunId: workflowEffectId || sessionId,
+        traceId: hookTraceId || sessionId,
+        trajectorySegmentId: turnId || toolCallId,
+        selectedSkillDigest,
+        routerCandidates: [
+          {
+            digest: selectedSkillDigest,
+            score: 1,
+            reason: "explicit-run_skill",
+          },
+        ],
+        providerModelVersion:
+          llmOptions?.provider && llmOptions?.model
+            ? `${llmOptions.provider}:${llmOptions.model}`
+            : null,
+        toolSetDigest,
+        osSandboxPermissionPolicyDigest: policyDigest,
+        taskCohort: "cli:run_skill",
+      });
+      const settleInvocation = (executionStatus, result = {}) =>
+        settleSkillInvocation(invocationStart, {
+          executionStatus,
+          graderReceipts: result.graderReceipts || [],
+          userCorrectionRef: result.userCorrectionRef || null,
+          tokensInput:
+            result.usage?.inputTokens || result.usage?.tokensInput || 0,
+          tokensOutput:
+            result.usage?.outputTokens || result.usage?.tokensOutput || 0,
+          costUsd: result.usage?.costUsd || result.costUsd || 0,
+          latencyMs: Date.now() - invocationStartedAt,
+        });
+
       // Check if skill requests isolation (via SKILL.md frontmatter)
       const skillIsolation = match.isolation === true;
       if (skillIsolation) {
@@ -8066,6 +8130,7 @@ async function executeToolInner(
               success: false,
               isolated: true,
               skill: args.skill_name,
+              invocationReceipt: settleInvocation("failed", result),
               code: result?.code || "CC_SKILL_ISOLATED_EXECUTION_FAILED",
               error: `Isolated skill execution failed: ${failureDetail}`,
               ...(result?.summary ? { summary: result.summary } : {}),
@@ -8075,6 +8140,7 @@ async function executeToolInner(
             success: true,
             isolated: true,
             skill: args.skill_name,
+            invocationReceipt: settleInvocation("completed", result),
             summary: result.summary,
             toolsUsed: result.toolsUsed,
           });
@@ -8096,6 +8162,7 @@ async function executeToolInner(
             success: false,
             isolated: true,
             skill: args.skill_name,
+            invocationReceipt: settleInvocation("failed"),
             code: err?.code || "CC_SKILL_ISOLATED_EXECUTION_FAILED",
             error: `Isolated skill execution failed: ${err.message}`,
           });
@@ -8112,6 +8179,7 @@ async function executeToolInner(
       return attachDescriptor({
         error: `Skill "${args.skill_name}" cannot execute handler.js directly. Add isolation: true and use the controlled agent-tool path.`,
         code: "CC_SKILL_DIRECT_HANDLER_BLOCKED",
+        invocationReceipt: settleInvocation("blocked"),
         policy: { decision: "blocked", via: "skill-execution-boundary" },
       });
     }