@elinpf/dsh-ops-prompts 0.1.0

package/README.i18n.yaml

@@ -0,0 +1,4 @@
+title: "@elinpf/dsh-ops-prompts"
+description:
+  zh: "Ops 提示词编排中心 — 方法论 section 与动态 reminder 的统一注册渠道"
+  en: "Ops prompt orchestration center — methodology sections and dynamic reminders for the ops preset"

package/README.md

@@ -0,0 +1,35 @@
+# @elinpf/dsh-ops-prompts
+
+Ops prompt orchestration center for DeepSeek Harness — one channel through which other ops plugins register methodology sections (static system-prompt text) and dynamic reminders (pre-step checks that inject ephemeral prompts).
+
+## What it does
+
+- **`ctx.get('opsPrompts')` handle** with two registration surfaces, each returning a disposer:
+  - `registerMethodology({ name, order, text })` — a static system-prompt section. All entries are rendered by a single `ops:methodology` section (order-sorted) that is re-evaluated at every prompt assembly, so late registrations and disposals take effect without rebuilding the prompt.
+  - `registerReminder({ name, check })` — a rule evaluated at each `agent/pre-step`. Non-null results are joined and delivered through `agent.inject`, which goes through the durable inbox splice: the reminder is reconstructable from the session log (model-visible ⟺ logged).
+- **Core ops methodology** (`ops:core`, order 250): root-cause discipline, verify-before-concluding, and investigation structuring — the shared baseline every ops tool builds on.
+- **Bundled skills provider** (`ops-prompts-bundled`, `src/skills.ts`): ships this package's `skills/` directory into dsh's native skill subsystem. Markdown files with native frontmatter (`name`/`description` required, `whenToUse` optional, `disable-model-invocation` honored) become catalog candidates; bodies are pulled on demand through the `skill` tool. The skills registry is optional — resolved get-first with an `ctx.inject` fallback, and tolerated when absent (the package then works as a pure prompt channel).
+
+## Design notes
+
+- **One section, many entries.** Methodology text aggregates into a single system-prompt section instead of one section per contributor, so ordering stays explicit (`order`) and prompt assembly reads one closure over the registry map.
+- **Reminders are ephemeral, never durable state.** Rules live in fiber-local maps; only the injected message touches the session log, via the platform's own inbox splice — so this package owns no session event types and no projection.
+- **Everything is fiber-scoped.** The system-prompt section and the skills provider register through `ctx.effect`; the pre-step listener is fiber-scoped via `ctx.on`. Fiber disposal/HMR removes every surface (covered by `tests/hmr-unload.spec.ts`).
+- **A prompt-only skill is a text file, never a package** — the bundled provider exists so repo-managed Markdown skills ride the native catalog instead of a self-built loader.
+
+## Config
+
+| Key | Type | Default | Description |
+|---|---|---|---|
+| `reminderEnabled` | `boolean` | `true` | Whether dynamic reminders are evaluated at each agent/pre-step. |
+
+Required inject: `systemPrompt`. Optional: `skills` (host-plane registry).
+
+## Testing
+
+```sh
+npm run build   # tsc → lib/
+npx vitest run  # unit specs + HMR unload spec
+```
+
+`tests/ops-prompts.spec.ts` covers the handle, methodology aggregation, and reminder delivery; `tests/skills.spec.ts` covers frontmatter parsing, the bundled provider, and the optional skills registration; `tests/hmr-unload.spec.ts` runs every collected disposer and asserts each registration surface is gone.

package/README.zh.md

