chainlesschain 0.166.10 → 0.166.14

package/src/lib/runtime-usage-ledger.js

@@ -1,5 +1,6 @@
 const MAX_LABEL_LENGTH = 160;
 const MAX_CALL_ID_LENGTH = 128;
+const MAX_OPERATION_ID_LENGTH = 160;
 const MAX_ATTRIBUTION_ID_LENGTH = 256;
 let fallbackToolSequence = 0;
 const USAGE_FIELDS = Object.freeze([
@@ -65,6 +66,21 @@ function callId(value, { required = false } = {}) {
   return value.trim();
 }
 
+function operationId(value) {
+  if (value === undefined) return null;
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value.length > MAX_OPERATION_ID_LENGTH ||
+    /\p{Cc}/u.test(value)
+  ) {
+    throw new TypeError(
+      "runtime usage boundary requires a bounded operation id",
+    );
+  }
+  return value.trim();
+}
+
 function projectAttribution(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const projected = {};
@@ -120,12 +136,14 @@ export function projectRuntimeTokenUsage(event = {}) {
     }
   }
   const projectedCallId = callId(event.callId);
+  const projectedOperationId = operationId(event.operationId);
   const attribution = projectAttribution(event.attribution);
   return {
     provider: cleanLabel(event.provider),
     model: cleanLabel(event.model),
     usage,
     ...(projectedCallId ? { callId: projectedCallId } : {}),
+    ...(projectedOperationId ? { operationId: projectedOperationId } : {}),
     ...(event.source ? { source: source(event.source) } : {}),
     ...(attribution ? { attribution } : {}),
   };
@@ -138,11 +156,13 @@ export function projectRuntimeUsageBoundary(event = {}, outcome) {
       "runtime usage boundary outcome must be started or unknown",
     );
   }
+  const projectedOperationId = operationId(event.operationId);
   const projected = {
     callId: callId(event.callId, { required: true }),
     provider: cleanLabel(event.provider),
     model: cleanLabel(event.model),
     source: source(event.source),
+    ...(projectedOperationId ? { operationId: projectedOperationId } : {}),
   };
   const attribution = projectAttribution(event.attribution);
   if (attribution) projected.attribution = attribution;

package/src/lib/session-consolidator.js

@@ -20,6 +20,8 @@ import {
 } from "@chainlesschain/session-core";
 import { readEvents, sessionExists } from "../harness/jsonl-session-store.js";
 import { getMemoryStore } from "./session-core-singletons.js";
+import { createCliCanonicalMemoryService } from "./context-memory-kernel/memory-service.js";
+import { resolveCliContextMemoryCutover } from "./context-memory-kernel/authority.js";
 
 /**
  * Build an in-memory TraceStore populated with events from a JSONL session.
@@ -108,6 +110,63 @@ export async function consolidateJsonlSession(sessionId, options = {}) {
   }
 
   const trace = buildTraceStoreFromJsonl(sessionId, options.events);
+  const decision = resolveCliContextMemoryCutover({
+    env: options.env,
+    scopeKey: `cli:session-consolidator:${sessionId}`,
+  });
+  if (decision.canonical) {
+    const traceEvents = trace.query(sessionId, {
+      limit: Number.MAX_SAFE_INTEGER,
+    });
+    const { defaultMemoryExtractor } = await import(
+      "@chainlesschain/session-core"
+    );
+    const facts = defaultMemoryExtractor(traceEvents);
+    const scope = options.scope || "agent";
+    const scopeId =
+      scope === "global"
+        ? null
+        : options.scopeId ||
+          (scope === "session" ? sessionId : options.agentId || sessionId);
+    if (options.dryRun) {
+      return {
+        sessionId,
+        scope,
+        scopeId,
+        eventCount: traceEvents.length,
+        factCount: facts.length,
+        writtenCount: 0,
+        written: [],
+        facts,
+        dryRun: true,
+      };
+    }
+    const service = createCliCanonicalMemoryService({ env: options.env });
+    const written = [];
+    for (const [index, fact] of facts.entries()) {
+      written.push(
+        await service.addScoped(String(fact.content || ""), {
+          scope,
+          scopeId,
+          category: fact.category || "general",
+          tags: fact.tags || [],
+          score: fact.score,
+          source: "cli-session-consolidator",
+          evidenceStore: "cli-jsonl-session",
+          evidenceId: `${sessionId}-${index}`,
+        }),
+      );
+    }
+    return {
+      sessionId,
+      scope,
+      scopeId,
+      eventCount: traceEvents.length,
+      factCount: facts.length,
+      writtenCount: written.length,
+      written,
+    };
+  }
   const memoryStore = options.memoryStore || getMemoryStore();
   const consolidator = new MemoryConsolidator({
     memoryStore,

package/src/lib/session-core-singletons.js

@@ -10,6 +10,10 @@
 import { join } from "node:path";
 import { promises as fsp, existsSync, mkdirSync } from "node:fs";
 import { getHomeDir } from "./paths.js";
+import {
+  assertLegacyMutationAllowed,
+  resolveCliContextMemoryCutover,
+} from "./context-memory-kernel/authority.js";
 import {
   ensureTrustedSessionLifecycleScope,
   resolveTrustedSessionLifecycleScope,
@@ -50,7 +54,15 @@ export function getApprovalPoliciesPath() {
 export function getMemoryStore() {
   if (_memoryStore) return _memoryStore;
   const adapter = createMemoryFileAdapter(getMemoryStorePath());
-  _memoryStore = new MemoryStore({ adapter });
+  _memoryStore = new MemoryStore({
+    adapter,
+    writeGuard: () =>
+      assertLegacyMutationAllowed(
+        resolveCliContextMemoryCutover({
+          scopeKey: "cli:legacy-session-core-memory",
+        }),
+      ),
+  });
   hydrateMemoryStore(_memoryStore, adapter);
   return _memoryStore;
 }
@@ -66,12 +78,13 @@ export async function getBetaFlags() {
 export async function getApprovalGate() {
   if (_approvalGate) return _approvalGate;
   const store = createApprovalGateFileAdapter(getApprovalPoliciesPath());
-  _approvalGate = new ApprovalGate({
+  const gate = new ApprovalGate({
     defaultPolicy: APPROVAL_POLICY.STRICT,
     store,
   });
-  await _approvalGate.load();
-  return _approvalGate;
+  await gate.load();
+  _approvalGate = gate;
+  return gate;
 }
 
 export function getParkedSessionsPath(options = {}) {

package/src/lib/session-hooks.js

@@ -9,7 +9,34 @@
  * - Notification
  */
 
