@qilin-agent/subagent-spawn-in-process 0.0.0-stage → 3.1.3

package/LICENSE

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

package/README.i18n.yaml

@@ -0,0 +1,79 @@
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/subagent/subagent-spawn-in-process/README.md
+/:
+  en: d510765ec1bebc28
+  zh: 35efb9f71f05f326
+/qilin-subagent-spawn-in-process:
+  en: 2be56cde0ecc8599
+  zh: 143c8e42cb2e8e42
+/qilin-subagent-spawn-in-process/summary:
+  en: 77354bfb7bbb447c
+  zh: 250fde8a163145ac
+/qilin-subagent-spawn-in-process/table-of-contents:
+  en: d152484eb41ac6b4
+  zh: 09388d293f9be9cb
+/qilin-subagent-spawn-in-process/use-this-package:
+  en: 8a75ad01cfe60938
+  zh: b63a8302502d289a
+/qilin-subagent-spawn-in-process/use-this-package/when-to-choose-it:
+  en: 5f14443940e59bb5
+  zh: 3e8610aec21c55e8
+/qilin-subagent-spawn-in-process/use-this-package/minimal-configuration:
+  en: 47275ac3ef383518
+  zh: fae5495b7c86194a
+/qilin-subagent-spawn-in-process/use-this-package/what-a-delegation-does:
+  en: 9f4e6f31ad4d86d1
+  zh: 4ad77e0b80c6efcc
+/qilin-subagent-spawn-in-process/understand-the-implementation:
+  en: 9e00b9dc2f9cf38c
+  zh: 60ce00ce6c3b5564
+/qilin-subagent-spawn-in-process/understand-the-implementation/design-concept:
+  en: 695d892574059848
+  zh: b3acbd068cd48ffb
+/qilin-subagent-spawn-in-process/understand-the-implementation/source-map:
+  en: f23771c3d213ffb1
+  zh: c0b16b102dc26345
+/qilin-subagent-spawn-in-process/understand-the-implementation/run-flow:
+  en: 7b55a5649bc38155
+  zh: 51fe220c84ca759a
+/qilin-subagent-spawn-in-process/understand-the-implementation/ownership-and-scope:
+  en: 8af949dc29cb4a5c
+  zh: f4e4f9f9f4a4b7c9
+/qilin-subagent-spawn-in-process/further-exploration:
+  en: 023e2a87c9472ff5
+  zh: da2a0d50eec1a8f6
+/qilin-subagent-spawn-in-process/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/qilin-subagent-spawn-in-process/model-experience/child-agent-request:
+  en: 05e6180f1498fdf9
+  zh: 2b05d2b97bfa67da
+/qilin-subagent-spawn-in-process/model-experience/child-agent-request/what-the-model-sees:
+  en: 2035bdd8640e5a8a
+  zh: 5afa645d7dbe31a5
+/qilin-subagent-spawn-in-process/model-experience/child-agent-request/token-effect:
+  en: e74d21e38e4a53a9
+  zh: 6a5e3ef5fe0f4f14
+/qilin-subagent-spawn-in-process/model-experience/child-agent-request/kv-cache-effect:
+  en: 78d800b26fb3b0af
+  zh: 313169b62c29af1d
+/qilin-subagent-spawn-in-process/model-experience/parent-tool-result-indirectly:
+  en: 75d061c2151624a7
+  zh: 71e58e020b60ff90
+/qilin-subagent-spawn-in-process/model-experience/parent-tool-result-indirectly/what-the-model-sees:
+  en: e13dd20fc123c970
+  zh: 031673267b742df6
+/qilin-subagent-spawn-in-process/model-experience/parent-tool-result-indirectly/token-effect:
+  en: ff8045aa0f466c2a
+  zh: e38fc5c6af2ce076
+/qilin-subagent-spawn-in-process/model-experience/parent-tool-result-indirectly/kv-cache-effect:
+  en: f5d5f97a153f7c70
+  zh: 3d6bc05b9eadfbc2
+/qilin-subagent-spawn-in-process/known-limitations-and-deferred-work:
+  en: 68720f2a663a4aad
+  zh: a472436c5cc2b801
+/qilin-subagent-spawn-in-process/known-limitations-and-deferred-work/dev-note:
+  en: e67f633dc6fe7773
+  zh: 3bb0c20c93f16f98

