chainlesschain 0.166.99 → 0.166.101

package/src/lib/context-memory-kernel/live-compaction.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import {
   canonicalDigest,
   InMemorySessionContextPort,
+  getCompactionPlanRejection,
 } from "@chainlesschain/context-memory-kernel";
 import { sessionExists } from "../../harness/jsonl-session-store.js";
 import {
@@ -11,6 +12,17 @@ import {
 } from "./message-adapter.js";
 import { JsonlSessionContextPort } from "./jsonl-session-context-port.js";
 import { createCliContextMemoryRuntime } from "./runtime.js";
+import { projectRuntimeTokenUsage } from "../runtime-usage-ledger.js";
+
+const rejectedCompactionUsage = new WeakMap();
+
+// Only the owned canonical adapter can associate an error with its completed
+// summarizer. A caller-supplied error property is never a settlement authority.
+export function getRejectedCompactionUsage(error) {
+  return error && typeof error === "object"
+    ? rejectedCompactionUsage.get(error) || null
+    : null;
+}
 
 function estimatedTokens(messages) {
   return Math.max(
@@ -20,7 +32,9 @@ function estimatedTokens(messages) {
         typeof message?.content === "string"
           ? message.content
           : JSON.stringify(message?.content ?? "");
-      return total + Math.max(1, Math.ceil(Buffer.byteLength(content, "utf8") / 4));
+      return (
+        total + Math.max(1, Math.ceil(Buffer.byteLength(content, "utf8") / 4))
+      );
     }, 0),
   );
 }
@@ -125,13 +139,22 @@ class CallbackSessionContextPort extends InMemorySessionContextPort {
 }
 
 function kernelBudget(compressor) {
-  const inputBudget = Math.max(256, Math.trunc(Number(compressor?.maxTokens)) || 16_384);
-  const reservedOutputTokens = Math.max(1, Math.min(2048, Math.floor(inputBudget / 10)));
+  const inputBudget = Math.max(
+    256,
+    Math.trunc(Number(compressor?.maxTokens)) || 16_384,
+  );
+  const reservedOutputTokens = Math.max(
+    1,
+    Math.min(2048, Math.floor(inputBudget / 10)),
+  );
   return {
     modelWindowTokens: inputBudget + reservedOutputTokens,
     reservedOutputTokens,
     safetyMarginTokens: 0,
-    recoveryReserveTokens: Math.min(256, Math.max(1, Math.floor(inputBudget * 0.05))),
+    recoveryReserveTokens: Math.min(
+      256,
+      Math.max(1, Math.floor(inputBudget * 0.05)),
+    ),
   };
 }
 
@@ -175,7 +198,10 @@ function usageReceipt(stats, provider, model) {
  * summarizer for the Kernel-selected dropped partition; it cannot commit or
  * choose the authoritative output on its own.
  */
-export async function compactLiveMessagesCanonical(messagesInput, options = {}) {
+export async function compactLiveMessagesCanonical(
+  messagesInput,
+  options = {},
+) {
   const messages = Array.isArray(messagesInput) ? [...messagesInput] : [];
   const sessionId = String(options.sessionId || `live-${randomUUID()}`);
   const operationId = String(options.operationId || `compact-${randomUUID()}`);
@@ -185,10 +211,13 @@ export async function compactLiveMessagesCanonical(messagesInput, options = {})
     new Date(Number((options.clock || Date.now)())).toISOString();
   const compressor = options.compressor;
   if (!compressor || typeof compressor.compress !== "function") {
-    throw new TypeError("canonical live compaction requires a compatibility summarizer");
+    throw new TypeError(
+      "canonical live compaction requires a compatibility summarizer",
+    );
   }
 
   let summaryStats = null;
+  let summaryReceipt = null;
   let runtime;
   let verifiedAuthoritySnapshot = null;
   const persistentSession =
@@ -227,9 +256,7 @@ export async function compactLiveMessagesCanonical(messagesInput, options = {})
       memoryPort: bootstrapRuntime.memoryPort,
       sessionPort,
     });
-  } else if (
-    persistentSession
-  ) {
+  } else if (persistentSession) {
     runtime = createCliContextMemoryRuntime({
       sessionId,
       scopeKey: `cli:session:${sessionId}`,
@@ -265,13 +292,13 @@ export async function compactLiveMessagesCanonical(messagesInput, options = {})
     });
   }
   if (!runtime.decision.canonical) {
-    const error = new Error("canonical live compaction is not authoritative for this cohort");
+    const error = new Error(
+      "canonical live compaction is not authoritative for this cohort",
+    );
     error.code = "legacy_writer_fenced";
     throw error;
   }
