draftgo-cli 3.0.52 → 3.0.54

package/README.md

@@ -2,7 +2,7 @@
 
 ## Workflow 2.0
 
-`draftgo context` outputs schema `2.0` with separate `bundled_references`, `live_project`, `live_resources`, `live_apis`, `live_db_meta`, and `live_session` sections. It writes to stdout by default, uses current cloud data on every run, and does not create a persistent context cache. Frontend and custom-service tasks always retain complete live DB Meta.
+The root DraftGo Skill loads automatically in supported AI hosts. Agents read the smallest task-specific Reference set first, then query current project state through precise MCP tools instead of generating an aggregate context bundle.
 
 Pages, navigations, documents, and custom services are long-content resources. Custom services use `draftgo checkout custom-services <id>` and a four-file worktree (`service.go`, `go.mod`, `go.sum`, `service.json`). `commit` saves the shared cloud draft, `test` validates or executes it in the DraftGo Runner, and `publish` explicitly promotes a validated draft without interrupting the current live version. Start later work with `refresh`; it stops when local edits exist. Cloud versions are the only history, while local storage keeps only current content and one base.
 
@@ -24,9 +24,7 @@ CLI 不再依赖 Python 同步脚本，也不会创建 DraftGo 业务资源的
 ## 工作模型
 
 ```text
-draftgo context -> 精确读取本地 Skill / Reference 章节
-                -> 复用一个 MCP 会话并行查询实时上下文
-
+根 SKILL.md -> Agent 按任务读取最少必要的 Reference
 AI 宿主 -> draftgo mcp serve -> DraftGo /mcp
                                      |
                                      +-> 结构化资源、元数据、搜索和正文片段
@@ -35,7 +33,7 @@ draftgo checkout/commit -> DraftGo 专用 HTTP 正文端点
                            （完整 HTML/Markdown 不经过 MCP 上下文）
 ```
 
-- `draftgo context` 是 CLI 聚合编排命令，不是 MCP 工具；它输出 Reference 原文、原始结构化实时结果和每项来源。
+- Agent 负责理解任务语义、选择 Reference，并通过精确 MCP 工具逐步定位相关资源；CLI 不生成聚合上下文包。
 - MCP 用于项目概览、资源搜索/列表、元数据、正文片段和实时 API 调用。
 - `pages`、`navigations` 和 `docs/articles` 的完整正文使用 `checkout` / `commit`。
 - `db_meta`、AIHub、`system_config`、角色、用户、文档分类、自定义服务等结构化资源直接通过 MCP/API 操作，不生成本地索引。
@@ -45,20 +43,19 @@ draftgo checkout/commit -> DraftGo 专用 HTTP 正文端点
 
 ## Agent 阅读顺序
 
-DraftGo Skill 不能被 MCP 替代。根 `SKILL.md` 会在 Skill 触发时自动加载；开发任务默认运行一次匹配领域的 context：
+DraftGo Skill 不能被 MCP 替代。根 `SKILL.md` 会在 Skill 触发时自动加载；Agent 按任务路由渐进读取相关 Reference：
 
 ```text
 已加载的 SKILL.md
--> draftgo context --task frontend --output json
--> 精确 Reference 原文 + MCP 当前状态
--> 按需继续调用 MCP
+-> 读取任务所需的最少 Reference
+-> 用 resource_search / api_search 精确定位
+-> 按需 describe、读取 metadata 或片段
 -> 必要时 checkout 正文
 ```
 
-`context` 先验证并逐字提取当前 CLI 随包 Reference 的固定任务章节，再用同一 MCP 会话并行查询项目、资源、API 和 `db_meta` 数据结构；它不做摘要，也不限制后续 MCP 调用。输出中的 `reference_bundle` 会报告 CLI bundle 与项目已安装 Skill 的版本及同步状态，不同步时先运行 `draftgo update`。页面或导航任务使用 `frontend`，数据、自定义服务、AIHub、正文和项目清点分别可用 `data`、`custom-service`、`aihub`、`content`、`project`。`mcp test` 是连接诊断，不是每次资源查询的前置步骤。
-当前 context JSON 使用 `schema_version: "1.1"`；`live.resources` 和 `live.api` 以带来源的 `pages` 序列保留批量原始响应，`live.data_structures` 保留 db_meta 的 registry、describe 契约及完整分页读取结果。
+页面任务读取 `frontend.md`，按需补读 `runtime.md` / `app-api.md`；数据、自定义服务和 AIHub 任务分别读取对应 Reference。目标明确时不要全量枚举无关资源。`mcp test` 是连接诊断，不是每次资源查询的前置步骤。
 
-只回答无需实时状态的本地规则问题，或需要 context 路由之外的专项资料时，Agent 继续按根 Skill 表格手工补读。静态资源须先区分：平台内置目录由 `frontend.md` 说明，指定页面依赖经 MCP 定位、checkout 后本地搜索，服务器全量文件不能凭现有 Skill、MCP 摘要或 checkout 声称已枚举。
+只回答无需实时状态的本地规则问题时，不必调用 MCP。静态资源须先区分：平台内置目录由 `frontend.md` 说明，指定页面依赖经 MCP 定位、checkout 后本地搜索，服务器全量文件不能凭现有 Skill、MCP 摘要或 checkout 声称已枚举。
 
 Skill 说明产品约束、内置能力和操作规则；MCP 说明当前远端状态；checkout 正文才能证明某个页面完整引用了哪些静态资源。汇报时应明确标注这三类证据，不能互相替代。
 
@@ -104,6 +101,8 @@ draftgo mcp test                # 验证 initialize、tools/list、项目/正文
 draftgo mcp serve               # 启动 stdio -> 远端 Streamable HTTP bridge
 ```
 
+`mcp serve` 会保留远端 `Mcp-Session-Id`。服务重启或 session 过期后，它会自动重新 initialize，并只重试一次被明确拒绝为 session 无效的当前请求；普通工具失败、超时和 5xx 不会自动重试。`mcp test` 使用独立的新连接，只证明当前配置能够建立新 session，不能直接证明宿主此前持有的 session 仍有效。
+
 `setup` 不传 target 时自动检测当前项目的宿主。可用 `--target codex,cursor` 传入多个目标。
 
 当前 MCP 宿主支持：
@@ -156,7 +155,8 @@ DraftGo MCP 预期提供以下工具：
 ## 标准工作流
 
 ```text
-context 一次准备信息
+Agent 按任务读取相关 Reference
+→ MCP 精确定位
 → Agent 自主设计并批量 checkout
 → 独立资源按需并行开发
 → 主 Agent 一次统一验证
