@sparkelf/dsh-patch-session-query-unindexable-session 0.2.0-rc.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write patches/npm/session-query-unindexable-session/README.md
+README.md: fab5177f06bc14e007af796a0ad8d0cb066cfe63
+README.zh.md: 2e7c838a4061cbff337ca8ca7dbaf1c08462566a

package/README.md

@@ -0,0 +1,56 @@
+# @sparkelf/dsh-patch-session-query-unindexable-session
+
+English | [中文](README.zh.md)
+
+## Summary
+
+Keeps content search working when a session's stored log cannot be migrated, and
+keeps an interrupted first index pass from starting over.
+
+## Why it is needed
+
+Content search reads every session log to build its index. Two behaviours made
+that fail permanently on a history of 200+ sessions:
+
+**A session the migration refuses ends the whole pass.** The v2→v3 session-format
+migration will not transform a message whose content kind is `document`, so the
+cold read throws `SessionFormatUnsupportedError`. That throw escapes the
+observation loop, so one session stops every other session from being indexed —
+and because it is read early on every attempt, the index never fills:
+
+```
+format v2 agent/inbox/spliced at seq 4 data.inserted[0].content[0]:
+cannot safely transform unclassified message content kind "document"
+name=SessionFormatUnsupportedError aborted=false
+```
+
+**The write sits after the entire read.** Nothing is published until every log
+has been read, so an interruption discards all the work. On this history the
+first pass reads 214 sessions and takes minutes.
+
+Measured before the patch: the index held **zero rows** after every search, and
+every search failed in 20–38 seconds. After it: 210 sessions and 202,803
+documents indexed, later searches answering in about a second.
+
+## What it changes
+
+| Behaviour | Before | After |
+|---|---|---|
+| A session whose log cannot be migrated | fails the whole search | skipped and named; others still indexed |
+| When a session is written | after the whole corpus is read | as soon as it is read |
+| Commit shape | one transaction per pass | bounded batches |
+
+## Install
+
+The patch carries no code of its own; the profile supervisor applies it to
+`@deepseek-ai/dsh-session-query-sqlite` when the package is installed.
+
+## Known Limitations and Deferred Work
+
+**A skipped session is invisible to content search.** A term that appears only in
+a skipped session's body is not found, and the search surface reports nothing.
+The skip is named in the deployment log; surfacing it in the UI is deferred.
+
+**The migration refusal itself is left alone.** Teaching the v2→v3 migration to
+transform the `document` kind would make those sessions searchable, but that is
+an upstream decision about what the transformed value should be.

package/README.zh.md

@@ -0,0 +1,41 @@
+# @sparkelf/dsh-patch-session-query-unindexable-session
+
+[English](README.md) | 中文
+
+## Summary
+
+当一个会话的已存日志无法迁移时，仍让内容搜索可用；并让被中断的首次索引不再从零开始。
+
+## Why it is needed
+
+内容搜索要读取每一个会话日志来建立索引。有两种行为让这在 200+ 会话的历史上永久失败：
+
+**一个被迁移拒绝的会话会终止整轮。** v2→v3 的会话格式迁移不会转换内容 kind 为 `document` 的消息，因此冷读抛出 `SessionFormatUnsupportedError`。该抛出逃出观察循环，于是一个会话阻断了其余每一个会话的索引 —— 而由于它每次尝试都被较早读到，索引永远填不满：
+
+```
+format v2 agent/inbox/spliced at seq 4 data.inserted[0].content[0]:
+cannot safely transform unclassified message content kind "document"
+name=SessionFormatUnsupportedError aborted=false
+```
+
+**写入排在整个读取之后。** 在每一个日志被读完之前什么都不会发布，因此一次中断会丢弃全部工作。在这份历史上，第一轮要读取 214 个会话，耗时数分钟。
+
+补丁前的实测：每次搜索之后索引都是**零行**，且每次搜索在 20–38 秒内失败。补丁后：210 个会话、202803 条文档被索引，后续搜索约一秒作答。
+
+## What it changes
+
+| 行为 | 之前 | 之后 |
+|---|---|---|
+| 一个无法迁移其日志的会话 | 让整次搜索失败 | 被跳过并点名；其余仍被索引 |
+| 何时写入一个会话 | 整个语料读完之后 | 一被读取就写 |
+| 提交形态 | 每轮一个事务 | 有界分批 |
+
+## Install
+
+该补丁不携带自己的代码；profile supervisor 会在安装 `@deepseek-ai/dsh-session-query-sqlite` 时把它应用上去。
+
+## Known Limitations and Deferred Work
+
+**被跳过的会话对内容搜索不可见。** 只出现在被跳过会话正文中的词找不到，而搜索界面不报告任何东西。该跳过会在部署日志中被点名；把它呈现在 UI 中属于后续工作。
+
+**迁移拒绝本身未被改动。** 教会 v2→v3 迁移转换 `document` kind 会让那些会话可被搜索，但那是关于转换后的值该为什么的上游决定。

package/package.json

