dsh-plugin-soulbridge 0.0.111 → 0.0.113

package/README.md

@@ -45,6 +45,7 @@ dsh plugin --profile desktop add "github:Jason0826/dsh-plugin-soulbridge#v0.0.4"
 | `user/message source=user chars=N` | 收到用户消息 |
 | `soul ready: db=… soul=… user=…` | core 与数据库就绪 |
 | `observe ok: chars=… written=… affect=… confidence=…` | **整条链路成功** |
+| `turn cost: session=… turn=… requests=N (steps=… failed=… plugin=…)` | 这一轮的请求数到了 30（见下节） |
 | `skipping profile bundle …` (stderr) | bundle 被启动器跳过，原因就在后面 |
 
 ## 卸载
@@ -94,6 +95,20 @@ DSH 启动器对 `package.json` 直接 `JSON.parse`，不剥 BOM。用 Windows P
 为什么是"规则优先、模型补漏"：实测规则精确率 1.00，但 26 条真实消息里漏了 19 条；
 让模型覆盖规则没有收益，只在漏掉时补才有。宿主模型**只能在真实轮次内调用**，
 启动时调用会被账号 provider 拒绝（见 `docs/experiment-2026-10-29-host-llm.md`）。
+
+## 每轮花了多少（0026）
+
+平台导出只有"每天一行"，单轮花大钱看不出来。所以插件自己记：
+
+| 落点 | 什么时候 | 内容 |
+|---|---|---|
+| `trace.jsonl` 的 `{"event":"turn-cost"}` | 每轮结束 | 请求数（= 步骤 + 失败尝试 + 插件自己的调用）、四类 token、耗时、结束原因 |
+| `plugin.log` 的 `turn cost:` | 一轮 ≥ 30 次请求 | 同一份数字压成一行 |
+
+计数来源是宿主的事件流：`step/start`（一次调用）、`assistant/attempt`（重试且没出消息）、
+`assistant/message.usage`（token）。子代理跑在自己的会话里，因此各自一条记录——事件流
+里没有父子关系，猜一个比写两条更坏。插件**不算钱**：金额只从 `scripts/billing.mjs`
+（读平台导出）来，价目有峰谷两档且会变。
 ## 升级提示：新增工具需要新开会话
 
 `ctx.inject(['tools'])` 注册的工具在**会话创建时**进入该会话的工具集。插件升级后

package/index.js

@@ -88,6 +88,151 @@ function trace(record) {
   }
 }
 