@@ -164,13 +164,9 @@ context 一次准备信息
 → draftgo changelog add "<完成结果>"
 ```
 
-无依赖且修改不同资源的工作可以并行；同一文件或 DraftGo 资源全程只分配给一个 Agent。开始并行实现前先确定共享 schema、接口、权限和路由。单页面、强依赖或仍共享主要资源的任务由一个 Agent 完成。主 Agent 负责 context、资源 owner、汇总回读、统一验证、commit 和最终 changelog。
-
-前端任务先准备上下文并按需补充 MCP 定位：
+无依赖且修改不同资源的工作可以并行；同一文件或 DraftGo 资源全程只分配给一个 Agent。开始并行实现前先确定共享 schema、接口、权限和路由。单页面、强依赖或仍共享主要资源的任务由一个 Agent 完成。主 Agent 负责 Reference/MCP 路由、资源 owner、汇总回读、统一验证、commit 和最终 changelog。
 
-```bash
-draftgo context --task frontend --output json
-```
+前端任务先读取 `references/frontend.md`，涉及 iframe、路由、认证或全局层时补读 `runtime.md` / `app-api.md`，再通过 MCP 定位目标资源。
 
 确定全部正文资源后批量 checkout，自主设计并按唯一 owner 编辑，最后统一验证和交付：
 
@@ -208,7 +204,6 @@ draftgo changelog add "完成文档管理系统及角色权限"
 
 | 命令 | 说明 |
 |---|---|
-| `draftgo context --task <task> --output json` | 精确读取任务 Reference 章节，并复用一个 MCP 会话并行查询项目、资源、API 和数据结构；保留原始结果及来源。 |
 | `draftgo map` | 并行读取 pages、navigations、docs/articles 元数据，再叠加本地 checkout 状态；`--type` 可限制一种类型。 |
 | `draftgo checkout <pages|nav|docs> <id...>` | 下载完整正文和 base，校验 hash 后原子落盘；`--force` 可显式覆盖已修改的本地正文。 |
 | `draftgo check` | 默认只检查本地 checkout；`--remote` 额外对比 local/base/manifest/remote 的版本和 hash。 |
@@ -354,8 +349,7 @@ checkout 会通过 MCP 获取元数据和专用下载地址，流式写入临时
 ## 常用选项
 
 - `--project <dir>`：操作指定项目目录，默认当前目录。
-- `--output json`：为 context、map、check、checkout、commit、diff、conflicts、conflict、api 或 delete 输出 JSON。
-- `--task <task>`：选择 context 路由；支持 frontend、data、custom-service、aihub、content、project。
+- `--output json`：为 map、check、checkout、commit、diff、conflicts、conflict、api 或 delete 输出 JSON。
 - `--type <type>`：限制 `map` 查询一种正文资源类型；支持 pages、nav/navigations、docs/articles 及其别名。
 - `--strict`：check/deploy/auto-push 将 warnings 视为失败。
 - `--remote`：让 check 按需对比 checkout 的远端版本和 hash；默认仍为快速离线检查。
@@ -376,7 +370,7 @@ checkout 会通过 MCP 获取元数据和专用下载地址，流式写入临时
 - `--token auto|never`：verify 默认读取 `.draftgo/config.json`，对与 `server` 同源的地址自动附加 `token=<SAT>`；配置无 SAT、跨源地址或 `never` 模式均不附加。
 - `--screenshot on-failure|always|never`：控制 UI 截图。
 - `--delivery local|preview|deploy`：控制 deploy 行为。
-- `--timeout <ms>`：控制 connect、MCP test 或 context 的远端请求超时。
+- `--timeout <ms>`：控制 connect 或 MCP test 的远端请求超时。
 
 设置 `DRAFTGO_NO_UPDATE_CHECK=1` 可关闭 npm 版本检查，适用于离线或 CI 环境。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draftgo-cli",
-  "version": "3.0.52",
+  "version": "3.0.54",
   "description": "Install and manage the DraftGo skill across AI coding agents (Claude Code, Codex, Cursor, Windsurf, Antigravity, Copilot, Gemini, Kiro).",
   "bin": {
     "draftgo": "bin/draftgo.js"
@@ -45,9 +45,8 @@
     "lint": "node scripts/check-syntax.js",
     "validate:skill": "node scripts/validate-skill.js",
     "verify:package": "node scripts/verify-package.js",
-    "test": "npm run lint && npm run validate:skill && npm run verify:package && npm run test:unit && npm run test:context && npm run test:workflow && npm run test:changelog && npm run test:mcp && npm run test:worktree && npm run test:migration && npm run test:local && npm run test:e2e",
+    "test": "npm run lint && npm run validate:skill && npm run verify:package && npm run test:unit && npm run test:workflow && npm run test:changelog && npm run test:mcp && npm run test:worktree && npm run test:migration && npm run test:local && npm run test:e2e",
     "test:unit": "node tests/unit.js",
-    "test:context": "node tests/context.test.js",
     "test:workflow": "node tests/workflow-upgrade.test.js",
     "test:changelog": "node tests/changelog.test.js",
     "test:mcp": "node tests/mcp.test.js",

package/resources/skill/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: draftgo
-description: Use this skill to inspect, develop, debug, or deliver a DraftGo application. Use draftgo context for task-specific references and live MCP discovery, checkout/commit for complete page, navigation, and document bodies, and write the changelog only after all verification and delivery succeed.
+description: Use this skill to inspect, develop, debug, or deliver a DraftGo application. Read task-specific references before using live MCP discovery, use checkout/commit for complete page, navigation, document, and custom-service bodies, and write the changelog only after all verification and delivery succeed.
 ---
 
 ## Workflow 2.0 authority
 
 - Treat pages, navigations, docs/articles, and custom services as checkout resources. Never save complete MCP responses, duplicate source snapshots, temporary Go modules, SDK stubs, executables, or build directories by hand.
-- `context` schema 2.0 separates `bundled_references` from `live_project`, `live_resources`, `live_apis`, and complete `live_db_meta`. It is stdout-only by default and has no persistent or delta cache.
-- Custom-service flow: `context --task custom-service` -> `checkout custom-services` -> edit four files -> `commit` cloud draft -> `test` in the server Runner -> `check --remote` -> `publish` -> `refresh`. CLI and admin UI edit the same cloud draft.
+- The root Skill loads automatically. Before acting, read the smallest relevant Reference set from the task-routing table, then use MCP only for live project evidence.
+- Custom-service flow: read `references/custom-services.md` -> locate the service through MCP -> `checkout custom-services` -> edit four files -> `commit` cloud draft -> `test` in the server Runner -> `check --remote` -> `publish` -> `refresh`. CLI and admin UI edit the same cloud draft.
 - Do not create Task overhead for a small, single-point change. For cross-module, cross-session, or multi-Agent work, create or resume `.draftgo/Task/[YYYY-MM-DD]<slug>/Task.md`. It is the only task state: preserve both the user's original request and the clarified executable requirement, assign one owner per item/resource, and check an item only with verification evidence. Changelog remains the final delivery record, not a task tracker.
 - Normal delivery uses `draftgo verify`; add `--remote` only when remote comparison is required and `--url` only for browser evidence. UI verification is iframe-aware and defaults to one viewport with no screenshot. Only explicit visual acceptance or regression diagnosis may pass `--viewport both` or `--screenshot on-failure|always`.
 - `.draftgo/tmp/` is entirely disposable. CLI data uses `.draftgo/tmp/<command>/<run-id>/`; AI-created scratch files use `.draftgo/tmp/ai/<run-id>/`. User-facing evidence belongs under registered `.draftgo/artifacts/`. Use `draftgo clean --dry-run` before `draftgo clean --yes`.
@@ -19,19 +19,13 @@ description: Use this skill to inspect, develop, debug, or deliver a DraftGo app
 - 本地 Skill / Reference 提供产品约束、运行机制和实践；MCP 提供当前项目、资源、API、权限与 schema。
 - pages、navigations、docs/articles 的完整正文只通过 `draftgo checkout`、本地 worktree 和 `draftgo commit` 处理，不放进 MCP 参数、结果、日志或聊天上下文。
 - db_meta、AIHub、system_config、roles、users、doc_categories 和自定义服务元数据直接通过 MCP 读写，不建立本地索引。
-- `draftgo context` 是 CLI 的一次性编排入口，不是 MCP 工具；它加载相关 Reference 章节并复用一个 MCP 会话查询实时信息。MCP 不可用时报告连接、协议或 SAT 问题，不回退到旧索引或 `pull --all`。
+- 根 Skill 会在触发时自动加载。Agent 必须先按任务读取最少必要的 Reference，再通过 MCP 获取实时项目证据；MCP 不可用时报告连接、协议或 SAT 问题，不回退到旧索引或 `pull --all`。
 - CLI 不提供页面模板，不预设页面骨架、视觉风格、原生技术或组件库选择。Agent 根据任务、受众、现有产品语言和可用资源自主设计。
 - 本地 Docker、MySQL、Redis、Milvus 与 `draftgo local ...` 独立于 MCP 工作流，必须保留。
 
 ## 任务路由
 
-开发、修改或交付先运行一次：
-
-```bash
-draftgo context --task <frontend|data|custom-service|aihub|content|project> --output json
-```
-
-context 会校验本地 Reference，返回逐字章节、来源、实时项目/资源/API/数据结构和 bundle 同步状态；不同步时先运行 `draftgo update`。它不会限制后续 MCP 查询。只回答本地规则或需要 context 未加载的专题时，直接补读对应 Reference：
+根 Skill 自动加载后，Agent 根据用户任务先读取下表中最少必要的 Reference，再用 MCP 查询当前项目。不要预先读取所有 Reference，也不要在目标明确时全量枚举无关资源：
 
 | 任务 | 专题资料与后续动作 |
 |---|---|
@@ -50,7 +44,7 @@ context 会校验本地 Reference，返回逐字章节、来源、实时项目/
 - 同一文件或 DraftGo 资源全程只能由一个 Agent 修改；其他 Agent 只读分析并回传建议。
 - 先确定共享 schema、接口、权限和 route，再并行处理无依赖且 owner 不冲突的工作单元。
 - 单页面、强依赖或仍共享主要资源的任务不强行并行。
-- 主 Agent 负责一次 context、owner 分配、汇总回读、统一验证、交付和完成日志；子 Agent 不单独写 changelog。
+- 主 Agent 负责 Reference/MCP 路由、owner 分配、汇总回读、统一验证、交付和完成日志；子 Agent 不单独写 changelog。
 - 冲突 owner、接口依赖或验证失败会阻塞依赖项，不影响无关分支继续汇总。
 
 ## 开发与交付

package/resources/skill/init/SKILL.md

@@ -17,7 +17,7 @@ description: Install or refresh the DraftGo skill, connect a project to a DraftG
    - 已有 DraftGo 服务器：运行 draftgo connect。
    - 需要本地 Docker 基座：运行 draftgo local setup。
 6. 连接后运行 draftgo mcp setup（或指定目标），再运行 draftgo mcp test 验证 initialize、tools/list 和关键工具。
-7. 运行 `draftgo context --task project --output json`，一次取得本地规则原文与远端实时上下文；只有需要叠加本地 checkout 状态时再运行 `draftgo map`。MCP 不可用时报告原因，不回退到 pull --all。
+7. 根 Skill 自动加载后，按实际任务读取最少必要的 Reference，并通过 MCP project_overview、resource_search 或 api_search 获取实时信息；需要叠加本地 checkout 状态时运行 `draftgo map`。MCP 不可用时报告原因，不回退到 pull --all。
 
 draftgo init 只负责 Skill 安装；draftgo connect 负责保存并验证 server/SAT；draftgo mcp setup 负责宿主配置。不要混用职责。
 
@@ -33,7 +33,7 @@ draftgo init 只负责 Skill 安装；draftgo connect 负责保存并验证 serv
 ## 后续动作
 
 - 宿主配置和诊断：draftgo mcp setup/status/test，详见 ../references/mcp.md。
-- 开发上下文：先运行匹配领域的 `draftgo context --task <task> --output json`；context 后仍可按需直接调用 MCP。
+- 开发准备：根 Skill 自动加载；按任务路由读取最少必要的 Reference，再按需直接调用 MCP。
 - 远端资源补充定位：MCP project_overview、resource_search、resource_list。
 - 正文编辑：自主设计并批量 checkout，不同资源按唯一 owner 并行修改，由主 Agent 统一运行 check、交付前 verify、diff 和 commit。
 - 结构化资源：直接使用 MCP 的 api_search、api_describe、api_call；不 checkout、不生成本地镜像。

package/resources/skill/manifest.json

@@ -2,13 +2,13 @@
   "schema_version": "1.0",
   "id": "draftgo",
   "name": "DraftGo 开发助手",
-  "version": "3.0.52",
+  "version": "3.0.54",
   "entry": "SKILL.md",
-  "description": "以 context 聚合编排、Skill/reference 原文、MCP 实时发现、长正文 checkout/commit、统一验证和完成日志为边界的 DraftGo 工作流。",
+  "description": "以 Skill/reference 任务路由、MCP 实时发现、长正文 checkout/commit、统一验证和完成日志为边界的 DraftGo 工作流。",
   "license": "MIT",
   "capabilities": [
     "draftgo-development",
-    "context-orchestration",
+    "reference-routing",
     "completion-changelog",
     "custom-service-ai-sdk",
     "mcp-bridge",

package/resources/skill/references/checkout.md

@@ -98,7 +98,7 @@ base 已变化时必须拒绝覆盖。
 4. 完整正文不得作为 MCP tool 参数发送。
 5. 底座确认 hash 和新版本后，CLI 原子更新 `.base` 与 manifest。返回 hash 不一致时不得推进基线。
 
-推荐编辑顺序：主 Agent 执行一次 context -> MCP 按需补充定位 -> Agent 自主设计并批量 checkout -> 独立资源按唯一 owner 并行编辑 -> 主 Agent 汇总回读 -> 统一运行一次 `draftgo check` -> `draftgo diff` -> commit -> 页面变化时用 `draftgo verify <type> <id> --remote --url <url>` 验证远端已提交版本。遇到本地正文已经等于远端、但 base/manifest 落后时，先用 `draftgo check --remote` 确认 `committed_unrecorded`，再运行 `draftgo reconcile`；不要手改 manifest。
+推荐编辑顺序：主 Agent 按任务读取相关 Reference -> MCP 精确定位 -> Agent 自主设计并批量 checkout -> 独立资源按唯一 owner 并行编辑 -> 主 Agent 汇总回读 -> 统一运行一次 `draftgo check` -> `draftgo diff` -> commit -> 页面变化时用 `draftgo verify <type> <id> --remote --url <url>` 验证远端已提交版本。遇到本地正文已经等于远端、但 base/manifest 落后时，先用 `draftgo check --remote` 确认 `committed_unrecorded`，再运行 `draftgo reconcile`；不要手改 manifest。
 
 单个 commit 成功不自动写 changelog。只有整个任务统一验证且全部 commit/MCP 交付成功后，主 Agent 才执行一次 `draftgo changelog add "<完成结果>"`。任何检查失败、409/412 或交付失败都不得写入。
 

package/resources/skill/references/mcp.md

@@ -12,7 +12,7 @@ DraftGo MCP 用于实时发现、结构化查询和普通 API 操作。完整 pa
 MCP tool result 或参数传输；需要全文时使用 `draftgo checkout`，提交时使用 `draftgo commit`。MCP 返回
 `artifact` / `omitted` 时保留该语义，不要尝试重新展开长内容。
 
-`draftgo context` 是注册在 CLI 的确定性编排命令，不是 MCP 工具，也不得在 MCP 服务端新增同名或等价的聚合工具。它先精确读取任务路由中的本地 Reference 章节，再复用一个 MCP 会话并行查询项目、资源、API 和数据结构，原样输出结构化结果及来源。context 完成后，Agent 仍可按需继续直接调用任意现有 MCP 工具。
+不要在 CLI 或 MCP 服务端增加聚合上下文工具。自然语言任务的语义筛选由已加载根 Skill 的 Agent 完成：先读取任务路由指定的最少必要 Reference，再调用下面的精确 MCP 工具，并根据结果逐步缩小范围。
 
 标准发现顺序：
 
@@ -75,18 +75,18 @@ describe 缺少与本次调用有关的参数、请求体、responses、permissi
 ## CLI
 
 ```bash
