dsh-decision-layer 0.7.1 → 0.7.2

package/service/dsh.mjs

@@ -1,288 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { resolveConfig, featureEnabled } from './config-store.mjs';
-import { createBackend } from './backend.mjs';
-import { createManagerRoutes } from './manager-api.mjs';
-import { createSessionState } from './session-state.mjs';
-import { createDangerGate, normalizeDangerRules } from './danger-gate.mjs';
-import { createSelfCheck } from './self-check.mjs';
-import { createNarrowing } from './narrowing.mjs';
-import { createTaskCompletion } from './task-completion.mjs';
-import { createLoopGuard } from './loop-guard.mjs';
-import { createLogStore } from './log-store.mjs';
-import { createStateStore } from './state-store.mjs';
-import { analyzeSessionLogs, reconstructSessionSeed, listSessionDecisions } from './log-analyze.mjs';
-
-export const name = 'dsh-decision-layer';
-export const inject = ['tools', 'skills'];
-
-// Best-effort extraction of the turn's final assistant text. The self-check
-// treats empty output as "skip", so an unreachable shape degrades safely.
-function lastAssistantText(agent) {
-  try {
-    const messages = agent?.session?.deriveMessages?.();
-    if (!Array.isArray(messages)) return '';
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const message = messages[i];
-      if (message?.role !== 'assistant' || !Array.isArray(message.content)) continue;
-      return message.content.filter(block => block?.type === 'text' && typeof block.text === 'string').map(block => block.text).join('');
-    }
-    return '';
-  } catch { return ''; }
-}
-
-// The task text a narrowing pass judges tools against: the user messages
-// entering this step. An unreachable shape yields '', which skips narrowing.
-function stepTaskText(messages) {
-  try {
-    if (!Array.isArray(messages)) return '';
-    return messages
-      .filter(message => message?.role === 'user' && Array.isArray(message.content))
-      .flatMap(message => message.content.filter(block => block?.type === 'text' && typeof block.text === 'string').map(block => block.text))
-      .join('\n').slice(0, 8 * 1024);
-  } catch { return ''; }
-}
-
-// The user's request text for this turn, used by task-completion to extract the
-// explicit conditions. Best-effort: an unreachable shape yields '', which skips
-// the check. Takes the trailing run of user messages (the prompt entering the turn).
-function turnUserText(agent) {
-  try {
-    const messages = agent?.session?.deriveMessages?.();
-    if (!Array.isArray(messages)) return '';
-    const texts = [];
-    let collecting = false;
-    // Walk backwards: skip the turn's trailing assistant/tool messages, collect the
-    // contiguous user run that started this turn, then stop at the prior assistant.
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const message = messages[i];
-      if (message?.role === 'user' && Array.isArray(message.content)) {
-        collecting = true;
-        texts.unshift(message.content.filter(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 ''; }
-}
-
-// Tool evidence for the turn's task-completion check: the tool calls and their
-// ok/error outcome from the derived history. Names only (no arguments), bounded.
-// An unreachable shape yields [], which skips the check.
-function turnToolEvidence(agent) {
-  try {
-    const messages = agent?.session?.deriveMessages?.();
-    if (!Array.isArray(messages)) return [];
-    const evidence = [];
-    for (const message of messages) {
-      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 []; }
-}
-
-// Enumerate the tool names/descriptions visible to this agent scope, best-effort.
-function agentTools(ctx, agent) {
-  try {
-    const schemas = typeof ctx.tools?.schemas === 'function' ? ctx.tools.schemas(agent) : undefined;
-    if (!Array.isArray(schemas)) return [];
-    return schemas
-      .filter(schema => schema && typeof schema.name === 'string')
-      .map(schema => ({ name: schema.name, description: typeof schema.description === 'string' ? schema.description : '' }));
-  } catch { return []; }
-}
-
-export async function apply(ctx, options = {}) {
-  const path = options.configPath;
-  const backend = createBackend({ config: () => resolveConfig({ path }) });
-  // The research log sink is attached once the web server reveals the instance
-  // port (used in the file name); until then decision logs stay in memory only.
-  let logStore;
-  // Durable per-session mirror of the live decision counters/log, keyed by
-  // session id (not port), so a resumed session's panel survives an instance
-  // restart instead of resetting to zero. Independent of the JSONL research log.
-  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(() => undefined),
-    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,
-  });
-  const loopGuard = createLoopGuard({ sessions });
-  // Live per-feature enablement; every decision point defaults to enabled.
-  // An invalid config must not fail every tool call: these hooks run inside the
-  // host's tools/pre-execute waterfall, which converts a throw into a failed call
-  // (the tool never dispatches, so `read`/`edit` can no longer repair the file).
-  // An unreadable config therefore degrades to "all features on", and each
-  // decision point keeps its own safe fallback (the gate falls back to 0.6 and
-  // the built-in rules), so the safety net stays armed instead of the agent
-  // losing every tool.
-  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') {
-      // Deterministic loop guard runs with no backend; then the dangerous-gate
-      // monotonic denial. Guards can only deny, never re-allow.
-      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) => 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) => agent.steer(createUserMessage({
-        content: [{ type: 'text', text }],
-        source: { kind: 'user' },
-      })),
-    });
-    // Independent turn-stopping listener, separate from the self-check: it checks
-    // whether the user's explicit conditions have supporting tool evidence.
-    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,
-    });
-    // Narrow once per turn, on its first step, and only enforce a restriction in
-    // enforce mode. The restriction is agent-scoped and lifted before the next
-    // turn's pass so a later turn is judged against the full host-allowed set.
-    const narrowedTurns = 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;
-      // Rehydrate this session's persisted counters/log on its first step this
-      // process, before any gate/check/narrow/complete event mutates them, so a
-      // resumed session continues from its saved totals instead of from zero.
-      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) {
-          // Release the previous turn's restriction first: restrict is agent-scoped
-          // and stays in force until disposed, so a turn where narrowing is now off
-          // must not inherit the earlier allow-list.
-          state?.dispose?.();
-          narrowedTurns.delete(id);
-          if (await featureOn('narrow')) {
-            const entry = { turn, dispose: undefined };
-            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 { /* narrowing is best effort; never block the step */ }
-          }
-        }
-      }
-      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: '显式发起结构化裁决，辅助明确边界的选择与评分。', 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: '对 state 和 questions 执行一次显式结构化裁决，不修改 agent 行为。',
-    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: 25_000,
-    execute: (args, exec) => backend.evaluate(args, { signal: exec.signal }),
-  });
-  ctx.tools.register({
-    name: 'decision_check_connection', description: '向裁决端点发送一次轻量连通测试，不增加自动裁决指标。',
-    parameters: { type: 'object', properties: {}, additionalProperties: false }, output, timeoutMs: 25_000,
-    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 = undefined; void store?.dispose(); };
-  });
-}

