dsh-plugin-soulbridge 0.0.117 → 0.0.119

package/index.js

@@ -233,6 +233,70 @@ export function createTurnCostTracker({ threshold = TURN_REQUEST_ALERT, maxTurns
   };
 }
 
+/**
+ * When a session has grown past the point where starting a new one is cheaper (0026).
+ *
+ * The signal is prompt tokens per request — how much history every single call re-buys —
+ * with the turn count as the second axis. 300k is where the old session degraded; 100
+ * turns is where continuing stops being cheap even at a smaller context.
+ */
+const SWITCH_SESSION = { contextPerRequest: 300_000, turns: 100 };
+
+/** The reminder the model relays: the reply is the only channel the user reads. */
+export function renderSwitchSession(stats, perRequest) {
+  const thousands = Math.round(perRequest / 1000);
+  return (
+    `<switch-session turns="${stats.turns}" context-per-request="${Math.round(perRequest)}">` +
+    `这个会话已经很大（每请求约 ${thousands}k token 上下文，共 ${stats.turns} 轮）。` +
+    `请提醒用户：新开一个会话更省——先把进度写进 docs/state.md 的接手须知，` +
+    `再到新会话用「读 docs/state.md 的接手须知」开头。` +
+    `</switch-session>`
+  );
+}
+
+/**
+ * Per-session cost ledger. It answers one question: has this session crossed the point
+ * where a new one is cheaper, and has the user been told yet?
+ *
+ * Not a nag: the reminder fires once per level, and a level is one more notch of the
+ * same threshold (600k/req or 200 turns is level 2). Crossing again by a doubling is
+ * worth saying again; saying it every turn is wallpaper.
+ */
+export function createSessionLedger({ thresholds = SWITCH_SESSION } = {}) {
+  const cost = new Map();
+  const reminded = new Map();
+  return {
+    /** Feed one finished turn — the turn-cost report. */
+    note(record) {
+      const id = String(record?.session ?? 'default');
+      const stats = cost.get(id) ?? { turns: 0, requests: 0, prompt: 0 };
+      stats.turns += 1;
+      stats.requests += Number(record?.requests) || 0;
+      stats.prompt +=
+        (Number(record?.input) || 0) + (Number(record?.cacheHit) || 0) + (Number(record?.cacheWrite) || 0);
+      cost.set(id, stats);
+      // Bounded like the tracker: a long-lived host must not accumulate sessions forever.
+      if (cost.size > 16) cost.delete(cost.keys().next().value);
+    },
+    /** The reminder block when a new level is crossed; '' otherwise. */
+    due(sessionId) {
+      const id = String(sessionId ?? 'default');
+      const stats = cost.get(id);
+      if (!stats || stats.requests === 0) return '';
+      const perRequest = stats.prompt / stats.requests;
+      const level = Math.floor(
+        Math.max(perRequest / thresholds.contextPerRequest, stats.turns / thresholds.turns),
+      );
+      if (level < 1 || level <= (reminded.get(id) ?? 0)) return '';
+      reminded.set(id, level);
+      return renderSwitchSession(stats, perRequest);
+    },
+  };
+}
+
+/** One ledger for the running host: a session is remembered across pre-steps. */
+const sessionLedger = createSessionLedger();
+
 /** Prompt assembly can run several times per step; do not hit SQLite every time. */
 
 /**
@@ -989,42 +1053,64 @@ export async function runStageChain(stages) {
   return false;
 }
 
-export function createPreStepHandler(deps) {
-  /** sessionId -> last turn that received an injection */
-  const injectedTurn = new Map();
-  /** Sessions that already got the handoff block once. */
+/**
+ * The handoff consumer: at most one NON-EMPTY block per session.
+ *
+ * Deliberately once per session and only when the topic belongs to a
+ * different session — repeating it every turn would make it wallpaper, and
+ * re-reading the previous session's own topic is not a handoff.
+ *
+ * The read is injected so tests can drive the consumption contract without a
+ * database. An EMPTY read does NOT consume the slot: a new session's first
+ * turn often reads empty because the previous segment has not been flushed
+ * yet (0028 decision 4 — handoff is a render, not a one-shot trigger), and
+ * forfeiting then would drop the one chance this session has to be told where
+ * it came from. A throwing read also leaves the slot open, as before.
+ */
+export function createHandoffTaker(readShot, logger, tracer) {
+  /** Sessions that already received a non-empty handoff block. */
   const handedOff = new Set();
-
-  /**
-   * The "where were we" block: the last topic that finished.
-   *
-   * Deliberately once per session and only when that topic belongs to a
-   * different session — repeating it every turn would make it wallpaper, and
-   * re-reading the previous session's own topic is not a handoff.
-   */
-  function takeHandoff(sessionId) {
+  return (sessionId) => {
     if (handedOff.has(sessionId)) return '';
     try {
-      const last = ensureSoul().lastClosedThread();
-      const block = renderHandoff(last, sessionId);
-      // Only mark it once the read succeeded: a transient failure on the first turn
-      // used to exclude the session from handoff forever.
-      handedOff.add(sessionId);
-      if (block) {
-        log(`handoff: "${last.thread.topic}" summary=${last.conclusion ? 'yes' : 'no'}`);
-        trace({
+      const shot = readShot(sessionId);
+      if (shot.block) {
+        handedOff.add(sessionId);
+        logger(`handoff: "${shot.topic}" summary=${shot.summary ? 'yes' : 'no'}`);
+        tracer({
           event: 'handoff',
-          thread: last.thread.id,
-          theme: last.thread.topic,
-          hasSummary: Boolean(last.conclusion),
+          thread: shot.thread,
+          theme: shot.topic,
+          hasSummary: shot.summary,
         });
       }
-      return block;
+      return shot.block;
     } catch (error) {
-      log(`handoff failed (will retry next turn): ${error instanceof Error ? error.message : String(error)}`);
+      logger(`handoff failed (will retry next turn): ${error instanceof Error ? error.message : String(error)}`);
       return '';
     }
-  }
+  };
+}
+
+export function createPreStepHandler(deps) {
+  /** sessionId -> last turn that received an injection */
+  const injectedTurn = new Map();
+
+  // "Where were we": one non-empty block per session, retried until it ships.
+  // The reader goes through ensureSoul() so the live store is read at call time.
+  const takeHandoff = createHandoffTaker(
+    (sessionId) => {
+      const last = ensureSoul().lastClosedThread();
+      return {
+        block: renderHandoff(last, sessionId),
+        thread: last?.thread?.id,
+        topic: last?.thread?.topic,
+        summary: Boolean(last?.conclusion),
+      };
+    },
+    log,
+    trace,
+  );
 
   return async (payload, next) => {
     const decision = await next();
@@ -1147,7 +1233,10 @@ export function createPreStepHandler(deps) {
       // previous session: one session can hold several topics, and a topic can
       // span sessions. Injected once per session, when it is a different one.
       const handoff = takeHandoff(sessionId);
-      const block = [handoff, related].filter(Boolean).join('\n\n');
+      // 0026: when this session has already grown past the point where a new one is
+      // cheaper, say so once per level — the reply is the only channel the user reads.
+      const switchHint = sessionLedger.due(sessionId);
+      const block = [handoff, switchHint, related].filter(Boolean).join('\n\n');
       injectedTurn.set(sessionId, turn);
       if (injectedTurn.size > 16) {
         // Keep the map bounded: drop the oldest entry, not the newest.
@@ -1168,6 +1257,10 @@ export function createPreStepHandler(deps) {
       const idPart = used.length > 0 ? ` ids=[${used.join(',')}]` : '';
       log(`prestep: inject turn=${turn} chars=${block.length}${idPart} handoff=${handoff ? 'yes' : 'no'}`);
       trace({ event: 'inject', session: sessionId, turn, chars: block.length, ids: used, handoff: Boolean(handoff) });
+      if (switchHint) {
+        log(`switch-session: remind turn=${turn}`);
+        trace({ event: 'switch_session', session: sessionId, turn });
+      }
       return { ...decision, messages: [...decision.messages, note] };
     } catch (error) {
       log(`prestep: skipped after error: ${error instanceof Error ? error.message : String(error)}`);
@@ -1424,8 +1517,10 @@ async function runExtraction(text, turnId, turnNo, origin = 'live', thread = nul
     // Provenance is observable (ADR 0035): the fact count alone cannot tell whether
     // anything came from my side of the exchange.
     const inferred = result.facts.filter((fact) => fact.source === 'inferred').length;
+    // "done", not "ok": the caller decides the queue outcome next (rules:model-failed
+    // is NOT ok), and the old prefix read as success in every log review.
     log(
-      `extract ok: by=${draft.by} reason=${draft.reason ?? '-'} entities=${result.entities.length} facts=${result.facts.length}` +
+      `extract done: by=${draft.by} reason=${draft.reason ?? '-'} entities=${result.entities.length} facts=${result.facts.length}` +
         ` gaps=${result.gaps.length} skipped=${result.skipped.length} draftSkipped=${(draft.skipped ?? []).length}` +
         ` slots->text=${result.droppedSlots.length} holder->world=${result.holderFallbacks.length}` +
         ` inferred=${inferred}` +
@@ -2523,7 +2618,12 @@ export function apply(ctx) {
   // reaches the threshold also gets one line in plugin.log. Attached before the
   // event listener so no turn can be missed.
   turnCostTracker = createTurnCostTracker({
-    onReport: (record) => trace(record),
+    onReport: (record) => {
+      trace(record);
+      // 0026 reminder: the same record that makes a turn visible also answers
+      // "is this session too big to keep going".
+      sessionLedger.note(record);
+    },
     onAlert: (line) => log(line),
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-soulbridge",
-  "version": "0.0.117",
+  "version": "0.0.119",
   "description": "Inject soulbridge context into DSH sessions and feed user turns back as observations.",
   "type": "module",
   "main": "index.js",