dsh-decision-layer 0.7.0 → 0.7.2

package/lib/host/index.js

@@ -0,0 +1,290 @@
+import { readFile } from "node:fs/promises";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { resolveConfig, featureEnabled } from "./config-store.js";
+import { createBackend } from "./backend.js";
+import { createManagerRoutes } from "./manager-api.js";
+import { createSessionState } from "./session-state.js";
+import { createDangerGate, normalizeDangerRules } from "./danger-gate.js";
+import { createSelfCheck } from "./self-check.js";
+import { createNarrowing } from "./narrowing.js";
+import { createTaskCompletion } from "./task-completion.js";
+import { createLoopGuard } from "./loop-guard.js";
+import { createLogStore } from "./log-store.js";
+import { createStateStore } from "./state-store.js";
+import { analyzeSessionLogs, reconstructSessionSeed, listSessionDecisions } from "./log-analyze.js";
+import { isObject } from "./types.js";
+const name = "dsh-decision-layer";
+const inject = ["tools", "skills"];
+const asMessage = (value) => isObject(value) ? value : void 0;
+const textOf = (content) => Array.isArray(content) ? content.filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("") : "";
+const derivedMessages = (agent) => {
+  const messages = agent?.session?.deriveMessages?.();
+  return Array.isArray(messages) ? messages : void 0;
+};
+function lastAssistantText(agent) {
+  try {
+    const messages = derivedMessages(agent);
+    if (!messages) return "";
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = asMessage(messages[i]);
+      if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+      return textOf(message.content);
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function stepTaskText(messages) {
+  try {
+    if (!Array.isArray(messages)) return "";
+    return messages.map(asMessage).filter((message) => message?.role === "user" && Array.isArray(message.content)).flatMap((message) => message.content.filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text)).join("\n").slice(0, 8 * 1024);
+  } catch {
+    return "";
+  }
+}
+function turnUserText(agent) {
+  try {
+    const messages = derivedMessages(agent);
+    if (!messages) return "";
+    const texts = [];
+    let collecting = false;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = asMessage(messages[i]);
+      if (message?.role === "user" && Array.isArray(message.content)) {
+        collecting = true;
+        texts.unshift(message.content.filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n"));
+      } else if (collecting) break;
+    }
+    return texts.join("\n").slice(0, 8 * 1024);
+  } catch {
+    return "";
+  }
+}
+function turnToolEvidence(agent) {
+  try {
+    const messages = derivedMessages(agent);
+    if (!messages) return [];
+    const evidence = [];
+    for (const item of messages) {
+      const message = asMessage(item);
+      if (message?.role !== "tool" || !Array.isArray(message.content)) continue;
+      const tool = typeof message.name === "string" ? message.name : typeof message.toolName === "string" ? message.toolName : "";
+      if (!tool) continue;
+      evidence.push({ tool: tool.slice(0, 128), outcome: message.isError === true ? "error" : "ok" });
+      if (evidence.length >= 40) break;
+    }
+    return evidence;
+  } catch {
+    return [];
+  }
+}
+function agentTools(ctx, agent) {
+  try {
+    const schemas = typeof ctx.tools?.schemas === "function" ? ctx.tools.schemas(agent) : void 0;
+    if (!Array.isArray(schemas)) return [];
+    return schemas.filter((schema) => isObject(schema) && typeof schema.name === "string").map((schema) => ({ name: schema.name, description: typeof schema.description === "string" ? schema.description : "" }));
+  } catch {
+    return [];
+  }
+}
+async function apply(ctx, options = {}) {
+  const path = options.configPath;
+  const backend = createBackend({ config: () => resolveConfig({ path }) });
+  let logStore;
+  const stateStore = createStateStore();
+  const sessions = createSessionState({
+    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
+    // persistence, or whose snapshot was pruned), reconstruct a seed from the
+    // 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, {
+      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();
+  });
+  const gate = createDangerGate({
+    evaluate: (input, request) => backend.evaluate(input, request),
+    sessions,
+    rules: async () => normalizeDangerRules((await resolveConfig({ path })).dangerRules),
+    // Live config-backed floor (default 0.6): a `deny` only blocks once the model
+    // is at least this confident. Read per call so an edit takes effect at once.
+    minConfidence: async () => (await resolveConfig({ path })).gateSettings?.minConfidence,
+    // Read lazily (only when a dangerous call is recorded) so ordinary tool calls
+    // never pay for deriveMessages().
+    taskText: (agent) => turnUserText(agent)
+  });
+  const loopGuard = createLoopGuard({ sessions });
+  const featureOn = async (key) => {
+    try {
+      return featureEnabled((await resolveConfig({ path })).features, key);
+    } catch {
+      return true;
+    }
+  };
+  if (typeof ctx.on === "function") {
+    if (typeof ctx.tools.guard === "function") {
+      ctx.tools.guard((exec) => loopGuard.check(exec));
+      ctx.tools.guard((exec) => gate.guardReason(exec));
+    }
+    const install = () => {
+      const disposePre = ctx.on("tools/pre-execute", async (exec, next) => {
+        if (!await featureOn("gate")) return next();
+        return gate.preExecute(exec, next);
+      });
+      const disposePost = ctx.on("tools/post-execute", async (exec, result, next) => {
+        gate.observeResult(exec, result);
+        return next();
+      });
+      return () => {
+        disposePre?.();
+        disposePost?.();
+      };
+    };
+    if (typeof ctx.effect === "function") ctx.effect(install);
+    else install();
+    const selfCheck = createSelfCheck({
+      evaluate: (input, request) => backend.evaluate(input, request),
+      sessions,
+      settings: async () => (await resolveConfig({ path })).checkSettings,
+      steer: (agent, text) => {
+        if (typeof agent.steer !== "function") throw new Error("Agent cannot be steered");
+        return agent.steer(createUserMessage({ content: [{ type: "text", text }], source: { kind: "user" } }));
+      }
+    });
+    const installCheck = () => ctx.on("agent/turn-stopping", async (payload) => {
+      if (!await featureOn("check")) return;
+      return selfCheck.review({
+        agent: payload.agent,
+        turn: payload.turn,
+        signal: payload.signal,
+        output: lastAssistantText(payload.agent),
+        userText: turnUserText(payload.agent)
+      });
+    });
+    if (typeof ctx.effect === "function") ctx.effect(installCheck);
+    else installCheck();
+    const taskCompletion = createTaskCompletion({
+      evaluate: (input, request) => backend.evaluate(input, request),
+      sessions,
+      settings: async () => (await resolveConfig({ path })).completeSettings,
+      steer: (agent, text) => {
+        if (typeof agent.steer !== "function") throw new Error("Agent cannot be steered");
+        return agent.steer(createUserMessage({ content: [{ type: "text", text }], source: { kind: "user" } }));
+      }
+    });
+    const installCompletion = () => ctx.on("agent/turn-stopping", async (payload) => {
+      if (!await featureOn("complete")) return;
+      return taskCompletion.review({
+        agent: payload.agent,
+        turn: payload.turn,
+        signal: payload.signal,
+        output: lastAssistantText(payload.agent),
+        userText: turnUserText(payload.agent),
+        evidence: turnToolEvidence(payload.agent)
+      });
+    });
+    if (typeof ctx.effect === "function") ctx.effect(installCompletion);
+    else installCompletion();
+    const narrowing = createNarrowing({
+      evaluate: (input, request) => backend.evaluate(input, request),
+      sessions,
+      settings: async () => (await resolveConfig({ path })).narrowSettings
+    });
+    const narrowedTurns = /* @__PURE__ */ new Map();
+    const installNarrowingHook = () => ctx.on("agent/pre-step", async (payload, next) => {
+      const agent = payload?.agent;
+      const id = agent?.session?.id;
+      const turn = payload?.turn;
+      if (typeof id === "string") await sessions.ensureLoaded(id);
+      if (typeof id === "string" && Number.isInteger(turn)) {
+        const state = narrowedTurns.get(id);
+        if (!state || state.turn !== turn) {
+          state?.dispose?.();
+          narrowedTurns.delete(id);
+          if (await featureOn("narrow")) {
+            const entry = { turn, dispose: void 0 };
+            narrowedTurns.set(id, entry);
+            if (narrowedTurns.size > 1024) {
+              const oldest = narrowedTurns.keys().next().value;
+              if (oldest !== id) {
+                narrowedTurns.get(oldest)?.dispose?.();
+                narrowedTurns.delete(oldest);
+              }
+            }
+            try {
+              const result = await narrowing.review({
+                agent,
+                turn,
+                signal: payload.signal,
+                state: stepTaskText(payload.messages),
+                tools: agentTools(ctx, agent)
+              });
+              if (result.mode === "enforce" && result.applied && typeof agent?.ctx?.tools?.restrict === "function") {
+                entry.dispose = agent.ctx.tools.restrict({ allow: result.keep });
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      return next();
+    });
+    if (typeof ctx.effect === "function") ctx.effect(installNarrowingHook);
+    else installNarrowingHook();
+  }
+  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();
+  ctx.skills.register({ name: "decision-layer", description: "\u663E\u5F0F\u53D1\u8D77\u7ED3\u6784\u5316\u88C1\u51B3\uFF0C\u8F85\u52A9\u660E\u786E\u8FB9\u754C\u7684\u9009\u62E9\u4E0E\u8BC4\u5206\u3002", content, source: "bundled" });
+  const output = { schema: { type: "object", additionalProperties: true }, render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }] };
+  ctx.tools.register({
+    name: "decision_evaluate",
+    description: "\u5BF9 state \u548C questions \u6267\u884C\u4E00\u6B21\u663E\u5F0F\u7ED3\u6784\u5316\u88C1\u51B3\uFF0C\u4E0D\u4FEE\u6539 agent \u884C\u4E3A\u3002",
+    parameters: { type: "object", required: ["state", "questions"], properties: {
+      state: { oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }, { type: "array", items: {} }] },
+      questions: { type: "object", additionalProperties: { type: "object", additionalProperties: true } }
+    }, additionalProperties: false },
+    output,
+    timeoutMs: 25e3,
+    execute: (args, exec) => backend.evaluate(args, { signal: exec.signal })
+  });
+  ctx.tools.register({
+    name: "decision_check_connection",
+    description: "\u5411\u88C1\u51B3\u7AEF\u70B9\u53D1\u9001\u4E00\u6B21\u8F7B\u91CF\u8FDE\u901A\u6D4B\u8BD5\uFF0C\u4E0D\u589E\u52A0\u81EA\u52A8\u88C1\u51B3\u6307\u6807\u3002",
+    parameters: { type: "object", properties: {}, additionalProperties: false },
+    output,
+    timeoutMs: 25e3,
+    execute: async (_args, exec) => {
+      const result = await backend.evaluate({ state: "Connection test", questions: {
+        connected: { type: "noul", instructions: "Is this a connection test?" }
+      } }, { signal: exec.signal });
+      return { connected: true, model: result.model, usage: result.usage };
+    }
+  });
+  ctx.inject(["webServer"], (web) => {
+    logStore = createLogStore({ port: web.webServer.port });
+    const port = web.webServer.port;
+    const analyze = async (sessionId) => analyzeSessionLogs(sessionId, {
+      port,
+      trendConfig: (await resolveConfig({ path })).checkSettings
+    });
+    const listRows = (sessionId, { page, pageSize } = {}) => listSessionDecisions(sessionId, { port, page, pageSize });
+    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();
+    };
+  });
+}
+export {
+  apply,
+  inject,
+  name
+};

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

@@ -0,0 +1,121 @@
+import type { LogRow, SessionSeed, TrendConfig } from './types.js';
+export type PersistedRecord = Record<string, unknown>;
+export type Annotation = {
+    rating?: unknown;
+    at: number;
+};
+export type TrendBacktest = {
+    warnHits: number;
+    severeHits: number;
+    maxRun: number;
+};
+export declare function foldSession(records: Iterable<unknown>): {
+    decisions: Map<string, PersistedRecord>;
+    annotations: Map<string, Annotation>;
+};
+export type Profile = {
+    gate: {
+        attempts: number;
+        allow: number;
+        ask: number;
+        deny: number;
+        error: number;
+    };
+    check: {
+        attempts: number;
+        ok: number;
+        low: number;
+        error: number;
+        scoreSum: number;
+        scoreCount: number;
+        confidence: {
+            lt40: number;
+            lt60: number;
+            lt80: number;
+            gte80: number;
+        };
+    };
+    narrow: {
+        attempts: number;
+        applied: number;
+        error: number;
+        droppedSum: number;
+        tooManyCandidates: number;
+    };
+    complete: {
+        attempts: number;
+        satisfied: number;
+        unsatisfied: number;
+        insufficient: number;
+        error: number;
+        steered: 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;
+export declare function annotationSummary(decisions: ReadonlyMap<string, PersistedRecord>, annotations: ReadonlyMap<string, Annotation>): {
+    summary: {
+        rated: number;
+        good: number;
+        bad: number;
+        unsure: number;
+    };
+    ratings: Record<string, unknown>;
+};
+export declare function analyzeSession(records: Iterable<unknown>, trendConfig?: TrendConfig): {
+    totalDecisions: number;
+    profile: Profile;
+    trendBacktest: TrendBacktest;
+    annotations: {
+        rated: number;
+        good: number;
+        bad: number;
+        unsure: number;
+    };
+    ratings: Record<string, unknown>;
+};
+export type ReadStream = (options: {
+    dir?: string;
+    port?: number;
+}) => AsyncIterable<unknown>;
+export declare function analyzeSessionLogs(sessionId: unknown, { dir, port, trendConfig, readStream }?: {
+    dir?: string;
+    port?: number;
+    trendConfig?: TrendConfig;
+    readStream?: ReadStream;
+}): Promise<{
+    totalDecisions: number;
+    profile: Profile;
+    trendBacktest: TrendBacktest;
+    annotations: {
+        rated: number;
+        good: number;
+        bad: number;
+        unsure: number;
+    };
+    ratings: Record<string, unknown>;
+}>;
+export declare function buildSeed(decisions: ReadonlyMap<string, PersistedRecord>, { maxLog, trendConfig }?: {
+    maxLog?: number;
+    trendConfig?: TrendConfig;
+}): SessionSeed;
+export declare function reconstructSessionSeed(sessionId: unknown, { dir, port, trendConfig, maxLog, readStream }?: {
+    dir?: string;
+    port?: number;
+    trendConfig?: TrendConfig;
+    maxLog?: number;
+    readStream?: ReadStream;
+}): Promise<SessionSeed | undefined>;
+export declare function listSessionDecisions(sessionId: unknown, { dir, port, page, pageSize, readStream }?: {
+    dir?: string;
+    port?: number;
+    page?: number;
+    pageSize?: number;
+    readStream?: ReadStream;
+}): Promise<{
+    entries: LogRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+    pages: number;
+}>;

package/lib/host/log-analyze.js

@@ -0,0 +1,254 @@
+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"]);
+const atOf = (record) => {
+  const value = record.at;
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+};
+function foldSession(records) {
+  const decisions = /* @__PURE__ */ new Map();
+  const annotations = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!isObject(record)) continue;
+    if (record.kind === "annotation") {
+      const target = typeof record.target === "string" ? record.target : void 0;
+      if (!target) continue;
+      const prev = annotations.get(target);
+      if (!prev || Number.isFinite(record.at) && record.at >= (prev.at ?? 0)) {
+        annotations.set(target, { rating: record.rating, at: Number.isFinite(record.at) ? record.at : 0 });
+      }
+      continue;
+    }
+    if (DECISION_KINDS.has(record.kind) && typeof record.id === "string") {
+      decisions.set(record.id, record);
+    }
+  }
+  return { decisions, annotations };
+}
+function confidenceBucket(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  if (value < 0.4) return "lt40";
+  if (value < 0.6) return "lt60";
+  if (value < 0.8) return "lt80";
+  return "gte80";
+}
+function emptyProfile() {
+  return {
+    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 }
+  };
+}
+function buildProfile(decisions) {
+  const profile = emptyProfile();
+  const rows = decisions instanceof Map ? [...decisions.values()] : [...decisions];
+  for (const record of rows) {
+    const kind = record.kind;
+    switch (kind) {
+      case "gate": {
+        const bucket = profile.gate;
+        bucket.attempts++;
+        if (record.outcome === "error") bucket.error++;
+        else if (record.outcome === "allow") bucket.allow++;
+        else if (record.outcome === "ask") bucket.ask++;
+        else if (record.outcome === "deny") bucket.deny++;
+        break;
+      }
+      case "check": {
+        const bucket = profile.check;
+        bucket.attempts++;
+        if (record.outcome === "error") bucket.error++;
+        else if (record.outcome === "low") bucket.low++;
+        else bucket.ok++;
+        if (typeof record.score === "number" && Number.isFinite(record.score)) {
+          bucket.scoreSum += record.score;
+          bucket.scoreCount++;
+        }
+        const cb = confidenceBucket(record.confidence);
+        if (cb) bucket.confidence[cb]++;
+        break;
+      }
+      case "narrow": {
+        const bucket = profile.narrow;
+        bucket.attempts++;
+        if (record.outcome === "error") bucket.error++;
+        else if (narrowApplied(record)) bucket.applied++;
+        if (Number.isSafeInteger(record.dropped) && record.dropped > 0) bucket.droppedSum += record.dropped;
+        if (record.reason === "too-many-candidates") bucket.tooManyCandidates++;
+        break;
+      }
+      case "complete": {
+        const bucket = profile.complete;
+        bucket.attempts++;
+        if (record.outcome === "error") bucket.error++;
+        if (Number.isSafeInteger(record.satisfied)) bucket.satisfied += record.satisfied;
+        if (Number.isSafeInteger(record.unsatisfied)) bucket.unsatisfied += record.unsatisfied;
+        if (Number.isSafeInteger(record.insufficient)) bucket.insufficient += record.insufficient;
+        if (record.steered === true) bucket.steered++;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return profile;
+}
+function backtestTrend(checkRecords, { trendMinConfidence = 0.6, trendRun = 3, trendSevereRun = 5, lowScoreThreshold = 1 } = {}) {
+  const ordered = [...checkRecords].filter((record) => isObject(record) && record.kind === "check").sort((a, b) => atOf(a) - atOf(b));
+  let run = 0, warnHits = 0, severeHits = 0, maxRun = 0;
+  for (const record of ordered) {
+    if (record.outcome === "error") continue;
+    const isLow = record.outcome === "low" || typeof record.score === "number" && record.score <= lowScoreThreshold;
+    if (!isLow) {
+      run = 0;
+      continue;
+    }
+    const confident = typeof record.confidence === "number" && Number.isFinite(record.confidence) && record.confidence >= trendMinConfidence;
+    if (!confident) continue;
+    run++;
+    maxRun = Math.max(maxRun, run);
+    if (run === trendSevereRun) severeHits++;
+    else if (run === trendRun) warnHits++;
+  }
+  return { warnHits, severeHits, maxRun };
+}
+function annotationSummary(decisions, annotations) {
+  const summary = { rated: 0, good: 0, bad: 0, unsure: 0 };
+  const ratings = /* @__PURE__ */ Object.create(null);
+  for (const [id] of decisions) {
+    const annotation = annotations.get(id);
+    if (!annotation || typeof annotation.rating !== "string") continue;
+    summary.rated++;
+    if (annotation.rating === "good") summary.good++;
+    else if (annotation.rating === "bad") summary.bad++;
+    else if (annotation.rating === "unsure") summary.unsure++;
+    ratings[id] = annotation.rating;
+  }
+  return { summary, ratings };
+}
+function analyzeSession(records, trendConfig) {
+  const { decisions, annotations } = foldSession(records);
+  const annotation = annotationSummary(decisions, annotations);
+  return {
+    totalDecisions: decisions.size,
+    profile: buildProfile(decisions),
+    trendBacktest: backtestTrend([...decisions.values()], trendConfig),
+    annotations: annotation.summary,
+    ratings: annotation.ratings
+  };
+}
+async function analyzeSessionLogs(sessionId, { dir, port, trendConfig, readStream = createReadableStream } = {}) {
+  if (typeof sessionId !== "string" || !sessionId.trim()) throw new Error("Invalid session id");
+  const records = [];
+  for await (const record of readStream({ dir, port })) {
+    if (!isObject(record)) continue;
+    if (record.sessionId === sessionId) records.push(record);
+  }
+  return analyzeSession(records, trendConfig);
+}
+function buildSeed(decisions, { maxLog = 50, trendConfig = {} } = {}) {
+  const ordered = [...decisions.values()].filter((record) => DECISION_KINDS.has(record.kind)).sort((a, b) => atOf(a) - atOf(b));
+  const seed = {
+    attempts: 0,
+    failures: 0,
+    gate: { attempts: 0, failures: 0, ask: 0, deny: 0, allow: 0, actual: { allow: 0, deny: 0, error: 0 } },
+    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 },
+    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 isError = record.outcome === "error";
+    if (isError) seed.failures++;
+    if (record.kind === "gate") {
+      seed.gate.attempts++;
+      if (isError) seed.gate.failures++;
+      if (record.outcome === "allow") seed.gate.allow++;
+      else if (record.outcome === "ask") seed.gate.ask++;
+      else if (record.outcome === "deny") seed.gate.deny++;
+    } else if (record.kind === "check") {
+      seed.check.attempts++;
+      if (isError) seed.check.failures++;
+      if (!isError) {
+        if (record.outcome === "low") seed.check.low++;
+        const confident = typeof record.confidence === "number" && Number.isFinite(record.confidence) && record.confidence >= minConfidence;
+        run = advanceRun(run, { lowScore: record.outcome === "low", confident });
+      }
+    } else if (record.kind === "narrow") {
+      seed.narrow.attempts++;
+      if (isError) seed.narrow.failures++;
+      if (record.outcome === "applied") {
+        if (narrowApplied(record)) seed.narrow.applied++;
+        if (Number.isSafeInteger(record.dropped) && record.dropped > 0) seed.narrow.dropped += record.dropped;
+      }
+    } else if (record.kind === "complete") {
+      seed.complete.attempts++;
+      if (isError) seed.complete.failures++;
+      if (!isError) {
+        if (Number.isSafeInteger(record.satisfied)) seed.complete.satisfied += record.satisfied;
+        if (Number.isSafeInteger(record.unsatisfied)) seed.complete.unsatisfied += record.unsatisfied;
+        if (Number.isSafeInteger(record.insufficient)) seed.complete.insufficient += record.insufficient;
+        if (record.steered === true) seed.complete.steered++;
+      }
+    }
+  }
+  seed.check.run = run;
+  seed.check.severity = severityOf(run, thresholds);
+  seed.log = ordered.slice(-maxLog).map((record) => {
+    const rest = { ...record };
+    delete rest.sessionId;
+    return rest;
+  });
+  return seed;
+}
+async function reconstructSessionSeed(sessionId, { dir, port, trendConfig, maxLog, readStream = createReadableStream } = {}) {
+  if (typeof sessionId !== "string" || !sessionId.trim()) return void 0;
+  const records = [];
+  for await (const record of readStream({ dir, port })) {
+    if (!isObject(record)) continue;
+    if (record.sessionId === sessionId) records.push(record);
+  }
+  if (records.length === 0) return void 0;
+  const { decisions } = foldSession(records);
+  if (decisions.size === 0) return void 0;
+  return buildSeed(decisions, { maxLog, trendConfig });
+}
+async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize = 100, 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 = [];
+  for await (const record of readStream({ dir, port })) {
+    if (!isObject(record)) continue;
+    if (record.sessionId === sessionId) records.push(record);
+  }
+  const { decisions } = foldSession(records);
+  const rows = [...decisions.values()].sort((a, b) => atOf(b) - atOf(a));
+  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);
+  const start = (current - 1) * size;
+  const entries = rows.slice(start, start + size).map((record) => {
+    const rest = { ...record };
+    delete rest.sessionId;
+    return rest;
+  });
+  return { entries, total, page: current, pageSize: size, pages };
+}
+export {
+  analyzeSession,
+  analyzeSessionLogs,
+  annotationSummary,
+  backtestTrend,
+  buildProfile,
+  buildSeed,
+  foldSession,
+  listSessionDecisions,
+  reconstructSessionSeed
+};

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

@@ -0,0 +1,4 @@
+export declare function createReadableStream({ dir, port }?: {
+    dir?: string;
+    port?: number;
+}): AsyncGenerator<unknown>;