dsh-plugin-soulbridge 0.0.120 → 0.0.122

package/index.js

@@ -242,27 +242,65 @@ export function createTurnCostTracker({ threshold = TURN_REQUEST_ALERT, maxTurns
  */
 const SWITCH_SESSION = { contextPerRequest: 300_000, turns: 100 };
 
-/** The reminder the model relays: the reply is the only channel the user reads. */
+/** The 0018 compact line: the same signal one notch earlier — compact before switching. */
+const CONTEXT_COMPACT = { contextPerRequest: 200_000 };
+
+/** The advice the model relays: the reply is the only channel the user reads. */
+export function renderContextCompact(stats, perRequest) {
+  const thousands = Math.round(perRequest / 1000);
+  return (
+    `<proactive id="context-compact" context-per-request="${Math.round(perRequest)}">` +
+    `上下文已经到每请求约 ${thousands}k token。请在合适处告诉用户一句：现在适合 /compact 续命——` +
+    `他的习惯是留在本会话压缩、不换新会话；若正在收口，压缩前先把进度写进 docs/state.md。` +
+    `提这一次即可，不要每轮重复。` +
+    `</proactive>`
+  );
+}
+
 export function renderSwitchSession(stats, perRequest) {
   const thousands = Math.round(perRequest / 1000);
   return (
-    `<switch-session turns="${stats.turns}" context-per-request="${Math.round(perRequest)}">` +
+    `<proactive id="switch-session" turns="${stats.turns}" context-per-request="${Math.round(perRequest)}">` +
     `这个会话已经很大（每请求约 ${thousands}k token 上下文，共 ${stats.turns} 轮）。` +
-    `请提醒用户：新开一个会话更省——先把进度写进 docs/state.md 的接手须知，` +
+    `请提醒用户：优先 /compact 续命；若已反复压缩或明显变慢，再新开会话——` +
+    `新开前先把进度写进 docs/state.md 的接手须知，` +
     `再到新会话用「读 docs/state.md 的接手须知」开头。` +
-    `</switch-session>`
+    `</proactive>`
   );
 }
 
 /**
- * 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?
+ * 0018 proactive triggers — declarative rows. A new habit is a new row; needing a new
+ * code path means the framework failed (0018 §0 acceptance line). Each row carries an
+ * id, the action kind (four choices, default silent — every row here is asking), a
+ * level over the session ledger, and the block to relay. v1 cost-gate = level crossing
+ * + once per level; saying it every turn is wallpaper.
+ */
+export const PROACTIVE_TRIGGERS = [
+  {
+    id: 'context-compact',
+    action: 'asking',
+    level: (stats, perRequest) => Math.floor(perRequest / CONTEXT_COMPACT.contextPerRequest),
+    render: (stats, perRequest) => renderContextCompact(stats, perRequest),
+  },
+  {
+    id: 'switch-session',
+    action: 'asking',
+    level: (stats, perRequest) =>
+      Math.floor(Math.max(perRequest / SWITCH_SESSION.contextPerRequest, stats.turns / SWITCH_SESSION.turns)),
+    render: (stats, perRequest) => renderSwitchSession(stats, perRequest),
+  },
+];
+
+/**
+ * Per-session cost ledger. It answers one question: has this session crossed a line
+ * where advice is worth saying, 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.
+ * Rows fire in registry order, each once per level: 200k suggests compact (0018 first
+ * slice), 300k/100 turns still says switch — compact first, switching is the fallback.
+ * Crossing again by a doubling is worth saying again; saying it every turn is wallpaper.
  */
-export function createSessionLedger({ thresholds = SWITCH_SESSION } = {}) {
+export function createSessionLedger({ triggers = PROACTIVE_TRIGGERS } = {}) {
   const cost = new Map();
   const reminded = new Map();
   return {
@@ -278,18 +316,24 @@ export function createSessionLedger({ thresholds = SWITCH_SESSION } = {}) {
       // 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. */
+    /** The advice when a row crosses a new level; null otherwise. */
     due(sessionId) {
       const id = String(sessionId ?? 'default');
       const stats = cost.get(id);
-      if (!stats || stats.requests === 0) return '';
+      if (!stats || stats.requests === 0) return null;
       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);
+      for (const trigger of triggers) {
+        const level = trigger.level(stats, perRequest);
+        if (level < 1 || level <= (reminded.get(`${id}:${trigger.id}`) ?? 0)) continue;
+        reminded.set(`${id}:${trigger.id}`, level);
+        return {
+          id: trigger.id,
+          action: trigger.action,
+          block: trigger.render(stats, perRequest),
+          trigger: Math.round(perRequest),
+        };
+      }
+      return null;
     },
   };
 }
@@ -1241,10 +1285,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);
-      // 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');
+      // 0018: proactive advice — declarative rows fire once per level; the reply is
+      // the only channel the user reads.
+      const proactive = sessionLedger.due(sessionId);
+      const block = [handoff, proactive?.block ?? '', 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.
@@ -1265,9 +1309,9 @@ 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 });
+      if (proactive) {
+        log(`proactive: remind id=${proactive.id} turn=${turn} trigger=${proactive.trigger}`);
+        trace({ event: 'proactive', id: proactive.id, action: proactive.action, session: sessionId, turn, trigger: proactive.trigger });
       }
       return { ...decision, messages: [...decision.messages, note] };
     } catch (error) {
@@ -1624,19 +1668,19 @@ function hasSubstance(text) {
 }
 
 /**
- * Extract one unit: a segment (0028), or a single message when there is no segment.
- *
- * `unit` carries the prompt-numbered turns; the attribution the model returns is
- * a product of this call, never an input to it (决定 3). `turnId`/`turnNo` are the
- * segment HEAD — the continuity point before the unit — and the fallback source
- * for facts the model did not number.
+ * Extract one unit: the segment a departure flushed (0028) — required, there is
+ * no single-message mode anymore (retirements extract-per-turn): an unflushed
+ * turn waits for its departure. `unit` carries the prompt-numbered turns; the
+ * attribution the model returns is a product of this call, never an input to it
+ * (决定 3). `turnId`/`turnNo` are the segment HEAD — the continuity point before
+ * the unit — and the fallback source for facts the model did not number.
  */
-async function runExtraction(text, turnId, turnNo, origin = 'live', unit = null) {
+async function runExtraction(text, turnId, turnNo, origin = 'live', unit) {
   const config = readConfig();
   if (config.extract === 'off') return 'skipped-off';
   // The unit decides, not its last message: a segment whose final turn is "好的"
   // still holds every turn above it, and taking the unit or none of it is rule 17.
-  const unitTexts = unit?.turns?.length ? unit.turns.map((entry) => entry.userText) : [text];
+  const unitTexts = unit.turns.map((entry) => entry.userText);
   if (typeof text !== 'string' || !unitTexts.some((entry) => typeof entry === 'string' && hasSubstance(entry))) {
     log(
       `extract skipped: no substance (chars=${unitTexts.reduce((n, entry) => n + (typeof entry === 'string' ? entry.length : 0), 0)})` +
@@ -1650,7 +1694,7 @@ async function runExtraction(text, turnId, turnNo, origin = 'live', unit = null)
     const soul = ensureSoul();
     const turnRow = soul.turn(turnId);
     // The context carries both halves of continuity (ADR 0034): the candidates' last
-    // lines, and the previous user line — extraction is per turn, so without it the
+    // lines, and the previous user line — the unit is a segment, so without them the
     // model cannot tell "继续" from a new subject.
     const context = soul.extractionContext(20, { turnNo, sessionId: turnRow?.sessionId });
     // "The previous turn belonged to this thread" is the cheapest continuity hint
@@ -1662,8 +1706,8 @@ async function runExtraction(text, turnId, turnNo, origin = 'live', unit = null)
     // 0028: the unit is the segment a departure flushed. The turns array is
     // numbered the way the prompt numbers them (1..n inside the unit), and each
     // fact may name its own turn — turnIds maps that number back to the real turn.
-    const turns = unit?.turns ?? null;
-    const turnIds = turns ? Object.fromEntries(turns.map((entry) => [entry.turnNo, entry.id])) : undefined;
+    const turns = unit.turns;
+    const turnIds = Object.fromEntries(turns.map((entry) => [entry.turnNo, entry.id]));
     const draft = await soul.extract(text, {
       llm: useLlm ? injectedLlm : undefined,
       mode: useLlm ? 'auto' : 'rules',
@@ -1673,19 +1717,34 @@ async function runExtraction(text, turnId, turnNo, origin = 'live', unit = null)
       // The exchange, not the message (ADR 0035): my reply is where promises and
       // decisions live, and it is the only way "我的承诺" can ever be extracted.
       assistantText: turnRow?.assistantText ?? undefined,
-      turns: turns ?? undefined,
+      turns,
     });
     const result = soul.commitDrafts(draft, { turnId, turnIds });
     // Attribution is written even when nothing was extracted: a turn that says
-    // "无" (nothing worth remembering) can still be part of a thread.
-    const attribution = soul.applyThread(draft.thread, {
+    // "无" (nothing worth remembering) can still be part of a thread. The unit is
+    // fanned over per turn (0028 ③): every turn of the segment gets attached, a
+    // turn no span covers chains to the previous one, and the continue/new/
+    // fallback chain inside applyThread is untouched (ADR 0034).
+    const spanTurns = turns.map((entry) => ({
+      promptNo: entry.turnNo,
+      turnNo: entry.hostTurnNo ?? turnNo,
+      turnId: entry.id,
+      at: entry.startedAt ?? Date.now(),
+      fallbackTopic: firstSentence(entry.userText),
+    }));
+    const applied = soul.applyThreadSpans(draft.spans, {
       sessionId: turnRow?.sessionId ?? 'unknown',
-      turnNo,
-      turnId,
-      at: Date.now(),
-      fallbackTopic: firstSentence(text),
+      turns: spanTurns,
       previousThreadId: context.previousThreadId,
     });
+    const attribution = applied[0];
+    // One thread keeps the old line's thread part byte for byte (`thread=th_xxx(new)`);
+    // a split segment lists every thread it produced, and `join=` is the unit's
+    // per-turn reasons joined with `+` (one value only when they agree) — the head
+    // alone no longer describes what the rest of the segment did.
+    const threadIds = [...new Set(applied.map((entry) => entry.threadId))];
+    const createdNew = applied.filter((entry) => entry.created).length;
+    const joins = [...new Set(applied.map((entry) => entry.joinReason))].join('+');
     const ms = Date.now() - started;
     // Provenance is observable (ADR 0035): the fact count alone cannot tell whether
     // anything came from my side of the exchange.
@@ -1697,11 +1756,12 @@ async function runExtraction(text, turnId, turnNo, origin = 'live', unit = null)
         ` gaps=${result.gaps.length} skipped=${result.skipped.length} draftSkipped=${(draft.skipped ?? []).length}` +
         ` slots->text=${result.droppedSlots.length} holder->world=${result.holderFallbacks.length}` +
         ` inferred=${inferred}` +
-        ` unit=${turns ? `${turns.length}turns` : '1turn'}` +
+        ` unit=${turns.length}turns` +
         ` ms=${ms} turn=${turnNo} origin=${origin}` +
-        ` thread=${attribution.threadId}${attribution.created ? '(new)' : ''}` +
-        ` join=${attribution.joinReason} threadLine=${draft.threadLine ?? 'rules'}` +
-        `${attribution.topicUpdated ? ' topic=updated' : ''}`,
+        ` thread=${threadIds.join(',')}` +
+          `${createdNew > 0 ? (threadIds.length === 1 ? '(new)' : `(${createdNew} new)`) : ''}` +
+          ` join=${joins} threadLine=${draft.threadLine ?? 'rules'}` +
+          `${applied.some((entry) => entry.topicUpdated) ? ' topic=updated' : ''}`,
     );
     for (const skipped of result.skipped.slice(0, 3)) {
       log(`  extract skipped: ${skipped.what} (${skipped.reason})`);
@@ -1732,6 +1792,18 @@ async function runExtraction(text, turnId, turnNo, origin = 'live', unit = null)
       threadTopic: attribution.topic,
       threadLine: draft.threadLine ?? null,
       topicUpdated: attribution.topicUpdated,
+      // Only when the segment actually split: one thread is the old shape, and the
+      // per-turn runs are what makes a wrong split diagnosable later (0028 ③).
+      ...(applied.length > 1
+        ? {
+            threadSpans: applied.map((entry, index) => ({
+              span: spanTurns[index].promptNo,
+              thread: entry.threadId,
+              join: entry.joinReason,
+              created: entry.created,
+            })),
+          }
+        : {}),
       origin,
       joinReason: attribution.joinReason,
       ms,
@@ -1851,7 +1923,11 @@ export async function drainExtractionQueue(options = {}) {
     // turn, so a fact's 轮次 lands on source_turn_id.
     const turns = taken.map((entry, index) => ({
       id: entry.item.turnId,
+      // Prompt numbering (1..n, what the model's spans match) and the host's real
+      // turn number (threads count turns that jump by 10–30) are different numbers;
+      // both ride along so attribution never has to guess which is which.
       turnNo: index + 1,
+      hostTurnNo: entry.row.turn,
       userText: entry.row.userText,
       assistantText: entry.row.assistantText,
       startedAt: entry.row.at,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-soulbridge",
-  "version": "0.0.120",
+  "version": "0.0.122",
   "description": "Inject soulbridge context into DSH sessions and feed user turns back as observations.",
   "type": "module",
   "main": "index.js",
@@ -42,6 +42,6 @@
     "setup": "node scripts/install-hooks.mjs"
   },
   "dependencies": {
-    "soulbridge": ">=0.0.116 <0.1.0"
+    "soulbridge": ">=0.0.117 <0.1.0"
   }
 }