+/** A turn that reaches this many model requests gets one line in plugin.log (0026). */
+const TURN_REQUEST_ALERT = 30;
+/** Subagent sessions each open a turn; past this many, the oldest unfinished turn is written out. */
+const TURN_TRACKER_MAX = 64;
+
+/**
+ * What one turn cost, in requests and tokens (brief 0026).
+ *
+ * The platform export is one line per day, so the turn that actually burned the
+ * money is invisible until the day is over. The host's event stream already
+ * carries everything needed to attribute it:
+ *
+ *   step/start          one model call was scheduled
+ *   assistant/attempt   a call that was retried and produced no message
+ *   assistant/message   a finished call, with the usage it reported
+ *   turn/start, turn/end  the window
+ *
+ * A subagent runs in its own session and therefore gets its own record; the
+ * event stream has no parent link, and guessing one would be worse than two
+ * honest lines. Money is deliberately absent — prices have peak/off-peak tiers
+ * and change, so amounts come only from `scripts/billing.mjs` in core.
+ *
+ * @param {object} [options]
+ * @param {number} [options.threshold] request count that triggers the log line.
+ * @param {number} [options.maxTurns] unfinished turns kept before the oldest is written out.
+ * @param {(record: object) => void} [options.onReport] called once per finished turn.
+ * @param {(line: string) => void} [options.onAlert] called when a turn reaches the threshold.
+ */
+export function createTurnCostTracker({ threshold = TURN_REQUEST_ALERT, maxTurns = TURN_TRACKER_MAX, onReport, onAlert } = {}) {
+  const open = new Map();
+  let lastSession;
+
+  const addUsage = (entry, usage) => {
+    if (!usage) return;
+    entry.input += Number(usage.inputTokens) || 0;
+    entry.cacheHit += Number(usage.cacheReadTokens) || 0;
+    entry.cacheWrite += Number(usage.cacheWriteTokens) || 0;
+    entry.output += Number(usage.outputTokens) || 0;
+  };
+
+  const requestsOf = (entry) => entry.steps + entry.failed + entry.plugin;
+
+  /** Write the record once, then forget the turn. `complete` is false for interrupted/evicted turns. */
+  const finish = (session, entry, reason, endedAt, complete) => {
+    open.delete(session);
+    const requests = requestsOf(entry);
+    if (requests === 0) return;
+    const secs = Math.max(0, Math.round((endedAt - entry.startedAt) / 1000));
+    const record = {
+      event: 'turn-cost',
+      session,
+      turn: entry.turn,
+      requests,
+      steps: entry.steps,
+      failed: entry.failed,
+      plugin: entry.plugin,
+      input: entry.input,
+      cacheHit: entry.cacheHit,
+      cacheWrite: entry.cacheWrite,
+      output: entry.output,
+      secs,
+      ...(complete ? {} : { open: true }),
+      ...(reason === undefined ? {} : { reason }),
+    };
+    onReport?.(record);
+    if (requests >= threshold) {
+      onAlert?.(
+        `turn cost: session=${session} turn=${entry.turn} requests=${requests}` +
+          ` (steps=${entry.steps} failed=${entry.failed} plugin=${entry.plugin})` +
+          ` input=${entry.input} cacheHit=${entry.cacheHit} output=${entry.output}` +
+          ` secs=${secs}${complete ? '' : ' open'}`,
+      );
+    }
+  };
+
+  return {
+    /**
+     * Feed one session event. Events of a session whose turn was never opened are
+     * ignored rather than attached to a neighbour: a wrong attribution is worse
+     * than a missing one.
+     * @param {string} session - session id the event belongs to.
+     * @param {{type?: string, time?: number, data?: object}} event - host session event.
+     */
+    observe(session, event) {
+      const type = event?.type;
+      const data = event?.data ?? {};
+      if (typeof data.turn !== 'number') return;
+      lastSession = session;
+      const entry = open.get(session);
+      if (type === 'turn/start') {
+        if (entry) finish(session, entry, 'restarted', event?.time ?? Date.now(), false);
+        open.set(session, {
+          turn: data.turn,
+          startedAt: event?.time ?? Date.now(),
+          steps: 0,
+          failed: 0,
+          plugin: 0,
+          input: 0,
+          cacheHit: 0,
+          cacheWrite: 0,
+          output: 0,
+        });
+        if (open.size > maxTurns) {
+          const oldest = open.keys().next().value;
+          finish(oldest, open.get(oldest), 'evicted', Date.now(), false);
+        }
+        return;
+      }
+      if (!entry || entry.turn !== data.turn) return;
+      if (type === 'step/start') entry.steps += 1;
+      else if (type === 'assistant/attempt') entry.failed += 1;
+      else if (type === 'assistant/message') addUsage(entry, data.usage);
+      else if (type === 'turn/end') {
+        finish(session, entry, data.reason?.kind, event?.time ?? Date.now(), true);
+      }
+    },
+    /**
+     * Count one model call made by this plugin, attributed to the turn it ran
+     * inside. The turn is the most recent one the host reported an event for —
+     * the stage chain only runs while that turn is live.
+     */
+    pluginCall() {
+      if (lastSession === undefined) return;
+      const entry = open.get(lastSession);
+      if (!entry) return;
+      entry.plugin += 1;
+    },
+    /**
+     * Add the tokens a plugin call reported to the same turn. Separate from
+     * {@link pluginCall} because the request is counted when it is dispatched
+     * (a failed call still costs money) while its usage only arrives at the end.
+     * @param {{inputTokens?: number, cacheReadTokens?: number, cacheWriteTokens?: number, outputTokens?: number}} [usage]
+     *   usage the call reported; absent when the call failed before reporting.
+     */
+    pluginUsage(usage) {
+      if (lastSession === undefined) return;
+      const entry = open.get(lastSession);
+      if (!entry) return;
+      addUsage(entry, usage);
+    },
+    /** Unfinished turns currently held (observability for the bound in tests). */
+    openCount: () => open.size,
+  };
+}
+
 /** Prompt assembly can run several times per step; do not hit SQLite every time. */
 
 /**
@@ -134,6 +279,8 @@ function readConfig() {
 /** Adapter side of the core LlmFn port: the host model, called inside a turn. */
 let currentTurn;
 let currentStep;
