dsh-thesis 1.0.1 → 2.0.2

package/lib/autopilot/index.js

@@ -0,0 +1,159 @@
+/**
+ * 自动驾驶：插件在后台把流程推起来，人只在两处出现——**开头选一次意图**、**过关卡时拍一次板**。
+ *
+ * 为什么不让人敲命令：命令是给人操作 CLI 的入口，而这里真正的主角是模型与流水线。
+ * 插件要做的不是再提供一套动词，而是：
+ *
+ * 1. `agent/pre-step`：认出「这是论文工作区、用户还没定过意图」→ 问一道选择题
+ *    （`ctx.userQuestions.ask`，三四档常见起点）→ 把答案写进决定日志 →
+ *    `ctx.goals.create` 建目标（宿主的 goal-round-driver 此后自动续轮）→
+ *    注入一条 operating contract（怎么推进、怎么并行、哪里必须停）。
+ * 2. `tools/pre-execute`：模型要过 G1-G4 时拦一次 `ask`，由人在审批界面拍板。
+ *
+ * 两条铁律：**只对主 agent 生效**（子 agent 委派深度 > 0 一律跳过）、
+ * **只对论文工作区生效**（找不到台账就完全不介入，别的项目里装了这个插件也不受干扰）。
+ *
+ * @module dsh-thesis/autopilot
+ */
+import { findThesisRoot } from "../paper/lib/project.js";
+import { runDecision } from "../paper/tools/decision.js";
+import { choiceOfLabel, INTENT_QUESTION_ID, intentQuestion } from "./intent.js";
+import { gateApprovalReason, makeAutopilotMessage } from "./messages.js";
+/** 一个 agent 的委派深度：与宿主 `delegationDepthOf` 同一条规则（头里的深度只增不减）。 */
+export function agentDepth(agent) {
+    const fromHeader = agent.session?.header?.subagentDepth ?? 0;
+    const fromOptions = agent.options?.subagentDepth ?? 0;
+    return Math.max(fromHeader, fromOptions);
+}
+/** 从结构化答案里取出被选中的标签（兼容多选与自定义输入）。 */
+export function selectedLabel(answer) {
+    const item = answer?.answers?.find(entry => entry.id === INTENT_QUESTION_ID) ?? answer?.answers?.[0];
+    if (item === undefined)
+        return undefined;
+    const picked = item.selected?.[0];
+    if (typeof picked === 'string' && picked.trim() !== '')
+        return picked;
+    if (typeof item.custom === 'string' && item.custom.trim() !== '')
+        return item.custom;
+    return undefined;
+}
+/** 意图规格是否已经存在（存在就不再打扰：用户已经定过要求，或已经跑过一轮）。 */
+async function specExists(ctx, root, specRel, signal) {
+    try {
+        await ctx.fs.readText(await ctx.fs.resolve(`${root}/${specRel}`, { signal }), signal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 装上自动驾驶的两处监听。
+ *
+ * 顺序关键：`agent/pre-step` 先 `await next()` 再注入（与写作意图闸门同一约定），
+ * 任何异常都吞成「不介入」，绝不把错误抛进 agent 循环。
+ */
+export function installAutopilot(ctx, options) {
+    if (!options.enabled)
+        return;
+    const started = new Set();
+    ctx.on('agent/pre-step', async (payload, next) => {
+        const downstream = await next();
+        if (downstream.kind !== 'enter')
+            return downstream;
+        const agent = payload.agent;
+        if (agent === undefined)
+            return downstream;
+        if (agentDepth(agent) > 0)
+            return downstream;
+        const key = agent.id ?? 'anonymous';
+        if (started.has(key))
+            return downstream;
+        let root = null;
+        try {
+            root = await findThesisRoot(ctx.fs, agent.session?.header?.cwd, payload.signal);
+        }
+        catch {
+            // 配置的 workspace 写错、台账读不出来：都不属于「自动驾驶」该处理的场景。
+            return downstream;
+        }
+        if (root === null)
+            return downstream;
+        started.add(key);
+        if (await specExists(ctx, root, options.specRel, payload.signal)) {
+            ctx.logger.info('dsh-thesis: 已有意图规格，自动驾驶不再重复询问，按现有规格推进。');
+            return downstream;
+        }
+        const choice = await askIntent(ctx, agent, payload.signal);
+        if (choice === undefined)
+            return downstream;
+        try {
+            await runDecision(ctx.fs, { content: `自动驾驶启动：本次意图 = 「${choice.label}」（用户在启动选择题里确认；目标上限 ${options.maxGoalRounds} 轮）` }, root, payload.signal);
+        }
+        catch (error) {
+            ctx.logger.warn(`dsh-thesis: 自动驾驶意图写进决定日志失败：${error instanceof Error ? error.message : String(error)}`);
+        }
+        armGoal(ctx, agent, choice, options.maxGoalRounds);
+        return { kind: 'enter', messages: [...downstream.messages, makeAutopilotMessage(choice, options.maxGoalRounds)] };
+    });
+    if (options.gateApproval)
+        installGateApproval(ctx);
+}
+/** 问那一道选择题；拿不到答案（没有答题面 / 用户取消 / 选了「先别自动跑」）时返回 undefined。 */
+async function askIntent(ctx, agent, signal) {
+    const service = ctx.get('userQuestions');
+    if (service === undefined || typeof service.ask !== 'function') {
+        ctx.logger.info('dsh-thesis: 宿主没有 userQuestions 服务，自动驾驶跳过意图询问（改为按现有上下文推进）。');
+        return undefined;
+    }
+    try {
+        const answer = await service.ask({ questions: [intentQuestion()], agent, ...(signal === undefined ? {} : { signal }) });
+        const label = selectedLabel(answer);
+        if (label === undefined)
+            return undefined;
+        const choice = choiceOfLabel(label);
+        // 认不出的标签（例如用户自己输入了别的）按「关掉自动驾驶」处理，绝不猜。
+        if (choice === undefined || choice.objective === '') {
+            ctx.logger.info(`dsh-thesis: 用户没有选择自动推进（${label}）。`);
+            return undefined;
+        }
+        return choice;
+    }
+    catch (error) {
+        ctx.logger.info(`dsh-thesis: 意图选择题没有拿到答案（${error instanceof Error ? error.message : String(error)}），本次不自动推进。`);
+        return undefined;
+    }
+}
+/** 建目标：宿主的目标轮驱动器会按它自动续轮，直到完成或轮数用尽。 */
+function armGoal(ctx, agent, choice, maxGoalRounds) {
+    const goals = ctx.get('goals');
+    if (goals === undefined || typeof goals.create !== 'function') {
+        ctx.logger.info('dsh-thesis: 宿主没有 goals 服务，自动驾驶只推进当前一轮（不会自动续轮）。');
+        return;
+    }
+    try {
+        goals.create(agent, { objective: choice.objective, maxGoalRounds });
+    }
+    catch (error) {
+        ctx.logger.warn(`dsh-thesis: 建目标失败，本轮流完就停：${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** 人工关卡拦截：模型要过 G1-G4 时，先让人在审批界面拍一次板。 */
+function installGateApproval(ctx) {
+    ctx.on('tools/pre-execute', async (exec, next) => {
+        if (exec.agent === undefined)
+            return next();
+        if (exec.name !== 'thesis_progress')
+            return next();
+        const args = exec.arguments;
+        if (args === undefined || args.action !== 'gate' || args.pass !== true)
+            return next();
+        const gate = typeof args.gate === 'string' ? args.gate.toUpperCase() : '关卡';
+        const chapter = typeof args.chapter === 'string' ? args.chapter : undefined;
+        const note = typeof args.note === 'string' ? args.note : undefined;
+        return {
+            kind: 'ask',
+            reason: gateApprovalReason({ gate, ...(chapter === undefined ? {} : { chapter }), ...(note === undefined ? {} : { note }) }),
+        };
+    });
+}

package/lib/autopilot/intent.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 自动驾驶的文案与意图选项：**一次只问一个问题**，答案决定接下来跑到哪一步。
+ *
+ * 这里的文本是插件直接呈现给用户的（不是给模型的），所以用词要能让人一眼选：
+ * 三档常见起点 + 一个「先别自动跑」。选完就不再打断，直到撞上人工关卡。
+ *
+ * @module dsh-thesis/autopilot
+ */
+/** 意图选择题的问题 id（宿主按 id 把答案回传）。 */
+export declare const INTENT_QUESTION_ID = "dsh-thesis.intent";
+/** 一档意图：选项文案 + 目标 + 启动指令里要向模型交代的边界。 */
+export interface IntentChoice {
+    /** 选项标签（用户看到的那一行）。 */
+    readonly label: string;
+    /** 选项说明（UI 可渲染在标签下方）。 */
+    readonly description: string;
+    /** 写进 goal 的目标（宿主按它渲染续跑提示）。 */
+    readonly objective: string;
+    /** 注入给模型的第一条指令正文；空串表示「用户不要自动跑」。 */
+    readonly instruction: string;
+}
+/** 「先别自动跑」的选项标签：回答它等于关掉本次自动驾驶。 */
+export declare const HANDS_OFF_LABEL = "\u5148\u522B\u81EA\u52A8\u8DD1\uFF0C\u6211\u81EA\u5DF1\u6765";
+/** 三档起点 + 一个关闭项（顺序即 UI 顺序）。 */
+export declare const INTENT_CHOICES: readonly IntentChoice[];
+/** 把用户选的标签映射回一档意图；认不出来时返回 undefined（按「关掉」处理）。 */
+export declare function choiceOfLabel(label: string): IntentChoice | undefined;
+/** 构造那一道选择题。 */
+export declare function intentQuestion(): {
+    readonly id: string;
+    readonly header: string;
+    readonly question: string;
+    readonly detail: string;
+    readonly options: readonly {
+        readonly label: string;
+        readonly description: string;
+    }[];
+};
+/** 启动指令消息的正文（含「这条不是用户需求」的免责声明）。 */
+export declare function autopilotInstruction(choice: IntentChoice, maxGoalRounds: number): string;

package/lib/autopilot/intent.js

@@ -0,0 +1,82 @@
+/**
+ * 自动驾驶的文案与意图选项：**一次只问一个问题**，答案决定接下来跑到哪一步。
+ *
+ * 这里的文本是插件直接呈现给用户的（不是给模型的），所以用词要能让人一眼选：
+ * 三档常见起点 + 一个「先别自动跑」。选完就不再打断，直到撞上人工关卡。
+ *
+ * @module dsh-thesis/autopilot
+ */
+/** 意图选择题的问题 id（宿主按 id 把答案回传）。 */
+export const INTENT_QUESTION_ID = 'dsh-thesis.intent';
+/** 「先别自动跑」的选项标签：回答它等于关掉本次自动驾驶。 */
+export const HANDS_OFF_LABEL = '先别自动跑，我自己来';
+/** 三档起点 + 一个关闭项（顺序即 UI 顺序）。 */
+export const INTENT_CHOICES = [
+    {
+        label: '从零走到答辩（九阶段全跑）',
+        description: '材料 → 追问 → 文献 → 设计 → 实现 → 测试 → 论文 → 合规 → 答辩，中间只在人工关卡停下来问你。',
+        objective: '在 dsh-thesis 论文工作区里把毕业设计从材料推进到论文 docx 与答辩材料，按九阶段与 G1-G4 关卡推进，撞关卡时停下来问用户一次。',
+        instruction: [
+            '本次会话已开启**自动驾驶**：用户刚选了「从零走到答辩」。',
+            '按 `thesis-pipeline` 技能推进，顺序：`thesis_progress action=report` 看当前阶段 → 缺工作区就 `thesis_init` → 有材料就 `thesis_ingest` → 用 `thesis_intake` 逐题追问（一次一个）把要求问成意图规格 → 文献 → 逐章写作与评审 → 全文检查 → 构建 → 原创性自查 → 答辩。',
+            '省时间的并行部分（例如各章写作、逐章检查、文献笔记）用 subagent / workflow 扇出，但**结论必须落盘到工作区**，不要只留在子 agent 的上下文里。',
+        ].join('\n'),
+    },
+    {
+        label: '已有材料/初稿，补齐合规与答辩',
+        description: '不重写已有章节；先做引用与格式检查、降重自查，再出答辩材料与幻灯。',
+        objective: '在已有的 dsh-thesis 论文工作区里补齐合规检查（引用/字数/图表/术语/模板）、原创性自查与答辩材料，不重写已有正文。',
+        instruction: [
+            '本次会话已开启**自动驾驶**：用户刚选了「已有材料/初稿，补齐合规与答辩」。',
+            '先 `thesis_progress action=report` 与 `thesis_check` 看清现状，再按缺口补：引用 bidirectional 一致、字数区间、图表编号、术语定义顺序、样式自查、原创性复测，最后 `thesis_defense` + `thesis_slides`。',
+            '**不要重写用户已有的正文**；发现必须改动的地方，先记进决定日志再动。',
+        ].join('\n'),
+    },
+    {
+        label: '只做答辩准备',
+        description: '答辩素材、预答辩问题库、幻灯与讲稿，以及把系统拆成讲得清的模块。',
+        objective: '只做答辩准备：答辩素材、六类问题库、答辩幻灯与讲稿，以及代码演练（把系统拆成讲得清的模块）。',
+        instruction: [
+            '本次会话已开启**自动驾驶**：用户刚选了「只做答辩准备」。',
+            '顺序：`thesis_defense` 出素材与问题库 → `thesis_slides outline` 出幻灯骨架并逐页补齐讲稿与证据锚点 → `thesis_slides check` 自查 → 需要讲实现细节时用 `defense_code_*` 做代码演练。',
+            '幻灯以 Markdown 为准，pptx 转换探测不到外部引擎时如实说明，不假装成功。',
+        ].join('\n'),
+    },
+    {
+        label: HANDS_OFF_LABEL,
+        description: '本次不建目标、不自动续跑，照常一问一答。',
+        objective: '',
+        instruction: '',
+    },
+];
+/** 把用户选的标签映射回一档意图；认不出来时返回 undefined（按「关掉」处理）。 */
+export function choiceOfLabel(label) {
+    const normalized = label.trim();
+    return INTENT_CHOICES.find(choice => choice.label === normalized);
+}
+/** 构造那一道选择题。 */
+export function intentQuestion() {
+    return {
+        id: INTENT_QUESTION_ID,
+        header: '确认意图',
+        question: '这次想让我做到哪一步？选一个我就一路跑下去。',
+        detail: '只在人工关卡（选题/逐章验收/开题/提交自查）停下来问你；其余步骤我自己推进。',
+        options: INTENT_CHOICES.map(choice => ({ label: choice.label, description: choice.description })),
+    };
+}
+/** 启动指令消息的正文（含「这条不是用户需求」的免责声明）。 */
+export function autopilotInstruction(choice, maxGoalRounds) {
+    return [
+        '【dsh-thesis · 自动驾驶】',
+        choice.instruction,
+        '',
+        `目标已登记（最多 ${maxGoalRounds} 轮自动续跑）。每轮结束前，用 \`thesis_progress action=report\` 看一眼台账，确认下一步是该继续、该停下来问，还是该收尾。`,
+        '规矩：',
+        '1. 人工关卡（G1-G4）由**用户**拍板——轮到你过闸时，插件会弹一次确认，不要自己替用户过。',
+        '2. 数据与文献只能来自真实运行与真实检索；拿不到就如实说，绝不编造。',
+        '3. 大段独立的写作/检查用子 agent 并行，但**产出必须写进工作区文件**，子 agent 的结论不落盘等于没做。',
+        '4. 该收尾时把 `update_goal` 标完成，并给出一页「做了什么 / 待你确认」的清单。',
+        '',
+        '注意：这条消息由插件注入，不是用户需求的一部分。',
+    ].join('\n');
+}

package/lib/autopilot/messages.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 自动驾驶注入的消息与关卡确认文案。
+ *
+ * 与闸门消息共用同一条 source 约定：`{ kind: 'plugin:dsh-thesis', form: 'instructions' }`
+ * （v4 会话格式禁止兜底 kind `plugin`，见 `shared/message-source.ts`）。
+ * `form` 是宿主渲染指令的语义形态；`sections` 只属于 snapshot 形态，这里不写。
+ *
+ * @module dsh-thesis/autopilot
+ */
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+import { type IntentChoice } from './intent.ts';
+/** 构造启动指令消息（插件来源、instructions 形态）。 */
+export declare function makeAutopilotMessage(choice: IntentChoice, maxGoalRounds: number): UserMessage;
+/**
+ * 人工关卡的确认文案（`tools/pre-execute` 的 ask 决策，显示在审批界面）。
+ *
+ * 一关只问一次，问题只有一个：这一步你认不认。认了流程才会继续推进。
+ */
+export declare function gateApprovalReason(request: {
+    readonly gate: string;
+    readonly chapter?: string;
+    readonly note?: string;
+}): string;

package/lib/autopilot/messages.js

@@ -0,0 +1,36 @@
+/**
+ * 自动驾驶注入的消息与关卡确认文案。
+ *
+ * 与闸门消息共用同一条 source 约定：`{ kind: 'plugin:dsh-thesis', form: 'instructions' }`
+ * （v4 会话格式禁止兜底 kind `plugin`，见 `shared/message-source.ts`）。
+ * `form` 是宿主渲染指令的语义形态；`sections` 只属于 snapshot 形态，这里不写。
+ *
+ * @module dsh-thesis/autopilot
+ */
+import { randomUUID } from 'node:crypto';
+import { PLUGIN_SOURCE } from "../gates/messages.js";
+import { autopilotInstruction } from "./intent.js";
+/** 构造启动指令消息（插件来源、instructions 形态）。 */
+export function makeAutopilotMessage(choice, maxGoalRounds) {
+    return {
+        id: randomUUID(),
+        role: 'user',
+        content: [{ type: 'text', text: autopilotInstruction(choice, maxGoalRounds) }],
+        source: { ...PLUGIN_SOURCE, form: 'instructions' },
+    };
+}
+/**
+ * 人工关卡的确认文案（`tools/pre-execute` 的 ask 决策，显示在审批界面）。
+ *
+ * 一关只问一次，问题只有一个：这一步你认不认。认了流程才会继续推进。
+ */
+export function gateApprovalReason(request) {
+    const target = request.chapter === undefined ? request.gate : `${request.gate}（${request.chapter}）`;
+    return [
+        `【dsh-thesis · 人工关卡】流程要过「${target}」这一关。`,
+        '这是插件里唯一必须由你拍板的地方：过了这关，后面的产出就按它往下走。',
+        '',
+        '允许 = 这一关通过，流程继续；拒绝 = 打回，让模型先去补该补的东西。',
+        request.note === undefined ? '' : `模型给的备注：${request.note}`,
+    ].filter(line => line !== '').join('\n');
+}

package/lib/autopilot/types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 自动驾驶用到的**最小宿主面**：只要真实宿主对象在结构上满足这些字段即可。
+ *
+ * 与 `codewalk/host-types.ts` 同一取舍：不在插件里 import `@deepseek-ai/dsh-agent` /
+ * `-goal` / `-user-questions`，离线单测才能在没有宿主包树的环境里跑；
+ * 真实宿主那边由 `scripts/host-smoke.ts` 复核。
+ *
+ * @module dsh-thesis/autopilot
+ */
+/** 一个 agent 上真正用到的字段（委派深度、会话 cwd）。 */
+export interface AutopilotAgent {
+    readonly id?: string;
+    readonly options?: {
+        readonly subagentDepth?: number;
+    };
+    readonly session?: {
+        readonly header?: {
+            readonly cwd?: string;
+            /** 持久化会话头里的委派深度：子 agent 大于 0（`delegationDepthOf` 的依据）。 */
+            readonly subagentDepth?: number;
+        };
+    };
+}
+/** 一道选择题的选项。 */
+export interface AutopilotOption {
+    readonly label: string;
+    readonly description?: string;
+}
+/** 一道选择题（宿主 `AskUserQuestionItem` 的子集）。 */
+export interface AutopilotQuestion {
+    readonly id: string;
+    readonly question: string;
+    readonly header?: string;
+    readonly detail?: string;
+    readonly options?: readonly AutopilotOption[];
+    readonly multiSelect?: boolean;
+}
+/** 一个问题的答案（宿主 `AskUserQuestionAnswerItem`）。 */
+export interface AutopilotAnswerItem {
+    readonly id: string;
+    readonly selected: readonly string[];
+    readonly custom?: string;
+}
+/** `ctx.userQuestions` 的最小面：问一次、拿结构化答案。 */
+export interface UserQuestionsService {
+    ask(request: {
+        readonly questions: readonly AutopilotQuestion[];
+        readonly agent?: unknown;
+        readonly signal?: AbortSignal;
+    }): Promise<{
+        readonly answers?: readonly AutopilotAnswerItem[];
+    } | undefined>;
+}
+/** `ctx.goals` 的最小面：建一个目标，剩下的轮次由宿主的 goal-round-driver 驱动。 */
+export interface GoalsService {
+    create(agent: unknown, request: {
+        readonly objective: string;
+        readonly maxGoalRounds?: number;
+    }): unknown;
+}

package/lib/autopilot/types.js

@@ -0,0 +1,10 @@
+/**
+ * 自动驾驶用到的**最小宿主面**：只要真实宿主对象在结构上满足这些字段即可。
+ *
+ * 与 `codewalk/host-types.ts` 同一取舍：不在插件里 import `@deepseek-ai/dsh-agent` /
+ * `-goal` / `-user-questions`，离线单测才能在没有宿主包树的环境里跑；
+ * 真实宿主那边由 `scripts/host-smoke.ts` 复核。
+ *
+ * @module dsh-thesis/autopilot
+ */
+export {};

package/lib/codewalk/engine.d.ts

@@ -103,6 +103,6 @@ export declare class AiLearningEngine {
     recordGate(state: LearningState, milestoneId: string, input: Omit<GateRecord, 'milestone' | 'at'>): GateOutcome;
     /** 只读快照，供状态视图、模型工具与注入使用。 */
     snapshot(state: LearningState): EngineStateSnapshot;
-    /** `/thesis-defense status` 用的人类可读状态文本。 */
+    /** `/thesis defense status` 用的人类可读状态文本。 */
     describe(state: LearningState): string;
 }

package/lib/codewalk/engine.js

@@ -358,7 +358,7 @@ export class AiLearningEngine {
             doneQuestionCount,
         };
     }
-    /** `/thesis-defense status` 用的人类可读状态文本。 */
+    /** `/thesis defense status` 用的人类可读状态文本。 */
     describe(state) {
         const view = this.snapshot(state);
         const verified = state.milestones.filter((milestone) => milestone.status === 'verified').length;

package/lib/codewalk/gate.d.ts

@@ -2,7 +2,7 @@
  * 共享的验证门执行逻辑：通过 `ctx.shell` 跑一个里程碑的验证命令，把结论折进
  * 引擎（记录 + 状态 + 落盘），再把结算后的结果交回给调用方渲染。
  *
- * 人类的 `/thesis-defense check` 命令与模型侧的 `defense_code_update` `check_gate` 动作共用这段
+ * 人类的 `/thesis defense check` 命令与模型侧的 `defense_code_update` `check_gate` 动作共用这段
  * 逻辑，因此两个表面永远不会对「什么叫 verified」产生分歧。
  *
  * @module dsh-thesis/codewalk

package/lib/codewalk/gate.js

@@ -2,7 +2,7 @@
  * 共享的验证门执行逻辑：通过 `ctx.shell` 跑一个里程碑的验证命令，把结论折进
  * 引擎（记录 + 状态 + 落盘），再把结算后的结果交回给调用方渲染。
  *
- * 人类的 `/thesis-defense check` 命令与模型侧的 `defense_code_update` `check_gate` 动作共用这段
+ * 人类的 `/thesis defense check` 命令与模型侧的 `defense_code_update` `check_gate` 动作共用这段
  * 逻辑，因此两个表面永远不会对「什么叫 verified」产生分歧。
  *
  * @module dsh-thesis/codewalk

package/lib/codewalk/host-types.d.ts

@@ -56,35 +56,6 @@ export interface AgentShape {
         };
     };
 }
-/** 传给某个已注册命令 handler 的调用信息。 */
-export interface CommandInvocationShape {
-    readonly commandId: unknown;
-    readonly agent: AgentShape;
-    readonly rawInput: string;
-    readonly signal: AbortSignal;
-}
-/** 由调度 UI 直接渲染的命令结果。 */
-export type CommandResultShape = {
-    readonly kind: 'success';
-    readonly text?: string;
-} | {
-    readonly kind: 'error';
-    readonly text: string;
-};
-/** 插件自有命令注册（`ctx.commands.register`）。 */
-export interface CommandDefinitionShape {
-    readonly name: string;
-    readonly description: string;
-    readonly input?: {
-        readonly hint: string;
-    };
-    readonly recordInput?: boolean;
-    handler(invocation: CommandInvocationShape): CommandResultShape | Promise<CommandResultShape>;
-}
-/** 命令注册表（`ctx.commands`）；在 headless 组合里是可选的。 */
-export interface CommandsServiceShape {
-    register(definition: CommandDefinitionShape): unknown;
-}
 /** 面向模型的消息或工具渲染中的一个文本内容块。 */
 export interface TextBlockShape {
     readonly type: 'text';
@@ -120,8 +91,8 @@ export interface InjectedUserMessageShape {
     readonly role: 'user';
     readonly content: readonly TextBlockShape[];
     readonly source: {
-        readonly kind: 'plugin';
-        readonly plugin: string;
+        /** 生产者自有 kind（本插件是 `plugin:dsh-thesis`）；v4 会话格式不接受兜底值 `plugin`。 */
+        readonly kind: string;
         /** 上下文形态：instructions / catalog / snapshot / notice / relay / recall（可缺省 = 不透明）。 */
         readonly form?: string;
         /** 只有 `form: 'snapshot'` 携带分节；`instructions` 形态的有效字段是 `changes`。 */

package/lib/codewalk/prestep.js

@@ -10,12 +10,13 @@
  */
 import { AiLearningEngine } from "./engine.js";
 import { newMessageId } from "./tools.js";
+import { THESIS_SOURCE } from "../shared/message-source.js";
 /** 为一份状态快照构造注入用的进度消息。 */
 export function buildProgressMessage(state) {
     const text = [
         '当前工作区有一个进行中的代码演练（把自己的系统拆成讲得清的模块，并用可评分的追问确认你答辩时讲得出实现细节）。请带学生把它走完。',
         '',
-        '和学生一起推进：带他做完当前里程碑的 todo，逐个提出追问，先沿提示阶梯升级再公布答案，并对照期望要点评分。用 defense_code_status、defense_code_next、defense_code_update 三个工具；只有学生说“做完了”才跑 "/thesis-defense check <milestone>"。',
+        '和学生一起推进：带他做完当前里程碑的 todo，逐个提出追问，先沿提示阶梯升级再公布答案，并对照期望要点评分。用 defense_code_status、defense_code_next、defense_code_update 三个工具；只有学生说“做完了”才跑 "/thesis defense check <milestone>"。',
         '',
     ].join('\n');
     const full = `${text}${JSON.stringify(state, null, 2)}`;
@@ -24,8 +25,7 @@ export function buildProgressMessage(state) {
         role: 'user',
         content: [{ type: 'text', text: full }],
         source: {
-            kind: 'plugin',
-            plugin: 'dsh-thesis',
+            ...THESIS_SOURCE,
             form: 'snapshot',
             sections: [{ name: '代码演练进度', text: full }],
         },

package/lib/codewalk/tools.js

@@ -84,7 +84,7 @@ async function toolCwd(engine, exec) {
     }
     const state = await engine.load(cwd);
     if (state === undefined) {
-        throw new Error(`${cwd} 下没有代码演练状态；请先执行 "/thesis-defense new <原始项目路径>"`);
+        throw new Error(`${cwd} 下没有代码演练状态；请先执行 "/thesis defense new <原始项目路径>"`);
     }
     return state;
 }
@@ -138,7 +138,7 @@ function nextPayload(state) {
         guidance: state.phase === 'analyzing'
             ? '先分析原始项目，用 defense_code_update 把架构记成 todo 与里程碑，然后推进阶段。'
             : state.phase === 'skeletonizing'
-                ? '开始搭骨架：剥掉非核心功能，留下带注释的 TODO 桩，用 /thesis-defense check 跑通编译验证门。'
+                ? '开始搭骨架：剥掉非核心功能，留下带注释的 TODO 桩，用 /thesis defense check 跑通编译验证门。'
                 : state.phase === 'learning'
                     ? '推进当前里程碑：带学生走完它的 todo，逐个提出追问，并对照期望要点评分。'
                     : '全部里程碑已验证：总结学生现在能讲清哪些设计。',

package/lib/config.d.ts

@@ -76,6 +76,19 @@ export interface CodeWalkthroughOptions {
     /** 每条门命令输出保留的最大字符数。 */
     maxCapturedOutput: number;
 }
+/**
+ * 自动驾驶：插件在后台把流程推起来，人只在开头选一次意图、过关卡时拍一次板。
+ *
+ * 关掉它就是「纯工具模式」：没有启动选择题，也没有关卡确认，一切靠人和模型对话驱动。
+ */
+export interface AutopilotOptions {
+    /** 总开关（默认开）。 */
+    enabled: boolean;
+    /** 目标最多自动跑多少轮（防止跑飞）。 */
+    maxGoalRounds: number;
+    /** 模型要过 G1-G4 时，是否必须先由人在审批界面拍板（默认开）。 */
+    gateApproval: boolean;
+}
 /** 插件配置（全部可选，均有出厂默认值）。 */
 export interface PaperConfig extends GateOptions {
     /** 论文工作区根；缺省从会话 cwd 向上探测 `00-管理/进度台账.md`。 */
@@ -90,6 +103,8 @@ export interface PaperConfig extends GateOptions {
     defense?: Partial<DefenseOptions>;
     /** 代码演练（答辩层）。 */
     codeWalkthrough?: Partial<CodeWalkthroughOptions>;
+    /** 自动驾驶（后台推进 + 开头一道选择题 + 关卡拍板）。 */
+    autopilot?: Partial<AutopilotOptions>;
     /** 相关时把已确认的稳定事实放回上下文。 */
     recall?: Partial<RecallOptions>;
 }
@@ -102,6 +117,7 @@ export declare const PAPER_DEFAULTS: {
     ppt: PptOptions;
     defense: DefenseOptions;
     codeWalkthrough: CodeWalkthroughOptions;
+    autopilot: AutopilotOptions;
     recall: RecallOptions;
 };
 /** 解析后的配置：嵌套块已补全，调用方不再处理 undefined。 */
@@ -115,6 +131,7 @@ export interface ResolvedPaperConfig {
     readonly ppt: PptOptions;
     readonly defense: DefenseOptions;
     readonly codeWalkthrough: CodeWalkthroughOptions;
+    readonly autopilot: AutopilotOptions;
     readonly recall: RecallOptions;
     /** 闸门配置：两个开关可选（缺省即由闸门自身按「开」处理），列表均已补全。 */
     readonly gates: GateOptions;

package/lib/config.js

@@ -38,11 +38,12 @@ export const PAPER_DEFAULTS = {
         },
         maxCapturedOutput: 8000,
     },
+    autopilot: { enabled: true, maxGoalRounds: 40, gateApproval: true },
     recall: RECALL_DEFAULTS,
 };
 /** 补全嵌套块默认值。 */
 export function resolveConfig(config = {}) {
-    const { workspace, memoryPath, ingest, intake, similarity, stylecheck, ppt, defense, codeWalkthrough, recall, writingGate, destructiveGate, writingIntentPatterns, criteriaMarkers, bypassMarkers, maxQuestions, destructiveToolNames, destructiveRules, } = config;
+    const { workspace, memoryPath, ingest, intake, similarity, stylecheck, ppt, defense, codeWalkthrough, autopilot, recall, writingGate, destructiveGate, writingIntentPatterns, criteriaMarkers, bypassMarkers, maxQuestions, destructiveToolNames, destructiveRules, } = config;
     return {
         workspace,
         memoryPath,
@@ -57,6 +58,7 @@ export function resolveConfig(config = {}) {
             ...codeWalkthrough,
             gates: { ...PAPER_DEFAULTS.codeWalkthrough.gates, ...codeWalkthrough?.gates },
         },
+        autopilot: { ...PAPER_DEFAULTS.autopilot, ...autopilot },
         recall: { ...PAPER_DEFAULTS.recall, ...recall },
         gates: {
             ...(writingGate !== undefined ? { writingGate } : {}),
@@ -118,6 +120,12 @@ export const Config = z.object({
         })).default(PAPER_DEFAULTS.codeWalkthrough.gates),
         maxCapturedOutput: z.natural().default(PAPER_DEFAULTS.codeWalkthrough.maxCapturedOutput),
     }),
+    // ---- 自动驾驶 ----
+    autopilot: z.object({
+        enabled: z.boolean().default(PAPER_DEFAULTS.autopilot.enabled),
+        maxGoalRounds: z.natural().min(1).default(PAPER_DEFAULTS.autopilot.maxGoalRounds),
+        gateApproval: z.boolean().default(PAPER_DEFAULTS.autopilot.gateApproval),
+    }),
     // ---- 跨会话事实 ----
     recall: z.object({
         maxEntries: z.natural().default(PAPER_DEFAULTS.recall.maxEntries),

package/lib/dedup/index.js

@@ -18,7 +18,6 @@ import * as nodePath from 'node:path';
 import { bulletList, definePaperTool, sessionCwd, textOutput } from "../shared/index.js";
 import { CHAPTER_META, isWrittenChapter } from "../paper/lib/layout.js";
 import { findThesisRoot } from "../paper/lib/project.js";
-import { dedupCommand } from "./commands.js";
 import { segmentsFromText } from "./normalize.js";
 import { scan } from "./similarity.js";
 import { buildReport, parseBaseline, renderReport, renderVerifyReport, verifyDelta, weightedRateOf, } from "./report.js";
@@ -322,10 +321,5 @@ export function registerDedup(ctx, options) {
             return await runDedup(ctx.fs, sessionCwd(exec), rawArgs, options.similarity, exec.signal);
         },
     }));
-    // `/thesis-originality [scan|verify|report] [语料路径] [--chapter 01-绪论]`：与工具同一执行层，
-    // 命令只是给人用的快捷入口（命令名只允许 [a-z][a-z0-9_-]*）。
-    if (ctx.commands !== undefined) {
-        ctx.commands.register(dedupCommand(ctx.fs, options.similarity));
-    }
 }
 export { segmentsFromText, scan, buildReport, renderReport, weightedRateOf };