dsh-decision-layer 0.7.3 → 0.7.5

package/lib/host/evaluation-trace.d.ts

@@ -0,0 +1,8 @@
+import type { EvaluationTelemetry, Evaluator } from './types.js';
+/** Local wrapper: the backend alone still owns wire validation and transport counts. */
+export declare function measuredEvaluator(evaluate: Evaluator, now?: () => number): Evaluator;
+/** One logical decision may fan out into several backend calls. Its latency is wall time. */
+export declare function createEvaluationTrace(evaluate: Evaluator, now?: () => number): {
+    evaluate: Evaluator;
+    detail(): Partial<EvaluationTelemetry>;
+};

package/lib/host/evaluation-trace.js

@@ -0,0 +1,70 @@
+import { randomUUID } from "node:crypto";
+import { isObject } from "./types.js";
+const numeric = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+function measuredEvaluator(evaluate, now = () => performance.now()) {
+  return async (input, options) => {
+    const start = now();
+    const telemetry = { requestId: randomUUID(), latencyMs: 0 };
+    try {
+      telemetry.requestBytes = Buffer.byteLength(JSON.stringify(input));
+    } catch {
+    }
+    try {
+      const result = await evaluate(input, options);
+      telemetry.latencyMs = Math.max(0, now() - start);
+      telemetry.model = result.model;
+      if (result.usage) {
+        if (numeric(result.usage.input_tokens)) telemetry.inputTokens = result.usage.input_tokens;
+        if (numeric(result.usage.output_tokens)) telemetry.outputTokens = result.usage.output_tokens;
+      }
+      return { ...result, telemetry: { ...telemetry, ...result.telemetry, latencyMs: telemetry.latencyMs } };
+    } catch (error) {
+      telemetry.latencyMs = Math.max(0, now() - start);
+      if (error instanceof Error) {
+        const existing = error.telemetry;
+        Object.assign(error, { telemetry: { ...telemetry, ...existing, latencyMs: telemetry.latencyMs } });
+      }
+      throw error;
+    }
+  };
+}
+function createEvaluationTrace(evaluate, now = () => performance.now()) {
+  const requestId = randomUUID();
+  let started;
+  let ended = 0;
+  const samples = [];
+  const record = (value) => {
+    const sample = isObject(value) && isObject(value.telemetry) ? value.telemetry : {};
+    samples.push(sample);
+    ended = now();
+  };
+  const traced = async (input, options) => {
+    started ??= now();
+    try {
+      const result = await evaluate(input, options);
+      record(result);
+      return result;
+    } catch (error) {
+      record(error);
+      throw error;
+    }
+  };
+  return {
+    evaluate: traced,
+    detail() {
+      if (!samples.length || started === void 0) return {};
+      const detail = { requestId, latencyMs: Math.max(0, ended - started) };
+      for (const key of ["requestBytes", "backendAttempts", "inputTokens", "outputTokens"]) {
+        if (samples.every((sample) => numeric(sample[key]))) detail[key] = samples.reduce((sum, sample) => sum + sample[key], 0);
+      }
+      const models = new Set(samples.map((sample) => sample.model).filter((model) => typeof model === "string"));
+      if (models.size === 1) detail.model = [...models][0];
+      else if (models.size > 1) detail.model = "mixed";
+      return detail;
+    }
+  };
+}
+export {
+  createEvaluationTrace,
+  measuredEvaluator
+};

package/lib/host/execution-observer.d.ts

@@ -0,0 +1,26 @@
+export type ExecutionEvidence = {
+    seq: number;
+    step: number;
+    tool: string;
+    outcome: 'ok' | 'error' | 'unknown';
+    command?: string;
+    path?: string;
+    result?: string;
+};
+export type ExecutionSnapshot = {
+    throughSeq: number;
+    step: number;
+    evidenceSteps: number;
+    evidence: ExecutionEvidence[];
+    unresolvedFailures: number;
+    artifactGeneration: number;
+    verificationGeneration?: number;
+    verificationAfterChange: boolean;
+    fingerprint: string;
+    failureFingerprint: string;
+};
+/** Pure, bounded per-turn collector. It neither reads history nor invokes host APIs. */
+export declare function createExecutionObserver(turn: number): {
+    snapshot: () => ExecutionSnapshot;
+    observe(event: unknown): ExecutionSnapshot | undefined;
+};

