dsh-as-aistudio 0.5.13 → 0.5.14

package/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 ## 中文
 
+**0.5.14** —— 跟进 dsh-log-trim 0.7.1（目标事件不再被折叠/重建丢掉）。
+
+- 内嵌 log-trim 升到 0.7.1：折叠与重建保留 `goal/change` 等状态事件，四条重写路径加守卫，
+  启动扫描修复孤儿目标轮次并清投影缓存。
+- 重新 vendor（新增 `dsh-log-trim.goal-repair.js`）。
+
 **0.5.13** —— 跟进 dsh-rerun-turn 0.2.11（`/state` 走内存快照 + 派生缓存）。
 
 **0.5.12** —— 跟进 dsh-rerun-turn 0.2.10（行增长节流 + 传输层重试）。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-as-aistudio",
-  "version": "0.5.13",
+  "version": "0.5.14",
   "description": "Google-AI-Studio-style turn controls for DeepSeek Harness, in one install: edit a prompt and re-run it, re-run a reply in place, delete a turn from the model context, render sent prompts as Markdown, and trim idle session logs on boot. Self-contained: the plugin list shows this one row, and the five components (four actions + one maintenance) are vendored inside it - installing the studio installs nothing else.",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -9642,7 +9642,7 @@ window.__ModuleLoader__.load({
     const react = require('react')
     const { jsx, jsxs } = require('react/jsx-runtime')
 
-    const PLUGIN_VERSION = '0.7.0'
+    const PLUGIN_VERSION = '0.7.1'
     const ROUTE_PREFIX = '/api/dsh-log-trim'
 
     /** The knobs this card edits, in the order they are drawn. */
@@ -10168,7 +10168,7 @@ window.__ModuleLoader__.load({
     const NS = 'dsh-as-aistudio'
 
     /** Keep in sync with package.json and src/components.js. */
-    const PLUGIN_VERSION = '0.5.13'
+    const PLUGIN_VERSION = '0.5.14'
 
     /** Presence marker the live verifier reads. */
     const DEBUG_KEY = '__DSH_AS_AISTUDIO__'

package/src/components.js

@@ -26,7 +26,7 @@
 export const STUDIO_ID = 'dsh-as-aistudio'
 
 /** Keep in sync with package.json and src/client.js. */
-export const STUDIO_VERSION = '0.5.13'
+export const STUDIO_VERSION = '0.5.14'
 
 /**
  * The AI Studio action strip this studio composes, in the order the user meets

package/src/vendor/host/dsh-edit-turn.js

@@ -1,6 +1,6 @@
 // dsh-edit-turn host half (dsh-edit-turn.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-edit-turn/lib/index.js  (v0.5.18, sha256 3a2e3a4008b8c061)
+// Source: ../dsh-edit-turn/lib/index.js  (v0.5.19, sha256 5a6e1fed0c1e2b64)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -85,7 +85,7 @@ export const PLUGIN_ID = 'dsh-edit-turn'
 export const name = PLUGIN_ID
 
 /** Keep in sync with package.json and lib/client.js. */
-export const PLUGIN_VERSION = '0.5.18'
+export const PLUGIN_VERSION = '0.5.19'
 
 // A ring of the last few requests, answering "did the browser half even ask, and
 // what did it get?" without needing its console. Read-only diagnostics: the

package/src/vendor/host/dsh-edit-turn.patch.js

@@ -1,6 +1,6 @@
 // dsh-edit-turn host half (dsh-edit-turn.patch.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-edit-turn/lib/patch.js  (v0.5.18, sha256 5e1e8cce1d168f6c)
+// Source: ../dsh-edit-turn/lib/patch.js  (v0.5.19, sha256 5e1e8cce1d168f6c)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-log-trim.flatten.js

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.flatten.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/flatten.js  (v0.7.0, sha256 3aa1fdcbb120ab06)
+// Source: ../dsh-log-trim/lib/flatten.js  (v0.7.1, sha256 3aa1fdcbb120ab06)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-log-trim.goal-repair.js

@@ -0,0 +1,187 @@
+// dsh-log-trim host half (dsh-log-trim.goal-repair.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
+//
+// Source: ../dsh-log-trim/lib/goal-repair.js  (v0.7.1, sha256 0801a28f35667ee7)
+// Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
+//
+// src/shell.js imports the copy named after the component, which is why the
+// studio installs with no runtime dependency on the component package.
+/**
+ * Repair sessions whose goal bookkeeping was lost by a log rewrite.
+ *
+ * `goal/change` is not a surface event: it carries the durable goal snapshot
+ * (create / edit / pause / resume / complete / block / clear), while the goal's
+ * rounds arrive as ordinary `user/message` events whose `data.source` says
+ * `{kind: 'goal', goalId, revision, round}`. The goal projection folds the two
+ * together and demands that every round be *the next admitted round* of the
+ * currently active goal.
+ *
+ * A rewrite that rebuilds the log from its visible surface (`rebuildSurface` in
+ * `lossless.js`, exposed by `applyFlatten` / `applyRebuild`) used to keep the
+ * rounds - they are surface nodes - and drop every `goal/change`. The log still
+ * passes every host format validator, because the format layer does not know
+ * goal semantics, but on the next load the goal projection refuses the whole
+ * log:
+ *
+ *   goal replay failed at session event N: goal round at session event N is not
+ *   the next admitted round of the active goal
+ *
+ * and `/goal` is unusable in that session forever (`command.execute failed`).
+ *
+ * The durable goal is already gone at that point - the snapshots were deleted -
+ * so the honest repair is to drop the now-dangling goal attribution from those
+ * rounds: they stay in the model's history as what they are, user messages, and
+ * `/goal` can create a fresh goal. Nothing is invented and no sequence number
+ * moves, so the repair cannot itself invalidate a log.
+ */
+
+/** Goal operations that keep (or replace) a current goal snapshot. */
+const SNAPSHOT_OPERATIONS = new Set(['create', 'edit', 'pause', 'resume', 'complete', 'block'])
+
+/**
+ * @typedef {{current?: {id?: string, revision?: number, phase?: string, maxGoalRounds?: number}, roundsStarted: number}} GoalFold
+ */
+
+/**
+ * Apply one `goal/change` payload to the local fold.
+ *
+ * Deliberately tolerant: a payload this function does not understand leaves the
+ * fold alone instead of failing the whole repair.
+ *
+ * @param {GoalFold} state - fold accumulator.
+ * @param {unknown} data - the event payload.
+ * @returns {GoalFold} the next fold state.
+ */
+function applyChange(state, data) {
+  if (data === null || typeof data !== 'object' || data.kind !== 'goal/change') return state
+  if (data.operation === 'clear') return { current: undefined, roundsStarted: 0 }
+  if (!SNAPSHOT_OPERATIONS.has(data.operation)) return state
+  const goal = data.goal
+  if (goal === null || typeof goal !== 'object' || typeof goal.id !== 'string') return state
+  return {
+    current: {
+      id: goal.id,
+      revision: goal.revision,
+      phase: goal.phase,
+      maxGoalRounds: goal.maxGoalRounds,
+    },
+    roundsStarted: Number.isSafeInteger(data.roundsStarted) ? data.roundsStarted : state.roundsStarted,
+  }
+}
+
+/**
+ * Whether one goal-source round is admitted by the fold (same rule as the goal
+ * projection's `applyGoalEvent`).
+ *
+ * @param {GoalFold} state - fold state before this round.
+ * @param {object} source - the message's `data.source`.
+ * @returns {boolean} true when the projection would admit this round.
+ */
+function admitsRound(state, source) {
+  const current = state.current
+  if (current === undefined) return false
+  if (current.phase !== 'active') return false
+  if (source.goalId !== current.id || source.revision !== current.revision) return false
+  if (source.round !== state.roundsStarted + 1) return false
+  if (Number.isSafeInteger(current.maxGoalRounds) && source.round > current.maxGoalRounds) return false
+  return true
+}
+
+/**
+ * Find the goal rounds a replay would reject as orphans.
+ *
+ * @param {object[]} events - the session's events, in seq order.
+ * @returns {number[]} the seqs of goal-source user messages no goal admits.
+ */
+export function orphanGoalRounds(events) {
+  /** @type {GoalFold} */
+  let state = { current: undefined, roundsStarted: 0 }
+  const orphans = []
+  for (const event of events) {
+    if (event.type === 'goal/change') {
+      state = applyChange(state, event.data)
+      continue
+    }
+    if (event.type !== 'user/message') continue
+    const source = event.data?.source
+    if (source === null || typeof source !== 'object' || source.kind !== 'goal') continue
+    if (admitsRound(state, source)) {
+      state = { ...state, roundsStarted: source.round }
+      continue
+    }
+    orphans.push(event.seq)
+  }
+  return orphans
+}
+
+/**
+ * Whether one log event belongs to the goal domain.
+ *
+ * Both halves matter: `goal/change` carries the snapshots, and every admitted
+ * `user/message` with a goal source advances `roundsStarted`. Losing either one
+ * makes the goal projection reject the whole log on replay.
+ *
+ * @param {object} event - a session event.
+ * @returns {boolean} true for goal bookkeeping events.
+ */
+export function isGoalEvent(event) {
+  if (event === null || typeof event !== 'object') return false
+  if (event.type === 'goal/change') return true
+  return event.type === 'user/message' && event.data?.source?.kind === 'goal'
+}
+
+/**
+ * How many goal-domain events a log carries.
+ *
+ * @param {object[]} events - session events.
+ * @returns {number} the count.
+ */
+export function goalEventCount(events) {
+  let count = 0
+  for (const event of events) if (isGoalEvent(event)) count += 1
+  return count
+}
+
+/**
+ * Refuse a rewrite that would drop a goal event.
+ *
+ * The goal projection folds the **whole** log, shadowed history included, so it
+ * is not enough to keep what the model can currently read: a compaction may have
+ * replaced a round, and trimming that round away turns every later round into an
+ * orphan. `goal/change` is preserved by the current writers; goal rounds are
+ * surface events and cannot be re-added as invisible bookkeeping, so a rewrite
+ * that would lose one has to stop rather than produce a log `/goal` cannot open.
+ *
+ * @param {object[]} original - the log before the rewrite.
+ * @param {object[]} kept - the events the rewrite would write.
+ * @throws {Error} when a goal event would disappear.
+ */
+export function assertGoalEventsKept(original, kept) {
+  const before = goalEventCount(original)
+  if (before === 0) return
+  const after = goalEventCount(kept)
+  if (after >= before) return
+  throw new Error(
+    `压缩会删掉 ${before - after} 条目标事件（goal/change 或目标轮次）。目标投影从整份日志折叠，` +
+      '删掉任何一条都会让该会话的 /goal 永久报 "goal replay failed"；已放弃这次写入',
+  )
+}
+
+/**
+ * Rewrite the orphan rounds' attribution into plain user messages.
+ *
+ * Copy-on-write: untouched events keep their identity, so a caller that finds
+ * no orphans can skip the write entirely.
+ *
+ * @param {object[]} events - the session's events, in seq order.
+ * @param {number[]} orphans - seqs from {@link orphanGoalRounds}.
+ * @returns {object[]} the repaired events (same seq numbering).
+ */
+export function stripOrphanGoalSources(events, orphans) {
+  const doomed = new Set(orphans)
+  if (doomed.size === 0) return events
+  return events.map((event) => {
+    if (!doomed.has(event.seq) || event.type !== 'user/message') return event
+    const data = event.data ?? {}
+    return { ...event, data: { ...data, source: { kind: 'user' } } }
+  })
+}

package/src/vendor/host/dsh-log-trim.host-libs.mjs

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.host-libs.mjs), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/host-libs.mjs  (v0.7.0, sha256 5ebed01988b5bfcf)
+// Source: ../dsh-log-trim/lib/host-libs.mjs  (v0.7.1, sha256 5ebed01988b5bfcf)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-log-trim.js

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/index.js  (v0.7.0, sha256 49dcb38f01b7c751)
+// Source: ../dsh-log-trim/lib/index.js  (v0.7.1, sha256 906bd2b437e569b4)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -37,13 +37,14 @@ import { discoverRoots, isCurrentLog, listLegacy } from './dsh-log-trim.roots.js
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
-import { applyTrim, foldSurface, isSessionLocked, keepLastWindows, readLogAsync, renumber, windowsOf } from './dsh-log-trim.vendor.compact-session.mjs'
+import { applyTrim, commitTrim, encodeLogAsync, foldSurface, isSessionLocked, keepLastWindows, readLogAsync, renumber, windowsOf } from './dsh-log-trim.vendor.compact-session.mjs'
 import { applyFlatten, applyLossless, applyStreamOnly, planLossless, applyRebuild } from './dsh-log-trim.lossless.js'
+import { orphanGoalRounds, stripOrphanGoalSources } from './dsh-log-trim.goal-repair.js'
 import { readLedger, recordFor } from './dsh-log-trim.ledger.js'
 
 export const name = 'dsh-log-trim'
 export const PLUGIN_ID = name
-export const PLUGIN_VERSION = '0.7.0'
+export const PLUGIN_VERSION = '0.7.1'
 export const ROUTE_PREFIX = '/api/dsh-log-trim'
 
 /**
@@ -345,6 +346,125 @@ export async function repairIfCorrupt(logFile, config) {
   return { sessionId: path.basename(path.dirname(logFile)), reason: detail, failed: true }
 }
 
+/**
+ * `<DSH_HOME>` for one session log, so the projection cache can be addressed.
+ *
+ * @param {string} logFile - the session's log.
+ * @param {object} config - resolved config (`sessionsRoot`).
+ * @returns {string} the DSH home directory.
+ */
+function dshHomeOf(logFile, config) {
+  const root = typeof config?.sessionsRoot === 'string' ? path.resolve(config.sessionsRoot) : null
+  const file = path.resolve(logFile)
+  if (root !== null && file.startsWith(root + path.sep)) return path.dirname(root)
+  // <home>/sessions/<workspace>/<session>/<log>
+  return path.dirname(path.dirname(path.dirname(path.dirname(file))))
+}
+
+/**
+ * Forget one session's durable projection cache record.
+ *
+ * The record's identity is the session header, not the log bytes, and its rows
+ * keep a checkpoint seq plus the values folded from it. A cached `goal` row that
+ * already carries the replay failure would therefore be restored verbatim after
+ * the log was repaired — the failure would outlive the fix. Deleting the record
+ * makes the next load fold from seq 0.
+ *
+ * @param {string} logFile - the session's log.
+ * @param {object} config - resolved config.
+ * @returns {string[]|null} removed cache file names, or null when there was none.
+ */
+export function dropProjectionCache(logFile, config) {
+  const sessionId = path.basename(path.dirname(path.resolve(logFile)))
+  const dir = path.join(dshHomeOf(logFile, config), 'storages', 'session_projcache', 'sessions')
+  let names
+  try {
+    names = fs.readdirSync(dir)
+  } catch {
+    return null
+  }
+  const bare = sessionId.replace(/^session-/, '')
+  const doomed = names.filter(
+    (name) => name.endsWith('.json') && (name === `${sessionId}.json` || name === `${bare}.json`),
+  )
+  const removed = []
+  for (const name of doomed) {
+    try {
+      fs.rmSync(path.join(dir, name), { force: true })
+      removed.push(name)
+    } catch {
+      // 删不掉就留着：下次启动还会再试一次。
+    }
+  }
+  return removed.length === 0 ? null : removed
+}
+
+/**
+ * 修好被重写路径弄丢目标的会话。
+ *
+ * `goal/change` 不是表面事件：它没有 surfaceOp，只是恰好落在某次 replace 的
+ * 区间里（或整份日志按表面重建时），就会被裁剪/重写顺手删掉；而目标轮次是普通
+ * 的 `user/message`，作为表面节点留了下来。这种日志能通过宿主的格式校验（格式层
+ * 不懂目标语义），但目标投影回放时会整份报错：
+ *
+ *   goal replay failed at session event N: goal round at session event N is not
+ *   the next admitted round of the active goal
+ *
+ * 之后 `/goal` 在该会话里永久失败（`command.execute failed`）。删掉的快照找不
+ * 回来，所以修复只做一件不发明任何东西的事：把这些已经指向不存在目标的轮次改回
+ * 普通用户消息（内容、seq 都不动），目标投影随之清空，`/goal` 可以重新开。顺带
+ * 删掉该会话的投影缓存，否则缓存里的 failure 行会被当成检查点继续复用。
+ *
+ * @param {string} logFile - 会话日志。
+ * @param {object} config - 生效配置。
+ * @returns {Promise<object|null>} 修了什么；没有孤儿轮次时返回 null。
+ */
+export async function repairOrphanGoalRounds(logFile, config) {
+  if (isSessionLocked(logFile)) return null
+  const original = await readLogAsync(logFile)
+  const orphans = orphanGoalRounds(original.events)
+  if (orphans.length === 0) return null
+  const repaired = stripOrphanGoalSources(original.events, orphans)
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const backup = `${logFile}.precompact-${stamp}`
+  const staging = `${logFile}.staging-${stamp}`
+  await fs.promises.writeFile(staging, await encodeLogAsync(original.header, repaired))
+  const { verifyLog } = await import('./dsh-log-trim.verify-session-log.mjs')
+  const verified = await verifyLog(staging)
+  if (!verified.ok) {
+    await fs.promises.rm(staging, { force: true })
+    const failed = (verified.checks || []).filter((check) => !check.ok).slice(0, 3)
+    throw new Error(
+      '目标轮次修复结果没通过宿主校验，未写入：' +
+        failed.map((check) => check.name + '：' + check.detail).join('；'),
+    )
+  }
+  const afterBytes = fs.statSync(staging).size
+  const summary = await commitTrim({
+    staging,
+    backup,
+    summary: {
+      backup,
+      before: { events: original.events.length, bytes: original.compressedBytes },
+      after: { events: repaired.length, bytes: afterBytes },
+      dropped: 0,
+    },
+  }, logFile)
+  const cache = dropProjectionCache(logFile, config)
+  recordFor(logFile, 'goal-repair', original.events, repaired, {
+    bytesBefore: original.compressedBytes,
+    bytesAfter: summary.after.bytes,
+    record: config?.recordLedger !== false,
+  })
+  return {
+    sessionId: path.basename(path.dirname(logFile)),
+    reason: `丢掉目标快照的轮次改回普通消息（${orphans.length} 条）`,
+    orphans: orphans.length,
+    backup: backup.slice(backup.lastIndexOf('.precompact-') + 1),
+    cache,
+  }
+}
+
 export function listBackups(root, limit = 40) {
   const found = []
   let total = 0
@@ -851,8 +971,22 @@ export async function runScan(config, logger = {}) {
       known.size === bytes &&
       known.mtimeMs === mtimeMs
     ) {
-      // Same bytes, same mtime: the answer cannot have changed.
+      // Same bytes, same mtime: the answer cannot have changed — except the goal
+      // repair, which older verdicts never ran. Do it once per file revision.
       remember[logFile] = known
+      if (known.goalChecked !== true && config.repairOnBoot !== false && bytes >= 64 * 1024) {
+        try {
+          const goalFixed = await repairOrphanGoalRounds(logFile, config)
+          if (goalFixed !== null) {
+            summary.repaired.push(goalFixed)
+            // 日志变了，旧判定作废；下一轮扫描按新文件重来。
+            continue
+          }
+        } catch (error) {
+          summary.failed.push({ sessionId, reason: `目标轮次修复失败：${error instanceof Error ? error.message : String(error)}` })
+        }
+        known.goalChecked = true
+      }
       if (known.verdict === 'skip') {
         summary.skipped.push({ sessionId, reason: known.reason })
       } else if (known.verdict === 'fail') {
@@ -860,6 +994,17 @@ export async function runScan(config, logger = {}) {
       }
       continue
     }
+    // 宿主的格式校验管不到目标语义：被重写过的日志能正常打开，却可能只剩目标轮次
+    // 而没有 goal/change，于是 /goal 永远报 "goal replay failed ... not the next
+    // admitted round"。这一步先把它修好；小日志不可能积累出一整段目标轮次，跳过。
+    if (config.repairOnBoot !== false && bytes >= 64 * 1024) {
+      try {
+        const goalFixed = await repairOrphanGoalRounds(logFile, config)
+        if (goalFixed !== null) summary.repaired.push(goalFixed)
+      } catch (error) {
+        summary.failed.push({ sessionId, reason: `目标轮次修复失败：${error instanceof Error ? error.message : String(error)}` })
+      }
+    }
     // 先折叠：edit/rerun/delete 的载体是“注释行”，落成正文后日志才是“本来如此”。
     // 折叠完继续往下走，于是同一份日志还能顺带被裁窗口（两步都各自验过才写）。
     // 这个计数跨两个分支用（折叠要不要跑、清理已遮蔽要不要跳过），必须在外层声明。

package/src/vendor/host/dsh-log-trim.ledger.js

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.ledger.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/ledger.js  (v0.7.0, sha256 5ca2460b42a3a776)
+// Source: ../dsh-log-trim/lib/ledger.js  (v0.7.1, sha256 5ca2460b42a3a776)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-log-trim.lossless.js

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.lossless.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/lossless.js  (v0.7.0, sha256 8b5c75ec49d48981)
+// Source: ../dsh-log-trim/lib/lossless.js  (v0.7.1, sha256 1b98a61bbad8ef87)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -24,6 +24,7 @@
  */
 
 import fs from 'node:fs'
+import { assertGoalEventsKept } from './dsh-log-trim.goal-repair.js'
 import { recordFor } from './dsh-log-trim.ledger.js'
 import { commitTrim, derivedHistory, dropOrphanCompactions, encodeLogAsync, foldSurface, readLogAsync, renumber, seededHeaderFor, textLengthOf } from './dsh-log-trim.vendor.compact-session.mjs'
 
@@ -123,6 +124,11 @@ export async function planLossless(logFile, config) {
   const original = await readLogAsync(logFile)
   const before = modelView(original.events)
   const cut = selectLossless(original.events)
+  try {
+    assertGoalEventsKept(original.events, cut.events)
+  } catch (error) {
+    return { should: false, reason: error instanceof Error ? error.message : String(error), report: { title: '', events: original.events.length, windows: 0, droppable: 0, modelBefore: 0, modelAfter: 0, modelSame: false, bytes: original.compressedBytes, afterBytes: original.compressedBytes }, cut }
+  }
   const after = modelView(cut.events)
   const bytes = (await encodeLogAsync(original.header, cut.events)).length
   const same = sameView(before, after)
@@ -189,6 +195,7 @@ export async function planLossless(logFile, config) {
  */
 export async function applyLossless(logFile, config, plan, options = {}) {
   const original = await readLogAsync(logFile)
+  assertGoalEventsKept(original.events, plan.cut.events)
   const renamed = renumber(plan.cut.events)
   const seqs = new Set(renamed.events.map((event) => event.seq))
   for (let index = 0; index < renamed.events.length; index += 1) {
@@ -206,6 +213,7 @@ export async function applyLossless(logFile, config, plan, options = {}) {
   const backup = `${logFile}.precompact-${stamp}`
   const staging = `${logFile}.staging-${stamp}`
   await fs.promises.writeFile(staging, await encodeLogAsync(original.header, renamed.events))
+  const afterBytes = fs.statSync(staging).size
 
   if (options.verify !== false) {
     let verified
@@ -224,7 +232,16 @@ export async function applyLossless(logFile, config, plan, options = {}) {
     }
   }
 
-  const summary = await commitTrim({ staging, backup }, logFile)
+  const summary = await commitTrim({
+    staging,
+    backup,
+    summary: {
+      backup,
+      before: { events: original.events.length, bytes: original.compressedBytes },
+      after: { events: renamed.events.length, bytes: afterBytes },
+      dropped: original.events.length - renamed.events.length,
+    },
+  }, logFile)
   recordFor(logFile, 'lossless', original.events, renamed.events, { bytesBefore: original.compressedBytes, bytesAfter: summary.after.bytes, record: config?.recordLedger !== false })
   return {
     ...summary,
@@ -243,6 +260,7 @@ export async function applyLossless(logFile, config, plan, options = {}) {
 export async function applyRebuild(logFile, config) {
   const original = await readLogAsync(logFile)
   const rebuilt = rebuildSurface(original.events)
+  assertGoalEventsKept(original.events, rebuilt)
   const stamp = new Date().toISOString().replace(/[:.]/g, '-')
   const backup = `${logFile}.precompact-${stamp}`
   const staging = `${logFile}.staging-${stamp}`
@@ -255,7 +273,16 @@ export async function applyRebuild(logFile, config) {
     throw new Error('重写结果没通过宿主校验，未写入：' + failed.map((check) => check.name + '：' + check.detail).join('；'))
   }
   const beforeBytes = fs.statSync(staging).size
-  await commitTrim({ staging, backup }, logFile)
+  await commitTrim({
+    staging,
+    backup,
+    summary: {
+      backup,
+      before: { events: original.events.length, bytes: original.compressedBytes },
+      after: { events: rebuilt.length, bytes: beforeBytes },
+      dropped: original.events.length - rebuilt.length,
+    },
+  }, logFile)
   recordFor(logFile, 'rebuild', original.events, rebuilt, { bytesBefore: original.compressedBytes, bytesAfter: beforeBytes, record: config?.recordLedger !== false })
   return {
     mode: 'rebuild',
@@ -319,6 +346,7 @@ export async function applyFlatten(logFile, config) {
   // 与窗口裁剪同一条规则：只留最近几轮的流式回放记录，更早的删掉。
   const stripped = stripOldStreams(flattened.events, 0)
   const folded = stripped.events
+  assertGoalEventsKept(original.events, folded)
   if (stats.edits + stats.reruns + stats.deletes === 0) {
     throw new Error('没有需要折叠的编辑/重跑/删除记录')
   }
@@ -334,7 +362,16 @@ export async function applyFlatten(logFile, config) {
     throw new Error('折叠结果没通过宿主校验，未写入：' + failed.map((check) => check.name + '：' + check.detail).join('；'))
   }
   const beforeBytes = fs.statSync(staging).size
-  await commitTrim({ staging, backup }, logFile)
+  await commitTrim({
+    staging,
+    backup,
+    summary: {
+      backup,
+      before: { events: original.events.length, bytes: original.compressedBytes },
+      after: { events: folded.length, bytes: beforeBytes },
+      dropped: original.events.length - folded.length,
+    },
+  }, logFile)
   recordFor(logFile, 'flatten', original.events, folded, { bytesBefore: original.compressedBytes, bytesAfter: beforeBytes, record: config?.recordLedger !== false })
   return {
     mode: 'flatten',
@@ -346,6 +383,86 @@ export async function applyFlatten(logFile, config) {
   }
 }
 
+/**
+ * Log events that are not part of the dialogue surface but that a host
+ * projection still folds from the log.
+ *
+ * The rebuild replays the visible messages and used to discard everything else,
+ * which silently deleted durable state:
+ *
+ * - `goal/change` carries the goal snapshot. Losing it while the goal's rounds
+ *   (ordinary surface `user/message` events) survive makes the goal projection
+ *   refuse the whole log: "goal round at session event N is not the next
+ *   admitted round of the active goal", and `/goal` stays broken forever.
+ * - `todo/write`, `plan/mode`, `schedule/change`, `team/*`, `feedback/*` and
+ *   `working-directory/change` are the same kind of snapshot state: the UI and
+ *   the projections read the last one, and dropping them looks like the user's
+ *   todos / plan mode / team board / schedules vanished.
+ *
+ * The six settings event types already re-emitted at the head of the rebuild
+ * (`agent-preset/selected`, `permission/preset`, `sandbox/mode`,
+ * `approval/policy`, `session/title`, `model/selection`) are deliberately not
+ * listed here: the rebuild regenerates each from its own last event.
+ */
+const PRESERVED_STATE_TYPES = new Set([
+  'goal/change',
+  'plan/mode',
+  'todo/write',
+  'schedule/change',
+  'working-directory/change',
+  'team/member',
+  'team/task',
+  'team/message/queued',
+  'team/message/delivered',
+  'feedback/record',
+  'feedback/message-put',
+  'feedback/message-delete',
+])
+
+/**
+ * Re-insert preserved state events just before the first surface block whose
+ * source event originally came after them.
+ *
+ * `out` is already the rebuilt surface; `marks` maps each copied source seq to
+ * the index at which its block starts. A state event that originally sat
+ * between two messages therefore lands back between them, which is what keeps a
+ * goal's create/edit snapshot ahead of the rounds it admits.
+ *
+ * @param {object[]} out - the rebuilt surface entries.
+ * @param {Map<number, number>} marks - source seq → output index.
+ * @param {object[]} preserved - state events to keep, in original seq order.
+ * @returns {object[]} the surface with state events merged back in.
+ */
+function mergeStateEvents(out, marks, preserved) {
+  if (preserved.length === 0) return out
+  const boundaries = [...marks.entries()].sort((left, right) => left[0] - right[0])
+  const buckets = new Map()
+  for (const event of preserved) {
+    let at = out.length
+    for (const [seq, index] of boundaries) {
+      if (seq > event.seq) {
+        at = index
+        break
+      }
+    }
+    const bucket = buckets.get(at)
+    if (bucket === undefined) buckets.set(at, [event])
+    else bucket.push(event)
+  }
+  const merged = []
+  const pushBucket = (index) => {
+    const bucket = buckets.get(index)
+    if (bucket === undefined) return
+    for (const event of bucket) merged.push({ seq: 0, type: event.type, time: event.time, data: event.data })
+  }
+  for (let index = 0; index < out.length; index += 1) {
+    pushBucket(index)
+    merged.push(out[index])
+  }
+  pushBucket(out.length)
+  return merged
+}
+
 /**
  * Rebuild a log from the surface the model reads.
  *
@@ -356,12 +473,21 @@ export async function applyFlatten(logFile, config) {
  * every tool result sits in the turn of its call, and no replace or compaction
  * record survives.
  *
+ * Events in {@link PRESERVED_STATE_TYPES} are re-inserted at their original
+ * position relative to the surface, so a goal snapshot still precedes the round
+ * it admits (and a later edit/clear still follows the rounds it follows today).
+ *
  * @param {object[]} events - the session's events.
  * @returns {object[]} the rebuilt events, seqs assigned from 0.
  */
 export function rebuildSurface(events) {
   const visible = foldSurface(events).visible ?? []
   const bySeq = new Map(events.map((event) => [event.seq, event]))
+  const preserved = events.filter((event) => PRESERVED_STATE_TYPES.has(String(event.type ?? '')))
+  // Output index at which each visible source event starts; state events are
+  // merged back in front of the first visible event that originally followed
+  // them.
+  const marks = new Map()
   const headers = events.filter((event) => event.type === 'request/header')
   const headerBefore = (seq) => {
     let found = null
@@ -466,6 +592,7 @@ export function rebuildSurface(events) {
     if (consumed.has(seq)) continue
     const event = bySeq.get(seq)
     if (event === undefined) continue
+    marks.set(seq, out.length)
     advance(event)
     const data = event.data ?? {}
     const message = data.message ?? data
@@ -484,12 +611,12 @@ export function rebuildSurface(events) {
         out.push({ seq: 0, type: 'request/header', time: clock, data: header.data })
         next.headerSeq = headerIndex
       }
-      out.push({ seq: 0, type: event.type, time: clock, data: next, surfaceOp: 'append' })
+      out.push({ seq: 0, type: event.type, time: ownTime(event), data: next, surfaceOp: 'append' })
       continue
     }
     if (role === 'user' || event.type === 'user/message') {
       openTurn(header)
-      out.push({ seq: 0, type: event.type, time: clock, data: { ...message, turn }, surfaceOp: 'append' })
+      out.push({ seq: 0, type: event.type, time: ownTime(event), data: { ...message, turn }, surfaceOp: 'append' })
       continue
     }
     if (!open) openTurn(header)
@@ -517,14 +644,14 @@ export function rebuildSurface(events) {
     // without it the format layer reads the row as a fork result and refuses it.
     if (data.error !== undefined) payload.error = data.error
     if (event.type === 'tool/call') payload.callId = data.callId
-    out.push({ seq: 0, type: event.type, time: clock, data: payload, surfaceOp: 'append' })
+    out.push({ seq: 0, type: event.type, time: ownTime(event), data: payload, surfaceOp: 'append' })
     // A tool call is announced by its assistant message and "started" by a
     // tool/call event; without that event the result looks like a tool that
     // never ran, and the format layer demands the TOOL_NOT_STARTED repair.
     if (event.type === 'assistant/message' && Array.isArray(message?.content)) {
       for (const block of message.content) {
         if (block === null || block === undefined || block.type !== 'tool-call' || !answered.has(block.id)) continue
-        out.push({ seq: 0, type: 'tool/call', time: clock, data: { turn, step, callId: block.id, name: block.name, arguments: block.arguments } })
+        out.push({ seq: 0, type: 'tool/call', time: ownTime(event), data: { turn, step, callId: block.id, name: block.name, arguments: block.arguments } })
         // The model reads a call and its result together; a result that arrived
         // many steps later would otherwise leave the step that advertised the
         // call unresolved, which the format layer refuses.
@@ -540,7 +667,8 @@ export function rebuildSurface(events) {
     }
   }
   closeTurn()
-  const rebuilt = out.map((event, index) => ({ ...event, seq: index }))
+  const merged = mergeStateEvents(out, marks, preserved)
+  const rebuilt = merged.map((event, index) => ({ ...event, seq: index }))
   // A fork result encodes the sequence it was appended at inside its identity
   // (`forked-tool-result-<callId>-<seq>`); renumbering has to follow, or the host
   // reads the row as a replacement that names a sequence it does not have.

package/src/vendor/host/dsh-log-trim.roots.js

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.roots.js), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/roots.js  (v0.7.0, sha256 028d9c12a395aaab)
+// Source: ../dsh-log-trim/lib/roots.js  (v0.7.1, sha256 028d9c12a395aaab)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-log-trim.vendor.compact-session.mjs

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.vendor.compact-session.mjs), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/vendor.compact-session.mjs  (v0.7.0, sha256 e3782b79b4db0062)
+// Source: ../dsh-log-trim/lib/vendor.compact-session.mjs  (v0.7.1, sha256 0f27c0d30c2c8215)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the
@@ -452,7 +452,44 @@ function resolveLog(arg) {
  * 无论被谁覆盖都保留的事件：这些是界面渲染「压缩标记」和会话元信息要用的，
  * 体量可以忽略（这个会话里 64 条），丢了会让界面少一行标记或丢标题。
  */
-const KEEP_ALWAYS = ['compaction/', 'session/']
+const KEEP_ALWAYS = ['compaction/', 'session/', 'goal/']
+
+/**
+ * 目标事件：`goal/change` 与带 goal source 的轮次。
+ *
+ * 目标投影折叠的是**整份日志**（包括已被 replace 遮蔽的历史），所以"模型看不见的
+ * 事件就能删"这条规则对它不成立：少一条 goal/change 或少一轮，后面的轮次就全成了
+ * 孤儿，该会话的 /goal 从此永久报 "goal replay failed"。
+ *
+ * @param {object} event - 一条日志事件。
+ * @returns {boolean} 是否属于目标。
+ */
+function isGoalEvent(event) {
+  if (event === null || typeof event !== 'object') return false
+  if (event.type === 'goal/change') return true
+  return event.type === 'user/message' && event.data?.source?.kind === 'goal'
+}
+
+/**
+ * 任何会让目标事件变少的裁剪都必须放弃：目标语义不在宿主的格式校验里，
+ * 写下去就是一整份"能装得上、但 /goal 永久失败"的日志。
+ *
+ * @param {object[]} original - 裁剪前的日志事件。
+ * @param {object[]} kept - 准备写入的事件。
+ * @throws {Error} 会删掉目标事件时抛出。
+ */
+export function assertNoGoalEventsDropped(original, kept) {
+  let before = 0
+  for (const event of original) if (isGoalEvent(event)) before += 1
+  if (before === 0) return
+  let after = 0
+  for (const event of kept) if (isGoalEvent(event)) after += 1
+  if (after >= before) return
+  throw new Error(
+    `压缩会删掉 ${before - after} 条目标事件（goal/change 或目标轮次）；` +
+      '目标投影从整份日志折叠，删掉任何一条都会让该会话的 /goal 永久失败，已放弃这次写入',
+  )
+}
 
 /**
  * 生成压缩后的日志事件流。
@@ -1572,6 +1609,10 @@ export function renumber(events) {
     'llm/retry', 'llm/retry-started', 'session/title', 'session/title-llm-request',
     'command/run', 'command/done', 'compaction/start', 'compaction/summary', 'compaction/end',
     'compaction/prune', 'session/end-seed',
+    // `goal/change` 没有 turn/step 字段，格式层不管它；但它的顺序对目标投影有意义
+    // （create/edit 必须排在被它放行的那一轮之前）。归到 head 会被搬到整份日志最前，
+    // 那一轮就成了孤儿，所以必须留在 body 原位。
+    'goal/change',
   ])
   const head = events.filter((e) => !RELATIONSHIP_TYPES.has(e.type))
   const body = events.filter((e) => RELATIONSHIP_TYPES.has(e.type))
@@ -2022,6 +2063,7 @@ export async function stageTrim(logFile, keep, options = {}) {
   // 旧回合的流式回放记录：与 data.message.content 逐块重复，留最近几轮就够。
   const streamKeepTurns = options.streamKeepTurns === undefined ? Infinity : options.streamKeepTurns
   const stripped = stripOldStreams(trimmed.events, streamKeepTurns)
+  assertNoGoalEventsDropped(original.events, stripped.events)
   const renamed = renumber(stripped.events)
 
   const seqs = new Set(renamed.events.map((e) => e.seq))

package/src/vendor/host/dsh-log-trim.verify-session-log.mjs

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.verify-session-log.mjs), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/verify-session-log.mjs  (v0.7.0, sha256 7cf835c053942961)
+// Source: ../dsh-log-trim/lib/verify-session-log.mjs  (v0.7.1, sha256 7cf835c053942961)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/host/dsh-log-trim.worker.mjs

@@ -1,6 +1,6 @@
 // dsh-log-trim host half (dsh-log-trim.worker.mjs), VENDORED by tools/vendor.mjs - DO NOT EDIT.
 //
-// Source: ../dsh-log-trim/lib/worker.mjs  (v0.7.0, sha256 675a759a767b7e38)
+// Source: ../dsh-log-trim/lib/worker.mjs  (v0.7.1, sha256 675a759a767b7e38)
 // Regenerate with `npm run vendor`; test/sync.test.js fails when this is stale.
 //
 // src/shell.js imports the copy named after the component, which is why the

package/src/vendor/versions.json

@@ -1,7 +1,7 @@
 {
-  "dsh-edit-turn": "0.5.18",
+  "dsh-edit-turn": "0.5.19",
   "dsh-rerun-turn": "0.2.11",
   "dsh-delete-turn": "0.2.4",
   "dsh-markdown-bubble": "0.1.5",
-  "dsh-log-trim": "0.7.0"
+  "dsh-log-trim": "0.7.1"
 }