-  if (
-    persistentSession
-  ) {
+  if (persistentSession) {
     const authority =
       verifiedAuthoritySnapshot ||
       (await runtime.sessionPort.readSnapshot(sessionId));
@@ -296,52 +323,102 @@ export async function compactLiveMessagesCanonical(messagesInput, options = {})
   const provider = options.provider || "provider.local";
   const model = options.model || "default";
   const memoryRevision = await runtime.memoryPort.getRevision();
-  const receipt = await runtime.kernel.compactContext({
-    operationId,
-    sessionId,
-    ...kernelBudget(compressor),
-    sink: provider,
-    scopeAdmissions: [{ scope: "session", scopeId: sessionId }],
-    policyVersion: "cli-context-policy-v1",
-    modelProfile: model,
-    memoryRevision,
-    allowFallback: false,
-    now: operationNow,
-    metadata: {
-      inputMessageCount: messages.length,
-      originalTokens: estimatedTokens(messages),
-      trigger,
-      provider,
-      model,
-    },
-    summarizer: async (droppedItems, context) => {
-      const droppedMessages = contextItemsToMessages(droppedItems);
-      const result = await compressor.compress(droppedMessages, {
-        preserveToolPairs: true,
-        ...(options.compressOptions || {}),
-      });
-      summaryStats = result.stats || {};
-      const reduced =
-        Number(summaryStats.saved || 0) > 0 ||
-        result.messages.length < droppedMessages.length;
-      const item = reduced
-        ? createSummaryContextItem({
-            messages: result.messages,
-            parents: droppedItems,
-            operationId: context.operationId,
-            now: operationNow,
-          })
-        : null;
-      return {
-        items: item ? [item] : [],
-        usageReceipt: usageReceipt(summaryStats, provider, model),
-        degraded: summaryStats.degraded === true,
-        ...(summaryStats.degradedReason
-          ? { degradedReason: String(summaryStats.degradedReason).slice(0, 160) }
-          : {}),
-      };
-    },
-  });
+  let receipt;
+  try {
+    receipt = await runtime.kernel.compactContext({
+      operationId,
+      sessionId,
+      ...kernelBudget(compressor),
+      sink: provider,
+      scopeAdmissions: [{ scope: "session", scopeId: sessionId }],
+      policyVersion: "cli-context-policy-v1",
+      modelProfile: model,
+      memoryRevision,
+      allowFallback: false,
+      now: operationNow,
+      metadata: {
+        inputMessageCount: messages.length,
+        originalTokens: estimatedTokens(messages),
+        trigger,
+        provider,
+        model,
+      },
+      summarizer: async (droppedItems, context) => {
+        const droppedMessages = contextItemsToMessages(droppedItems);
+        const result = await compressor.compress(droppedMessages, {
+          preserveToolPairs: true,
+          ...(options.compressOptions || {}),
+        });
+        summaryStats = result.stats || {};
+        summaryReceipt = usageReceipt(summaryStats, provider, model);
+        const reduced =
+          Number(summaryStats.saved || 0) > 0 ||
+          result.messages.length < droppedMessages.length;
+        const item = reduced
+          ? createSummaryContextItem({
+              messages: result.messages,
+              parents: droppedItems,
+              operationId: context.operationId,
+              now: operationNow,
+            })
+          : null;
+        return {
+          items: item ? [item] : [],
+          usageReceipt: summaryReceipt,
+          degraded: summaryStats.degraded === true,
+          ...(summaryStats.degradedReason
+            ? {
+                degradedReason: String(summaryStats.degradedReason).slice(
+                  0,
+                  160,
+                ),
+              }
+            : {}),
+        };
+      },
+    });
+  } catch (error) {
+    const rejection = getCompactionPlanRejection(error);
+    if (
+      rejection?.operationId === operationId &&
+      rejection.sessionId === sessionId &&
+      summaryReceipt !== null &&
+      rejection.usageReceipt &&
+      canonicalDigest(rejection.usageReceipt) ===
+        canonicalDigest(summaryReceipt) &&
+      summaryStats?.summaryUsageUnknown !== true
+    ) {
+      try {
+        const usage = projectRuntimeTokenUsage({
+          ...(summaryStats.summaryCallId
+            ? { callId: summaryStats.summaryCallId }
+            : {}),
+          provider: summaryStats.summaryProvider || provider,
+          model: summaryStats.summaryModel || model,
+          source: "semantic-compaction",
+          usage: {
+            input_tokens: summaryStats.summaryUsage?.inputTokens,
+            output_tokens: summaryStats.summaryUsage?.outputTokens,
+            cache_read_input_tokens:
+              summaryStats.summaryUsage?.cacheReadTokens ?? 0,
+            cache_creation_input_tokens:
+              summaryStats.summaryUsage?.cacheCreationTokens ?? 0,
+          },
+        });
+        rejectedCompactionUsage.set(
+          error,
+          Object.freeze({
+            ...usage,
+            usage: Object.freeze(usage.usage),
+            receipt: Object.freeze({ ...summaryReceipt }),
+          }),
+        );
+      } catch {
+        // Missing or invalid usage retains the caller's unknown outcome path.
+      }
+    }
+    throw error;
+  }
   if (!["committed", "degraded"].includes(receipt.status)) {
     return {
       messages,
@@ -361,12 +438,16 @@ export async function compactLiveMessagesCanonical(messagesInput, options = {})
     messages: outputMessages,
     stats: {
       ...(summaryStats || {}),
-      strategy: receipt.status === "degraded" ? "deterministic-fallback" : "canonical",
+      strategy:
+        receipt.status === "degraded" ? "deterministic-fallback" : "canonical",
       originalMessages: messages.length,
       compressedMessages: outputMessages.length,
       originalTokens: estimatedTokens(messages),
       compressedTokens: estimatedTokens(outputMessages),
-      saved: Math.max(0, estimatedTokens(messages) - estimatedTokens(outputMessages)),
+      saved: Math.max(
+        0,
+        estimatedTokens(messages) - estimatedTokens(outputMessages),
+      ),
       canonicalAlreadySettled: true,
       canonicalReceipt: receipt,
     },

package/src/lib/eval/verify01-execution-window.js

@@ -0,0 +1,70 @@
+function windowError(code, message) {
+  return Object.assign(new Error(`VERIFY-01 ${message}`), { code });
+}
+
+function timestamp(value) {
+  if (typeof value !== "string") return NaN;
+  // Frozen windows need an explicit timezone, valid calendar date, and at
+  // most millisecond precision. Date.parse alone normalizes February 30 and
+  // accepts local-time/numeric strings that are not suitable for admission.
+  const match =
+    /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{1,3}))?(Z|[+-]\d{2}:\d{2})$/u.exec(
+      value,
+    );
+  if (!match) return NaN;
+  const localUtc = `${match[1]}.${(match[2] || "").padEnd(3, "0")}Z`;
+  const localTime = Date.parse(localUtc);
+  if (
+    !Number.isFinite(localTime) ||
+    new Date(localTime).toISOString() !== localUtc
+  )
+    return NaN;
+  return Date.parse(value);
+}
+
+/**
+ * Admission immediately before a formal task starts or launches its agent.
+ * This pure guard neither executes a task nor records an observation. It does
+ * not establish human approval, account funding, or a provider spend limit.
+ * Call with the full frozen task budget at task start; recheck with the
+ * remaining required time at dispatch if preparation can span a window edge.
+ */
+export function assertVerify01ExecutionWindow(
+  plan,
+  { now = Date.now(), requiredTimeMs = 0 } = {},
+) {
+  const start = timestamp(plan?.window?.start);
+  const end = timestamp(plan?.window?.end);
+  if (
+    !Number.isFinite(start) ||
+    !Number.isFinite(end) ||
+    start >= end ||
+    !Number.isFinite(now) ||
+    !Number.isFinite(requiredTimeMs) ||
+    requiredTimeMs < 0
+  ) {
+    throw windowError(
+      "CC_VERIFY01_WINDOW_INVALID",
+      "execution window, current time, and required task duration must be valid",
+    );
+  }
+  if (now < start) {
+    throw windowError(
+      "CC_VERIFY01_WINDOW_NOT_STARTED",
+      "execution window has not started; no task may be launched",
+    );
+  }
+  if (now >= end) {
+    throw windowError(
+      "CC_VERIFY01_WINDOW_EXPIRED",
+      "execution window has expired; no task may be launched",
+    );
+  }
+  if (requiredTimeMs > end - now) {
+    throw windowError(
+      "CC_VERIFY01_WINDOW_INSUFFICIENT_TIME",
+      "execution window cannot fit the required task time budget",
+    );
+  }
+  return { startedAt: now, windowEndMs: end };
+}

package/src/lib/eval/verify01-execution.js

@@ -15,6 +15,7 @@ import { createHash } from "node:crypto";
 import executionBroker from "../process-execution-broker/index.js";
 import { evalDigest, createEvalComparison } from "./evidence.js";
 import { outcomeDigest } from "./outcomes.js";
+import { assertVerify01ExecutionWindow } from "./verify01-execution-window.js";
 import {
   readBytes,
   readJson,
@@ -30,7 +31,8 @@ export const VERIFY01_SUITES = [
 const agentBindings = new WeakSet();
 const EMPTY_DELIVERABLE_DIGEST = evalDigest(Buffer.alloc(0));
 
-function createAgentBinding(directory, allowedPaths, provider, model) {
+function createAgentBinding(directory, allowedPaths, provider, model, window) {
+  assertVerify01ExecutionWindow({ window });
   const workspace = canonicalDirectory(directory);
   for (const relative of allowedPaths) {
     const file = regularPath(workspace, relative);
@@ -72,6 +74,7 @@ function createAgentBinding(directory, allowedPaths, provider, model) {
     root,
     provider,
     model,
+    executionWindow: Object.freeze({ ...window }),
     allowedPaths: Object.freeze([...allowedPaths]),
     environment,
   });
@@ -86,6 +89,7 @@ export function captureVerify01AgentBinding(binding, directory) {
     agentBindings.has(binding),
     "unrecognized VERIFY01 agent binding",
   );
+  assertVerify01ExecutionWindow({ window: binding.executionWindow });
   requireValue(
     canonicalDirectory(directory) === binding.workspace,
     "VERIFY01 agent binding belongs to another workspace",
@@ -420,6 +424,9 @@ export function loadVerify01Suite(options = {}) {
       costBudgetUsd: sample.costBudget,
       expectedFiles: [...reviewed.allowedChangedPaths],
       async setup(directory, budget) {
+        receipt.windowAdmission = assertVerify01ExecutionWindow(bundle.plan, {
+          requiredTimeMs: sample.timeBudgetMs,
+        });
         receipt.workspace = directory;
         receipt.checkout = await materializeCheckout(
           projectRoot,
@@ -450,6 +457,7 @@ export function loadVerify01Suite(options = {}) {
           reviewed.allowedChangedPaths,
           options.provider,
           options.model,
+          bundle.plan.window,
         );
         receipt.agentBinding = {
           workspace: agentBinding.workspace,

package/src/lib/eval/verify01-host-capture.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { evalDigest } from "./evidence.js";
 import { outcomeDigest } from "./outcomes.js";
+import { assertVerify01ExecutionWindow } from "./verify01-execution-window.js";
 import {
   requireValue,
   relativeFile,
@@ -202,8 +203,11 @@ export async function prepareVerify01HostTask(bundle, preparation, options) {
     !fs.existsSync(workspace) && !fs.existsSync(root),
     "workspace and capture directory must be new; retry cannot overwrite an attempt",
   );
-  const startedAt = new Date().toISOString(),
-    deadline = Date.now() + sample.timeBudgetMs;
+  const windowAdmission = assertVerify01ExecutionWindow(bundle.plan, {
+    requiredTimeMs: sample.timeBudgetMs,
+  });
+  const startedAt = new Date(windowAdmission.startedAt).toISOString(),
+    deadline = windowAdmission.startedAt + sample.timeBudgetMs;
   fs.mkdirSync(workspace, { recursive: true, mode: 0o700 });
   fs.mkdirSync(root, { recursive: true, mode: 0o700 });
   const stageBudget = budget(deadline);