dsh-thesis 1.0.1 → 2.0.1

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,22 @@
+/**
+ * 自动驾驶注入的消息与关卡确认文案。
+ *
+ * 与闸门消息共用同一条 source 约定：`{ kind: 'plugin', plugin: 'dsh-thesis', form: 'instructions' }`。
+ * `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,35 @@
+/**
+ * 自动驾驶注入的消息与关卡确认文案。
+ *
+ * 与闸门消息共用同一条 source 约定：`{ kind: 'plugin', plugin: 'dsh-thesis', form: 'instructions' }`。
+ * `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';

package/lib/codewalk/prestep.js

@@ -15,7 +15,7 @@ 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)}`;

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 };

package/lib/index.d.ts

@@ -2,7 +2,8 @@
  * dsh-thesis：论文与答辩全流程助手（DeepSeek Harness 单一插件）。
  *
  * 本文件是**唯一装配层**：把各能力挂到同一个插件 fiber 上，对外只有一行
- * `dsh plugin add dsh-thesis`、一个 Config、一套技能。
+ * `dsh plugin add dsh-thesis`、一个 Config、一套技能。**没有斜杠命令**：
+ * 插件在论文工作区里自己把流程推起来（开头一道选择题 + 关卡拍板）。
  *
  * | 目录 | 职责 |
  * |---|---|
@@ -14,6 +15,7 @@
  * | `memory/` | 跨会话事实：学校规范、导师要求、写作偏好（学生不必直接调用） |
  * | `codewalk/` | 代码演练：把 AI 写的系统拆成答辩讲得清的模块 |
  * | `gates/` | 闸门：写作意图闸门 + 不可逆操作闸门 + 意图规格闸门 |
+ * | `autopilot/` | 自动驾驶：开头一道选择题 + 建目标自动续轮 + 关卡拍板（无斜杠命令） |
  * | `shared/` | 工具胶水、工具定义器、文本与文件系统错误工具 |
  *
  * **一个领域模型**：材料 → 要求 → 九阶段 → 论文与答辩。学生的工具清单里

package/lib/index.js

@@ -2,7 +2,8 @@
  * dsh-thesis：论文与答辩全流程助手（DeepSeek Harness 单一插件）。
  *
  * 本文件是**唯一装配层**：把各能力挂到同一个插件 fiber 上，对外只有一行
- * `dsh plugin add dsh-thesis`、一个 Config、一套技能。
+ * `dsh plugin add dsh-thesis`、一个 Config、一套技能。**没有斜杠命令**：
+ * 插件在论文工作区里自己把流程推起来（开头一道选择题 + 关卡拍板）。
  *
  * | 目录 | 职责 |
  * |---|---|
@@ -14,6 +15,7 @@
  * | `memory/` | 跨会话事实：学校规范、导师要求、写作偏好（学生不必直接调用） |
  * | `codewalk/` | 代码演练：把 AI 写的系统拆成答辩讲得清的模块 |
  * | `gates/` | 闸门：写作意图闸门 + 不可逆操作闸门 + 意图规格闸门 |
+ * | `autopilot/` | 自动驾驶：开头一道选择题 + 建目标自动续轮 + 关卡拍板（无斜杠命令） |
  * | `shared/` | 工具胶水、工具定义器、文本与文件系统错误工具 |
  *
  * **一个领域模型**：材料 → 要求 → 九阶段 → 论文与答辩。学生的工具清单里
@@ -22,8 +24,8 @@
  * @module dsh-thesis
  */
 import { fileURLToPath } from 'node:url';
+import { installAutopilot } from "./autopilot/index.js";
 import { registerCodewalk } from "./codewalk/register.js";
-import { registerDefenseCommand } from "./commands.js";
 import { Config, resolveConfig } from "./config.js";
 import { registerDedup } from "./dedup/index.js";
 import { installDangerousGate } from "./gates/dangerous.js";
@@ -36,7 +38,7 @@ import { setWorkspaceRoot } from "./paper/lib/project.js";
 import { registerPaper } from "./paper/register.js";
 import { registerPpt } from "./ppt/index.js";
 export const name = 'dsh-thesis';
-export const inject = ['tools', 'fs', 'commands'];
+export const inject = ['tools', 'fs'];
 export { Config };
 export { PAPER_DEFAULTS, resolveConfig } from "./config.js";
 /** 随包发布的技能目录（`thesis_init` 复制到论文仓库 `.dsh/skills/`）。 */
