dsh-advisor-plugin 0.2.1

package/lib/patrol.d.ts

@@ -0,0 +1,51 @@
+/**
+ * patrol —— 巡逻模式：把 advisor 从"被动求助"升级为"主动监控"。
+ *
+ * 工作方式：
+ *   1. agent/request 每步触发（复用现有 waterfall），按间隔步数 + 最小时间
+ *      间隔决定是否发起一次巡逻（不阻塞当前请求，异步执行）；
+ *   2. 巡逻 = 把会话快照 + 巡逻问题发给审查模型，要求回
+ *      ON-TRACK / CORRECTION: ... / STOP: ... 三选一裁决；
+ *   3. 裁决为纠偏/停止时，把干预文本经 `agent.inject()` 以 user 上下文排进
+ *      下一步请求——落在对话尾部（新近性最高，实测系统提示段在几百条工具
+ *      结果的会话里权重不足，执行模型"读到但不动"）；同时把裁决写入会话
+ *      日志（patrol-event.ts，log-only），消息流出 🧭 巡逻卡片（ON-TRACK
+ *      出低调灰卡，unclear 不出）；
+ *   4. 侧调用（巡逻自身 + 显式 advisor() 工具）通过 llm-call 的
+ *      深度计数排除，避免把自己的请求当成执行请求。
+ *
+ * 成本提示：每次巡逻 = 整段会话计费一次审查模型（与显式 advisor()
+ * 相同）。patrolEnabled / patrolEverySteps 可在设置页调整或关闭。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Message } from '@deepseek-ai/dsh-llm';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Config, Selection } from './config.js';
+/** 两次巡逻之间的最小墙钟间隔（防止快速工具链把审查模型打爆） */
+export declare const MIN_PATROL_INTERVAL_MS = 90000;
+/** 巡逻裁决（解析失败归为 unclear——不确定时宁可不打扰执行模型） */
+export type PatrolVerdictKind = 'on-track' | 'correction' | 'stop' | 'unclear';
+export interface PatrolVerdict {
+    kind: PatrolVerdictKind;
+    detail: string;
+}
+/** 是否该发起一次巡逻（纯函数，可单测） */
+export declare function shouldPatrol(input: {
+    armed: boolean;
+    blocked: boolean;
+    step: number;
+    everySteps: number;
+    now: number;
+    lastPatrolMs: number;
+    minIntervalMs: number;
+    inFlight: boolean;
+    patrolEnabled: boolean;
+}): boolean;
+/** 解析审查模型的巡逻裁决（纯函数）：只认首行前缀，其余整段作为细节 */
+export declare function parsePatrolVerdict(text: string): PatrolVerdict;
+export interface PatrolDeps {
+    getConfig: () => Config;
+    getSelection: () => Selection | undefined;
+    buildMessages: (agent: Agent) => Message[];
+}
+export declare function registerPatrol(ctx: Context, deps: PatrolDeps): () => void;

package/lib/patrol.js

