release: v0.2.36

build/windows-installer-migration.ps1

@@ -388,7 +388,10 @@ function Convert-IdentityToSid([string]$Identity) {
 }
 
 function Get-FileSystemSecurity([string]$PathValue) {
-  $sections = [Security.AccessControl.AccessControlSections]::All
+  # Journal trust only depends on the owner and DACL. Requesting All would
+  # also read the SACL/Audit section, which ordinary user accounts cannot
+  # inspect without SeSecurityPrivilege.
+  $sections = [Security.AccessControl.AccessControlSections]::Owner -bor [Security.AccessControl.AccessControlSections]::Access
   if ([IO.Directory]::Exists($PathValue)) {
     return [IO.Directory]::GetAccessControl($PathValue, $sections)
   }

docs/KUN_CONFIG.md

@@ -120,7 +120,7 @@ GUI 启动 Kun 时会按下面的顺序合并配置。
   },
   "runtime": {
     "streamIdleTimeoutMs": 450000,
-    "toolStorm": { "enabled": true, "windowSize": 8, "threshold": 3 },
+    "toolStorm": { "enabled": true },
     "toolArgumentRepair": { "maxStringBytes": 524288 }
   }
 }

docs/graph-mode.md

@@ -477,7 +477,9 @@ Journal 是带 checksum 的 append-only JSONL；sequence 单调递增。snapshot
 2. 过期 lease，标记缺失 worktree。
 3. 对 queued/running/waiting attempt 与 child session 对账。
 4. 缺失 child 变为 orphaned/interrupted，并按剩余 attempt 次数重试或升级。
-5. `pausing` 收敛到 paused；缺 final summary 的 `completing` 回到 supervision。
+5. `pausing` 按持久化的 `pendingControlIntent` 收敛：`pause` 进入 `paused`；
+   `cancel` 或旧 journal 的 `cancellation dispatch fence` 完成幂等 cleanup 后进入
+   `cancelled`。缺 final summary 的 `completing` 回到 supervision。
 6. 写入 cleanup 和 recovery signal，再启动 scheduler。
 
 Retention 只删除超过期限、terminal 且未被 thread reference 引用的 GraphRun。

docs/kun-architecture.md

@@ -94,6 +94,17 @@ Kun 的缓存命中率要按 provider 原生 usage 字段优先计算和优化
   重启或 resume 后 runtime usage 面板不重新从 0 计算。
 - 动态上下文必须追加在稳定前缀之后。compaction、resume、fork、plan context
   也不得改写稳定系统前缀。
+- 自动压缩同时考虑输入压力和请求总预算：压缩触发不仅比较历史/请求输入与
+  soft/hard 输入阈值，还会把为模型输出保留的预算（`maxOutputTokens`）计入
+  `input + output` 总预算，并与发送前硬上限（上下文窗口的 85% 或模型
+  profile 的 hard threshold）对齐。这样输入尚未达到软阈值、但加上输出预算
+  已经突破发送上限（例如 1M 窗口 + 131072 输出预算）时，会在发送前强制
+  压缩，而不是在发送校验处直接失败。
+- 最终请求只允许一次启发式兜底压缩：重新构造（图片/浏览器转发、token
+  economy、history hygiene）后的精确请求若仍超出 `input + output` 上限，
+  会基于最新持久化历史再做一次确定性启发式压缩（不调用 summary 模型、不
+  重复预算 reservation）并重建请求；第二次仍超限才精确失败。任何路径都
+  不会无限循环压缩、递归重建或把超限请求发往供应商。
 
 冷启动第一轮可能仍然低或为 0，因为服务端还没有同一前缀可读；热起来后应稳定
 超过 90%。2026-06-02 的真实 Kun 临时线程验证：

docs/kun-cache-optimization.md

@@ -146,11 +146,8 @@ Kun 也会在模型请求边界做一层共享的 history hygiene：
 - `kun/src/loop/request-history-hygiene.ts`
 - `kun/src/loop/agent-loop.ts`
 
-同一 turn 内还会启用 repeat-loop guard：
-
-- 第三次完全相同的 `(toolName, arguments)` 会被抑制。
-- Kun 会写入一个 error `tool_result`，让模型收敛到更窄的查询或解释原因。
-- 文件变更类工具会清掉之前的只读调用记录，避免“编辑后复读”被误判。
+同一 turn 内不再抑制重复的相同工具调用：模型可以按需重试同一参数的工具，
+失败原因通过 error `tool_result` 返回给模型自行收敛。
 
 连续的内置只读工具调用会做保守并发：
 
@@ -162,8 +159,8 @@ Kun 也会在模型请求边界做一层共享的 history hygiene：
 
 实现位置：
 
