super-dsh 0.3.0-c → 0.3.0-e

package/node_modules/better-dsh/dsh-docs/user/develop/framework/events.zh.md

@@ -1,143 +0,0 @@
-# 事件系统
-
-[English](events.md) | 中文
-
-事件是 Cordis 插件间通信的核心机制。Harness 大量使用事件来实现松耦合的扩展点。
-
-## 基本用法
-
-### 监听事件
-
-```ts ignore-check
-ctx.on('event-name', (payload) => {
-  // Handle the event.
-})
-```
-
-### 触发事件
-
-```ts ignore-check
-ctx.emit('event-name', payload)
-```
-
-## 事件模式
-
-Cordis 提供多种事件模式，适用于不同的交互契约：
-
-### emit — 广播
-
-所有监听器同步执行，返回值会被忽略：
-
-```ts ignore-check
-// Emit
-ctx.emit('my-plugin/ready', { id: 'worker-1' })
-
-// Listen
-ctx.on('my-plugin/ready', ({ id }) => {
-  console.log(`${id} is ready`)
-})
-```
-
-### bail — 短路
-
-监听器按顺序运行，第一个不是 `null`、`false` 或 `undefined` 的返回值会成为最终结果：
-
-```ts ignore-check
-// Dispatch
-const result = ctx.bail('some-check', input)
-
-// Listen: a returned value stops later listeners.
-ctx.on('some-check', (input) => {
-  if (shouldBlock(input)) return 'blocked'
-  // Return null, false, or undefined to continue to the next listener.
-})
-```
-
-### serial — 顺序执行
-
-监听器按注册顺序依次执行，并等待异步结果；第一个不是 `null`、`false` 或 `undefined` 的返回值会终止后续执行：
-
-```ts ignore-check
-await ctx.serial('setup-phase', context)
-```
-
-### waterfall（瀑布式事件）— 流水线
-
-每个监听器可以包装下游返回值，形成处理链。**必须调用 `next()` 传递给下游**，不调用即会短路流水线：
-
-```ts ignore-check
-// Dispatch
-const output = await ctx.waterfall('my-plugin/transform', input, async () => input)
-
-// Listen: next() is mandatory.
-ctx.on('my-plugin/transform', async (_input, next) => {
-  const downstream = await next()
-  return downstream.trim()
-})
-```
-
-::: warning
-waterfall 监听器**必须调用 `next()`**。不调用 `next` 会短路整个流水线，这是故意为之的设计——用于实现拦截/网关逻辑。
-:::
-
-## 类型安全的事件
-
-Harness 使用 TypeScript 声明合并来为事件提供类型安全：
-
-```ts
-import '@deepseek-ai/cordis'
-
-declare module '@deepseek-ai/cordis' {
-  interface Events {
-    'my-plugin/ready': (payload: { id: string }) => void
-    'my-plugin/check': (input: string) => boolean | undefined
-    'my-plugin/transform': (input: string, next: () => Promise<string>) => Promise<string>
-  }
-}
-
-// ctx.on('my-plugin/ready', ...) and ctx.emit('my-plugin/ready', ...)
-// are now inferred correctly.
-```
-
-## Cordis 事件与会话记录
-
-Harness 的 Cordis 事件遵循 `namespace/action` 命名，例如 `agent/pre-step`、`agent/request`、`agent/request-error`、`tools/result` 和 `session/event`。完整签名与触发模式见[子系统页面](../../../subsystems/core.zh.md)上生成的 `cordis-surface` 区块。
-
-`turn/*`、`step/*`、`tool/call`、`tool/result` 和 `compaction/*` 是持久化的会话事件类型，不是同名 Cordis 事件。需要观察它们时，监听 `session/event` 并检查 `event.type`。
-
-## 事件监听器也是效果
-
-通过 `ctx.on()` 注册的监听器会在插件卸载时自动移除：
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // This listener is removed when the plugin disposes.
-  ctx.on('tools/result', handler)
-}
-```
-
-## 示例：日志插件
-
-这个插件记录工具调用和工具结果：
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-import '@deepseek-ai/dsh-tools'
-
-export const name = 'tool-logger'
-
-export function apply(ctx: Context) {
-  ctx.on('tools/result', (exec, result) => {
-    console.log(`[tool] ${exec.name}(${JSON.stringify(exec.arguments)})`)
-    const text = result.content
-      .map(block => block.type === 'text' ? block.text : '')
-      .join('')
-    console.log(`[tool result] ${text.slice(0, 100)}`)
-  })
-}
-```
-
-## 下一步
-
-- [能力分层](../practice/index.zh.md) — 了解能力接口中的事件
-- [LLM（大语言模型）适配器](../practice/llm-adapter.zh.md) — 实现一个完整的 LLM 后端

