feat: 移除 Codex Fast mode 与 AutoReview 后台分析，模型改为配置驱动

移除 pi-extension-codex-fast-mode：
- 删除整个扩展目录；同步清理根 package.json 的 files / pi.extensions /
  dependencies 条目、package-lock.json、tests/extension-load.test.ts 断言
  与文档章节。
- pi-minimal-footer 的 Fast on 渲染是该扩展的唯一消费者。扩展移除后 accent
  分支不再有生产者，collectFooterStatusItems 简化为直接返回非空状态字符串，
  去掉 FooterStatusItem 与 accent 标志，避免留下死代码。

移除 500 次裁决后的后台分析体系：
- 删除 analysis-agent.ts（192 行）与 ledger.ts（296 行），以及对应的
  auto-review-runtime / auto-review-ledger 测试。
- runtime.ts 由 177 行收敛到 85 行：安装选项缩为 { service, config }；删除
  handleAgentSettled 与 agent_settled 注册；保留 session_start / turn_start
  （denial circuit breaker 属安全语义）/ session_shutdown。
- 删除 analysis 配置键：config、extension-config、config-schema、生成的
  permissions.schema.json 与种子配置。
- 删除 reviewer 的 onDecision 回调（唯一消费者是 ledger）。
- 删除迁移机制 scripts/migrate-permission-policy.mjs、其测试与 update.sh 中
  46 行 migrate_permission_policy 接线。种子部署保持“目标缺失才写入”，已存在
  的 policy.jsonc 永不被覆盖。

AutoReview 模型改为纯配置驱动：
- 删除 DEFAULT_PROVIDER / DEFAULT_MODEL 常量与 findCodexTemplate 合成逻辑；
  model.ts 由 65 行收敛到 48 行。
- provider / model 任一缺失时返回新增失败类别 model-unconfigured 并 defer 到
  人工审批；provider 未注册或模型未发布同样 defer。
- reasoning 不再有默认常量，完全由配置决定。
- session_start 在 auto-review 已列入 authorizerChain 且 provider/model 未配齐
  时 ui.notify 提示一次，避免不使用 AutoReview 的用户被打扰。
- 种子 autoReview 只保留 enabled，provider/model/reasoning 由用户按本机实际
  可用的模型填写。

破坏性变更：analysis 键已从 strictObject schema 删除，任何仍带该键的
policy.jsonc 会使整份配置被拒（fail-closed 到全 ask）。这是刻意的变更，已由
config-loader 测试固定，防止将来无声放宽。

测试：
- 新增 auto-review-model.test.ts（7 例），覆盖此前完全缺失的模型解析：真实
  命中、未配置、provider 未知、模型未发布，以及不再合成替代模型。
- 重写 auto-review-runtime.test.ts（6 例）：authorizer 注册、未配置时提示
  一次、已配置 / disabled / 无 UI / 不在 chain 时静默。
- config-loader.test.ts 新增 2 例：带 analysis 的旧配置被拒且 fail-closed、
  autoReview 逐字段合并。
- composition-root.test.ts 的 EXPECTED_HANDLERS 移除 agent_settled。

文档：AGENTS.md、README.md、pi-permission-system 的 README / CHANGELOG /
configuration.md / architecture.md / auto-review UPSTREAM.md。

验证：pi-permission-system 的 typecheck、2577 个测试与 build 全部通过；根 50
个测试通过；schema 重新生成无漂移；新种子通过 schema 校验；5 个脚本 sh -n
通过；git diff --check 无空白问题。未安装 shellcheck；未执行真实 pi install /
update（属外部写操作）。

pi-permission-system/test/auto-review-runtime.test.ts

@@ -1,61 +1,15 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
-import type { ExtensionAPI, ModelRegistry, SessionManager } from "@earendil-works/pi-coding-agent";
-import {
-  DEFAULT_AUTO_REVIEW_ANALYSIS_CONFIG,
-  DEFAULT_AUTO_REVIEW_CONFIG,
-} from "#src/auto-review/config";
-import { AutoReviewLedger } from "#src/auto-review/ledger";
+import type { ExtensionContext, ModelRegistry, SessionManager } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_AUTO_REVIEW_CONFIG, type AutoReviewConfig } from "#src/auto-review/config";
 import { installBuiltinAutoReview } from "#src/auto-review/runtime";
-import { getAnalysisStateDir } from "#src/config-paths";
 import type { ConfigReader } from "#src/config-store";
-import type { PermissionsService, PromptPermissionDetails } from "#src/service";
-import type { ReviewLogger } from "#src/session-logger";
+import type { PermissionsService } from "#src/service";
 