-- `kun/src/loop/tool-storm-breaker.ts`
-- `kun/src/loop/agent-loop.ts`
+- `kun/src/loop/tool-dispatch-policy.ts`
+- `kun/src/loop/tool-call-dispatcher.ts`
 
 Fork / resume 创建新线程时也会修复克隆历史：
 

kun/package.json

@@ -98,7 +98,7 @@
     "semver": "^7.8.5",
     "typescript": "5.9.3",
     "typescript-language-server": "5.3.0",
-    "undici": "^7.28.0",
+    "undici": "^7.29.0",
     "yauzl": "^3.4.0",
     "yazl": "^3.3.1",
     "zod": "^4.4.3"
@@ -112,6 +112,9 @@
   },
   "overrides": {
     "@hono/node-server": "2.0.11",
+    "fast-uri": "3.1.5",
+    "hono": "4.13.0",
+    "ip-address": "10.4.0",
     "@connectrpc/connect-node": {
       "undici": "6.28.0"
     }

kun/src/adapters/file/atomic-write.ts

@@ -32,11 +32,35 @@ export async function atomicWriteFile(
     }
   } catch (error) {
     await rm(tmp, { force: true }).catch(() => undefined)
-    throw error
+    throw describeAtomicWriteError(path, error)
   }
   await rm(tmp, { force: true }).catch(() => undefined)
 }
 