@@ -0,0 +1,202 @@
+/**
+ * patrol —— 巡逻模式：把 advisor 从"被动求助"升级为"主动监控"。
+ *
+ * 工作方式：
+ *   1. agent/request 每步触发（复用现有 waterfall），按间隔步数 + 最小时间
+ *      间隔决定是否发起一次巡逻（不阻塞当前请求，异步执行）；
+ *   2. 巡逻 = 把会话快照 + 巡逻问题发给审查模型，要求回
+ *      ON-TRACK / CORRECTION: ... / STOP: ... 三选一裁决；
+ *   3. 裁决为纠偏/停止时，把干预文本经 `agent.inject()` 以 user 上下文排进
+ *      下一步请求——落在对话尾部（新近性最高，实测系统提示段在几百条工具
+ *      结果的会话里权重不足，执行模型"读到但不动"）；同时把裁决写入会话
+ *      日志（patrol-event.ts，log-only），消息流出 🧭 巡逻卡片（ON-TRACK
+ *      出低调灰卡，unclear 不出）；
+ *   4. 侧调用（巡逻自身 + 显式 advisor() 工具）通过 llm-call 的
+ *      深度计数排除，避免把自己的请求当成执行请求。
+ *
+ * 成本提示：每次巡逻 = 整段会话计费一次审查模型（与显式 advisor()
+ * 相同）。patrolEnabled / patrolEverySteps 可在设置页调整或关闭。
+ */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { PATROL_NUDGE, PATROL_SYSTEM_PROMPT, buildInterventionText } from './advisor-prompt.js';
+import { isExecutorBlocked } from './config.js';
+import { callReviewer, stripExecutorEcho } from './llm-call.js';
+import { appendPatrolVerdict } from './patrol-event.js';
+import { createAdviceDeduper, isContentFreeAdvice, normalizeAdvice } from './emission-guard.js';
+/** 两次巡逻之间的最小墙钟间隔（防止快速工具链把审查模型打爆） */
+export const MIN_PATROL_INTERVAL_MS = 90_000;
+/** 是否该发起一次巡逻（纯函数，可单测） */
+export function shouldPatrol(input) {
+    if (!input.patrolEnabled || !input.armed || input.blocked || input.inFlight)
+        return false;
+    if (input.everySteps < 1)
+        return false;
+    if (input.step % input.everySteps !== 0)
+        return false;
+    return input.now - input.lastPatrolMs >= input.minIntervalMs;
+}
+/** 解析审查模型的巡逻裁决（纯函数）：只认首行前缀，其余整段作为细节 */
+export function parsePatrolVerdict(text) {
+    const trimmed = text.trim();
+    if (trimmed === '')
+        return { kind: 'unclear', detail: '' };
+    const firstLineEnd = trimmed.indexOf('\n');
+    const firstLine = (firstLineEnd === -1 ? trimmed : trimmed.slice(0, firstLineEnd)).trim();
+    const rest = firstLineEnd === -1 ? '' : trimmed.slice(firstLineEnd + 1).trim();
+    const upper = firstLine.toUpperCase();
+    if (upper.startsWith('ON-TRACK'))
+        return { kind: 'on-track', detail: rest };
+    if (upper.startsWith('CORRECTION:') || upper.startsWith('CORRECTION')) {
+        const inline = firstLine.slice(firstLine.indexOf(':') + 1).trim();
+        return { kind: 'correction', detail: [inline, rest].filter(s => s !== '').join('\n') };
+    }
+    if (upper.startsWith('STOP:') || upper.startsWith('STOP')) {
+        const inline = firstLine.slice(firstLine.indexOf(':') + 1).trim();
+        return { kind: 'stop', detail: [inline, rest].filter(s => s !== '').join('\n') };
+    }
+    return { kind: 'unclear', detail: trimmed };
+}
+function createUserText(text) {
+    return createUserMessage({ content: [{ type: 'text', text }], source: { kind: 'user' } });
+}
+export function registerPatrol(ctx, deps) {
+    const stepCounts = new Map();
+    /** 每 agent 的建议去重器（防噪闸之一：会话内精确去重） */
+    const dedupers = new Map();
+    /** 每 agent 的纠偏冷却终点（步数）：一次注入后 N 个请求内 concern 降级 */
+    const immuneUntilStep = new Map();
+    let lastPatrolMs = 0;
+    let inFlight = false;
+    const runPatrol = async (agent) => {
+        const selection = deps.getSelection();
+        if (selection === undefined)
+            return;
+        inFlight = true;
+        const startedAt = Date.now();
+        try {
+            // 快照末尾挂巡逻问题（与显式咨询共用消息组装，含工具清单前缀与尾部规则）
+            const messages = [...deps.buildMessages(agent), createUserText(PATROL_NUDGE)];
+            // 调查授权：审查模型可先在工作区内只读核实再裁决（cwd 缺省时不启用）
+            const investigate = deps.getConfig().investigate !== false ? agent.session.header.cwd : undefined;
+            const outcome = await callReviewer(ctx, selection, PATROL_SYSTEM_PROMPT, messages, undefined, investigate, agent.session.id);
+            if (!outcome.ok) {
+                console.log(`[dsh-advisor][patrol] 巡逻调用失败（已跳过本轮）：${outcome.errorMessage}`);
+                return;
+            }
+            const verdict = parsePatrolVerdict(stripExecutorEcho(outcome.text, messages));
+            const elapsed = Math.round(Date.now() - startedAt);
+            if (verdict.kind === 'on-track') {
+                console.log(`[dsh-advisor][patrol] ON-TRACK（${elapsed}ms）——执行方向正常`);
+                // 低调灰卡：on-track 也写事件（用户拍板的完整视野）；写失败不影响巡逻
+                appendPatrolVerdict(agent.session, {
+                    verdict: 'on-track',
+                    detail: verdict.detail,
+                    step: stepCounts.get(agent) ?? 0,
+                    reviewer: `${selection.provider}/${selection.model}`,
+                    patrolMs: elapsed,
+                    usage: outcome.usage,
+                });
+                return;
+            }
+            if (verdict.kind === 'unclear') {
+                // 解析失败不出卡片（不是"检查通过"也不是"需要干预"，只留日志）
+                console.log(`[dsh-advisor][patrol] 裁决不可解析（${elapsed}ms），不打扰执行模型。原文前 200 字：${outcome.text.slice(0, 200)}`);
+                return;
+            }
+            console.log(`[dsh-advisor][patrol] ${verdict.kind === 'stop' ? 'STOP' : 'CORRECTION'}（${elapsed}ms）：${verdict.detail.slice(0, 200)}`);
+            // 防噪闸 ①：内容空短语——只给结论不给理由的建议没有信息量，按不打扰处理
+            const normalized = normalizeAdvice(verdict.detail);
+            if (isContentFreeAdvice(normalized)) {
+                console.log(`[dsh-advisor][patrol] 裁决内容空（归一化后无实质信息），不打扰执行模型：${normalized.slice(0, 60)}`);
+                return;
+            }
+            const deduper = dedupers.get(agent) ?? createAdviceDeduper();
+            dedupers.set(agent, deduper);
+            // 冷却降级：一次注入后 N 个请求内，correction 只出卡片不注入（stop 豁免）
+            const step = stepCounts.get(agent) ?? 0;
+            const downgraded = verdict.kind === 'correction' && step < (immuneUntilStep.get(agent) ?? -1);
+            // 人类可观测性通道：裁决写入会话日志，消息流将出现 🧭 卡片（log-only）
+            appendPatrolVerdict(agent.session, {
+                verdict: verdict.kind,
+                detail: verdict.detail,
+                step,
+                reviewer: `${selection.provider}/${selection.model}`,
+                patrolMs: elapsed,
+                usage: outcome.usage,
+                ...(downgraded ? { downgraded: true } : {}),
+            });
+            console.log('[dsh-advisor][patrol] 裁决已写入会话事件');
+            // 防噪闸 ②：会话内精确去重——与已注入过的建议重复则丢弃（只记日志）
+            if (!downgraded && !deduper(normalized)) {
+                console.log('[dsh-advisor][patrol] 与此前已注入的纠偏重复，丢弃本次注入');
+                return;
+            }
+            if (downgraded) {
+                console.log(`[dsh-advisor][patrol] 纠偏冷却期内（第 ${step} 步 < ${immuneUntilStep.get(agent)}），本次只出卡片不注入`);
+                return;
+            }
+            // 模型面投递：agent.inject() 把干预排成下一步请求的尾部 user 上下文。
+            // 实测教训：系统提示动态段在几百条工具结果的会话里新近性不足，执行
+            // 模型"读到但不动"；尾部上下文是文件变更通知/skill 内容同款官方通道，
+            // 位置就是模型注意力最集中的对话末尾，且 UI 会渲染成上下文行。
+            try {
+                const immuneTurns = deps.getConfig().patrolImmuneTurns ?? 3;
+                if (verdict.kind === 'correction' && immuneTurns > 0) {
+                    immuneUntilStep.set(agent, step + immuneTurns);
+                }
+                agent.inject(createUserMessage({
+                    content: [{ type: 'text', text: buildInterventionText(verdict.kind, verdict.detail) }],
+                    source: {
+                        kind: 'plugin',
+                        plugin: 'dsh-advisor',
+                        form: 'notice',
+                        summary: `${verdict.kind === 'stop' ? '巡逻叫停' : '巡逻纠偏'}：${verdict.detail.slice(0, 60)}`,
+                    },
+                }));
+                console.log(`[dsh-advisor][patrol] 已将${verdict.kind === 'stop' ? '停止' : '纠偏'}干预排入下一步请求（尾部上下文）`);
+            }
+            catch (error) {
+                // 注入失败不影响巡逻本身
+                console.warn('[dsh-advisor][patrol] 干预注入失败：', error);
+            }
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+    const disposeRequest = ctx.on('agent/request', async (payload, next) => {
+        const config = await next();
+        try {
+            const agent = payload.agent;
+            const step = (stepCounts.get(agent) ?? 0) + 1;
+            stepCounts.set(agent, step);
+            const pluginConfig = deps.getConfig();
+            const blocked = isExecutorBlocked(pluginConfig, config.provider, config.model, config.reasoningEffort);
+            if (!shouldPatrol({
+                armed: deps.getSelection() !== undefined,
+                blocked,
+                step,
+                everySteps: pluginConfig.patrolEverySteps ?? 6,
+                now: Date.now(),
+                lastPatrolMs,
+                minIntervalMs: MIN_PATROL_INTERVAL_MS,
+                inFlight,
+                patrolEnabled: pluginConfig.patrolEnabled !== false,
+            }))
+                return config;
+            lastPatrolMs = Date.now();
+            void runPatrol(agent);
+        }
+        catch (error) {
+            // 巡逻绝不破坏用户的 turn
+            console.error('[dsh-advisor][patrol] 调度失败：', error);
+        }
+        return config;
+    });
+    return () => {
+        disposeRequest();
+        stepCounts.clear();
+        dedupers.clear();
+        immuneUntilStep.clear();
+    };
+}

package/lib/prompt-section.d.ts

@@ -0,0 +1,7 @@
+/**
+ * prompt-section —— 注入系统提示的升级守则段。
+ * 只在已选审查模型时注册——未武装的 advisor 零提示词成本。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Config } from './config.js';
+export declare function registerAdvisorSection(ctx: Context, config: Config): () => void;

package/lib/prompt-section.js

@@ -0,0 +1,16 @@
+/**
+ * prompt-section —— 注入系统提示的升级守则段。
+ * 只在已选审查模型时注册——未武装的 advisor 零提示词成本。
+ */
+import { DEFAULT_GUIDELINES } from './advisor-prompt.js';
+export function registerAdvisorSection(ctx, config) {
+    const guidelines = config.guidelines === undefined || config.guidelines.length === 0
+        ? DEFAULT_GUIDELINES
+        : config.guidelines;
+    const text = ['## Advisor escalation', '', ...guidelines.map(g => `- ${g}`)].join('\n');
+    return ctx.systemPrompt.section({
+        name: 'advisor-guidelines',
+        order: 550,
+        text,
+    });
+}

package/lib/settings.d.ts

@@ -0,0 +1,18 @@
+/**
+ * settings —— 把 'advisor' 命名空间接入 settings 服务（用户层 =
+ * ~/.dsh/settings.yaml 的 advisor: 段；设置页卡片写的也是这一层）。
+ *
+ * 双路径兼容（rc.6 与更新版本宿主）：
+ *   - installSection（较新宿主）：带 setSource/onChange 钩子的注册面
+ *   - settings.register（rc.6）：scope.get() 初读 + scope.watch() 活编辑
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type Config, type Selection } from './config.js';
+export interface SettingsWiring {
+    /** 设置服务状态描述（进 /advisor 命令输出与日志） */
+    info: string;
+}
+export declare function wireSettings(ctx: Context, state: {
+    config: Config;
+    selection: Selection | undefined;
+}, onConfigChange: () => void): SettingsWiring;

package/lib/settings.js

@@ -0,0 +1,50 @@
+/**
+ * settings —— 把 'advisor' 命名空间接入 settings 服务（用户层 =
+ * ~/.dsh/settings.yaml 的 advisor: 段；设置页卡片写的也是这一层）。
+ *
+ * 双路径兼容（rc.6 与更新版本宿主）：
+ *   - installSection（较新宿主）：带 setSource/onChange 钩子的注册面
+ *   - settings.register（rc.6）：scope.get() 初读 + scope.watch() 活编辑
+ */
+import { Config as ConfigSchema, resolveSelection } from './config.js';
+export function wireSettings(ctx, state, onConfigChange) {
+    const settings = ctx.get('settings');
+    if (settings === undefined) {
+        return { info: 'settings 服务不可用——advisor 配置固定为插件组合层' };
+    }
+    if (typeof settings.installSection === 'function') {
+        // 较新宿主：setSource 把"当前值来源"交给设置服务接管
+        let source = () => state.config;
+        settings.installSection(ctx, 'advisor', ConfigSchema, state.config, {
+            setSource: (next) => {
+                source = next;
+            },
+            onChange: () => {
+                state.config = source();
+                state.selection = resolveSelection(state.config);
+                onConfigChange();
+            },
+        });
+        return { info: 'settings.installSection 已接入（advisor 命名空间可在设置页编辑）' };
+    }
+    if (typeof settings.register === 'function') {
+        // rc.6 宿主：scope.get() 读合成值（schema 默认 → base → 用户层），watch 活编辑
+        try {
+            const scope = settings.register('advisor', ConfigSchema, { base: state.config });
+            const resolved = scope.get();
+            state.selection = resolveSelection(resolved);
+            state.config = resolved;
+            onConfigChange();
+            scope.watch(next => {
+                state.config = next;
+                state.selection = resolveSelection(next);
+                onConfigChange();
+            });
+            return { info: `settings.register 已接入（advisor 命名空间，用户层在 ~/.dsh/settings.yaml）` };
+        }
+        catch (error) {
+            return { info: `settings.register 失败：${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    return { info: 'settings 服务形态未知——advisor 配置固定为插件组合层' };
+}

package/lib/tool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * tool —— 零参数 `advisor` 工具（defineTool）。
+ *
+ * execute() 解析当前选择 → 组装审查消息 → 侧调用 → 返回规范值；
+ * 每条失败路径同样返回值（渲染成可读文本），执行模型读到错误说明后
+ * 继续本轮——advisor 挂掉绝不炸掉执行模型的 turn。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type Selection } from './config.js';
+/** 工具结果信封：成功带指导文本，失败带可读错误（渲染层只取文本） */
+export interface AdvisorValue {
+    ok: boolean;
+    advisorModel: string;
+    guidance?: string;
+    effort?: string;
+    finishKind?: string;
+    errorMessage?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+}
+export declare function createAdvisorTool(ctx: Context, getSelection: () => Selection | undefined, buildMessages: (agent: Agent) => import('@deepseek-ai/dsh-llm').Message[], getConfig: () => import('./config.js').Config): import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/tool.js

@@ -0,0 +1,91 @@
+/**
+ * tool —— 零参数 `advisor` 工具（defineTool）。
+ *
+ * execute() 解析当前选择 → 组装审查消息 → 侧调用 → 返回规范值；
+ * 每条失败路径同样返回值（渲染成可读文本），执行模型读到错误说明后
+ * 继续本轮——advisor 挂掉绝不炸掉执行模型的 turn。
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { ADVISOR_SYSTEM_PROMPT, ADVISOR_TOOL_DESCRIPTION, ADVISOR_TOOL_NAME, MSG_NO_AGENT_SCOPE, MSG_NO_MODEL } from './advisor-prompt.js';
+import { selectionLabel } from './config.js';
+import { callReviewer, stripExecutorEcho } from './llm-call.js';
+function renderText(value) {
+    if (!value.ok)
+        return value.errorMessage ?? 'Advisor call failed.';
+    return value.guidance ?? '';
+}
+/** 从工具结果内容块提取纯文本（presentResult 只拿得到渲染后的内容块） */
+function textOfContent(content) {
+    return content
+        .filter((block) => block.type === 'text')
+        .map(block => block.text)
+        .join('\n')
+        .trim();
+}
+export function createAdvisorTool(ctx, getSelection, buildMessages, getConfig) {
+    return defineTool({
+        name: ADVISOR_TOOL_NAME,
+        description: ADVISOR_TOOL_DESCRIPTION,
+        parameters: {},
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ok: { type: 'boolean' },
+                    advisorModel: { type: 'string' },
+                    guidance: { type: 'string' },
+                    effort: { type: 'string' },
+                    finishKind: { type: 'string' },
+                    errorMessage: { type: 'string' },
+                    inputTokens: { type: 'number' },
+                    outputTokens: { type: 'number' },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderText(value) }],
+        },
+        // 专属卡片：调用中/结果两态都有 🧭 标识，结果卡片正文就是审查建议，
+        // 用户在消息列表展开即见"真的调了 advisor、建议是什么"
+        presentCall: () => ({ card: 'generic', title: '🧭 Advisor 咨询中…' }),
+        presentResult: (_args, result) => {
+            const text = textOfContent(result.content);
+            return {
+                card: 'generic',
+                title: result.isError ? '🧭 Advisor 调用失败' : '🧭 Advisor 建议',
+                ...(text === '' ? {} : { content: [{ type: 'text', text }] }),
+            };
+        },
+        async execute(_args, exec) {
+            const selection = getSelection();
+            if (selection === undefined) {
+                return { ok: false, advisorModel: '(not configured)', errorMessage: MSG_NO_MODEL };
+            }
+            if (exec.agent === undefined) {
+                return { ok: false, advisorModel: selectionLabel(selection), errorMessage: MSG_NO_AGENT_SCOPE };
+            }
+            const messages = buildMessages(exec.agent);
+            // 调查授权与巡逻一致：审查模型可先只读核实再给建议
+            const investigate = getConfig().investigate !== false ? exec.agent.session.header.cwd : undefined;
+            const outcome = await callReviewer(ctx, selection, ADVISOR_SYSTEM_PROMPT, messages, exec.signal, investigate, exec.agent.session.id);
+            if (!outcome.ok) {
+                return {
+                    ok: false,
+                    advisorModel: selectionLabel(selection),
+                    ...(selection.effort === undefined ? {} : { effort: selection.effort }),
+                    errorMessage: outcome.errorMessage,
+                };
+            }
+            return {
+                ok: true,
+                advisorModel: selectionLabel(selection),
+                // 剥掉审查模型对执行模型"最后一句话"的回显（网关实测行为）
+                guidance: stripExecutorEcho(outcome.text, messages),
+                ...(selection.effort === undefined ? {} : { effort: selection.effort }),
+                finishKind: outcome.finishKind,
+                ...(outcome.usage === undefined
+                    ? {}
+                    : { inputTokens: outcome.usage.inputTokens, outputTokens: outcome.usage.outputTokens }),
+            };
+        },
+    });
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "dsh-advisor-plugin",
+  "version": "0.2.1",
+  "description": "DeepSeek Harness advisor plugin: pair a fast executor with a stronger reviewer model for plan / correction / stop guidance.",
+  "type": "module",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/client/index.d.ts",
+      "default": "./lib/client/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-cordis"
+      ],
+      "platform": "web"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "files": [
+    "src",
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leeyoung1/dsh-advisor-plugin.git"
+  },
+  "homepage": "https://github.com/leeyoung1/dsh-advisor-plugin",
+  "bugs": {
+    "url": "https://github.com/leeyoung1/dsh-advisor-plugin/issues"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "advisor",
+    "agent",
+    "reviewer",
+    "coding-agent"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "*",
+    "@deepseek-ai/dsh-agent": "*",
+    "@deepseek-ai/dsh-commands": "*",
+    "@deepseek-ai/dsh-llm": "*",
+    "@deepseek-ai/dsh-session": "*",
+    "@deepseek-ai/dsh-settings": "*",
+    "@deepseek-ai/dsh-system-prompt": "*",
+    "@deepseek-ai/dsh-tools": "*",
+    "@deepseek-ai/schemastery": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "~18.3.1",
+    "esbuild": "^0.28.2",
+    "react": "^18.2.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/build-client.mjs",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  }
+}

package/src/advisor-prompt.ts

@@ -0,0 +1,102 @@
+/**
+ * advisor-prompt —— 插件全部固定文案与提示词常量（纯声明，无逻辑）。
+ *
+ * 面向模型的文本用英文（模型侧语义稳定），面向用户的日志用中文。
+ * 三个提示词共同构成 advisor 策略模式契约：审查模型三选一回文、
+ * 执行模型按守则升级、尾部 nudge 保证 user 结尾。
+ */
+
+export const ADVISOR_TOOL_NAME = 'advisor'
+
+/** 发给审查模型的系统提示词：plan / correction / stop signal 三选一契约 */
+export const ADVISOR_SYSTEM_PROMPT = [
+  'You are an advisor model in an advisor-strategy pattern.',
+  'An executor model is running a task end-to-end — calling tools, reading',
+  'results, iterating toward a solution. When the executor hits a decision it',
+  'cannot reasonably solve alone, it consults you for guidance. The executor\'s',
+  'full tool inventory is prepended before the conversation so you can judge',
+  'tool-choice correctness.',
+  '',
+  'You read the shared conversation context and return ONE of:',
+  '- a plan (concrete next steps the executor should take),',
+  '- a correction (the executor is going down a wrong path — redirect it),',
+  '- a stop signal (the executor should halt and escalate to the user).',
+  '',
+  'You NEVER call tools. You NEVER produce user-facing output. Be concise,',
+  'directive, and grounded in the shared context. Name files, functions, and',
+  'line numbers where possible. No preamble, no apologies, no meta-commentary',
+  '— just the guidance the executor needs.',
+].join('\n')
+
+/** 零参数工具 description —— 执行模型判断"何时升级"的主要依据 */
+export const ADVISOR_TOOL_DESCRIPTION = [
+  'Escalate to a stronger reviewer model for guidance. When you need',
+  'stronger judgment — a complex decision, an ambiguous failure, a problem',
+  "you're circling without progress — escalate to the advisor model for",
+  'guidance, then resume. Takes NO parameters — when you call advisor(),',
+  'your entire conversation history (task, every tool call, every result)',
+  'is automatically forwarded. When to call:',
+  '(1) BEFORE substantive work — before writing, before committing to an',
+  'interpretation, before building on an assumption;',
+  '(2) BEFORE declaring done — and make your deliverable durable first;',
+  '(3) when stuck — recurring errors, approach not converging;',
+  '(4) when your evidence contradicts previous advice, reconcile in one',
+  'more call instead of silently switching.',
+  'After each advisor result, restate its key guidance (plan / correction',
+  '/ stop signal) in your next visible reply to the user before continuing.',
+].join(' ')
+
+/** 注入系统提示的升级守则（未配置审查模型时不注册，零提示词成本） */
+export const DEFAULT_GUIDELINES: readonly string[] = [
+  'Call `advisor` BEFORE substantive work — before writing, before committing to an interpretation, before building on an assumption. Orientation (finding files, fetching a source, seeing what is there) is not substantive work; writing, editing, and declaring an answer are.',
+  'Also call `advisor` when you believe the task is complete. BEFORE this call, make your deliverable durable: write the file, save the result, commit the change. The advisor call takes time; if the session ends during it, a durable result persists and an unwritten one does not.',
+  'Also call `advisor` when stuck — errors recurring, approach not converging, results that do not fit — or when considering a change of approach.',
+  'On tasks longer than a few steps, call `advisor` at least once before committing to an approach and once before declaring done. On short reactive tasks where the next action is dictated by tool output you just read, you don\'t need to keep calling.',
+  'Give the advisor\'s advice serious weight. If you follow a step and it fails empirically, or you have primary-source evidence that contradicts a specific claim, adapt — a passing self-test is not evidence the advice is wrong.',
+  'If you\'ve already retrieved data pointing one way and the advisor points another, don\'t silently switch — surface the conflict in one more `advisor` call. A reconcile call is cheaper than committing to the wrong branch.',
+  'After each `advisor` result, put the advisor\'s key guidance into your next visible reply to the user before continuing — quote or paraphrase the plan, correction, or stop signal. The user often cannot see collapsed tool results.',
+]
+
+/** 尾部 nudge：部分 provider 拒绝 assistant 结尾的载荷 */
+export const MSG_USER_TAIL_NUDGE = 'Please advise on the executor\'s situation above.'
+
+/**
+ * 巡逻模式系统提示：审查模型对执行过程做中段检查，回三选一裁决。
+ * 首行前缀是机器可解析契约（patrol.parsePatrolVerdict），细节跟在后面。
+ */
+export const PATROL_SYSTEM_PROMPT = [
+  'You are the advisor model running a PATROL check on an executor model mid-task.',
+  'You see the executor\'s tool inventory and its conversation so far.',
+  'Reply with EXACTLY one verdict on the first line, detail after it if applicable:',
+  '- "ON-TRACK" — the executor is progressing correctly; reply with just this line',
+  '- "CORRECTION: <one-paragraph redirect>" — the executor has drifted; state what is wrong and the concrete next step',
+  '- "STOP: <reason>" — the executor should halt and report to the user',
+  'Flag only substantive drift: wrong files or approach, hallucinated progress,',
+  'destructive operations, violating the user\'s constraints, or the task already',
+  'being satisfied while the executor keeps working. Do not nitpick style.',
+].join('\n')
+
+/** 巡逻问题（挂在快照尾部，随整段会话发给审查模型） */
+export const PATROL_NUDGE = 'Patrol check: is the executor still on track for the user\'s task? Reply per the patrol contract.'
+
+/** 把巡逻裁决转成注入执行模型的干预文本（llm/stream 尾部 user 消息） */
+export function buildInterventionText(kind: 'correction' | 'stop', detail: string): string {
+  if (kind === 'stop') {
+    return [
+      '[advisor patrol] STOP signal from the reviewer model that monitors this execution:',
+      detail,
+      'Halt the current approach immediately and report the situation to the user.',
+    ].join('\n')
+  }
+  return [
+    '[advisor patrol] The reviewer model monitoring this execution flagged a drift. Its correction:',
+    detail,
+    'Adjust your approach now. Briefly acknowledge this correction in your next visible reply, then continue.',
+  ].join('\n')
+}
+
+/** 用户可见文案（中文） */
+export const MSG_NO_MODEL =
+  '未配置 advisor 审查模型——在设置 → 插件里选择一个审查模型（或 /advisor 查看可用路由）。'
+export const MSG_NO_AGENT_SCOPE =
+  'advisor 无法访问当前会话（未拿到 agent 上下文）——请从会话内调用。'