sage-mem 1.0.0 → 1.0.2

package/lib/autodream/engine.js

@@ -290,6 +290,8 @@ export class AutodreamEngine {
         auditBefore,
         auditAfter,
         finalText: result.finalText,
+        continuations: result.continuations,
+        truncated: result.truncated,
         archiveMode: policy.mode,
         archiveRequested: policy.requested,
         archiveCandidates: policy.candidates,
@@ -316,6 +318,8 @@ export class AutodreamEngine {
         auditBefore,
         auditAfter,
         finalText: result.finalText,
+        continuations: result.continuations,
+        truncated: result.truncated,
         transcript: result.transcript,
         tokensIn: result.tokensIn,
         tokensOut: result.tokensOut,
@@ -341,6 +345,9 @@ export class AutodreamEngine {
         problemsAfter: auditAfter.problems,
         tokensIn: result.tokensIn,
         tokensOut: result.tokensOut,
+        // 残篇要能在界面上被认出来（面板读 lastResult）：只报「成功」是不够的。
+        continuations: result.continuations,
+        truncated: result.truncated,
         report: report.name,
         snapshotId: snapshot?.id ?? null,
       }
@@ -353,6 +360,8 @@ export class AutodreamEngine {
         touched: result.touched,
         changeCount: result.changes.length,
         snapshotId: snapshot?.id ?? null,
+        continuations: result.continuations,
+        truncated: result.truncated,
         auditBefore,
         auditAfter,
       }

package/lib/autodream/llm-loop.js

@@ -150,10 +150,35 @@ export async function streamOnce(llm, req) {
   return asm
 }
 
+/**
+ * 一次模型调用的输出上限。
+ *
+ * ⚠️ **调大它解决不了「长报告被截断」**：报告长度没有上界，调大只是把墙往后挪一格
+ * （2026-10-17 实测：10-01 的报告 5532 字符、10-13 是 5957，都完整收尾；这次 8553 字符
+ * 就断在半个句子里）。真正的处理是撞上它时**接着写** —— 见下面的 MAX_CONTINUATIONS。
+ */
+const MAX_TOKENS_PER_CALL = 4096
+/** 撞上单次上限后最多续写几轮：够把最后一段写完，又不至于让一次跑飞掉。 */
+const MAX_CONTINUATIONS = 3
+/** 续写指令。三条禁令缺一不可 —— 重写整篇 / 重新开头 / 道歉寒暄，模型都干得出来。 */
+const CONTINUE_PROMPT =
+  '（上一条回答被输出长度上限截断了。请**从中断处继续写**，不要重复已经写过的内容，不要重新开头，不要解释或道歉，直接接着写。）'
+
+/** 取这一次调用里的全部文字块，拼成一段。 */
+function textOf(asm) {
+  return asm
+    .blocks()
+    .filter((b) => b.type === 'text')
+    .map((b) => b.text)
+    .join('')
+    .trim()
+}
+
 /**
  * 极简 agent 循环：模型 → 工具 → 结果回灌 → 再问，直到模型不再要工具或触顶。
  *
  * 每一步都把「这一轮要了什么工具」记进 stepLog，设置面板显示的就是这个。
+ * **一步可以包含多次模型调用**：撞上输出上限时接着写，而不是把半篇当成品交出去。
  */
 export async function agentLoop(cfg, runOpts) {
   const { provider, model, toolSchemas, runner, maxSteps, tokenBudget, signal } = runOpts
@@ -178,40 +203,90 @@ export async function agentLoop(cfg, runOpts) {
   let tokensIn = 0
   let tokensOut = 0
   let finalText = ''
+  // 截断与续写的账：`continuations` 是「确实接着写过几轮」，`truncated` 是「续写用尽还是没写完」。
+  // 两个都要进声明与报告 —— 「报告是残篇却报成功」正是这一版要修的那处静默。
+  let continuations = 0
+  let truncated = false
+  let lastStep = 0
   const allToolsUsed = []
+  const addUsage = (u) => {
+    if (!u) return
+    tokensIn += u.inputTokens ?? 0
+    tokensOut += u.outputTokens ?? 0
+  }
 
   for (let step = 1; step <= maxSteps; step++) {
     if (signal?.aborted) throw new Error('autodream 被取消')
     // 让工具执行器知道现在是第几轮：模型没自述缘由时，声明要靠这个追溯「哪一步干的」。
     if (typeof runner.setStep === 'function') runner.setStep(step)
     this.phase = `第 ${step} 轮：等待模型`
-    const asm = await this.streamOnce(llm, {
+    lastStep = step
+
+    let asm = await this.streamOnce(llm, {
       provider,
       model,
       system,
       messages,
       tools: toolSchemas,
-      maxTokens: 4096,
+      maxTokens: MAX_TOKENS_PER_CALL,
       signal,
     })
-    const usage = asm.usage
-    if (usage) {
-      tokensIn += usage.inputTokens ?? 0
-      tokensOut += usage.outputTokens ?? 0
+    addUsage(asm.usage)
+
+    // 一段 = 一次模型调用产出的文字。正常只有一段；撞上输出上限时接着写下一段。
+    let text = ''
+    let calls = []
+    let segment = 0
+    for (;;) {
+      const segText = textOf(asm)
+      const blocks = asm.blocks()
+      const segCalls = blocks.filter((b) => b.type === 'tool-call')
+      // 只有第一段可能带工具调用：被截断时 BlockAssembler 已经丢掉了参数残缺的 tool-call。
+      if (segment === 0) calls = segCalls
+      text += segText
+      transcript.push({
+        step,
+        text: segText,
+        tools: segCalls.map((c) => c.name),
+        ...(segment ? { continuation: true } : {}),
+      })
+      this.stepLog.push({
+        step,
+        tools: segCalls.map((c) => c.name),
+        chars: segText.length,
+        at: Date.now(),
+        ...(segment ? { continuation: true } : {}),
+      })
+      segment += 1
+      if (asm.finish.kind !== 'max-tokens') break
+      // 空段没法接着写；续写名额用尽也一样 —— 两种都算「这篇没写完」，要如实记下来。
+      if (!segText || continuations >= MAX_CONTINUATIONS) {
+        truncated = true
+        break
+      }
+      continuations += 1
+      messages.push(assistantMessage(blocks, provider, model))
+      messages.push(userMessage(CONTINUE_PROMPT))
+      this.phase = `第 ${step} 轮：输出撞上单次上限，续写 ${continuations}/${MAX_CONTINUATIONS}`
+      asm = await this.streamOnce(llm, {
+        provider,
+        model,
+        system,
+        messages,
+        tools: toolSchemas,
+        maxTokens: MAX_TOKENS_PER_CALL,
+        signal,
+      })
+      addUsage(asm.usage)
     }
-    const blocks = asm.blocks()
-    const text = blocks.filter((b) => b.type === 'text').map((b) => b.text).join('').trim()
-    const calls = blocks.filter((b) => b.type === 'tool-call')
-    if (text) finalText = text
-    transcript.push({ step, text, tools: calls.map((c) => c.name) })
-    this.stepLog.push({ step, tools: calls.map((c) => c.name), chars: text.length, at: Date.now() })
 
+    if (text) finalText = text
     if (asm.finish.kind === 'error') {
       throw new Error(`模型返回错误：${asm.finish.failure?.message ?? '未知'}`)
     }
     if (!calls.length) break
 
-    messages.push(assistantMessage(blocks, provider, model))
+    messages.push(assistantMessage(asm.blocks(), provider, model))
     for (const call of calls) {
       let args = {}
       try {
@@ -231,11 +306,22 @@ export async function agentLoop(cfg, runOpts) {
     }
   }
 
+  if (truncated) {
+    // 过程清单要以「没写完」收尾：否则报告里那半句话看起来只是模型话说到一半。
+    transcript.push({
+      step: lastStep,
+      text: `（输出撞上单次长度上限，续写 ${continuations} 轮后仍未写完 —— 上面这段是残篇，后文缺失）`,
+      tools: [],
+    })
+  }
+
   return {
     transcript,
     finalText,
     tokensIn,
     tokensOut,
+    continuations,
+    truncated,
     toolsUsed: allToolsUsed,
     touched: runner.touchedFiles(),
     changes: runner.changes(),

package/lib/autodream/report.js

@@ -55,6 +55,9 @@ export async function writeDeclaration(payload) {
     },
     report: payload.report ?? null,
     finalText: payload.finalText ?? '',
+    // 1.0.1：输出撞上单次上限这件事要进机读记录 —— 残篇在界面上和「话说一半」长得一模一样。
+    continuations: Number(payload.continuations) || 0,
+    truncated: payload.truncated === true,
     rolledBackAt: 0,
     rolledBackAtHuman: '',
   }
@@ -75,6 +78,11 @@ export function renderDeclaration(m, headingLevel = 1) {
       ? `- 回滚点：\`${m.snapshot.id}\`（${m.snapshot.files} 个文件）`
       : '- 回滚点：未做（只出报告模式不写盘，无需回滚）',
     `- 审计：结构问题 ${m.audit.before.problems} → ${m.audit.after.problems}`,
+    ...(m.truncated
+      ? [`- ⚠️ 输出被单次长度上限截断：续写 ${m.continuations ?? 0} 轮后仍未写完，收尾说明是**残篇**`]
+      : m.continuations
+        ? [`- 输出曾撞上单次长度上限，已自动续写 ${m.continuations} 轮补齐`]
+        : []),
     '',
     `${H}# 改了什么、为什么`,
     '',
@@ -198,6 +206,20 @@ export async function writeReport(payload) {
   const name = `${payload.runId}.md`
   const file = join(dir, name)
 
+  /**
+   * 输出撞上限这件事**必须在报告第一屏就说**。
+   * 为什么：残篇与「模型话说一半」在文件里长得一样，读者无从分辨；而这一版之前，
+   * 被截断的那份报告在界面上报的是「成功」。
+   */
+  const truncLines = payload.truncated
+    ? [
+        `- ⚠️ **本次输出被单次长度上限截断**：自动续写 ${payload.continuations ?? 0} 轮后仍未写完 —— ` +
+          '下面「模型的收尾说明」是**残篇**，后文缺失',
+      ]
+    : payload.continuations
+      ? [`- 输出曾撞上单次长度上限，已自动续写 ${payload.continuations} 轮补齐（报告完整）`]
+      : []
+
   const lines = [
     `# Autodream 报告 · ${stampHuman(payload.startedAt)}`,
     '',
@@ -208,6 +230,7 @@ export async function writeReport(payload) {
     `- 模型：\`${payload.provider}/${payload.model}\`${payload.fromDefault ? '（跟随当前会话默认模型）' : '（配置里指定）'}`,
     `- 门控：距上次 ${payload.hoursSince === null ? '（首次）' : payload.hoursSince.toFixed(1) + 'h'} · 期间 ${payload.sessionCount} 个会话更新`,
     `- 耗时：${((payload.endedAt - payload.startedAt) / 1000).toFixed(1)}s · token ${payload.tokensIn} in / ${payload.tokensOut} out`,
+    ...truncLines,
     payload.snapshot
       ? `- 回滚点：\`${payload.snapshot.id}\` · ${payload.snapshot.dir}（${payload.snapshot.count} 个文件）`
       : '- 回滚点：未做（只读模式不写盘）',
@@ -233,10 +256,19 @@ export async function writeReport(payload) {
     payload.declarationMarkdown,
     '## 过程',
     '',
-    ...payload.transcript.map(
-      (t) =>
-        `- 第 ${t.step} 轮${t.tools.length ? `：调用 ${t.tools.join('、')}` : '：结束'}${t.text ? ` — ${t.text.slice(0, 120)}` : ''}`,
-    ),
+    ...payload.transcript.map((t) => {
+      // 「续写」必须标出来：否则同一轮出现好几条，读起来像模型重复劳动。
+      const mark = t.continuation ? '（截断续写）' : ''
+      const kind = t.tools.length ? `：调用 ${t.tools.join('、')}` : '：结束'
+      // ⚠️ **先压平空白再截断**。模型这一步的文字里常带换行与 `## 标题`，直接 slice(0,120)
+      // 会把标题漏成真标题 —— 报告读起来像「内容重复了一遍」（2026-10-17 10:42 那次真踩到：
+      // 「过程」最后一条把下一节的 `## 一、必须修改的…` 顶了出来）。
+      const brief = String(t.text ?? '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 120)
+      return `- 第 ${t.step} 轮${mark}${kind}${brief ? ` — ${brief}` : ''}`
+    }),
     '',
   ]
   await writeFile(file, lines.join('\n'), 'utf8')

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "main": "lib/index.js",
   "exports": {