@@ -0,0 +1,35 @@
+# @elinpf/dsh-ops-prompts
+
+DeepSeek Harness 的 ops 提示词编排中心 — 其他 ops 插件通过这一个渠道注册方法论 section(静态系统提示词文本)和动态 reminder(pre-step 检查函数,注入临时提示词)。
+
+## 功能
+
+- **`ctx.get('opsPrompts')` 句柄**,两个注册面,都返回 disposer:
+  - `registerMethodology({ name, order, text })` — 静态系统提示词 section。所有条目由同一个 `ops:methodology` section 渲染(按 `order` 排序),每次组装提示词时重新求值,所以晚注册和注销都能即时生效。
+  - `registerReminder({ name, check })` — 每个 `agent/pre-step` 求值的规则。非空结果拼接后通过 `agent.inject` 投递,走持久化 inbox splice:reminder 可以从会话日志重建(model-visible ⟺ logged)。
+- **核心 ops 方法论**(`ops:core`,order 250):根因纪律、下结论前先验证、调查结构化 — 所有 ops 工具共享的基线。
+- **bundled skills provider**(`ops-prompts-bundled`,`src/skills.ts`):把本包 `skills/` 目录送进 dsh 原生 skill 子系统。带原生 frontmatter 的 Markdown(`name`/`description` 必填,`whenToUse` 可选,支持 `disable-model-invocation`)成为 catalog 候选;正文通过 `skill` 工具按需拉取。skills 注册表是可选依赖 — 先 `ctx.get` 再 `ctx.inject` 兜底,缺失时容忍(包退化为纯提示词渠道)。
+
+## 设计要点
+
+- **一个 section,多个条目。** 方法论文本聚合进单个系统提示词 section,而不是每个贡献者一个 section:排序靠 `order` 显式表达,提示词组装只读一个闭包。
+- **reminder 是临时的,永远不是持久状态。** 规则活在 fiber 局部 Map 里;只有注入的消息经由平台自己的 inbox splice 进入会话日志 — 因此本包不拥有任何 session 事件类型,也不需要 projection。
+- **一切注册都是 fiber 作用域。** 系统提示词 section 和 skills provider 走 `ctx.effect`,pre-step 监听器经 `ctx.on` 挂在 fiber 上。fiber 销毁/HMR 会卸掉所有注册面(`tests/hmr-unload.spec.ts` 覆盖)。
+- **纯提示词 skill 就是一个文本文件,永远不是一个包** — bundled provider 的意义在于让仓库维护的 Markdown skill 搭原生 catalog 的车,而不是自建加载器。
+
+## 配置
+
+| 键 | 类型 | 默认值 | 说明 |
+|---|---|---|---|
+| `reminderEnabled` | `boolean` | `true` | 是否在每个 agent/pre-step 求值动态 reminder。 |
+
+必需 inject:`systemPrompt`。可选:`skills`(host 平面注册表)。
+
+## 测试
+
+```sh
+npm run build   # tsc → lib/
+npx vitest run  # 单元测试 + HMR 卸载测试
+```
+
+`tests/ops-prompts.spec.ts` 覆盖句柄、方法论聚合和 reminder 投递;`tests/skills.spec.ts` 覆盖 frontmatter 解析、bundled provider 和可选 skills 注册;`tests/hmr-unload.spec.ts` 执行所有收集到的 disposer 并断言每个注册面都被移除。

package/cordis.patch.yml