@@ -0,0 +1,39 @@
+{
+  "description": "Skip a session whose stored log cannot be migrated instead of failing the whole content search, and index each session as it is read",
+  "dshPatch": {
+    "formatVersion": 1,
+    "variants": [
+      {
+        "dsh": ">=0.1.6-alpha.1",
+        "file": "./patches/session-query-unindexable-session.patch",
+        "id": "session-query-unindexable-session",
+        "target": {
+          "baseRevision": "ddefc45fbc7f8e46dd73185e68295696d1297887",
+          "kind": "dsh-source",
+          "paths": [
+            "packages/session-query/session-query-sqlite/"
+          ]
+        }
+      }
+    ]
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./patches/session-query-unindexable-session.patch": "./patches/session-query-unindexable-session.patch"
+  },
+  "files": [
+    "patches/*.patch"
+  ],
+  "license": "MIT",
+  "name": "@sparkelf/dsh-patch-session-query-unindexable-session",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "patches/npm/session-query-unindexable-session",
+    "type": "git",
+    "url": "git+https://github.com/SparkElf/deepseek-harness-plus.git"
+  },
+  "type": "module",
+  "version": "0.2.0-rc.9"
+}

package/patches/session-query-unindexable-session.patch

@@ -0,0 +1,90 @@
+diff --git a/packages/session-query/session-query-sqlite/src/index.ts b/packages/session-query/session-query-sqlite/src/index.ts
+index 7c95afa..ccb36da 100644
+--- a/packages/session-query/session-query-sqlite/src/index.ts
++++ b/packages/session-query/session-query-sqlite/src/index.ts
+@@ -11,9 +11,10 @@ import { Context, Service, type Fiber } from '@deepseek-ai/cordis'
+ import z from '@deepseek-ai/schemastery'
+ import type { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session'
+ import type SessionPersistence from '@deepseek-ai/dsh-session-persistence'
+-import type {
+-  SessionPersistenceRevision,
+-  SessionPersistenceSnapshot,
++import {
++  SessionFormatUnsupportedError,
++  type SessionPersistenceRevision,
++  type SessionPersistenceSnapshot,
+ } from '@deepseek-ai/dsh-session-persistence'
+ import SessionQueryEngine, {
+   SESSION_QUERY_DEFAULT_PERSISTED_INSPECT_CONCURRENCY,
+@@ -24,6 +25,7 @@ import SessionQueryEngine, {
+   assertSessionHeadersCompatible,
+   buildSessionEventSearchDocuments,
+   readColdSessionLog,
++  type ColdSessionLog,
+ } from '@deepseek-ai/dsh-session-query'
+ import type {
+   Config as SessionQueryConfig,
+@@ -519,10 +521,27 @@ export class SqliteSessionQueryEngine extends SessionQueryEngine {
+             // live-preferred.
+             if (initiallyLive.has(entry.header.id) || this.ctx.sessions.get(entry.header.id) !== undefined) continue
+             assertNotAborted(signal)
+-            const loaded = await readColdSessionLog(persistence, entry.header.id, signal)
++            let loaded: ColdSessionLog
++            try {
++              loaded = await readColdSessionLog(persistence, entry.header.id, signal)
++            } catch (readError: unknown) {
++              // A session whose stored log cannot be migrated is not indexable,
++              // but it must not stop every other session from being indexed: one
++              // unreadable log would otherwise fail content search on every
++              // attempt, forever. Leave it out of this pass.
++              if (!(readError instanceof SessionFormatUnsupportedError)) throw readError
++              continue
++            }
+             assertNotAborted(signal)
+             assertSessionHeadersCompatible(entry.header, loaded.header)
+             entry.loaded = observeSession(loaded.header, loaded.inheritedEventCount, loaded.events)
++            // Publish this session before reading the next one. The first pass
++            // over a large history reads every log, so deferring the write until
++            // the whole corpus is observed means an interrupt discards all of it
++            // and the next search repeats the same work forever. Committing per
++            // session keeps earlier progress, and the revision check above skips
++            // whatever is already indexed on the next attempt.
++            this._persistObservedSession(entry.loaded, entry.revision)
+           }
+           assertNotAborted(signal)
+           const afterSnapshots = await persistence.list(listOptions)
+@@ -613,6 +632,34 @@ export class SqliteSessionQueryEngine extends SessionQueryEngine {
+     }
+   }
+ 
++  /**
++   * Index one observed session in its own transaction.
++   *
++   * Called while the corpus is being read rather than after it, so a first pass
++   * that is interrupted keeps every session it already indexed. The next pass
++   * skips those by revision and continues where this one stopped.
++   * @param entry - the observed session and its parsed documents.
++   * @param revision - the persistence revision the entry was read at.
++   */
++  private _persistObservedSession(entry: ObservedSession, revision: SessionPersistenceRevision): void {
++    const db = this._requireDb()
++    const generation = this._mainGeneration() + 1
++    db.exec('BEGIN IMMEDIATE')
++    try {
++      this._replacePersistedSession(entry, revision, generation)
++      db.prepare('UPDATE search_state SET global_generation = ? WHERE singleton = 1').run(generation)
++      db.exec('COMMIT')
++    } catch (error: unknown) {
++      try {
++        db.exec('ROLLBACK')
++      } catch {
++        // The write failure is the actionable cause; a rollback failure on the
++        // same broken transaction adds nothing.
++      }
++      throw error
++    }
++  }
++
+   private _replaceLiveSession(entry: ObservedSession, generation: number, persisted: boolean): void {
+     this._deleteSession('live', entry.header.id)
+     const db = this._requireDb()