chainlesschain 0.166.46 → 0.166.48

package/src/gateways/ws/ws-agent-handler.js

@@ -76,6 +76,7 @@ import {
 import { sessionBudgetAdmissionError } from "../../lib/session-budget-production-root.js";
 import { captureAgentSkillOutcomeIndex } from "../../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../../lib/skill-vector-authority.js";
+import { captureSkillRuntimeDependencies } from "../../lib/evolution/skill-runtime-revalidation.js";
 import {
   beginSessionBudgetUsage,
   markSessionBudgetUsageUnknown,
@@ -84,6 +85,7 @@ import {
 } from "../../lib/session-budget-usage.js";
 import { HostResourceBudget } from "../../lib/host-resource-budget.js";
 import { captureAgentEvolutionRuntimeComposition } from "../../lib/evolution/agent-evolution-runtime-composition-brand.js";
+import { composePrepareCall } from "../../lib/goal-context.js";
 
 const CANONICAL_WS_TURN_QUEUES = new Map();
 const CANONICAL_WS_CLAIM_CAS_ATTEMPTS = 4;
@@ -182,8 +184,14 @@ export class WSAgentHandler {
     evolutionCompositionFactory = null,
     skillOutcomeIndex = null,
     skillVectorAuthority = null,
+    skillRuntimeAdmission = null,
+    skillRuntimeAdmissionRequired = false,
   }) {
     this.session = session;
+    this._runtimeAdmissionDependencies = captureSkillRuntimeDependencies({
+      skillRuntimeAdmission,
+      skillRuntimeAdmissionRequired,
+    });
     this.interaction = interaction;
     this.db = db || null;
     this._processing = false;
@@ -371,6 +379,10 @@ export class WSAgentHandler {
           "WebSocket evolution composition and Skill vector authority must share one tenant",
         );
       }
+      captureSkillRuntimeDependencies(
+        this._runtimeAdmissionDependencies,
+        composition.tenantId,
+      );
       await composition.evolutionIngress.start();
       return composition;
     } catch (cause) {
@@ -1373,6 +1385,7 @@ export class WSAgentHandler {
     }
 
     this._processing = true;
+    this.interaction.beginContextRevision?.();
     const abortController = new AbortController();
     const turnSignal = this._turnSignal(abortController.signal);
     this._abortController = abortController;
@@ -1539,9 +1552,13 @@ export class WSAgentHandler {
         shellPolicyOverrides: session.shellPolicyOverrides || null,
         slotFiller,
         interaction: this.interaction,
+        prepareCall: composePrepareCall([
+          this.interaction.createDeferredPrepareCall?.(),
+        ]),
         ...(this._skillOutcomeIndex === null
           ? {}
           : { skillOutcomeIndex: this._skillOutcomeIndex }),
+        ...this._runtimeAdmissionDependencies,
         ...(this._skillVectorAuthority === null
           ? {}
           : { skillVectorAuthority: this._skillVectorAuthority }),

package/src/gateways/ws/ws-server.js

@@ -17,6 +17,7 @@ import { dirname, join } from "node:path";
 import { WebSocketServer } from "ws";
 import { captureAgentSkillOutcomeIndex } from "../../lib/evolution/agent-evolution-runtime-composition-brand.js";
 import { captureSkillVectorAuthority } from "../../lib/skill-vector-authority.js";
+import { captureSkillRuntimeDependencies } from "../../lib/evolution/skill-runtime-revalidation.js";
 import {
   createEnvelope,
   envelopeFromStreamEvent,
@@ -332,6 +333,8 @@ export class ChainlessChainWSServer extends EventEmitter {
     }
     this.evolutionCompositionFactory =
       options.evolutionCompositionFactory || null;
+    this.runtimeAdmissionDependencies =
+      captureSkillRuntimeDependencies(options);
     this.skillOutcomeIndex =
       options.skillOutcomeIndex == null
         ? null

package/src/gateways/ws/ws-session-state.js

@@ -16,6 +16,7 @@ export const DEFAULT_WS_SESSION_STATE_MAX_EVENTS = 64;
 
 const RUN_STATUSES = new Set(["idle", "running", "interrupted"]);
 const APPROVAL_STATUSES = new Set(["pending", "interrupted"]);
+const MAX_DEFERRED_QUESTIONS = 32;
 
 function own(object, key) {
   return Object.prototype.hasOwnProperty.call(object || {}, key);
@@ -112,12 +113,87 @@ function normalizeRun(value) {
   };
 }
 
+function normalizeDeferredRecord(value, resolved = false) {
+  if (!value || typeof value !== "object") return null;
+  const requestId =
+    typeof value.requestId === "string" && value.requestId.length > 0
+      ? value.requestId
+      : null;
+  if (!requestId || !value.binding || typeof value.binding !== "object") {
+    return null;
+  }
+  const binding = cloneJson(value.binding);
+  if (
+    binding.sessionId == null ||
+    !Number.isSafeInteger(binding.sequence) ||
+    binding.sequence <= 0
+  ) {
+    return null;
+  }
+  let answer = "";
+  if (resolved) {
+    if (typeof value.answer === "string") answer = value.answer;
+    else {
+      try {
+        answer = JSON.stringify(value.answer);
+      } catch {
+        answer = String(value.answer ?? "");
+      }
+    }
+    if (typeof answer !== "string") answer = String(value.answer ?? "");
+    answer = answer.slice(0, 16384);
+  }
+  return {
+    requestId,
+    question:
+      typeof value.question === "string" ? value.question.slice(0, 2048) : "",
+    binding,
+    requestedRevision: nonNegativeRevision(
+      value.requestedRevision ?? value.contextRevision,
+    ),
+    ...(resolved
+      ? {
+          answer,
+          resolvedRevision: nonNegativeRevision(value.resolvedRevision),
+        }
+      : {
+          options: Array.isArray(value.options)
+            ? cloneJson(value.options.slice(0, 32), [])
+            : null,
+          multiSelect: value.multiSelect === true,
+          purpose:
+            value.purpose === "preference" ? "preference" : "information",
+          contextRevision: nonNegativeRevision(value.contextRevision),
+        }),
+  };
+}
+
+function upsertBounded(list, record) {
+  if (!record) return list;
+  const next = list.filter((item) => item.requestId !== record.requestId);
+  next.push(record);
+  return next.slice(-MAX_DEFERRED_QUESTIONS);
+}
+
 function normalizeSnapshot(value = {}, options = {}) {
   const source = value && typeof value === "object" ? value : {};
   const snapshot = {
     revision: nonNegativeRevision(source.revision),
     todo: normalizeTodoSnapshot(source.todo),
     pendingApproval: normalizePendingApproval(source.pendingApproval),
+    contextRevision: nonNegativeRevision(source.contextRevision),
+    deferredQuestions: Array.isArray(source.deferredQuestions)
+      ? source.deferredQuestions
+          .map((value) => normalizeDeferredRecord(value, false))
+          .filter(Boolean)
+          .slice(-MAX_DEFERRED_QUESTIONS)
+      : [],
+    deferredAnswers: Array.isArray(source.deferredAnswers)
+      ? source.deferredAnswers
+          .map((value) => normalizeDeferredRecord(value, true))
+          .filter(Boolean)
+          .slice(-MAX_DEFERRED_QUESTIONS)
+      : [],
     run: normalizeRun(source.run),
   };
 
@@ -183,6 +259,58 @@ function applyEvent(snapshot, event) {
       }
       break;
 
+    case "question.context.revision":
+      next.contextRevision = Math.max(
+        next.contextRevision,
+        nonNegativeRevision(payload.contextRevision),
+      );
+      break;
+
+    case "question.deferred.requested": {
+      const question = normalizeDeferredRecord(payload, false);
+      if (
+        question &&
+        question.binding.sessionId === payload.binding?.sessionId
+      ) {
+        next.deferredQuestions = upsertBounded(
+          next.deferredQuestions,
+          question,
+        );
+      }
+      break;
+    }
+
+    case "question.deferred.resolved": {
+      const answer = normalizeDeferredRecord(payload, true);
+      if (answer) {
+        const pending = next.deferredQuestions.find(
+          (item) => item.requestId === answer.requestId,
+        );
+        if (
+          pending &&
+          JSON.stringify(pending.binding) === JSON.stringify(answer.binding)
+        ) {
+          next.deferredQuestions = next.deferredQuestions.filter(
+            (item) => item.requestId !== answer.requestId,
+          );
+          next.deferredAnswers = upsertBounded(next.deferredAnswers, answer);
+        }
+      }
+      break;
+    }
+
+    case "question.deferred.consumed": {
+      const ids = new Set(
+        Array.isArray(payload.questionIds)
+          ? payload.questionIds.filter((id) => typeof id === "string")
+          : [],
+      );
+      next.deferredAnswers = next.deferredAnswers.filter(
+        (item) => !ids.has(item.requestId),
+      );
+      break;
+    }
+
     case "run.started":
       next.run = normalizeRun({
         status: "running",
@@ -302,6 +430,9 @@ export function createWsSessionState(options = {}) {
         revision: 0,
         todo: normalizeTodoSnapshot(options.todo),
         pendingApproval: null,
+        contextRevision: 0,
+        deferredQuestions: [],
+        deferredAnswers: [],
         run: normalizeRun(),
         ...(hasPlanSnapshot
           ? { planSnapshot: cloneJson(options.planSnapshot) }

package/src/generated/cc-agent-protocol.schema.json

@@ -18,12 +18,13 @@
       "agent_stream_events",
       "agent_stream_payloads",
       "unified_policy_decision",
+      "deferred_questions",
       "context_memory_kernel"
     ],
     "contextMemory": {
       "schemaId": "https://chainlesschain.com/schemas/context-memory-kernel/v1",
       "schemaVersion": 1,
-      "sourceDigest": "sha256:9dabfbccf4315d511bb09d13decc743e1b43b90ad81eaa5da62df44ba55934cb",
+      "sourceDigest": "sha256:6599168b8fa9ace2d1697c44c2ac10141aa20bd7e9be29e9ea814ff032f87d68",
       "methods": {
         "context/plan": {
           "request": "ContextPlanRequest",
@@ -3832,6 +3833,7 @@
         "method": {
           "enum": [
             "approval/decide",
+            "question/answer",
             "humanTask/decide"
           ]
         },
@@ -3862,6 +3864,8 @@
             "item/completed",
             "approval/requested",
             "approval/resolved",
+            "question/requested",
+            "question/resolved",
             "tool/requested",
             "tool/result",
             "subagent/started",
@@ -4804,6 +4808,13 @@
             "$ref": "#/$defs/ContextScopeAdmission"
           }
         },
+        "semanticCandidates": {
+          "type": "array",
+          "maxItems": 1000,
+          "items": {
+            "$ref": "#/$defs/MemorySemanticCandidate"
+          }
+        },
         "limit": {
           "type": "integer",
           "minimum": 1,
@@ -4850,6 +4861,15 @@
           "type": "integer",
           "minimum": 0
         },
+        "retrievalMode": {
+          "enum": [
+            "governed_hybrid"
+          ]
+        },
+        "semanticEvidenceCount": {
+          "type": "integer",
+          "minimum": 0
+        },
         "results": {
           "type": "array",
           "maxItems": 1000,
@@ -5764,6 +5784,33 @@
           "$ref": "#/$defs/MemoryRecallResult"
         }
       }
+    },
+    "MemorySemanticCandidate": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "memoryId",
+        "revision",
+        "recordDigest",
+        "score"
+      ],
+      "properties": {
+        "memoryId": {
+          "$ref": "#/$defs/ContextMemoryIdentifier"
+        },
+        "revision": {
+          "type": "integer",
+          "minimum": 1
+        },
+        "recordDigest": {
+          "$ref": "#/$defs/ContextMemoryDigest"
+        },
+        "score": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        }
+      }
     }
   }
 }

package/src/lazy-dispatch.js

@@ -814,7 +814,14 @@ export function isFastReadOnlyInvocation(argv, env = process.env) {
     commandLocation?.token === "session" &&
     argv[commandLocation.index + 1] === "show" &&
     !explicitOtlp;
-  return quickStatus || sessionShow;
+  // Capability inspection is a deliberately static, read-only diagnostic.
+  // Keep it ahead of observability initialization even when an OTLP endpoint
+  // is configured; otherwise merely inspecting a profile creates a queue and
+  // contradicts the command's no-network/no-write contract.
+  const llmCapabilities =
+    commandLocation?.token === "llm" &&
+    argv[commandLocation.index + 1] === "capabilities";
+  return quickStatus || sessionShow || llmCapabilities;
 }
 
 let processHandlersInstalled = false;