-draftgo context --task frontend --output json
 draftgo mcp setup [target...]
 draftgo mcp status [target...]
 draftgo mcp test
 draftgo mcp serve
 ```
 
-- `context` 是开发任务的一次性准备入口；不保存业务镜像，不传输完整正文。
 - `setup` 写入项目级宿主配置，只替换 `draftgo` MCP 条目并保留其他配置。
 - `status` 检查配置是否存在、格式是否有效，以及是否误写了凭据或远端 URL。
 - `test` 从 `.draftgo/config.json` 读取连接，验证 initialize、tools/list、三类正文 resource_list，以及 db_meta 的 api_search、api_describe 和只读 api_call。
-- `serve` 启动 stdio bridge，把宿主请求代理到当前项目配置的远端 Streamable HTTP `/mcp`。
+- `serve` 启动 stdio bridge，把宿主请求代理到当前项目配置的远端 Streamable HTTP `/mcp`。远端重启或 session 过期后，bridge 会清除旧 `Mcp-Session-Id`、重新 initialize，并对被明确拒绝为 session 无效的当前请求重试一次；普通超时、服务端错误和工具错误不会自动重试。
+
+`draftgo mcp test` 每次使用独立的新连接，因此它证明当前 server、SAT 和协议可以建立新 session，不代表宿主已持有的旧 session 仍然有效。宿主工具报告 session 失效但 `mcp test` 成功时，bridge 应自动恢复；若恢复仍失败，再检查远端日志、代理头传递和服务可用性。
 
 `draftgo connect` 保存并验证 server/SAT、探测 `/mcp` 和关键工具，并可提示宿主 setup；`--server` 表示基础地址，完整 MCP endpoint 使用 `--mcp-url` 显式传入。它不下载业务资源，
 也不创建 pages、navigation、docs、db_meta 等本地镜像。底座仍在开发或暂不可达时，报告诊断结果即可，

package/src/cli.js

@@ -31,7 +31,6 @@ const VALUE_FLAGS = new Set([
   'params',
   'input',
   'type',
-  'task',
   'title',
   'description',
   'item-id',

package/src/commandRegistry.js

@@ -7,7 +7,6 @@ const commands = [
   { name: 'update', run: (dir, args, flags) => require('./commands/update')(dir, args, flags) },
   { name: 'uninstall', aliases: ['remove'], run: (dir, args, flags) => require('./commands/uninstall')(dir, args, flags) },
   { name: 'status', run: (dir) => require('./commands/status')(dir) },
-  { name: 'context', run: (dir, args, flags) => require('./commands/context')(dir, args, flags) },
   { name: 'changelog', run: (dir, args, flags) => require('./commands/changelog')(dir, args, flags) },
   { name: 'task', run: (dir, args, flags) => require('./commands/task')(dir, args, flags) },
   { name: 'clean', run: (dir, args, flags) => require('./commands/clean')(dir, args, flags) },

package/src/commands/help.js

@@ -17,8 +17,7 @@ DraftGo Next frontend baseline: React + Vite.
 Database pages may use native web technologies or bundled component libraries.
 MCP handles live discovery and structured resources; complete page, navigation,
 document, and custom-service bodies use checkout/commit outside MCP context.
-The context command combines exact local Reference sections with live MCP data;
-it is a CLI orchestration command, not an MCP tool.
+The installed Skill routes agents to task-specific References and MCP tools.
 
 Usage:
   draftgo init [<target>...]       Install the DraftGo Skill. No target = detect.
@@ -37,9 +36,6 @@ Usage:
   draftgo mcp test                 Test project, resource, and API MCP calls.
   draftgo mcp serve                Bridge local stdio to the remote /mcp endpoint.
 
-  draftgo context --task <task>    Read exact task Reference sections, then reuse
-                                    one MCP session to query project, resources,
-                                    APIs, and data structures in parallel.
   draftgo map                      Read remote overview/resources through MCP and
                                     overlay local checkout state.
   draftgo checkout <type> <id...>  Download pages/nav/docs body + verified base.
@@ -110,7 +106,7 @@ Important flags:
   --mcp-url <url>          (connect) Explicit endpoint; standard /mcp derives the
                            base URL; custom paths also need --server.
   --token <sat>            (connect) SAT for non-interactive use.
-  --timeout <ms>           (connect/mcp test/context) Network timeout.
+  --timeout <ms>           (connect/mcp test) Network timeout.
   --allow-offline          (connect) Save only after explicitly accepting a
                            failed MCP validation.
   --no-mcp-setup           (connect) Do not write host MCP configuration.
@@ -121,8 +117,6 @@ Important flags:
   --local-dev              (init) Continue into local Docker setup.
   --no-setup               (init) Install the Skill without either setup flow.
   --output json            Print machine-readable output where supported.
-  --task <task>            (context) frontend | data | custom-service | aihub |
-                           content | project.
   --type <type>            (map) pages | nav/navigations | docs/articles.
   --strict                 Treat check warnings as failures.
   --remote                 (check) Compare checkout hashes/versions with remote.
@@ -167,7 +161,6 @@ Examples:
   draftgo init codex
   draftgo connect codex --server https://draftgo.example --token <sat>
   draftgo mcp test
-  draftgo context --task frontend --output json
   draftgo map --output json
   draftgo checkout pages 42
   draftgo check --strict

package/src/mcp/client.js

@@ -65,6 +65,44 @@ class McpRpcError extends Error {
   }
 }
 
+const SESSION_INVALID_CODES = new Set([
+  -32002,
+  'SESSION_EXPIRED',
+  'SESSION_NOT_FOUND',
+  'MCP_SESSION_EXPIRED',
+  'MCP_SESSION_NOT_FOUND',
+]);
+
+function isSessionInvalidError(error) {
+  if (!error) return false;
+  if (Number(error.status) === 404) return true;
+  const code = error.code != null
+    ? error.code
+    : error.rpc && error.rpc.error && error.rpc.error.code;
+  if (SESSION_INVALID_CODES.has(code)) return true;
+  const message = String(error.message
+    || error.rpc && error.rpc.error && error.rpc.error.message
+    || '');
+  return /\b(?:mcp\s+)?session(?:\s+id)?\s+(?:was\s+)?(?:not\s+found|expired|invalid|unknown|lost)\b/i.test(message)
+    || /\b(?:server|mcp)\s+(?:is\s+)?(?:not initialized|uninitialized)\b/i.test(message)
+    || /\binitialize first\b/i.test(message);
+}
+
+function requestIdKeys(message) {
+  const messages = Array.isArray(message) ? message : [message];
+  return new Set(messages
+    .filter((item) => isObject(item) && typeof item.method === 'string' && item.id != null)
+    .map((item) => `${typeof item.id}:${JSON.stringify(item.id)}`));
+}
+
+function sessionInvalidResponse(message, expectedIds) {
+  const messages = Array.isArray(message) ? message : [message];
+  return messages.find((item) => isObject(item)
+    && item.error
+    && expectedIds.has(`${typeof item.id}:${JSON.stringify(item.id)}`)
+    && isSessionInvalidError(item.error)) || null;
+}
+
 function diagnosticNextCursor(result) {
   const value = diagnosticData(result);
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
@@ -154,6 +192,9 @@ class DraftGoMcpClient {
     this.sessionId = null;
     this.protocolVersion = options.protocolVersion || DEFAULT_PROTOCOL_VERSION;
     this.nextId = 1;
+    this.sessionGeneration = 0;
+    this.sessionRecovery = null;
+    this.sessionRecoveryCount = 0;
     this.onMessage = typeof options.onMessage === 'function' ? options.onMessage : null;
   }
 
@@ -163,28 +204,65 @@ class DraftGoMcpClient {
     }
 
     const initialize = findInitializeRequest(message);
+    const internalRecovery = options._sessionRecoveryInternal === true;
+    if (!initialize && !internalRecovery && this.sessionRecovery) {
+      await this.sessionRecovery;
+    }
+    if (initialize) this.sessionId = null;
     const requestedVersion = initialize
       && initialize.params
       && initialize.params.protocolVersion;
     const delivered = [];
+    const expectedIds = requestIdKeys(message);
+    const attemptedSessionId = initialize ? null : this.sessionId;
+    const attemptedGeneration = this.sessionGeneration;
+    const canRecover = !initialize
+      && !internalRecovery
+      && options._sessionRecoveryAttempted !== true
+      && attemptedSessionId != null;
+    let suppressedSessionError = null;
 
     try {
       await postJsonRpc(this.config, message, {
         signal: options.signal,
         timeoutMs: options.timeoutMs,
-        sessionId: this.sessionId,
+        sessionId: attemptedSessionId,
         protocolVersion: requestedVersion || this.protocolVersion,
-        onSession: (sessionId) => { this.sessionId = sessionId; },
+        onSession: (sessionId) => {
+          if (initialize || (this.sessionGeneration === attemptedGeneration
+              && this.sessionId === attemptedSessionId)) {
+            this.sessionId = sessionId;
+          }
+        },
         onMessage: (remoteMessage) => {
           const safe = redactValue(remoteMessage, this.secrets);
           delivered.push(safe);
+          const invalid = canRecover && sessionInvalidResponse(safe, expectedIds);
+          if (invalid) {
+            suppressedSessionError = invalid;
+            return;
+          }
+          if (options._suppressCallbacks === true) return;
           if (this.onMessage) this.onMessage(safe);
           if (typeof options.onMessage === 'function') options.onMessage(safe);
         },
       });
+      if (suppressedSessionError) {
+        const remoteError = suppressedSessionError.error;
+        const error = new McpRpcError(
+          remoteError.message || `MCP error ${remoteError.code}`,
+          { code: remoteError.code, data: remoteError.data, id: suppressedSessionError.id },
+        );
+        error.rpc = suppressedSessionError;
+        throw error;
+      }
     } catch (error) {
       if (error && error.rpc) error.rpc = redactValue(error.rpc, this.secrets);
       if (error && error.message) error.message = redactText(error.message, this.secrets);
+      if (canRecover && isSessionInvalidError(error)) {
+        await this.recoverSession(attemptedSessionId, attemptedGeneration, options);
+        return this.forward(message, { ...options, _sessionRecoveryAttempted: true });
+      }
       throw error;
     }
 
@@ -196,6 +274,54 @@ class DraftGoMcpClient {
     return delivered;
   }
 
+  async recoverSession(failedSessionId, failedGeneration, options = {}) {
+    if (this.sessionGeneration !== failedGeneration) return;
+    if (this.sessionId != null && this.sessionId !== failedSessionId) return;
+    if (this.sessionRecovery) return this.sessionRecovery;
+
+    const recoveryNumber = this.sessionRecoveryCount + 1;
+    this.sessionId = null;
+    const recovery = (async () => {
+      if (typeof options.onSessionRecovery === 'function') {
+        options.onSessionRecovery('started', { attempt: recoveryNumber });
+      }
+      try {
+        await this.initialize({
+          id: `draftgo-session-recovery-${recoveryNumber}`,
+          protocolVersion: this.protocolVersion,
+          timeoutMs: options.timeoutMs,
+          signal: options.signal,
+          _sessionRecoveryInternal: true,
+          _suppressCallbacks: true,
+        });
+        this.sessionRecoveryCount = recoveryNumber;
+        if (typeof options.onSessionRecovery === 'function') {
+          options.onSessionRecovery('succeeded', { attempt: recoveryNumber });
+        }
+      } catch (error) {
+        this.sessionId = null;
+        if (typeof options.onSessionRecovery === 'function') {
+          options.onSessionRecovery('failed', { attempt: recoveryNumber });
+        }
+        const message = redactText(error && error.message ? error.message : error, this.secrets);
+        const wrapped = new McpRpcError(`DraftGo MCP session recovery failed: ${message}`, {
+          code: error && error.code != null ? error.code : -32000,
+          data: error && error.data,
+        });
+        wrapped.status = Number(error && error.status) || 0;
+        wrapped.sessionRecovery = true;
+        wrapped.cause = error;
+        throw wrapped;
+      }
+    })();
+    this.sessionRecovery = recovery;
+    try {
+      await recovery;
+    } finally {
+      if (this.sessionRecovery === recovery) this.sessionRecovery = null;
+    }
+  }
+
   async request(method, params, options = {}) {
     const id = options.id == null ? this.nextId++ : options.id;
     const message = { jsonrpc: '2.0', id, method };
@@ -249,6 +375,7 @@ class DraftGoMcpClient {
       throw error;
     }
     if (typeof options.onStage === 'function') options.onStage('initialized', 'succeeded');
+    this.sessionGeneration += 1;
     return result;
   }
 
@@ -425,6 +552,7 @@ class DraftGoMcpClient {
       initialized,
       protocolVersion: this.protocolVersion,
       sessionId: this.sessionId,
+      sessionRecoveries: this.sessionRecoveryCount,
       tools,
       testedTool: tested[0].name,
       toolResult: tested[0].result,
@@ -457,6 +585,7 @@ module.exports = {
   diagnosticData,
   diagnosticNextCursor,
   findDBMetaListOperation,
+  isSessionInvalidError,
   redactValue,
   testConnection,
   callTool,

package/src/commands/context.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const log = require('../logger');
-const { collectContext, compactContext, TASK_PROFILES } = require('../context');
-const { parseTimeout } = require('../timeout');
-
-function printUsage() {
-  log.err('Usage: draftgo context --task <task> --output json');
-  log.dim(`  tasks: ${Object.keys(TASK_PROFILES).join(', ')}`);
-}
-
-async function contextCommand(projectDir, positional = [], flags = {}) {
-  if (positional.length || !flags.task || (flags.output && flags.output !== 'json')) {
-    printUsage();
-    return 1;
-  }
-  const result = await collectContext(projectDir, flags.task, {
-    timeoutMs: parseTimeout(flags.timeout),
-  });
-  console.log(JSON.stringify(flags.compact ? compactContext(result) : result, null, 2));
-  return 0;
-}
-
-contextCommand.printUsage = printUsage;
-contextCommand.parseTimeout = parseTimeout;
-
-module.exports = contextCommand;

package/src/context/index.js

@@ -1,662 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-const pkg = require('../../package.json');
-const { RESOURCES_DIR } = require('../paths');
-const { loadProjectConfig } = require('../projectConfig');
-const { TOOL_NAMES, openToolSession } = require('../mcp/tools');
-const { readInstalledVersion } = require('../skill');
-
-const SKILL_ROOT = path.join(RESOURCES_DIR, 'skill');
-const MAX_STRUCTURED_TEXT_BYTES = 1024 * 1024;
-const LONG_CONTENT_RESOURCE_TYPES = Object.freeze([
-  'pages',
-  'navigations',
-  'docs/articles',
-  'custom_services',
-]);
-const DB_META_LIST_PATH = '/api/db-meta';
-const DB_META_PAGE_SIZE = 100;
-
-const TASK_PROFILES = Object.freeze({
-  frontend: {
-    apiQueries: [
-      { resource_type: 'pages' },
-      { resource_type: 'navigations' },
-      { resource_type: 'db' },
-    ],
-    references: [
-      {
-        file: 'references/architecture.md',
-        headings: ['核心概念（30 秒）', 'App 对象是什么（1 分钟）', '技术栈（30 秒）'],
-      },
-      {
-        file: 'references/modules.md',
-        headings: ['可开发模块（开发者负责实现）', '平台内置模块（开箱即用，不需实现）'],
-      },
-      {
-        file: 'references/frontend.md',
-        headings: [
-          '页面开发强制规则',
-          '页面实践经验',
-          '必须 / 禁止',
-          '前端底座与组件库清单',
-          '本地静态资源清单',
-          'GSAP 动效规范',
-          '颜色 Token（强制）',
-          '导航栏开发',
-          '退出登录',
-          '加载体验',
-          '选择器与表单体验',
-        ],
-      },
-      {
-        file: 'references/runtime.md',
-        headings: [
-          'iframe 注入机制',
-          'App 对象来源',
-          'URL 参数读取（标准三阶回落）',
-          '全局事件',
-          '前端全局层',
-        ],
-      },
-      {
-        file: 'references/app-api.md',
-        headings: ['请求', '反馈', '路由', '状态', '主题', '其他'],
-      },
-      { file: 'references/mcp.md', headings: ['API 发现与调用'] },
-      {
-        file: 'references/checkout.md',
-        headings: ['适用范围', '命令', 'Commit 流程', '409 / 412 冲突'],
-      },
-    ],
-  },
-  data: {
-    apiQueries: [{ resource_type: 'db' }],
-    references: [
-      {
-        file: 'references/modules.md',
-        headings: ['可开发模块（开发者负责实现）', '模块选型决策'],
-      },
-      {
-        file: 'references/data.md',
-        headings: [
-          'DB Meta 结构',
-          '关联关系（ref）',
-          'CRUD 操作范式',
-          'filters 操作符',
-          'db_meta 实时契约',
-          '通用筛选参数（非动态 DB）',
-        ],
-      },
-      { file: 'references/mcp.md', headings: ['API 发现与调用', '协议与安全'] },
-    ],
-  },
-  'custom-service': {
-    apiQueries: [{ resource_type: 'custom_scripts' }],
-    references: [
-      {
-        file: 'references/modules.md',
-        headings: ['可开发模块（开发者负责实现）', '模块选型决策', '自定义服务边界'],
-      },
-      {
-        file: 'references/custom-services.md',
-        headings: [
-          '最小服务',
-          '资源读写',
-          '触发器',
-          '平台 SDK',
-          '权限与运行限制',
-          '实时 API',
-          '验收清单',
-        ],
-      },
-      {
-        file: 'references/data.md',
-        headings: ['自定义服务内的 draftgo.DB.Query', 'filters 操作符'],
-      },
-      { file: 'references/mcp.md', headings: ['API 发现与调用', '协议与安全'] },
-    ],
-  },
-  aihub: {
-    apiQueries: [
-      { resource_type: 'aihub' },
-      { resource_type: 'agents' },
-    ],
-    references: [
-      {
-        file: 'references/aihub.md',
-        headings: ['条目骨架', '`data.spec` 字段地图', '观测'],
-      },
-      {
-        file: 'references/chat-sdk.md',
-        headings: [
-          '最小接入',
-          '协议',
-          '配置与布局',
-          'JavaScript API 与事件',
-          '历史与会话',
-          '鉴权与安全',
-        ],
-      },
-      { file: 'references/mcp.md', headings: ['API 发现与调用', '协议与安全'] },
-    ],
-  },
-  content: {
-    apiQueries: [
-      { resource_type: 'pages' },
-      { resource_type: 'navigations' },
-      { resource_type: 'docs/articles' },
-    ],
-    references: [
-      { file: 'references/architecture.md', headings: ['核心概念（30 秒）'] },
-      { file: 'references/modules.md', headings: ['可开发模块（开发者负责实现）'] },
-      {
-        file: 'references/checkout.md',
-        headings: ['适用范围', '命令', 'Checkout 流程', 'Commit 流程', '409 / 412 冲突'],
-      },
-    ],
-  },
-  project: {
-    apiQueries: [
-      { resource_type: 'pages' },
-      { resource_type: 'navigations' },
-      { resource_type: 'docs/articles' },
-      { resource_type: 'db' },
-    ],
-    references: [
-      {
-        file: 'references/architecture.md',
-        headings: ['核心概念（30 秒）', '为什么这样设计（1 分钟）', '技术栈（30 秒）'],
-      },
-      {
-        file: 'references/modules.md',
-        headings: [
-          '可开发模块（开发者负责实现）',
-          '平台内置模块（开箱即用，不需实现）',
-          '模块选型决策',
-          '自定义服务边界',
-        ],
-      },
-      { file: 'references/mcp.md', headings: ['边界', 'API 发现与调用', '协议与安全'] },
-      { file: 'references/checkout.md', headings: ['适用范围'] },
-    ],
-  },
-});
-
-const TASK_ALIASES = Object.freeze({
-  backend: 'custom-service',
-  service: 'custom-service',
-  ui: 'frontend',
-});
-
-function normalizeTask(value) {
-  const requested = String(value || '').trim().toLowerCase();
-  const task = Object.prototype.hasOwnProperty.call(TASK_ALIASES, requested)
-    ? TASK_ALIASES[requested]
-    : requested;
-  if (!Object.prototype.hasOwnProperty.call(TASK_PROFILES, task)) {
-    const supported = Object.keys(TASK_PROFILES).join(', ');
-    throw new Error(`Unsupported context task: ${requested || '(empty)'}. Supported tasks: ${supported}.`);
-  }
-  return task;
-}
-
-function lineNumberAt(source, offset) {
-  let line = 1;
-  for (let index = 0; index < offset; index += 1) {
-    if (source.charCodeAt(index) === 10) line += 1;
-  }
-  return line;
-}
-
-function sectionEndLine(content, startLine) {
-  let newlines = 0;
-  for (let index = 0; index < content.length; index += 1) {
-    if (content.charCodeAt(index) === 10) newlines += 1;
-  }
-  return startLine + newlines - (content.endsWith('\n') ? 1 : 0);
-}
-
-function extractSections(source, requestedHeadings, sourcePath) {
-  const matches = [...source.matchAll(/^## ([^\r\n]+)\r?$/gm)];
-  const wanted = requestedHeadings ? new Set(requestedHeadings) : null;
-  const sections = [];
-
-  if (matches.length && matches[0].index > 0) {
-    const content = source.slice(0, matches[0].index);
-    const title = content.match(/^# ([^\r\n]+)\r?$/m);
-    sections.push({
-      source: {
-        kind: 'bundled_reference',
-        path: sourcePath,
-        heading: title ? title[1] : '(preamble)',
-        line_start: 1,
-        line_end: sectionEndLine(content, 1),
-        sha256: crypto.createHash('sha256').update(content, 'utf8').digest('hex'),
-      },
-      content,
-    });
-  }
-
-  for (let index = 0; index < matches.length; index += 1) {
-    const match = matches[index];
-    const heading = match[1];
-    if (wanted && !wanted.has(heading)) continue;
-    const start = match.index;
-    const end = index + 1 < matches.length ? matches[index + 1].index : source.length;
-    const content = source.slice(start, end);
-    const startLine = lineNumberAt(source, start);
-    sections.push({
-      source: {
-        kind: 'bundled_reference',
-        path: sourcePath,
-        heading,
-        line_start: startLine,
-        line_end: sectionEndLine(content, startLine),
-        sha256: crypto.createHash('sha256').update(content, 'utf8').digest('hex'),
-      },
-      content,
-    });
-  }
-
-  if (wanted) {
-    const found = new Set(matches.map((match) => match[1]));
-    const missing = requestedHeadings.filter((heading) => !found.has(heading));
-    if (missing.length) {
-      throw new Error(`${sourcePath} is missing required sections: ${missing.join(', ')}.`);
-    }
-  }
-  if (!sections.length) throw new Error(`${sourcePath} contains no selectable reference sections.`);
-  return sections;
-}
-
-function readTaskReferences(taskValue, options = {}) {
-  const task = normalizeTask(taskValue);
-  const skillRoot = options.skillRoot || SKILL_ROOT;
-  return TASK_PROFILES[task].references.flatMap((entry) => {
-    const absolute = path.join(skillRoot, entry.file);
-    const source = fs.readFileSync(absolute, 'utf8');
-    const sourcePath = path.posix.join('resources/skill', entry.file.replace(/\\/g, '/'));
-    return extractSections(source, entry.headings, sourcePath);
-  });
-}
-
-function rawQuery(session, expectedName, args, server, options = {}) {
-  const tool = session.names[expectedName] || expectedName;
-  return session.client.toolsCall(tool, args, options).then((result) => ({
-    source: {
-      kind: 'mcp_tool',
-      server,
-      tool,
-      canonical_tool: expectedName,
-      arguments: args,
-      fetched_at: new Date().toISOString(),
-    },
-    result,
-  }));
-}
-
-function structuredValueFromRaw(result) {
-  let value = result;
-  if (value && value.result) value = value.result;
-  if (value && value.structuredContent) value = value.structuredContent;
-  else if (value && value.structured_content) value = value.structured_content;
-  else if (value && Array.isArray(value.content)) {
-    const text = value.content.find((part) =>
-      part && part.type === 'text' && typeof part.text === 'string');
-    if (text) {
-      if (Buffer.byteLength(text.text, 'utf8') > MAX_STRUCTURED_TEXT_BYTES) {
-        throw new Error('DraftGo MCP pagination result exceeded the structured JSON limit.');
-      }
-      try {
-        value = JSON.parse(text.text);
-      } catch {
-        throw new Error('DraftGo MCP pagination result did not contain structured JSON.');
-      }
-    }
-  }
-  if (value && value.data) value = value.data;
-  if (value && Object.prototype.hasOwnProperty.call(value, 'value')) value = value.value;
-  return value;
-}
-
-function nextCursorFromRaw(result) {
-  const value = structuredValueFromRaw(result);
-  if (!value || typeof value !== 'object') return null;
-  const hasMore = value.has_more === true || value.hasMore === true;
-  let cursor = null;
-  let hasCursor = false;
-  if (Object.prototype.hasOwnProperty.call(value, 'next_cursor')) {
-    cursor = value.next_cursor;
-    hasCursor = true;
-  } else if (Object.prototype.hasOwnProperty.call(value, 'nextCursor')) {
-    cursor = value.nextCursor;
-    hasCursor = true;
-  } else if (hasMore && Object.prototype.hasOwnProperty.call(value, 'cursor')) {
-    cursor = value.cursor;
-    hasCursor = true;
-  }
-  if (hasMore && (!hasCursor || cursor == null || cursor === '')) {
-    throw new Error('DraftGo MCP pagination reported more results without a cursor.');
-  }
-  return hasCursor ? cursor : null;
-}
-
-async function collectLongContentResources(session, server, options = {}) {
-  const sequences = await Promise.all(LONG_CONTENT_RESOURCE_TYPES.map((resourceType) =>
-    rawPagedQuery(
-      session,
-      TOOL_NAMES.resourceList,
-      { resource_type: resourceType, limit: 100 },
-      server,
-      options,
-    )));
-  return {
-    source: {
-      kind: 'mcp_tool_batch',
-      server,
-      canonical_tool: TOOL_NAMES.resourceList,
-      arguments: LONG_CONTENT_RESOURCE_TYPES.map((resourceType) => ({
-        resource_type: resourceType,
-        limit: 100,
-      })),
-    },
-    pages: sequences.flatMap((sequence) => sequence.pages),
-  };
-}
-
-async function collectTaskAPIs(session, queries, server, options = {}) {
-  const argumentsList = queries.map((query) => ({ ...query, limit: 100 }));
-  const sequences = await Promise.all(argumentsList.map((args) =>
-    rawPagedQuery(session, TOOL_NAMES.apiSearch, args, server, options)));
-  return {
-    source: {
-      kind: 'mcp_tool_batch',
-      server,
-      canonical_tool: TOOL_NAMES.apiSearch,
-      arguments: argumentsList,
-    },
-    pages: sequences.flatMap((sequence) => sequence.pages),
-  };
-}
-
-function itemsFromRawSequence(sequence) {
-  if (!sequence || !Array.isArray(sequence.pages)) return [];
-  return sequence.pages.flatMap((page) => {
-    const value = structuredValueFromRaw(page);
-    if (Array.isArray(value)) return value;
-    if (value && Array.isArray(value.items)) return value.items;
-    if (value && Array.isArray(value.operations)) return value.operations;
-    return [];
-  });
-}
-
-function selectDBMetaListOperation(sequence) {
-  return itemsFromRawSequence(sequence).find((operation) => {
-    if (!operation || typeof operation !== 'object') return false;
-    const method = String(operation.method || '').trim().toUpperCase();
-    const resourceType = String(operation.resource_type || '').trim().toLowerCase();
-    const operationPath = String(operation.path || operation.path_template || '').trim();
-    return method === 'GET'
-      && resourceType === 'db_meta'
-      && operationPath === DB_META_LIST_PATH
-      && operation.destructive !== true;
-  }) || null;
-}
-
-function optionalPageInteger(value, field, minimum) {
-  if (value == null) return null;
-  if (!Number.isSafeInteger(value) || value < minimum) {
-    throw new Error(`DraftGo db_meta API returned invalid ${field}.`);
-  }
-  return value;
-}
-
-function dbMetaPageInfo(response) {
-  let value = structuredValueFromRaw(response);
-  if (value && value.response) value = value.response;
-  if (value && value.data) value = value.data;
-  if (!value || typeof value !== 'object' || !Array.isArray(value.items)) return null;
-  return {
-    items: value.items,
-    total: optionalPageInteger(value.total, 'total', 0),
-    page: optionalPageInteger(value.page, 'page', 1),
-    pageSize: optionalPageInteger(value.page_size, 'page_size', 1),
-  };
-}
-
-async function rawPagedQuery(session, expectedName, baseArgs, server, options = {}) {
-  const pages = [];
-  const seen = new Set();
-  const maxPages = options.maxPages == null ? 100 : Number(options.maxPages);
-  if (!Number.isSafeInteger(maxPages) || maxPages < 1) {
-    throw new TypeError('maxPages must be a positive integer.');
-  }
-  let cursor = null;
-
-  for (let page = 0; page < maxPages; page += 1) {
-    const args = cursor == null ? { ...baseArgs } : { ...baseArgs, cursor };
-    const response = await rawQuery(session, expectedName, args, server, options);
-    pages.push(response);
-    const next = nextCursorFromRaw(response.result);
-    if (next == null || next === '') {
-      return {
-        source: {
-          kind: 'mcp_tool_sequence',
-          server,
-          canonical_tool: expectedName,
-          arguments: baseArgs,
-        },
-        pages,
-      };
-    }
-    const key = String(next);
-    if (seen.has(key)) throw new Error(expectedName + ' repeated a cursor.');
-    seen.add(key);
-    cursor = next;
-  }
-  throw new Error(expectedName + ' exceeded ' + maxPages + ' pages.');
-}
-
-async function collectDBMetaResources(session, operationID, server, options = {}) {
-  const pages = [];
-  let fetchedItems = 0;
-  let reportedTotal = null;
-  const maxPages = options.maxPages == null ? 100 : Number(options.maxPages);
-  if (!Number.isSafeInteger(maxPages) || maxPages < 1) {
-    throw new TypeError('maxPages must be a positive integer.');
-  }
-  for (let page = 1; page <= maxPages; page += 1) {
-    const args = {
-      operation_id: operationID,
-      query: { page, page_size: DB_META_PAGE_SIZE },
-    };
-    const response = await rawQuery(session, TOOL_NAMES.apiCall, args, server, options);
-    pages.push(response);
-    const info = dbMetaPageInfo(response);
-    if (!info) {
-      return {
-        source: {
-          kind: 'mcp_tool_sequence',
-          server,
-          canonical_tool: TOOL_NAMES.apiCall,
-          operation_id: operationID,
-        },
-        pages,
-        pagination: { complete: false, reason: 'response_shape_unavailable' },
-      };
-    }
-    const responsePage = info.page || page;
-    const responsePageSize = info.pageSize || DB_META_PAGE_SIZE;
-    if (responsePage !== page) {
-      throw new Error(`DraftGo db_meta API returned page ${responsePage} while page ${page} was requested.`);
-    }
-    fetchedItems += info.items.length;
-    if (info.total != null) {
-      if (reportedTotal != null && info.total !== reportedTotal) {
-        throw new Error(`DraftGo db_meta API changed total from ${reportedTotal} to ${info.total} during pagination.`);
-      }
-      reportedTotal = info.total;
-    }
-    if (reportedTotal != null) {
-      if (fetchedItems >= reportedTotal) {
-        return {
-          source: {
-            kind: 'mcp_tool_sequence',
-            server,
-            canonical_tool: TOOL_NAMES.apiCall,
-            operation_id: operationID,
-          },
-          pages,
-          pagination: { complete: true, total: reportedTotal },
-        };
-      }
-      if (!info.items.length) {
-        throw new Error('DraftGo db_meta API ended before the reported total was reached.');
-      }
-    } else if (info.items.length < responsePageSize) {
-      return {
-        source: {
-          kind: 'mcp_tool_sequence',
-          server,
-          canonical_tool: TOOL_NAMES.apiCall,
-          operation_id: operationID,
-        },
-        pages,
-        pagination: { complete: true, total: null },
-      };
-    }
-  }
-  throw new Error(`DraftGo db_meta API exceeded ${maxPages} pages.`);
-}
-
-async function collectDataStructures(session, server, options = {}) {
-  const api = await rawPagedQuery(
-    session,
-    TOOL_NAMES.apiSearch,
-    { resource_type: 'db_meta', limit: 100 },
-    server,
-    options,
-  );
-  const operation = selectDBMetaListOperation(api);
-  if (!operation || !operation.operation_id) {
-    throw new Error('DraftGo MCP does not expose a read-only GET /api/db-meta operation.');
-  }
-  const operationID = String(operation.operation_id);
-  const [contract, resources] = await Promise.all([
-    rawQuery(
-      session,
-      TOOL_NAMES.apiDescribe,
-      { operation_id: operationID },
-      server,
-      options,
-    ),
-    collectDBMetaResources(session, operationID, server, options),
-  ]);
-  return { api, contract, resources };
-}
-
-async function collectContext(projectDir, taskValue, options = {}) {
-  const task = normalizeTask(taskValue);
-  const profile = TASK_PROFILES[task];
-  const references = readTaskReferences(task, options);
-  const installedSkillVersion = readInstalledSkillVersion(projectDir);
-  const config = options.config || loadProjectConfig(projectDir);
-  const expected = [
-    TOOL_NAMES.projectOverview,
-    TOOL_NAMES.resourceList,
-    TOOL_NAMES.apiSearch,
-    TOOL_NAMES.apiDescribe,
-    TOOL_NAMES.apiCall,
-  ];
-  const openSession = options.openToolSession || openToolSession;
-  const session = options.session || await openSession(config, expected, options);
-  const controller = new AbortController();
-  const externalSignal = options.signal;
-  const forwardAbort = () => controller.abort(externalSignal.reason);
-  if (externalSignal) {
-    if (externalSignal.aborted) forwardAbort();
-    else externalSignal.addEventListener('abort', forwardAbort, { once: true });
-  }
-
-  let project;
-  let resources;
-  let api;
-  let dataStructures;
-  try {
-    const queryOptions = { ...options, signal: controller.signal };
-    [project, resources, api, dataStructures] = await Promise.all([
-      rawQuery(session, TOOL_NAMES.projectOverview, {}, config.server, queryOptions),
-      collectLongContentResources(session, config.server, queryOptions),
-      collectTaskAPIs(session, profile.apiQueries, config.server, queryOptions),
-      collectDataStructures(session, config.server, queryOptions),
-    ]);
-  } catch (error) {
-    if (!controller.signal.aborted) controller.abort(error);
-    throw error;
-  } finally {
-    if (externalSignal) externalSignal.removeEventListener('abort', forwardAbort);
-  }
-
-  return {
-    schema_version: '2.0',
-    task,
-    bundled_references: {
-      source: 'draftgo-cli',
-      version: pkg.version,
-      installed_skill_version: installedSkillVersion,
-      synchronized: installedSkillVersion == null ? null : installedSkillVersion === pkg.version,
-      sections: references.map((entry) => ({
-        ...entry,
-        source: { ...entry.source, source: 'cli_bundle', version: pkg.version },
-      })),
-    },
-    live_project: project,
-    live_resources: resources,
-    live_apis: api,
-    live_db_meta: dataStructures,
-    live_session: {
-      server: config.server,
-      protocol_version: session.client.protocolVersion,
-      fetched_at: new Date().toISOString(),
-    },
-  };
-}
-
-function compactContext(value) {
-  if (Array.isArray(value)) return value.map(compactContext);
-  if (!value || typeof value !== 'object') return value;
-  if (value.source && Object.prototype.hasOwnProperty.call(value, 'result')) {
-    return { source: compactContext(value.source), value: structuredValueFromRaw(value.result) };
-  }
-  const result = {};
-  for (const [key, child] of Object.entries(value)) result[key] = compactContext(child);
-  return result;
-}
-
-function readInstalledSkillVersion(projectDir) {
-  return readInstalledVersion(projectDir);
-}
-
-module.exports = {
-  TASK_PROFILES,
-  normalizeTask,
-  extractSections,
-  readTaskReferences,
-  structuredValueFromRaw,
-  nextCursorFromRaw,
-  rawPagedQuery,
-  collectLongContentResources,
-  collectTaskAPIs,
-  itemsFromRawSequence,
-  selectDBMetaListOperation,
-  dbMetaPageInfo,
-  collectDBMetaResources,
-  collectDataStructures,
-  readInstalledSkillVersion,
-  collectContext,
-  compactContext,
-};