+/**
+ * Preserves Node fs error fields (`code`, `errno`, `syscall`, `path`) while
+ * prefixing a stable `atomic write failed (CODE) for <path>` message so
+ * manager/runtime logs clearly attribute disk exhaustion (ENOSPC) or
+ * permission failures to the exact lease/config file instead of a bare
+ * "Internal server error" / "fetch failed".
+ */
+function describeAtomicWriteError(path: string, error: unknown): unknown {
+  if (!(error instanceof Error)) return error
+  const source = error as NodeJS.ErrnoException
+  const code = String(source.code ?? '')
+  const prefixed = new Error(
+    `atomic write failed${code ? ` (${code})` : ''} for ${path}: ${error.message}`,
+    { cause: error }
+  )
+  Object.assign(prefixed, {
+    ...(source.code !== undefined ? { code: source.code } : {}),
+    ...(source.errno !== undefined ? { errno: source.errno } : {}),
+    ...(source.syscall !== undefined ? { syscall: source.syscall } : {}),
+    ...(source.path !== undefined ? { path: source.path } : {})
+  })
+  return prefixed
+}
+
 async function renameWithRetry(
   from: string,
   to: string,

kun/src/adapters/hybrid/hybrid-thread-projection.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+import { makeGoalContextItem, makeUserItem } from '../../domain/item.js'
+import { createThreadRecord } from '../../domain/thread.js'
+import { createTurnRecord } from '../../domain/turn.js'
+import { hydrateThreadItems } from './hybrid-thread-projection.js'
+
+describe('hydrateThreadItems', () => {
+  it('does not rehydrate internal goal context into the public thread projection', () => {
+    const threadId = 'thread_goal_projection'
+    const turnId = 'turn_goal_projection'
+    const prompt = 'Continue the goal.'
+    const user = makeUserItem({
+      id: 'item_goal_user',
+      threadId,
+      turnId,
+      text: prompt
+    })
+    const goal = makeGoalContextItem({
+      id: 'item_goal_context',
+      threadId,
+      turnId,
+      text: 'Internal stable goal context.',
+      createdAt: '2026-08-06T00:00:00.000Z'
+    })
+    const thread = {
+      ...createThreadRecord({
+        id: threadId,
+        title: 'Goal projection',
+        workspace: '/tmp/workspace',
+        model: 'test-model'
+      }),
+      turns: [createTurnRecord({
+        id: turnId,
+        threadId,
+        prompt,
+        status: 'completed'
+      })]
+    }
+
+    const hydrated = hydrateThreadItems(thread, [user, goal], {
+      preserveExistingItemsWhenNoFileItems: false
+    })
+
+    expect(hydrated.turns[0]?.items).toEqual([user])
+    expect(JSON.stringify(hydrated)).not.toContain('Internal stable goal context.')
+  })
+
+  it('filters an internal goal context from a preserved legacy item mirror', () => {
+    const threadId = 'thread_goal_legacy_projection'
+    const turnId = 'turn_goal_legacy_projection'
+    const prompt = 'Keep the public history.'
+    const user = makeUserItem({
+      id: 'item_goal_legacy_user',
+      threadId,
+      turnId,
+      text: prompt
+    })
+    const goal = makeGoalContextItem({
+      id: 'item_goal_legacy_context',
+      threadId,
+      turnId,
+      text: 'Do not expose this model-only goal context.',
+      createdAt: '2026-08-06T00:00:00.000Z'
+    })
+    const thread = {
+      ...createThreadRecord({
+        id: threadId,
+        title: 'Legacy goal projection',
+        workspace: '/tmp/workspace',
+        model: 'test-model'
+      }),
+      turns: [{
+        ...createTurnRecord({
+          id: turnId,
+          threadId,
+          prompt,
+          status: 'completed'
+        }),
+        items: [user, goal]
+      }]
+    }
+
+    const hydrated = hydrateThreadItems(thread, [], {
+      preserveExistingItemsWhenNoFileItems: true
+    })
+
+    expect(hydrated.turns[0]?.items).toEqual([user])
+    expect(JSON.stringify(hydrated)).not.toContain('Do not expose this model-only goal context.')
+  })
+})

kun/src/adapters/hybrid/hybrid-thread-projection.ts

@@ -1,6 +1,6 @@
 import type { ThreadRecord } from '../../contracts/threads.js'
 import { ThreadSchema } from '../../contracts/threads.js'
-import type { TurnItem } from '../../contracts/items.js'
+import { isPublicTurnItem, type TurnItem } from '../../contracts/items.js'
 import type { Turn } from '../../contracts/turns.js'
 
 export type ThreadMetadataLine = {
@@ -14,14 +14,37 @@ export function stripThreadItemBodies(thread: ThreadRecord): ThreadRecord {
   return { ...thread, turns: thread.turns.map((turn) => ({ ...turn, prompt: '', items: [] })) }
 }
 
+function stripInternalThreadItems(thread: ThreadRecord): ThreadRecord {
+  let changed = false
+  const turns = thread.turns.map((turn) => {
+    const items = turn.items.filter(isPublicTurnItem)
+    if (items.length === turn.items.length) return turn
+    changed = true
+    return { ...turn, items }
+  })
+  return changed ? { ...thread, turns } : thread
+}
+
 export function hydrateThreadItems(
   thread: ThreadRecord,
   items: TurnItem[],
   options: { preserveExistingItemsWhenNoFileItems: boolean }
 ): ThreadRecord {
-  if (items.length === 0) return options.preserveExistingItemsWhenNoFileItems ? thread : stripThreadItemBodies(thread)
+  // The session stream also contains model-only records (for example the
+  // stable active-goal context). A hybrid ThreadRecord is the renderer/API
+  // projection, so it must never rehydrate those records after a restart.
+  const publicItems = items.filter(isPublicTurnItem)
+  if (publicItems.length === 0) {
+    // Older hybrid snapshots can still carry their own item mirror while the
+    // canonical stream is absent. Preserve that public history when asked,
+    // but do not let a model-only item from a previous process escape through
+    // this fallback path.
+    return options.preserveExistingItemsWhenNoFileItems ? stripInternalThreadItems(thread) : stripThreadItemBodies(thread)
+  }
   const itemsByTurn = new Map<string, TurnItem[]>()
-  for (const item of items) itemsByTurn.set(item.turnId, [...(itemsByTurn.get(item.turnId) ?? []), item])
+  for (const item of publicItems) {
+    itemsByTurn.set(item.turnId, [...(itemsByTurn.get(item.turnId) ?? []), item])
+  }
   const knownTurnIds = new Set(thread.turns.map((turn) => turn.id))
   const turns = thread.turns.map((turn): Turn => {
     const turnItems = itemsByTurn.get(turn.id) ?? []

kun/src/adapters/hybrid/hybrid-thread-store.ts

@@ -895,7 +895,26 @@ async function yieldToEventLoop(): Promise<void> {
   await new Promise<void>((resolve) => setTimeout(resolve, 0))
 }
 
+/**
+ * Classifies the common better-sqlite3 failure — a prebuilt `.node` binary
+ * compiled for a different Node/Electron ABI — so operators see the exact
+ * compiled vs current ABI instead of a generic "JSONL fallback" line.
+ */
+export function describeSqliteAbiMismatch(message: string): string | null {
+  const compiled = /NODE_MODULE_VERSION (\d+)/.exec(message)?.[1]
+  if (!compiled) return null
+  return `abi: compiled=${compiled} current=${process.versions.modules ?? 'unknown'} ` +
+    `(node ${process.version}, ${process.platform}/${process.arch})`
+}
+
 function warnSqlite(action: string, error: unknown): void {
   const message = error instanceof Error ? error.message : String(error)
-  console.warn(`[kun] hybrid sqlite ${action} failed; using JSONL fallback: ${message}`)
+  const abi = describeSqliteAbiMismatch(message)
+  const hint = abi
+    ? ' Run `npm rebuild better-sqlite3` (or `npm ci`) with the same Node/Electron runtime that launches Kun.'
+    : ' Run `npm rebuild better-sqlite3` if the module is missing or stale.'
+  console.warn(
+    `[kun] hybrid sqlite ${action} failed; using JSONL fallback: ${message}` +
+      `${abi ? ` [${abi}]` : ''}${hint}`
+  )
 }