@@ -0,0 +1 @@
+[]

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Ops prompt orchestration center.
+ *
+ * Provides a capability (`ctx.get('opsPrompts')`) that other ops plugins use
+ * to register methodology prompts (static system prompt sections) and dynamic
+ * reminders (evaluated at each agent/pre-step, injected into the conversation
+ * flow).
+ *
+ * It also registers its own core ops methodology prompt and the agent/pre-step
+ * listener that evaluates all registered reminder rules.
+ *
+ * @module @elinpf/dsh-ops-prompts
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { Config as ConfigShape } from './types.js';
+export * from './skills.js';
+export type { MethodologyEntry, OpsPromptsHandle, ReminderEntry } from './types.js';
+export declare const name = "ops-prompts";
+export declare const inject: string[];
+export type Config = ConfigShape;
+export declare const Config: z<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,130 @@
+/**
+ * Ops prompt orchestration center.
+ *
+ * Provides a capability (`ctx.get('opsPrompts')`) that other ops plugins use
+ * to register methodology prompts (static system prompt sections) and dynamic
+ * reminders (evaluated at each agent/pre-step, injected into the conversation
+ * flow).
+ *
+ * It also registers its own core ops methodology prompt and the agent/pre-step
+ * listener that evaluates all registered reminder rules.
+ *
+ * @module @elinpf/dsh-ops-prompts
+ */
+import z from '@deepseek-ai/schemastery';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { createBundledSkillsProvider } from './skills.js';
+export * from './skills.js';
+// ── Plugin identity ───────────────────────────────────────────────────────────
+export const name = 'ops-prompts';
+export const inject = ['systemPrompt'];
+export const Config = z.object({
+    reminderEnabled: z.boolean().default(true),
+});
+// ── Core ops methodology ─────────────────────────────────────────────────────
+const CORE_METHODOLOGY = [
+    '## Ops investigation discipline',
+    '',
+    '### Root cause analysis',
+    '- Every conclusion must answer "why". Do not stop at a symptom or intermediate cause.',
+    '- Keep asking "why does this happen?" until you reach a physical or infrastructure-level fact',
+    '  (e.g. "disk full", "memory exhausted", "network partition").',
+    '- "The CSI operation is stuck" is NOT a root cause. "Ceph storage is 99% full, blocking OMAP writes"',
+    '  IS a root cause.',
+    '',
+    '### Verify before concluding',
+    '- Do not mark a step done with an unverified hypothesis.',
+    '- If you claim "X is caused by Y", verify Y before completing the step.',
+    '- `done` means the investigation of this step is complete, NOT that the conclusion is final.',
+    '  Use `reopen` when a completed step\'s conclusion turns out to be wrong or incomplete.',
+    '',
+    '### Structure your investigation',
+    '- When you find something new, add a step — do not accumulate findings in a single node.',
+    '- Use `link` to record causal edges: "this symptom is caused by that root cause".',
+    '- Use `abandon` for dead ends AND for steps no longer relevant due to changed circumstances.',
+].join('\n');
+// ── Plugin apply ─────────────────────────────────────────────────────────────
+export function apply(ctx, config) {
+    const methodologies = new Map();
+    const reminders = new Map();
+    // Expose the handle so other plugins can register through ctx.get('opsPrompts')
+    const handle = {
+        registerMethodology(opts) {
+            methodologies.set(opts.name, opts);
+            return () => { methodologies.delete(opts.name); };
+        },
+        registerReminder(opts) {
+            reminders.set(opts.name, opts);
+            return () => { reminders.delete(opts.name); };
+        },
+    };
+    ctx.provide('opsPrompts', handle);
+    // Register core ops methodology as the first entry
+    handle.registerMethodology({
+        name: 'ops:core',
+        order: 250,
+        text: CORE_METHODOLOGY,
+    });
+    // Bundled ops skills: ship this package's skills/ directory into dsh's
+    // native skill subsystem (catalog via candidates, bodies pulled on demand
+    // through the `skill` tool). The skills registry lives in the host
+    // composition — resolve with the usual get-first / inject-fallback race
+    // discipline, and tolerate its absence (this package then works as a pure
+    // prompt channel).
+    const registerBundledSkills = (rctx, registry) => {
+        rctx.effect(() => registry.registerProvider(() => createBundledSkillsProvider(undefined, m => rctx.logger('ops-prompts').warn(m))));
+    };
+    const immediateSkills = ctx.get('skills');
+    if (immediateSkills !== undefined) {
+        registerBundledSkills(ctx, immediateSkills);
+    }
+    else {
+        ctx.inject(['skills'], (pctx) => {
+            registerBundledSkills(pctx, pctx.skills);
+        });
+    }
+    // System prompt section that renders all registered methodology entries.
+    // Re-evaluated at each prompt assembly. systemPrompt is a REQUIRED inject:
+    // an absent service pends the fiber and apply never runs, so read it as a
+    // declared dependency — a ctx.get fallback branch would be dead code.
+    // The section disposer MUST go through ctx.effect: the service returns a
+    // disposer that fiber disposal/HMR would otherwise never run (leak).
+    const systemPrompt = ctx.systemPrompt;
+    ctx.effect(() => systemPrompt.section({
+        name: 'ops:methodology',
+        order: 250,
+        text: () => {
+            const entries = [...methodologies.values()].sort((a, b) => a.order - b.order);
+            return entries.map((e) => e.text).join('\n\n');
+        },
+    }));
+    // agent/pre-step listener: evaluate all registered reminder rules.
+    // Non-null results are delivered through agent.inject — the message goes
+    // through the durable inbox splice (agent/inbox/spliced), so the reminder
+    // is reconstructable from the session log (model-visible ⟺ logged) and is
+    // claimed at the next step boundary.
+    if (config.reminderEnabled) {
+        ;
+        ctx.on('agent/pre-step', async (payload, next) => {
+            const decision = await next();
+            if (decision.kind === 'reject')
+                return decision;
+            const agent = payload?.agent;
+            if (!agent || typeof agent.inject !== 'function')
+                return decision;
+            const results = [];
+            for (const reminder of reminders.values()) {
+                const text = reminder.check(agent);
+                if (text !== null)
+                    results.push(text);
+            }
+            if (results.length === 0)
+                return decision;
+            agent.inject(createUserMessage({
+                content: [{ type: 'text', text: results.join('\n') }],
+                source: { kind: 'plugin', plugin: name, form: 'notice', summary: 'ops reminder' },
+            }));
+            return decision;
+        }, { prepend: true });
+    }
+}