@@ -55,20 +57,21 @@ export function apply(ctx, config = {}) {
     registerFacts(ctx, resolved.memoryPath);
     // 事实回灌：相关时自动把已确认的稳定事实放回上下文（不相关则完全静默）。
     installFactRecall(ctx, resolved.recall);
-    // 论文工作区：11 个工具 + 5 个命令。
+    // 论文工作区：11 个工具。
     registerPaper(ctx, { skillsDir: SKILLS_DIR });
     // 代码演练（答辩层）：3 个工具 + 进度卡注入 + code-walkthrough 技能。
     registerCodewalk(ctx, resolved.codeWalkthrough);
     // 材料入口：Office 摄取 → 文本与材料清单。
     registerIngest(ctx, { ingest: resolved.ingest });
-    // 意图规格：逐题追问状态机 + `/thesis-intake`。
+    // 意图规格：逐题追问状态机。
     registerIntake(ctx, { intake: resolved.intake });
     // 原创性自查：本地度量 + 改写处方 + 复测。
     registerDedup(ctx, { similarity: resolved.similarity });
     // 答辩：Markdown 幻灯 + 外部转换器探测。
     registerPpt(ctx, { ppt: resolved.ppt });
-    // 答辩命令：幻灯侧与代码演练侧在装配层聚合为 `/thesis-defense`。
-    registerDefenseCommand(ctx, { ppt: resolved.ppt });
+    // 自动驾驶：论文工作区里开口就问一次意图 → 建目标自动续轮；关卡由人拍板。
+    // 不提供任何斜杠命令：人只在「开头选一次」与「过关卡」两处出现。
+    installAutopilot(ctx, { ...resolved.autopilot, specRel: resolved.intake.specRel });
     // 闸门：写作意图闸门 + 不可逆操作闸门 + 意图规格闸门。
     installWritingGate(ctx, resolved.gates);
     installDangerousGate(ctx, resolved.gates);

package/lib/ingest/index.d.ts

@@ -175,5 +175,5 @@ export interface RegisterIngestOptions {
     /** 摄取配置（`maxBytes`/`maxChars`，来自 `src/config.ts`）。 */
     readonly ingest: IngestOptions;
 }
-/** 注册 `thesis_ingest`（同步注册，走仓库统一的 `definePaperTool`；斜杠命令见 `commands.ts`）。 */
+/** 注册 `thesis_ingest`（同步注册，走仓库统一的 `definePaperTool`；本插件不提供斜杠命令）。 */
 export declare function registerIngest(ctx: Context, options: RegisterIngestOptions): void;

package/lib/ingest/index.js

@@ -14,7 +14,6 @@ import { readdir, readFile, stat } from 'node:fs/promises';
 import * as nodePath from 'node:path';
 import { findThesisRoot } from "../paper/lib/project.js";
 import { bulletList, definePaperTool, sessionCwd, textOutput } from "../shared/index.js";
-import { ingestCommand } from "./commands.js";
 import { codeLanguageOf, detectTechStack, isManifestFile, renderProjectSummary, summarizeSource, } from "./code.js";
 import { extractDocx } from "./docx.js";
 import { extractPdf } from "./pdf.js";
@@ -615,7 +614,7 @@ export function renderOutcome(outcome, maxChars) {
         return text;
     return `${text.slice(0, Math.max(0, maxChars - 20))}\n…（清单过长已截断）`;
 }
-/** 注册 `thesis_ingest`（同步注册，走仓库统一的 `definePaperTool`；斜杠命令见 `commands.ts`）。 */
+/** 注册 `thesis_ingest`（同步注册，走仓库统一的 `definePaperTool`；本插件不提供斜杠命令）。 */
 export function registerIngest(ctx, options) {
     ctx.tools.register(definePaperTool({
         name: 'thesis_ingest',
@@ -636,5 +635,4 @@ export function registerIngest(ctx, options) {
             return renderOutcome(outcome, options.ingest.maxChars);
         },
     }));
-    ctx.commands.register(ingestCommand(ctx.fs, options.ingest));
 }

package/lib/intake/index.d.ts

@@ -57,20 +57,3 @@ export interface IntakeExecLike {
         };
     };
 }
-/** 命令返回值（宿主 `CommandResult` 的形状）。 */
-export interface IntakeCommandResult {
-    readonly kind: 'success' | 'error';
-    readonly text?: string;
-}
-/** 把 `/thesis-intake` 的一行输入翻译成追问动作。 */
-export declare function parseCommandInput(raw: string): IntakeArgs;
-/**
- * 注册命令 `/thesis-intake`（命令名只允许 `[a-z][a-z0-9_-]*`）。
- *
- * 用法：`/thesis-intake` 取下一个问题；`/thesis-intake status|spec|done|start`；
- * `/thesis-intake answer school.name XX大学`；`/thesis-intake skip ref.samples 暂时没有`。
- * `ctx.commands` 不可用（未装配命令服务的宿主）时静默跳过，不影响工具能力。
- */
-export declare function registerIntakeCommand(ctx: Context, options: {
-    intake: IntakeSubOptions;
-}): boolean;