package/node_modules/better-dsh/dsh-docs/user/develop/framework/index.md

@@ -1,137 +0,0 @@
-# Plugins and lifecycle
-
-English | [中文](index.zh.md)
-
-This page describes the Cordis plugin model and lifecycle state machine.
-
-## Fiber state machine
-
-Every loaded plugin owns a **Fiber** scope with the following states:
-
-```
-PENDING → LOADING → ACTIVE
-                 ↘ FAILED
-ACTIVE → UNLOADING → DISPOSED
-```
-
-| State | Meaning |
-|------|------|
-| PENDING | Declared, but required dependencies are not ready |
-| LOADING | Dependencies are ready and `apply` is running |
-| ACTIVE | The plugin is running |
-| FAILED | `apply` threw an error |
-| UNLOADING | The plugin is unloading and disposing resources |
-| DISPOSED | The plugin is fully unloaded |
-
-## Dependency-driven loading
-
-A plugin with `inject` waits for every required service before loading:
-
-```ts ignore-check
-export const inject = ['tools', 'llm']
-
-export function apply(ctx: Context) {
-  // ctx.tools and ctx.llm are ready here.
-}
-```
-
-If a required service disappears, for example during provider replacement, the plugin unloads automatically (ACTIVE → DISPOSED) and loads again when the service returns.
-
-## Automatic cleanup
-
-Every registration made through `ctx` is undone when the plugin unloads:
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // Event listener: removed automatically on unload.
-  ctx.on('some-event', handler)
-
-  // Custom resource: the returned disposer runs on unload.
-  ctx.effect(() => {
-    const connection = createConnection()
-    return () => connection.close()
-  })
-}
-```
-
-The framework tracks and disposes all of these operations:
-- `ctx.on(event, handler)` — event listener
-- `ctx.tools.register(tool)` — tool registration
-- `ctx.llm.registerAdapter(names, adapter)` — LLM adapter registration
-- `ctx.effect(() => cleanup)` — custom resource
-
-During unload, disposer invocation starts in reverse registration order, but multiple async disposers run concurrently and have no serial completion guarantee. Put order-dependent cleanup in one disposer returned from a single `ctx.effect()` and await its steps serially there.
-
-## Nested contexts
-
-`ctx.plugin()` creates a child Fiber that inherits the parent context but has an independent lifecycle:
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // Register a child plugin.
-  ctx.plugin(childPlugin)
-
-  // The child has its own Fiber and unloads with its parent.
-}
-```
-
-## Dispose semantics
-
-To stop a plugin instance early:
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-declare const ctx: Context
-declare function myPlugin(ctx: Context): void
-
-const fiber = ctx.plugin(myPlugin)
-
-// Dispose it manually later.
-await fiber.dispose()
-```
-
-`dispose` guarantees:
-1. All registrations owned by the plugin are removed.
-2. Child plugins are recursively unloaded.
-3. The returned promise resolves after all asynchronous cleanup finishes.
-
-## Hot replacement (HMR)
-
-With `@deepseek-ai/cordis-plugin-hmr` loaded from `cordis.yml`, editing a plugin source file triggers:
-
-1. Unload the old plugin and clean up its registrations.
-2. Load the new code.
-3. Run the new `apply`.
-
-Because plugin registrations clean themselves up, hot replacement does not retain registrations from the old instance.
-
-## Example lifecycle
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  console.log('plugin loading')
-
-  ctx.effect(() => {
-    console.log('effect registered')
-    return () => console.log('effect cleaned up')
-  })
-}
-```
-
-Loading prints:
-```
-plugin loading
-effect registered
-```
-
-Unloading prints:
-```
-effect cleaned up
-```
-
-## Next steps
-
-- [Services and dependencies](./service.md) — expose a capability to other plugins
-- [Event system](./events.md) — communicate between plugins
-- [Cordis tutorial](../../../cordis-tutorial/index.md) — the same lifecycle, services, and events built step by step against the Cordis runtime