package/service/log-analyze.mjs

@@ -1,257 +0,0 @@
-import { createReadableStream } from './log-read.mjs';
-import { advanceRun, severityOf } from './quality-trend.mjs';
-import { narrowApplied } from './narrowing.mjs';
-
-// Offline analysis over the persisted decision JSONL logs. Pure aggregation:
-// given a stream of records (decision events + annotation events) for one
-// session, fold annotations onto decisions by id (latest wins) and build a
-// process-metrics profile plus a quality-trend threshold backtest.
-//
-// Reading is separated (log-read.mjs) so this module stays pure and testable
-// without touching the filesystem.
-
-const DECISION_KINDS = new Set(['gate', 'check', 'narrow', 'complete']);
-const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
-
-// Reduce one session's records into decisions (with the latest annotation
-// attached) and per-kind aggregates. `records` is any iterable of parsed rows.
-export function foldSession(records) {
-  const decisions = new Map();          // id → decision record
-  const annotations = new Map();        // target id → latest annotation
-  for (const record of records) {
-    if (!isObject(record)) continue;
-    if (record.kind === 'annotation') {
-      const target = typeof record.target === 'string' ? record.target : undefined;
-      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 };
-}
-
-// A confidence bucket label for the [0,1] range, coarse enough to be useful.
-function confidenceBucket(value) {
-  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined;
-  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 },
-  };
-}
-
-// Build the process-metrics profile from the folded decisions. Clean denominators:
-// each `attempts` counts real evaluations of that kind; averages (e.g. mean
-// dropped) are reported as-is, never mislabeled as percentages.
-export function buildProfile(decisions) {
-  const profile = emptyProfile();
-  for (const record of decisions.values()) {
-    const kind = record.kind;
-    const bucket = profile[kind];
-    if (!bucket) continue;
-    bucket.attempts++;
-    if (kind === 'gate') {
-      if (record.outcome === 'error') bucket.error++;
-      else if (['allow', 'ask', 'deny'].includes(record.outcome)) bucket[record.outcome]++;
-    } else if (kind === 'check') {
-      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]++;
-    } else if (kind === 'narrow') {
-      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++;
-    } else if (kind === 'complete') {
-      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++;
-    }
-  }
-  return profile;
-}
-
-// Replay the quality-trend thresholds over this session's check records in time
-// order: how many times would the alarm have fired at warn / severe? Uses the
-// same run semantics as quality-trend.mjs (good resets, high-confidence low
-// grows, low-confidence low and non-low are skipped for the run — but a good
-// score still resets). This is a calibration aid, not a live signal.
-export function backtestTrend(checkRecords, { trendMinConfidence = 0.6, trendRun = 3, trendSevereRun = 5, lowScoreThreshold = 1 } = {}) {
-  const ordered = [...checkRecords].filter(r => isObject(r) && r.kind === 'check').sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
-  let run = 0, warnHits = 0, severeHits = 0, maxRun = 0;
-  for (const record of ordered) {
-    if (record.outcome === 'error') continue; // unevaluated: skip
-    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; // low-confidence low: skip, run unchanged
-    run++;
-    maxRun = Math.max(maxRun, run);
-    if (run === trendSevereRun) severeHits++;
-    else if (run === trendRun) warnHits++;
-  }
-  return { warnHits, severeHits, maxRun };
-}
-
-// Attach annotation summary: how many decisions carry a good/bad/unsure rating.
-// Also returns a per-decision ratings map (id → rating) so a UI can show the
-// persisted annotation state on each decision, whichever surface renders it.
-export function annotationSummary(decisions, annotations) {
-  const summary = { rated: 0, good: 0, bad: 0, unsure: 0 };
-  const ratings = 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 };
-}
-
-// One-call analysis over an iterable of records for a single session.
-export 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,
-  };
-}
-
-// Read the persisted logs for one session id and analyze them. Streams files so
-// a large corpus is never fully buffered; only rows whose sessionId matches are
-// kept. `readStream` is injected for tests; production reads the logs dir.
-export 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);
-}
-
-// Reconstruct a live session-state seed (the counter shape session-state keeps,
-// plus the recent decision log) from this session's folded decisions. Used to
-// bridge a restart for a session that has persisted JSONL history but no state
-// snapshot yet, so its panel resumes from its real totals instead of from zero.
-//
-// Faithful for every counter because each feature logs exactly one record per
-// record*() call with the same outcome — with one documented exception:
-// gate.actual (observed tool outcomes) is never logged, so it starts at zero and
-// resumes as new tool results arrive. The check trend run/severity is replayed
-// with the same advanceRun/severityOf semantics the live path uses.
-export function buildSeed(decisions, { maxLog = 50, trendConfig = {} } = {}) {
-  const ordered = [...decisions.values()].filter(record => DECISION_KINDS.has(record.kind)).sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
-  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) {
-    const bucket = seed[record.kind];
-    seed.attempts++;
-    bucket.attempts++;
-    const isError = record.outcome === 'error';
-    if (isError) { seed.failures++; bucket.failures++; }
-    if (record.kind === 'gate') {
-      if (['allow', 'ask', 'deny'].includes(record.outcome)) bucket[record.outcome]++;
-    } else if (record.kind === 'check') {
-      if (!isError) {
-        if (record.outcome === 'low') bucket.low++;
-        // Replay the trend run exactly as recordCheck does: lowScore keys off the
-        // 'low' outcome, confident off the logged confidence vs the threshold.
-        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') {
-      if (record.outcome === 'applied') {
-        if (narrowApplied(record)) bucket.applied++;
-        if (Number.isSafeInteger(record.dropped) && record.dropped > 0) bucket.dropped += record.dropped;
-      }
-    } else if (record.kind === 'complete') {
-      if (!isError) {
-        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++;
-      }
-    }
-  }
-  seed.check.run = run;
-  seed.check.severity = severityOf(run, thresholds);
-  // The recent-log list: the newest decisions, as plain records (drop sessionId,
-  // which the live log does not carry). Already in the panel-record shape.
-  seed.log = ordered.slice(-maxLog).map(record => { const { sessionId, ...rest } = record; return rest; });
-  return seed;
-}
-
-// Read one session's persisted JSONL and reconstruct its live state seed, or
-// undefined when it has no decision history. Streams files like analyzeSessionLogs.
-export async function reconstructSessionSeed(sessionId, { dir, port, trendConfig, maxLog, readStream = createReadableStream } = {}) {
-  if (typeof sessionId !== 'string' || !sessionId.trim()) return undefined;
-  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 undefined;
-  const { decisions } = foldSession(records);
-  if (decisions.size === 0) return undefined;
-  return buildSeed(decisions, { maxLog, trendConfig });
-}
-
-// Read one session's persisted decision rows and return a single newest-first
-// page. Backs the analysis tab's full decision log (the dock panel still shows
-// only the in-memory recent rows). Decisions are folded by id (latest wins) so a
-// re-logged id is not double-counted. Rows carry only the panel fields, including
-// the gate's redacted, length-bounded command/path. The internal sessionId tag is
-// stripped before the row leaves the server.
-export 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) => (b.at ?? 0) - (a.at ?? 0)); // newest first
-  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(({ sessionId: _sessionId, ...rest }) => rest);
-  return { entries, total, page: current, pageSize: size, pages };
-}