package/lib/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Invariant companion for @elinpf/dsh-ops-prompts.
+ *
+ * @module @elinpf/dsh-ops-prompts/invariant
+ */
+/** Cordis companion plugin name. */
+declare const name = "ops-prompts-invariant";
+/** Service required before the companion can reserve package ownership. */
+declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Context carrying the invariant service.
+ * @returns a promise resolving after registration.
+ */
+declare const apply: (ctx: any) => Promise<void>;
+export { apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,27 @@
+/**
+ * Invariant companion for @elinpf/dsh-ops-prompts.
+ *
+ * @module @elinpf/dsh-ops-prompts/invariant
+ */
+const PACKAGE_NAME = '@elinpf/dsh-ops-prompts';
+/** Cordis companion plugin name. */
+const name = 'ops-prompts-invariant';
+/** Service required before the companion can reserve package ownership. */
+const inject = ['invariants'];
+/**
+ * No runtime invariant: this plugin owns no session event types and no
+ * durable state. Methodology entries and reminder rules are ephemeral
+ * registrations held in fiber-local maps, and reminder delivery goes through
+ * agent.inject, which the session inbox splice already logs (model-visible
+ * ⟺ logged holds without a package-owned fold).
+ */
+const install = () => { };
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Context carrying the invariant service.
+ * @returns a promise resolving after registration.
+ */
+const apply = async (ctx) => {
+    ctx.invariants.register(PACKAGE_NAME, install);
+};
+export { apply, inject, name };

package/lib/skills.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Bundled ops skills provider.
+ *
+ * Ships the repo-managed ops skills (Markdown files in this package's
+ * `skills/` directory) into dsh's NATIVE skill subsystem: candidates carry
+ * name + description into the model-facing catalog, bodies are pulled on
+ * demand through the `skill` tool. This replaces the earlier self-built
+ * loader — the platform already owns discovery, ranking, and loading.
+ *
+ * Modeled on @deepseek-ai/dsh-skill-badge: provider candidates are listed
+ * from the bundled directory, bodies are read from disk relative to this
+ * module (same ../skills layout from src/ in tests and lib/ at runtime).
+ *
+ * @module @elinpf/dsh-ops-prompts
+ */
+import { type SkillCandidate, type SkillProvider } from '@deepseek-ai/dsh-skill';
+export declare const BUNDLED_SKILLS_PROVIDER = "ops-prompts-bundled";
+/** The bundled skills directory (package root/skills, from src/ or lib/). */
+export declare function bundledSkillsDir(): string;
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    whenToUse?: string;
+    disableModelInvocation: boolean;
+}
+/**
+ * Parse a native skill file's frontmatter. `name` and `description` are
+ * required — a file missing either is not a skill and returns null (the
+ * caller skips it with a warning).
+ */
+export declare function parseSkillFrontmatter(text: string): SkillFrontmatter | null;
+export interface BundledListResult {
+    candidates: SkillCandidate[];
+    /** Files skipped for missing/invalid frontmatter (diagnostics). */
+    skipped: string[];
+}
+/** List valid skill candidates from a directory of `.md` files. */
+export declare function listBundledSkills(dir?: string): Promise<BundledListResult>;
+/** Create the bundled provider over a skills directory (injectable for tests). */
+export declare function createBundledSkillsProvider(dir?: string, warn?: (message: string) => void): SkillProvider;

package/lib/skills.js

