@qilin-agent/subagent-fork-in-process 0.0.0-stage → 3.1.4

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,82 @@
+# 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-fork-in-process/README.md
+/:
+  en: a4a75d423f70c4de
+  zh: a60816274b877a80
+/qilin-agent-subagent-fork-in-process:
+  en: 7cf0e37620e22522
+  zh: b443e50dc2b48be2
+/qilin-agent-subagent-fork-in-process/summary:
+  en: 97309f84ffe50ba9
+  zh: ce4121b0823b7c7f
+/qilin-agent-subagent-fork-in-process/table-of-contents:
+  en: d152484eb41ac6b4
+  zh: 09388d293f9be9cb
+/qilin-agent-subagent-fork-in-process/use-this-package:
+  en: 71affc798c840594
+  zh: 258a2932c3c04841
+/qilin-agent-subagent-fork-in-process/use-this-package/when-to-choose-it:
+  en: 05090df7cc302c6a
+  zh: bd988019ba062e0a
+/qilin-agent-subagent-fork-in-process/use-this-package/seed-boundary:
+  en: f4dfd1ce652f019b
+  zh: 9bb75239491f07cc
+/qilin-agent-subagent-fork-in-process/use-this-package/minimal-configuration:
+  en: 2991e26cbb054981
+  zh: 283ec9733299ce57
+/qilin-agent-subagent-fork-in-process/use-this-package/what-a-fork-delegation-does:
+  en: 461063deda821a1b
+  zh: 18d2d41d64884f22
+/qilin-agent-subagent-fork-in-process/understand-the-implementation:
+  en: 6a0fe4b9cc780aaa
+  zh: 50cd69ceb8296827
+/qilin-agent-subagent-fork-in-process/understand-the-implementation/design-concept:
+  en: 49c8725fee5330ed
+  zh: 9050680f2011820a
+/qilin-agent-subagent-fork-in-process/understand-the-implementation/source-map:
+  en: f1f45255fd9f71c1
+  zh: 9a3f016b8fe9754a
+/qilin-agent-subagent-fork-in-process/understand-the-implementation/run-flow:
+  en: ef063b5c5542e129
+  zh: ba564c6b92453b44
+/qilin-agent-subagent-fork-in-process/understand-the-implementation/lifecycle-binding:
+  en: 8dad0155ed1b32d2
+  zh: f4d82d5ede03c4d7
+/qilin-agent-subagent-fork-in-process/further-exploration:
+  en: c2982ca1d8a57a07
+  zh: 9054738d81c989bd
+/qilin-agent-subagent-fork-in-process/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/qilin-agent-subagent-fork-in-process/model-experience/child-agent-history-and-envelope:
+  en: 91a5bd22001586e9
+  zh: 456e5bf20881a70d
+/qilin-agent-subagent-fork-in-process/model-experience/child-agent-history-and-envelope/what-the-model-sees:
+  en: fe88f3e65bb01009
+  zh: 64e05acfe80e81f3
+/qilin-agent-subagent-fork-in-process/model-experience/child-agent-history-and-envelope/token-effect:
+  en: db9ae2edb5ee28ce
+  zh: 5a342ffa3e7a7b40
+/qilin-agent-subagent-fork-in-process/model-experience/child-agent-history-and-envelope/kv-cache-effect:
+  en: 45f524befcb9b070
+  zh: ddd41e8b0d218864
+/qilin-agent-subagent-fork-in-process/model-experience/parent-tool-result-indirectly:
+  en: 75d061c2151624a7
+  zh: 71e58e020b60ff90
+/qilin-agent-subagent-fork-in-process/model-experience/parent-tool-result-indirectly/what-the-model-sees:
+  en: 54d10ba4da6cdece
+  zh: bb9cb4d685098483
+/qilin-agent-subagent-fork-in-process/model-experience/parent-tool-result-indirectly/token-effect:
+  en: 8c81bab3c5d6a38a
+  zh: 44c798432a4bfdfb
+/qilin-agent-subagent-fork-in-process/model-experience/parent-tool-result-indirectly/kv-cache-effect:
+  en: f5d5f97a153f7c70
+  zh: 3d6bc05b9eadfbc2
+/qilin-agent-subagent-fork-in-process/known-limitations-and-deferred-work:
+  en: 7bdc464ac3108d28
+  zh: 6d94cdd487ab24a5
+/qilin-agent-subagent-fork-in-process/known-limitations-and-deferred-work/dev-note:
+  en: e67f633dc6fe7773
+  zh: 3bb0c20c93f16f98

