@aa2246740/dsh-resume 0.2.2 → 0.2.5

package/README.en.md

@@ -2,28 +2,49 @@
 
 [中文](README.md)
 
-```sh
-dsh plugin --profile web add github:aa2246740/dsh-resume
-```
+Bring local Codex, Claude Code, Cursor, Grok, Pi, and ZCode session context into DeepSeek Harness to continue unfinished work.
+
+## Install
+
+**Version 0.2.5 is verified against DeepSeek Harness 0.2.0-rc.2.** Both the package and repository contain compiled plugin files; no Harness source checkout or local build is required. Python 3 is required to read history. Compressed Codex rollouts additionally require `zstd`.
+
+### Official Desktop app
+
+1. Open **Plugins → Add plugin** (under Settings in some versions).
+2. Enter `github:aa2246740/dsh-resume#v0.2.5` in **Package name or address**, then install and enable it.
+3. Follow the installer's activation instructions. Type `/resume-` in the composer and check that all six commands below appear.
+
+Alternatively, download `dsh-resume-0.2.5.tgz` from the [v0.2.5 Release](https://github.com/aa2246740/dsh-resume/releases/tag/v0.2.5) and enter its absolute path in the same installer. Desktop uses its own profile; do not use Web Host commands to install into Desktop.
 
-`dsh plugin add` runs **pnpm** in the web profile. `dsh` (or `npx @deepseek-ai/dsh`) and pnpm must be on `PATH`. The command only writes the profile; it does not hot-load a running Host. Then restart that Host and reload the page. Confirm the slash commands appeared. Do not mount it through both a bundle and a patch.
+### Web Host
 
-Built for official DeepSeek Harness `0.1.7-rc.1`. This repo commits `lib/` and declares `dsh.bundle.patch`, so a `github:` install does not need a build. Node.js `22.19+` or `24+`, Python 3. `zstd` is only needed for compressed Codex rollouts.
+Use the official CLI:
 
-From a clone:
+```sh
+dsh plugin --profile web add github:aa2246740/dsh-resume#v0.2.5
+```
+
+Or, from the downloaded archive's directory:
 
 ```sh
-git clone https://github.com/aa2246740/dsh-resume.git
-dsh plugin --profile web add ./dsh-resume
+dsh plugin --profile web add ./dsh-resume-0.2.5.tgz
 ```
 
+The official `dsh` command and pnpm must be available. Node.js must be `^22.19.0` or `>=24.0.0`. Use the existing Web Host's `DSH_HOME`. This only installs into the Web profile, not Desktop. Follow the official installer's activation result. If it requests a restart, exit and reopen the original Host normally; do not start another Host alongside it.
+
+### Upgrade and remove
+
+Repeat the matching installation steps to upgrade. If migrating from a manual mount, disable the old duplicate entry and retain only the package's `dsh-resume` instance.
+
+Remove through the Desktop plugin manager, or for Web:
+
 ```sh
 dsh plugin --profile web remove dsh-resume
 ```
 
-Continue unfinished Codex, Claude Code, Cursor, Grok, or Pi work inside DeepSeek Harness.
+## Usage
 
-Type `/resume-claude`, or the matching command for the other four. The plugin reads that local session, pulls context that can still be handed off, and writes a card into the current DSH chat. It does not restart the old process or rewrite anyone else's session files.
+Type `/resume-claude`, or the matching command for the other five. The plugin reads that local session, pulls context that can still be handed off, and writes a card into the current DSH chat. It does not restart the old process or rewrite anyone else's session files.
 
 ![Composer with /resume-claude typed](docs/screenshots/composer-resume-claude.png)
 
@@ -37,7 +58,7 @@ The six sections are objective, files, done, remaining, stopped at, and reader w
 
 ## Commands
 
-Read-only. Foreign session stores are not modified. System prompts, hidden reasoning, encrypted or corrupt records are dropped or marked unavailable. History conclusions start as `HISTORY_REPORTED`. Only facts checked in the current workspace this turn are `CURRENT_OBSERVED`. Grok reads visible `updates.jsonl` only. Pi follows the current branch only.
+Read-only. Foreign session stores are not modified. System prompts, hidden reasoning, encrypted or corrupt records are dropped or marked unavailable. History conclusions start as `HISTORY_REPORTED`. Only facts checked in the current workspace this turn are `CURRENT_OBSERVED`. Grok reads visible `updates.jsonl` only. Pi follows the current branch only. ZCode reads `cli/db/db.sqlite` only and does not replay calls or revive the CLI. Compaction is a warning; older rows still in the database are kept. Abandoned `v2/sessions` and `cli/rollout` JSONL are not the primary store. Projects JSONL is a warned fallback only when sqlite is absent.
 
 | Command | Source |
 | --- | --- |
@@ -46,6 +67,7 @@ Read-only. Foreign session stores are not modified. System prompts, hidden reaso
 | `/resume-cursor [latest \| session id \| path \| title]` | Cursor |
 | `/resume-grok [latest \| session id \| path \| title]` | Grok |
 | `/resume-pi [latest \| session id \| path \| title]` | Pi |
+| `/resume-zcode [latest \| session id \| path \| title]` | ZCode |
 
 ## Develop
 

package/README.md

@@ -1,29 +1,70 @@
-# dsh-resume
+# npm installation for DSH 0.2.0-rc.2
 
-[English](README.en.md)
+This npm distribution uses the existing `@aa2246740/dsh-resume` package. Install it under the original `dsh-resume` alias so the bundled Cordis module and client IDs keep resolving correctly.
+
+In the official Desktop plugin manager, enter:
+
+```text
+dsh-resume@npm:@aa2246740/dsh-resume@0.2.5
+```
+
+For Web:
 
 ```sh
-dsh plugin --profile web add github:aa2246740/dsh-resume
+dsh plugin --profile web add dsh-resume@npm:@aa2246740/dsh-resume@0.2.5
 ```
 
-`dsh plugin add` 在 web profile 里跑 **pnpm**。PATH 上要有 `dsh`（或 `npx @deepseek-ai/dsh`）和 pnpm。这条命令只写 profile，不会热挂正在跑的 Host。然后重启这个 Host，刷新页面。确认斜杠命令已经出现。不要同时用 bundle 和 patch 挂两份。
+The runtime files match the [dsh-resume v0.2.5 release](https://github.com/aa2246740/dsh-resume/releases/tag/v0.2.5). Only the npm package name, publish configuration, and this installation note differ.
+
+---
+
+# dsh-resume
+
+[English](README.en.md)
+
+把 Codex、Claude Code、Cursor、Grok、Pi、ZCode 的本机会话整理成可继续工作的上下文，在 DeepSeek Harness 中接着做。
+
+## 安装
 
-面向官方 DeepSeek Harness `0.1.7-rc.1`。仓库已提交编好的 `lib/`，并声明了 `dsh.bundle.patch`，所以 `github:` 安装不用再构建。Node.js `22.19+` 或 `24+`，Python 3。Codex 的压缩 rollout 才需要 `zstd`。
+**0.2.5 面向 DeepSeek Harness 0.2.0-rc.2 验证。** 安装包和仓库均包含编译好的插件，无需下载 Harness 源码或自行构建。读取历史需要本机有 Python 3；读取压缩的 Codex rollout 另需 `zstd`。
 
-本地 clone：
+### 官方桌面端
+
+1. 打开 **插件 → 添加插件**（部分版本入口在设置里）。
+2. 在 **包名或地址** 中填入 `github:aa2246740/dsh-resume#v0.2.5`，然后安装并启用。
+3. 按安装器提示完成激活，在输入框输入 `/resume-`，确认能看到下面列出的六条命令。
+
+也可以在 [v0.2.5 Release](https://github.com/aa2246740/dsh-resume/releases/tag/v0.2.5) 下载 `dsh-resume-0.2.5.tgz`，把该文件的绝对路径填入同一安装框。桌面端使用自己的 desktop profile，无需运行 Web Host 命令。
+
+### Web Host
+
+使用官方 CLI：
+
+```sh
+dsh plugin --profile web add github:aa2246740/dsh-resume#v0.2.5
+```
+
+或在下载的安装包所在目录运行：
 
 ```sh
-git clone https://github.com/aa2246740/dsh-resume.git
-dsh plugin --profile web add ./dsh-resume
+dsh plugin --profile web add ./dsh-resume-0.2.5.tgz
 ```
 
+需要官方 `dsh` 和 pnpm 可用，Node.js 版本为 `^22.19.0` 或 `>=24.0.0`。使用与现有 Web Host 相同的 `DSH_HOME`；这条命令只安装到 Web profile，不会替桌面端安装。按官方安装器返回的提示完成激活；只有它要求重启时，再正常退出并重开原来的 Host，不要启动第二个 Host。
+
+### 升级与卸载
+
+升级时重复对应安装步骤即可。若从旧版手动挂载方式迁移，停用旧的重复挂载行，只保留包自带的 `dsh-resume` 实例。
+
+桌面端通过插件管理器卸载。Web Host 使用：
+
 ```sh
 dsh plugin --profile web remove dsh-resume
 ```
 
-在 DeepSeek Harness 里接着做 Codex、Claude Code、Cursor、Grok、Pi 没做完的事。
+## 使用
 
-输入 `/resume-claude`，另外四条同理。它只读本机那次会话，抽出还能接手的上下文，写成一张交接卡。旧进程不会被拉起来，别人的会话文件也不会被改。
+输入 `/resume-claude`，另外五条同理。它只读本机那次会话，抽出还能接手的上下文，写成一张交接卡。旧进程不会被拉起来，别人的会话文件也不会被改。
 
 ![官方 composer 已输入 /resume-claude](docs/screenshots/composer-resume-claude.png)
 
@@ -37,7 +78,7 @@ dsh plugin --profile web remove dsh-resume
 
 ## 命令
 
-只读，不改任何一家的会话仓库。系统提示、隐藏推理、加密或坏掉的记录要么丢掉，要么标明不可用。历史里的结论先标成 `HISTORY_REPORTED`，这轮在当前仓库里核对过的才是 `CURRENT_OBSERVED`。Grok 只读看得见的 `updates.jsonl`。Pi 只跟当前这条分支。
+只读，不改任何一家的会话仓库。系统提示、隐藏推理、加密或坏掉的记录要么丢掉，要么标明不可用。历史里的结论先标成 `HISTORY_REPORTED`，这轮在当前仓库里核对过的才是 `CURRENT_OBSERVED`。Grok 只读看得见的 `updates.jsonl`。Pi 只跟当前这条分支。ZCode 只读 `cli/db/db.sqlite`，不回放调用、不复活进程。压缩只标成警告，库里仍在的更早记录会保留。废弃的 `v2/sessions` 和 `cli/rollout` JSONL 不是主存储；只有 sqlite 不在时，才对 `projects/` 下的 JSONL 做带警告的尽力读取。
 
 | 命令 | 从哪接着 |
 | --- | --- |
@@ -46,6 +87,7 @@ dsh plugin --profile web remove dsh-resume
 | `/resume-cursor [latest \| 会话 id \| 路径 \| 标题]` | Cursor |
 | `/resume-grok [latest \| 会话 id \| 路径 \| 标题]` | Grok |
 | `/resume-pi [latest \| 会话 id \| 路径 \| 标题]` | Pi |
+| `/resume-zcode [latest \| 会话 id \| 路径 \| 标题]` | ZCode |
 
 ## 开发
 

package/lib/dsh-resume.js

@@ -9,7 +9,8 @@ const FOREIGN_SESSION_PROVIDERS = [
 	"codex",
 	"cursor",
 	"grok",
-	"pi"
+	"pi",
+	"zcode"
 ];
 const FOREIGN_SESSION_ACTIONS = ["show", "list"];
 /**
@@ -267,9 +268,16 @@ const RESUME_SKILL_SPECS = [
 		product: "Pi",
 		description: "继续当前工作目录中的 Pi 会话；可附会话 ID、JSONL 路径或标题关键词。",
 		recoveryBoundary: "The reader follows Pi's current active leaf only and excludes thinking, hooks, system messages, and extension-injected records."
+	},
+	{
+		name: "resume-zcode",
+		provider: "zcode",
+		product: "ZCode",
+		description: "继续当前工作目录中的 ZCode 会话；可附会话 ID、记录路径或标题关键词。",
+		recoveryBoundary: "The reader uses the ZCode sqlite store at cli/db/db.sqlite and does not replay calls or revive the CLI. Abandoned v2 sessions and cli/rollout JSONL are ignored. Projects JSONL is a warned fallback only when sqlite is absent. Compaction is a summary marker; older rows still stored are kept."
 	}
 ];
-/** One source of truth for all five user-only slash skills. */
+/** One source of truth for all six user-only slash skills. */
 function skillRegistration(spec) {
 	return {
 		name: spec.name,
@@ -344,14 +352,14 @@ const JSON_TEXT_OUTPUT = {
 		text: value
 	}]
 };
-/** Register one read-only reader tool and five user-only slash skills. */
+/** Register one read-only reader tool and six user-only slash skills. */
 function apply(ctx) {
 	if (!existsSync(SESSION_READER_PATH)) throw new Error(`dsh-resume: missing bundled reader at ${SESSION_READER_PATH}`);
 	if (!existsSync(GROK_SESSION_READER_PATH)) throw new Error(`dsh-resume: missing pinned Grok reader at ${GROK_SESSION_READER_PATH}`);
 	console.log("[dsh-resume] loaded");
 	ctx.tools.register(defineTool({
 		name: "foreign_session_read",
-		description: "Read Codex, Claude Code, Cursor, Grok, or Pi local session history into a Grok-compatible inert JSON schema. Use only after an explicit resume slash skill or explicit user request. Discovery is scoped to the current DSH working directory; an explicit native ID or path is supported. The tool is read-only and never executes recovered calls.",
+		description: "Read Codex, Claude Code, Cursor, Grok, Pi, or ZCode local session history into a Grok-compatible inert JSON schema. Use only after an explicit resume slash skill or explicit user request. Discovery is scoped to the current DSH working directory; an explicit native ID or path is supported. The tool is read-only and never executes recovered calls.",
 		parameters: {
 			provider: {
 				type: "string",

package/lib/types/dsh-resume.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 export declare const name = "dsh-resume";
 export declare const inject: string[];
-/** Register one read-only reader tool and five user-only slash skills. */
+/** Register one read-only reader tool and six user-only slash skills. */
 export declare function apply(ctx: Context): void;
 export { buildReaderArgs, GROK_SESSION_READER_PATH, runSessionReader, SESSION_READER_PATH, slashReferenceFromSession, slashReferenceFromUserText, } from './reader.ts';
 export { RESUME_SKILL_SPECS, resumeSkillContent, skillRegistration } from './skills.ts';

package/lib/types/reader.d.ts

@@ -1,4 +1,4 @@
-export declare const FOREIGN_SESSION_PROVIDERS: readonly ["claude", "codex", "cursor", "grok", "pi"];
+export declare const FOREIGN_SESSION_PROVIDERS: readonly ["claude", "codex", "cursor", "grok", "pi", "zcode"];
 export type ForeignSessionProvider = typeof FOREIGN_SESSION_PROVIDERS[number];
 export declare const FOREIGN_SESSION_ACTIONS: readonly ["show", "list"];
 export type ForeignSessionAction = typeof FOREIGN_SESSION_ACTIONS[number];

package/lib/types/skills.d.ts

@@ -37,8 +37,14 @@ export declare const RESUME_SKILL_SPECS: readonly [{
     readonly product: "Pi";
     readonly description: "继续当前工作目录中的 Pi 会话；可附会话 ID、JSONL 路径或标题关键词。";
     readonly recoveryBoundary: "The reader follows Pi's current active leaf only and excludes thinking, hooks, system messages, and extension-injected records.";
+}, {
+    readonly name: "resume-zcode";
+    readonly provider: "zcode";
+    readonly product: "ZCode";
+    readonly description: "继续当前工作目录中的 ZCode 会话；可附会话 ID、记录路径或标题关键词。";
+    readonly recoveryBoundary: "The reader uses the ZCode sqlite store at cli/db/db.sqlite and does not replay calls or revive the CLI. Abandoned v2 sessions and cli/rollout JSONL are ignored. Projects JSONL is a warned fallback only when sqlite is absent. Compaction is a summary marker; older rows still stored are kept.";
 }];
-/** One source of truth for all five user-only slash skills. */
+/** One source of truth for all six user-only slash skills. */
 export declare function skillRegistration(spec: ResumeSkillSpec): SkillRegistration;
 export declare function resumeSkillContent(spec: ResumeSkillSpec): string;
 //# sourceMappingURL=skills.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aa2246740/dsh-resume",
-  "version": "0.2.2",
-  "description": "Continue Codex, Claude Code, Cursor, Grok, and Pi work in DeepSeek Harness.",
+  "version": "0.2.5",
+  "description": "Continue Codex, Claude Code, Cursor, Grok, Pi, and ZCode work in DeepSeek Harness.",
   "type": "module",
   "main": "lib/dsh-resume.js",
   "types": "lib/types/dsh-resume.d.ts",
@@ -52,30 +52,31 @@
     "cursor",
     "grok",
     "pi-coding-agent",
+    "zcode",
     "session-handoff"
   ],
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-skill": ">=0.1.7-rc.1 <0.1.8",
-    "@deepseek-ai/dsh-tools": ">=0.1.7-rc.1 <0.1.8"
+    "@deepseek-ai/dsh-skill": ">=0.2.0-rc.1 <0.2.1",
+    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.1 <0.2.1"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.4",
-    "@deepseek-ai/dsh-agent": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-invariants": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-llm": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-ptc-runtime": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-sandbox": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-sandbox-policy": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-scope": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-session": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-session-projection": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-skill": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-tools": "0.1.7-rc.1",
-    "@deepseek-ai/dsh-user-approval": "0.1.7-rc.1",
-    "@types/node": "^22.20.0",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-invariants": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-ptc-runtime": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-scope": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-skill": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-user-approval": "0.2.0-rc.2",
     "semver": "^7.7.2",
+    "@types/node": "^22.20.0",
     "tsdown": "^0.22.2",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3"
@@ -84,5 +85,9 @@
     "bundle": {
       "patch": "./cordis.patch.yml"
     }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
 }

package/resources/dsh_session_reader.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Extend Grok's foreign-session reader with inert Grok and Pi adapters."""
+"""Extend Grok's foreign-session reader with inert Grok, Pi, and ZCode adapters."""
 
 from __future__ import annotations
 
@@ -7,9 +7,13 @@ import argparse
 import json
 import os
 import re
+import shutil
+import sqlite3
 import sys
+import tempfile
+from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, Iterable
+from typing import Any, Iterable, Iterator
 from urllib.parse import quote
 
 import session_reader as core
@@ -21,7 +25,7 @@ for _stream in (sys.stdout, sys.stderr):
         pass
 
 
-EXTENDED_TOOLS = ("grok", "pi")
+EXTENDED_TOOLS = ("grok", "pi", "zcode")
 TOOLS = (*core.TOOLS, *EXTENDED_TOOLS)
 
 
@@ -124,6 +128,10 @@ def _append_text_turn(
 
 class ProviderAdapter:
     tool: str
+    warnings: list[dict[str, str]]
+
+    def __init__(self) -> None:
+        self.warnings = []
 
     def discover(self, cwd: str, within_min: int) -> list[dict[str, Any]]:
         raise NotImplementedError
@@ -956,9 +964,785 @@ class PiAdapter(ProviderAdapter):
         return core._finalize_result(result)
 
 
+_ZCODE_REQUIRED_COLUMNS = {
+    "session": ("id", "directory", "time_created", "time_updated"),
+    "message": ("id", "session_id", "data"),
+    "part": ("message_id", "data"),
+}
+_ZCODE_SESSION_OPTIONAL = ("title", "task_type", "parent_id", "data", "slug", "version")
+_ZCODE_HIDDEN_PARTS = {"reasoning", "thinking", "redacted_reasoning", "redacted-thinking"}
+_ZCODE_STRUCTURAL_PARTS = {"step-start", "step-finish", "step-end"}
+_ZCODE_JSONL_FALLBACK_WARNING = (
+    "ZCode sqlite store was absent; used best-effort JSONL under projects/. "
+    "The primary store is cli/db/db.sqlite. Abandoned v2/sessions and cli/rollout JSONL are not read."
+)
+
+
+def _parse_data_object(raw: Any) -> dict[str, Any] | None:
+    if isinstance(raw, bytes):
+        raw = raw.decode("utf-8", errors="replace")
+    if isinstance(raw, str):
+        if not raw.strip():
+            return None
+        try:
+            raw = json.loads(raw)
+        except json.JSONDecodeError:
+            return None
+    if isinstance(raw, dict):
+        return raw
+    return None
+
+
+def _row_value(row: sqlite3.Row, name: str) -> Any:
+    return row[name] if name in row.keys() else None
+
+
+def _is_abandoned_zcode_path(path: Path) -> bool:
+    parts = [part.casefold() for part in path.expanduser().parts]
+    for index, part in enumerate(parts):
+        if part == "v2" and index + 1 < len(parts) and parts[index + 1] == "sessions":
+            return True
+        if part == "cli" and index + 1 < len(parts) and parts[index + 1] == "rollout":
+            return True
+    return False
+
+
+def _connect_sqlite_snapshot(path: Path) -> tuple[sqlite3.Connection, tempfile.TemporaryDirectory[str] | None]:
+    """Open a private snapshot so a live WAL writer cannot wedge this process."""
+    if not path.is_file() or path.is_symlink():
+        raise core.ReaderError(f"ZCode sqlite store is missing: {path}")
+    temp = tempfile.TemporaryDirectory(prefix="dsh-zcode-")
+    snapshot = Path(temp.name) / "db.sqlite"
+    uri = path.resolve().as_uri()
+    try:
+        source = sqlite3.connect(f"{uri}?mode=ro", uri=True, timeout=1.0)
+        try:
+            source.execute("PRAGMA query_only = ON")
+            source.execute("PRAGMA busy_timeout = 1000")
+            dest = sqlite3.connect(snapshot)
+            try:
+                source.backup(dest)
+            finally:
+                dest.close()
+        finally:
+            source.close()
+        database = sqlite3.connect(f"{snapshot.resolve().as_uri()}?mode=ro", uri=True)
+    except (OSError, sqlite3.Error):
+        try:
+            shutil.copy2(path, snapshot)
+            for suffix in ("-wal", "-shm"):
+                sibling = Path(f"{path}{suffix}")
+                if sibling.is_file() and not sibling.is_symlink():
+                    shutil.copy2(sibling, Path(f"{snapshot}{suffix}"))
+            database = sqlite3.connect(f"{snapshot.resolve().as_uri()}?mode=ro", uri=True)
+        except (OSError, sqlite3.Error):
+            temp.cleanup()
+            temp = None
+            try:
+                database = sqlite3.connect(f"{uri}?mode=ro&immutable=1", uri=True, timeout=1.0)
+            except (OSError, sqlite3.Error) as exc:
+                raise core.ReaderError(f"failed to open ZCode sqlite store {path}: {exc}") from exc
+    database.row_factory = sqlite3.Row
+    try:
+        database.execute("PRAGMA query_only = ON")
+        database.execute("PRAGMA busy_timeout = 1000")
+    except sqlite3.Error as exc:
+        database.close()
+        if temp is not None:
+            temp.cleanup()
+        raise core.ReaderError(f"failed to open ZCode sqlite store {path}: {exc}") from exc
+    return database, temp
+
+
+@contextmanager
+def _zcode_database(path: Path) -> Iterator[sqlite3.Connection]:
+    database, temp = _connect_sqlite_snapshot(path)
+    try:
+        yield database
+    finally:
+        database.close()
+        if temp is not None:
+            temp.cleanup()
+
+
+def _sqlite_tables(database: sqlite3.Connection) -> set[str]:
+    rows = database.execute("SELECT name FROM sqlite_master WHERE type = 'table'").fetchall()
+    return {str(row[0]) for row in rows}
+
+
+def _sqlite_columns(database: sqlite3.Connection, table: str) -> set[str]:
+    rows = database.execute(f'PRAGMA table_info("{table}")').fetchall()
+    return {str(row[1]) for row in rows}
+
+
+def _require_zcode_schema(
+    database: sqlite3.Connection,
+    path: Path,
+) -> tuple[dict[str, set[str]], list[dict[str, str]]]:
+    warnings: list[dict[str, str]] = []
+    tables = _sqlite_tables(database)
+    missing_tables = [name for name in ("session", "message", "part") if name not in tables]
+    if missing_tables:
+        raise core.ReaderError(
+            f"ZCode database {path} is missing required table(s): {', '.join(missing_tables)}"
+        )
+    columns: dict[str, set[str]] = {}
+    for table, required in _ZCODE_REQUIRED_COLUMNS.items():
+        present = _sqlite_columns(database, table)
+        missing = [name for name in required if name not in present]
+        if missing:
+            raise core.ReaderError(
+                f"ZCode table {table} in {path} is missing required column(s): {', '.join(missing)}"
+            )
+        columns[table] = present
+    if "task_type" not in columns["session"]:
+        core._add_warning(
+            warnings,
+            "task_type_unavailable",
+            "ZCode session table has no task_type column; subagent_child sessions could not be filtered.",
+        )
+    return columns, warnings
+
+
+def _selected_columns(present: set[str], required: Iterable[str], optional: Iterable[str]) -> list[str]:
+    names = [name for name in required if name in present]
+    names.extend(name for name in optional if name in present and name not in names)
+    return names
+
+
+def _session_payload(row: sqlite3.Row) -> dict[str, Any]:
+    return _parse_data_object(_row_value(row, "data")) or {}
+
+
+def _session_text(row: sqlite3.Row, payload: dict[str, Any], name: str, *aliases: str) -> str | None:
+    value = _row_value(row, name)
+    if isinstance(value, str) and value.strip():
+        return value
+    for key in (name, *aliases):
+        candidate = payload.get(key)
+        if isinstance(candidate, str) and candidate.strip():
+            return candidate
+    return None
+
+
+def _zcode_tool_part(
+    payload: dict[str, Any],
+    max_tool_chars: int,
+    index: int,
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    state = payload.get("state") if isinstance(payload.get("state"), dict) else {}
+    call_id = (
+        payload.get("callID")
+        or payload.get("callId")
+        or payload.get("toolCallId")
+        or payload.get("id")
+        or f"zcode-call-{index}"
+    )
+    name = payload.get("tool") or payload.get("name") or state.get("tool") or "zcode_tool"
+    raw_input = state.get("input") if "input" in state else payload.get("input", {})
+    call = {
+        "id": core._safe_text(call_id),
+        "name": core._safe_text(name),
+        "input": core._json_preview(raw_input, max_tool_chars),
+        "inert": True,
+    }
+    status = state.get("status")
+    has_output = "output" in state or "error" in state
+    if status in {None, "pending", "running"} and not has_output:
+        return call, None
+    is_error = status in {"error", "failed"}
+    if is_error and state.get("error") not in (None, ""):
+        output: Any = state.get("error")
+    elif "output" in state:
+        output = state.get("output")
+    elif "error" in state:
+        output = state.get("error")
+        is_error = True
+    else:
+        output = ""
+    content = _bounded_text(output, max_tool_chars) if isinstance(output, str) else core._json_preview(output, max_tool_chars)
+    return call, {
+        "tool_use_id": core._safe_text(call_id),
+        "content": content,
+        "is_error": is_error,
+        "unavailable": False,
+        "inert": True,
+    }
+
+
+def _compaction_summary(payload: dict[str, Any]) -> str:
+    for key in ("summary", "text", "content"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            return core._safe_text(value)
+    details: list[str] = []
+    tail = payload.get("tail_start_id") or payload.get("tailStartId")
+    summary_id = payload.get("summaryMessageId") or payload.get("summary_message_id")
+    if isinstance(tail, str) and tail:
+        details.append(f"tail {tail}")
+    if isinstance(summary_id, str) and summary_id:
+        details.append(f"summary message {summary_id}")
+    if isinstance(payload.get("compactBoundary"), dict):
+        details.append("compact boundary present")
+    detail = "; ".join(details) if details else "boundary present"
+    return f"ZCode context was compacted ({detail}). Older rows still in the database were kept."
+
+
+def _message_model(payload: dict[str, Any]) -> str | None:
+    for key in ("modelID", "modelId"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            return value
+    model = payload.get("model")
+    if isinstance(model, str) and model.strip():
+        return model
+    if isinstance(model, dict):
+        for key in ("modelID", "modelId", "id"):
+            value = model.get(key)
+            if isinstance(value, str) and value.strip():
+                return value
+    return None
+
+
+def _assemble_zcode_turns(
+    messages: list[tuple[str, dict[str, Any], list[dict[str, Any]]]],
+    max_tool_chars: int,
+    warnings: list[dict[str, str]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], str | None, int]:
+    """Build inert turns. Compaction markers never drop rows that still exist."""
+    turns: list[dict[str, Any]] = []
+    summaries: list[dict[str, Any]] = []
+    hidden = 0
+    unknown = 0
+    malformed = 0
+    compactions = 0
+    model: str | None = None
+    for message_index, (role, payload, parts) in enumerate(messages):
+        if role == "assistant":
+            found = _message_model(payload)
+            if found:
+                model = found
+        texts: list[str] = []
+        calls: list[dict[str, Any]] = []
+        results: list[dict[str, Any]] = []
+        for part_index, part in enumerate(parts):
+            part_type = part.get("type")
+            if part_type == "text":
+                text = part.get("text")
+                if isinstance(text, str) and text:
+                    texts.append(core._safe_text(text))
+                continue
+            if part_type in _ZCODE_HIDDEN_PARTS:
+                hidden += 1
+                continue
+            if part_type == "tool":
+                call, result = _zcode_tool_part(part, max_tool_chars, message_index * 1000 + part_index)
+                calls.append(call)
+                if result is not None:
+                    results.append(result)
+                continue
+            if part_type == "compaction":
+                compactions += 1
+                summaries.append(
+                    {
+                        "kind": "compaction",
+                        "content": _compaction_summary(part),
+                        "inert": True,
+                    }
+                )
+                continue
+            if part_type in _ZCODE_STRUCTURAL_PARTS:
+                continue
+            unknown += 1
+        text = "\n".join(texts)
+        if text or calls:
+            turns.append(core._turn(role, text=text, tool_calls=calls))
+        if results:
+            turns.append(core._turn("tool", tool_results=results))
+    if malformed:
+        core._add_warning(
+            warnings,
+            "malformed_records_skipped",
+            f"Skipped {malformed} malformed ZCode record(s).",
+        )
+    if hidden:
+        core._add_warning(
+            warnings,
+            "hidden_reasoning_skipped",
+            f"Excluded {hidden} ZCode reasoning or thinking part(s).",
+        )
+    if compactions:
+        core._add_warning(
+            warnings,
+            "compaction_summary",
+            (
+                f"Surfaced {compactions} ZCode compaction marker(s) as summary markers. "
+                "Older rows still present in the database were kept."
+            ),
+        )
+    if unknown:
+        core._add_warning(
+            warnings,
+            "unknown_records_skipped",
+            f"Skipped {unknown} unsupported ZCode part(s).",
+        )
+    return turns, summaries, model, malformed
+
+
+class ZCodeAdapter(ProviderAdapter):
+    """Read ZCode's OpenCode-like sqlite store as inert history.
+
+    Primary store: ``$ZCODE_HOME/cli/db/db.sqlite`` or ``~/.zcode/cli/db/db.sqlite``.
+    ``session.directory`` scopes discovery to the current cwd. ``task_type ==
+    subagent_child`` is omitted from discovery; an explicit native id can still
+    be read. Abandoned ``v2/sessions`` and ``cli/rollout`` JSONL are never a
+    source. ``projects/**/*.jsonl`` is a warned best-effort fallback only when
+    the sqlite file is absent.
+    """
+
+    tool = "zcode"
+
+    @staticmethod
+    def _home() -> Path:
+        configured = os.environ.get("ZCODE_HOME")
+        return Path(configured).expanduser() if configured else Path.home() / ".zcode"
+
+    @classmethod
+    def _database_path(cls) -> Path:
+        return cls._home() / "cli" / "db" / "db.sqlite"
+
+    @classmethod
+    def _projects_root(cls) -> Path:
+        return cls._home() / "projects"
+
+    def _candidate(
+        self,
+        *,
+        session_id: str,
+        path: Path,
+        title: str | None,
+        cwd: str | None,
+        created_ms: int | None,
+        updated_ms: int,
+        task_type: str | None,
+        parent_id: str | None,
+        store: str,
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        source = "zcode" if store == "sqlite" else "zcode-projects-jsonl"
+        return {
+            "tool": "zcode",
+            "source": source,
+            "store": store,
+            "session_id": core._safe_text(session_id),
+            "path": str(path),
+            "title": core._safe_text(title) if title else None,
+            "cwd": core._safe_text(cwd) if cwd else None,
+            "branch": None,
+            "created_at": core._iso_from_millis(created_ms),
+            "updated_at_ms": updated_ms,
+            "updated_at": core._iso_from_millis(updated_ms),
+            "source_repo_root_path": None,
+            "model": core._safe_text(model) if model else None,
+            "task_type": core._safe_text(task_type) if task_type else None,
+            "parent_session": core._safe_text(parent_id) if parent_id else None,
+        }
+
+    def _sqlite_candidates(
+        self,
+        database: sqlite3.Connection,
+        path: Path,
+        columns: dict[str, set[str]],
+        *,
+        include_subagents: bool,
+    ) -> list[dict[str, Any]]:
+        selected = _selected_columns(
+            columns["session"],
+            _ZCODE_REQUIRED_COLUMNS["session"],
+            _ZCODE_SESSION_OPTIONAL,
+        )
+        rows = database.execute(
+            f"SELECT {', '.join(selected)} FROM session ORDER BY time_updated, id"
+        ).fetchall()
+        sessions: list[dict[str, Any]] = []
+        for row in rows:
+            payload = _session_payload(row)
+            task_type = _session_text(row, payload, "task_type", "taskType")
+            if not include_subagents and task_type == "subagent_child":
+                continue
+            session_id = _row_value(row, "id")
+            directory = _session_text(row, payload, "directory", "cwd", "workspace")
+            if not isinstance(session_id, str) or not session_id:
+                continue
+            created_ms = core._timestamp_to_millis(_row_value(row, "time_created"))
+            updated_ms = core._timestamp_to_millis(_row_value(row, "time_updated")) or created_ms or 0
+            sessions.append(
+                self._candidate(
+                    session_id=session_id,
+                    path=path,
+                    title=_session_text(row, payload, "title"),
+                    cwd=directory,
+                    created_ms=created_ms,
+                    updated_ms=updated_ms,
+                    task_type=task_type,
+                    parent_id=_session_text(row, payload, "parent_id", "parentId"),
+                    store="sqlite",
+                )
+            )
+        return sessions
+
+    def _iter_project_jsonl(self) -> Iterable[Path]:
+        root = self._projects_root()
+        if not root.is_dir() or root.is_symlink():
+            return
+        stack = [root]
+        while stack:
+            current = stack.pop()
+            try:
+                children = sorted(current.iterdir(), key=lambda item: item.name)
+            except OSError:
+                continue
+            for child in children:
+                if child.is_symlink() or _is_abandoned_zcode_path(child):
+                    continue
+                if child.is_dir():
+                    if len(child.relative_to(root).parts) <= 3:
+                        stack.append(child)
+                    continue
+                if child.is_file() and child.suffix == ".jsonl":
+                    yield child
+
+    def _jsonl_file_candidates(
+        self,
+        path: Path,
+        cwd: str,
+        *,
+        require_cwd: bool,
+    ) -> list[dict[str, Any]]:
+        records, _malformed = core._read_plain_jsonl(path)
+        groups: dict[str, list[dict[str, Any]]] = {}
+        order: list[str] = []
+        for record in records:
+            session_id = record.get("sessionId") or record.get("session_id")
+            if record.get("type") == "session" and isinstance(record.get("id"), str):
+                session_id = record["id"]
+            if not isinstance(session_id, str) or not session_id.strip():
+                session_id = path.stem
+            if session_id not in groups:
+                groups[session_id] = []
+                order.append(session_id)
+            groups[session_id].append(record)
+        candidates: list[dict[str, Any]] = []
+        for session_id in order:
+            group = groups[session_id]
+            actual_cwd = next(
+                (
+                    value
+                    for record in group
+                    for value in (record.get("cwd"), record.get("directory"))
+                    if isinstance(value, str) and value.strip()
+                ),
+                None,
+            )
+            if require_cwd and not _same_cwd(actual_cwd, cwd):
+                continue
+            if not any(record.get("role") in {"user", "assistant"} for record in group):
+                continue
+            title = next(
+                (
+                    record.get("title")
+                    for record in group
+                    if isinstance(record.get("title"), str) and record["title"].strip()
+                ),
+                None,
+            )
+            timestamps = [
+                core._timestamp_to_millis(record.get("timestamp") or record.get("time"))
+                for record in group
+            ]
+            valid = [value for value in timestamps if value is not None]
+            updated_ms = valid[-1] if valid else core._mtime_millis(path)
+            candidates.append(
+                self._candidate(
+                    session_id=session_id,
+                    path=path,
+                    title=title if isinstance(title, str) else None,
+                    cwd=actual_cwd,
+                    created_ms=valid[0] if valid else None,
+                    updated_ms=updated_ms,
+                    task_type=None,
+                    parent_id=None,
+                    store="projects-jsonl",
+                )
+            )
+        return candidates
+
+    def _discover_sqlite(self, path: Path, cwd: str, within_min: int) -> list[dict[str, Any]]:
+        with _zcode_database(path) as database:
+            columns, warnings = _require_zcode_schema(database, path)
+            self.warnings.extend(warnings)
+            sessions = [
+                candidate
+                for candidate in self._sqlite_candidates(
+                    database,
+                    path,
+                    columns,
+                    include_subagents=False,
+                )
+                if _same_cwd(candidate.get("cwd"), cwd)
+                and core._within(int(candidate.get("updated_at_ms") or 0), within_min)
+            ]
+        return core._sort_and_dedupe(sessions)
+
+    def _discover_jsonl(self, cwd: str, within_min: int) -> list[dict[str, Any]]:
+        sessions: list[dict[str, Any]] = []
+        saw_file = False
+        for path in self._iter_project_jsonl():
+            saw_file = True
+            try:
+                found = self._jsonl_file_candidates(path, cwd, require_cwd=True)
+            except core.ReaderError as exc:
+                core._add_warning(
+                    self.warnings,
+                    "jsonl_fallback",
+                    f"Skipped unreadable ZCode projects JSONL {path}: {exc}",
+                )
+                continue
+            for candidate in found:
+                if core._within(int(candidate.get("updated_at_ms") or 0), within_min):
+                    sessions.append(candidate)
+        if saw_file:
+            core._add_warning(self.warnings, "jsonl_fallback", _ZCODE_JSONL_FALLBACK_WARNING)
+        return core._sort_and_dedupe(sessions)
+
+    def discover(self, cwd: str, within_min: int) -> list[dict[str, Any]]:
+        self.warnings = []
+        path = self._database_path()
+        if path.is_symlink():
+            core._add_warning(
+                self.warnings,
+                "sqlite_store_skipped",
+                f"ZCode sqlite path is a symlink and was not followed: {path}",
+            )
+        elif path.is_file():
+            return self._discover_sqlite(path, cwd, within_min)
+        return self._discover_jsonl(cwd, within_min)
+
+    def candidate_from_path(self, raw_path: str, cwd: str) -> dict[str, Any] | None:
+        path = Path(raw_path).expanduser()
+        if _is_abandoned_zcode_path(path):
+            return None
+        if not path.is_file() or path.is_symlink() or path.suffix != ".jsonl":
+            return None
+        try:
+            found = self._jsonl_file_candidates(path, cwd, require_cwd=False)
+        except core.ReaderError:
+            return None
+        if len(found) == 1:
+            return found[0]
+        if len(found) > 1:
+            raise core.AmbiguousReference(raw_path, found)
+        return None
+
+    def find_id(self, session_id: str, cwd: str) -> dict[str, Any] | None:
+        path = self._database_path()
+        if path.is_file() and not path.is_symlink():
+            with _zcode_database(path) as database:
+                columns, _warnings = _require_zcode_schema(database, path)
+                matches = [
+                    candidate
+                    for candidate in self._sqlite_candidates(
+                        database,
+                        path,
+                        columns,
+                        include_subagents=True,
+                    )
+                    if str(candidate.get("session_id", "")).casefold() == session_id.casefold()
+                ]
+            if len(matches) == 1:
+                return matches[0]
+            if len(matches) > 1:
+                raise core.AmbiguousReference(session_id, matches)
+            return None
+        matches = [
+            candidate
+            for candidate in self._discover_jsonl(cwd, 0)
+            if str(candidate.get("session_id", "")).casefold() == session_id.casefold()
+        ]
+        if len(matches) == 1:
+            return matches[0]
+        if len(matches) > 1:
+            raise core.AmbiguousReference(session_id, matches)
+        return None
+
+    def _load_sqlite_parts(
+        self,
+        database: sqlite3.Connection,
+        columns: dict[str, set[str]],
+        session_id: str,
+    ) -> tuple[list[tuple[str, dict[str, Any], list[dict[str, Any]]]], int]:
+        message_cols = _selected_columns(columns["message"], ("id", "session_id", "data"), ("time_created",))
+        message_order = "time_created, id" if "time_created" in columns["message"] else "rowid"
+        message_rows = database.execute(
+            f"SELECT {', '.join(message_cols)} FROM message WHERE session_id = ? ORDER BY {message_order}",
+            (session_id,),
+        ).fetchall()
+        part_optional = ("id", "session_id", "time_created")
+        part_cols = _selected_columns(columns["part"], ("message_id", "data"), part_optional)
+        part_order = "time_created, rowid" if "time_created" in columns["part"] else "rowid"
+        if "session_id" in columns["part"]:
+            part_rows = database.execute(
+                f"SELECT {', '.join(part_cols)} FROM part WHERE session_id = ? ORDER BY {part_order}",
+                (session_id,),
+            ).fetchall()
+        else:
+            part_rows = database.execute(
+                f"SELECT {', '.join(part_cols)} FROM part WHERE message_id IN "
+                "(SELECT id FROM message WHERE session_id = ?) "
+                f"ORDER BY {part_order}",
+                (session_id,),
+            ).fetchall()
+        parts_by_message: dict[str, list[dict[str, Any]]] = {}
+        malformed = 0
+        for row in part_rows:
+            message_id = _row_value(row, "message_id")
+            payload = _parse_data_object(_row_value(row, "data"))
+            if not isinstance(message_id, str) or payload is None:
+                malformed += 1
+                continue
+            parts_by_message.setdefault(message_id, []).append(payload)
+        messages: list[tuple[str, dict[str, Any], list[dict[str, Any]]]] = []
+        for row in message_rows:
+            message_id = _row_value(row, "id")
+            payload = _parse_data_object(_row_value(row, "data"))
+            if not isinstance(message_id, str) or payload is None:
+                malformed += 1
+                continue
+            role = payload.get("role")
+            if role not in {"user", "assistant"}:
+                malformed += 1
+                continue
+            messages.append((role, payload, parts_by_message.get(message_id, [])))
+        return messages, malformed
+
+    def _read_sqlite(self, candidate: dict[str, Any], max_tool_chars: int) -> dict[str, Any]:
+        path = Path(str(candidate["path"]))
+        session_id = str(candidate.get("session_id") or "")
+        with _zcode_database(path) as database:
+            columns, schema_warnings = _require_zcode_schema(database, path)
+            messages, malformed = self._load_sqlite_parts(database, columns, session_id)
+        warnings = list(schema_warnings)
+        if malformed:
+            core._add_warning(
+                warnings,
+                "malformed_records_skipped",
+                f"Skipped {malformed} malformed ZCode message or part row(s).",
+            )
+        turns, summaries, model, _ignored = _assemble_zcode_turns(messages, max_tool_chars, warnings)
+        if not candidate.get("title"):
+            title = next(
+                (
+                    core._one_line(turn.get("text"), 120)
+                    for turn in turns
+                    if turn.get("role") == "user" and turn.get("text")
+                ),
+                None,
+            )
+        else:
+            title = candidate.get("title")
+        result = {
+            "tool": "zcode",
+            "source": "zcode",
+            "session_id": session_id,
+            "path": str(path),
+            "title": title,
+            "cwd": candidate.get("cwd"),
+            "branch": None,
+            "created_at": candidate.get("created_at"),
+            "updated_at": candidate.get("updated_at"),
+            "source_repo_root_path": None,
+            "model": model or candidate.get("model"),
+            "task_type": candidate.get("task_type"),
+            "parent_session": candidate.get("parent_session"),
+            "turns": turns,
+            "summaries": summaries,
+            "warnings": warnings,
+        }
+        return core._finalize_result(result)
+
+    def _read_jsonl(self, candidate: dict[str, Any], max_tool_chars: int) -> dict[str, Any]:
+        path = Path(str(candidate["path"]))
+        records, malformed = core._read_plain_jsonl(path)
+        wanted = str(candidate.get("session_id") or "")
+        messages: list[tuple[str, dict[str, Any], list[dict[str, Any]]]] = []
+        model: str | None = None
+        for record in records:
+            session_id = record.get("sessionId") or record.get("session_id") or path.stem
+            if record.get("type") == "session":
+                header_id = record.get("id")
+                if isinstance(header_id, str):
+                    session_id = header_id
+            if str(session_id).casefold() != wanted.casefold():
+                continue
+            if record.get("type") == "session":
+                continue
+            role = record.get("role")
+            if role not in {"user", "assistant"}:
+                continue
+            content = record.get("content", record.get("text"))
+            parts: list[dict[str, Any]] = []
+            if isinstance(content, str):
+                parts.append({"type": "text", "text": content})
+            elif isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict):
+                        parts.append(block)
+            elif content is not None:
+                parts.append({"type": "text", "text": core._safe_text(content)})
+            found = _message_model(record)
+            payload = {"role": role}
+            if found:
+                payload["modelID"] = found
+                model = found
+            messages.append((role, payload, parts))
+        warnings: list[dict[str, str]] = []
+        core._add_warning(warnings, "jsonl_fallback", _ZCODE_JSONL_FALLBACK_WARNING)
+        if malformed:
+            core._add_warning(
+                warnings,
+                "malformed_records_skipped",
+                f"Skipped {malformed} malformed ZCode JSONL record(s).",
+            )
+        turns, summaries, assembled_model, _ignored = _assemble_zcode_turns(messages, max_tool_chars, warnings)
+        result = {
+            "tool": "zcode",
+            "source": "zcode-projects-jsonl",
+            "session_id": wanted,
+            "path": str(path),
+            "title": candidate.get("title"),
+            "cwd": candidate.get("cwd"),
+            "branch": None,
+            "created_at": candidate.get("created_at"),
+            "updated_at": candidate.get("updated_at"),
+            "source_repo_root_path": None,
+            "model": assembled_model or model,
+            "task_type": None,
+            "turns": turns,
+            "summaries": summaries,
+            "warnings": warnings,
+        }
+        return core._finalize_result(result)
+
+    def read(self, candidate: dict[str, Any], max_tool_chars: int) -> dict[str, Any]:
+        if candidate.get("store") == "projects-jsonl":
+            return self._read_jsonl(candidate, max_tool_chars)
+        return self._read_sqlite(candidate, max_tool_chars)
+
+
 ADAPTERS: dict[str, ProviderAdapter] = {
     "grok": GrokAdapter(),
     "pi": PiAdapter(),
+    "zcode": ZCodeAdapter(),
 }
 
 
@@ -1070,7 +1854,7 @@ def main(argv: list[str] | None = None) -> int:
                             "tool": args.tool,
                             "cwd": args.cwd,
                             "sessions": sessions,
-                            "warnings": [],
+                            "warnings": list(adapter.warnings),
                         },
                         indent=2,
                         ensure_ascii=True,