package/service/log-read.mjs

@@ -1,27 +0,0 @@
-import { createReadStream } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { createInterface } from 'node:readline';
-import { join } from 'node:path';
-import { logsDir } from './log-store.mjs';
-
-// Stream the persisted decision JSONL logs line by line, yielding one parsed
-// record per line. Files are read sequentially so a large corpus is never fully
-// buffered. A malformed line is skipped, not fatal. Only this port's files are
-// read when `port` is given (matching the log-store naming); otherwise all
-// `decisions-*.jsonl` files are read.
-export async function* createReadableStream({ dir = logsDir(), port } = {}) {
-  const prefix = Number.isInteger(port) && port > 0 ? `decisions-${port}-` : 'decisions-';
-  let names;
-  try { names = await readdir(dir); } catch { return; }
-  const files = names.filter(name => name.startsWith(prefix) && name.endsWith('.jsonl')).sort();
-  for (const name of files) {
-    const stream = createReadStream(join(dir, name), { encoding: 'utf8' });
-    const lines = createInterface({ input: stream, crlfDelay: Infinity });
-    try {
-      for await (const line of lines) {
-        if (!line.trim()) continue;
-        try { yield JSON.parse(line); } catch { /* skip malformed line */ }
-      }
-    } finally { lines.close(); stream.close(); }
-  }
-}

