chainlesschain 0.166.10 → 0.166.14

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

@@ -42,6 +42,12 @@ import { createWsApprovalGate } from "./ws-approval-gate.js";
 import { createSessionMcpLedgerSink } from "../../lib/mcp-call-ledger-store.js";
 import { createMcpHostRecoveryRuntime } from "../../lib/mcp-host-recovery-runtime.js";
 import { compactConversationWithProvider } from "../../harness/provider-backed-compaction.js";
+import {
+  estimateMessagesTokens,
+  PromptCompressor,
+} from "../../harness/prompt-compressor.js";
+import { resolveCliContextMemoryCutover } from "../../lib/context-memory-kernel/authority.js";
+import { compactLiveMessagesCanonical } from "../../lib/context-memory-kernel/live-compaction.js";
 import { projectCanonicalResumeMessages } from "../../lib/session-message-provenance.js";
 import { feature } from "../../lib/feature-flags.js";
 import { classifyStreamRetryReason } from "../../lib/stream-retry.js";
@@ -586,6 +592,124 @@ export class WSAgentHandler {
     return block;
   }
 
+  _contextMemoryCutover() {
+    return resolveCliContextMemoryCutover({
+      env: this.session.contextMemoryEnv || process.env,
+      scopeKey: `cli:session:${this.session.id}`,
+    });
+  }
+
+  async _compactContextMemory(messages, providerOptions, trigger) {
+    const cutover = this._contextMemoryCutover();
+    if (!cutover.canonical) {
+      return compactConversationWithProvider(messages, providerOptions);
+    }
+    const probe = new PromptCompressor({
+      model: providerOptions.model,
+      provider: providerOptions.provider,
+      ...(providerOptions.maxMessages
+        ? { maxMessages: providerOptions.maxMessages }
+        : {}),
+      ...(providerOptions.maxTokens
+        ? { maxTokens: providerOptions.maxTokens }
+        : {}),
+    });
+    if (
+      providerOptions.onlyIfNeeded === true &&
+      !probe.shouldAutoCompact(messages)
+    ) {
+      const tokens = estimateMessagesTokens(messages);
+      return {
+        messages: [...messages],
+        stats: {
+          strategy: "none",
+          originalMessages: messages.length,
+          compressedMessages: messages.length,
+          originalTokens: tokens,
+          compressedTokens: tokens,
+          saved: 0,
+        },
+        degradedEvent: null,
+        usageEvent: null,
+        usageUnknownEvent: null,
+      };
+    }
+
+    let compatibilityResult = null;
+    const canonical = await compactLiveMessagesCanonical(messages, {
+      compressor: {
+        maxTokens: probe.maxTokens,
+        compress: async (dropped) => {
+          compatibilityResult = await compactConversationWithProvider(
+            dropped,
+            providerOptions,
+          );
+          await providerOptions.onContextMemorySummarySettled?.(
+            compatibilityResult,
+          );
+          return compatibilityResult;
+        },
+      },
+      sessionId: this.session.id,
+      operationId: `${trigger}-${randomUUID()}`,
+      provider: this.session.provider,
+      model: this.session.model,
+      env: this.session.contextMemoryEnv || process.env,
+      persist: this.session.canonicalJsonlSession === true,
+      trigger,
+      ...(this.session.canonicalJsonlSession === true
+        ? {
+            commit: (stats, output, settlement) => {
+              this._sessionHostLease?.assert?.();
+              const result =
+                this._canonicalSessionStore.appendCompactEventIfMessagesMatch(
+                  this.session.id,
+                  {
+                    ...stats,
+                    trigger,
+                    messages: projectCanonicalResumeMessages(output, {
+                      strict: true,
+                    }),
+                  },
+                  settlement.expectedMessages,
+                );
+              if (result && typeof result.then === "function") {
+                void Promise.resolve(result).catch(() => {});
+                const error = new TypeError(
+                  "Canonical compact settlement must be synchronous",
+                );
+                error.code = "CC_COMPACTION_SETTLEMENT_ASYNC";
+                throw error;
+              }
+              return result;
+            },
+          }
+        : {}),
+    });
+    if (canonical.receipt.status === "stale") {
+      const error = new Error(
+        "session messages changed during canonical compaction",
+      );
+      error.code = "SESSION_REVISION_STALE";
+      throw error;
+    }
+    if (
+      canonical.receipt.status === "reconciliation_required" &&
+      !compatibilityResult?.usageUnknownEvent
+    ) {
+      const error = new Error("canonical compaction requires reconciliation");
+      error.code = "CC_COMPACTION_RECONCILIATION_REQUIRED";
+      throw error;
+    }
+    return {
+      messages: canonical.messages,
+      stats: canonical.stats,
+      degradedEvent: compatibilityResult?.degradedEvent || null,
+      usageEvent: compatibilityResult?.usageEvent || null,
+      usageUnknownEvent: compatibilityResult?.usageUnknownEvent || null,
+    };
+  }
+
   _canonicalTurnFromAuthority(state, requestId, userMessage, inputDigest) {
     const status = state?.status || (state?.turn ? "completed" : "none");
     this._applyCanonicalMessages(state?.messages || []);
@@ -630,7 +754,8 @@ export class WSAgentHandler {
     const { session } = this;
     if (
       session.autoCompact === false ||
-      !feature("PROMPT_COMPRESSOR") ||
+      (!feature("PROMPT_COMPRESSOR") &&
+        !this._contextMemoryCutover().canonical) ||
       this._compactionSettlementBlock?.commitState === "provider-usage-unknown"
     ) {
       return true;
@@ -647,7 +772,7 @@ export class WSAgentHandler {
     let result;
     try {
       this._sessionHostLease?.assert?.();
-      result = await compactConversationWithProvider(session.messages, {
+      result = await this._compactContextMemory(session.messages, {
         provider: session.provider,
         model: session.model,
         baseUrl: session.baseUrl,
@@ -675,8 +800,17 @@ export class WSAgentHandler {
         maxTokens: session.compactionMaxTokens,
         maxOutputTokens: session.compactionMaxOutputTokens,
         summaryInputMaxChars: session.compactionInputMaxChars,
-      });
-      if (compactionUsageCall) {
+        onContextMemorySummarySettled: (summaryResult) => {
+          if (compactionUsageCall && !compactionUsageSettled) {
+            this._settleCanonicalCompactionUsage(
+              compactionUsageCall,
+              summaryResult,
+            );
+            compactionUsageSettled = true;
+          }
+        },
+      }, "auto");
+      if (compactionUsageCall && !compactionUsageSettled) {
         this._settleCanonicalCompactionUsage(compactionUsageCall, result);
         compactionUsageSettled = true;
       }
@@ -747,7 +881,11 @@ export class WSAgentHandler {
       );
     const shouldSettle = stats?.strategy !== "none" && stats?.saved > 0;
     let settlementError = null;
-    if (!messagesChanged && shouldSettle) {
+    if (
+      !messagesChanged &&
+      shouldSettle &&
+      stats?.canonicalAlreadySettled !== true
+    ) {
       try {
         const settlement =
           this._canonicalSessionStore.appendCompactEventIfMessagesMatch(
@@ -1977,7 +2115,7 @@ export class WSAgentHandler {
         try {
           this.assertSessionBudgetAdmission("WebSocket compaction");
           this._sessionHostLease?.assert?.();
-          result = await compactConversationWithProvider(session.messages, {
+          result = await this._compactContextMemory(session.messages, {
             provider: session.provider,
             model: session.model,
             baseUrl: session.baseUrl,
@@ -2002,8 +2140,17 @@ export class WSAgentHandler {
               : {}),
             maxOutputTokens: session.compactionMaxOutputTokens,
             summaryInputMaxChars: session.compactionInputMaxChars,
-          });
-          if (compactionUsageCall) {
+            onContextMemorySummarySettled: (summaryResult) => {
+              if (compactionUsageCall && !compactionUsageSettled) {
+                this._settleCanonicalCompactionUsage(
+                  compactionUsageCall,
+                  summaryResult,
+                );
+                compactionUsageSettled = true;
+              }
+            },
+          }, "manual");
+          if (compactionUsageCall && !compactionUsageSettled) {
             this._settleCanonicalCompactionUsage(compactionUsageCall, result);
             compactionUsageSettled = true;
           }
@@ -2068,7 +2215,8 @@ export class WSAgentHandler {
           if (
             !commandError &&
             !messagesChanged &&
-            session.canonicalJsonlSession === true
+            session.canonicalJsonlSession === true &&
+            stats?.canonicalAlreadySettled !== true
           ) {
             if (stats?.strategy !== "none") {
               try {

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

@@ -20,6 +20,7 @@ import {
 } from "../../lib/plan-mode.js";
 import { CLIContextEngineering } from "../../lib/cli-context-engineering.js";
 import { CLIPermanentMemory } from "../../lib/permanent-memory.js";
+import { resolveCliContextMemoryCutover } from "../../lib/context-memory-kernel/authority.js";
 import {
   createTrustedMcpServerMap,
   resolveMcpServerPolicy,
@@ -61,7 +62,48 @@ import {
   hydrateWsSessionState,
   recoverWsSessionState,
   serializeWsSessionState,
+  WS_SESSION_STATE_SCHEMA,
+  WS_SESSION_STATE_VERSION,
 } from "./ws-session-state.js";
+import {
+  appendEvent as appendCanonicalSessionEvent,
+  findLatestEvent as findLatestCanonicalSessionEvent,
+} from "../../harness/jsonl-session-store.js";
+
+export const WS_SESSION_ROLLOUT_EVENT = "ws_session_state";
+const WS_SESSION_ROLLOUT_SCHEMA = "chainlesschain.ws-session-rollout/v1";
+
+function canonicalWsStateError(code, message) {
+  const error = new Error(message);
+  error.name = "CanonicalWsSessionStateError";
+  error.code = code;
+  return error;
+}
+
+function hydrateCanonicalWsSessionState(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    value.schema !== WS_SESSION_STATE_SCHEMA ||
+    value.version !== WS_SESSION_STATE_VERSION ||
+    !value.snapshot ||
+    typeof value.snapshot !== "object" ||
+    !Array.isArray(value.events)
+  ) {
+    throw canonicalWsStateError(
+      "CC_WS_CANONICAL_STATE_CORRUPT",
+      "canonical WebSocket session state has an invalid envelope",
+    );
+  }
+  const journal = hydrateWsSessionState(value);
+  if (journal.events.length !== value.events.length) {
+    throw canonicalWsStateError(
+      "CC_WS_CANONICAL_STATE_CORRUPT",
+      "canonical WebSocket session state contains a revision gap",
+    );
+  }
+  return journal;
+}
 
 function normalizeHostWorkspaceRoot(workspaceRoot) {
   if (
@@ -181,6 +223,11 @@ export class WSSessionManager {
     );
     this.defaultSystemPromptExtension =
       options.defaultSystemPromptExtension || null;
+    this.canonicalSessionStore = {
+      appendEvent: appendCanonicalSessionEvent,
+      findLatestEvent: findLatestCanonicalSessionEvent,
+      ...(options.canonicalSessionStore || {}),
+    };
 
     /** @type {Map<string, Session>} */
     this.sessions = new Map();
@@ -410,7 +457,15 @@ export class WSSessionManager {
         `max_sessions_exceeded: ${this.maxSessions} concurrent sessions reached — close some before creating more`,
       );
     }
-    const sessionId = this._generateId();
+    const sessionId = options.sessionId || this._generateId();
+    if (this.sessions.has(sessionId)) {
+      const error = new Error(`session already exists: ${sessionId}`);
+      error.code = "CC_WS_SESSION_EXISTS";
+      throw error;
+    }
+    const contextMemoryCutover = resolveCliContextMemoryCutover({
+      scopeKey: `cli:ws-session:${sessionId}`,
+    });
     const requireDurable = options.requireDurable === true;
     if (requireDurable && !this.db) {
       const error = new Error(
@@ -458,15 +513,17 @@ export class WSSessionManager {
     // Create context engine
     let contextEngine = null;
     let permanentMemory = null;
-    try {
-      const memoryDir = path.join(projectRoot, "memory");
-      permanentMemory = new CLIPermanentMemory({
-        db: this.db,
-        memoryDir,
-      });
-      permanentMemory.initialize();
-    } catch (_err) {
-      // Non-critical
+    if (!contextMemoryCutover.canonical) {
+      try {
+        const memoryDir = path.join(projectRoot, "memory");
+        permanentMemory = new CLIPermanentMemory({
+          db: this.db,
+          memoryDir,
+        });
+        permanentMemory.initialize();
+      } catch (_err) {
+        permanentMemory = null;
+      }
     }
 
     try {
@@ -687,33 +744,44 @@ export class WSSessionManager {
         metadata,
       );
       const planManager = this._hydratePlanManager(metadata.planSnapshot);
-      const sessionStateJournal = hydrateWsSessionState(
-        metadata.sessionState,
-        Object.prototype.hasOwnProperty.call(metadata, "planSnapshot")
-          ? {
-              // Legacy/current metadata migration is pass-through only.
-              // PlanModeManager remains the sole owner of Plan hydration and
-              // persistence.
-              planSnapshot: metadata.planSnapshot,
-            }
-          : {},
-      );
+      const canonicalSessionState =
+        metadata.canonicalJsonlSession === true
+          ? this._readCanonicalSessionState(dbSession.id, { required: true })
+          : null;
+      const sessionStateJournal = canonicalSessionState
+        ? hydrateCanonicalWsSessionState(canonicalSessionState)
+        : hydrateWsSessionState(
+            metadata.sessionState,
+            Object.prototype.hasOwnProperty.call(metadata, "planSnapshot")
+              ? {
+                  // Legacy/current metadata migration is pass-through only.
+                  // PlanModeManager remains the sole owner of Plan hydration and
+                  // persistence.
+                  planSnapshot: metadata.planSnapshot,
+                }
+              : {},
+          );
       const stateRecovery = recoverWsSessionState(sessionStateJournal, {
         reason: "process_restart",
       });
       const externalTools = this._buildSessionExternalTools();
+      const contextMemoryCutover = resolveCliContextMemoryCutover({
+        scopeKey: `cli:ws-session:${dbSession.id}`,
+      });
       let contextEngine = null;
       let permanentMemory = null;
 
-      try {
-        const memoryDir = path.join(workspace.projectRoot, "memory");
-        permanentMemory = new CLIPermanentMemory({
-          db: this.db,
-          memoryDir,
-        });
-        permanentMemory.initialize();
-      } catch (_err) {
-        // Non-critical
+      if (!contextMemoryCutover.canonical) {
+        try {
+          const memoryDir = path.join(workspace.projectRoot, "memory");
+          permanentMemory = new CLIPermanentMemory({
+            db: this.db,
+            memoryDir,
+          });
+          permanentMemory.initialize();
+        } catch (_err) {
+          permanentMemory = null;
+        }
       }
 
       try {
@@ -756,6 +824,9 @@ export class WSSessionManager {
         patchHistory: this._boundPatchHistory(metadata.patchHistory),
         taskGraph: this._hydrateTaskGraph(metadata.taskGraph),
         interaction: null,
+        canonicalJsonlSession:
+          canonicalSessionState != null ||
+          metadata.canonicalJsonlSession === true,
         createdAt: dbSession.created_at,
         lastActivity: new Date().toISOString(),
       };
@@ -779,6 +850,7 @@ export class WSSessionManager {
       this._bindPlanManagerPersistence(session);
       this.sessions.set(session.id, session);
       if (stateRecovery.changed) {
+        this._persistCanonicalSessionState(session, sessionStateJournal);
         this._persistSessionState(session.id);
       }
       return session;
@@ -787,6 +859,47 @@ export class WSSessionManager {
     }
   }
 
+  /** Build the local compatibility projection for a verified canonical-only session. */
+  resumeCanonicalSession(sessionId, options = {}) {
+    if (this.sessions.has(sessionId)) return this.resumeSession(sessionId);
+    // Read and validate any canonical WS journal before creating a DB/cache
+    // projection. An invalid journal must never be replaced by empty state.
+    const canonicalSessionState = this._readCanonicalSessionState(sessionId);
+    const canonicalJournal = canonicalSessionState
+      ? hydrateCanonicalWsSessionState(canonicalSessionState)
+      : null;
+    const stateRecovery = canonicalJournal
+      ? recoverWsSessionState(canonicalJournal, {
+          reason: "process_restart",
+        })
+      : { changed: false };
+    const created = this.createSession({
+      sessionId,
+      type: options.type || "agent",
+      provider: options.provider,
+      model: options.model,
+      baseUrl: options.baseUrl,
+      projectRoot: options.projectRoot,
+      requireDurable: false,
+    });
+    const session = this.sessions.get(created.sessionId) || null;
+    if (session && canonicalJournal) {
+      try {
+        session.canonicalJsonlSession = true;
+        this._bindSessionStateJournal(session, canonicalJournal);
+        if (stateRecovery.changed) {
+          this._persistCanonicalSessionState(session, canonicalJournal);
+        }
+        this._persistSessionState(session.id);
+      } catch (error) {
+        this.sessions.delete(session.id);
+        this._discardSessionResources(session);
+        throw error;
+      }
+    }
+    return session;
+  }
+
   /**
    * Close a session and persist final state.
    *
@@ -1641,6 +1754,7 @@ export class WSSessionManager {
       baseUrl: session.baseUrl || null,
       hostManagedToolPolicy: session.hostManagedToolPolicy || null,
       sessionBudgetRoot: session.sessionBudgetRoot || null,
+      canonicalJsonlSession: session.canonicalJsonlSession === true,
       enabledToolNames: session.enabledToolNames || [],
       canonicalHostSystemPrefix: Array.isArray(
         session._canonicalHostSystemPrefix,
@@ -1689,12 +1803,72 @@ export class WSSessionManager {
     return session._sessionStateJournal;
   }
 
+  _readCanonicalSessionState(sessionId, { required = false } = {}) {
+    const event = this.canonicalSessionStore.findLatestEvent(
+      sessionId,
+      WS_SESSION_ROLLOUT_EVENT,
+    );
+    if (!event) {
+      if (required) {
+        throw canonicalWsStateError(
+          "CC_WS_CANONICAL_STATE_MISSING",
+          `canonical WebSocket session state is missing: ${sessionId}`,
+        );
+      }
+      return null;
+    }
+    if (event.data?.schema !== WS_SESSION_ROLLOUT_SCHEMA) {
+      throw canonicalWsStateError(
+        "CC_WS_CANONICAL_STATE_CORRUPT",
+        `canonical WebSocket session state has an invalid schema: ${sessionId}`,
+      );
+    }
+    return event.data.journal;
+  }
+
+  _persistCanonicalSessionState(session, journal) {
+    if (session?.canonicalJsonlSession !== true) return null;
+    return this.canonicalSessionStore.appendEvent(
+      session.id,
+      WS_SESSION_ROLLOUT_EVENT,
+      {
+        schema: WS_SESSION_ROLLOUT_SCHEMA,
+        journal: serializeWsSessionState(journal),
+      },
+    );
+  }
+
+  markCanonicalSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    const previous = session.canonicalJsonlSession === true;
+    session.canonicalJsonlSession = true;
+    try {
+      this._persistCanonicalSessionState(
+        session,
+        this._ensureSessionStateJournal(session),
+      );
+      this._persistSessionState(sessionId);
+      return session;
+    } catch (error) {
+      session.canonicalJsonlSession = previous;
+      throw error;
+    }
+  }
+
   /** Record a recovery event and atomically persist it with session messages. */
   recordSessionStateEvent(sessionId, type, payload = {}) {
     const session = this.sessions.get(sessionId);
     if (!session) return null;
     const journal = this._ensureSessionStateJournal(session);
+    const before = serializeWsSessionState(journal);
     appendWsSessionStateEvent(journal, type, payload);
+    try {
+      this._persistCanonicalSessionState(session, journal);
+    } catch (error) {
+      this._bindSessionStateJournal(session, hydrateWsSessionState(before));
+      throw error;
+    }
     this._persistSessionState(sessionId);
     return getWsSessionStateSnapshot(journal);
   }