-type AnalysisRunner = NonNullable<
-  Parameters<typeof installBuiltinAutoReview>[0]["runAnalysis"]
->;
-
-const roots: string[] = [];
-
-afterEach(() => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-function seedPending(agentDir: string) {
-  const analysis = { ...DEFAULT_AUTO_REVIEW_ANALYSIS_CONFIG, threshold: 1 };
-  const ledger = new AutoReviewLedger(getAnalysisStateDir(agentDir));
-  ledger.recordDecision({
-    details: {
-      requestId: "request-1",
-      source: "tool",
-      agentName: "main",
-      surface: "bash",
-      toolName: "bash",
-      command: "npm install example",
-    } as unknown as PromptPermissionDetails,
-    assessment: {
-      outcome: "allow",
-      riskLevel: "low",
-      userAuthorization: "high",
-      rationale: "directly authorized",
-    },
-    policyRevision: "policy-a",
-    config: DEFAULT_AUTO_REVIEW_CONFIG,
-    analysis,
-  });
-  return { analysis, ledger };
-}
-
-function harness(agentDir: string, analysis: typeof DEFAULT_AUTO_REVIEW_ANALYSIS_CONFIG, runAnalysis: Parameters<typeof installBuiltinAutoReview>[0]["runAnalysis"]) {
-  const sendMessage = vi.fn();
+function harness(autoReview: AutoReviewConfig, hasUI = true) {
+  const notify = vi.fn();
   const registerAuthorizer = vi.fn(() => () => {});
-  const review = vi.fn();
   const controller = installBuiltinAutoReview({
-    pi: { sendMessage } as unknown as ExtensionAPI,
     service: { registerAuthorizer } as unknown as PermissionsService,
     config: {
       current: () => ({
@@ -63,118 +17,75 @@ function harness(agentDir: string, analysis: typeof DEFAULT_AUTO_REVIEW_ANALYSIS
         permissionReviewLog: true,
         yoloMode: false,
         doublePressToConfirm: true,
-        autoReview: DEFAULT_AUTO_REVIEW_CONFIG,
-        analysis,
+        authorizerChain: ["auto-review"],
+        autoReview,
       }),
     } as ConfigReader,
-    logger: { review } as unknown as ReviewLogger,
-    agentDir,
-    runAnalysis,
   });
-  controller.handleSessionStart({
+  const ctx = {
+    hasUI,
+    ui: { notify },
     modelRegistry: {} as ModelRegistry,
     sessionManager: { getBranch: () => [] } as unknown as Pick<SessionManager, "getBranch">,
-  });
-  return { controller, sendMessage, registerAuthorizer, review };
+  } as unknown as ExtensionContext;
+
+  controller.handleSessionStart(ctx);
+  return { controller, notify, registerAuthorizer };
 }
 
 describe("built-in AutoReview lifecycle", () => {
-  it("analyzes a persisted pending checkpoint at agent_settled and follows up in the same session", async () => {
-    const agentDir = mkdtempSync(join(tmpdir(), "auto-review-runtime-"));
-    roots.push(agentDir);
-    const { analysis } = seedPending(agentDir);
-    const runAnalysis = vi.fn<AnalysisRunner>(async () => ({
-      summary: "No unconditional policy changes recommended.",
-      allowCandidates: [],
-      denyCandidates: [],
-      keepReview: [],
-      hardGuardCandidates: [],
-    }));
-    const { controller, sendMessage, registerAuthorizer } = harness(agentDir, analysis, runAnalysis);
-
-    await controller.handleAgentSettled();
+  it("registers the auto-review authorizer", () => {
+    const { registerAuthorizer } = harness({ ...DEFAULT_AUTO_REVIEW_CONFIG });
 
     expect(registerAuthorizer).toHaveBeenCalledWith("auto-review", expect.any(Function));
-    expect(runAnalysis).toHaveBeenCalledTimes(1);
-    expect(runAnalysis.mock.calls[0]?.[0].batch).toMatchObject({ fromSequence: 1, toSequence: 1 });
-    expect(sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({ customType: "permission-policy-analysis-ready", display: true }),
-      { deliverAs: "followUp", triggerTurn: true },
-    );
-    expect(new AutoReviewLedger(getAnalysisStateDir(agentDir)).hasPendingAnalysis()).toBe(false);
-
-    await controller.handleAgentSettled();
-    expect(runAnalysis).toHaveBeenCalledTimes(1);
   });
 
-  it("keeps the checkpoint pending when background analysis fails", async () => {
-    const agentDir = mkdtempSync(join(tmpdir(), "auto-review-runtime-"));
-    roots.push(agentDir);
-    const { analysis } = seedPending(agentDir);
-    const runAnalysis = vi.fn<AnalysisRunner>(async () => {
-      throw new Error("analysis unavailable");
+  it("warns once at session start when provider and model are unset", () => {
+    const { notify } = harness({ ...DEFAULT_AUTO_REVIEW_CONFIG });
+
+    expect(notify).toHaveBeenCalledTimes(1);
+    expect(notify.mock.calls[0]?.[1]).toBe("warning");
+    expect(notify.mock.calls[0]?.[0]).toMatch(/provider.*model/iu);
+  });
+
+  it("stays silent when both provider and model are configured", () => {
+    const { notify } = harness({ ...DEFAULT_AUTO_REVIEW_CONFIG, provider: "vendor", model: "m" });
+
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  it("stays silent when AutoReview is disabled", () => {
+    const { notify } = harness({ ...DEFAULT_AUTO_REVIEW_CONFIG, enabled: false });
+
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  it("does not notify without a UI", () => {
+    const { notify } = harness({ ...DEFAULT_AUTO_REVIEW_CONFIG }, false);
+
+    expect(notify).not.toHaveBeenCalled();
+  });
+
+  it("stays silent when auto-review is not in the authorizer chain", () => {
+    const notify = vi.fn();
+    const controller = installBuiltinAutoReview({
+      service: { registerAuthorizer: vi.fn(() => () => {}) } as unknown as PermissionsService,
+      config: {
+        current: () => ({
+          debugLog: false,
+          permissionReviewLog: true,
+          yoloMode: false,
+          doublePressToConfirm: true,
+          authorizerChain: [],
+          autoReview: { ...DEFAULT_AUTO_REVIEW_CONFIG },
+        }),
+      } as ConfigReader,
     });
-    const { controller, sendMessage, review } = harness(agentDir, analysis, runAnalysis);
-
-    await controller.handleAgentSettled();
-
-    expect(sendMessage).not.toHaveBeenCalled();
-    expect(review).toHaveBeenCalledWith("auto_review.analysis_failed", { error: "analysis unavailable" });
-    expect(new AutoReviewLedger(getAnalysisStateDir(agentDir)).hasPendingAnalysis()).toBe(true);
-  });
-
-  it("discards a stale result after session replacement without advancing the checkpoint", async () => {
-    const agentDir = mkdtempSync(join(tmpdir(), "auto-review-runtime-"));
-    roots.push(agentDir);
-    const { analysis } = seedPending(agentDir);
-    let resolveAnalysis!: (proposal: Awaited<ReturnType<AnalysisRunner>>) => void;
-    const runAnalysis = vi.fn<AnalysisRunner>(() => new Promise((resolve) => {
-      resolveAnalysis = resolve;
-    }));
-    const { controller, sendMessage, review } = harness(agentDir, analysis, runAnalysis);
-
-    const pending = controller.handleAgentSettled();
-    expect(runAnalysis).toHaveBeenCalledTimes(1);
-    controller.handleSessionShutdown();
     controller.handleSessionStart({
-      modelRegistry: {} as ModelRegistry,
-      sessionManager: { getBranch: () => [] } as unknown as Pick<SessionManager, "getBranch">,
-    });
-    resolveAnalysis({
-      summary: "stale proposal",
-      allowCandidates: [],
-      denyCandidates: [],
-      keepReview: [],
-      hardGuardCandidates: [],
-    });
-    await pending;
+      hasUI: true,
+      ui: { notify },
+    } as unknown as ExtensionContext);
 
-    expect(sendMessage).not.toHaveBeenCalled();
-    expect(review).not.toHaveBeenCalledWith("auto_review.analysis_completed", expect.anything());
-    expect(new AutoReviewLedger(getAnalysisStateDir(agentDir)).hasPendingAnalysis()).toBe(true);
-  });
-
-  it("does not advance the checkpoint when same-session delivery fails", async () => {
-    const agentDir = mkdtempSync(join(tmpdir(), "auto-review-runtime-"));
-    roots.push(agentDir);
-    const { analysis } = seedPending(agentDir);
-    const runAnalysis = vi.fn<AnalysisRunner>(async () => ({
-      summary: "proposal",
-      allowCandidates: [],
-      denyCandidates: [],
-      keepReview: [],
-      hardGuardCandidates: [],
-    }));
-    const { controller, sendMessage, review } = harness(agentDir, analysis, runAnalysis);
-    sendMessage.mockImplementation(() => {
-      throw new Error("session delivery unavailable");
-    });
-
-    await controller.handleAgentSettled();
-
-    expect(review).toHaveBeenCalledWith("auto_review.analysis_failed", {
-      error: "session delivery unavailable",
-    });
-    expect(new AutoReviewLedger(getAnalysisStateDir(agentDir)).hasPendingAnalysis()).toBe(true);
+    expect(notify).not.toHaveBeenCalled();
   });
 });