package/README.md

@@ -1,3 +1,149 @@
-# Temporary Holding Version
+---
+description: "In-process spawn subagent backend for users and maintainers choosing, configuring, or debugging fresh-child delegation."
+kind: "package-reference"
+---
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @qilin-agent/subagent-spawn-in-process
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`qilin-subagent-spawn-in-process` is an in-process subagent backend: it runs each delegated task in a fresh child agent that shares this process and its agent factory, LLM, and tool services. The child starts with an empty conversation, so a task prompt must stand alone; it inherits the parent's working directory, session lineage, provider, model, reasoning effort, and output-token limit unless `request.agentOptions` overrides them. A delegation tool or API call reaches it under the `spawn` provider name. Choose it for the cheapest delegation transport; choose the fork backend when the child must build on the parent's completed conversation turns.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Mount this backend in a composition that delegates work to fresh in-process children. The common path is explicit: load the subagent service and this backend, then point a delegation tool such as `qilin-tool-subagent` at the `spawn` provider.
+
+### When to choose it
+
+Choose the spawn backend when the child needs no parent conversation and running in this process is acceptable. Avoid it when the child must build on completed parent turns — the fork backend seeds that history — or when the child must run outside this process, which the out-of-process backends provide. Because the child inherits the parent's working directory and LLM selection by default, a self-contained prompt behaves exactly as written.
+
+### Minimal configuration
+
+Load the subagent service and this backend, then configure one delegation tool per target. This is the smallest composition that exposes a `subagent` tool backed by spawn:
+
+```yaml
+- name: '@qilin-agent/subagent'
+- name: '@qilin-agent/subagent-spawn-in-process'
+- name: '@qilin-agent/tool-subagent'
+  config:
+    provider: spawn
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `providerName` | `spawn` | Provider name registered on `ctx.subagents` |
+
+The generated [configuration catalog](../../../docs/config-catalog.md#qilin-agentsubagent-spawn-in-process) is the exhaustive source for every accepted field and its JSDoc.
+
+### What a delegation does
+
+One tool call starts one child and waits for its result: the child works in its own session and the parent receives only its final output, or an errored tool result when the run is cancelled, refused, truncated by its token limit, or rejected at startup. A rejected start leaves no published child; a completed run is disposed after its result is collected.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+This section explains how the backend is built and where the behavior in [Use this package](#use-this-package) comes from; the shared mechanics belong to the in-process driver.
+
+### Design concept
+
+One separation: this backend contributes only the provider registration and the decision to start fresh, while every run mechanic — depth checking, child creation, per-child customization, structured output, cancellation, result reading, and disposal — lives in `qilin-subagent-in-process-driver`. The agent factory's creation transaction owns the unpublished setup window and its rollback; after publication the caller owns the run.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Provider registration: `Config` schema, capability declaration, `start()` |
+
+### Run flow
+
+A start request resolves through the subagent service, then the shared driver validates depth, mints a child session id, creates the child through the host agent factory with the caller's signal, applies persona, tool filter, and structured output inside the creation window, publishes the child, drives one task, reads the child's own final output, and disposes the handle quiescently.
+
+### Ownership and scope
+
+The child gets a fresh flat registration scope: parent tool restrictions and authority are never imported, and the filter the tool applies is composition, not a parent-derived grant. The backend advertises all five start-time capabilities, including `agentOptions`, because it controls the child's creation window and can enforce each one.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when the package-level contract is not enough; they move from the shared subagent model to the sibling backends and exhaustive configuration.
+
+- [Subagent subsystem](../../../docs/subsystems/subagent.md) — start requests, results, live runs, and the provider contract.
+- [qilin-subagent-in-process-driver](../subagent-in-process-driver/README.md) — the shared run driver this backend calls.
+- [qilin-subagent-fork-in-process](../subagent-fork-in-process/README.md) — the sibling backend that seeds completed parent turns.
+- [qilin-tool-subagent](../tool-subagent/README.md) — the model-facing delegation tool that reaches this provider.
+- [Generated configuration catalog](../../../docs/config-catalog.md#qilin-agentsubagent-spawn-in-process) — every accepted config field and its source declaration.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Child-agent request
+
+#### What the model sees
+
+The fresh child receives the task content verbatim as its only user message in a new empty conversation, with the parent provider, model, reasoning effort, output-token limit, and working directory by default. A configured persona shadows global prompt text in the child's scope; a tool filter removes named global tools from its schemas, executable lookup, and PTC mode SDK bindings while leaving independently registered guidance. No parent conversation message is included; the filter is composition, not an inherited authority grant.
+
+#### Token effect
+
+The child pays for a new independent context and history, and no parent-history token is duplicated. A persona changes the child's repeated prompt cost; a tool filter changes its schema or generated SDK cost.
+
+#### KV Cache effect
+
+The child's request cache is independent of the parent's. Child history grows append-only, while persona, tool-filter, generated-SDK, provider, or model changes establish a different child prefix.
+
+### Parent tool result, indirectly
+
+#### What the model sees
+
+Through `qilin-tool-subagent`, the parent receives only the child's final output or an errored result for a non-completed stop reason; intermediate child work never reaches it.
+
+#### Token effect
+
+Parent input grows by one data-dependent result, retained until compaction.
+
+#### KV Cache effect
+
+Append-only; newly visible content follows the reusable request prefix and does not invalidate existing KV-cache entries.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define when the backend is the wrong choice; they are current package constraints.
+
+- **Fresh means no parent transcript** — the child inherits cwd, lineage, provider, model, reasoning effort, output-token limit, and explicitly configured persona or tool restrictions, but none of the parent's conversation; use the fork backend when completed-turn context is required.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,149 @@
+---
+description: "面向用户与维护者的进程内 spawn subagent 后端说明，用于选择、配置或排查全新子级委派。"
+kind: "package-reference"
+---
+
+# @qilin-agent/subagent-spawn-in-process
+
+[English](README.md) | 中文
+
+## 概述
+
+`qilin-subagent-spawn-in-process` 是一个进程内 subagent 后端：它在当前进程中运行每个委派任务，子 agent（智能体）是一个全新子 `Agent`，复用宿主的 agent 工厂及 LLM（大语言模型）/工具服务。子 agent 以空对话开始，因此任务提示词必须自足；除非 `request.agentOptions` 覆盖，否则它继承父 agent 的工作目录、会话谱系、提供方、模型、推理强度与输出 token 上限。委派工具或 API 调用以 `spawn` 提供方名称找到它。需要成本最低的委派传输时选择它；需要子 agent 建立在父级已完成对话轮次之上时，请选择 fork 后端。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+在需要把工作委派给全新进程内子 agent 的组合中挂载此后端。常用配置路径很明确：加载 subagent 服务与本后端，再把 `qilin-tool-subagent` 之类的委派工具指向 `spawn` 提供方。
+
+### 何时选择
+
+当子 agent 不需要父级对话、且可以接受在本进程内运行时，选择 spawn 后端。当子 agent 必须建立在已完成父级轮次之上时——fork 后端会提供这些历史——或必须在本进程之外运行时（进程外后端提供此能力），请避免使用它。由于子 agent 默认继承父级的工作目录与 LLM 选择，自足的提示词会按原样生效。
+
+### 最小配置
+
+先加载 subagent 服务与本后端，再为每个目标配置一个委派工具。这是暴露由 spawn 支撑的 `subagent` 工具的最小组合：
+
+```yaml
+- name: '@qilin-agent/subagent'
+- name: '@qilin-agent/subagent-spawn-in-process'
+- name: '@qilin-agent/tool-subagent'
+  config:
+    provider: spawn
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `providerName` | `spawn` | 注册到 `ctx.subagents` 的提供方名称 |
+
+生成的[配置目录](../../../docs/config-catalog.zh.md#qilin-agentsubagent-spawn-in-process)是每个受支持字段及其 JSDoc 的穷尽式真源。
+
+### 一次委派会做什么
+
+一次工具调用启动一个子 agent 并等待其结果：子 agent 在自有会话中工作，父级只接收其最终输出；若运行被取消、拒绝、被 token 上限截断或在启动时被拒，则收到出错的工具结果。被拒绝的启动不会留下已发布的子 agent；完成的运行在结果收集后即被 dispose（资源释放）。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释后端的构建方式以及[使用本包](#use-this-package)中行为的来源；共享机制属于进程内驱动器。
+
+### 设计理念
+
+职责划分如下：本后端只贡献提供方注册与「全新开始」的决定，其余全部运行机制——深度检查、子 agent 创建、按子 agent 定制、结构化输出、取消、结果读取与 dispose——都在 `qilin-subagent-in-process-driver` 中。agent 工厂的创建事务拥有未发布设置窗口及其回滚；发布之后，调用方拥有该运行。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 提供方注册：`Config` schema、能力声明、`start()` |
+
+### 运行流程
+
+启动请求先由 subagent 服务解析，然后共享驱动器校验深度、生成子会话 id、通过宿主 agent 工厂以调用方信号创建子 agent、在创建窗口内应用 persona、工具过滤器与结构化输出、发布子 agent、驱动一项任务、读取子 agent 自身的最终输出，最后完全停稳地 dispose 句柄。
+
+### 所有权与作用域
+
+子 agent 获得全新的扁平注册作用域：父级工具限制与权限绝不会被导入，工具所施加的过滤属于组合而非父级派生授权。后端声明包括 `agentOptions` 在内的全部五项启动时能力，因为它控制子 agent 的创建窗口，可以逐一强制执行。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当包级约定不够用时阅读以下页面；它们从共享 subagent 模型进入兄弟后端与穷尽式配置。
+
+- [Subagent 子系统](../../../docs/subsystems/subagent.zh.md)——启动请求、结果、实时运行与提供方约定。
+- [qilin-subagent-in-process-driver](../subagent-in-process-driver/README.zh.md)——本后端调用的共享运行驱动器。
+- [qilin-subagent-fork-in-process](../subagent-fork-in-process/README.zh.md)——以已完成父级轮次作初始内容的兄弟后端。
+- [qilin-tool-subagent](../tool-subagent/README.zh.md)——指向该提供方的面向模型委派工具。
+- [生成配置目录](../../../docs/config-catalog.zh.md#qilin-agentsubagent-spawn-in-process)——每个受支持配置字段及其源声明。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 子 agent 请求
+
+#### 模型看到什么
+
+全新子 agent 逐字接收任务内容，作为新空对话中的唯一用户消息，默认使用父级提供方、模型、推理强度、输出 token 上限与工作目录。配置的 persona 会在子 agent 作用域中遮蔽全局提示词文本；工具过滤器会从其 schema、可执行工具查找与 PTC mode SDK 绑定中移除指定的全局工具，但保留独立注册的指导内容。不包含任何父级对话消息；过滤属于组合，而非继承的权限授予。
+
+#### Token 影响
+
+子 agent 会为全新的独立上下文与历史消耗 token，不复制任何父级历史 token。persona 会改变该子 agent 反复使用的提示词成本；工具过滤器会改变其 schema 或生成 SDK 的成本。
+
+#### KV Cache 影响
+
+子 agent 的请求缓存与父级相互独立。子 agent 历史仅追加；persona、工具过滤、生成 SDK、提供方或模型变化会建立不同的子 agent 前缀。
+
+### 父级工具结果（间接）
+
+#### 模型看到什么
+
+通过 `qilin-tool-subagent`，父级只接收子 agent 的最终输出，或非完成终止原因对应的出错结果；子 agent 的中间工作绝不会到达父级。
+
+#### Token 影响
+
+父级输入增加一个取决于数据的结果，并保留到上下文压缩（context compaction）为止。
+
+#### KV Cache 影响
+
+仅追加；新增可见内容位于可复用请求前缀之后，不会使现有 KV Cache 条目失效。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明何时选择该后端是错误的；它们是当前包约束。
+
+- **全新表示不含父级 transcript（文本记录）**——子 agent 继承 cwd、谱系、提供方、模型、推理强度、输出 token 上限及显式配置的 persona/工具限制，但不继承父级的任何对话；需要已完成轮次上下文时，请使用 fork 后端。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,45 @@
+import z from "@qilin-agent/schemastery";
+import { startInProcessRun } from "@qilin-agent/subagent-in-process-driver";
+//#region lib/types/index.js
+/**
+* The in-process SPAWN subagent backend: registers a {@link SubagentProvider} on
+* `ctx.subagents` that runs each child as a fresh child {@link Agent} on the same cordis
+* context (its own session, own system prompt, zero parent context). The cheapest transport,
+* reusing the agent factory's quiescent teardown.
+* @module @qilin-agent/subagent-spawn-in-process
+*/
+const name = "subagent-spawn-in-process";
+const inject = ["subagents"];
+const Config = z.object({ providerName: z.string().default("spawn") });
+/**
+* The spawn provider. Supports every start-time capability: `depthLimit` (it
+* constructs the child, so it can enforce a recursion cap), `outputSchema`
+* (the scoped structured runtime), `agentOptions` (merged over the parent
+* route), and `toolFilter`/`persona` (scoped `restrict()` and a scoped
+* shadowing persona section, applied in the child's creation window).
+*/
+var SpawnInProcessProvider = class {
+	name;
+	capabilities = {
+		agentOptions: true,
+		outputSchema: true,
+		depthLimit: true,
+		toolFilter: true,
+		persona: true
+	};
+	inheritsParentContext = false;
+	constructor(name) {
+		this.name = name;
+	}
+	start(request) {
+		return startInProcessRun(request, {});
+	}
+	prepareContinuable() {
+		return Promise.resolve({});
+	}
+};
+function apply(ctx, config) {
+	ctx.subagents.registerProvider(new SpawnInProcessProvider(config.providerName));
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The in-process SPAWN subagent backend: registers a {@link SubagentProvider} on
+ * `ctx.subagents` that runs each child as a fresh child {@link Agent} on the same cordis
+ * context (its own session, own system prompt, zero parent context). The cheapest transport,
+ * reusing the agent factory's quiescent teardown.
+ * @module @qilin-agent/subagent-spawn-in-process
+ */
+import type { Context } from '@qilin-agent/kylin';
+import z from '@qilin-agent/schemastery';
+export declare const name = "subagent-spawn-in-process";
+export declare const inject: string[];
+/** Config: the registry name to register the provider under. */
+export interface Config {
+    /** Provider name on `ctx.subagents` (default `spawn`). */
+    providerName: string;
+}
+export declare const Config: z<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@qilin-agent/subagent-spawn-in-process",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "In-process spawn subagent backend: runs a fresh child agent on ctx.agents",
+  "version": "3.1.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/subagent/subagent-spawn-in-process"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@qilin-agent/subagent": "3.1.3",
+    "@qilin-agent/subagent-in-process-driver": "3.1.3",
+    "@qilin-agent/kylin": "~4.0.3"
+  },
+  "dependencies": {
+    "@qilin-agent/schemastery": "~3.18.3"
+  },
+  "devDependencies": {
+    "@qilin-agent/kylin-plugin-loader": "~1.0.4",
+    "@qilin-agent/agent-loop": "3.1.3",
+    "@qilin-agent/bash-local": "3.1.3",
+    "@qilin-agent/agent-loop-testkit": "3.1.3",
+    "@qilin-agent/agent": "3.1.3",
+    "@qilin-agent/subprocess-local": "3.1.3",
+    "@qilin-agent/llm": "3.1.3",
+    "@qilin-agent/llm-deepseek-api-key": "3.1.3",
+    "@qilin-agent/subagent": "3.1.3",
+    "@qilin-agent/session": "3.1.3",
+    "@qilin-agent/subagent-in-process-driver": "3.1.3",
+    "@qilin-agent/tool-bash": "3.1.3",
+    "@qilin-agent/tool-subagent": "3.1.3",
+    "@qilin-agent/llm-deepseek": "3.1.3",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/session-projection": "3.1.3"
+  }
 }