+/** Per-turn cost accounting (0026); null until apply() attaches it (tests import this module bare). */
+let turnCostTracker;
 
 // Measured, not guessed: 279 calls, p50=1.7s p90=6.8s p99=46.7s, max=142.9s.
 // 90s is ~2x p99 and caps a hung call without cutting the ordinary tail.
@@ -170,6 +317,11 @@ export function makeLlm(ctx, config) {
     // a call actually lands in.
     const started = Date.now();
     log(`llm probe: start turn=${currentTurn ?? '?'} step=${currentStep ?? '?'} chars=${prompt.length}`);
+    // This call is a model request too (0026): count it, and keep the usage the
+    // stream reports so the turn's token total is complete rather than just its
+    // agent-loop part.
+    let usage;
+    turnCostTracker?.pluginCall();
     try {
       const text = await withTimeout(
         collectText(
@@ -185,10 +337,14 @@ export function makeLlm(ctx, config) {
               },
             ],
           }),
+          (reported) => {
+            usage = reported;
+          },
         ),
         LLM_TIMEOUT_MS,
         'llm call',
       );
+      turnCostTracker?.pluginUsage(usage);
       log(
         `llm probe: end ok ms=${Date.now() - started} out=${typeof text === 'string' ? text.length : -1}` +
           ` step=${currentStep ?? '?'}`,
@@ -215,8 +371,12 @@ export function makeLlm(ctx, config) {
  * `finish{reason:{kind:'error'|'aborted'}}` instead of throwing, so without this
  * check the failure came back as `''` and the caller read it as "the model said
  * nothing". `collectText` throws unless some text was produced before the failure.
+ *
+ * @param {AsyncIterable<object>} stream - chunks of one model call.
+ * @param {(usage: object) => void} [onUsage] called with the usage chunk, if the
+ *   adapter reported one; without it a call's tokens have no reader (0026).
  */
-export async function collectText(stream) {
+export async function collectText(stream, onUsage) {
   let text = '';
   let sawDelta = false;
   let failure;
@@ -226,6 +386,8 @@ export async function collectText(stream) {
       sawDelta = true;
     } else if (!sawDelta && chunk.type === 'block-end' && chunk.block?.type === 'text') {
       text += chunk.block.text ?? '';
+    } else if (chunk.type === 'usage' && chunk.usage) {
+      onUsage?.(chunk.usage);
     } else if (chunk.type === 'finish' && (chunk.reason?.kind === 'error' || chunk.reason?.kind === 'aborted')) {
       failure = chunk.reason;
     }
@@ -1098,6 +1260,17 @@ function bumpExtractAttempt(turnId) {
   );
 }
 
+/**
+ * After a thread was extracted, every queued turn of that thread is already covered.
+ * Leaving them would extract the same topic again, turn by turn (0025).
+ */
+function removeExtractItemsOfThread(threadId, turnIds) {
+  if (!threadId) return;
+  writeExtractQueue(
+    readExtractQueue().filter((item) => !turnIds.includes(item.turnId)),
+  );
+}
+
 /**
  * Add one turn to the extraction queue.
  *
@@ -1131,7 +1304,7 @@ function hasSubstance(text) {
   return !/^(好的?|嗯+|哦+|可以|行|ok|okay|收到|明白|继续|好)[。！!.\s]*$/i.test(trimmed);
 }
 
-async function runExtraction(text, turnId, turnNo, origin = 'live') {
+async function runExtraction(text, turnId, turnNo, origin = 'live', thread = null) {
   const config = readConfig();
   if (config.extract === 'off') return 'skipped-off';
   if (typeof text !== 'string' || !hasSubstance(text)) {
@@ -1153,6 +1326,10 @@ async function runExtraction(text, turnId, turnNo, origin = 'live') {
       const previousThreadId = soul.threadBefore(turnRow.sessionId, turnNo);
       if (previousThreadId) context.previousThreadId = previousThreadId;
     }
+    // 0025: the unit is the whole topic when the turn belongs to one. The turns array is
+    // numbered the way the prompt numbers them, and each fact may name its own turn.
+    const turns = thread?.turns ?? null;
+    const turnIds = turns ? Object.fromEntries(turns.map((entry) => [entry.turnNo, entry.id])) : undefined;
     const draft = await soul.extract(text, {
       llm: useLlm ? injectedLlm : undefined,
       mode: useLlm ? 'auto' : 'rules',
@@ -1162,8 +1339,9 @@ async function runExtraction(text, turnId, turnNo, origin = 'live') {
       // 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,
     });
-    const result = soul.commitDrafts(draft, { turnId });
+    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, {
@@ -1183,6 +1361,7 @@ async function runExtraction(text, turnId, turnNo, origin = 'live') {
         ` gaps=${result.gaps.length} skipped=${result.skipped.length}` +
         ` slots->text=${result.droppedSlots.length} holder->world=${result.holderFallbacks.length}` +
         ` inferred=${inferred}` +
+        ` unit=${turns ? `${turns.length}turns` : '1turn'} threadId=${thread?.id ?? '-'}` +
         ` ms=${ms} turn=${turnNo} origin=${origin}` +
         ` thread=${attribution.threadId}${attribution.created ? '(new)' : ''}` +
         ` join=${attribution.joinReason} threadLine=${draft.threadLine ?? 'rules'}` +
@@ -1276,9 +1455,21 @@ export async function drainExtractionQueue() {
   try {
     const item = pickExtractionItem(queue);
     let text = '';
+    let thread = null;
     try {
-      const turn = ensureSoul().turn(item.turnId);
+      const soul = ensureSoul();
+      const turn = soul.turn(item.turnId);
       text = turn?.userText ?? '';
+      // A turn is a trigger, the topic is the unit (0025). When the turn is already in a
+      // thread, extract that thread's turns instead of this message alone.
+      const threadId = soul.turnThreadId(item.turnId);
+      if (threadId) {
+        const turns = soul.threadTurns(threadId);
+        if (turns.length > 0) {
+          thread = { id: threadId, turns };
+          text = turns[turns.length - 1].userText;
+        }
+      }
     } catch {
       text = '';
     }
@@ -1288,14 +1479,21 @@ export async function drainExtractionQueue() {
       return;
     }
 
-    const outcome = await runExtraction(text, item.turnId, item.turnNo, item.origin ?? 'live');
+    const outcome = await runExtraction(text, item.turnId, item.turnNo, item.origin ?? 'live', thread);
     const ok =
       outcome === 'ok' || outcome === 'skipped-off' || outcome === 'skipped-empty' || outcome === 'rules-mode';
     if (ok) {
-      removeExtractItem(item.turnId);
-      // Promotion is decided after the facts exist: a corrected turn's lessons enter
-      // the classification queue here, which is the only live producer it has.
-      feedClassifyFromTurn(item.turnId);
+      if (thread) {
+        removeExtractItemsOfThread(thread.id, thread.turns.map((entry) => entry.id));
+        // Promotion is decided after the facts exist; a whole thread can hold several
+        // corrected turns, so every turn is offered.
+        for (const entry of thread.turns) feedClassifyFromTurn(entry.id);
+      } else {
+        removeExtractItem(item.turnId);
+        // Promotion is decided after the facts exist: a corrected turn's lessons enter
+        // the classification queue here, which is the only live producer it has.
+        feedClassifyFromTurn(item.turnId);
+      }
       trace({ event: 'extract-queue', drained: 1, remaining: readExtractQueue().length, outcome });
       return true;
     }
@@ -2244,6 +2442,14 @@ export function apply(ctx) {
   // Backfill is triggered by the first user message, not here: at apply() time
   // the host model service is not mounted yet and every call fails.
 
+  // Per-turn cost (0026): a turn's record goes to trace.jsonl, and a turn that
+  // 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),
+    onAlert: (line) => log(line),
+  });
+
   try {
     ctx.effect(
       () => {
@@ -2330,6 +2536,10 @@ export function apply(ctx) {
 
       const sessionId = session?.id ?? 'default';
 
+      // Before any early return below: turn/end is where the cost record is
+      // written, and that branch returns.
+      turnCostTracker?.observe(sessionId, event);
+
       // Keep the last reply: a correction only makes sense next to what it targets.
       if (typeof event.data?.turn === 'number') currentTurn = event.data.turn;
       if (typeof event.data?.step === 'number') currentStep = event.data.step;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-soulbridge",
-  "version": "0.0.111",
+  "version": "0.0.113",
   "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.108 <0.1.0"
+    "soulbridge": ">=0.0.112 <0.1.0"
   }
 }