package/node_modules/better-dsh/dsh-docs/user/develop/framework/index.zh.md

@@ -1,137 +0,0 @@
-# 插件与生命周期
-
-[English](index.md) | 中文
-
-本页介绍 Cordis 插件模型和生命周期状态机。
-
-## Fiber 状态机
-
-每个被加载的插件都拥有一个 **Fiber** 作用域，其状态如下：
-
-```
-PENDING → LOADING → ACTIVE
-                 ↘ FAILED
-ACTIVE → UNLOADING → DISPOSED
-```
-
-| 状态 | 含义 |
-|------|------|
-| PENDING | 已声明，但所需依赖未就绪 |
-| LOADING | 依赖就绪，正在执行 `apply` |
-| ACTIVE | 插件运行中 |
-| FAILED | `apply` 抛出异常 |
-| UNLOADING | 插件正在卸载并释放资源 |
-| DISPOSED | 已完全卸载 |
-
-## 依赖驱动的加载
-
-声明了 `inject` 的插件会等待所有必需服务就绪：
-
-```ts ignore-check
-export const inject = ['tools', 'llm']
-
-export function apply(ctx: Context) {
-  // ctx.tools and ctx.llm are ready here.
-}
-```
-
-如果依赖的服务消失（例如提供方被替换时），插件会被自动卸载（ACTIVE → DISPOSED），待服务恢复后重新加载。
-
-## 自动清理机制
-
-通过 `ctx` 做的任何注册，在插件卸载时都会自动撤销：
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // Event listener: removed automatically on unload.
-  ctx.on('some-event', handler)
-
-  // Custom resource: the returned disposer runs on unload.
-  ctx.effect(() => {
-    const connection = createConnection()
-    return () => connection.close()
-  })
-}
-```
-
-以下操作都会被自动追踪和清理：
-- `ctx.on(event, handler)` — 事件监听
-- `ctx.tools.register(tool)` — 工具注册
-- `ctx.llm.registerAdapter(names, adapter)` — LLM（大语言模型）适配器注册
-- `ctx.effect(() => cleanup)` — 自定义资源
-
-插件卸载时，处置器按注册顺序的逆序开始调用，但多个异步处置器会并发执行，不保证逐个完成。存在顺序依赖的清理步骤必须放进同一个 `ctx.effect()` 返回的处置器中，由该处置器负责串行等待。
-
-## 嵌套上下文
-
-`ctx.plugin()` 创建子 Fiber，它继承父上下文但有独立的生命周期：
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  // Register a child plugin.
-  ctx.plugin(childPlugin)
-
-  // The child has its own Fiber and unloads with its parent.
-}
-```
-
-## dispose（资源释放）语义
-
-当你需要提前终止一个插件实例：
-
-```ts
-import type { Context } from '@deepseek-ai/cordis'
-
-declare const ctx: Context
-declare function myPlugin(ctx: Context): void
-
-const fiber = ctx.plugin(myPlugin)
-
-// Dispose it manually later.
-await fiber.dispose()
-```
-
-`dispose` 保证：
-1. 该插件拥有的所有注册均被移除
-2. 它的子插件也被递归卸载
-3. 返回的 Promise 会在所有异步清理完成后兑现
-
-## HMR（热模块替换）
-
-通过 `cordis.yml` 加载 `@deepseek-ai/cordis-plugin-hmr` 后，修改插件源文件会触发：
-
-1. 卸载旧插件（清理所有注册）
-2. 重新加载新代码
-3. 执行新的 `apply`
-
-因为插件注册会被自动清理，所以热替换不会保留旧实例的注册。
-
-## 生命周期示例
-
-```ts ignore-check
-export function apply(ctx: Context) {
-  console.log('plugin loading')
-
-  ctx.effect(() => {
-    console.log('effect registered')
-    return () => console.log('effect cleaned up')
-  })
-}
-```
-
-加载时输出：
-```
-plugin loading
-effect registered
-```
-
-卸载时输出：
-```
-effect cleaned up
-```
-
-## 下一步
-
-- [服务与依赖](./service.zh.md) — 让插件向其他插件提供能力
-- [事件系统](./events.zh.md) — 在插件之间通信
-- [Cordis 框架教程](../../../cordis-tutorial/index.zh.md) — 在 Cordis 运行时上逐步搭出同一套生命周期、服务与事件

