chainlesschain 0.166.46 → 0.166.48

package/src/lib/evolution/wiki-evidence-commit-guard.js

@@ -0,0 +1,366 @@
+import { randomUUID } from "node:crypto";
+import { types } from "node:util";
+import {
+  captureWikiRevisionReader,
+  WikiMaintainerLedgerAdapter,
+} from "./wiki-maintainer-ledger-adapter.js";
+import {
+  digestWikiState,
+  WIKI_EVIDENCE_SCHEMA,
+  WIKI_PATTERN_STATUS,
+} from "./evidence-backed-wiki-maintainer.js";
+import { verifyWikiRevision } from "./wiki-revision-protocol.js";
+
+export const WIKI_EVIDENCE_COMMIT_REQUEST_SCHEMA =
+  "chainlesschain.wiki-evidence-commit-request/v1";
+export const WIKI_EVIDENCE_COMMIT_LEASE_SCHEMA =
+  "chainlesschain.wiki-evidence-commit-lease/v1";
+export const WIKI_EVIDENCE_COMMIT_DENIED_CODE =
+  "CC_WIKI_EVIDENCE_COMMIT_DENIED";
+export const WIKI_EVIDENCE_COMMIT_RELEASE_FAILED_CODE =
+  "CC_WIKI_EVIDENCE_COMMIT_RELEASE_FAILED";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const USED_LEASES = new WeakSet();
+const TERMINAL = new Set([
+  WIKI_PATTERN_STATUS.QUARANTINED,
+  WIKI_PATTERN_STATUS.REVOKED,
+  WIKI_PATTERN_STATUS.TOMBSTONED,
+]);
+const EVIDENCE_KEYS = [
+  "schema",
+  "tenantId",
+  "ref",
+  "sourceDigest",
+  "projectionDigest",
+  "artifactRef",
+  "trustedProjection",
+  "trustDomain",
+  "kind",
+  "status",
+  "observedAt",
+  "expiresAt",
+  "data",
+];
+const LEASE_KEYS = [
+  "schema",
+  "tenantId",
+  "runId",
+  "requestDigest",
+  "evidenceBindingDigest",
+  "leaseId",
+  "assertCurrent",
+  "release",
+];
+function denied(message, cause) {
+  const error = new Error(message, cause === undefined ? undefined : { cause });
+  error.code = WIKI_EVIDENCE_COMMIT_DENIED_CODE;
+  return error;
+}
+function record(value, label, keys) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    types.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  )
+    throw denied(`${label} must be a plain non-Proxy record`);
+  const own = Reflect.ownKeys(value);
+  if (
+    (keys &&
+      (own.length !== keys.length || own.some((key) => !keys.includes(key)))) ||
+    own.some(
+      (key) =>
+        typeof key !== "string" ||
+        !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value"),
+    )
+  )
+    throw denied(`${label} must contain only exact own data fields`);
+  return value;
+}
+function syncMethod(value, name, label) {
+  const method = Object.getOwnPropertyDescriptor(value, name)?.value;
+  if (
+    typeof method !== "function" ||
+    types.isProxy(method) ||
+    types.isAsyncFunction(method) ||
+    types.isGeneratorFunction(method)
+  )
+    throw denied(`${label}.${name} must be synchronous`);
+  return (...args) => Reflect.apply(method, value, args);
+}
+// Copy before calling any host authority. No getters, toJSON, custom prototypes,
+// proxies, sparse arrays or mutable aliases survive into the publish request.
+function snapshot(value, budget = { nodes: 0, bytes: 0 }, depth = 0) {
+  if (++budget.nodes > 100_000 || depth > 32)
+    throw denied("Wiki revision exceeds its structural budget");
+  if (value === null || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    budget.bytes += Buffer.byteLength(value, "utf8");
+    if (budget.bytes > 1_048_576)
+      throw denied("Wiki revision strings exceed their byte budget");
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "object" || types.isProxy(value))
+    throw denied("Wiki revision is not plain data");
+  if (Array.isArray(value)) {
+    if (
+      Object.getPrototypeOf(value) !== Array.prototype ||
+      value.length > 100_000 ||
+      Reflect.ownKeys(value).length !== value.length + 1
+    )
+      throw denied("Wiki revision array is not dense and bounded");
+    const result = [];
+    for (let i = 0; i < value.length; i++) {
+      const entry = Object.getOwnPropertyDescriptor(value, String(i));
+      if (!entry || !Object.hasOwn(entry, "value"))
+        throw denied("Wiki revision array contains an accessor or hole");
+      result.push(snapshot(entry.value, budget, depth + 1));
+    }
+    return Object.freeze(result);
+  }
+  record(value, "Wiki revision record");
+  return Object.freeze(
+    Object.fromEntries(
+      Object.keys(value).map((key) => [
+        key,
+        snapshot(
+          Object.getOwnPropertyDescriptor(value, key).value,
+          budget,
+          depth + 1,
+        ),
+      ]),
+    ),
+  );
+}
+function bindingsFor(revision) {
+  const state = revision.state;
+  record(state.evidence, "Wiki evidence map");
+  record(state.patterns, "Wiki pattern map");
+  const refs = new Set();
+  const add = (ref) => {
+    if (typeof ref !== "string" || !ref || !Object.hasOwn(state.evidence, ref))
+      throw denied("Wiki dependency has no bound evidence");
+    refs.add(ref);
+    if (refs.size > 256)
+      throw denied(
+        "Wiki active dependencies exceed 256; none may be truncated",
+      );
+  };
+  // Old evidence can be reused by upsert or merged into an existing pattern.
+  // Therefore scope is the OUTPUT dependencies, not just this request's refs.
+  for (const pattern of Object.values(state.patterns)) {
+    if (TERMINAL.has(pattern.status)) continue;
+    if (!Object.values(WIKI_PATTERN_STATUS).includes(pattern.status))
+      throw denied("Wiki pattern status is invalid");
+    for (const field of ["positiveEvidence", "negativeEvidence"]) {
+      if (!Array.isArray(pattern[field]))
+        throw denied("Wiki pattern dependencies are invalid");
+      for (const ref of pattern[field]) add(ref);
+    }
+  }
+  // Newly read active evidence is also admitted even when no pattern is made.
+  // Terminal cleanup may retain old tombstones without reauthorizing learning.
+  for (const ref of revision.evidenceRefs) {
+    const item = state.evidence[ref];
+    if (!item || !["active", "revoked", "deleted"].includes(item.status))
+      throw denied("Wiki request evidence status is invalid");
+    if (item.status === "active") add(ref);
+  }
+  return Object.freeze(
+    [...refs].sort().map((ref) => {
+      const item = record(
+        state.evidence[ref],
+        "Wiki evidence binding",
+        EVIDENCE_KEYS,
+      );
+      if (
+        item.schema !== WIKI_EVIDENCE_SCHEMA ||
+        item.tenantId !== revision.tenantId ||
+        item.ref !== ref ||
+        item.trustedProjection !== true ||
+        item.status !== "active" ||
+        !DIGEST.test(item.sourceDigest) ||
+        !DIGEST.test(item.projectionDigest) ||
+        typeof item.artifactRef !== "string" ||
+        !item.artifactRef ||
+        typeof item.trustDomain !== "string" ||
+        !item.trustDomain ||
+        !["tool-observation", "grader-receipt"].includes(item.kind) ||
+        !Number.isFinite(Date.parse(item.observedAt)) ||
+        !Number.isFinite(Date.parse(item.expiresAt))
+      )
+        throw denied(
+          "Wiki active dependency is not authenticated typed evidence",
+        );
+      record(item.data, "Wiki trusted metadata");
+      for (const key of [
+        "rawRecordDigest",
+        "manifestDigest",
+        "projectionReceiptDigest",
+        "schemaDigest",
+      ])
+        if (!DIGEST.test(item.data[key]))
+          throw denied("Wiki evidence identity digest is missing");
+      return item;
+    }),
+  );
+}
+
+/**
+ * Explicit host trust boundary. acquireCurrentEvidence MUST synchronously hold
+ * a cross-evidence state/principal/ACL lock (or irrevocable scoped grant) until
+ * release. A timestamp/read receipt alone is not that contract. Deployments must
+ * prove the coordinator's cross-process semantics; this wrapper does not defend
+ * against a malicious authority. The authority NEVER receives publish authority.
+ */
+export function createWikiEvidenceCommitGuard({
+  wikiAdapter,
+  commitCoordinator,
+  principalEnvelope,
+  clock = Date.now,
+} = {}) {
+  if (
+    !wikiAdapter ||
+    types.isProxy(wikiAdapter) ||
+    Object.getPrototypeOf(wikiAdapter) !== WikiMaintainerLedgerAdapter.prototype
+  )
+    throw denied("a genuine production Wiki adapter is required");
+  const reader = captureWikiRevisionReader(wikiAdapter);
+  const publish = syncMethod(wikiAdapter, "commitRevision", "Wiki adapter");
+  record(commitCoordinator, "Wiki commit coordinator", [
+    "acquireCurrentEvidence",
+  ]);
+  const acquire = syncMethod(
+    commitCoordinator,
+    "acquireCurrentEvidence",
+    "Wiki commit coordinator",
+  );
+  if (
+    typeof principalEnvelope !== "string" ||
+    !principalEnvelope ||
+    principalEnvelope.length > 65_536 ||
+    typeof clock !== "function" ||
+    types.isProxy(clock) ||
+    types.isAsyncFunction(clock)
+  )
+    throw denied("Wiki principal envelope and synchronous clock are required");
+  let committing = false;
+  return Object.freeze({
+    commitRevision(input) {
+      if (committing) throw denied("Wiki publication is not reentrant");
+      const owned = snapshot(input);
+      record(
+        owned,
+        "Wiki commit input",
+        Object.hasOwn(owned, "expectedLedgerHead")
+          ? ["expectedStateDigest", "revision", "expectedLedgerHead"]
+          : ["expectedStateDigest", "revision"],
+      );
+      const revision = verifyWikiRevision(owned.revision, reader.descriptor);
+      if (
+        !DIGEST.test(owned.expectedStateDigest) ||
+        owned.expectedStateDigest !== revision.priorStateDigest
+      )
+        throw denied("Wiki prior state is not bound to the publication");
+      const evidenceBindings = bindingsFor(revision);
+      const requestedAt = new Date(clock()).toISOString();
+      if (
+        evidenceBindings.some(
+          (item) => Date.parse(item.expiresAt) <= Date.parse(requestedAt),
+        )
+      )
+        throw denied("Wiki evidence expired before lease acquisition");
+      const evidenceBindingDigest = digestWikiState({
+        domain: "chainlesschain.wiki-evidence-bindings/v1",
+        tenantId: reader.descriptor.tenantId,
+        runId: reader.descriptor.evolutionRunId,
+        evidenceBindings,
+      });
+      const core = Object.freeze({
+        schema: WIKI_EVIDENCE_COMMIT_REQUEST_SCHEMA,
+        tenantId: reader.descriptor.tenantId,
+        runId: reader.descriptor.evolutionRunId,
+        principalEnvelope,
+        expectedStateDigest: owned.expectedStateDigest,
+        revisionId: revision.revisionId,
+        stateDigest: revision.stateDigest,
+        evidenceRefs: revision.evidenceRefs,
+        evidenceBindings,
+        evidenceBindingDigest,
+        requestNonce: randomUUID(),
+        requestedAt,
+      });
+      const request = Object.freeze({
+        ...core,
+        requestDigest: digestWikiState(core),
+      });
+      let release;
+      let receipt;
+      let failure;
+      committing = true;
+      try {
+        const lease = acquire(request);
+        record(lease, "Wiki commit lease", LEASE_KEYS);
+        if (!Object.isFrozen(lease))
+          throw denied("Wiki commit lease must be immutable");
+        if (USED_LEASES.has(lease))
+          throw denied("Wiki commit lease cannot be reused");
+        USED_LEASES.add(lease);
+        release = syncMethod(lease, "release", "Wiki commit lease");
+        const assertCurrent = syncMethod(
+          lease,
+          "assertCurrent",
+          "Wiki commit lease",
+        );
+        if (
+          lease.schema !== WIKI_EVIDENCE_COMMIT_LEASE_SCHEMA ||
+          lease.tenantId !== request.tenantId ||
+          lease.runId !== request.runId ||
+          lease.requestDigest !== request.requestDigest ||
+          lease.evidenceBindingDigest !== request.evidenceBindingDigest ||
+          typeof lease.leaseId !== "string" ||
+          !lease.leaseId ||
+          lease.leaseId.length > 256
+        )
+          throw denied("Wiki commit lease is not bound to the entire request");
+        if (assertCurrent() !== true)
+          throw denied("Wiki commit lease is not currently held");
+        // No await or host-supplied publish callback between lease and real write.
+        receipt = publish(owned);
+      } catch (error) {
+        failure = error?.code
+          ? error
+          : denied("Wiki evidence commit authorization failed", error);
+      } finally {
+        let releaseFailure;
+        try {
+          if (release && release() !== undefined)
+            releaseFailure = new Error(
+              "Wiki commit lease release must be synchronous and return undefined",
+            );
+        } catch (error) {
+          releaseFailure = error;
+        }
+        if (releaseFailure) {
+          if (receipt?.committed === true) {
+            failure = new Error(
+              "Wiki was committed but its authorization lease failed to release",
+              { cause: releaseFailure },
+            );
+            failure.code = WIKI_EVIDENCE_COMMIT_RELEASE_FAILED_CODE;
+            failure.committed = true;
+            failure.receipt = receipt;
+          } else if (!failure)
+            failure = denied(
+              "Wiki commit lease failed to release",
+              releaseFailure,
+            );
+        }
+        committing = false;
+      }
+      if (failure) throw failure;
+      return receipt;
+    },
+  });
+}