@@ -0,0 +1,128 @@
+/**
+ * Bundled ops skills provider.
+ *
+ * Ships the repo-managed ops skills (Markdown files in this package's
+ * `skills/` directory) into dsh's NATIVE skill subsystem: candidates carry
+ * name + description into the model-facing catalog, bodies are pulled on
+ * demand through the `skill` tool. This replaces the earlier self-built
+ * loader — the platform already owns discovery, ranking, and loading.
+ *
+ * Modeled on @deepseek-ai/dsh-skill-badge: provider candidates are listed
+ * from the bundled directory, bodies are read from disk relative to this
+ * module (same ../skills layout from src/ in tests and lib/ at runtime).
+ *
+ * @module @elinpf/dsh-ops-prompts
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { BUNDLED_SKILL_RANK, } from '@deepseek-ai/dsh-skill';
+export const BUNDLED_SKILLS_PROVIDER = 'ops-prompts-bundled';
+const SKILLS_DIR_URL = new URL('../skills/', import.meta.url);
+const INVOCATION = { modelInvocable: true, userInvocable: true };
+/** The bundled skills directory (package root/skills, from src/ or lib/). */
+export function bundledSkillsDir() {
+    return fileURLToPath(SKILLS_DIR_URL);
+}
+/**
+ * Parse a native skill file's frontmatter. `name` and `description` are
+ * required — a file missing either is not a skill and returns null (the
+ * caller skips it with a warning).
+ */
+export function parseSkillFrontmatter(text) {
+    const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+    if (!match)
+        return null;
+    const fields = new Map();
+    for (const line of match[1].split('\n')) {
+        const kv = line.match(/^([\w-]+):\s*(\S[\s\S]*)?$/);
+        if (!kv)
+            continue;
+        fields.set(kv[1], (kv[2] ?? '').trim());
+    }
+    const name = fields.get('name');
+    const description = fields.get('description');
+    if (!name || !description)
+        return null;
+    const parsed = {
+        name,
+        description,
+        disableModelInvocation: fields.get('disable-model-invocation') === 'true',
+    };
+    const whenToUse = fields.get('whenToUse');
+    if (whenToUse)
+        parsed.whenToUse = whenToUse;
+    return parsed;
+}
+/** List valid skill candidates from a directory of `.md` files. */
+export async function listBundledSkills(dir = bundledSkillsDir()) {
+    const candidates = [];
+    const skipped = [];
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch {
+        return { candidates, skipped }; // no bundled dir — nothing to offer
+    }
+    const resourceBase = { kind: 'directory', path: dir };
+    for (const file of files.filter(f => f.endsWith('.md')).sort()) {
+        const path = join(dir, file);
+        let text;
+        try {
+            text = await readFile(path, 'utf8');
+        }
+        catch {
+            skipped.push(path);
+            continue;
+        }
+        const fm = parseSkillFrontmatter(text);
+        if (fm === null) {
+            skipped.push(path);
+            continue;
+        }
+        const candidate = {
+            name: fm.name,
+            description: fm.description,
+            ...fm.whenToUse !== undefined ? { whenToUse: fm.whenToUse } : {},
+            invocation: { ...INVOCATION, modelInvocable: !fm.disableModelInvocation },
+            provider: BUNDLED_SKILLS_PROVIDER,
+            source: 'bundled',
+            resourceBase,
+            rank: BUNDLED_SKILL_RANK,
+            locator: path,
+            path,
+        };
+        candidates.push(candidate);
+    }
+    return { candidates, skipped };
+}
+/** Create the bundled provider over a skills directory (injectable for tests). */
+export function createBundledSkillsProvider(dir = bundledSkillsDir(), warn = () => { }) {
+    return {
+        name: BUNDLED_SKILLS_PROVIDER,
+        async list() {
+            const { candidates, skipped } = await listBundledSkills(dir);
+            if (skipped.length > 0) {
+                // Skips are authoring mistakes in this repo — surface loudly enough
+                // to be fixed, without failing the whole catalog.
+                warn(`ops-prompts bundled skills: skipped ${skipped.join(', ')} (frontmatter requires name and description)`);
+            }
+            return candidates;
+        },
+        async get(candidate) {
+            const path = candidate.locator;
+            return {
+                name: candidate.name,
+                description: candidate.description,
+                ...candidate.whenToUse !== undefined ? { whenToUse: candidate.whenToUse } : {},
+                invocation: candidate.invocation,
+                provider: BUNDLED_SKILLS_PROVIDER,
+                source: 'bundled',
+                resourceBase: candidate.resourceBase,
+                content: await readFile(path, 'utf8'),
+                path,
+            };
+        },
+    };
+}

