agent-trellis 0.19.0 → 0.21.0

package/dist/evolve/reportView.js

@@ -0,0 +1,311 @@
+/**
+ * 进化可视化聚合层(trellis-evolve-visualization 任务 1.1)。
+ *
+ * 单一计算源:从三个只读来源(~/.trellis/evolve/archive/records.jsonl、
+ * evolve/pending/*.json、evolve.yaml)聚合出 `EvolveReport`,CLI 的
+ * `evolve report` / `status --json` 与 GUI sidecar 路由只是它的渲染/传输
+ * 壳——绝不维护第二份独立计算(gui-sidecar-api 的"读视图镜像 CLI"规约)。
+ *
+ * 只读零副作用:本模块永不 mkdir/append/write;全部指标可从档案重算,
+ * 每条趋势指标带口径说明(spec"趋势指标只来自真实测量")。数值评分
+ * (0-100 健康分之类)一律不合成——分数轴等 L2 探针任务集落地后另行变更。
+ */
+import { loadEvolveLevelPolicy } from "../host/index.js";
+import { readArchiveRecords } from "./archive.js";
+import { readPendingRecords, safeProposalFileName } from "./pending.js";
+import { JOB_RUN_KIND, PROPOSAL_ARCHIVE_KIND } from "./trigger.js";
+import { VERDICT_ARCHIVE_KIND } from "./gate.js";
+import { PROPOSAL_DECISION_ARCHIVE_KIND } from "./pending.js";
+import { PROPOSAL_REJECT_ARCHIVE_KIND } from "./validate.js";
+import { LESSON_ARCHIVE_KIND } from "./lesson.js";
+function isoTime(entry) {
+    return entry.recordedAt;
+}
+function payloadOf(entry) {
+    return (entry.payload ?? {});
+}
+function levelMap(policy) {
+    return {
+        defaultLevel: policy.defaultLevel ?? null,
+        agents: { ...policy.agents },
+        workspaces: { ...policy.workspaces },
+    };
+}
+/**
+ * 聚合进化报告(纯读)。timeline 按提案 id 关联 proposal / proposal-reject /
+ * verdict / proposal-decision / apply-run / lesson 档案;链上缺环如实标注,
+ * 不推断补齐。
+ */
+export function buildEvolveReport(homeDir) {
+    const entries = readArchiveRecords(homeDir);
+    const pending = readPendingRecords(homeDir);
+    const policy = loadEvolveLevelPolicy(homeDir);
+    const drafts = new Map();
+    const ensureDraft = (id) => {
+        let draft = drafts.get(id);
+        if (draft === undefined) {
+            draft = {
+                id,
+                summary: id,
+                kind: "",
+                riskClass: null,
+                layer: null,
+                edits: [],
+                chain: [],
+                measurement: null,
+                backupRunId: null,
+                lessonId: null,
+                endedInReject: false,
+                decided: null,
+                applied: false,
+            };
+            drafts.set(id, draft);
+        }
+        return draft;
+    };
+    // pending 存储给出提案正文(摘要/编辑/层);档案只追加,pending 是可变态。
+    const pendingById = new Map();
+    for (const record of pending)
+        pendingById.set(record.id, record);
+    for (const entry of entries) {
+        const payload = payloadOf(entry);
+        switch (entry.kind) {
+            case PROPOSAL_ARCHIVE_KIND: {
+                const id = String(payload.proposalId ?? "");
+                if (id === "")
+                    break;
+                const draft = ensureDraft(id);
+                draft.riskClass = payload.riskClass ?? draft.riskClass;
+                draft.chain.push({ stage: "proposed", at: isoTime(entry), note: "提案入队" });
+                break;
+            }
+            case PROPOSAL_REJECT_ARCHIVE_KIND: {
+                const id = String(payload.proposalId ?? "");
+                if (id === "")
+                    break;
+                const draft = ensureDraft(id);
+                draft.endedInReject = true;
+                draft.chain.push({
+                    stage: "discarded",
+                    at: isoTime(entry),
+                    note: `${String(payload.phase ?? "")} 丢弃:${String(payload.code ?? "")} — ${String(payload.reason ?? "")}`,
+                });
+                break;
+            }
+            case VERDICT_ARCHIVE_KIND: {
+                const id = String(payload.proposalId ?? "");
+                if (id === "")
+                    break;
+                const draft = ensureDraft(id);
+                draft.measurement = {
+                    decision: String(payload.decision ?? ""),
+                    reason: String(payload.reason ?? ""),
+                    targetIds: payload.targetIds ?? [],
+                    resolvedIds: payload.resolvedIds ?? [],
+                    introduced: payload.introduced ?? [],
+                };
+                draft.chain.push({
+                    stage: "verdict",
+                    at: isoTime(entry),
+                    note: `L1 ${draft.measurement.decision}:${draft.measurement.reason}`,
+                });
+                break;
+            }
+            case PROPOSAL_DECISION_ARCHIVE_KIND: {
+                const id = String(payload.proposalId ?? "");
+                if (id === "")
+                    break;
+                const draft = ensureDraft(id);
+                draft.decided = payload.decision === "rejected" ? "rejected" : "approved";
+                draft.chain.push({
+                    stage: "decision",
+                    at: isoTime(entry),
+                    note: `管理面${draft.decided === "rejected" ? "拒绝" : "批准"}`,
+                });
+                break;
+            }
+            case "apply-run": {
+                const runId = String(payload.runId ?? "");
+                const failed = payload.failed === true;
+                const ids = payload.proposalIds ?? [];
+                for (const id of ids) {
+                    const draft = ensureDraft(id);
+                    if (failed) {
+                        draft.chain.push({ stage: "applied", at: isoTime(entry), note: `应用部分失败(run ${runId}):${String(payload.error ?? "")}` });
+                    }
+                    else {
+                        draft.applied = true;
+                        draft.backupRunId = runId;
+                        draft.chain.push({ stage: "applied", at: isoTime(entry), note: `应用完成(备份会话 ${runId},可回滚)` });
+                        // 生效时点回放(review-fixes ❌3):effects 随 apply-run 档案入档;
+                        // 旧档案无此字段如实跳过,不伪造。
+                        const effects = payload.effects ?? [];
+                        for (const effect of effects) {
+                            draft.chain.push({
+                                stage: "applied",
+                                at: isoTime(entry),
+                                note: `生效时点 ${String(effect.agent ?? "?")}:${String(effect.effect ?? "")}`,
+                            });
+                        }
+                    }
+                }
+                break;
+            }
+            case LESSON_ARCHIVE_KIND: {
+                const lesson = entry.payload;
+                // lesson.id = `lesson-<safeProposalFileName>`:反查提案链。
+                const stem = lesson.id.startsWith("lesson-") ? lesson.id.slice("lesson-".length) : lesson.id;
+                for (const [id, draft] of drafts) {
+                    if (safeProposalFileName(id) === stem) {
+                        draft.lessonId = lesson.id;
+                        draft.chain.push({ stage: "lesson", at: isoTime(entry), note: `蒸馏 lesson: ${lesson.cue}` });
+                        break;
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    // pending 是提案正文源,且可能先于/独立于档案存在(如管理面直写):
+    // 以 pending 记录同样播种追踪链,档案缺环如实空缺,不伪造补齐。
+    for (const [id, record] of pendingById) {
+        const draft = ensureDraft(id);
+        if (draft.summary === id)
+            draft.summary = record.proposal.summary;
+        if (draft.kind === "")
+            draft.kind = record.proposal.kind;
+        if (draft.layer === null)
+            draft.layer = record.proposal.layer;
+        if (draft.edits.length === 0)
+            draft.edits = [...record.proposal.edits];
+        if (draft.riskClass === null)
+            draft.riskClass = record.riskClass;
+        if (draft.decided === null)
+            draft.decided = record.status === "pending" ? null : record.status;
+    }
+    const timeline = [...drafts.values()]
+        .map((draft) => {
+        const status = draft.applied
+            ? "applied"
+            : draft.endedInReject && draft.decided === null
+                ? "discarded"
+                : draft.decided === "rejected"
+                    ? "rejected"
+                    : draft.decided === "approved"
+                        ? "approved"
+                        : "pending";
+        return {
+            id: draft.id,
+            summary: draft.summary,
+            kind: draft.kind,
+            riskClass: draft.riskClass,
+            layer: draft.layer,
+            status,
+            chain: [...draft.chain].sort((a, b) => (a.at < b.at ? -1 : a.at > b.at ? 1 : 0)),
+            measurement: draft.measurement,
+            edits: draft.edits,
+            backupRunId: draft.backupRunId,
+            lessonId: draft.lessonId,
+        };
+    })
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    // ---- 趋势指标(可从档案重算;口径随数据导出) ----
+    let resolvedTotal = 0;
+    let decidedCount = 0;
+    let approvedCount = 0;
+    for (const entry of entries) {
+        if (entry.kind === VERDICT_ARCHIVE_KIND) {
+            resolvedTotal += payloadOf(entry).resolvedIds?.length ?? 0;
+        }
+        if (entry.kind === PROPOSAL_DECISION_ARCHIVE_KIND) {
+            decidedCount += 1;
+            if (payloadOf(entry).decision === "approved")
+                approvedCount += 1;
+        }
+    }
+    const jobEntries = entries.filter((entry) => entry.kind === JOB_RUN_KIND);
+    const jobFailures = jobEntries.filter((entry) => typeof payloadOf(entry).error === "string");
+    const everMeasured = entries.some((entry) => entry.kind === VERDICT_ARCHIVE_KIND);
+    const everDecided = decidedCount > 0;
+    const trends = [
+        {
+            id: "findings-resolved",
+            label: "累计发现解决数",
+            value: everMeasured ? resolvedTotal : null,
+            source: "verdict 档案 resolvedIds 累计",
+        },
+        {
+            id: "adoption-rate",
+            label: "提案采纳率",
+            value: everDecided ? approvedCount / decidedCount : null,
+            source: "proposal-decision 档案 approved / 全部决策",
+        },
+        {
+            id: "rejection-rate",
+            label: "提案拒绝率",
+            value: everDecided ? (decidedCount - approvedCount) / decidedCount : null,
+            source: "proposal-decision 档案 rejected / 全部决策",
+        },
+        {
+            id: "job-runs",
+            label: "作业运行次数",
+            value: jobEntries.length > 0 ? jobEntries.length : null,
+            source: "job-run 档案条数",
+        },
+        {
+            id: "job-failures",
+            label: "作业失败次数",
+            value: jobEntries.length > 0 ? jobFailures.length : null,
+            source: "job-run 档案含 error 字段的条数",
+        },
+    ];
+    // ---- 作业运行与通知 ----
+    const jobRuns = jobEntries.map((entry) => {
+        const payload = payloadOf(entry);
+        const summary = (payload.summary ?? {});
+        return {
+            startedAt: new Date(Number(payload.startedAtMs ?? 0)).toISOString(),
+            endedAt: typeof payload.endedAtMs === "number" ? new Date(payload.endedAtMs).toISOString() : null,
+            ok: typeof payload.error !== "string",
+            error: typeof payload.error === "string" ? payload.error : null,
+            trigger: payload.trigger === "manual" || payload.trigger === "chain" ? payload.trigger : "event",
+            summary: {
+                signalsConsidered: typeof summary.signalsConsidered === "number" ? summary.signalsConsidered : null,
+                enqueued: Array.isArray(summary.enqueuedIds) ? summary.enqueuedIds.length : null,
+                autoAdopted: Array.isArray(summary.autoAdoptedIds) ? summary.autoAdoptedIds.length : null,
+            },
+        };
+    });
+    const notices = [];
+    for (const entry of jobEntries) {
+        const summary = (payloadOf(entry).summary ?? {});
+        if (Array.isArray(summary.notices)) {
+            for (const notice of summary.notices)
+                if (typeof notice === "string")
+                    notices.push(notice);
+        }
+    }
+    // ---- 状态与计数 ----
+    const counts = {
+        pending: pending.filter((record) => record.status === "pending").length,
+        approved: pending.filter((record) => record.status === "approved").length,
+        rejected: pending.filter((record) => record.status === "rejected").length,
+        approvedUnapplied: timeline.filter((trace) => trace.status === "approved").length,
+    };
+    const hasPolicy = policy.defaultLevel !== undefined ||
+        Object.keys(policy.agents).length > 0 ||
+        Object.keys(policy.workspaces).length > 0;
+    const hasActivity = entries.length > 0 || pending.length > 0;
+    const state = !hasActivity && !hasPolicy ? "not-enabled" : hasActivity ? "active" : "enabled-idle";
+    return {
+        state,
+        levels: levelMap(policy),
+        counts,
+        timeline,
+        trends,
+        jobRuns,
+        notices,
+    };
+}

package/dist/evolve/risk.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 风险分类器与采纳门(trellis-evolve 任务 12.3)。
+ *
+ * 分级由代码按 **kind + target 形态** 数据驱动计算,不采信 editor 自报的
+ * `riskClass`(design D9):
+ *
+ *   - Class A(可逆、零爆炸半径、证据确凿的机器本地单文件修复)—— 仅
+ *     级别 `auto-A` 且 probe 通过时自动采纳,采纳后通知(指明编辑、证据
+ *     与回滚路径);
+ *   - Class B(内容/路由/对外副作用非零)—— 永远需要人对 diff 与证据的
+ *     显式批准,不受级别影响;
+ *   - Class C(受保护目标)—— 已在 12.2 机械校验阶段拒绝,分类器只为
+ *     完备性映射,不可达;
+ *   - 无法分类(未知 kind / target 形态不匹配)→ 一律按 B;
+ *   - 以全局层为目标、仅由单 workspace 证据(或证据层未知)支撑的升格
+ *     编辑 → 一律 B(消费 12.2 的 `needsExplicitApproval` 标记)。
+ *
+ * 分类表的 A 例取自 `docs/self-evolution.md` 的既定设计:"补一个
+ * `${VAR}` 名"(secrets-policy-fix → secrets.policy.yaml)与"修复 doctor
+ * 已报告的 drift"(sync-config-fix → agent 原生 home 配置面);workspace
+ * 配置文件常被 git 跟踪、团队可见,对外副作用非零 → B(与 tasks 14.1
+ * E2E 的"Class B 呈现、带外批准"一致);MCP 路由变更 → B("内容或路由
+ * 编辑")。
+ */
+import type { Level } from "../host/index.js";
+import type { EvidenceLink, Proposal, RiskClass } from "./types.js";
+/** target 形态:规则表的第二维。 */
+export type TargetShape = "any" | "agent-native" | "secrets-policy";
+export interface RiskRule {
+    readonly id: string;
+    /** C 类不进规则表(前置硬排除),表内只有 A/B。 */
+    readonly riskClass: "A" | "B";
+    readonly kind: string;
+    readonly targetShape: TargetShape;
+    readonly note: string;
+}
+/**
+ * 分类表(按序首条命中即用;未命中走兜底 B)。数据驱动:新增形态加行,
+ * 不写分支特例。
+ */
+export declare const RISK_RULES: readonly RiskRule[];
+export interface RiskClassification {
+    readonly riskClass: RiskClass;
+    /** 命中的规则 id,或前置/兜底标识。 */
+    readonly ruleId: string;
+    readonly reason: string;
+    /** 升格降级是否发生(12.2 `needsExplicitApproval` 的消费痕迹)。 */
+    readonly demotedByPromotion: boolean;
+}
+export interface ClassifyOptions {
+    readonly homeDir: string;
+    /**
+     * 12.2 的不自动升格标记;缺省按 `evaluatePromotion` 从提案自身证据层
+     * 重算(同源判定)。
+     */
+    readonly needsExplicitApproval?: boolean;
+}
+/**
+ * 风险分类(kind + target 形态 → A/B/C)。不采信 `proposal.riskClass`
+ * 自报值;C 类目标在 12.2 校验阶段已拒,此处只为完备性映射。
+ */
+export declare function classifyProposalRisk(proposal: Proposal, options: ClassifyOptions): RiskClassification;
+/** 自动采纳的通知负载:指明编辑、证据与回滚路径(spec 场景 1)。 */
+export interface AdoptionNotification {
+    readonly message: string;
+    readonly proposalId: string;
+    readonly editPaths: readonly string[];
+    readonly evidence: readonly EvidenceLink[];
+    readonly rollbackPath: string;
+}
+export type AdoptionDecision = {
+    readonly action: "auto-adopt";
+    readonly riskClass: "A";
+    readonly reason: string;
+    readonly notification: AdoptionNotification;
+} | {
+    readonly action: "await-approval";
+    readonly riskClass: RiskClass;
+    readonly reason: string;
+};
+export interface AdoptionGateInput {
+    readonly level: Level;
+    readonly classification: RiskClassification;
+    /** L1 前闸 verdict 差集可采纳(true = probe 通过)。 */
+    readonly probePassed: boolean;
+    readonly proposal: Proposal;
+    /**
+     * 回滚路径指引;缺省指向标准备份会话语义(12.5 应用时会写入真实会话
+     * 标识,由调用方替换为具体指引)。
+     */
+    readonly rollbackHint?: string;
+}
+export declare const DEFAULT_ROLLBACK_HINT = "trellis rollback --list(\u6807\u51C6\u5907\u4EFD\u4F1A\u8BDD\u5185\u9010\u5B57\u8282\u8FD8\u539F)";
+/**
+ * 应用后用真实备份会话标识重写通知的回滚行(review-fixes ❌5)。决策时
+ * 备份会话尚不存在,回滚行只能是泛化占位;应用拿到真实 runId 后由调用
+ * 方经本函数回填。只重写 `回滚:` 行,其余行不动;格式由 buildNotification
+ * 单点控制。
+ */
+export declare function retargetNotificationRollback(notification: AdoptionNotification, rollbackPath: string): AdoptionNotification;
+/**
+ * 采纳门:A 仅在级别 `auto-A` 且 probe 通过时自动采纳(并产出通知);
+ * B 永远需要显式批准,不受级别影响;C 不可达(校验阶段已拒)防御性按
+ * 待批准收口。probe 未通过或级别低于 `auto-A` 时 Class A 也不自动采纳。
+ */
+export declare function evaluateAdoptionGate(input: AdoptionGateInput): AdoptionDecision;

package/dist/evolve/risk.js

@@ -0,0 +1,224 @@
+/**
+ * 风险分类器与采纳门(trellis-evolve 任务 12.3)。
+ *
+ * 分级由代码按 **kind + target 形态** 数据驱动计算,不采信 editor 自报的
+ * `riskClass`(design D9):
+ *
+ *   - Class A(可逆、零爆炸半径、证据确凿的机器本地单文件修复)—— 仅
+ *     级别 `auto-A` 且 probe 通过时自动采纳,采纳后通知(指明编辑、证据
+ *     与回滚路径);
+ *   - Class B(内容/路由/对外副作用非零)—— 永远需要人对 diff 与证据的
+ *     显式批准,不受级别影响;
+ *   - Class C(受保护目标)—— 已在 12.2 机械校验阶段拒绝,分类器只为
+ *     完备性映射,不可达;
+ *   - 无法分类(未知 kind / target 形态不匹配)→ 一律按 B;
+ *   - 以全局层为目标、仅由单 workspace 证据(或证据层未知)支撑的升格
+ *     编辑 → 一律 B(消费 12.2 的 `needsExplicitApproval` 标记)。
+ *
+ * 分类表的 A 例取自 `docs/self-evolution.md` 的既定设计:"补一个
+ * `${VAR}` 名"(secrets-policy-fix → secrets.policy.yaml)与"修复 doctor
+ * 已报告的 drift"(sync-config-fix → agent 原生 home 配置面);workspace
+ * 配置文件常被 git 跟踪、团队可见,对外副作用非零 → B(与 tasks 14.1
+ * E2E 的"Class B 呈现、带外批准"一致);MCP 路由变更 → B("内容或路由
+ * 编辑")。
+ */
+import { basename, join, relative, resolve, sep } from "node:path";
+import { NATIVE_CHECK_SURFACE } from "../host/index.js";
+import { evaluatePromotion, protectedPathReason } from "./validate.js";
+/**
+ * 分类表(按序首条命中即用;未命中走兜底 B)。数据驱动:新增形态加行,
+ * 不写分支特例。
+ */
+export const RISK_RULES = [
+    // A:可逆、零爆炸半径 —— 机器本地单文件,备份会话内逐字节可回滚。
+    {
+        id: "sync-config-fix/agent-native",
+        riskClass: "A",
+        kind: "sync-config-fix",
+        targetShape: "agent-native",
+        note: "修复 doctor 已报告的投递面 drift:agent 原生 home 配置单文件,零对外半径",
+    },
+    {
+        id: "secrets-policy-fix/secrets-policy",
+        riskClass: "A",
+        kind: "secrets-policy-fix",
+        targetShape: "secrets-policy",
+        note: "策略文件只含变量名/拒绝模式(补 `${VAR}` 名形态),机器本地可回滚",
+    },
+    // B:内容/路由/对外副作用非零。
+    {
+        id: "workspace-config-fix/any",
+        riskClass: "B",
+        kind: "workspace-config-fix",
+        targetShape: "any",
+        note: "workspace 配置常被 git 跟踪(团队可见),对外副作用非零",
+    },
+    {
+        id: "mcp-config-fix/any",
+        riskClass: "B",
+        kind: "mcp-config-fix",
+        targetShape: "any",
+        note: "MCP 路由变更,永远人批",
+    },
+    {
+        id: "oauth-config-fix/any",
+        riskClass: "B",
+        kind: "oauth-config-fix",
+        targetShape: "any",
+        note: "auth 相邻配置,不自动",
+    },
+];
+/** 提案涉及的全部路径(target 描述 + 各编辑路径)。 */
+function pathsOf(proposal) {
+    return [proposal.target, ...proposal.edits.map((edit) => edit.path)];
+}
+/** homeDir 相对路径形态;home 外或非绝对形态返回原始串(走尾缀匹配)。 */
+function relOfHome(path, homeDir) {
+    const abs = resolve(path);
+    const rel = relative(resolve(homeDir), abs);
+    return rel !== "" && (rel === ".." || rel.startsWith(`..${sep}`)) ? path : rel;
+}
+function matchesShape(shape, proposal, homeDir) {
+    if (shape === "any")
+        return true;
+    const rels = pathsOf(proposal).map((path) => relOfHome(path, homeDir));
+    if (shape === "secrets-policy") {
+        const policy = join(".trellis", "secrets.policy.yaml");
+        return rels.some((rel) => rel === policy || basename(rel) === "secrets.policy.yaml");
+    }
+    // agent-native:NATIVE_CHECK_SURFACE 条目(或其内)。
+    return rels.some((rel) => NATIVE_CHECK_SURFACE.some((entry) => rel === entry || rel.startsWith(entry + sep)));
+}
+/**
+ * 风险分类(kind + target 形态 → A/B/C)。不采信 `proposal.riskClass`
+ * 自报值;C 类目标在 12.2 校验阶段已拒,此处只为完备性映射。
+ */
+export function classifyProposalRisk(proposal, options) {
+    // C 前置:target 描述符的 auth 形态 + 受保护路径(与 12.2 同源)。
+    if (/\bauth\b/i.test(proposal.target)) {
+        return {
+            riskClass: "C",
+            ruleId: "protected/auth-descriptor",
+            reason: `提案目标 "${proposal.target}" 为 MCP auth 配置形态(校验阶段已拒)`,
+            demotedByPromotion: false,
+        };
+    }
+    for (const path of pathsOf(proposal)) {
+        const reason = protectedPathReason(path, options.homeDir);
+        if (reason !== null) {
+            return {
+                riskClass: "C",
+                ruleId: "protected/path",
+                reason: `${path}:${reason}(校验阶段已拒)`,
+                demotedByPromotion: false,
+            };
+        }
+    }
+    // 升格降级:全局层目标 + 仅单 workspace 证据(或层未知)→ 一律 B。
+    const needsExplicitApproval = options.needsExplicitApproval ?? evaluatePromotion(proposal).needsExplicitApproval;
+    const demotedByPromotion = needsExplicitApproval && proposal.layer.kind === "global";
+    if (demotedByPromotion) {
+        return {
+            riskClass: "B",
+            ruleId: "promotion-demotion",
+            reason: "全局层升格编辑仅由单 workspace 证据(或证据层未知)支撑,一律按 B 处理",
+            demotedByPromotion: true,
+        };
+    }
+    // 规则表:按序首条命中。
+    for (const rule of RISK_RULES) {
+        if (rule.kind !== proposal.kind)
+            continue;
+        if (!matchesShape(rule.targetShape, proposal, options.homeDir))
+            continue;
+        return {
+            riskClass: rule.riskClass,
+            ruleId: rule.id,
+            reason: rule.note,
+            demotedByPromotion: false,
+        };
+    }
+    // 兜底:未知 kind / 形态不匹配 → 无法分类按 B。
+    return {
+        riskClass: "B",
+        ruleId: "fallback-unclassified",
+        reason: `kind "${proposal.kind}" / target "${proposal.target}" 不匹配任何已知分类规则,无法分类按 B 处理`,
+        demotedByPromotion: false,
+    };
+}
+export const DEFAULT_ROLLBACK_HINT = "trellis rollback --list(标准备份会话内逐字节还原)";
+function describeEvidence(link) {
+    const id = link.kind === "run" ? link.runId : link.kind === "doctor-finding" ? link.findingId : link.signalId;
+    return `${link.kind}:${id}`;
+}
+function buildNotification(input, reason) {
+    const { proposal, classification } = input;
+    const rollbackPath = input.rollbackHint ?? DEFAULT_ROLLBACK_HINT;
+    const editPaths = proposal.edits.map((edit) => edit.path);
+    const message = [
+        `自动采纳 Class A 提案 ${proposal.id}(${classification.ruleId}):${reason}`,
+        `编辑:${editPaths.join(", ")}`,
+        `证据:${proposal.evidence.map(describeEvidence).join("; ")}`,
+        `回滚:${rollbackPath}`,
+    ].join("\n");
+    return { message, proposalId: proposal.id, editPaths, evidence: proposal.evidence, rollbackPath };
+}
+/**
+ * 应用后用真实备份会话标识重写通知的回滚行(review-fixes ❌5)。决策时
+ * 备份会话尚不存在,回滚行只能是泛化占位;应用拿到真实 runId 后由调用
+ * 方经本函数回填。只重写 `回滚:` 行,其余行不动;格式由 buildNotification
+ * 单点控制。
+ */
+export function retargetNotificationRollback(notification, rollbackPath) {
+    const message = notification.message
+        .split("\n")
+        .map((line) => (line.startsWith("回滚:") ? `回滚:${rollbackPath}` : line))
+        .join("\n");
+    return { ...notification, message, rollbackPath };
+}
+/**
+ * 采纳门:A 仅在级别 `auto-A` 且 probe 通过时自动采纳(并产出通知);
+ * B 永远需要显式批准,不受级别影响;C 不可达(校验阶段已拒)防御性按
+ * 待批准收口。probe 未通过或级别低于 `auto-A` 时 Class A 也不自动采纳。
+ */
+export function evaluateAdoptionGate(input) {
+    const { classification, level, probePassed } = input;
+    if (classification.riskClass === "C") {
+        return {
+            action: "await-approval",
+            riskClass: "C",
+            reason: "C 类受保护目标在校验阶段已拒绝,不进入自动采纳",
+        };
+    }
+    if (classification.riskClass === "B") {
+        return {
+            action: "await-approval",
+            riskClass: "B",
+            reason: classification.demotedByPromotion
+                ? `${classification.reason}(不自动采纳,呈现等待显式批准)`
+                : "B 类编辑永远需要人对 diff 与证据的显式批准,不受级别影响",
+        };
+    }
+    // Class A。
+    if (level !== "auto-A") {
+        return {
+            action: "await-approval",
+            riskClass: "A",
+            reason: `级别 "${level}" 低于 auto-A,Class A 也不自动采纳(呈现等待批准)`,
+        };
+    }
+    if (!probePassed) {
+        return {
+            action: "await-approval",
+            riskClass: "A",
+            reason: "probe 未通过(L1 前闸不可采纳),不自动采纳",
+        };
+    }
+    const reason = "级别 auto-A、Class A 且 probe 通过";
+    return {
+        action: "auto-adopt",
+        riskClass: "A",
+        reason,
+        notification: buildNotification(input, reason),
+    };
+}

package/dist/evolve/sources.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 可选信号源探测(trellis-evolve 任务 11.3)。
+ *
+ * agent-bridge 委托记录是可选信号源:缺席是合法状态,SHALL NOT 使运行
+ * 失败——探测返回 `unavailable` 而非抛错,作业评估(11.5)以此继续并把
+ * 状态记录下来。委托记录存储取 Trellis 真实落盘的 agent 间委托(task
+ * store,`~/.trellis/tasks/tasks.json`);委托记录到信号的映射设计未定,
+ * 本期只做源可用性探测,不派生信号内容。
+ */
+export type OptionalSourceStatus = "available" | "unavailable";
+export interface OptionalSourceProbe {
+    readonly source: "agent-bridge";
+    readonly status: OptionalSourceStatus;
+    /** 人类可读的状态说明(写入档案时直接采用)。 */
+    readonly note: string;
+}
+export declare function agentBridgeRecordsPath(homeDir: string): string;
+/** 探测 agent-bridge 委托记录是否可用;永不抛错。 */
+export declare function probeAgentBridgeSource(homeDir: string): OptionalSourceProbe;