package/lib/host/execution-observer.js

@@ -0,0 +1,168 @@
+import { createHash } from "node:crypto";
+import { decisionText } from "./decision-context.js";
+import { redactCredentials, stripInjected } from "./excerpt.js";
+import { isObject } from "./types.js";
+const SHELL = /* @__PURE__ */ new Set(["bash", "shell", "pwsh"]);
+const WRITES = /* @__PURE__ */ new Set(["write", "edit", "file_write", "write_file", "str_replace_editor", "apply_patch"]);
+const RECOVERY = /* @__PURE__ */ new Set(["TOOL_OUTCOME_UNKNOWN", "TOOL_NOT_STARTED", "ABORTED_BEFORE_DISPATCH", "ABORTED"]);
+const MAX_CALLS = 128;
+const MAX_STRATEGIES = 64;
+const OPAQUE = /[A-Za-z0-9_+-]{24,}/g;
+const PERSISTENT_SIGNATURE = /\[Command finished with exit code|\[shell exited|\[Command timed out or OOM|persistent bash shell was reset/i;
+const digest = (value) => createHash("sha256").update(value).digest("hex");
+const integer = (value) => Number.isSafeInteger(value) && value >= 0;
+const bounded = (value, bytes) => decisionText(typeof value === "string" ? value.replace(OPAQUE, "[redacted]") : "", bytes);
+const label = (value, bytes) => decisionText(value, bytes);
+const STATUS_LINE = /^\[(?:exit code: -?\d+|Command finished with exit code -?\d+|shell exited(?:: code -?\d+)?|Command timed out or OOM|timed out after [^\]\n]*|stopped: [^\]\n]*|killed by signal: [^\]\n]*|shell killed by signal: [^\]\n]*|sandbox: [^\]\n]*|still running after [^\]\n]*)\]$/i;
+function shellStatus(text) {
+  const lines = text.slice(-4096).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index--) {
+    const line = lines[index];
+    if (!STATUS_LINE.test(line)) continue;
+    if (/^\[still running after/i.test(line)) return { backgrounded: true, explicit: true };
+    const code = /^\[(?:exit code: (-?\d+)|Command finished with exit code (-?\d+)|shell exited: code (-?\d+))\]$/i.exec(line);
+    if (code) return { exit: Number(code[1] ?? code[2] ?? code[3]), explicit: true };
+    if (/^\[shell exited\]$/i.test(line)) return { explicit: true };
+    return { terminated: true, explicit: true };
+  }
+  return { exit: 0 };
+}
+function argumentsOf(value) {
+  if (typeof value === "string") {
+    if (value.length > 32 * 1024) return {};
+    try {
+      const parsed = JSON.parse(value);
+      return isObject(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return isObject(value) ? value : {};
+}
+function modifies(command) {
+  return /(?:\b(?:sed|perl)\b[^\n]*\s-[^\s]*i|\b(?:rm|mv|cp|touch|mkdir|tee)\s|\bgit\s+(?:apply|reset|checkout|restore|clean)\b|(?:^|[^>])>{1,2}\s*\S|\bnpm\s+(?:install|uninstall)\b)/i.test(command);
+}
+function verifies(command) {
+  if (/[\n;|&<>`]|\$\(/.test(command)) return false;
+  return /^(?:(?:npm|pnpm|yarn)\s+(?:test\b|(?:run\s+)?(?:check|typecheck|lint|build|test(?::[\w-]+)?)\b)|(?:pytest|vitest|jest)\b|node\s+--test\b|(?:cargo|go)\s+test\b)/i.test(command.trim());
+}
+function createExecutionObserver(turn) {
+  let throughSeq = -1;
+  let latestStep = 0;
+  let evidenceSteps = 0;
+  let dirtyStep;
+  let artifactGeneration = 0;
+  let verificationGeneration;
+  const calls = /* @__PURE__ */ new Map();
+  const failures = /* @__PURE__ */ new Map();
+  const explicitShells = /* @__PURE__ */ new Set();
+  const evidence = [];
+  const snapshot = () => {
+    const selected = evidence.map((item) => ({ ...item }));
+    const strategies = [...failures].sort(([a], [b]) => a.localeCompare(b));
+    return {
+      throughSeq,
+      step: latestStep,
+      evidenceSteps,
+      evidence: selected,
+      unresolvedFailures: Math.max(0, ...strategies.map(([, count]) => count)),
+      artifactGeneration,
+      ...verificationGeneration === void 0 ? {} : { verificationGeneration },
+      verificationAfterChange: verificationGeneration !== void 0 && verificationGeneration < artifactGeneration,
+      fingerprint: digest(JSON.stringify([selected, artifactGeneration, verificationGeneration, strategies])),
+      failureFingerprint: digest(JSON.stringify(strategies))
+    };
+  };
+  return {
+    snapshot,
+    observe(event) {
+      if (!isObject(event) || !integer(event.seq) || event.seq <= throughSeq || typeof event.type !== "string" || !isObject(event.data)) return;
+      throughSeq = event.seq;
+      const data = event.data;
+      if (data.turn !== turn || !integer(data.step)) return;
+      latestStep = data.step;
+      if (event.type === "tool/call") {
+        if (typeof data.callId !== "string" || !data.callId || data.callId.length > 256 || typeof data.name !== "string") return;
+        const rawTool = data.name.slice(0, 256);
+        const tool = label(rawTool, 96);
+        if (!tool) return;
+        const args = argumentsOf(data.arguments);
+        const shell = SHELL.has(rawTool);
+        const commandValue = args.command ?? args.cmd;
+        const commandTruncated = shell && typeof commandValue === "string" && commandValue.length > 32 * 1024;
+        const rawCommand = shell && typeof commandValue === "string" ? commandValue.slice(0, 32 * 1024) : "";
+        const backgrounded = shell && args.run_in_background === true;
+        const command = bounded(rawCommand, 256);
+        const pathValue = args.file_path ?? args.path ?? args.filePath;
+        const rawPath = typeof pathValue === "string" ? pathValue.slice(0, 32 * 1024) : "";
+        const path = bounded(rawPath, 160);
+        const strategy = digest(JSON.stringify([rawTool, rawCommand, rawPath]));
+        calls.set(data.callId, {
+          rawTool,
+          tool,
+          step: data.step,
+          command,
+          path,
+          strategy,
+          shell,
+          backgrounded,
+          modifies: WRITES.has(rawTool) || shell && (commandTruncated || modifies(rawCommand)),
+          verifies: shell && !commandTruncated && verifies(rawCommand) && !modifies(rawCommand)
+        });
+        if (calls.size > MAX_CALLS) calls.delete(calls.keys().next().value);
+        return;
+      }
+      if (event.type === "tool/result") {
+        if (event.surfaceOp !== void 0 && event.surfaceOp !== "append" && !(isObject(event.surfaceOp) && event.surfaceOp.op === "append")) return;
+        const message = isObject(data.message) ? data.message : void 0;
+        if (!message || message.role !== "tool") return;
+        const source = isObject(message.source) ? message.source : void 0;
+        if (source && source.kind !== "tool") return;
+        if (source?.callId !== void 0 && message.toolCallId !== void 0 && source.callId !== message.toolCallId) return;
+        const id = typeof message.toolCallId === "string" ? message.toolCallId : source?.callId;
+        const call = typeof id === "string" ? calls.get(id) : void 0;
+        if (!call || call.step !== data.step) return;
+        calls.delete(id);
+        const error = isObject(data.error) ? data.error : void 0;
+        const synthetic = typeof error?.code === "string" && RECOVERY.has(error.code);
+        const content = call.shell && Array.isArray(message.content) ? message.content.filter(isObject).filter((block) => block.type === "text" && typeof block.text === "string").slice(0, 16).map((block) => {
+          const text = redactCredentials(stripInjected(block.text.replace(OPAQUE, "[redacted]")));
+          return text.length <= 32 * 1024 ? text : `${text.slice(0, 24 * 1024)}
+[output omitted]
+${text.slice(-8 * 1024)}`;
+        }).join("\n") : "";
+        const status = call.shell ? call.backgrounded ? { backgrounded: true } : shellStatus(content) : void 0;
+        if (call.shell && status?.explicit && PERSISTENT_SIGNATURE.test(content)) {
+          explicitShells.add(call.rawTool);
+          if (explicitShells.size > 16) explicitShells.delete(explicitShells.values().next().value);
+        }
+        const paused = Boolean(call.shell && status && !status.explicit && !call.backgrounded && explicitShells.has(call.rawTool));
+        const outcome = synthetic ? "unknown" : message.isError === true ? "error" : !status ? "ok" : status.backgrounded ? "unknown" : paused ? "unknown" : status.terminated ? "error" : status.exit === void 0 ? "unknown" : status.exit === 0 ? "ok" : "error";
+        if (outcome === "error") {
+          failures.set(call.strategy, Math.min((failures.get(call.strategy) ?? 0) + 1, 1e3));
+          if (failures.size > MAX_STRATEGIES) failures.delete(failures.keys().next().value);
+        } else if (outcome === "ok") failures.delete(call.strategy);
+        if (call.modifies && !synthetic) artifactGeneration++;
+        if (call.verifies && outcome === "ok" && !paused && status?.exit === 0) verificationGeneration = artifactGeneration;
+        const item = { seq: event.seq, step: data.step, tool: call.tool, outcome };
+        if (call.command) item.command = call.command;
+        if (call.path) item.path = call.path;
+        if (content) item.result = bounded(content, 256);
+        evidence.push(item);
+        while (evidence.length > 12 || Buffer.byteLength(JSON.stringify(evidence)) > 4096) evidence.shift();
+        if (!synthetic) dirtyStep = data.step;
+        return;
+      }
+      if (event.type === "step/end" && dirtyStep === data.step) {
+        evidenceSteps++;
+        dirtyStep = void 0;
+        calls.clear();
+        return snapshot();
+      }
+      return;
+    }
+  };
+}
+export {
+  createExecutionObserver
+};

package/lib/host/index.d.ts

@@ -3,4 +3,5 @@ export declare const name = "dsh-decision-layer";
 export declare const inject: string[];
 export declare function apply(ctx: HostContext, options?: {
     configPath?: string;
+    storageDir?: string;
 }): Promise<void>;

package/lib/host/index.js

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import { join } from "node:path";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import { resolveConfig, featureEnabled } from "./config-store.js";
 import { createBackend } from "./backend.js";
@@ -12,6 +13,7 @@ import { createLoopGuard } from "./loop-guard.js";
 import { createLogStore } from "./log-store.js";
 import { createStateStore } from "./state-store.js";
 import { createDecisionContext } from "./decision-context.js";
+import { createCheckpointReview } from "./checkpoint-review.js";
 import { analyzeSessionLogs, reconstructSessionSeed, listSessionDecisions } from "./log-analyze.js";
 import { isObject } from "./types.js";
 const name = "dsh-decision-layer";
@@ -46,11 +48,16 @@ function agentTools(ctx, agent) {
   }
 }
 async function apply(ctx, options = {}) {
-  const path = options.configPath;
+  const path = options.configPath ?? (options.storageDir ? join(options.storageDir, "config.json") : void 0);
+  const logDir = options.storageDir ? join(options.storageDir, "logs") : void 0;
   const backend = createBackend({ config: () => resolveConfig({ path }) });
   let logStore;
-  const stateStore = createStateStore();
+  const stateStore = createStateStore({ dir: options.storageDir ? join(options.storageDir, "state") : void 0 });
+  let closeCheckpoint;
   const sessions = createSessionState({
+    onEnabled: (id, enabled) => {
+      if (!enabled) closeCheckpoint?.(id);
+    },
     onLog: (entry) => logStore?.append(entry),
     // Restore a resumed session from its durable snapshot; if it has none yet but
     // has persisted JSONL decision history (e.g. a session that predates this
@@ -58,13 +65,12 @@ async function apply(ctx, options = {}) {
     // logs instead. Logs are read across all ports and filtered by the globally
     // unique session id, so a changed instance port never orphans the history.
     loadState: async (id) => await stateStore.load(id) ?? reconstructSessionSeed(id, {
+      dir: logDir,
       trendConfig: (await resolveConfig({ path })).checkSettings
     }).catch(() => void 0),
     persistState: (id, state) => stateStore.save(id, state)
   });
-  if (typeof ctx.effect === "function") ctx.effect(() => () => {
-    void stateStore.dispose();
-  });
+  if (typeof ctx.effect === "function") ctx.effect(() => () => stateStore.dispose());
   const steeredIds = /* @__PURE__ */ new Map();
   const rememberSteer = (message) => {
     const id = isObject(message) && typeof message.id === "string" ? message.id : void 0;
@@ -79,6 +85,14 @@ async function apply(ctx, options = {}) {
     return agent.steer(message);
   };
   const decisionContext = createDecisionContext({ ignored: (id) => steeredIds.has(id) });
+  const checkpoints = createCheckpointReview({
+    evaluate: (input, request) => backend.evaluate(input, request),
+    sessions,
+    settings: async () => (await resolveConfig({ path })).checkpointSettings
+  });
+  closeCheckpoint = (id) => checkpoints.close(id);
+  if (typeof ctx.effect === "function") ctx.effect(() => () => checkpoints.dispose());
+  const checkpointRequests = /* @__PURE__ */ new WeakMap();
   const gate = createDangerGate({
     evaluate: (input, request) => backend.evaluate(input, request),
     sessions,
@@ -186,6 +200,19 @@ async function apply(ctx, options = {}) {
         if (typeof id === "string") await sessions.ensureLoaded(id);
         if (typeof id === "string" && Number.isInteger(turn)) {
           const entered = decisionContext.enter(agent, { turn, messages: payload.messages });
+          if (agent) {
+            try {
+              if (entered.snapshot) checkpointRequests.set(agent, { turn, request: entered.snapshot.context.request });
+              const cached = checkpointRequests.get(agent);
+              checkpoints.enter(agent, {
+                turn,
+                request: cached && cached.turn === turn ? cached.request : "",
+                changed: entered.changed,
+                signal: payload.signal
+              });
+            } catch {
+            }
+          }
           const previous = narrowedTurns.get(id);
           const turnChanged = !previous || previous.turn !== turn;
           if (turnChanged || entered.changed) {
@@ -227,13 +254,26 @@ async function apply(ctx, options = {}) {
     };
     if (typeof ctx.effect === "function") ctx.effect(installNarrowingHook);
     else installNarrowingHook();
-    const installNarrowingRelease = () => ctx.on("session/event", (subject, event) => {
-      if (!isObject(event) || event.type !== "turn/end") return;
-      const id = isObject(subject) && typeof subject.id === "string" ? subject.id : void 0;
-      if (id !== void 0) releaseNarrowing(id);
-    });
-    if (typeof ctx.effect === "function") ctx.effect(installNarrowingRelease);
-    else installNarrowingRelease();
+    const installSessionLifecycle = () => {
+      const offEvents = ctx.on("session/event", (subject, event) => {
+        try {
+          checkpoints.observe(subject, event);
+        } catch {
+        }
+        if (!isObject(event) || event.type !== "turn/end") return;
+        const id = isObject(subject) && typeof subject.id === "string" ? subject.id : void 0;
+        if (id !== void 0) releaseNarrowing(id);
+      });
+      const offDisposed = ctx.on("session/disposed", (subject) => {
+        if (isObject(subject) && typeof subject.id === "string") checkpoints.close(subject.id);
+      });
+      return () => {
+        offEvents?.();
+        offDisposed?.();
+      };
+    };
+    if (typeof ctx.effect === "function") ctx.effect(installSessionLifecycle);
+    else installSessionLifecycle();
   }
   const rawSkill = await readFile(new URL("../../skills/decision-layer/SKILL.md", import.meta.url), "utf8");
   const content = rawSkill.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
@@ -248,7 +288,11 @@ async function apply(ctx, options = {}) {
     }, additionalProperties: false },
     output,
     timeoutMs: 25e3,
-    execute: (args, exec) => backend.evaluate(args, { signal: exec.signal })
+    // Local measurement metadata never crosses the model-visible tool boundary.
+    execute: async (args, exec) => {
+      const result = await backend.evaluate(args, { signal: exec.signal });
+      return { model: result.model, answers: result.answers, ...result.usage ? { usage: result.usage } : {} };
+    }
   });
   ctx.tools.register({
     name: "decision_check_connection",
@@ -264,19 +308,20 @@ async function apply(ctx, options = {}) {
     }
   });
   ctx.inject(["webServer"], (web) => {
-    logStore = createLogStore({ port: web.webServer.port });
+    logStore = createLogStore({ port: web.webServer.port, dir: logDir });
     const port = web.webServer.port;
     const analyze = async (sessionId) => analyzeSessionLogs(sessionId, {
       port,
+      dir: logDir,
       trendConfig: (await resolveConfig({ path })).checkSettings
     });
-    const listRows = (sessionId, { page, pageSize } = {}) => listSessionDecisions(sessionId, { port, page, pageSize });
+    const listRows = (sessionId, { page, pageSize, lowOnly } = {}) => listSessionDecisions(sessionId, { port, dir: logDir, page, pageSize, lowOnly });
     const unregister = createManagerRoutes({ path, sessions, backend, logStore, analyze, listRows, bindHost: web.webServer.host }).map((route) => web.webServer.register(route));
     return () => {
       unregister.forEach((dispose) => dispose());
       const store = logStore;
       logStore = void 0;
-      void store?.dispose();
+      return store?.dispose();
     };
   });
 }

package/lib/host/log-analyze.d.ts

@@ -50,6 +50,24 @@ export type Profile = {
         error: number;
         steered: number;
     };
+    checkpoint: {
+        attempts: number;
+        concern: number;
+        uncertain: number;
+        error: number;
+        skipped: number;
+    };
+    telemetry: {
+        measured: number;
+        latencyMsSum: number;
+        latencyMsP50: number | null;
+        latencyMsP95: number | null;
+        inputTokens: number;
+        outputTokens: number;
+        usageMeasured: number;
+        backendAttempts: number;
+        transportMeasured: number;
+    };
 };
 export declare function buildProfile(decisions: ReadonlyMap<string, PersistedRecord> | Iterable<PersistedRecord>): Profile;
 export declare function backtestTrend(checkRecords: Iterable<unknown>, { trendMinConfidence, trendRun, trendSevereRun, lowScoreThreshold }?: TrendConfig): TrendBacktest;
@@ -106,11 +124,12 @@ export declare function reconstructSessionSeed(sessionId: unknown, { dir, port,
     maxLog?: number;
     readStream?: ReadStream;
 }): Promise<SessionSeed | undefined>;
-export declare function listSessionDecisions(sessionId: unknown, { dir, port, page, pageSize, readStream }?: {
+export declare function listSessionDecisions(sessionId: unknown, { dir, port, page, pageSize, lowOnly, readStream }?: {
     dir?: string;
     port?: number;
     page?: number;
     pageSize?: number;
+    lowOnly?: boolean;
     readStream?: ReadStream;
 }): Promise<{
     entries: LogRow[];

package/lib/host/log-analyze.js

@@ -2,7 +2,8 @@ import { createReadableStream } from "./log-read.js";
 import { advanceRun, severityOf } from "./quality-trend.js";
 import { narrowApplied } from "./narrowing.js";
 import { isObject } from "./types.js";
-const DECISION_KINDS = /* @__PURE__ */ new Set(["gate", "check", "narrow", "complete"]);
+import { sanitizeLogRow } from "./log-row.js";
+const DECISION_KINDS = /* @__PURE__ */ new Set(["gate", "check", "narrow", "complete", "checkpoint"]);
 const atOf = (record) => {
   const value = record.at;
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
@@ -22,7 +23,8 @@ function foldSession(records) {
       continue;
     }
     if (DECISION_KINDS.has(record.kind) && typeof record.id === "string") {
-      decisions.set(record.id, record);
+      const row = sanitizeLogRow(record);
+      if (row) decisions.set(record.id, row);
     }
   }
   return { decisions, annotations };
@@ -39,14 +41,43 @@ function emptyProfile() {
     gate: { attempts: 0, allow: 0, ask: 0, deny: 0, error: 0 },
     check: { attempts: 0, ok: 0, low: 0, error: 0, scoreSum: 0, scoreCount: 0, confidence: { lt40: 0, lt60: 0, lt80: 0, gte80: 0 } },
     narrow: { attempts: 0, applied: 0, error: 0, droppedSum: 0, tooManyCandidates: 0 },
-    complete: { attempts: 0, satisfied: 0, unsatisfied: 0, insufficient: 0, error: 0, steered: 0 }
+    complete: { attempts: 0, satisfied: 0, unsatisfied: 0, insufficient: 0, error: 0, steered: 0 },
+    checkpoint: { attempts: 0, concern: 0, uncertain: 0, error: 0, skipped: 0 },
+    telemetry: {
+      measured: 0,
+      latencyMsSum: 0,
+      latencyMsP50: null,
+      latencyMsP95: null,
+      inputTokens: 0,
+      outputTokens: 0,
+      usageMeasured: 0,
+      backendAttempts: 0,
+      transportMeasured: 0
+    }
   };
 }
 function buildProfile(decisions) {
   const profile = emptyProfile();
   const rows = decisions instanceof Map ? [...decisions.values()] : [...decisions];
+  const latencies = [];
   for (const record of rows) {
     const kind = record.kind;
+    if (DECISION_KINDS.has(kind) && record.outcome !== "skipped") {
+      if (typeof record.latencyMs === "number" && Number.isFinite(record.latencyMs) && record.latencyMs >= 0) {
+        profile.telemetry.measured++;
+        profile.telemetry.latencyMsSum += record.latencyMs;
+        latencies.push(record.latencyMs);
+      }
+      if (Number.isSafeInteger(record.inputTokens) && record.inputTokens >= 0 && Number.isSafeInteger(record.outputTokens) && record.outputTokens >= 0) {
+        profile.telemetry.usageMeasured++;
+        profile.telemetry.inputTokens += record.inputTokens;
+        profile.telemetry.outputTokens += record.outputTokens;
+      }
+      if (Number.isSafeInteger(record.backendAttempts) && record.backendAttempts >= 0) {
+        profile.telemetry.transportMeasured++;
+        profile.telemetry.backendAttempts += record.backendAttempts;
+      }
+    }
     switch (kind) {
       case "gate": {
         const bucket = profile.gate;
@@ -90,10 +121,26 @@ function buildProfile(decisions) {
         if (record.steered === true) bucket.steered++;
         break;
       }
+      case "checkpoint": {
+        const bucket = profile.checkpoint;
+        if (record.outcome === "skipped") bucket.skipped++;
+        else {
+          bucket.attempts++;
+          if (record.outcome === "error") bucket.error++;
+          else if (record.outcome === "concern") bucket.concern++;
+          else if (record.outcome === "uncertain") bucket.uncertain++;
+        }
+        break;
+      }
       default:
         break;
     }
   }
+  latencies.sort((a, b) => a - b);
+  if (latencies.length) {
+    profile.telemetry.latencyMsP50 = latencies[Math.ceil(latencies.length * 0.5) - 1];
+    profile.telemetry.latencyMsP95 = latencies[Math.ceil(latencies.length * 0.95) - 1];
+  }
   return profile;
 }
 function backtestTrend(checkRecords, { trendMinConfidence = 0.6, trendRun = 3, trendSevereRun = 5, lowScoreThreshold = 1 } = {}) {
@@ -158,16 +205,26 @@ function buildSeed(decisions, { maxLog = 50, trendConfig = {} } = {}) {
     check: { attempts: 0, failures: 0, low: 0, run: 0, severity: "normal" },
     narrow: { attempts: 0, failures: 0, applied: 0, dropped: 0 },
     complete: { attempts: 0, failures: 0, unsatisfied: 0, satisfied: 0, insufficient: 0, steered: 0 },
+    checkpoint: { attempts: 0, failures: 0, concern: 0, uncertain: 0, skipped: 0 },
     log: []
   };
   const minConfidence = typeof trendConfig.trendMinConfidence === "number" ? trendConfig.trendMinConfidence : 0.6;
   const thresholds = { trendRun: trendConfig.trendRun ?? 3, trendSevereRun: trendConfig.trendSevereRun ?? 5 };
   let run = 0;
   for (const record of ordered) {
-    seed.attempts++;
+    const checkpoint = record.kind === "checkpoint";
+    if (!checkpoint && record.outcome !== "skipped") seed.attempts++;
     const isError = record.outcome === "error";
-    if (isError) seed.failures++;
-    if (record.kind === "gate") {
+    if (!checkpoint && isError) seed.failures++;
+    if (checkpoint) {
+      if (record.outcome === "skipped") seed.checkpoint.skipped++;
+      else {
+        seed.checkpoint.attempts++;
+        if (isError) seed.checkpoint.failures++;
+        else if (record.outcome === "concern") seed.checkpoint.concern++;
+        else if (record.outcome === "uncertain") seed.checkpoint.uncertain++;
+      }
+    } else if (record.kind === "gate") {
       seed.gate.attempts++;
       if (isError) seed.gate.failures++;
       if (record.outcome === "allow") seed.gate.allow++;
@@ -220,7 +277,7 @@ async function reconstructSessionSeed(sessionId, { dir, port, trendConfig, maxLo
   if (decisions.size === 0) return void 0;
   return buildSeed(decisions, { maxLog, trendConfig });
 }
-async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize = 100, readStream = createReadableStream } = {}) {
+async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize = 100, lowOnly = false, readStream = createReadableStream } = {}) {
   if (typeof sessionId !== "string" || !sessionId.trim()) throw new Error("Invalid session id");
   const size = Number.isSafeInteger(pageSize) && pageSize > 0 && pageSize <= 500 ? pageSize : 100;
   const records = [];
@@ -229,7 +286,8 @@ async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize =
     if (record.sessionId === sessionId) records.push(record);
   }
   const { decisions } = foldSession(records);
-  const rows = [...decisions.values()].sort((a, b) => atOf(b) - atOf(a));
+  const all = [...decisions.values()].sort((a, b) => atOf(b) - atOf(a));
+  const rows = lowOnly ? all.filter((record) => record.kind === "check" && record.outcome === "low") : all;
   const total = rows.length;
   const pages = Math.max(1, Math.ceil(total / size));
   const current = Math.min(Math.max(1, Number.isSafeInteger(page) ? page : 1), pages);

package/lib/host/log-row.d.ts

@@ -0,0 +1,3 @@
+import type { LogRow } from './types.js';
+/** The same whitelist protects live logs, restored snapshots and browser rows. */
+export declare function sanitizeLogRow(value: unknown): LogRow | undefined;