@ai-agent-forge/plugin-decision-escalation 0.0.0-stage → 0.88.15

package/dist/index.js

@@ -0,0 +1,592 @@
+/**
+ * Decision escalation capability plugin (`docs/design/决策升级插件设计.md`):
+ * a formal ask channel for forks (decision_ask), a local confirmation page
+ * plus TUI-text answers resolved through decision_resolve, a factory-180s
+ * timeout de-escalation chain (single adjudicator for routine forks,
+ * advocates + judge for significant ones, via the public
+ * `agent-forge.agent-task-scheduler@1` capability), and an irreversible
+ * redline that keeps the agent stopped.
+ *
+ * Persistence protocol, structurally identical to the goal/plan/alignment
+ * plugins: append-only `decision.state` full snapshots (the single rebuild
+ * source) plus one `decision.transition` audit entry per conversion,
+ * announced as `decision.changed` (version 1, correlationId
+ * "decision.state", data = the complete DecisionState snapshot).
+ *
+ * Injections (设计 §6): user answers ride `decision.answered`
+ * (`display: false`, model context like alignment.feedback); timeout
+ * adjudication/halted notices ride `decision.notice` (`display: true`, the
+ * user must see them). Both trigger a new turn via `sendMessage`.
+ */
+import { randomUUID } from "node:crypto";
+import { Type } from "typebox";
+import { requireSchedulerCaller, runAdjudication } from "./adjudication.js";
+import { applyAdjudicationFailure, applyDecisionAnswer, applyDecisionAsk, applyDecisionCancel, applyDecisionTimeout, findDecision, rebuildDecisionState, recordVerdict, } from "./engine.js";
+import { startDecisionServer } from "./http-server.js";
+import { DECISION_LIMITS, DecisionError, } from "./types.js";
+const STATE_ENTRY = "decision.state";
+const TRANSITION_ENTRY = "decision.transition";
+/** 出厂默认（设计 §10）：问询超时 180 秒，config `timeoutMs` 可覆盖。 */
+const DEFAULT_TIMEOUT_MS = 180_000;
+/**
+ * 注入接受判定的兜底窗口（alignment v3.10 同款）：宿主在回合开头落
+ * custom_message 条目（正常毫秒级可见）。第三方宿主若不投影该类条目，窗口
+ * 结束仍未拒绝即视为已接受。
+ */
+const INJECT_ACCEPT_TIMEOUT_MS = 750;
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * 双调用约定（goal/alignment 同款）：会话路径以 (toolCallId, params, signal,
+ * onUpdate) 调用插件工具——first 是调用 id 字符串；runtime facade 以
+ * (input, context?, signal?) 调用——first 是入参对象。按 first 的类型区分，
+ * 两条路径（含 runtime 携带 context）都取到真实入参。
+ */
+function toolInput(first, second) {
+    if (typeof first === "string") {
+        if (!isObject(second))
+            return {};
+        return second;
+    }
+    if (!isObject(first))
+        throw new Error("decision tool input must be an object");
+    return first;
+}
+/** config `timeoutMs`（设计 §10）：数值覆盖出厂 180s；非法类型显式报错。 */
+function readTimeoutMs(config) {
+    const value = config.timeoutMs;
+    if (value === undefined)
+        return DEFAULT_TIMEOUT_MS;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+        throw new Error("decision-escalation: config.timeoutMs must be a positive integer (ms)");
+    }
+    return value;
+}
+function loadState(api) {
+    const entries = (api.session?.getBranchEntries() ?? []);
+    return rebuildDecisionState(entries);
+}
+function loadTransitions(api) {
+    const entries = api.session?.getBranchEntries() ?? [];
+    return entries
+        .filter((item) => item.customType === TRANSITION_ENTRY)
+        .map((item) => item.data)
+        .filter((item) => isObject(item));
+}
+function pageView(record, timeoutMs) {
+    return {
+        decisionId: record.id,
+        question: record.question,
+        options: record.options,
+        contextDigest: record.contextDigest,
+        riskClass: record.riskClass,
+        redLine: record.redLine,
+        status: record.status,
+        ...(record.status === "answered" && record.choice !== undefined ? { answeredChoice: record.choice } : {}),
+        timeoutMs,
+        revision: record.revision,
+    };
+}
+function optionLine(record, choice) {
+    const option = record.options[choice];
+    return option === undefined ? `choice ${choice}` : `[${choice}] ${option.label}`;
+}
+/** `decision.answered` injection body (设计 §6): user choice delivered to the model. */
+function answeredMessage(record, choice, note) {
+    const lines = [
+        `[decision.answered] 决策 ${record.id} 已作答：${optionLine(record, choice)}`,
+        `问题：${record.question}`,
+    ];
+    if (note !== undefined && note !== "")
+        lines.push(`用户补充：${note}`);
+    lines.push(`请立即调用 decision_resolve（decisionId "${record.id}"，choice ${choice}，source "user"）落账，然后按选择继续执行。`);
+    return lines.join("\n");
+}
+/** `decision.notice` halted body (设计 §5.1): redline / failed adjudication. */
+function haltedMessage(record, detail) {
+    const lines = [
+        `[decision.notice] 决策 ${record.id} 已停止推进（问题：${record.question}）`,
+        ...record.options.map((option, index) => `[${index}] ${option.label} — ${option.description}（后果：${option.consequences}，可逆性：${option.reversibility ?? "未声明"}）`),
+    ];
+    if (detail !== undefined && detail !== "")
+        lines.push(`原因：${detail}`);
+    lines.push("纪律：停止执行，把该分叉与上述选项整理后写给用户，等待用户明示；不得自行裁决后继续，不得自动调用 decision_resolve。");
+    return lines.join("\n");
+}
+/** `decision.notice` adjudication body (设计 §5): the full verdict drives the next turn. */
+function adjudicationNoticeMessage(record) {
+    const verdict = record.verdict;
+    if (verdict === undefined)
+        throw new DecisionError("invalid-input", `no verdict stored on decision ${record.id}`);
+    return [
+        `[decision.notice] 决策 ${record.id} 已超时，由独立裁决链裁决完成（问题：${record.question}）`,
+        `裁决：${optionLine(record, verdict.choice)}（置信度 ${verdict.confidence}）`,
+        `理由：${verdict.rationale}`,
+        `关键证据：${verdict.keyEvidence.join("；")}`,
+        `请立即调用 decision_resolve（decisionId "${record.id}"，choice ${verdict.choice}，source "adjudication"）落账，然后按裁决继续执行。`,
+        "纪律：有实质异议时停止并说明异议与依据，不得静默推翻，也不得静默服从明知有致命缺陷的裁决。",
+    ].join("\n");
+}
+const PROMPT_GUIDELINES = [
+    "L0 微小分叉自主决策，不问；L1+ 且无法从既有指令推出用户偏好时才 decision_ask。",
+    "context_digest 必须对称：每个选项都要写支持与反对证据；不得为倾向选项写更充分的论证。",
+    "任何选项不可逆时必须如实声明 reversibility，不得打包成 reversible 规避红线。",
+    "收到 halted 通知：停止执行，把分叉与选项整理给用户，不得自行裁决后继续。",
+    "收到裁决书：执行裁决；有实质异议时停止并说明异议与依据，不得静默推翻，也不得静默服从明知有致命缺陷的裁决。",
+];
+const askSchema = Type.Object({
+    question: Type.String({ description: "分叉一句话" }),
+    options: Type.Array(Type.Object({
+        label: Type.String({ description: "选项短标签" }),
+        description: Type.String({ description: "选项一句话说明" }),
+        consequences: Type.String({ description: "选它的直接后果" }),
+        reversibility: Type.Optional(Type.Union([Type.Literal("reversible"), Type.Literal("irreversible")], {
+            description: "可逆性；缺失按红线处理（保守默认）",
+        })),
+    }), { description: "2..4 个封闭选项", minItems: 2, maxItems: 4 }),
+    context_digest: Type.String({
+        description: "对称决策简报：每个选项的支持证据、反对证据、影响范围；缺项视为无效简报",
+    }),
+    risk_class: Type.Union([Type.Literal("routine"), Type.Literal("significant")], {
+        description: "L1/L2 自评，仅决定超时后走单裁还是对抗裁决",
+    }),
+});
+const resolveSchema = Type.Object({
+    decisionId: Type.String({ description: "decision_ask 返回的决策 id" }),
+    choice: Type.Integer({ description: "选项下标（0 起）" }),
+    source: Type.Union([Type.Literal("user"), Type.Literal("adjudication")], {
+        description: "user=用户作答；adjudication=已注入的裁决书（必须与裁决一致，不得伪造）",
+    }),
+    note: Type.Optional(Type.String({ description: "落账备注（可选）" })),
+});
+function listLines(state, count) {
+    if (state.decisions.length === 0)
+        return "no decisions in this session; ask one with decision_ask";
+    const lines = [`decisions: ${state.decisions.length}`];
+    for (const record of state.decisions.slice(-count).reverse()) {
+        lines.push(`- ${record.id} [${record.status}${record.redLine ? "/redline" : `/${record.riskClass}`}] ${record.question.replace(/\n/g, " ").slice(0, 80)} · ${record.resolvedBy ?? "-"}${record.choice === undefined ? "" : ` choice=${record.choice}`} · ${new Date(record.createdAt).toISOString()}`);
+    }
+    return lines.join("\n");
+}
+function showLines(record, transitions) {
+    const lines = [
+        `${record.id} [${record.status}${record.redLine ? "/redline" : `/${record.riskClass}`}] ${record.question}`,
+        `created: ${new Date(record.createdAt).toISOString()} · revision ${record.revision}`,
+    ];
+    for (const [index, option] of record.options.entries()) {
+        const marker = record.choice === index ? " ← 已选" : "";
+        lines.push(`[${index}] ${option.label} — ${option.description}`);
+        lines.push(`    后果：${option.consequences} · 可逆性：${option.reversibility}${marker}`);
+    }
+    lines.push(`对称简报：${record.contextDigest}`);
+    if (record.resolvedBy !== undefined)
+        lines.push(`resolved_by: ${record.resolvedBy}${record.choice === undefined ? "" : `（${optionLine(record, record.choice)}）`}`);
+    if (record.note !== undefined)
+        lines.push(`note: ${record.note}`);
+    if (record.verdict !== undefined) {
+        lines.push(`裁决书：choice=${record.verdict.choice} confidence=${record.verdict.confidence}`, `理由：${record.verdict.rationale}`, `关键证据：${record.verdict.keyEvidence.map((item) => `\n  - ${item}`).join("")}`);
+    }
+    const events = transitions.filter((entry) => entry.decisionId === record.id);
+    if (events.length > 0) {
+        lines.push("审计：");
+        for (const entry of events) {
+            lines.push(`  rev${entry.revision} ${entry.event}${entry.reason.detail === undefined ? "" : ` — ${entry.reason.detail}`}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function createCapability(api, options = {}) {
+    let state = loadState(api);
+    let server;
+    /** Disposed sessions never inject again: checked at every timer-job await point. */
+    let disposed = false;
+    const effectiveTimeoutMs = options.timeoutMs ?? readTimeoutMs(api.config);
+    const timers = new Map();
+    /**
+     * 计时路径没有调用方可观察异常：注入失败在这里保留原始错误（不吞不改，
+     * 不产生未处理的 promise 拒绝），并在 /decision log 可见。
+     */
+    const timeoutFailures = [];
+    /**
+     * 双 POST 幂等标记：内存态，不进持久化——同一决策的页面作答
+     * 只注入一次，重复提交直接幂等返回。
+     */
+    const deliveredAnswers = new Map();
+    const persist = (next, transitions) => {
+        state = next;
+        api.session?.appendEntry(STATE_ENTRY, state);
+        for (const entry of transitions)
+            api.session?.appendEntry(TRANSITION_ENTRY, entry);
+        void api.publish({ type: "decision.changed", version: 1, correlationId: STATE_ENTRY, data: state });
+        return state;
+    };
+    /**
+     * 注入是否已被会话接受（alignment v3.10 同款）：宿主在回合开始时就把
+     * custom message 落成条目并持久化，因此"条目可见"就是送达事实；不能等
+     * `sendMessage` 的 promise——它要到整个模型回合结束才 resolve。
+     */
+    const customMessageCount = () => {
+        const entries = api.session?.getBranchEntries() ?? [];
+        return entries.filter((entry) => entry.type === "custom_message").length;
+    };
+    const awaitAccepted = async (baseline, sent) => {
+        let settled = false;
+        let failure;
+        const outcome = sent.then(() => {
+            settled = true;
+        }, (error) => {
+            settled = true;
+            failure = error;
+        });
+        const started = Date.now();
+        // 迭代上限是假定时器（Date 也被冻结）时的兜底：不靠时钟也能退出循环。
+        for (let attempt = 0; attempt < 100_000; attempt += 1) {
+            if (customMessageCount() > baseline) {
+                // 回合继续在后台跑；它之后的失败由宿主呈现。
+                void outcome;
+                return;
+            }
+            if (settled) {
+                await outcome;
+                if (failure !== undefined)
+                    throw failure;
+                return;
+            }
+            if (Date.now() - started >= INJECT_ACCEPT_TIMEOUT_MS) {
+                // 无条目证据的宿主：sendMessage 已调用且未拒绝，按已接受处理。
+                void outcome;
+                return;
+            }
+            // setImmediate 而不是 setTimeout：条目写入在毫秒级，且宿主的单测可能
+            // 伪造 setTimeout（假定时器下 setTimeout 不推进会把送达判定挂死）。
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        await outcome;
+        if (failure !== undefined)
+            throw failure;
+    };
+    const inject = async (customType, content, display) => {
+        // alignment 两处降级同款：sendMessage 缺失显式抛错，不静默。
+        const send = api.session?.sendMessage;
+        if (!send) {
+            throw new DecisionError("invalid-input", "host session does not expose sendMessage; the decision answer cannot be injected");
+        }
+        const baseline = customMessageCount();
+        const sent = send({ customType, content, display }, { triggerTurn: true });
+        await awaitAccepted(baseline, sent);
+        // triggerTurn 注入会同步驱动模型回合，回合内的 decision_resolve 已把变更
+        // 落账 entries——此处从 entries 重建内存态，不回写回合前快照。
+        if (api.session)
+            state = loadState(api);
+    };
+    const clearTimer = (decisionId) => {
+        const timer = timers.get(decisionId);
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timers.delete(decisionId);
+        }
+    };
+    const requireAsked = (decisionId) => {
+        const record = findDecision(state, decisionId);
+        if (!record)
+            throw new DecisionError("not-found", `unknown decision: ${decisionId}`);
+        if (record.status !== "asked") {
+            throw new DecisionError("not-active", `decision is not active (status ${record.status}): ${decisionId}`);
+        }
+        return record;
+    };
+    const injectNotice = (record, detail) => inject("decision.notice", haltedMessage(record, detail), true);
+    /** Timeout fire (设计 §5): halt redlines, adjudicate reversible levels. */
+    const handleTimeout = async (decisionId) => {
+        timers.delete(decisionId);
+        if (disposed)
+            return; // 会话已关闭：不派发、不注入
+        const record = requireAsked(decisionId);
+        const mode = record.redLine ? "halt" : "adjudicate";
+        const run = applyDecisionTimeout(state, { decisionId, mode }, Date.now());
+        persist(run.state, run.transitions);
+        if (disposed)
+            return; // 已关闭：落账保留，放弃后续派发
+        if (mode === "halt") {
+            await injectNotice(run.state.decisions.find((item) => item.id === decisionId) ?? record);
+            return;
+        }
+        // 裁决链（§5）：scheduler 缺失、submit/drain 抛错、协议失败一律按 halted
+        // 通知收尾——不重试、不静默降级。
+        const caller = requireSchedulerCaller(api);
+        const outcome = caller === undefined
+            ? {
+                ok: false,
+                code: "unavailable",
+                detail: "agent-forge.agent-task-scheduler capability is not available",
+            }
+            : await runAdjudication(caller, {
+                decisionId: record.id,
+                question: record.question,
+                options: record.options,
+                contextDigest: record.contextDigest,
+                riskClass: record.riskClass,
+            });
+        if (disposed)
+            return; // 已关闭：放弃裁决落账与注入
+        const adjudicating = findDecision(state, decisionId);
+        if (adjudicating === undefined)
+            throw new DecisionError("not-found", `decision vanished during adjudication: ${decisionId}`);
+        if (!outcome.ok) {
+            const failed = applyAdjudicationFailure(state, { decisionId, code: outcome.code, detail: outcome.detail }, Date.now());
+            persist(failed.state, failed.transitions);
+            await injectNotice(failed.state.decisions.find((item) => item.id === decisionId) ?? adjudicating, outcome.detail);
+            return;
+        }
+        const verdictRun = recordVerdict(state, { decisionId, verdict: outcome.verdict }, Date.now());
+        const withVerdict = persist(verdictRun.state, verdictRun.transitions);
+        const decided = findDecision(withVerdict, decisionId);
+        if (decided === undefined)
+            throw new DecisionError("not-found", `decision vanished after verdict: ${decisionId}`);
+        await inject("decision.notice", adjudicationNoticeMessage(decided), true);
+    };
+    const recordTimeoutFailure = (error) => {
+        // 计时路径没有调用方可观察异常：保留原始错误供 /decision 诊断与
+        // 测试断言，不吞不改。
+        timeoutFailures.push(error);
+    };
+    const timerFired = (decisionId) => {
+        void handleTimeout(decisionId).catch(recordTimeoutFailure);
+    };
+    const armTimer = (decisionId, remainingMs) => {
+        clearTimer(decisionId);
+        timers.set(decisionId, setTimeout(() => timerFired(decisionId), remainingMs ?? effectiveTimeoutMs));
+    };
+    /**
+     * 页面目标决策从 state 派生：
+     * 最新的 asked 优先；否则最近一条（超时降级/终态记录保持可查看）。
+     * 重载后同一 URL 继续可答旧决策，不再依赖一次性捕获。
+     */
+    const pageRecord = () => state.decisions.find((record) => record.status === "asked") ?? state.decisions.at(-1);
+    const ensureServer = async () => {
+        // 页面生命周期（alignment 走查 2026-10-04 同款）：服务随第一个
+        // decision_ask 启动后常驻到插件 dispose（会话关闭）；下一次问询在
+        // 同一 URL 上覆盖内容。
+        if (server)
+            return server;
+        server = await startDecisionServer({
+            getState: () => {
+                const record = pageRecord();
+                return record === undefined ? undefined : pageView(record, effectiveTimeoutMs);
+            },
+            onAnswer: (post) => handleAnswerPost(post),
+        }, { port: options.serverPort });
+        return server;
+    };
+    /** Page POST (设计 §7): validate the choice, inject `decision.answered`. */
+    const handleAnswerPost = async (post) => {
+        const record = pageRecord();
+        if (record === undefined)
+            return { status: 409, body: { error: "no decision awaiting an answer" } };
+        // 双 POST 幂等：同一决策的作答只注入一次，重复提交直接返回。
+        const deliveredChoice = deliveredAnswers.get(record.id);
+        if (deliveredChoice !== undefined) {
+            return {
+                status: 200,
+                body: { ok: true, delivered: true, idempotent: true, decisionId: record.id, choice: deliveredChoice },
+            };
+        }
+        if (record.status !== "asked") {
+            return {
+                status: 409,
+                body: { code: "not-active", error: `decision is not active (status ${record.status}): ${record.id}` },
+            };
+        }
+        if (!Number.isInteger(post.choice)) {
+            return { status: 400, body: { code: "invalid-input", error: "choice must be an option index" } };
+        }
+        const choice = post.choice;
+        if (choice < 0 || choice >= record.options.length) {
+            return {
+                status: 400,
+                body: { code: "choice-out-of-range", error: `choice must be within 0..${record.options.length - 1}` },
+            };
+        }
+        let note;
+        if (post.note !== undefined && post.note !== null && post.note !== "") {
+            if (typeof post.note !== "string") {
+                return { status: 400, body: { code: "invalid-input", error: "note must be a string" } };
+            }
+            if (post.note.length > DECISION_LIMITS.noteMaxLength) {
+                return {
+                    status: 400,
+                    body: { code: "invalid-input", error: `note exceeds ${DECISION_LIMITS.noteMaxLength} characters` },
+                };
+            }
+            note = post.note;
+        }
+        try {
+            await inject("decision.answered", answeredMessage(record, choice, note), false);
+            deliveredAnswers.set(record.id, choice);
+            // 作答送达即撤销超时计时器：否则窗口末端作答会在模型
+            // resolve 前被计时器触发的裁决链推翻。
+            clearTimer(record.id);
+            return { status: 200, body: { ok: true, delivered: true, decisionId: record.id, choice } };
+        }
+        catch (error) {
+            return {
+                status: 503,
+                body: {
+                    error: `answer delivery failed: ${error instanceof Error ? error.message : String(error)}`,
+                    retry: true,
+                },
+            };
+        }
+    };
+    const runAsk = async (input) => {
+        // 作答通道依赖注入（设计 §2/§7）：sendMessage 缺失在落账前显式失败，
+        // 不留下一个永远等不到作答的决策（alignment 两处降级同款）。
+        if (!api.session?.sendMessage) {
+            throw new DecisionError("invalid-input", "host session does not expose sendMessage; decision answers cannot be delivered on this host");
+        }
+        // 决策 id 由插件生成（设计 §4.1 输入没有 id 字段）：模型拿到的
+        // decisionId 是本工具返回值，不自己起名。
+        const askInput = {
+            id: `decision-${randomUUID().replace(/-/g, "").slice(0, 12)}`,
+            question: input.question,
+            options: input.options,
+            contextDigest: input.context_digest,
+            riskClass: input.risk_class,
+        };
+        // 先懒启动页面（失败不落账），再落 asked 快照与计时器，最后立即返回。
+        // 已有 asked 决策时 applyDecisionAsk 结构化拒绝（decision-active-exists），
+        // 服务已在同一 URL 上服务该决策。
+        const running = await ensureServer();
+        const run = applyDecisionAsk(state, askInput, Date.now());
+        persist(run.state, run.transitions);
+        armTimer(askInput.id);
+        const record = findDecision(state, askInput.id);
+        return {
+            decisionId: record.id,
+            url: running.url,
+            timeoutMs: effectiveTimeoutMs,
+            riskClass: record.riskClass,
+            redLine: record.redLine,
+        };
+    };
+    const askTool = api.registerTool({
+        name: "decision_ask",
+        label: "Ask a fork decision",
+        description: "Ask the user to decide a fork (2..4 closed options): returns a decision id, a local confirmation-page URL and progress facts immediately. Non-blocking: the answer arrives later as a decision.answered message; on timeout reversible forks are adjudicated independently and irreversible ones halt",
+        parameters: askSchema,
+        promptGuidelines: PROMPT_GUIDELINES,
+        readonlySafe: true,
+        execute: async (first, second) => runAsk(toolInput(first, second)),
+    });
+    const resolveTool = api.registerTool({
+        name: "decision_resolve",
+        label: "Resolve a decision",
+        description: 'Record the answer that closed a decision_ask fork: source "user" for a user reply (from the page or TUI text), source "adjudication" only to book an injected adjudication verdict (must match it; fabricating one is rejected)',
+        parameters: resolveSchema,
+        promptGuidelines: PROMPT_GUIDELINES,
+        readonlySafe: true,
+        execute: async (first, second) => {
+            const input = toolInput(first, second);
+            const run = applyDecisionAnswer(state, {
+                decisionId: typeof input.decisionId === "string" ? input.decisionId : "",
+                choice: input.choice,
+                source: input.source,
+                note: input.note,
+            }, Date.now());
+            persist(run.state, run.transitions);
+            // 决策已终态：超时计时器随之撤销。
+            clearTimer(typeof input.decisionId === "string" ? input.decisionId : "");
+            const record = findDecision(state, typeof input.decisionId === "string" ? input.decisionId : "");
+            return {
+                decisionId: record.id,
+                status: record.status,
+                resolvedBy: record.resolvedBy,
+                choice: record.choice,
+                option: record.choice === undefined ? undefined : record.options[record.choice]?.label,
+            };
+        },
+    });
+    const command = api.registerCommand({
+        name: "decision",
+        description: "Decision audit: `log [N]` lists the recent forks (id, question, status, resolved_by, choice), `show <id>` prints the full record including the adjudication verdict, `cancel <id>` cancels an active fork",
+        execute: async (args) => {
+            try {
+                const parts = args
+                    .trim()
+                    .split(/\s+/)
+                    .filter((part) => part !== "");
+                if (parts.length === 0) {
+                    return {
+                        status: "success",
+                        message: "Usage: /decision log [N] | /decision show <id> | /decision cancel <id>",
+                    };
+                }
+                if (parts[0] === "log") {
+                    const count = Number.parseInt(parts[1] ?? "20", 10);
+                    const lines = [listLines(loadState(api), Number.isFinite(count) && count > 0 ? count : 20)];
+                    // 超时作业的注入失败在这里可见（原始错误保留，不吞不改）。
+                    for (const failure of timeoutFailures) {
+                        lines.push(`timeout-job failure: ${failure instanceof Error ? failure.message : String(failure)}`);
+                    }
+                    return { status: "success", message: lines.join("\n") };
+                }
+                if (parts[0] === "show") {
+                    const id = parts[1] ?? "";
+                    const record = findDecision(loadState(api), id);
+                    if (!record)
+                        return { status: "error", message: `unknown decision: ${id || "(none given)"}` };
+                    return { status: "success", message: showLines(record, loadTransitions(api)) };
+                }
+                if (parts[0] === "cancel") {
+                    const id = parts[1] ?? "";
+                    const run = applyDecisionCancel(state, { decisionId: id }, Date.now());
+                    persist(run.state, run.transitions);
+                    clearTimer(id);
+                    return { status: "success", message: `cancelled: ${id}` };
+                }
+                return {
+                    status: "error",
+                    message: "Usage: /decision log [N] | /decision show <id> | /decision cancel <id>",
+                };
+            }
+            catch (error) {
+                return { status: "error", message: error instanceof Error ? error.message : String(error) };
+            }
+        },
+    });
+    const stopServer = () => {
+        const stopping = server;
+        server = undefined;
+        if (stopping)
+            void stopping.stop().catch(() => undefined);
+    };
+    // 会话重载重臂：装载时对仍处 asked 的决策按剩余时间重臂计时器
+    //（createdAt + timeoutMs - now）；已过期（<=0）立即走与正常超时同一语义
+    // 的降级链，不留一个静默失效的窗口。
+    for (const reloaded of state.decisions) {
+        if (reloaded.status !== "asked")
+            continue;
+        const remaining = reloaded.createdAt + effectiveTimeoutMs - Date.now();
+        if (remaining <= 0)
+            timerFired(reloaded.id);
+        else
+            armTimer(reloaded.id, remaining);
+    }
+    // The command registration doubles as the teardown hook for the local
+    // confirmation server and the pending timeout timers (plugin dispose must
+    // release the port and must not fire adjudications into a closed session).
+    const commandWithTeardown = {
+        id: command.id,
+        kind: command.kind,
+        dispose: () => {
+            disposed = true; // 先置位，在途超时作业在 await 点放弃注入
+            void command.dispose();
+            for (const decisionId of [...timers.keys()])
+                clearTimer(decisionId);
+            stopServer();
+        },
+    };
+    return [askTool, resolveTool, commandWithTeardown];
+}
+//# sourceMappingURL=index.js.map