package/node_modules/better-dsh/dsh-docs/user/develop/framework/service.md

@@ -1,148 +0,0 @@
-# Services and dependencies
-
-English | [中文](service.zh.md)
-
-A service is a capability one plugin exposes to other plugins. `inject` declares the services a plugin requires.
-
-## What is a service?
-
-In Harness, `tools`, `llm`, and `agents` are services. Each is a named capability mounted on `ctx`:
-
-```ts ignore-check
-ctx.tools    // ToolRuntime service
-ctx.llm      // LLM service
-ctx.agents   // Agent service
-```
-
-Any plugin can provide a service for other plugins to consume.
-
-## Consume a service
-
-Declare `inject` to use an existing service:
-
-```ts ignore-check
-export const inject = ['tools']
-
-export function apply(ctx: Context) {
-  // ctx.tools exists and is ready here.
-  ctx.tools.register(/* ... */)
-}
-```
-
-When `apply` runs, every service declared by `inject` is ready. If a service is not ready, the plugin waits instead of running.
-
-## Provide a service
-
-### Extend Service
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-export default class MetricsService extends Service {
-  static inject = ['llm']  // A service may depend on other services.
-
-  constructor(ctx: Context) {
-    super(ctx, 'metrics')  // 'metrics' is the service name.
-  }
-
-  // Public service method.
-  record(event: string, value: number) {
-    // ...
-  }
-}
-```
-
-After loading this plugin, consumers access the service as `ctx.metrics`:
-
-```ts ignore-check
-export const inject = ['metrics']
-
-export function apply(ctx: Context) {
-  ctx.metrics.record('tool_call', 1)
-}
-```
-
-### Declare its type
-
-Use TypeScript declaration merging to type `ctx.metrics`:
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-declare module '@deepseek-ai/cordis' {
-  interface Context {
-    metrics: MetricsService
-  }
-}
-
-export default class MetricsService extends Service {
-  constructor(ctx: Context) {
-    super(ctx, 'metrics')
-  }
-
-  record(event: string, value: number) { /* ... */ }
-}
-```
-
-## Dependency behavior
-
-### Required and optional dependencies
-
-```ts ignore-check
-// Required: the plugin does not load while the service is absent.
-export const inject = ['tools']
-
-// Optional: omit inject and query with ctx.get() at the use site.
-export function apply(ctx: Context) {
-  const metrics = ctx.get('metrics')
-  metrics?.record('plugin_loaded', 1)
-}
-```
-
-### When a service disappears
-
-If a required service disappears while the application is running, for example because its provider unloads:
-
-1. Dependent plugins dispose automatically.
-2. They load again when the service returns.
-
-This prevents a plugin from calling a service that no longer exists.
-
-## Service isolation
-
-`cordis.yml` can isolate services so separate plugin groups see separate instances of the same service:
-
-```yaml
-- id: group-a
-  name: '@deepseek-ai/cordis-plugin-group'
-  group: true
-  isolate:
-    shell: true
-  config:
-    - name: '@deepseek-ai/dsh-bash-local'
-      config:
-        timeoutMs: 5000
-    - name: './src/plugin-a.ts'
-
-- id: group-b
-  name: '@deepseek-ai/cordis-plugin-group'
-  group: true
-  isolate:
-    shell: true
-  config:
-    - name: '@deepseek-ai/dsh-bash-local'
-      config:
-        timeoutMs: 60000
-    - name: './src/plugin-b.ts'
-```
-
-`plugin-a` and `plugin-b` each see the Bash instance in their own group, with no cross-group effect.
-
-## Built-in Harness services
-
-The repository generates the service names, public methods, and source locations into each service's [subsystem page](../../../subsystems/core.md). Use those generated regions and the service's TypeScript interface while developing a plugin; do not maintain a second static list.
-
-## Next steps
-
-- [Event system](./events.md) — communicate between plugins without tight coupling
-- [Capability layering](../practice/index.md) — use services as capability interfaces

package/node_modules/better-dsh/dsh-docs/user/develop/framework/service.zh.md