package/README.md

@@ -1,3 +1,155 @@
-# Temporary Holding Version
+---
+description: "In-process fork subagent backend for users and maintainers choosing, configuring, or debugging children seeded with the parent's completed turns."
+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-fork-in-process
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`dsh-subagent-fork-in-process` is an in-process subagent backend that seeds each child with the parent's completed conversation turns: the child sees every finished turn and none of the in-flight one, so follow-up work builds on the conversation without duplicating it. A delegation tool reaches it under the `fork` provider name, and its behavior matches the spawn backend except for the session seed. Choose it when a subtask continues this conversation; choose spawn when the child must stand alone. The seed is a one-time snapshot taken at fork time: later parent turns never reach the child.
+
+## 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 when delegated work must build on the parent's conversation. The common path mirrors spawn: load the subagent service and this backend, then point a delegation tool such as `dsh-tool-subagent` at the `fork` provider.
+
+### When to choose it
+
+Choose fork when the child needs the conversation's completed turns — a follow-up analysis, a review, a continuation. Choose spawn when the child should start clean, or an out-of-process backend when the child must not share this process. The seed carries conversation history only: the child still gets a fresh tool scope and none of the parent's authority.
+
+### Seed boundary
+
+The seed ends at the parent's last completed turn. A parent's current tool-calling turn is still open when a subagent starts, so that in-flight turn is never included; before the first completed turn the seed is empty and the child behaves like a fresh spawn.
+
+### Minimal configuration
+
+Load the subagent service and this backend, then configure a delegation tool. This composition exposes a `subagent` tool backed by fork:
+
+```yaml
+- name: '@qilin-agent/subagent'
+- name: '@qilin-agent/subagent-fork-in-process'
+- name: '@qilin-agent/tool-subagent'
+  config:
+    provider: fork
+```
+
+| Field | Default | Meaning |
+|---|---|---|
+| `providerName` | `fork` | Provider name registered on `ctx.subagents` |
+
+The generated [configuration catalog](../../../docs/config-catalog.md#qilin-agentsubagent-fork-in-process) is the exhaustive source for every accepted field and its JSDoc.
+
+### What a fork delegation does
+
+One tool call creates a background child and returns its session id immediately. The child works in its own session; the parent receives its final answer in a completion notice. The child can also send messages through `send_message`. A rejected start leaves no published child. Programmatic callers such as workflows can await the activation result directly.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+This section explains the design decisions behind the backend and where the behavior in [Use this package](#use-this-package) comes from.
+
+### Design concept
+
+This backend supplies the balanced completed-turn prefix of the parent log as the child session seed. The subagent service records the inherited range so results contain only the child’s own output.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | Provider registration: prefix computation, `Config` schema, capability declaration |
+
+### Run flow
+
+`prepareContinuable()` captures the parent’s completed-turn prefix once at creation. `startActivation()` creates the child with that seed, and the subagent service applies persona, tool filtering, and structured output for this activation. The provider advertises the same agent options, output, depth, filter, and persona capabilities as spawn.
+
+### Lifecycle binding
+
+The delegation tool creates a background activation and returns a stable child session id. Parent and child share the same messaging tool definitions and ordering; the parent id and return guidance follow inherited history in the initial task. Workflows await results with caller delivery and send no completion notice to the parent.
+
+</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 the design evidence for preserving the inherited request prefix.
+
+- [Subagent subsystem](../../../docs/subsystems/subagent.md) — start requests, results, provider contract, and in-process depth and seed.
+- [dsh-subagent-spawn-in-process](../subagent-spawn-in-process/README.md) — the fresh-child sibling backend.
+- [dsh-tool-subagent](../tool-subagent/README.md) — the model-facing delegation tool that reaches this provider.
+- [Generated configuration catalog](../../../docs/config-catalog.md#qilin-agentsubagent-fork-in-process) — every accepted config field and its source declaration.
+- [Forked children preserve the parent request prefix](../../../.agents/notes/implemented/architecture/2026-08-10-fork-children-stay-one-shot.md) — why continuable fork preserves the inherited request prefix.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Child-agent history and envelope
+
+#### What the model sees
+
+The child receives the parent's balanced completed-turn prefix, then the new task content verbatim. A configured persona shadows prompt text in the child's fresh scope; a tool restriction filters its global wire schemas, executable lookup, and PTC mode SDK bindings but not standalone guidance. The parent's tool view and authority are not inherited; an optional structured-output request adds a child-only contract; the parent's current in-flight turn is excluded.
+
+#### Token effect
+
+Forking duplicates retained completed history into the child's request, which then accumulates its own tokens independently. A persona changes repeated prompt cost; filtering changes schema or generated SDK cost; a first-turn fork has no inherited history.
+
+#### KV Cache effect
+
+The child may reuse the inherited byte-identical prefix under the same provider and model. Persona, tool-filter, generated-SDK, or route changes may invalidate reuse before inherited history; later child history is append-only. Continuable messaging adds no child-only system-prompt section or tool schema; the parent id and return guidance follow inherited history in the initial user task ([cache-preserving fork Agent Note](../../../.agents/notes/implemented/architecture/2026-08-10-fork-children-stay-one-shot.md)).
+
+### Parent tool result, indirectly
+
+#### What the model sees
+
+Through `dsh-tool-subagent`, the parent first receives the child session id, then a completion notice with its final answer. Child-authored messages arrive through `send_message`; the inherited prefix and internal work remain in the child session.
+
+#### Token effect
+
+Parent input grows by one data-dependent final 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.
+
+- **The seed is a one-time snapshot** — the child sees the parent's completed turns as of the fork and nothing the parent logs afterwards; there is no live context sharing.
+- **Prefix reuse depends on matching request inputs** — parent and child messaging definitions match byte for byte; explicit persona, tool filtering, generated-SDK, or route changes can still break equality. Rationale: the [cache-preserving fork Agent Note](../../../.agents/notes/implemented/architecture/2026-08-10-fork-children-stay-one-shot.md).
+- **Shipped fork tools do not expose child LLM route selection** — they inherit the parent's provider and model so the copied history remains eligible for KV Cache reuse. Route selection stays disabled until a change can preserve reuse or expose a bounded recomputation cost.
+
+<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,155 @@
+---
+description: "面向用户与维护者的进程内 fork subagent 后端说明，用于选择、配置或排查以父级已完成轮次作初始内容的子 agent（智能体）。"
+kind: "package-reference"
+---
+
+# @qilin-agent/subagent-fork-in-process
+
+[English](README.md) | 中文
+
+## 概述
+
+`dsh-subagent-fork-in-process` 是一个进程内 subagent 后端：它以父级已完成的对话轮次作为每个子 agent 的初始内容——子 agent 能看到所有已完成轮次，但看不到进行中的轮次，因此后续工作可以在对话基础上继续，而无需重复提供对话内容。委派工具以 `fork` 提供方名称找到它，其行为与 spawn 后端一致，唯一差异是会话初始内容。当子任务延续当前对话时选择它；当子 agent 必须独立运行时选择 spawn。初始内容是 fork 时的一次性快照：此后父级记录的任何内容都不会到达子 agent。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+当委派的工作必须建立在父级对话之上时，挂载此后端。常用路径与 spawn 相同：加载 subagent 服务与本后端，再把 `dsh-tool-subagent` 之类的委派工具指向 `fork` 提供方。
+
+### 何时选择
+
+当子 agent 需要对话的已完成轮次时——后续分析、审查、延续——选择 fork。当子 agent 应全新开始时选择 spawn；当子 agent 不能共享本进程时选择进程外后端。初始内容只传递对话历史：子 agent 仍获得全新的工具作用域，且不继承父级的任何权限。
+
+### 初始内容边界
+
+初始内容止于父级最后一个已完成的轮次。subagent 启动时，父级当前的工具调用轮次仍在进行，因此该进行中的轮次绝不会被包含；在第一个已完成轮次之前，初始内容为空，子 agent 的行为与全新 spawn 相同。
+
+### 最小配置
+
+先加载 subagent 服务与本后端，再配置一个委派工具。此组合暴露由 fork 支撑的 `subagent` 工具：
+
+```yaml
+- name: '@qilin-agent/subagent'
+- name: '@qilin-agent/subagent-fork-in-process'
+- name: '@qilin-agent/tool-subagent'
+  config:
+    provider: fork
+```
+
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `providerName` | `fork` | 注册到 `ctx.subagents` 的提供方名称 |
+
+生成的[配置目录](../../../docs/config-catalog.zh.md#qilin-agentsubagent-fork-in-process)是每个受支持字段及其 JSDoc 的穷尽式真源。
+
+### 一次 fork 委派会做什么
+
+一次工具调用创建后台子 agent 并立即返回子会话 ID。子级在自己的会话中工作，父级通过完成通知收到其最终答案。子级也可以通过 `send_message` 发送消息。被拒绝的启动不会留下已发布的子 agent；工作流等程序调用方可以直接等待 activation 的结果。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释后端背后的设计决策，以及[使用本包](#use-this-package)中行为的来源。
+
+### 设计理念
+
+本后端把父级日志中已配平的已完成轮次前缀作为子会话初始内容。subagent 服务记录继承范围，因此结果只包含子级自己的输出。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | 提供方注册：前缀计算、`Config` schema、能力声明 |
+
+### 运行流程
+
+`prepareContinuable()` 在创建时捕获一次父级已完成轮次前缀。`startActivation()` 以此创建子 agent，并由 subagent 服务应用 persona、工具过滤与本次 activation 的结构化输出设置。提供方声明与 spawn 相同的 `agentOptions`、输出、深度、过滤及 persona 能力。
+
+### 生命周期绑定
+
+委派工具以后台 activation 创建子级，并返回稳定的子会话 ID。父级与子级共享相同的消息工具定义及顺序；父级 ID 与返回指导位于继承历史之后的初始任务中。工作流以调用方收集模式等待结果，不向父级发送完成通知。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当包级约定不够用时阅读以下页面；它们从共享 subagent 模型进入兄弟后端，以及保留继承请求前缀的设计证据。
+
+- [Subagent 子系统](../../../docs/subsystems/subagent.zh.md)——启动请求、结果、提供方约定与进程内深度和初始内容。
+- [dsh-subagent-spawn-in-process](../subagent-spawn-in-process/README.zh.md)——全新子级的兄弟后端。
+- [dsh-tool-subagent](../tool-subagent/README.zh.md)——指向该提供方的面向模型委派工具。
+- [生成配置目录](../../../docs/config-catalog.zh.md#qilin-agentsubagent-fork-in-process)——每个受支持配置字段及其源声明。
+- [Fork child 保留 parent 请求前缀](../../../.agents/notes/implemented/architecture/2026-08-10-fork-children-stay-one-shot.zh.md)——可继续 fork 为何保留继承的请求前缀。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### 子 agent 历史与包络
+
+#### 模型看到什么
+
+子 agent 先接收由父级已配平的已完成轮次构成的前缀，再逐字接收新的任务内容。配置的 persona 会在子 agent 的全新作用域中遮蔽提示词文本；工具限制会过滤其全局协议 schema、可执行工具查找与 PTC mode SDK 绑定，但不影响独立指导内容。父级的工具视图与权限不会被继承；可选的结构化输出请求会添加仅属于子 agent 的约定；父级当前进行中的轮次会被排除。
+
+#### Token 影响
+
+fork 会把保留的已完成历史复制到子 agent 的请求中，子 agent 随后独立累积自己的 token。persona 会改变重复提示词的成本；过滤会改变 schema 或生成 SDK 的成本；首轮 fork 没有继承历史。
+
+#### KV Cache 影响
+
+在提供方与模型相同的前提下，子 agent 可以复用继承的逐字节相同前缀。persona、工具过滤、生成 SDK 或路由变化可能在继承历史之前使复用失效；后续子 agent 历史仅追加。可继续消息不会增加子级专属的系统提示词区段或工具 schema；父级 ID 与返回指导在初始用户任务中位于继承历史之后（见[保持 fork 缓存的 Agent Note](../../../.agents/notes/implemented/architecture/2026-08-10-fork-children-stay-one-shot.zh.md)）。
+
+### 父级工具结果（间接）
+
+#### 模型看到什么
+
+父级通过 `dsh-tool-subagent` 先收到子会话 ID，随后收到包含最终答案的完成通知。子级自行编写的消息通过 `send_message` 到达；继承的前缀与内部工作保留在子会话中。
+
+#### Token 影响
+
+父级输入增加一个取决于数据的最终结果，并保留到上下文压缩（context compaction）为止。
+
+#### KV Cache 影响
+
+仅追加；新增可见内容位于可复用请求前缀之后，不会使现有 KV Cache 条目失效。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明何时选择该后端是错误的；它们是当前包约束。
+
+- **初始内容是一次性快照**——子 agent 只能看到 fork 时父级已完成的轮次，看不到父级此后记录的任何内容；不会实时共享上下文。
+- **前缀复用取决于请求输入是否匹配**——父级与子级的消息定义都逐字节相同；显式 persona、工具过滤、生成 SDK 或路由变化仍可破坏相等性。理由见[保持 fork 缓存的 Agent Note](../../../.agents/notes/implemented/architecture/2026-08-10-fork-children-stay-one-shot.zh.md)。
+- **随附 fork 工具不公开子级 LLM（大语言模型）路由选择**——它们继承父级提供方与模型，使复制的历史仍有资格复用 KV Cache。在某项改动能保留复用或公开有界重算成本前，路由选择保持禁用。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,56 @@
+import z from "@qilin-agent/schemastery";
+//#region lib/types/index.js
+/**
+* The in-process FORK subagent backend: registers a {@link SubagentProvider} on
+* `ctx.subagents` that runs each child as a child {@link Agent} SEEDED with a prefix of the
+* parent's session log — so the child inherits the parent's conversation context instead of
+* starting fresh. The seed ends at the last `turn/end`: the current tool-call turn is
+* unbalanced and cannot be replayed as a valid child session.
+* @module @qilin-agent/subagent-fork-in-process
+*/
+const name = "subagent-fork-in-process";
+const inject = ["subagents"];
+const Config = z.object({ providerName: z.string().default("fork") });
+/**
+* The balanced completed-turn prefix of `parent`'s log: every event up to and including the
+* last `turn/end`. The in-flight turn is excluded; before any completed turn the child starts
+* fresh. Because live sequence numbers equal array indexes, the result remains a valid seed
+* beginning at sequence zero.
+* @param parent - the agent whose session log to slice.
+* @returns the seed events, contiguous from seq 0; empty when no turn has completed.
+*/
+function completedTurnPrefix(parent) {
+	const events = parent.session.snapshotEvents();
+	const lastEnd = events.findLast((e) => e.type === "turn/end");
+	if (lastEnd === void 0) return [];
+	return events.slice(0, lastEnd.seq + 1);
+}
+/**
+* The fork provider. Supports `depthLimit` and `outputSchema` (via the shared
+* in-process structured runtime), `agentOptions` (merged over the parent
+* route), and `toolFilter`/`persona` (scoped restrict() and a scoped shadowing
+* persona section).
+*/
+var ForkInProcessProvider = class {
+	name;
+	capabilities = {
+		agentOptions: true,
+		outputSchema: true,
+		depthLimit: true,
+		toolFilter: true,
+		persona: true
+	};
+	inheritsParentContext = true;
+	constructor(name) {
+		this.name = name;
+	}
+	prepareContinuable(request) {
+		const seed = completedTurnPrefix(request.parent);
+		return Promise.resolve(seed.length > 0 ? { seed } : {});
+	}
+};
+function apply(ctx, config) {
+	ctx.subagents.registerProvider(new ForkInProcessProvider(config.providerName));
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The in-process FORK subagent backend: registers a {@link SubagentProvider} on
+ * `ctx.subagents` that runs each child as a child {@link Agent} SEEDED with a prefix of the
+ * parent's session log — so the child inherits the parent's conversation context instead of
+ * starting fresh. The seed ends at the last `turn/end`: the current tool-call turn is
+ * unbalanced and cannot be replayed as a valid child session.
+ * @module @qilin-agent/subagent-fork-in-process
+ */
+import type { Context } from '@qilin-agent/kylin';
+import z from '@qilin-agent/schemastery';
+export declare const name = "subagent-fork-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 `fork`). */
+    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,53 @@
 {
   "name": "@qilin-agent/subagent-fork-in-process",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "In-process fork subagent backend: runs a child agent seeded with a prefix of the parent's log",
+  "version": "3.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/subagent/subagent-fork-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/agent": "3.1.4",
+    "@qilin-agent/subagent": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/session": "3.1.4"
+  },
+  "dependencies": {
+    "@qilin-agent/schemastery": "~3.18.3"
+  },
+  "devDependencies": {
+    "@qilin-agent/kylin-plugin-loader": "~1.0.4",
+    "@qilin-agent/agent": "3.1.4",
+    "@qilin-agent/agent-loop": "3.1.4",
+    "@qilin-agent/agent-loop-testkit": "3.1.4",
+    "@qilin-agent/subagent": "3.1.4",
+    "@qilin-agent/subagent-spawn-in-process": "3.1.4",
+    "@qilin-agent/llm": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/session-projection": "3.1.4",
+    "@qilin-agent/session": "3.1.4"
+  }
 }