package/lib/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Type definitions for the ops-prompts plugin.
+ *
+ * @module @elinpf/dsh-ops-prompts
+ */
+export interface Config {
+    /** Whether dynamic reminders are enabled. */
+    reminderEnabled: boolean;
+}
+/** A registered methodology prompt section. */
+export interface MethodologyEntry {
+    name: string;
+    order: number;
+    text: string;
+}
+/** A registered dynamic reminder rule. */
+export interface ReminderEntry {
+    name: string;
+    check: (agent: any) => string | null;
+}
+/** The ops prompt orchestration handle exposed via ctx.get('opsPrompts'). */
+export interface OpsPromptsHandle {
+    /** Register a static methodology prompt section. Returns a disposer. */
+    registerMethodology(opts: MethodologyEntry): () => void;
+    /** Register a dynamic reminder rule evaluated at each agent/pre-step. Returns a disposer. */
+    registerReminder(opts: ReminderEntry): () => void;
+}

package/lib/types.js

@@ -0,0 +1,6 @@
+/**
+ * Type definitions for the ops-prompts plugin.
+ *
+ * @module @elinpf/dsh-ops-prompts
+ */
+export {};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@elinpf/dsh-ops-prompts",
+  "version": "0.1.0",
+  "description": "Ops prompt orchestration center — methodology prompts and dynamic reminders for ops preset.",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types.d.ts",
+      "default": "./lib/types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/skills.js",
+    "lib/types.js",
+    "lib/**/*.d.ts",
+    "skills/",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-skill": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-system-prompt": "^0.0.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-attachment": "0.0.1-rc.5",
+    "@deepseek-ai/dsh-brand": "0.0.1-rc.5",
+    "@deepseek-ai/dsh-invariants": "0.0.1-rc.5",
+    "@deepseek-ai/dsh-scope": "0.0.1-rc.5",
+    "@deepseek-ai/dsh-timeout": "0.0.1-rc.5",
+    "@deepseek-ai/cordis": "4.0.1",
+    "@deepseek-ai/dsh-llm": "0.0.1-rc.5",
+    "@deepseek-ai/dsh-skill": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-system-prompt": "0.0.1-rc.5",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.11"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/skills/change.md