-import { HookEvents, executeHooks } from "./hook-manager.js";
+import { HookEvents } from "./hook-manager.js";
+import { executeHooksV2Event } from "./hooks-v2-producers.js";
+
+async function executeCanonicalDatabaseHooks(db, event, context) {
+  const outcome = await executeHooksV2Event(event, context, { hookDb: db });
+  return (outcome.results || [])
+    .filter(
+      (entry) =>
+        !String(entry?.hookId || "").startsWith(
+          "database:adapter-read-failure:",
+        ),
+    )
+    .map((entry) => ({
+      hookId: entry.hookId,
+      hookName: entry.hookName || entry.hookId,
+      success: entry.status === "success",
+      result: entry.result,
+      stdout:
+        typeof entry.result === "string"
+          ? entry.result
+          : entry.result?.raw ||
+            (entry.result && typeof entry.result === "object"
+              ? JSON.stringify(entry.result)
+              : null),
+      error: entry.error || null,
+      executionTime: entry.durationMs || 0,
+    }));
+}
 
 // 会话钩子白名单
 export const SESSION_HOOK_EVENTS = Object.freeze([
@@ -22,7 +49,7 @@ export const SESSION_HOOK_EVENTS = Object.freeze([
 
 // 依赖注入点（用于测试）
 export const _deps = {
-  executeHooks,
+  executeHooks: executeCanonicalDatabaseHooks,
   logFailure: (_db, event, error) => {
     console.error(`[session-hooks] Failed to fire ${event}:`, error);
   },

package/src/lib/session-transcript-migration.js

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+
+import {
+  appendEvent,
+  findLatestEvent,
+  listSessionAuthoritySummaries,
+  readVerifiedMessages,
+  sessionHasPersistedEvidence,
+  startSession,
+} from "../harness/jsonl-session-store.js";
+import {
+  getSession as getDatabaseSession,
+  listSessions as listDatabaseSessions,
+} from "./session-manager.js";
+import { sanitizePersistedMessages } from "./session-message-provenance.js";
+
+export const SESSION_STORE_MIGRATION_EVENT = "session_store_migrated";
+export const SESSION_STORE_MIGRATION_SCHEMA =
+  "chainlesschain.session-store-migration/v1";
+
+function migrationError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "SessionTranscriptMigrationError";
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+}
+
+function timestampEpoch(value) {
+  if (typeof value !== "string" || !value) return 0;
+  const normalized =
+    value.includes(" ") && !value.includes("T")
+      ? `${value.replace(" ", "T")}Z`
+      : value;
+  const parsed = Date.parse(normalized);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function canonicalMessages(messages, { stripLeadingSystem = true } = {}) {
+  const sanitized = sanitizePersistedMessages(messages || [], { strict: true });
+  let start = 0;
+  // Legacy WS sessions own exactly the first system message as their host
+  // prompt. Later leading system messages can be recovery notices or compacted
+  // summaries and therefore remain logical transcript content.
+  if (stripLeadingSystem && sanitized[0]?.role === "system") start = 1;
+  return sanitized.slice(start);
+}
+
+function messagesDigest(messages) {
+  return `sha256:${createHash("sha256")
+    .update(JSON.stringify(messages))
+    .digest("hex")}`;
+}
+
+/**
+ * Import a legacy physical session snapshot into the verified canonical
+ * transcript. The two-event sequence is restartable: a crash after
+ * session_start leaves an empty verified prefix which a retry can complete.
+ */
+export function ensureCanonicalSessionTranscript(
+  {
+    sessionId,
+    title = "Untitled",
+    provider = "",
+    model = "",
+    messages = [],
+    source = "legacy",
+    stripLeadingSystem = true,
+  },
+  dependencies = {},
+) {
+  const deps = {
+    appendEvent,
+    findLatestEvent,
+    readVerifiedMessages,
+    sessionHasPersistedEvidence,
+    startSession,
+    ...dependencies,
+  };
+  const id = String(sessionId || "").trim();
+  if (!id) {
+    throw migrationError(
+      "CC_SESSION_MIGRATION_INVALID",
+      "sessionId is required for transcript migration",
+    );
+  }
+  const importedMessages = canonicalMessages(messages, { stripLeadingSystem });
+  const digest = messagesDigest(importedMessages);
+
+  const existed = deps.sessionHasPersistedEvidence(id);
+  if (!existed) {
+    deps.startSession(id, { title, provider, model });
+  }
+
+  const completed = deps.findLatestEvent(id, SESSION_STORE_MIGRATION_EVENT);
+  if (completed) {
+    if (
+      completed.data?.source !== source ||
+      completed.data?.messagesDigest !== digest
+    ) {
+      throw migrationError(
+        "CC_SESSION_MIGRATION_CONFLICT",
+        `session ${id} was already imported from different content`,
+        { sessionId: id },
+      );
+    }
+    return Object.freeze({
+      sessionId: id,
+      migrated: false,
+      messages: deps.readVerifiedMessages(id),
+      source,
+      messagesDigest: digest,
+    });
+  }
+
+  const currentMessages = deps.readVerifiedMessages(id);
+  if (currentMessages.length > 0) {
+    if (messagesDigest(currentMessages) !== digest) {
+      throw migrationError(
+        "CC_SESSION_MIGRATION_CONFLICT",
+        `canonical transcript already contains different messages: ${id}`,
+        { sessionId: id },
+      );
+    }
+  } else if (importedMessages.length > 0) {
+    deps.appendEvent(id, "compact", {
+      messages: importedMessages,
+      originalMessages: importedMessages.length,
+      compressedMessages: importedMessages.length,
+      reason: "physical-store-import",
+    });
+  }
+
+  deps.appendEvent(id, SESSION_STORE_MIGRATION_EVENT, {
+    schema: SESSION_STORE_MIGRATION_SCHEMA,
+    source,
+    messagesDigest: digest,
+    messageCount: importedMessages.length,
+  });
+  return Object.freeze({
+    sessionId: id,
+    migrated: true,
+    messages: deps.readVerifiedMessages(id),
+    source,
+    messagesDigest: digest,
+  });
+}
+
+export function ensureCanonicalSessionFromDatabase(
+  database,
+  sessionId,
+  dependencies = {},
+) {
+  if (!database) return null;
+  const readDatabaseSession =
+    dependencies.getDatabaseSession || getDatabaseSession;
+  const session = readDatabaseSession(database, sessionId);
+  if (!session) return null;
+  return ensureCanonicalSessionTranscript(
+    {
+      sessionId: session.id,
+      title: session.title || "Untitled",
+      provider: session.provider || "",
+      model: session.model || "",
+      messages: session.messages || [],
+      source: "sqlite:llm_sessions",
+      stripLeadingSystem: true,
+    },
+    dependencies,
+  );
+}
+
+/** Resolve the newest readable logical session across JSONL and legacy DB. */
+export function getLastLogicalSessionId(database = null, dependencies = {}) {
+  const listCanonical =
+    dependencies.listSessionAuthoritySummaries || listSessionAuthoritySummaries;
+  const listLegacy = dependencies.listDatabaseSessions || listDatabaseSessions;
+  const canonical = listCanonical({ limit: 1 }).find(
+    (session) => session?._blocked !== true,
+  );
+  const legacy = database ? listLegacy(database, { limit: 1 })[0] : null;
+  if (!canonical) return legacy?.id || null;
+  if (!legacy || canonical.id === legacy.id) return canonical.id;
+  return timestampEpoch(legacy.updated_at) >
+    timestampEpoch(canonical.updated_at)
+    ? legacy.id
+    : canonical.id;
+}