@@ -1,150 +0,0 @@
-# 服务与依赖
-
-[English](service.md) | 中文
-
-服务是一个插件向其他插件公开的能力。inject 声明插件需要哪些服务。
-
-## 什么是服务
-
-在 Harness 中，`tools`、`llm`、`agents` 都是服务。服务是挂载在 `ctx` 上的命名能力：
-
-```ts ignore-check
-ctx.tools    // ToolRuntime service
-ctx.llm      // LLM service
-ctx.agents   // Agent service
-```
-
-任何插件都可以提供服务，供其他插件使用。
-
-## 使用服务
-
-声明 `inject` 来使用已有服务：
-
-```ts ignore-check
-export const inject = ['tools']
-
-export function apply(ctx: Context) {
-  // ctx.tools exists and is ready here.
-  ctx.tools.register(/* ... */)
-}
-```
-
-框架保证：在 `apply` 执行时，`inject` 声明的服务已经全部就绪。如果服务还没准备好，你的插件会等着，不会执行。
-
-## 提供服务
-
-### 使用 Service 基类
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-export default class MetricsService extends Service {
-  static inject = ['llm']  // A service may depend on other services.
-
-  constructor(ctx: Context) {
-    super(ctx, 'metrics')  // 'metrics' is the service name.
-  }
-
-  // Public service method.
-  record(event: string, value: number) {
-    // ...
-  }
-}
-```
-
-加载这个插件后，消费方就可以通过 `ctx.metrics` 访问它：
-
-```ts ignore-check
-export const inject = ['metrics']
-
-export function apply(ctx: Context) {
-  ctx.metrics.record('tool_call', 1)
-}
-```
-
-### 类型声明
-
-使用 TypeScript 声明合并让 `ctx.metrics` 有正确类型：
-
-```ts
-import { Service, type Context } from '@deepseek-ai/cordis'
-
-declare module '@deepseek-ai/cordis' {
-  interface Context {
-    metrics: MetricsService
-  }
-}
-
-export default class MetricsService extends Service {
-  constructor(ctx: Context) {
-    super(ctx, 'metrics')
-  }
-
-  record(event: string, value: number) { /* ... */ }
-}
-```
-
-## 依赖的行为
-
-### 必需依赖与可选依赖
-
-```ts ignore-check
-// Required: the plugin does not load while the service is absent.
-export const inject = ['tools']
-
-// Optional: omit inject and query with ctx.get() at the use site.
-export function apply(ctx: Context) {
-  const metrics = ctx.get('metrics')
-  metrics?.record('plugin_loaded', 1)
-}
-```
-
-### 服务消失时的行为
-
-如果应用运行期间某项必需服务消失（例如其提供方卸载）：
-
-1. 依赖它的插件会自动 dispose（资源释放）
-2. 当服务重新出现时，插件自动重新加载
-
-这可以防止插件调用已不存在的服务。
-
-<a id="service-isolation"></a>
-
-## 服务隔离
-
-`cordis.yml` 支持服务隔离——同一个服务可以有多个实例，不同插件组看到不同实例：
-
-```yaml
-- id: group-a
-  name: '@deepseek-ai/cordis-plugin-group'
-  group: true
-  isolate:
-    shell: true
-  config:
-    - name: '@deepseek-ai/dsh-bash-local'
-      config:
-        timeoutMs: 5000
-    - name: './src/plugin-a.ts'
-
-- id: group-b
-  name: '@deepseek-ai/cordis-plugin-group'
-  group: true
-  isolate:
-    shell: true
-  config:
-    - name: '@deepseek-ai/dsh-bash-local'
-      config:
-        timeoutMs: 60000
-    - name: './src/plugin-b.ts'
-```
-
-`plugin-a` 和 `plugin-b` 各自看到自己组内的 Bash 实例，互不影响。
-
-## Harness 内置服务
-
-服务名、公开方法和源码位置由仓库自动生成到各服务的[子系统页面](../../../subsystems/core.zh.md)。开发插件时应以这些生成区块和服务的 TypeScript 接口为准，不要维护另一份静态清单。
-
-## 下一步
-
-- [事件系统](./events.zh.md) — 插件间松耦合通信
-- [能力分层](../practice/index.zh.md) — 将服务用作能力接口