package/service/log-store.mjs

@@ -1,82 +0,0 @@
-import { mkdir, appendFile, readdir, rm } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-
-export function logsDir() {
-  return join(homedir(), '.config', 'dsh-decision-layer', 'logs');
-}
-
-const dayStamp = date => date.toISOString().slice(0, 10);
-
-// Batched, rolling JSONL log writer keyed by the running instance's port. One
-// file per UTC day: `decisions-<port>-YYYY-MM-DD.jsonl`. Entries are buffered and
-// flushed on an interval or when the buffer fills; every flush prunes this port's
-// files older than the retention window. Writing is best-effort: a failed flush
-// drops that batch rather than throwing into the decision path.
-export function createLogStore({ port, dir = logsDir(), flushIntervalMs = 5000,
-  maxBuffer = 200, retentionDays = 30, now = () => new Date() } = {}) {
-  const safePort = Number.isInteger(port) && port > 0 && port < 65536 ? port : 0;
-  const prefix = `decisions-${safePort}-`;
-  let buffer = [];
-  let timer;
-  let flushing = false;
-
-  const fileFor = date => join(dir, `${prefix}${dayStamp(date)}.jsonl`);
-
-  const prune = async () => {
-    let names;
-    try { names = await readdir(dir); } catch { return; }
-    const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000;
-    await Promise.all(names.map(async name => {
-      if (!name.startsWith(prefix) || !name.endsWith('.jsonl')) return;
-      const stamp = name.slice(prefix.length, -'.jsonl'.length);
-      const day = Date.parse(`${stamp}T00:00:00Z`);
-      if (Number.isFinite(day) && day < cutoff) await rm(join(dir, name), { force: true }).catch(() => {});
-    }));
-  };
-
-  const flush = async () => {
-    if (flushing || buffer.length === 0) return;
-    flushing = true;
-    const pending = buffer;
-    buffer = [];
-    try {
-      await mkdir(dir, { recursive: true, mode: 0o700 });
-      const byFile = new Map();
-      for (const entry of pending) {
-        const at = Number.isFinite(entry?.at) ? entry.at : now().getTime();
-        const file = fileFor(new Date(at));
-        (byFile.get(file) ?? byFile.set(file, []).get(file)).push(`${JSON.stringify(entry)}\n`);
-      }
-      for (const [file, lines] of byFile) await appendFile(file, lines.join(''), { mode: 0o600 });
-      await prune();
-    } catch { /* best effort; a dropped batch must never break the decision path */ }
-    finally { flushing = false; }
-  };
-
-  return {
-    append(entry) {
-      if (entry === null || typeof entry !== 'object') return;
-      buffer.push(entry);
-      if (buffer.length >= maxBuffer) { void flush(); return; }
-      if (!timer) timer = setTimeout(() => { timer = undefined; void flush(); }, flushIntervalMs);
-    },
-    // An annotation is an explicit user action, not telemetry: write it
-    // immediately (not batched) and surface failure to the caller instead of
-    // dropping it. It lands in the same JSONL directory as a `kind:"annotation"`
-    // event and is pruned with the decision logs on the next flush.
-    async appendAnnotation(entry) {
-      if (entry === null || typeof entry !== 'object') throw new Error('Invalid annotation');
-      const at = Number.isFinite(entry.at) ? entry.at : now().getTime();
-      const record = { ...entry, at };
-      await mkdir(dir, { recursive: true, mode: 0o700 });
-      await appendFile(fileFor(new Date(at)), `${JSON.stringify(record)}\n`, { mode: 0o600 });
-      return record;
-    },
-    flush,
-    dispose() {
-      if (timer) { clearTimeout(timer); timer = undefined; }
-      return flush();
-    },
-  };
-}