@@ -0,0 +1,89 @@
+---
+name: change
+description: 变更纪律——调查收口后需要 rw 修复时使用的四阶段流程：出方案/验证/人审/执行；验证与执行必须 spawn 干净上下文的子 agent，方案必须五要素齐全。变更是重操作，只能由人用 /change 显式启动。
+whenToUse: trace 调查树收口、需要 rw 权限做修复变更时（人来判断，不由 agent 自动触发）
+disable-model-invocation: true
+---
+
+# 修复变更 — 四阶段纪律
+
+出方案、验证、审核、执行是四种不同的认知活动。混在同一个上下文里会互相污染：验证者被诊断者的确信感传染（确认偏误），执行者被排查中已证伪的错误路径带偏。所以验证和执行必须 spawn 干净上下文的子 agent，绝不在本上下文做。
+
+## 触发条件
+
+- 启动：由人在消息首行输入 `/change` 显式启动——通常是在 trace 调查收口（goal 有定论）且修复需要 rw 权限之后。本 skill 不在模型 catalog 中，agent 不会也无法自动加载它
+- 不启动：只读排查、信息收集、状态确认——这些用 kubectl/environment 工具直接做
+
+## 四阶段 workflow
+
+```
+出方案（本上下文，基于 trace 树）
+  → 验证（spawn 子 agent，干净上下文）
+  → 打回? 回环修订（同一子会话追问，3 次上限）
+  → 人审（人批准方案）
+  → 执行（spawn 子 agent，干净上下文，rw 自己申请）
+```
+
+1. **出方案**：基于 trace 调查树写修复方案——树是现成的压缩诊断产物。方案必须五要素齐全（见下模板），不齐不送验。
+2. **验证**：spawn 子 agent 送验。它静态推演 + ro 查证环境现状（它有 kubectl 等工具），按「通过 / 打回+理由」回答。
+3. **回环**：打回则把验证报告作为发现挂回 trace 树（complete 带 summary），修订后在同一子会话追问再送验。3 次上限，超限停止并升级给人。
+4. **人审+执行**：方案经人批准后，spawn 执行子 agent，prompt 只给已批准的步骤。rw 权限由执行 agent 自己调 request_access 申请。
+
+## 方案模板（五要素）
+
+- **目标**：修完后的可验证状态（不是动作，是状态——"X 恢复调度"而不是"重启了 Y"）
+- **步骤**：逐条原子操作，每条写明对象（集群/namespace/对象名）
+- **预期结果**：每步执行后应该观察到什么
+- **回滚**：每步怎么撤；不可逆的步骤必须显式标注
+- **影响面**：谁会受影响（哪些服务/用户/数据），执行窗口要不要挑
+
+**坏方案**（要素缺失，直接打回）：
+
+> ceph 的 CSI 锁卡死了，重启 pod 解决。
+
+没有目标状态、没有预期结果、没有回滚、没有影响面——"重启 pod"只是动作不是方案。
+
+**好方案**：
+
+> 目标：卡死的 PVC 挂载恢复，工作负载重新 Running。
+> 步骤：1) delete pod `<csi-rbdplugin-xxx>`（kube-system，DaemonSet 会自动重建）；2) 观察新 pod Ready；3) 确认卡死的挂载解除、工作负载恢复 Running。
+> 预期结果：新 csi-rbdplugin pod Running；卡死的 VolumeAttachment 解除；目标 pod 从 ContainerCreating 转 Running。
+> 回滚：delete pod 由 DaemonSet 自愈，无需回滚；若新 pod 起不来，describe 看原因并升级给人。
+> 影响面：该节点上经此 CSI 插件的挂载在重建窗口内短暂不可用；选择业务低峰执行。
+
+## 验证清单（验证 agent 必须逐项检查）
+
+1. **副作用推演**：每个步骤除了预期结果还会动到什么
+2. **回滚可行性**：回滚步骤真的可执行吗；不可逆步骤有没有标注
+3. **前提条件仍成立**：方案依据的诊断结论，环境里还是这样吗（ro 查证）
+4. **影响面核对**：方案声称的影响面和实际环境一致吗（ro 查证）
+5. **环境现状**：涉及的对象现在的状态（用 kubectl ro 查，不要信方案的转述）
+
+## spawn 纪律
+
+- prompt 必须自包含——子 agent 看不到本会话：给完整方案 + 涉及的环境事实（集群/namespace/对象名）
+- 只给方案，不给你的确信度——"我很确定是 X" 会污染验证
+- 修订送验在同一子会话追问，不重新 spawn（验证上下文要保留）
+- prompt 里必须附上汇报契约（见下）——不定格式，子 agent 会灌给你一屏日志
+
+## 汇报契约（子 agent 的回复格式）
+
+子 agent 的回复是你唯一的信息来源。回复必须短而全：
+
+- **≤25 行**：结论（通过 / 打回 / 成功 / 失败）→ 做了什么 → 关键证据 → 未决问题
+- **不贴原始输出**：长输出只留结论 + 可复查的指针（对象名、命名空间、执行的命令），全量输出你自己用 ro 工具去查证
+- **打回理由必须指向具体要素**：哪条回滚不可执行、哪个前提不成立、哪步影响面漏了——"感觉有风险"不接受
+
+完成信号：子 agent 回复结束 = 该任务完成；没回复就是还在跑——等，不要重复 spawn 同一个任务。
+
+## rw 申请纪律
+
+- rw 权限由执行 agent 自己调 request_access 申请，**reason 必须写方案摘要**——人审的是方案，不是裸权限
+- 血缘不用自报：门会自动记录你的父会话，人审能看到你是被谁委派的
+- 申请被拒或超时 = 停止并报告人，不重试不绕行
+
+## 失败模式（真实 session 教训）
+
+- **跳过 milestone 直接收口 goal**：假设没验证完就 resolve——goal 收口必须等假设逐条证实/证伪
+- **link 当 complete 用**：caused_by 只记因果关系，不改变节点状态；证实要 complete 带 summary
+- **把"我希望它对"带进验证环节**：给验证 agent 的方案里夹带倾向性措辞，等于没验证