chainlesschain 0.162.197 → 0.162.200

package/src/lib/session-search.js

@@ -11,7 +11,7 @@
  */
 
 import {
-  readEvents,
+  readVerifiedEvents,
   listJsonlSessions,
 } from "../harness/jsonl-session-store.js";
 
@@ -54,7 +54,7 @@ export class SessionSearchIndex {
    * @returns {Array<{role: string, content: string, timestamp: number}>}
    */
   extractMessages(sessionId) {
-    const events = readEvents(sessionId);
+    const events = readVerifiedEvents(sessionId);
     const messages = [];
 
     for (const event of events) {
@@ -86,13 +86,22 @@ export class SessionSearchIndex {
     if (!this._db) return { indexed: 0 };
     if (!this._initialized) this.ensureTables();
 
-    const messages = this.extractMessages(sessionId);
-    if (messages.length === 0) return { indexed: 0 };
+    const deleteExisting = () =>
+      this._db.exec(
+        `DELETE FROM session_fts WHERE session_id = '${sessionId.replace(/'/g, "''")}'`,
+      );
+    let messages;
+    try {
+      messages = this.extractMessages(sessionId);
+    } catch (error) {
+      deleteExisting();
+      throw error;
+    }
 
-    // Remove existing entries for this session (idempotent re-index)
-    this._db.exec(
-      `DELETE FROM session_fts WHERE session_id = '${sessionId.replace(/'/g, "''")}'`,
-    );
+    // Remove existing entries before publishing the newly verified sample.
+    // Empty and damaged sessions must not leave older searchable content.
+    deleteExisting();
+    if (messages.length === 0) return { indexed: 0 };
 
     const insert = this._db.prepare(
       `INSERT INTO session_fts (session_id, role, content, timestamp) VALUES (?, ?, ?, ?)`,
@@ -164,13 +173,18 @@ export class SessionSearchIndex {
 
     const sessions = listJsonlSessions({ limit: 10000 });
     let totalMessages = 0;
+    let rejected = 0;
 
     for (const session of sessions) {
-      const result = this.indexSession(session.id);
-      totalMessages += result.indexed;
+      try {
+        const result = this.indexSession(session.id);
+        totalMessages += result.indexed;
+      } catch {
+        rejected += 1;
+      }
     }
 
-    return { sessions: sessions.length, messages: totalMessages };
+    return { sessions: sessions.length, messages: totalMessages, rejected };
   }
 
   /**

package/src/lib/session-tail.js

@@ -10,7 +10,31 @@
 
 import { promises as fsp } from "node:fs";
 import { existsSync, statSync } from "node:fs";
-import { sessionPath } from "../harness/jsonl-session-store.js";
+import {
+  getSessionPresence,
+  SESSION_PRESENCE,
+  sessionPath,
+} from "../harness/jsonl-session-store.js";
+
+function assertLiveTranscriptReadable(sessionId) {
+  const presence = getSessionPresence(sessionId);
+  if (
+    presence === SESSION_PRESENCE.PRESENT ||
+    presence === SESSION_PRESENCE.ABSENT
+  ) {
+    return;
+  }
+  const error = new Error(
+    presence === SESSION_PRESENCE.TOMBSTONED
+      ? `Session ${sessionId} has been deleted`
+      : `Session ${sessionId} transcript cannot be verified for live tailing`,
+  );
+  error.code =
+    presence === SESSION_PRESENCE.TOMBSTONED
+      ? "SESSION_DELETED"
+      : "SESSION_TRANSCRIPT_UNVERIFIED";
+  throw error;
+}
 
 function parseLine(line) {
   const trimmed = line.trim();
@@ -53,6 +77,7 @@ function matchesFilter(event, { types, sinceMs }) {
  *   - fromEnd (default): current EOF, so only new events are yielded
  */
 export function initialOffset(sessionId, { fromStart = false } = {}) {
+  assertLiveTranscriptReadable(sessionId);
   const p = sessionPath(sessionId);
   if (!existsSync(p)) return 0;
   if (fromStart) return 0;
@@ -98,6 +123,11 @@ export async function* followSession(sessionId, options = {}) {
   while (true) {
     if (signal?.aborted) return;
 
+    // A long-lived tail is a live canonical reader. Re-check the durable
+    // sidecar witness on every poll so external deletion or a tombstoned path
+    // restoration cannot silently turn into empty output or stale replay.
+    assertLiveTranscriptReadable(sessionId);
+
     if (existsSync(filePath)) {
       const stat = await fsp.stat(filePath);
       if (stat.size < offset) {

package/src/lib/side-effect-ledger-store.js

@@ -10,7 +10,7 @@
  */
 
 import {
-  appendEvent as storeAppendEvent,
+  appendAuthorityEvent as storeAppendAuthorityEvent,
   readEvents as storeReadEvents,
   findLatestEvent as storeFindLatestEvent,
 } from "../harness/jsonl-session-store.js";
@@ -23,7 +23,7 @@ import {
 export const SIDE_EFFECT_LEDGER_EVENT = "side_effect_ledger";
 
 export const _deps = {
-  appendEvent: storeAppendEvent,
+  appendEvent: storeAppendAuthorityEvent,
   readEvents: storeReadEvents,
   findLatestEvent: storeFindLatestEvent,
 };

package/src/lib/skill-budget.js

@@ -0,0 +1,222 @@
+/**
+ * Host-owned admission limits for file-backed CLI skills.
+ *
+ * These are security ceilings, not defaults that callers may raise. Loader
+ * options can only tighten them through resolveSkillLimits().
+ */
+export const HOST_SKILL_LIMITS = Object.freeze({
+  maxSkillFileBytes: 256 * 1024,
+  maxSkillTotalBytes: 512 * 1024,
+  maxSkillDiscoveryEntries: 16_384,
+  maxSkillDiscoveryFiles: 4096,
+  maxSkillDiscoveryBytes: 64 * 1024 * 1024,
+  maxSkillNestDepth: 5,
+  maxSkillPromptBytes: 48_000,
+  // Provider-neutral conservative ceiling: one token cannot require fewer
+  // than zero bytes, and byte-level tokenizers cannot produce more tokens than
+  // the UTF-8 byte sequence. Hosts with a smaller context may tighten this.
+  maxSkillPromptTokens: 48_000,
+  maxSkillPromptTotalBytes: 192_000,
+  maxSkillPromptTotalTokens: 192_000,
+});
+
+const LIMIT_KEYS = Object.freeze(Object.keys(HOST_SKILL_LIMITS));
+
+function tighteningLimit(value, hardLimit) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return hardLimit;
+  }
+  return Math.min(hardLimit, Math.max(1, Math.floor(value)));
+}
+
+export function resolveSkillLimits(options = {}) {
+  const limits = {};
+  for (const key of LIMIT_KEYS) {
+    limits[key] = tighteningLimit(options?.[key], HOST_SKILL_LIMITS[key]);
+  }
+  return Object.freeze(limits);
+}
+
+export function skillBudgetError(code, message, details = {}) {
+  const error = new Error(message);
+  error.name = "SkillBudgetError";
+  error.code = code;
+  if (Number.isFinite(details.limit)) error.limit = details.limit;
+  if (Number.isFinite(details.actual)) error.actual = details.actual;
+  if (details.component) error.component = details.component;
+  return error;
+}
+
+export function isSkillBudgetError(error) {
+  return error?.name === "SkillBudgetError";
+}
+
+export function assertSkillFileSize(component, size, limitsInput = {}) {
+  const limits = resolveSkillLimits(limitsInput);
+  if (!Number.isSafeInteger(size) || size < 0) {
+    throw skillBudgetError(
+      "CC_SKILL_FILE_SIZE_INVALID",
+      `Skill component size is invalid: ${component}`,
+      { component },
+    );
+  }
+  if (size > limits.maxSkillFileBytes) {
+    throw skillBudgetError(
+      "CC_SKILL_FILE_TOO_LARGE",
+      `Skill component exceeds the host byte limit: ${component}`,
+      { component, limit: limits.maxSkillFileBytes, actual: size },
+    );
+  }
+  return size;
+}
+
+export function assertSkillTotalSize(size, limitsInput = {}) {
+  const limits = resolveSkillLimits(limitsInput);
+  if (!Number.isSafeInteger(size) || size < 0) {
+    throw skillBudgetError(
+      "CC_SKILL_TOTAL_SIZE_INVALID",
+      "Skill component total is invalid.",
+    );
+  }
+  if (size > limits.maxSkillTotalBytes) {
+    throw skillBudgetError(
+      "CC_SKILL_TOTAL_BYTES_EXCEEDED",
+      "Skill components exceed the host aggregate byte limit.",
+      { limit: limits.maxSkillTotalBytes, actual: size },
+    );
+  }
+  return size;
+}
+
+export function createSkillDiscoveryBudget(limitsInput = {}) {
+  return {
+    limits: resolveSkillLimits(limitsInput),
+    entries: 0,
+    files: 0,
+    bytes: 0,
+  };
+}
+
+export function debitSkillDiscoveryEntry(budget) {
+  const nextEntries = budget.entries + 1;
+  if (
+    !Number.isSafeInteger(nextEntries) ||
+    nextEntries > budget.limits.maxSkillDiscoveryEntries
+  ) {
+    throw skillBudgetError(
+      "CC_SKILL_DISCOVERY_ENTRIES_EXCEEDED",
+      "Recursive skill discovery exceeds the host directory-entry limit.",
+      {
+        limit: budget.limits.maxSkillDiscoveryEntries,
+        actual: nextEntries,
+      },
+    );
+  }
+  budget.entries = nextEntries;
+  return budget;
+}
+
+export function debitSkillDiscoveryBudget(budget, fileCount, byteCount) {
+  const nextFiles = budget.files + fileCount;
+  const nextBytes = budget.bytes + byteCount;
+  if (
+    !Number.isSafeInteger(nextFiles) ||
+    nextFiles > budget.limits.maxSkillDiscoveryFiles
+  ) {
+    throw skillBudgetError(
+      "CC_SKILL_DISCOVERY_FILES_EXCEEDED",
+      "Recursive skill discovery exceeds the host file-count limit.",
+      {
+        limit: budget.limits.maxSkillDiscoveryFiles,
+        actual: nextFiles,
+      },
+    );
+  }
+  if (
+    !Number.isSafeInteger(nextBytes) ||
+    nextBytes > budget.limits.maxSkillDiscoveryBytes
+  ) {
+    throw skillBudgetError(
+      "CC_SKILL_DISCOVERY_BYTES_EXCEEDED",
+      "Recursive skill discovery exceeds the host aggregate byte limit.",
+      {
+        limit: budget.limits.maxSkillDiscoveryBytes,
+        actual: nextBytes,
+      },
+    );
+  }
+  budget.files = nextFiles;
+  budget.bytes = nextBytes;
+  return budget;
+}
+
+export function measureSkillPrompt(body) {
+  if (typeof body !== "string") {
+    throw skillBudgetError(
+      "CC_SKILL_PROMPT_INVALID",
+      "Skill instructions must be a string before model projection.",
+    );
+  }
+  const bytes = Buffer.byteLength(body, "utf8");
+  return Object.freeze({
+    bytes,
+    // Conservative provider-neutral upper bound for text-derived tokens. This
+    // intentionally does not trust a configurable estimator that could return
+    // zero or NaN.
+    tokenUpperBound: bytes,
+  });
+}
+
+export function admitSkillPrompt(body, limitsInput = {}) {
+  const limits = resolveSkillLimits(limitsInput);
+  const measured = measureSkillPrompt(body);
+  if (measured.bytes > limits.maxSkillPromptBytes) {
+    throw skillBudgetError(
+      "CC_SKILL_PROMPT_BYTES_EXCEEDED",
+      "Skill instructions exceed the host model-projection byte limit.",
+      { limit: limits.maxSkillPromptBytes, actual: measured.bytes },
+    );
+  }
+  if (measured.tokenUpperBound > limits.maxSkillPromptTokens) {
+    throw skillBudgetError(
+      "CC_SKILL_PROMPT_TOKENS_EXCEEDED",
+      "Skill instructions exceed the host model-projection token limit.",
+      { limit: limits.maxSkillPromptTokens, actual: measured.tokenUpperBound },
+    );
+  }
+  return measured;
+}
+
+export function debitSkillPromptBudget(budget, measured) {
+  const nextBytes = budget.bytes + measured.bytes;
+  const nextTokens = budget.tokens + measured.tokenUpperBound;
+  if (
+    !Number.isSafeInteger(nextBytes) ||
+    nextBytes > budget.limits.maxSkillPromptTotalBytes
+  ) {
+    throw skillBudgetError(
+      "CC_SKILL_PROMPT_TOTAL_BYTES_EXCEEDED",
+      "Skill instructions exceed the host aggregate model-projection byte limit.",
+      {
+        limit: budget.limits.maxSkillPromptTotalBytes,
+        actual: nextBytes,
+      },
+    );
+  }
+  if (
+    !Number.isSafeInteger(nextTokens) ||
+    nextTokens > budget.limits.maxSkillPromptTotalTokens
+  ) {
+    throw skillBudgetError(
+      "CC_SKILL_PROMPT_TOTAL_TOKENS_EXCEEDED",
+      "Skill instructions exceed the host aggregate model-projection token limit.",
+      {
+        limit: budget.limits.maxSkillPromptTotalTokens,
+        actual: nextTokens,
+      },
+    );
+  }
+  budget.bytes = nextBytes;
+  budget.tokens = nextTokens;
+  return budget;
+}