package/src/lib/evolution/wiki-informed-skill-proposer.js

@@ -2,6 +2,8 @@ import { createHash } from "node:crypto";
 
 export const WIKI_SKILL_PROPOSAL_SCHEMA =
   "chainlesschain.wiki-informed-skill-proposal/v2";
+export const WIKI_SKILL_CANDIDATE_CONTENT_SCHEMA =
+  "chainlesschain.wiki-informed-skill-candidate-content/v1";
 export const WIKI_PROPOSAL_STATUS = Object.freeze({
   PROPOSAL: "proposal",
   NO_PROPOSAL: "no-proposal",
@@ -42,6 +44,16 @@ export function computeWikiSkillProposalDigest(proposal) {
   return hash(proposal);
 }
 
+function candidateContent(proposal) {
+  // Evidence digests belong to the candidate's ID-bound metadata, not its
+  // plaintext body. Keep the full proposal (and its independent digest) intact.
+  // This is a representation change, not a schema-based secret-scan exemption:
+  // PURPOSE references, machineDiff and all other body fields remain scanned.
+  const body = { ...proposal, schema: WIKI_SKILL_CANDIDATE_CONTENT_SCHEMA };
+  delete body.sourceEvidenceRefs;
+  return canonical(body);
+}
+
 function deepFreeze(value) {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {
     Object.freeze(value);
@@ -408,7 +420,7 @@ export class WikiInformedSkillProposer {
       proposerModel: proposal.proposerModel,
       requestedCapabilities: proposal.requestedCapabilities,
       sourceEvidenceRefs: proposal.sourceEvidenceRefs,
-      content: canonical(proposal),
+      content: candidateContent(proposal),
     });
     const created = await this._ports.createCandidate(candidateInput);
     const candidate = created?.candidate;

package/src/lib/goal-context.js

@@ -63,25 +63,34 @@ export function goalPrepareCall(goal) {
 
 /**
  * Compose several `prepareCall` functions into one. Each is invoked per turn
- * and their non-empty `systemSuffix` strings are concatenated. A failing
- * member is skipped, never fatal.
+ * and their non-empty transient system/user contexts are concatenated without
+ * changing authority: `systemSuffix` stays system, `userContext` stays user.
+ * A failing member is skipped, never fatal.
  * @param {Array<Function|null|undefined>} fns
  * @returns {(ctx:object) => Promise<{systemSuffix:string}|null>}
  */
 export function composePrepareCall(fns) {
   const list = (fns || []).filter((f) => typeof f === "function");
   return async (ctx) => {
-    const parts = [];
+    const systemParts = [];
+    const userParts = [];
     for (const fn of list) {
       try {
         const r = await fn(ctx);
         if (r && typeof r.systemSuffix === "string" && r.systemSuffix.trim()) {
-          parts.push(r.systemSuffix);
+          systemParts.push(r.systemSuffix);
+        }
+        if (r && typeof r.userContext === "string" && r.userContext.trim()) {
+          userParts.push(r.userContext);
         }
       } catch {
         /* a failing member must not break the turn */
       }
     }
-    return parts.length ? { systemSuffix: parts.join("\n\n") } : null;
+    if (systemParts.length === 0 && userParts.length === 0) return null;
+    return {
+      ...(systemParts.length ? { systemSuffix: systemParts.join("\n\n") } : {}),
+      ...(userParts.length ? { userContext: userParts.join("\n\n") } : {}),
+    };
   };
 }

package/src/lib/interaction-adapter.js

@@ -20,6 +20,7 @@ import {
   normalizeInteractionBinding,
   sameInteractionBinding,
 } from "./interaction-binding.js";
+import { DeferredQuestionContext } from "./deferred-question-context.js";
 import { createEnvelope } from "@chainlesschain/session-core";
 
 // Phase 5: parallel service-envelope emission. Map WS agent-handler event
@@ -133,6 +134,35 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     // global default tracker.
     this._sequenceTracker = new CodingAgentSequenceTracker();
     this._questionSequence = 0;
+    const deferredState =
+      options.deferredState && typeof options.deferredState === "object"
+        ? options.deferredState
+        : {};
+    this._contextRevision = Number.isSafeInteger(deferredState.contextRevision)
+      ? deferredState.contextRevision
+      : 0;
+    this.onDeferredQuestionChange =
+      typeof options.onDeferredQuestionChange === "function"
+        ? options.onDeferredQuestionChange
+        : null;
+    this._deferredQuestionContext = new DeferredQuestionContext({
+      sessionId: this.sessionId,
+      initialAnswers: Array.isArray(deferredState.deferredAnswers)
+        ? deferredState.deferredAnswers.map((answer) => ({
+            ...answer,
+            questionId: answer.questionId || answer.requestId,
+          }))
+        : [],
+      onConsumed: (questionIds) =>
+        this._notifyDeferredQuestion("question.deferred.consumed", {
+          questionIds,
+        }),
+    });
+    for (const pending of Array.isArray(deferredState.deferredQuestions)
+      ? deferredState.deferredQuestions
+      : []) {
+      this._restoreDeferredQuestion(pending);
+    }
     // Phase 5: parallel service-envelope emission. Opt-in (default off) so
     // legacy callers that count ws.send invocations stay green.
     this.enablePhase5Envelopes = options.enablePhase5Envelopes === true;
@@ -155,6 +185,54 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     }
   }
 
+  _notifyDeferredQuestion(type, payload) {
+    if (!this.onDeferredQuestionChange) return;
+    try {
+      this.onDeferredQuestionChange({ type, payload });
+    } catch {
+      // The live interaction remains available; the host journal owns retry.
+    }
+  }
+
+  _restoreDeferredQuestion(record) {
+    const requestId = String(record?.requestId || "").trim();
+    const binding = normalizeInteractionBinding(record?.binding);
+    if (!requestId || binding.sessionId !== String(this.sessionId)) return;
+    this._questionSequence = Math.max(
+      this._questionSequence,
+      Number.isSafeInteger(binding.sequence) ? binding.sequence : 0,
+    );
+    this._pending.set(requestId, {
+      resolve: (answer) => {
+        const resolvedRevision = this._contextRevision;
+        this._deferredQuestionContext.record({
+          questionId: requestId,
+          question: record.question,
+          answer,
+          binding,
+          requestedRevision: record.contextRevision,
+          resolvedRevision,
+        });
+        this._notifyDeferredQuestion("question.deferred.resolved", {
+          requestId,
+          question: record.question,
+          answer,
+          binding,
+          requestedRevision: record.contextRevision,
+          resolvedRevision,
+        });
+      },
+      reject: () => {},
+      timeoutId: null,
+      kind: "question",
+      approvalRequest: false,
+      binding,
+      bindingType: "interaction",
+      requireBinding: true,
+      deferred: true,
+    });
+  }
+
   /** Generate a unique request id */
   _requestId() {
     return `q-${Date.now()}-${createHash("sha256").update(Math.random().toString()).digest("hex").slice(0, 6)}`;
@@ -207,6 +285,10 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
         bindingType: options.bindingType || null,
         requireBinding: options.requireBinding === true,
       });
+      options.onRegistered?.({
+        requestId,
+        binding: options.binding || null,
+      });
 
       if (approvalRequest) {
         this._notifyPendingApproval("approval.requested", {
@@ -337,7 +419,7 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
    * elicitation, while exposing the stream protocol's `question_request`
    * shape so capable UIs can render options natively.
    */
-  async askUser({
+  askUser({
     question,
     options = null,
     multiSelect = false,
@@ -348,6 +430,9 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     turnId,
     toolUseId,
     metadata = null,
+    mode = "blocking",
+    purpose = "decision",
+    onRegistered = null,
   } = {}) {
     const normalizedTurnId =
       turnId === undefined || turnId === null ? null : String(turnId);
@@ -380,6 +465,9 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
         question: typeof question === "string" ? question : "",
         options: Array.isArray(options) ? options : null,
         multiSelect: multiSelect === true,
+        mode,
+        blocking: mode !== "deferred",
+        purpose,
         ...(defaultValue !== undefined ? { defaultValue } : {}),
         ...(onTimeout ? { onTimeout } : {}),
         ...(onReject ? { onReject } : {}),
@@ -401,10 +489,84 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
         binding,
         bindingType: "interaction",
         ...(Number(timeoutMs) > 0 ? { timeoutMs: Number(timeoutMs) } : {}),
+        ...(typeof onRegistered === "function" ? { onRegistered } : {}),
       },
     );
   }
 
+  /**
+   * Register an informational question without blocking the current agent loop.
+   * Its answer is retained as one-shot, user-authority context for prepareCall.
+   */
+  deferUserQuestion(request = {}) {
+    let registration = null;
+    const requestedRevision = this._contextRevision;
+    const answer = this.askUser({
+      ...request,
+      mode: "deferred",
+      onRegistered: (value) => {
+        registration = value;
+      },
+    });
+    this._notifyDeferredQuestion("question.deferred.requested", {
+      requestId: registration?.requestId,
+      question: request.question,
+      options: request.options,
+      multiSelect: request.multiSelect === true,
+      purpose: request.purpose || "information",
+      binding: registration?.binding || null,
+      contextRevision: requestedRevision,
+    });
+    answer
+      .then((value) => {
+        this._deferredQuestionContext.record({
+          questionId: registration?.requestId,
+          question: request.question,
+          answer: value,
+          binding: registration?.binding || null,
+          requestedRevision,
+          resolvedRevision: this._contextRevision,
+        });
+        this._notifyDeferredQuestion("question.deferred.resolved", {
+          requestId: registration?.requestId,
+          question: request.question,
+          answer: value,
+          binding: registration?.binding || null,
+          requestedRevision,
+          resolvedRevision: this._contextRevision,
+        });
+      })
+      .catch(() => {
+        // Timeout/disconnect simply leaves no asynchronous user context.
+      });
+    return Object.freeze({
+      questionId: registration?.requestId,
+      status: "pending",
+      mode: "deferred",
+      purpose: request.purpose || "information",
+      authorization: false,
+      binding: registration?.binding || null,
+      contextRevision: requestedRevision,
+    });
+  }
+
+  beginContextRevision(revision = null) {
+    this._contextRevision = Number.isSafeInteger(revision)
+      ? revision
+      : this._contextRevision + 1;
+    this._notifyDeferredQuestion("question.context.revision", {
+      contextRevision: this._contextRevision,
+    });
+    return this._contextRevision;
+  }
+
+  createDeferredPrepareCall() {
+    return () =>
+      this._deferredQuestionContext.prepareCall({
+        currentRevision: this._contextRevision,
+      });
+  }
+
   /**
    * Called by ws-server when a session-answer message arrives.
    * Resolves the corresponding pending promise.
@@ -502,6 +664,9 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
       }
       pending.reject(error);
     }
+    // Deferred questions and already-resolved answers are durable host state;
+    // a transport disconnect must not erase them. Blocking questions and
+    // approvals above are still rejected fail-closed.
   }
 
   emit(eventType, data) {