refactor(shared): 「該用哪些資源」搬出 CLI——一份實作，acr 與安裝器吃同一條規則

leo 2026-08-12：「根本就不應該在 CLI，我要的是一個大家都可以用到的規則。」「這個實例該用哪些資源」換到安裝器就要重寫一次 ⇒ 依 rules/07-thin-shell.md 的判準它是**能力**，而它原本住在 cli/src/lib/resource-resolver.ts ⇒ 那本身就是違規。後果已經真的發生：acr 那條有 Arcrun#97 的修法、安裝器那條沒有，於是安裝器照名字找、找不到就建一顆空的綁上去 ⇒「我按了更新，工作流和登入全不見了」。規則搬到 shared/resource-rule/（零依賴 ESM，Node 與 Workers runtime 都直接跑）： · rule.mjs 規則本體＋把 CF 回應讀成事實的 normalizeLive* · cf-resource-api.mjs ResourceApi 的 CF REST 實作——**眼睛也共用**：兩條路各自解讀 CF 回應，只要一邊看不到既有綁定就會去新建， #97 不需要規則寫錯就能重演 · installer-entry.mjs 安裝器唯一該碰的入口 resolveInstanceResources() 不是做成 cypher 端點的理由（自舉）：這條規則要在「決定怎麼裝」的當下就用得到，而那時 cypher 可能還不存在（安裝器的工作正是把它生出來）；且輸入是使用者自己帳號的綁定狀態，不該送去平台換答案。它是純函式，用不著變成服務。只有一份，機械看守： · 安裝器直接 import repo archive 裡的原稿，**不需要副本** · acr 因為 npm pack 打不進套件目錄外的檔案，帶一份逐位元組鏡射（scripts/sync-resource-rule.mjs 產生；build/test 先跑 --check，差一位元組就紅） ——同 cli/harness/ 產生物＋世代閘的既有慣例 · cli/tests/single-implementation.test.ts 掃全 repo：7 支規則函式的實作只有一處 CLI 淨 -496 行（邏輯是搬走，不是複製）。cf-api.ts 的 CfAccountClient 保留公開介面， ResourceApi 那七個方法全部委派共用 client。驗證：cli 58/58 綠（含新增的兩條路一致性 fixture ＋三種情境），tsc --noEmit 乾淨。
chore(builds): 重編成品——把 #107 的版本標籤修法放進執行檔
2026-08-12 23:37:01 +08:00 · 2026-08-12 22:22:57 +08:00 · 2026-08-12 14:05:57 +00:00 · 2026-08-12 21:58:43 +08:00 · 2026-08-12 21:10:12 +08:00 · 2026-08-12 20:03:30 +08:00
32 changed files with 3843 additions and 744 deletions
@@ -52,6 +52,14 @@ scripts/__pycache__/
 # D1 備份/匯出（wrangler d1 export 產物，含整庫全量資料=機敏，絕不 commit）
 *.sql
 backup-*.sql
+# 🔴 但 migration 不是備份，它是**要出貨的程式碼**（2026-08-12 實撞）：
+#    上面那條 `*.sql` 的用意是擋 D1 匯出（整庫全量資料＝機敏），卻連 migration 一起吃掉。
+#    後果：0001-0004 因為在該規則之前就 commit 所以還在，**0005/0006 從此沒進過版控**
+#    ⇒ 更新指令從 Gitea 抓 main，那兩個檔根本不在那裡 ⇒ 每個用戶都會收到
+#      「✗ D1 migration: 部署物缺 kbdb/migrations/0005…」——**不是誰忘了推，是規則吃掉的**。
+#    ⇒ 與 `.component-builds/**/component.wasm` 同慣例（見 rules/05-deploy-convention.md
+#      「WASM 來源」段），用否定規則放行。備份檔仍由 `backup-*.sql` 與目錄位置擋住。
+!kbdb/migrations/*.sql

 # GitHub 公開 mirror 工作目錄(publish-github.sh 產物)
 .github-public/
@@ -9341,9 +9341,11 @@ function authStoreStatus(env) {
 var healthRouter = new Hono2();
 healthRouter.get("/health", (c) => {
  const bundleVersion = c.env.ARCRUN_BUNDLE_VERSION;
+  const bundleCommit = c.env.ARCRUN_BUNDLE_COMMIT;
  return c.json({
    ok: true,
    ...bundleVersion ? { bundle_version: bundleVersion } : {},
+    ...bundleCommit ? { bundle_commit: bundleCommit } : {},
    auth_store: authStoreStatus(c.env),
    // arcrun-rag#38/#69/#25（2026-08-11）：安裝器判斷「要不要重推」只比 bundle_version——
    // 但這次要修的洞是「installer 從沒注入過 PORTAL_MAIL_RELAY_BASE」，跟 bundle 內容
@@ -13285,7 +13287,12 @@ portalRouter.post(
      session_token: token,
      display_name: rec.values.display_name ?? "",
      role: rec.values.role ?? "user",
-      libraries: parseLibraries(rec.values.libraries)
+      libraries: parseLibraries(rec.values.libraries),
+      // session 還能活多久（秒）。**非機密**（是這台實例的 TTL 設定，不是任何人的憑據），
+      // 但呼叫端需要它才能把自己發的憑證對齊這個上限——arcrun-mcp 用它把 OAuth
+      // access_token 的 TTL 夾到 min(自己的 TTL, 這個值)：否則 MCP token 活 30 天、
+      // 底下的 portal session 7 天就死，使用者會在第 8 天遇到「連著卻查不到」的鬼打牆。
+      session_expires_in: sessionTtl(c.env)
      // 絕不回租戶字串（design §3.3：portal_user 拿到租戶字串就能繞過庫 filter 直打 /kbdb/*）
    });
  })
@@ -15363,6 +15370,151 @@ portalDataRouter.get(
    return c.json({ success: true, workflows, total: workflows.length, read_only: true });
  })
 );
+function recordLibrary(values) {
+  const lib = values?.library;
+  return typeof lib === "string" && lib.trim() ? lib.trim() : null;
+}
+function canReadRecord(rec, tenant2, libraries) {
+  if ((rec.owner_id ?? "") !== tenant2) return false;
+  const lib = recordLibrary(rec.values);
+  return lib === null || canReadLibrary(libraries, lib);
+}
+portalDataRouter.get(
+  "/portal/data/map",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const libraries = parseLibraries(auth.user.values.libraries);
+    if (libraries.length === 0) {
+      return c.json({ success: true, libraries: [], count: 0, note: "\u6B64\u5E33\u865F\u5C1A\u672A\u88AB\u6388\u6B0A\u4EFB\u4F55\u77E5\u8B58\u5EAB\uFF0C\u8ACB\u806F\u7D61\u7BA1\u7406\u54E1\u3002" });
+    }
+    const res = await kbdbFetch(c.env, `/map?owner_id=${encodeURIComponent(portalTenant(c.env))}`);
+    if (!res.ok) {
+      return new Response(res.body, { status: res.status, headers: { "Content-Type": "application/json" } });
+    }
+    const body = await res.json().catch(() => null);
+    if (!body || !Array.isArray(body.libraries)) {
+      return c.json({ error: "\u85CF\u66F8\u5730\u5716\u8B80\u53D6\u5931\u6557\uFF1AKBDB \u56DE\u61C9\u4E0D\u662F\u9810\u671F\u7684 libraries \u6E05\u55AE" }, 502);
+    }
+    const allowed = body.libraries.filter(
+      (l) => typeof l?.library === "string" && canReadLibrary(libraries, l.library)
+    );
+    return c.json({ success: true, libraries: allowed, count: allowed.length });
+  })
+);
+portalDataRouter.get(
+  "/portal/data/map/:library",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const libraries = parseLibraries(auth.user.values.libraries);
+    const library = c.req.param("library");
+    if (!canReadLibrary(libraries, library)) return notFound(c);
+    const res = await kbdbFetch(
+      c.env,
+      `/map/${encodeURIComponent(library)}?owner_id=${encodeURIComponent(portalTenant(c.env))}`
+    );
+    if (res.status === 404) return notFound(c);
+    if (!res.ok) return c.json({ error: `KBDB \u56DE\u932F\uFF08HTTP ${res.status}\uFF09` }, 502);
+    return new Response(res.body, { status: 200, headers: { "Content-Type": "application/json" } });
+  })
+);
+portalDataRouter.get(
+  "/portal/data/templates",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const res = await kbdbFetch(c.env, "/templates");
+    if (!res.ok) return c.json({ error: `KBDB \u56DE\u932F\uFF08HTTP ${res.status}\uFF09` }, 502);
+    return new Response(res.body, { status: 200, headers: { "Content-Type": "application/json" } });
+  })
+);
+portalDataRouter.post(
+  "/portal/data/templates",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.name !== "string" || !body.name.trim() || !Array.isArray(body.slots)) {
+      return c.json({ error: "name \u8207 slots[] \u5FC5\u586B" }, 400);
+    }
+    const res = await kbdbFetch(c.env, "/templates", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: body.name,
+        slots: body.slots,
+        description: typeof body.description === "string" ? body.description : void 0,
+        created_by: portalTenant(c.env)
+      })
+    });
+    return new Response(res.body, { status: res.status, headers: { "Content-Type": "application/json" } });
+  })
+);
+portalDataRouter.get(
+  "/portal/data/records/by-template/:template",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const libraries = parseLibraries(auth.user.values.libraries);
+    if (libraries.length === 0) return c.json({ success: true, records: [], count: 0 });
+    const tenant2 = portalTenant(c.env);
+    const res = await kbdbFetch(
+      c.env,
+      `/records/by-template/${encodeURIComponent(c.req.param("template"))}?owner_id=${encodeURIComponent(tenant2)}`
+    );
+    if (!res.ok) return c.json({ error: `KBDB \u56DE\u932F\uFF08HTTP ${res.status}\uFF09` }, 502);
+    const body = await res.json().catch(() => null);
+    if (!body || !Array.isArray(body.records)) {
+      return c.json({ error: "record \u8B80\u53D6\u5931\u6557\uFF1AKBDB \u56DE\u61C9\u4E0D\u662F\u9810\u671F\u7684 records \u6E05\u55AE" }, 502);
+    }
+    const records = body.records.filter((r) => canReadRecord(r, tenant2, libraries));
+    return c.json({ success: true, records, count: records.length });
+  })
+);
+portalDataRouter.get(
+  "/portal/data/records/:recordId",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const libraries = parseLibraries(auth.user.values.libraries);
+    if (libraries.length === 0) return notFound(c);
+    const res = await kbdbFetch(c.env, `/records/${encodeURIComponent(c.req.param("recordId"))}`);
+    if (res.status === 404) return notFound(c);
+    if (!res.ok) return c.json({ error: `KBDB \u56DE\u932F\uFF08HTTP ${res.status}\uFF09` }, 502);
+    const body = await res.json().catch(() => null);
+    const record = body?.record;
+    if (!record) return notFound(c);
+    if (!canReadRecord(record, portalTenant(c.env), libraries)) return notFound(c);
+    return c.json({ success: true, record });
+  })
+);
+portalDataRouter.post(
+  "/portal/data/records",
+  (c) => run(c, async () => {
+    const auth = await requirePortalUser(c);
+    if (!auth.ok) return auth.res;
+    const libraries = parseLibraries(auth.user.values.libraries);
+    if (libraries.length === 0) {
+      return c.json({ error: "\u6B64\u5E33\u865F\u5C1A\u672A\u88AB\u6388\u6B0A\u4EFB\u4F55\u77E5\u8B58\u5EAB\uFF0C\u7121\u6CD5\u5BEB\u5165" }, 403);
+    }
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.template !== "string" || !body.template.trim() || !body.values || typeof body.values !== "object") {
+      return c.json({ error: "template \u8207 values \u5FC5\u586B" }, 400);
+    }
+    const values = body.values;
+    const targetLib = recordLibrary(values);
+    if (targetLib !== null && !canReadLibrary(libraries, targetLib)) {
+      return c.json({ error: `\u7121\u300C${targetLib}\u300D\u5EAB\u7684\u6B0A\u9650\uFF0C\u4E0D\u80FD\u5BEB\u5165\u8A72\u5EAB` }, 403);
+    }
+    const res = await kbdbFetch(c.env, "/records", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ template: body.template, values, owner_id: portalTenant(c.env) })
+    });
+    return new Response(res.body, { status: res.status, headers: { "Content-Type": "application/json" } });
+  })
+);
 portalDataRouter.get(
  "/portal/data/diagnostics",
  (c) => run(c, async () => {
@@ -3281,7 +3281,7 @@ async function createRecord(db, input) {
    });
    await db.prepare(`INSERT INTO entry_values (id, record_id, template_id, slot_name, entry_id) VALUES (?, ?, ?, ?, ?)`).bind(uid2("ev"), recordId, tpl.id, slot, entry.id).run();
  }
-  return { record_id: recordId, template_id: tpl.id, values: input.values };
+  return { record_id: recordId, template_id: tpl.id, values: input.values, owner_id: input.owner_id ?? null };
 }
 async function updateRecord(db, recordId, values) {
  const evRes = await db.prepare(
@@ -3312,7 +3312,7 @@ async function updateRecord(db, recordId, values) {
 }
 async function getRecord(db, recordId) {
  const res = await db.prepare(
-    `SELECT ev.slot_name as slot, e.content as content, ev.template_id as template_id
+    `SELECT ev.slot_name as slot, e.content as content, ev.template_id as template_id, e.owner_id as owner_id
       FROM entry_values ev JOIN entries e ON ev.entry_id = e.id
       WHERE ev.record_id = ?`
  ).bind(recordId).all();
@@ -3320,7 +3320,8 @@ async function getRecord(db, recordId) {
  if (rows.length === 0) return null;
  const values = {};
  for (const r of rows) values[r.slot] = r.content;
-  return { record_id: recordId, template_id: rows[0].template_id, values };
+  const owner_id = rows.find((r) => r.owner_id != null)?.owner_id ?? null;
+  return { record_id: recordId, template_id: rows[0].template_id, values, owner_id };
 }
 async function searchByTemplate(db, template, owner_id, limit = 100) {
  const tpl = await getTemplate(db, template);
@@ -3339,17 +3340,18 @@ async function searchByTemplate(db, template, owner_id, limit = 100) {
    const chunk = ids.slice(i, i + 90);
    const placeholders = chunk.map(() => "?").join(",");
    const evRes = await db.prepare(
-      `SELECT ev.record_id as record_id, ev.slot_name as slot, e.content as content, ev.template_id as template_id
+      `SELECT ev.record_id as record_id, ev.slot_name as slot, e.content as content, ev.template_id as template_id, e.owner_id as owner_id
         FROM entry_values ev JOIN entries e ON ev.entry_id = e.id
         WHERE ev.record_id IN (${placeholders})`
    ).bind(...chunk).all();
    for (const r of evRes.results ?? []) {
      let rec = byId.get(r.record_id);
      if (!rec) {
-        rec = { record_id: r.record_id, template_id: r.template_id, values: {} };
+        rec = { record_id: r.record_id, template_id: r.template_id, values: {}, owner_id: null };
        byId.set(r.record_id, rec);
      }
      rec.values[r.slot] = r.content;
+      if (rec.owner_id == null && r.owner_id != null) rec.owner_id = r.owner_id;
    }
  }
  return ids.map((id) => byId.get(id)).filter((r) => !!r);
@@ -1,18 +1,18 @@
 {
  "schema": 1,
  "built_for": "arcrun-tier2-worker-artifacts",
-  "generated_at": "2026-08-12T07:29:58.626Z",
-  "repo_head": "1791ffa4972b4135dacd4208e805f67b747479c4",
+  "generated_at": "2026-08-12T14:22:56.880Z",
+  "repo_head": "21293568d550ab7ef50cec2020165d8bf4376104",
  "repo_dirty": false,
  "workers": [
    {
      "name": "arcrun-cypher-executor",
      "source_dir": "cypher-executor",
-      "source_commit": "f1370e2275eea62b64a88821a096f2c2cfe76fb0",
+      "source_commit": "53b05c6d3d4a5a02661880dd5565fa9feb743bb6",
      "main_module": "worker.mjs",
      "main_file": "arcrun-cypher-executor/worker.mjs",
-      "js_bytes": 577374,
-      "content_sha256": "8411ed59b7ad9e1a74ac0d8e3b620d7166e7d0178ac5939e6cc736f2e8d1d2be",
+      "js_bytes": 584721,
+      "content_sha256": "b7c810d7654c05d197abe9a37acce2ed5f77e1af09595d5b4316b69166edf11a",
      "modules": [],
      "compat_date": "2025-02-19",
      "compat_flags": [
@@ -58,11 +58,11 @@
    {
      "name": "arcrun-kbdb",
      "source_dir": "kbdb",
-      "source_commit": "c497ec418eba6cd94b1d5872671c51fd5812c11c",
+      "source_commit": "f87d0e92f49690253e7c89c5badc82a08eb5d21b",
      "main_module": "worker.mjs",
      "main_file": "arcrun-kbdb/worker.mjs",
-      "js_bytes": 149533,
-      "content_sha256": "ffb8d43467d0cefbd7545fdc0d347f2b965e3c3de20b3315eed7613f20266891",
+      "js_bytes": 149797,
+      "content_sha256": "8b23853cbc88aee0ca15ef20ca46e92bd8e75064cd311af2847f4d51811960b1",
      "modules": [],
      "compat_date": "2025-02-19",
      "compat_flags": [
@@ -148,11 +148,11 @@
    {
      "name": "arcrun-mcp",
      "source_dir": "mcp",
-      "source_commit": "035e8b255b0dcbd4238707f7d2ac8ccf9ee1ba72",
+      "source_commit": "10d150ac2b4385af95a457f3c411430c4a146cf9",
      "main_module": "worker.mjs",
      "main_file": "arcrun-mcp/worker.mjs",
-      "js_bytes": 1165388,
-      "content_sha256": "c5ff10f9b9d5a77217be343af12d2be3ee8f9792d3e1e091e48e5e6c8d24ca9d",
+      "js_bytes": 1179487,
+      "content_sha256": "1cd4c4d079d72bf7cba7c490ba6a88476f70b3ea51af7e5c93f9a184ae3c0ce6",
      "modules": [],
      "compat_date": "2024-11-27",
      "compat_flags": [
@@ -8,11 +8,12 @@
  "main": "./dist/index.js",
  "type": "module",
  "scripts": {
-    "build": "npm run build:harness && npm run check:harness && tsc",
+    "build": "npm run build:harness && npm run check:harness && npm run check:rule && tsc",
    "build:harness": "node scripts/build-harness-skill.mjs",
    "check:harness": "node scripts/check-harness-generation.mjs",
+    "check:rule": "node ../scripts/sync-resource-rule.mjs --check",
    "dev": "tsc --watch",
-    "test": "node --test \"tests/**/*.test.ts\"",
+    "test": "npm run check:rule && node --experimental-transform-types --import ./tests/register-ts-hooks.mjs --test \"tests/**/*.test.ts\"",
    "prepublishOnly": "npm run build && chmod +x dist/index.js"
  },
  "dependencies": {
@@ -3,7 +3,8 @@
 * 使用 CF REST API 直接存取用戶的 KV namespace，不依賴 Wrangler CLI
 */

-import type { LiveBinding, ResourceApi, ScriptBindings } from './resource-resolver.js';
+import { createCloudflareResourceApi } from './resource-rule/cf-resource-api.mjs';
+import type { ResourceApi, ScriptBindings } from './resource-resolver.js';

 const CF_API_BASE = 'https://api.cloudflare.com/client/v4';

@@ -86,170 +87,81 @@ export class CfKvClient {
 * 對應 SDD：.agents/specs/arcrun/sdk-and-website/self-hosted-init.md §3 step 1-2
 */
 export class CfAccountClient implements ResourceApi {
-  private accountBase: string;
-  private headers: Record<string, string>;
+  /**
+   * `ResourceApi` 的七個方法**全部委派**給共用規則附的那支 client
+   * （`shared/resource-rule/cf-resource-api.mjs`）。
+   *
+   * 🔴 為什麼不是在這裡自己實作一份：判斷一致還不夠，**看到的東西**也要一致。
+   *   兩條路各自寫一份 CF client，只要有一邊把 404 當錯誤、漏了 per_page、少認一種
+   *   欄位名，那一邊就會「看不到既有綁定」——而看不到既有綁定的下一步，依規則就是新建。
+   *   Arcrun#97 不需要規則寫錯，眼睛不一樣就足以重演。
+   */
+  private readonly rule: ReturnType<typeof createCloudflareResourceApi>;

  constructor(accountId: string, apiToken: string) {
-    this.accountBase = `${CF_API_BASE}/accounts/${accountId}`;
-    this.headers = {
-      'Authorization': `Bearer ${apiToken}`,
-      'Content-Type': 'application/json',
-    };
+    this.rule = createCloudflareResourceApi({ accountId, apiToken });
  }

  private async cf<T>(path: string, init?: RequestInit): Promise<T> {
-    const { ok, status, result, error } = await this.cfRaw<T>(path, init);
+    const { ok, status, result, error } = await this.rule.cfRaw(path, init);
    if (!ok) throw new Error(`CF API ${path} 失敗：${error ?? `HTTP ${status}`}`);
    return result as T;
  }

-  /** 同 cf()，但把 HTTP status 交回呼叫端自己判斷（要區分「404 不存在」和「其他錯誤」時用）。 */
-  private async cfRaw<T>(
-    path: string,
-    init?: RequestInit,
-  ): Promise<{ ok: boolean; status: number; result?: T; error?: string }> {
-    const res = await fetch(`${this.accountBase}${path}`, {
-      ...init,
-      headers: { ...this.headers, ...(init?.headers ?? {}) },
-    });
-    const data = await res.json().catch(() => null) as
-      | { success: boolean; result: T; errors?: Array<{ message: string }> }
-      | null;
-    if (!res.ok || !data?.success) {
-      return {
-        ok: false,
-        status: res.status,
-        error: data?.errors?.map(e => e.message).filter(Boolean).join('; ') || `HTTP ${res.status}`,
-      };
-    }
-    return { ok: true, status: res.status, result: data.result };
-  }
-
  /** 驗證 token 能存取此 account（權限不足會在後續建立操作報錯，這裡先確認 account 可達）。*/
  async verifyAccess(): Promise<void> {
    // GET /accounts/{id} 能通 = token 有此 account 的基本讀權限
    await this.cf<{ id: string; name: string }>('');
  }

-  /** 列出現有 KV namespace（冪等用：已存在就重用，不重建）。回傳 title → id 對照。*/
-  async listKvNamespaces(): Promise<Map<string, string>> {
-    const result = await this.cf<Array<{ id: string; title: string }>>(
-      '/storage/kv/namespaces?per_page=100',
-    );
-    const map = new Map<string, string>();
-    for (const ns of result) map.set(ns.title, ns.id);
-    return map;
-  }
-
-  /**
-   * 無條件新建一顆 KV namespace。
-   *
-   * 🔴 Arcrun#97：這裡**故意沒有**「找不到同名就順手建一顆」的 ensure 版本。
-   * 「照名字找 → 找不到 → 新建 → 綁上去」正是把使用者實例洗成空的那條路
-   * （安裝器取的名字跟我們的 binding 名不一樣，永遠對不上 ⇒ 每次更新都新建）。
-   * 要不要建，一律先經過 resource-resolver 的 planResources 判斷；那裡只有在
-   * 「確定沒有任何已部署的 worker 綁過這個 binding」時才會排進 create。
-   */
-  async createKvNamespace(title: string): Promise<string> {
-    const result = await this.cf<{ id: string; title: string }>(
-      '/storage/kv/namespaces',
-      { method: 'POST', body: JSON.stringify({ title }) },
-    );
-    return result.id;
-  }
-
-  /**
-   * 讀一顆已部署 worker 現在綁著哪些資源——**使用者那側的事實**（Arcrun#97 的唯一真相源）。
-   * CF：`GET /accounts/{id}/workers/scripts/{script}/settings` → `result.bindings[]`。
-   *
-   * - script 不存在（404）→ `{ deployed: false }`，這是「還沒部署」，不是錯誤。
-   * - 其他任何失敗 → throw。呼叫端必須把它當「我不知道」而**不是**「它沒有」——
-   *   把查不到當成不存在，就是 #97 的根因。
-   */
-  async getScriptBindings(script: string): Promise<ScriptBindings> {
-    const path = `/workers/scripts/${encodeURIComponent(script)}/settings`;
-    const res = await this.cfRaw<{ bindings?: RawWorkerBinding[] }>(path);
-    if (!res.ok) {
-      if (res.status === 404) return { deployed: false, bindings: [] };
-      throw new Error(`讀 ${script} 綁定失敗：${res.error}`);
-    }
-    return { deployed: true, bindings: normalizeBindings(res.result?.bindings ?? []) };
-  }
-
  /** 查 workers.dev subdomain（cypher-executor WORKER_SUBDOMAIN 用，組對內 component URL）。*/
  async getWorkersSubdomain(): Promise<string> {
    const result = await this.cf<{ subdomain: string }>('/workers/subdomain');
    return result.subdomain;
  }

-  // D1 (KBDB Base). Free on Workers Free plan, no credit card (kbdb-base Q4 verified).
-  async listD1Databases(): Promise<Map<string, string>> {
-    const result = await this.cf<Array<{ uuid: string; name: string }>>('/d1/database?per_page=100');
-    const map = new Map<string, string>();
-    for (const db of result) map.set(db.name, db.uuid);
-    return map;
+  // ── 以下七支＝`ResourceApi`，一律委派共用規則，**這個檔案不得自己實作** ────────────
+  //    （`shared/resource-rule/cf-resource-api.mjs`；委派而非複製的理由見本 class 開頭）
+
+  /** 讀一顆已部署 worker 現在綁著哪些資源——使用者那側的事實（Arcrun#97 的唯一真相源）。 */
+  getScriptBindings(script: string): Promise<ScriptBindings> {
+    return this.rule.getScriptBindings(script);
  }

-  /** 無條件新建 D1。沒有 ensure 版本，理由同 createKvNamespace（Arcrun#97）。 */
-  async createD1Database(name: string): Promise<string> {
-    const result = await this.cf<{ uuid: string; name: string }>(
-      '/d1/database',
-      { method: 'POST', body: JSON.stringify({ name }) },
-    );
-    return result.uuid;
+  /** 帳號上現有的 KV namespace（title → id）。判斷「綁著的那顆還在不在」用。 */
+  listKvNamespaces(): Promise<Map<string, string>> {
+    return this.rule.listKvNamespaces();
  }

-  /** 帳號上現有的 Vectorize index 名單（判斷「綁著的那顆還在不在」用）。 */
-  async listVectorizeIndexes(): Promise<string[]> {
-    const result = await this.cf<Array<{ name: string }>>('/vectorize/v2/indexes');
-    return (result ?? []).map(i => i.name);
+  /** 帳號上現有的 D1（name → uuid）。 */
+  listD1Databases(): Promise<Map<string, string>> {
+    return this.rule.listD1Databases();
+  }
+
+  /** 帳號上現有的 Vectorize index 名單。 */
+  listVectorizeIndexes(): Promise<string[]> {
+    return this.rule.listVectorizeIndexes();
  }

  /**
-   * 新建 KBDB embed 用的 Vectorize index（**bge-m3 = 1024 維 / cosine**，見 deploy.ts 常數說明）。
-   * 已存在（409 / already exists）視為成功——並行或重跑不該炸。沒有 ensure 版本：
-   * 「要不要建」由 planResources 判斷，這裡只負責建（Arcrun#97）。
+   * 無條件新建一顆 KV namespace。
+   *
+   * 🔴 Arcrun#97：**故意沒有**「找不到同名就順手建一顆」的 ensure 版本。
+   * 「照名字找 → 找不到 → 新建 → 綁上去」正是把使用者實例洗成空的那條路。
+   * 要不要建，一律先經過 planResources；那裡只有在「確定沒有任何已部署的 worker
+   * 綁過這個 binding」時才會排進 create。
   */
-  async createVectorizeIndex(name: string): Promise<string> {
-    const res = await this.cfRaw<{ name: string }>('/vectorize/v2/indexes', {
-      method: 'POST',
-      body: JSON.stringify({
-        name,
-        config: { dimensions: 1024, metric: 'cosine' },
-        description: 'arcrun KBDB embed module — bge-m3 1024d (issue #7 / #59)',
-      }),
-    });
-    if (res.ok) return name;
-    const detail = (res.error ?? '').toLowerCase();
-    if (res.status === 409 || /already exists|duplicate|conflict/.test(detail)) return name;
-    throw new Error(`建 Vectorize index ${name} 失敗：${res.error}`);
+  createKvNamespace(title: string): Promise<string> {
+    return this.rule.createKvNamespace(title);
+  }
+
+  /** 無條件新建 D1。沒有 ensure 版本，理由同 createKvNamespace（Arcrun#97）。 */
+  createD1Database(name: string): Promise<string> {
+    return this.rule.createD1Database(name);
+  }
+
+  /** 新建 KBDB embed 用的 Vectorize index。沒有 ensure 版本，理由同上（Arcrun#97）。 */
+  createVectorizeIndex(name: string): Promise<string> {
+    return this.rule.createVectorizeIndex(name);
  }
 }
-
-/** CF `/settings` 回的 binding 原始形狀（同一種資源在不同 API 版本欄位名不一，故全都收）。 */
-interface RawWorkerBinding {
-  type?: string;
-  name?: string;
-  namespace_id?: string;
-  id?: string;
-  database_id?: string;
-  index_name?: string;
-}
-
-/** 把 CF 的 binding 陣列收斂成 resolver 認得的三種資源。不認得的型別直接略過。 */
-function normalizeBindings(raw: RawWorkerBinding[]): LiveBinding[] {
-  const out: LiveBinding[] = [];
-  for (const b of raw) {
-    if (!b?.name) continue;
-    if (b.type === 'kv_namespace') {
-      const value = b.namespace_id ?? b.id;
-      if (value) out.push({ kind: 'kv_namespace', binding: b.name, value });
-    } else if (b.type === 'd1' || b.type === 'd1_database') {
-      const value = b.id ?? b.database_id;
-      if (value) out.push({ kind: 'd1', binding: b.name, value });
-    } else if (b.type === 'vectorize') {
-      if (b.index_name) out.push({ kind: 'vectorize', binding: b.name, value: b.index_name });
-    }
-  }
-  return out;
-}
@@ -98,6 +98,119 @@ function giteaToken(): string | undefined {
  return process.env.ARCRUN_GITEA_TOKEN || process.env.GITEA_TOKEN || undefined;
 }

+/**
+ * 版本標籤的「發行頻道」來源（Arcrun#106）。
+ *
+ * Portal 設定頁與 daemon `cloudVersionStale()` 都是拿**這支**回的 `release` 當「最新版」，
+ * 再跟實例 `/health` 的 `bundle_version` 比。CLI 更新完若不烙一個同一把尺量得出來的版號，
+ * 使用者就只會看到「無法讀取目前版本」或永遠「落後」。
+ * fork／自架另有發行頻道者用 ARCRUN_RELEASE_API 覆蓋，不寫死。
+ */
+const ARCRUN_RELEASE_API = process.env.ARCRUN_RELEASE_API ?? 'https://install.arcrun.dev/api/latest';
+
+/** CLI 自己負責注入 / 自己烙的 var——**不從已部署的 worker 沿用**（沿用會蓋掉這趟算出來的正解）。 */
+export const CLI_MANAGED_VARS = [
+  'WORKER_SUBDOMAIN',        // 由 ctx.workerSubdomain 注入
+  'CF_ACCOUNT_ID',           // 由 ctx.accountId 注入
+  'MULTI_TENANT',            // 由 selfHosted 注入
+  'KBDB_BASE_URL',           // 由 workerSubdomain 組
+  'ARCRUN_BUNDLE_VERSION',   // 版本標籤：每趟重烙，**絕不沿用舊值**（見 resolveBundleStamp）
+  'ARCRUN_BUNDLE_COMMIT',
+] as const;
+
+/** 烙版本標籤的那顆 worker（`/health` 就是它吐的）。其餘 worker 不需要版本標籤。 */
+export const VERSION_STAMP_WORKER = 'arcrun-cypher-executor';
+
+/** 這趟部署要烙上去的版本標籤。 */
+export interface BundleStamp {
+  /** 寫進 `ARCRUN_BUNDLE_VERSION`。 */
+  version: string;
+  /** 寫進 `ARCRUN_BUNDLE_COMMIT`（查得到才有）。 */
+  commit?: string;
+  /** 給人看的一句話（CLI 會印出來），說明這個版號是怎麼來的。 */
+  note: string;
+}
+
+/**
+ * 算「這趟部署上去的東西，該叫幾版」（Arcrun#106）。
+ *
+ * 🔴 為什麼**不是沿用實例上原本那個值**：那個值描述的是**當時裝上去的那份程式碼**。
+ *   更新完程式碼換了，標籤沒換 = 一個永遠停在安裝當天的假標籤——比沒有標籤更糟，
+ *   因為 leo 會拿它當「我驗收過了」。版本標籤是**成品的屬性**，不是使用者的設定，
+ *   所以它是唯一一個「不沿用、每趟重烙」的 var（其餘 plain_text var 一律沿用，見 preservedVars）。
+ *
+ * 誠實邊界（mindset §7，這段要留著）：
+ *   - CLI 部的是 `ARCRUN_REPO@ref` 的**原始碼**，發行版號（semver）是**安裝器頻道**在發的，
+ *     兩者不是同一套編號。這裡取的是「部署當下該頻道公告的 release」，
+ *     語義＝「我跟這個頻道的最新發行同源」，並**另外把真正的 commit 一起烙上去**
+ *     （`ARCRUN_BUNDLE_COMMIT`／`/health` 的 `bundle_commit`）→ 有沒有漂掉，看 commit 就查得出來。
+ *   - 查不到 release（離線／頻道掛了）→ **不猜、不掰**，退成 `YYYY-MM-DD+<commit7>` 這個
+ *     舊實例本來就在用的格式。Portal 對非 semver 一律顯示成「較舊版本」——
+ *     那正是我們想要的：**寧可說不準，也不要假裝已是最新**。
+ */
+export async function resolveBundleStamp(
+  ref: string,
+  commit?: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<BundleStamp> {
+  const short = commit ? commit.slice(0, 7) : ref;
+  const today = new Date().toISOString().slice(0, 10);
+  try {
+    const res = await fetchImpl(ARCRUN_RELEASE_API, { signal: AbortSignal.timeout(15_000) });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const body = (await res.json()) as { release?: string } | null;
+    const release = String(body?.release ?? '').trim();
+    if (!/^\d+\.\d+\.\d+$/.test(release)) throw new Error(`發行頻道回的版號不是 semver（${release || '空'}）`);
+    return {
+      version: release,
+      commit,
+      note: `${release}（發行頻道 ${ARCRUN_RELEASE_API}${commit ? `；實際部署 commit ${short}` : ''}）`,
+    };
+  } catch (e) {
+    const version = `${today}+${short}`;
+    return {
+      version,
+      commit,
+      note:
+        `${version}（查不到發行版號：${e instanceof Error ? e.message : String(e)}）` +
+        `\n      → 誠實標成 commit 版；Portal 會顯示成「較舊版本」而不是假裝已是最新。`,
+    };
+  }
+}
+
+/**
+ * 把 `ref`（branch / tag / sha）解析成確切的 commit sha（Arcrun#106）。
+ *
+ * 兩個用途：① 版本標籤要烙「真的部了哪個 commit」；② 解出來之後**直接用 sha 下載 archive**——
+ * sha 是不可變的，順帶把 #13 P2 的「branch tarball 被中間層快取成舊的」整個病根拿掉。
+ * 查不到就回 undefined（呼叫端退回原本的用 ref 下載，行為不變）——這條路徑不該讓更新失敗。
+ */
+export async function resolveGiteaCommit(
+  ref: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<string | undefined> {
+  const headers = buildDownloadHeaders();
+  const tryUrls = [
+    `${ARCRUN_GITEA_BASE}/api/v1/repos/${ARCRUN_REPO}/branches/${encodeURIComponent(ref)}`,
+    `${ARCRUN_GITEA_BASE}/api/v1/repos/${ARCRUN_REPO}/commits?sha=${encodeURIComponent(ref)}&limit=1&stat=false`,
+  ];
+  for (const url of tryUrls) {
+    try {
+      const res = await fetchImpl(url, { headers, signal: AbortSignal.timeout(20_000) });
+      if (!res.ok) continue;
+      const body = (await res.json()) as
+        | { commit?: { id?: string } }
+        | Array<{ sha?: string }>
+        | null;
+      const sha = Array.isArray(body) ? body[0]?.sha : body?.commit?.id;
+      if (typeof sha === 'string' && /^[0-9a-f]{7,64}$/i.test(sha)) return sha;
+    } catch {
+      /* 換下一種問法；全都問不到就回 undefined */
+    }
+  }
+  return undefined;
+}
+
 /**
 * 組 Gitea archive 下載 URL（純函式，好離線測 URL 組裝）。
 * Gitea archive API：`GET {base}/api/v1/repos/{owner}/{repo}/archive/{ref}.tar.gz`。
@@ -253,9 +366,12 @@ export async function downloadAndDeploy(
  const mode = opts.mode ?? 'update';
  const api = opts.api ?? new CfAccountClient(ctx.accountId, ctx.apiToken);
  // 1. 下載 + 解壓 Gitea archive tarball
+  //    #106：先把 ref 解析成確切 commit，**用 sha 下載**（不可變 → 順帶解掉 branch tarball 被快取的老問題），
+  //    同一個 sha 稍後也會被烙成版本標籤。解不出來就照舊用 ref 下載（行為不變）。
+  const commit = await resolveGiteaCommit(ref);
  let root: string;
  try {
-    root = await downloadRepoTarball(ref);
+    root = await downloadRepoTarball(commit ?? ref, commit ? ref : undefined);
  } catch (e) {
    return {
      implemented: true,
@@ -310,6 +426,7 @@ export async function downloadAndDeploy(
  //    所以「解析看到的」和「最後寫進去的」保證是同一份檔案的同一種樣子。
  const requirements: BindingRequirement[] = [];
  const tomlPreviews = new Map<string, string>();   // dir → 注入前的原文
+  const dirScript = new Map<string, string>();      // dir → worker script 名（#106：var 沿用要逐顆對號）
  for (const dir of allDirs) {
    const tomlPath = join(dir, 'wrangler.toml');
    if (!existsSync(tomlPath)) continue;
@@ -318,12 +435,14 @@ export async function downloadAndDeploy(
    const preview = renderWranglerToml(raw, ctx, new Map());
    const parsed = parseWranglerRequirements(preview);
    if (!parsed.script) continue;   // 沒宣告 name 的 toml 不該存在；跳過而非亂猜
+    dirScript.set(dir, parsed.script);
    for (const b of parsed.bindings) {
      requirements.push({ ...b, worker: parsed.script });
    }
  }

  let resolved = new Map<string, ResolvedResource>();
+  let liveVars = new Map<string, Record<string, string>>();
  if (requirements.length > 0) {
    process.stdout.write(chalk.gray('  → 對照你帳號上已部署的 worker，確認每個綁定該用哪顆資源...'));
    let plan;
@@ -369,6 +488,7 @@ export async function downloadAndDeploy(
        message: `停手：\n${detail}${hint}\n\n沒有部署任何 worker——你現在的實例維持原樣。`,
      };
    }
+    liveVars = plan.liveVars;
    console.log(chalk.green(' ✓'));
    const adopted = [...resolved.values()].filter((r) => r.origin === 'adopted');
    const created = [...resolved.values()].filter((r) => r.origin === 'created');
@@ -407,6 +527,48 @@ export async function downloadAndDeploy(
    }
  }

+  // ── 2.8 var（plain_text）：既有的沿用、版本標籤重烙（Arcrun#106）─────────────────
+  //
+  // 🔴 #97 修好了「櫃子」（KV/D1/Vectorize 沿用既有），但 **var 這批「櫃子上的標籤」沒人管**：
+  //    wrangler deploy 是整份覆蓋，toml 沒寫的 var 直接消失。leo 2026-08-12 實撞的畫面
+  //    「無法讀取目前版本（知識庫服務可能正在啟動）」就是 `ARCRUN_BUNDLE_VERSION` 被這樣洗掉的。
+  //
+  // 兩種 var 走**相反**的規則，這是本次的核心判斷：
+  //    · 設定類（PORTAL_MAIL_RELAY_BASE / CONSOLE_TENANT / …）＝**使用者實例的事實** → 沿用
+  //    · 版本標籤（ARCRUN_BUNDLE_VERSION）＝**這份成品的屬性** → 每趟重烙，沿用舊值就是假標籤
+  //
+  // 範圍註記：`liveVars` 來自資源解析那一趟讀到的 worker（＝有資源綁定的那些：cypher/kbdb/mcp/registry）。
+  //   純零件 worker 沒有資源綁定、不在那份名單裡 → 這裡不會沿用它們的 var。目前它們的 var 只有
+  //   toml 自己帶的 `COMPONENT_ID`，沒有東西可丟；若哪天有人往零件 worker 注入設定，要在這裡補讀。
+  const extraVarsByDir = new Map<string, Record<string, string>>();
+  let stamp: BundleStamp | undefined;
+  if (dirScript.size > 0) {
+    const needStamp = [...dirScript.values()].includes(VERSION_STAMP_WORKER);
+    if (needStamp) {
+      process.stdout.write(chalk.gray('  → 算這趟要烙上去的版本標籤...'));
+      stamp = await resolveBundleStamp(ref, commit);
+      console.log(chalk.green(' ✓'));
+      console.log(chalk.gray(`    ARCRUN_BUNDLE_VERSION = ${stamp.note}`));
+    }
+    const preservedTotal: string[] = [];
+    for (const [dir, script] of dirScript) {
+      const raw = tomlPreviews.get(dir);
+      if (!raw) continue;
+      const keep = preservedVars(liveVars.get(script), raw);
+      for (const k of Object.keys(keep)) preservedTotal.push(`${script}:${k}`);
+      const vars: Record<string, string> = { ...keep };
+      if (stamp && script === VERSION_STAMP_WORKER) {
+        vars.ARCRUN_BUNDLE_VERSION = stamp.version;
+        if (stamp.commit) vars.ARCRUN_BUNDLE_COMMIT = stamp.commit;
+      }
+      if (Object.keys(vars).length > 0) extraVarsByDir.set(dir, vars);
+    }
+    if (preservedTotal.length > 0) {
+      console.log(chalk.gray(`    沿用你實例上既有的 ${preservedTotal.length} 個設定值（var）：`));
+      for (const item of preservedTotal) console.log(chalk.gray(`      = ${item}`));
+    }
+  }
+
  // 3. 對每個 worker：注入 KV id（+ cypher WORKER_SUBDOMAIN）→ wrangler deploy。tier1 先 tier2 後。
  // 逐 worker 串流進度（每個含 pnpm install + wrangler deploy，沉默會讓人以為卡住——
  //   壓測 2026-06-11 richblack 觀察：「D1 ✓」後停很久其實在這個迴圈靜默部署 20+ worker）。
@@ -422,7 +584,7 @@ export async function downloadAndDeploy(
    const label = dir.replace(/^.*\.component-builds\//, '').replace(/^.*\//, '');
    process.stdout.write(chalk.gray(`    [${i + 1}/${allDirs.length}] ${label} ...`));
    try {
-      injectWranglerConfig(tomlPath, ctx, resolved, tomlPreviews.get(dir));
+      injectWranglerConfig(tomlPath, ctx, resolved, tomlPreviews.get(dir), extraVarsByDir.get(dir));
      // 注入後算指紋：與 manifest 比，相同 = 上次成功部過且內容沒變 → 跳過。
      const hash = dirContentHash(dir, ctx.accountId);
      if (manifest[label] === hash) {
@@ -599,11 +761,13 @@ async function ensureVectorizeMetadataIndexes(ctx: DeployContext, indexName: str
 * 解法：fetch 時帶 no-cache header + 唯一 query param 強制繞過快取，每次抓到 ref 的最新內容。
 *
 * Arcrun#4：來源由 GitHub codeload 改為 Gitea archive API（走 GITEA_TOKEN，不寫死）。*/
-async function downloadRepoTarball(ref: string): Promise<string> {
+async function downloadRepoTarball(ref: string, fromRef?: string): Promise<string> {
  // 唯一 cache-buster query param：對不同 query 視為不同請求 → 繞過 stale 快取。
  const bust = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
  const url = buildArchiveUrl(ref, bust);
-  console.log(chalk.gray(`  → 從 Gitea 下載最新版本（${ARCRUN_REPO}@${ref}，約 10–30 秒，視網速）...`));
+  // fromRef 有值 = ref 已被解析成 commit sha（#106），印出來讓人看得到「這趟到底部了哪個 commit」。
+  const label = fromRef ? `${fromRef} → ${ref.slice(0, 7)}` : ref;
+  console.log(chalk.gray(`  → 從 Gitea 下載最新版本（${ARCRUN_REPO}@${label}，約 10–30 秒，視網速）...`));
  const res = await fetch(url, {
    signal: AbortSignal.timeout(120_000),
    // 強制繞過任何中間快取，避免抓到 push 後尚未刷新的 stale tarball（#13 P2 假綠根因）。
@@ -701,11 +865,91 @@ function injectWranglerConfig(
  ctx: DeployContext,
  resolved: Map<string, ResolvedResource>,
  original?: string,
+  extraVars: Record<string, string> = {},
 ): void {
  if (!existsSync(tomlPath)) return;
  // original = 資源解析階段讀到的原文。用它而不是重讀檔案，確保「解析看到的」與「寫回去的」同源。
  const toml = original ?? readFileSync(tomlPath, 'utf8');
-  writeFileSync(tomlPath, renderWranglerToml(toml, ctx, resolved), 'utf8');
+  writeFileSync(tomlPath, renderWranglerToml(toml, ctx, resolved, extraVars), 'utf8');
+}
+
+/**
+ * 挑出「這顆已部署的 worker 上有、但這版 toml 不會自己帶的」plain_text var（Arcrun#106）。
+ *
+ * 規則就一句：**已部署 worker 上掛著什麼 var，那就是事實**（#97 對資源講的那句話，
+ * 原封不動套用在標籤上）。所以預設全部沿用，只有兩種例外：
+ *   ① `CLI_MANAGED_VARS`——這趟由 CLI 自己算（帳號 id／subdomain／單租戶旗標／版本標籤），
+ *      沿用等於拿舊值蓋掉正解。
+ *   ② 值一模一樣的（toml 已經寫了同樣的值）——寫進去只是雜訊，略過。
+ *
+ * ⚠️ 這裡刻意**不**做「toml 有宣告就以 toml 為準」：那正是這次的病
+ * ——repo toml 裡的 `CONSOLE_TENANT = "leo"`／`WORKER_SUBDOMAIN` 之類是**官方 prod 的值**，
+ * 拿它蓋掉使用者實例上的值，就是「更新一次把人家的設定洗成官方預設」。
+ */
+export function preservedVars(
+  live: Record<string, string> | undefined,
+  toml: string,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!live) return out;
+  const managed = new Set<string>(CLI_MANAGED_VARS);
+  for (const key of Object.keys(live).sort()) {
+    if (managed.has(key)) continue;
+    if (!/^[A-Za-z0-9_]+$/.test(key)) continue;      // 怪名字不碰（applyVars 也會擋，這裡先濾掉不誤報）
+    if (readVar(toml, key) === live[key]) continue;   // toml 已經是同一個值 → 不必動
+    out[key] = live[key];
+  }
+  return out;
+}
+
+/** 讀 toml 裡某個 var 目前的值（只看未註解的行）。找不到回 undefined。 */
+function readVar(toml: string, key: string): string | undefined {
+  const m = toml.match(new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, 'm'));
+  return m?.[1];
+}
+
+/** TOML basic string 轉義（值裡可能有引號／反斜線，例如網址或 JSON 片段）。 */
+function tomlEscape(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+/**
+ * 把一組 var 寫進 toml 的 `[vars]`（Arcrun#106）。純函式。
+ *
+ * 三種既有狀態各自處理（比照 injectMultiTenant，同一種文字操作層級）：
+ *   1. 已有未註解的同名行 → 換值
+ *   2. 只有被註解掉的同名行 → 取消註解並填值
+ *   3. 都沒有 → 插在 `[vars]` header 下一行；連 `[vars]` 都沒有就在檔尾新開一段
+ */
+export function applyVars(toml: string, vars: Record<string, string>): string {
+  let out = toml;
+  for (const key of Object.keys(vars).sort()) {
+    // 只接受合法的 var 名（CF 那側本來就是這個字集）。怪名字寧可不寫，也不要拿它去組正規式。
+    if (!/^[A-Za-z0-9_]+$/.test(key)) continue;
+    const value = tomlEscape(vars[key]);
+    // 🔴 一律用「函式版 replace」：值裡若有 `$&`／`$1` 這種字元，字串版 replace 會把它當成
+    //   反向參照展開，寫出來的就不是使用者那個值了。
+    if (new RegExp(`^\\s*${key}\\s*=`, 'm').test(out)) {
+      out = out.replace(
+        new RegExp(`^(\\s*${key}\\s*=\\s*")[^"]*(".*)$`, 'm'),
+        (_m, head: string, tail: string) => `${head}${value}${tail}`,
+      );
+      continue;
+    }
+    if (new RegExp(`^\\s*#\\s*${key}\\s*=`, 'm').test(out)) {
+      out = out.replace(
+        new RegExp(`^(\\s*)#\\s*${key}\\s*=\\s*"[^"]*"(.*)$`, 'm'),
+        (_m, indent: string, tail: string) => `${indent}${key} = "${value}"${tail}`,
+      );
+      continue;
+    }
+    if (/^\s*\[vars\]\s*$/m.test(out)) {
+      out = out.replace(/^(\s*\[vars\]\s*)$/m, (_m, header: string) => `${header}\n${key} = "${value}"`);
+      continue;
+    }
+    out = `${out.replace(/\s*$/, '')}\n\n[vars]\n${key} = "${value}"\n`;
+  }
+  return out;
 }

 /**
@@ -715,11 +959,15 @@ function injectWranglerConfig(
 * 「除了資源 id 以外都已經定案」的 toml，資源解析就是照這份預覽去數需求的
 * ⇒ 解析階段看到的 binding 清單，與最後真的寫進檔案的，保證一致（Arcrun#97 的教訓：
 *   兩段程式對同一份檔案有不同想像，就會出現「以為沒有、其實有」）。
+ *
+ * `extraVars`（Arcrun#106）：這顆 worker 要**沿用的既有 var** ＋ 這趟要**重烙的版本標籤**。
+ *   預覽時不傳（vars 不影響資源需求解析，傳不傳都是同一份需求清單）。
 */
 export function renderWranglerToml(
  toml: string,
  ctx: DeployContext,
  resolved: Map<string, ResolvedResource>,
+  extraVars: Record<string, string> = {},
 ): string {
  // cypher-executor 的 WORKER_SUBDOMAIN（vars）換成用戶帳號 subdomain
  if (ctx.workerSubdomain && /WORKER_SUBDOMAIN/.test(toml)) {
@@ -770,6 +1018,11 @@ export function renderWranglerToml(
    toml = toml.replace(/# (\[ai\])\n# (binding = "AI")/, '$1\n$2');
  }

+  // 沿用的既有 var ＋ 這趟的版本標籤（#106）。**放在所有 CLI 注入之後**：
+  // CLI_MANAGED_VARS 已經在 preservedVars 排除掉，故這裡不會蓋掉上面剛算好的
+  // WORKER_SUBDOMAIN / CF_ACCOUNT_ID / MULTI_TENANT / KBDB_BASE_URL。
+  toml = applyVars(toml, extraVars);
+
  // 資源 id 一律最後注入，且**照 binding 名逐個對號**（不是「檔案裡第一個 database_id」那種盲換）。
  // 空 map = 預覽模式，這步什麼也不做。
  return applyResolvedBindings(toml, resolved);
@@ -1,408 +1,42 @@
 /**
- * resource-resolver.ts — 資源解析：「已部署的 worker 現在綁著什麼，那就是事實」
+ * resource-resolver.ts — **這裡沒有邏輯**，只是把共用規則接到 CLI 的既有 import 路徑上。
 *
- * 🔴 Arcrun#97（2026-08-12 實害，leo 的實例中了）：
- *   舊做法叫「照名字 ensure」——`acr update` 拿 **binding 名**（`WEBHOOKS`）當成 Cloudflare 上的
- *   **資源標題**去找，找不到就**新建一顆空的、然後綁到 worker 上**。
- *   安裝器建的資源不叫那個名字（它叫 `arcrun-rag-<instance>-kv-webhooks`）⇒ 一次例行更新
- *   新建了 9 顆 KV、1 顆 D1，使用者的工作流／登入狀態／子庫**在畫面上全部消失**。
- *   資料沒有被刪，但 worker 被綁去空的那幾顆——從使用者的角度，他的東西就是不見了。
+ * 「這個實例該用哪些資源」的規則住在 `shared/resource-rule/`（repo 根目錄），
+ * 那是**唯一一份人手維護的實作**；`./resource-rule/` 是該目錄的逐位元組鏡射
+ * （`scripts/sync-resource-rule.mjs` 產生，`npm run build` / `npm test` 會跑 `--check` 擋漂移）。
+ * 之所以要有這份鏡射：`arcrun` 是獨立 npm 套件，`npm pack` 打不進套件目錄外的檔案。
 *
- *   根因不是「KV 那段寫錯」，是**「用名字猜使用者的資源」這個做法本身**：
- *   名字是**使用者那側的事實**（安裝器要怎麼取名由它決定，而且它有權改），
- *   我們不能拿自己的命名慣例去對號入座，更不能在對不上的時候自作主張生一顆新的。
- *   ——所以修法不是「多比對幾種名字」，是**不再用名字當識別**。
+ * 為什麼規則不在 CLI（leo 2026-08-12）：
+ *   「根本就不應該在 CLI，我要的是一個大家都可以用到的規則。」
+ *   ——`acr` 有這條規則、安裝器沒有，結果就是 Arcrun#97：
+ *   安裝器照名字找、找不到就建一顆空的綁上去，使用者的工作流與登入狀態整片消失。
+ *   規則搬到共用層之後，安裝器直接 import 同一份原稿，**不再有第二種答案**。
 *
- * ── 新規則（三句話）────────────────────────────────────────────────
- *   1. **已部署的 worker 上綁著什麼，那就是事實** → 原封不動沿用，不管那顆資源叫什麼名字。
- *   2. **只有「確定沒有任何人綁過它」才准新建**（新版本新增的 binding、或真的全新帳號）。
- *   3. **只要有一點說不準就整趟停手**（讀不到綁定／綁著的資源不見了／同一個 binding 指向兩顆／
- *      該更新的 worker 一顆都不在），**什麼都不建、什麼都不部署**，把話說清楚讓人來判斷。
- *
- * ── 為什麼拆成 plan / apply 兩段 ─────────────────────────────────────
- *   `planResources()` **完全不寫入**，只回一份「要沿用什麼、要新建什麼、有什麼不敢動的」。
- *   `applyResourcePlan()` 看到有任何 blocker 就直接拒絕執行。
- *   ⇒「被擋下的時候一顆資源都不會被建出來」是**結構上的保證**，
- *     不是靠某個人記得在對的地方寫 early return。#97 正是死在「先動手、後判斷」。
+ * 🔴 不要把任何判斷寫回這個檔案。要改規則 → 改 `shared/resource-rule/rule.mjs`。
 */

-/** 這支負責的資源種類。要加新種類（R2/Queue/Hyperdrive…）就加在這裡，
- *  一律走同一道門——不准任何呼叫端自己「照名字 ensure」繞過去。 */
-export type ResourceKind = 'kv_namespace' | 'd1' | 'vectorize';
+export {
+  planResources,
+  applyResourcePlan,
+  parseWranglerRequirements,
+  normalizeLiveBindings,
+  normalizeLiveVars,
+  bindingKey,
+  ResourcePlanBlocked,
+  KIND_LABEL,
+  TABLE_KIND,
+} from './resource-rule/rule.mjs';

-/** 從已部署 worker 上讀回來的一條綁定。`value`：KV/D1 是資源 id，Vectorize 是 index 名。 */
-export interface LiveBinding {
-  kind: ResourceKind;
-  binding: string;
-  value: string;
-}
-
-export interface ScriptBindings {
-  /** false = 這顆 worker 在帳號上還不存在（全新部署），不是「讀取失敗」。讀取失敗要 throw。 */
-  deployed: boolean;
-  bindings: LiveBinding[];
-}
-
-/** resolver 需要的 CF 能力（收窄成介面，方便離線測試餵假帳號）。 */
-export interface ResourceApi {
-  getScriptBindings(script: string): Promise<ScriptBindings>;
-  /** title → id */
-  listKvNamespaces(): Promise<Map<string, string>>;
-  /** name → uuid */
-  listD1Databases(): Promise<Map<string, string>>;
-  listVectorizeIndexes(): Promise<string[]>;
-  createKvNamespace(title: string): Promise<string>;
-  createD1Database(name: string): Promise<string>;
-  createVectorizeIndex(name: string): Promise<string>;
-}
-
-/** 「這顆 worker 需要這個 binding」。createName 只在**真的要新建**時才會被拿來當名字用。 */
-export interface BindingRequirement {
-  kind: ResourceKind;
-  binding: string;
-  /** 需要它的 worker script 名（= wrangler.toml 的 `name`）。 */
-  worker: string;
-  createName: string;
-}
-
-export interface PlannedAdopt {
-  kind: ResourceKind;
-  binding: string;
-  value: string;
-  /** 從哪顆已部署的 worker 上讀到的 */
-  from: string;
-}
-
-export interface PlannedCreate {
-  kind: ResourceKind;
-  binding: string;
-  createName: string;
-  wantedBy: string[];
-  /** 其他也指向同一顆資源的 binding（見 shareSameResource）。建一顆，大家共用。 */
-  alsoBind: string[];
-}
-
-export interface ResourcePlan {
-  adopt: PlannedAdopt[];
-  create: PlannedCreate[];
-  /** 非空 = 整趟停手。applyResourcePlan 會拒絕執行。 */
-  blockers: string[];
-}
-
-export interface ResolvedResource {
-  kind: ResourceKind;
-  binding: string;
-  value: string;
-  origin: 'adopted' | 'created';
-  from?: string;
-}
-
-/** plan 被擋下時丟這個，讓呼叫端能把每一條原因原文轉給使用者。 */
-export class ResourcePlanBlocked extends Error {
-  constructor(readonly blockers: string[]) {
-    super(`資源解析被擋下（${blockers.length} 項）`);
-    this.name = 'ResourcePlanBlocked';
-  }
-}
-
-export function bindingKey(kind: ResourceKind, binding: string): string {
-  return `${kind}:${binding}`;
-}
-
-const KIND_LABEL: Record<ResourceKind, string> = {
-  kv_namespace: 'KV namespace',
-  d1: 'D1 資料庫',
-  vectorize: 'Vectorize index',
-};
-
-function msg(e: unknown): string {
-  return e instanceof Error ? e.message : String(e);
-}
-
-/**
- * 決定每個 binding 要沿用哪顆資源／要不要新建，**不寫入任何東西**。
- *
- * @param mode 'update' = 這台照定義已經裝過了（見下方「一顆都不在」規則）；'init' = 全新安裝，允許從零建。
- */
-export async function planResources(
-  api: ResourceApi,
-  requirements: readonly BindingRequirement[],
-  mode: 'update' | 'init',
-): Promise<ResourcePlan> {
-  const blockers: string[] = [];
-  const adopt: PlannedAdopt[] = [];
-  const create: PlannedCreate[] = [];
-
-  // ── 1. 先讀「即將被覆蓋的每一顆 worker」現在綁著什麼 ──────────────────
-  // 讀取失敗 ≠ 沒有綁。#97 的災情就是把「我查不到」當成「它不存在」。
-  const scripts = [...new Set(requirements.map((r) => r.worker))].sort();
-  const live = new Map<string, LiveBinding[]>();
-  let readFailed = false;
-  for (const script of scripts) {
-    try {
-      const res = await api.getScriptBindings(script);
-      if (res.deployed) live.set(script, res.bindings);
-    } catch (e) {
-      readFailed = true;
-      blockers.push(
-        `讀不到已部署的 worker「${script}」目前綁著哪些資源（${msg(e)}）。` +
-          `不確定它現在用的是哪一顆，就不能重新綁——整趟更新停手，沒有動任何東西。`,
-      );
-    }
-  }
-
-  // 「這台照定義已經裝過了，卻一顆 worker 都找不到」= 我對不上它的實例（名字不同／token 看不到）。
-  // 這種時候繼續走下去，等於把一整套資源重新生一遍再綁上去——正是 #97 的形狀，只是換一道門進來。
-  if (mode === 'update' && !readFailed && live.size === 0 && scripts.length > 0) {
-    blockers.push(
-      `在這個 Cloudflare 帳號上找不到任何一顆要更新的 worker（找過：${scripts.join('、')}）。` +
-        `acr update 的前提是「這台已經裝好了」——對不上就不猜：` +
-        `可能是 API token 看得到的帳號不對，或這台實例的 worker 用了別的名字。` +
-        `已停手，沒有新建任何資源。`,
-    );
-  }
-
-  // ── 2. 逐個 binding 決定：沿用 / 新建 / 停手 ─────────────────────────
-  const byKey = new Map<string, BindingRequirement[]>();
-  for (const req of requirements) {
-    const key = bindingKey(req.kind, req.binding);
-    const list = byKey.get(key);
-    if (list) list.push(req);
-    else byKey.set(key, [req]);
-  }
-
-  const existingCache = new Map<ResourceKind, Set<string>>();
-  const listExisting = async (kind: ResourceKind): Promise<Set<string>> => {
-    const hit = existingCache.get(kind);
-    if (hit) return hit;
-    let set: Set<string>;
-    if (kind === 'kv_namespace') set = new Set((await api.listKvNamespaces()).values());
-    else if (kind === 'd1') set = new Set((await api.listD1Databases()).values());
-    else set = new Set(await api.listVectorizeIndexes());
-    existingCache.set(kind, set);
-    return set;
-  };
-
-  for (const [, reqs] of byKey) {
-    const { kind, binding } = reqs[0];
-
-    const found: Array<{ value: string; script: string }> = [];
-    for (const [script, bindings] of live) {
-      const hit = bindings.find((b) => b.kind === kind && b.binding === binding);
-      if (hit) found.push({ value: hit.value, script });
-    }
-    const distinct = [...new Set(found.map((f) => f.value))];
-
-    // 2a. 同一個 binding 名在不同 worker 上指向不同資源 → 分不出哪個才是使用者要的。
-    //     自己挑一個 = 有一半機率把另外那半的資料從畫面上抹掉。不猜。
-    if (distinct.length > 1) {
-      blockers.push(
-        `綁定「${binding}」在不同 worker 上指向不同的 ${KIND_LABEL[kind]}` +
-          `（${found.map((f) => `${f.script} → ${f.value}`).join('、')}）。` +
-          `分不出哪一顆才是你在用的，不猜——停手。`,
-      );
-      continue;
-    }
-
-    // 2b. 有人綁著它 → 這就是事實，沿用。名字長什麼樣完全不看。
-    if (distinct.length === 1) {
-      const value = distinct[0];
-      let existing: Set<string>;
-      try {
-        existing = await listExisting(kind);
-      } catch (e) {
-        blockers.push(
-          `查不到帳號上的 ${KIND_LABEL[kind]} 清單，無法確認「${binding}」綁著的 ${value} 還在不在` +
-            `（${msg(e)}）。不確定就不動——停手。`,
-        );
-        continue;
-      }
-      if (!existing.has(value)) {
-        // 這正是 #97 的入口：舊版在這裡會安靜地新建一顆空的頂上去。
-        blockers.push(
-          `worker「${found[0].script}」的「${binding}」綁著 ${KIND_LABEL[kind]} ${value}，` +
-            `但這顆在你的 Cloudflare 帳號上找不到了。` +
-            `這裡**不會**幫你新建一顆空的頂上去（Arcrun#97 的災情就是那樣來的）——` +
-            `請先確認那顆資源是被刪掉了，還是這把 API token 看不到它。`,
-        );
-        continue;
-      }
-      adopt.push({ kind, binding, value, from: found[0].script });
-      continue;
-    }
-
-    // 2c. 沒有任何已部署的 worker 綁過它 → 新版本新增的 binding，或全新帳號。
-    //     這種情況下新建不會弄丟任何東西（本來就沒有東西可丟）。
-    create.push({
-      kind,
-      binding,
-      createName: reqs[0].createName,
-      wantedBy: [...new Set(reqs.map((r) => r.worker))],
-      alsoBind: [],
-    });
-  }
-
-  return { adopt, create: shareSameResource(adopt, create, byKey), blockers };
-}
-
-/**
- * 收斂「不同 binding 其實是同一顆資源」的情況。
- *
- * 判準是 **toml 自己宣告的名字**（`database_name` / `index_name`），不是使用者那側的資源名——
- * cypher 的 `CREDENTIALS_DB` 與 kbdb 的 `DB` 都寫 `database_name = "arcrun-kbdb"`，
- * 那是**我們**在宣告「這兩個綁定指向同一顆庫」，跟 #97 那種「拿名字去猜使用者的資源」是兩回事。
- *
- * 沒有這一步會出兩種錯：
- *   ① 全新安裝時建出兩顆同名 D1，KBDB 的資料與 credential 目錄從此分家。
- *   ② 一邊已部署（沿用既有）、另一邊沒有（新建一顆空的）→ 半套資料，比全壞更難查。
- */
-function shareSameResource(
-  adopt: PlannedAdopt[],
-  create: PlannedCreate[],
-  byKey: Map<string, BindingRequirement[]>,
-): PlannedCreate[] {
-  const declaredName = (kind: ResourceKind, binding: string): string | undefined =>
-    byKey.get(bindingKey(kind, binding))?.[0]?.createName;
-
-  const out: PlannedCreate[] = [];
-  const groups = new Map<string, PlannedCreate>();
-
-  for (const c of create) {
-    const groupKey = `${c.kind}${c.createName}`;
-
-    // ① 已經有 binding 沿用到同一顆（依 toml 宣告）→ 跟著沿用，不要另外建一顆。
-    const twin = adopt.find(
-      (a) => a.kind === c.kind && declaredName(a.kind, a.binding) === c.createName,
-    );
-    if (twin) {
-      adopt.push({ kind: c.kind, binding: c.binding, value: twin.value, from: twin.from });
-      continue;
-    }
-
-    // ② 同一趟裡有多個 binding 要建同一顆 → 建一次，其他人共用。
-    const head = groups.get(groupKey);
-    if (head) {
-      head.alsoBind.push(c.binding);
-      head.wantedBy = [...new Set([...head.wantedBy, ...c.wantedBy])];
-      continue;
-    }
-    groups.set(groupKey, c);
-    out.push(c);
-  }
-  return out;
-}
-
-/**
- * 照 plan 動手：沿用的原樣帶出來，該建的才建。
- * 有任何 blocker 直接丟 ResourcePlanBlocked，**一顆都不建**。
- */
-export async function applyResourcePlan(
-  api: ResourceApi,
-  plan: ResourcePlan,
-): Promise<Map<string, ResolvedResource>> {
-  if (plan.blockers.length > 0) throw new ResourcePlanBlocked(plan.blockers);
-
-  const out = new Map<string, ResolvedResource>();
-  for (const a of plan.adopt) {
-    out.set(bindingKey(a.kind, a.binding), {
-      kind: a.kind,
-      binding: a.binding,
-      value: a.value,
-      origin: 'adopted',
-      from: a.from,
-    });
-  }
-  const madeSoFar: string[] = [];
-  for (const c of plan.create) {
-    let value: string;
-    try {
-      if (c.kind === 'kv_namespace') value = await api.createKvNamespace(c.createName);
-      else if (c.kind === 'd1') value = await api.createD1Database(c.createName);
-      else value = await api.createVectorizeIndex(c.createName);
-    } catch (e) {
-      // 半途失敗：已經建出來的那幾顆還沒被綁到任何 worker 上。**要講出來**——
-      // 不講的話它們就是帳號上一批沒人認得的孤兒，而且下次重跑會再建一批。
-      const orphans = madeSoFar.length > 0
-        ? `\n  已經建好但還沒綁上任何 worker 的：${madeSoFar.join('、')}（重跑前可先刪掉，或留著讓下次沿用）`
-        : '';
-      throw new Error(`建 ${KIND_LABEL[c.kind]}「${c.createName}」失敗：${msg(e)}${orphans}`);
-    }
-    madeSoFar.push(`${KIND_LABEL[c.kind]} ${c.createName}`);
-    for (const binding of [c.binding, ...c.alsoBind]) {
-      out.set(bindingKey(c.kind, binding), { kind: c.kind, binding, value, origin: 'created' });
-    }
-  }
-  return out;
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// wrangler.toml → 需求清單
-// ─────────────────────────────────────────────────────────────────────────────
-
-export interface WranglerRequirements {
-  /** worker script 名（toml 頂層 `name`）。空字串 = 這份 toml 沒宣告 name（不該發生）。 */
-  script: string;
-  bindings: Array<{ kind: ResourceKind; binding: string; createName: string }>;
-}
-
-/** wrangler.toml 的 table 名 → 資源種類。需求解析與注入共用同一張表，兩邊才不會對不上。 */
-export const TABLE_KIND: Record<string, ResourceKind> = {
-  kv_namespaces: 'kv_namespace',
-  d1_databases: 'd1',
-  vectorize: 'vectorize',
-};
-
-/**
- * 從 wrangler.toml 抽出「這顆 worker 需要哪些資源綁定」。
- *
- * 刻意寫成行掃描而不引 TOML parser：注入端（injectWranglerConfig）本來就是純文字操作，
- * 兩邊用同一種視角看這份檔案才不會對不上。註解掉的區塊**不算需求**
- * （kbdb 的 `[[vectorize]]` 預設是註解狀態，要開語義查詢時才會被取消註解 → 那時才成為需求）。
- */
-export function parseWranglerRequirements(toml: string): WranglerRequirements {
-  let script = '';
-  let seenTable = false;
-  const bindings: WranglerRequirements['bindings'] = [];
-
-  let kind: ResourceKind | null = null;
-  let binding = '';
-  let createName = '';
-
-  const flush = (): void => {
-    if (kind && binding) {
-      bindings.push({ kind, binding, createName: createName || binding });
-    }
-    kind = null;
-    binding = '';
-    createName = '';
-  };
-
-  for (const raw of toml.split('\n')) {
-    const line = raw.trim();
-    if (line === '' || line.startsWith('#')) continue;
-
-    const table = line.match(/^\[\[?([A-Za-z0-9_]+)\]?\]$/);
-    if (table) {
-      flush();
-      seenTable = true;
-      kind = TABLE_KIND[table[1]] ?? null;
-      continue;
-    }
-
-    const kv = line.match(/^([A-Za-z0-9_]+)\s*=\s*"([^"]*)"/);
-    if (!kv) continue;
-    const [, key, value] = kv;
-
-    if (!seenTable && key === 'name') {
-      script = value;
-      continue;
-    }
-    if (!kind) continue;
-    if (key === 'binding') binding = value;
-    // 只有 D1／Vectorize 在 toml 裡帶得出「名字」；KV 沒有，退回用 binding 名（見 flush）。
-    else if (key === 'database_name' || key === 'index_name') createName = value;
-  }
-  flush();
-
-  return { script, bindings };
-}
+export type {
+  ResourceKind,
+  LiveBinding,
+  ScriptBindings,
+  ResourceApi,
+  BindingRequirement,
+  PlannedAdopt,
+  PlannedCreate,
+  ResourcePlan,
+  ResolvedResource,
+  WranglerRequirements,
+  RawWorkerBinding,
+} from './resource-rule/rule.mjs';
@@ -0,0 +1,202 @@
+// @ts-check
+/**
+ * cf-resource-api.mjs — 規則的**眼睛與手**：對 Cloudflare 帳號的那七個動作，也只有一份。
+ *
+ * `rule.mjs` 是純判斷，IO 由呼叫端注入（`ResourceApi`）。本檔就是那個注入物的正貨：
+ * 用 CF REST API 實作 `ResourceApi`，零依賴、只用 global `fetch`
+ * ⇒ Node 18+ 與 Cloudflare Workers runtime 都能直接跑。
+ *
+ * 【為什麼連這層也要共用】
+ * 判斷一致還不夠——**看到的東西**也要一致。
+ * 「已部署的 worker 綁著什麼」是從 `GET /workers/scripts/{script}/settings` 讀來的；
+ * 如果兩條路各自寫一份 client，隨便一個差異（打錯端點、把 404 當錯誤、漏了 per_page、
+ * 少認一種欄位名）都會讓其中一條路「看不到既有綁定」——而看不到既有綁定的下一步，
+ * 依規則就是**新建**。Arcrun#97 的災情不需要規則寫錯，只要眼睛不一樣就會重演。
+ *
+ * 這裡**故意只有 `ResourceApi` 那七個方法**。verifyAccess / 查 subdomain / KV 讀寫
+ * 這些跟「該用哪些資源」無關的帳號操作留在各自的呼叫端，不往共用層堆。
+ *
+ * 🔴 除了同目錄的 `./rule.mjs`，這支不准 import 任何東西——共用層的價值在於
+ *    「整個目錄複製到哪個 runtime 都能直接跑」，多一個外部依賴就少一條路吃得到。
+ */
+
+import { normalizeLiveBindings, normalizeLiveVars } from './rule.mjs';
+
+const CF_API_BASE = 'https://api.cloudflare.com/client/v4';
+
+/**
+ * @typedef {import('./rule.mjs').ResourceApi} ResourceApi
+ * @typedef {import('./rule.mjs').ScriptBindings} ScriptBindings
+ * @typedef {import('./rule.mjs').RawWorkerBinding} RawWorkerBinding
+ */
+
+/**
+ * @typedef {object} CfResourceApiOptions
+ * @property {string} accountId
+ * @property {string} apiToken
+ * @property {typeof globalThis.fetch} [fetch]
+ *   注入用（離線測試餵假帳號、或宿主要用自己的 fetch）。預設 global fetch。
+ */
+
+/**
+ * 建一個打真實 Cloudflare 的 `ResourceApi`。
+ *
+ * @param {CfResourceApiOptions} options
+ * @returns {ResourceApi & { cfRaw: (path: string, init?: RequestInit) => Promise<{ok: boolean, status: number, result?: any, error?: string}> }}
+ */
+export function createCloudflareResourceApi({ accountId, apiToken, fetch: fetchImpl }) {
+  const doFetch = fetchImpl ?? globalThis.fetch;
+  if (typeof doFetch !== 'function') {
+    throw new Error('createCloudflareResourceApi：這個執行環境沒有 fetch，請用 options.fetch 注入。');
+  }
+  const accountBase = `${CF_API_BASE}/accounts/${accountId}`;
+  const headers = {
+    Authorization: `Bearer ${apiToken}`,
+    'Content-Type': 'application/json',
+  };
+
+  /**
+   * 把 HTTP status 交回呼叫端自己判斷（要區分「404 不存在」和「其他錯誤」時用）。
+   * @param {string} path
+   * @param {RequestInit} [init]
+   * @returns {Promise<{ok: boolean, status: number, result?: any, error?: string}>}
+   */
+  async function cfRaw(path, init) {
+    const res = await doFetch(`${accountBase}${path}`, {
+      ...init,
+      headers: { ...headers, ...(init?.headers ?? {}) },
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok || !data?.success) {
+      return {
+        ok: false,
+        status: res.status,
+        error:
+          (data?.errors ?? []).map((/** @type {{message?: string}} */ e) => e.message).filter(Boolean).join('; ') ||
+          `HTTP ${res.status}`,
+      };
+    }
+    return { ok: true, status: res.status, result: data.result };
+  }
+
+  /**
+   * @param {string} path
+   * @param {RequestInit} [init]
+   * @returns {Promise<any>}
+   */
+  async function cf(path, init) {
+    const { ok, status, result, error } = await cfRaw(path, init);
+    if (!ok) throw new Error(`CF API ${path} 失敗：${error ?? `HTTP ${status}`}`);
+    return result;
+  }
+
+  return {
+    cfRaw,
+
+    /**
+     * 讀一顆已部署 worker 現在綁著哪些資源——**使用者那側的事實**（Arcrun#97 的唯一真相源）。
+     *
+     * - script 不存在（404）→ `{ deployed: false }`，這是「還沒部署」，不是錯誤。
+     * - 其他任何失敗 → throw。呼叫端必須把它當「我不知道」而**不是**「它沒有」——
+     *   把查不到當成不存在，就是 #97 的根因。
+     *
+     * @param {string} script
+     * @returns {Promise<ScriptBindings>}
+     */
+    async getScriptBindings(script) {
+      const path = `/workers/scripts/${encodeURIComponent(script)}/settings`;
+      const res = await cfRaw(path);
+      if (!res.ok) {
+        if (res.status === 404) return { deployed: false, bindings: [], vars: {} };
+        throw new Error(`讀 ${script} 綁定失敗：${res.error}`);
+      }
+      /** @type {RawWorkerBinding[]} */
+      const raw = res.result?.bindings ?? [];
+      return {
+        deployed: true,
+        bindings: normalizeLiveBindings(raw),
+        vars: normalizeLiveVars(raw),
+      };
+    },
+
+    /** @returns {Promise<Map<string, string>>} title → id */
+    async listKvNamespaces() {
+      /** @type {Array<{id: string, title: string}>} */
+      const result = await cf('/storage/kv/namespaces?per_page=100');
+      const map = new Map();
+      for (const ns of result) map.set(ns.title, ns.id);
+      return map;
+    },
+
+    /** @returns {Promise<Map<string, string>>} name → uuid */
+    async listD1Databases() {
+      /** @type {Array<{uuid: string, name: string}>} */
+      const result = await cf('/d1/database?per_page=100');
+      const map = new Map();
+      for (const db of result) map.set(db.name, db.uuid);
+      return map;
+    },
+
+    /** @returns {Promise<string[]>} */
+    async listVectorizeIndexes() {
+      /** @type {Array<{name: string}>} */
+      const result = await cf('/vectorize/v2/indexes');
+      return (result ?? []).map((i) => i.name);
+    },
+
+    /**
+     * 無條件新建一顆 KV namespace。
+     *
+     * 🔴 Arcrun#97：這裡**故意沒有**「找不到同名就順手建一顆」的 ensure 版本。
+     * 「照名字找 → 找不到 → 新建 → 綁上去」正是把使用者實例洗成空的那條路
+     * （安裝器取的名字跟 binding 名不一樣，永遠對不上 ⇒ 每次更新都新建）。
+     * 要不要建一律先過 `planResources`。
+     *
+     * @param {string} title
+     * @returns {Promise<string>}
+     */
+    async createKvNamespace(title) {
+      const result = await cf('/storage/kv/namespaces', {
+        method: 'POST',
+        body: JSON.stringify({ title }),
+      });
+      return result.id;
+    },
+
+    /**
+     * 無條件新建 D1。沒有 ensure 版本，理由同 createKvNamespace（Arcrun#97）。
+     * @param {string} name
+     * @returns {Promise<string>}
+     */
+    async createD1Database(name) {
+      const result = await cf('/d1/database', {
+        method: 'POST',
+        body: JSON.stringify({ name }),
+      });
+      return result.uuid;
+    },
+
+    /**
+     * 新建 KBDB embed 用的 Vectorize index（**bge-m3 = 1024 維 / cosine**）。
+     * 已存在（409 / already exists）視為成功——並行或重跑不該炸。
+     * 沒有 ensure 版本：「要不要建」由 planResources 判斷，這裡只負責建（Arcrun#97）。
+     *
+     * @param {string} name
+     * @returns {Promise<string>}
+     */
+    async createVectorizeIndex(name) {
+      const res = await cfRaw('/vectorize/v2/indexes', {
+        method: 'POST',
+        body: JSON.stringify({
+          name,
+          config: { dimensions: 1024, metric: 'cosine' },
+          description: 'arcrun KBDB embed module — bge-m3 1024d (issue #7 / #59)',
+        }),
+      });
+      if (res.ok) return name;
+      const detail = (res.error ?? '').toLowerCase();
+      if (res.status === 409 || /already exists|duplicate|conflict/.test(detail)) return name;
+      throw new Error(`建 Vectorize index ${name} 失敗：${res.error}`);
+    },
+  };
+}
@@ -0,0 +1,100 @@
+// @ts-check
+/**
+ * installer-entry.mjs — 安裝器那條路的**唯一入口**。
+ *
+ * 安裝器（arcrun-rag `installer/oauth-prototype/worker.js`）不必、也不准自己判斷
+ * 「該建哪些資源」——它只要呼叫這一支，拿回「每個 binding 該用哪顆資源」。
+ *
+ * ```js
+ * import { resolveInstanceResources } from './shared/resource-rule/installer-entry.mjs';
+ *
+ * const r = await resolveInstanceResources({
+ *   accountId, apiToken,
+ *   wranglerTomls: [cypherToml, registryToml, mcpToml, kbdbToml],  // 字串陣列
+ *   mode: isUpdate ? 'update' : 'init',
+ * });
+ * if (r.blocked) {
+ *   // 🔴 一顆資源都沒被建。把 r.blockers 原文顯示給使用者，**不要自己「試著繼續」**。
+ *   return showAndStop(r.blockers);
+ * }
+ * // r.bindings: { 'kv_namespace:WEBHOOKS': 'kvid-…', 'd1:DB': 'uuid-…', … }
+ * // r.liveVars: { 'arcrun-cypher-executor': { ARCRUN_BUNDLE_VERSION: '1.4.33', … } }
+ * ```
+ *
+ * 為什麼安裝器不需要副本：安裝器本來就會下載本 repo 的 archive 當部署來源
+ * （見 `.claude/rules/05-deploy-convention.md`「WASM 來源」），
+ * `shared/resource-rule/` 就在那份 archive 裡，直接 import 即可——
+ * **不必再編一次、不必貼一份、也就不會有第二種答案。**
+ */
+
+import { planResources, applyResourcePlan, parseWranglerRequirements, ResourcePlanBlocked } from './rule.mjs';
+import { createCloudflareResourceApi } from './cf-resource-api.mjs';
+
+/**
+ * @typedef {object} ResolveOptions
+ * @property {string} accountId
+ * @property {string} apiToken
+ * @property {string[]} wranglerTomls  各 worker 的 wrangler.toml **內容**（不是路徑）。
+ * @property {'update' | 'init'} mode  這台照定義裝過了沒。
+ * @property {typeof globalThis.fetch} [fetch]  注入用（測試／宿主自帶 fetch）。
+ */
+
+/**
+ * @typedef {object} ResolveResult
+ * @property {boolean} blocked            true = 什麼都沒建、什麼都不該部署。
+ * @property {string[]} blockers          blocked 時的原因原文（要原樣轉給使用者）。
+ * @property {Record<string, string>} bindings   `${kind}:${binding}` → 資源 id／index 名。
+ * @property {Record<string, 'adopted'|'created'>} origin  同上 key → 這顆是沿用還是新建。
+ * @property {Record<string, Record<string, string>>} liveVars  script → 現有 plain_text var（#106）。
+ */
+
+/**
+ * 決定這台實例每個 binding 該用哪顆資源；照規則沿用既有、只在確定沒人綁過時才新建。
+ *
+ * @param {ResolveOptions} options
+ * @returns {Promise<ResolveResult>}
+ */
+export async function resolveInstanceResources({ accountId, apiToken, wranglerTomls, mode, fetch }) {
+  const api = createCloudflareResourceApi({ accountId, apiToken, fetch });
+
+  /** @type {import('./rule.mjs').BindingRequirement[]} */
+  const requirements = [];
+  for (const toml of wranglerTomls) {
+    const parsed = parseWranglerRequirements(toml);
+    if (!parsed.script) continue;  // 沒宣告 name 的 toml 不該存在；跳過而非亂猜
+    for (const b of parsed.bindings) requirements.push({ ...b, worker: parsed.script });
+  }
+
+  /** @param {string[]} blockers @returns {ResolveResult} */
+  const stop = (blockers) => ({ blocked: true, blockers, bindings: {}, origin: {}, liveVars: {} });
+
+  if (requirements.length === 0) {
+    return stop(['這批 wrangler.toml 裡讀不到任何資源綁定需求——不確定要裝什麼，停手。']);
+  }
+
+  let plan;
+  try {
+    plan = await planResources(api, requirements, mode);
+  } catch (e) {
+    return stop([`資源解析失敗（${e instanceof Error ? e.message : String(e)}）。沒有建立任何資源。`]);
+  }
+  if (plan.blockers.length > 0) return stop(plan.blockers);
+
+  /** @type {Map<string, import('./rule.mjs').ResolvedResource>} */
+  let resolved;
+  try {
+    resolved = await applyResourcePlan(api, plan);
+  } catch (e) {
+    return stop(e instanceof ResourcePlanBlocked ? e.blockers : [e instanceof Error ? e.message : String(e)]);
+  }
+
+  /** @type {Record<string, string>} */
+  const bindings = {};
+  /** @type {Record<string, 'adopted'|'created'>} */
+  const origin = {};
+  for (const [key, r] of resolved) {
+    bindings[key] = r.value;
+    origin[key] = r.origin;
+  }
+  return { blocked: false, blockers: [], bindings, origin, liveVars: Object.fromEntries(plan.liveVars) };
+}
@@ -0,0 +1,570 @@
+// @ts-check
+/**
+ * rule.mjs — 「這個實例該用哪些資源」的**唯一一份**規則。
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 這份檔案為什麼在這裡（`shared/`），不在 `cli/`
+ * ─────────────────────────────────────────────────────────────────────────────
+ * leo 2026-08-12：「根本就不應該在 CLI，我要的是一個大家都可以用到的規則。」
+ *
+ * `.claude/rules/07-thin-shell.md` 的判準口訣：
+ *   「這段邏輯換一個介面要不要重寫？」要重寫 → 它是能力，該在共用層。
+ *
+ * 「該沿用哪幾顆資源」換到安裝器就得重寫一次 ⇒ 它是**能力**，不是薄殼的事。
+ * 而它原本住在 `cli/src/lib/resource-resolver.ts` ⇒ 那本身就是違規，
+ * 後果也真的發生了：`acr` 那條有這條規則、安裝器那條沒有，於是安裝器照名字找、
+ * 找不到就建新的空的 ⇒ Arcrun#97「我按了更新，工作流和登入全不見了」。
+ *
+ * ── 為什麼不是 cypher-executor 的 API 端點（薄殼原則的標準答案）────────────
+ * **自舉**：這條規則要在「決定怎麼裝／怎麼更新」的當下就用得到，而那個當下
+ * cypher 可能還不存在（安裝器的工作正是把它生出來），或正要被覆蓋。
+ * 而且判斷的輸入是**使用者自己 Cloudflare 帳號上的綁定狀態**——
+ * 把它送去一顆平台託管的 worker 換一個答案，等於①讓「能不能安裝」綁在平台是否活著，
+ * ②把使用者的帳號拓撲交給第三方。兩件都不該為了形式上的漂亮而做。
+ *
+ * 薄殼原則要求的是「能力只實作一次」，不是「能力一定要是 HTTP」。
+ * 這條規則是**純函式**（唯一的 IO 由呼叫端注入 `ResourceApi`），
+ * 所以它用不著變成服務——一份零依賴的 ESM 就能讓每條路吃到同一份判斷。
+ *
+ * ── 怎麼讓兩條路吃到「同一份」而不是各留一份 ───────────────────────────────
+ * 本檔是**唯一被人手維護的實作**，零依賴、不吃任何 node 內建、Workers runtime 可直接跑。
+ *   · `acr`：`cli/src/lib/resource-rule.mjs` 是本檔的**逐位元組副本**，
+ *     由 `scripts/sync-resource-rule.mjs` 產生（CLI 要能單獨 npm publish，
+ *     套件目錄外的檔案打不進 tarball，故必須有這一份）。
+ *     `npm run build` / `npm test` 都會跑 `--check`，內容一漂就紅。
+ *     ——同 `cli/harness/`（產生物＋世代閘）的既有慣例。
+ *   · 安裝器 / 任何 Worker：安裝器本來就會下載本 repo 的 archive（部署來源，
+ *     見 `.claude/rules/05-deploy-convention.md`「WASM 來源」），
+ *     直接 import 這一份 `shared/resource-rule/rule.mjs` 即可，**不需要再編一次、也不留副本**。
+ *     用法見同目錄 README.md。
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 規則本身（leo 的兩句話）
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 「如果你沒有裝，就是新的；如果你已經有，原來叫什麼名字就繼續用下去。」
+ *
+ * 判準是「**這顆 worker 現在綁著誰**」，不是「有沒有叫這個名字的資源」：
+ *   1. **已部署的 worker 上綁著什麼，那就是事實** → 原封不動沿用，不管那顆資源叫什麼名字。
+ *   2. **只有「確定沒有任何人綁過它」才准新建**（新版本新增的 binding、或真的全新帳號）。
+ *   3. **只要有一點說不準就整趟停手**（讀不到綁定／綁著的資源不見了／同一個 binding 指向兩顆／
+ *      該更新的 worker 一顆都不在），**什麼都不建、什麼都不部署**，把話說清楚讓人來判斷。
+ *
+ * ── 為什麼拆成 plan / apply 兩段 ─────────────────────────────────────
+ *   `planResources()` **完全不寫入**，只回一份「要沿用什麼、要新建什麼、有什麼不敢動的」。
+ *   `applyResourcePlan()` 看到有任何 blocker 就直接拒絕執行。
+ *   ⇒「被擋下的時候一顆資源都不會被建出來」是**結構上的保證**，
+ *     不是靠某個人記得在對的地方寫 early return。#97 正是死在「先動手、後判斷」。
+ *
+ * 🔴 這份檔案沒有 import、也不准有。任何依賴都會讓某一條路吃不到它。
+ */
+
+/**
+ * 這支負責的資源種類。要加新種類（R2/Queue/Hyperdrive…）就加在這裡，
+ * 一律走同一道門——不准任何呼叫端自己「照名字 ensure」繞過去。
+ * @typedef {'kv_namespace' | 'd1' | 'vectorize'} ResourceKind
+ */
+
+/**
+ * 從已部署 worker 上讀回來的一條綁定。`value`：KV/D1 是資源 id，Vectorize 是 index 名。
+ * @typedef {object} LiveBinding
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} value
+ */
+
+/**
+ * @typedef {object} ScriptBindings
+ * @property {boolean} deployed
+ *   false = 這顆 worker 在帳號上還不存在（全新部署），不是「讀取失敗」。讀取失敗要 throw。
+ * @property {LiveBinding[]} bindings
+ * @property {Record<string, string>} [vars]
+ *   這顆 worker 現在掛著的 `plain_text` var（名 → 值）。
+ *
+ *   🔴 Arcrun#106：#97 只把「資源類」綁定當成事實沿用（KV/D1/Vectorize），
+ *     plain_text var 整批沒人管 ⇒ 重部署把它們洗成 repo toml 的預設值。
+ *     最痛的一個是 `ARCRUN_BUNDLE_VERSION`（安裝器注入的版本標籤）——
+ *     更新完就消失，Portal 設定頁變成「無法讀取目前版本」。
+ *     **保留了櫃子，沒保留櫃子上的標籤**。這個欄位就是那些標籤。
+ */
+
+/**
+ * 規則需要的 CF 能力（收窄成介面，方便離線測試餵假帳號，也讓安裝器用自己的 fetch 實作）。
+ * @typedef {object} ResourceApi
+ * @property {(script: string) => Promise<ScriptBindings>} getScriptBindings
+ * @property {() => Promise<Map<string, string>>} listKvNamespaces  title → id
+ * @property {() => Promise<Map<string, string>>} listD1Databases   name → uuid
+ * @property {() => Promise<string[]>} listVectorizeIndexes
+ * @property {(title: string) => Promise<string>} createKvNamespace
+ * @property {(name: string) => Promise<string>} createD1Database
+ * @property {(name: string) => Promise<string>} createVectorizeIndex
+ */
+
+/**
+ * 「這顆 worker 需要這個 binding」。createName 只在**真的要新建**時才會被拿來當名字用。
+ * @typedef {object} BindingRequirement
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} worker  需要它的 worker script 名（= wrangler.toml 的 `name`）。
+ * @property {string} createName
+ */
+
+/**
+ * @typedef {object} PlannedAdopt
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} value
+ * @property {string} from  從哪顆已部署的 worker 上讀到的
+ */
+
+/**
+ * @typedef {object} PlannedCreate
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} createName
+ * @property {string[]} wantedBy
+ * @property {string[]} alsoBind  其他也指向同一顆資源的 binding（見 shareSameResource）。建一顆，大家共用。
+ */
+
+/**
+ * @typedef {object} ResourcePlan
+ * @property {PlannedAdopt[]} adopt
+ * @property {PlannedCreate[]} create
+ * @property {string[]} blockers  非空 = 整趟停手。applyResourcePlan 會拒絕執行。
+ * @property {Map<string, Record<string, string>>} liveVars
+ *   每顆**已部署** worker 現在掛著的 plain_text var（script → 名/值）。未部署的不在裡面。
+ *
+ *   Arcrun#106：讀綁定的時候本來就把整份 `bindings[]` 拿回來了，var 就在同一份回應裡——
+ *   順手帶出來，**不另外打一次 API**，也不新增一種「查不到」的失敗模式
+ *   （讀不到綁定這件事已經在上面 blockers 那一關擋掉了）。
+ */
+
+/**
+ * @typedef {object} ResolvedResource
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} value
+ * @property {'adopted' | 'created'} origin
+ * @property {string} [from]
+ */
+
+/**
+ * @typedef {object} WranglerRequirements
+ * @property {string} script  worker script 名（toml 頂層 `name`）。空字串 = 這份 toml 沒宣告 name（不該發生）。
+ * @property {Array<{kind: ResourceKind, binding: string, createName: string}>} bindings
+ */
+
+/** plan 被擋下時丟這個，讓呼叫端能把每一條原因原文轉給使用者。 */
+export class ResourcePlanBlocked extends Error {
+  /** @param {string[]} blockers */
+  constructor(blockers) {
+    super(`資源解析被擋下（${blockers.length} 項）`);
+    this.name = 'ResourcePlanBlocked';
+    /** @type {string[]} */
+    this.blockers = blockers;
+  }
+}
+
+/**
+ * @param {ResourceKind} kind
+ * @param {string} binding
+ * @returns {string}
+ */
+export function bindingKey(kind, binding) {
+  return `${kind}:${binding}`;
+}
+
+/** @type {Record<ResourceKind, string>} */
+export const KIND_LABEL = {
+  kv_namespace: 'KV namespace',
+  d1: 'D1 資料庫',
+  vectorize: 'Vectorize index',
+};
+
+/**
+ * @param {unknown} e
+ * @returns {string}
+ */
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+/**
+ * 決定每個 binding 要沿用哪顆資源／要不要新建，**不寫入任何東西**。
+ *
+ * @param {ResourceApi} api
+ * @param {readonly BindingRequirement[]} requirements
+ * @param {'update' | 'init'} mode
+ *   'update' = 這台照定義已經裝過了（見下方「一顆都不在」規則）；'init' = 全新安裝，允許從零建。
+ * @returns {Promise<ResourcePlan>}
+ */
+export async function planResources(api, requirements, mode) {
+  /** @type {string[]} */
+  const blockers = [];
+  /** @type {PlannedAdopt[]} */
+  const adopt = [];
+  /** @type {PlannedCreate[]} */
+  const create = [];
+
+  // ── 1. 先讀「即將被覆蓋的每一顆 worker」現在綁著什麼 ──────────────────
+  // 讀取失敗 ≠ 沒有綁。#97 的災情就是把「我查不到」當成「它不存在」。
+  const scripts = [...new Set(requirements.map((r) => r.worker))].sort();
+  /** @type {Map<string, LiveBinding[]>} */
+  const live = new Map();
+  /** @type {Map<string, Record<string, string>>} */
+  const liveVars = new Map();
+  let readFailed = false;
+  for (const script of scripts) {
+    try {
+      const res = await api.getScriptBindings(script);
+      if (res.deployed) {
+        live.set(script, res.bindings);
+        // #106：同一份回應裡的 plain_text var 一起收下（呼叫端要拿它決定哪些 var 該沿用）。
+        liveVars.set(script, res.vars ?? {});
+      }
+    } catch (e) {
+      readFailed = true;
+      blockers.push(
+        `讀不到已部署的 worker「${script}」目前綁著哪些資源（${msg(e)}）。` +
+          `不確定它現在用的是哪一顆，就不能重新綁——整趟更新停手，沒有動任何東西。`,
+      );
+    }
+  }
+
+  // 「這台照定義已經裝過了，卻一顆 worker 都找不到」= 我對不上它的實例（名字不同／token 看不到）。
+  // 這種時候繼續走下去，等於把一整套資源重新生一遍再綁上去——正是 #97 的形狀，只是換一道門進來。
+  if (mode === 'update' && !readFailed && live.size === 0 && scripts.length > 0) {
+    blockers.push(
+      `在這個 Cloudflare 帳號上找不到任何一顆要更新的 worker（找過：${scripts.join('、')}）。` +
+        `acr update 的前提是「這台已經裝好了」——對不上就不猜：` +
+        `可能是 API token 看得到的帳號不對，或這台實例的 worker 用了別的名字。` +
+        `已停手，沒有新建任何資源。`,
+    );
+  }
+
+  // ── 2. 逐個 binding 決定：沿用 / 新建 / 停手 ─────────────────────────
+  /** @type {Map<string, BindingRequirement[]>} */
+  const byKey = new Map();
+  for (const req of requirements) {
+    const key = bindingKey(req.kind, req.binding);
+    const list = byKey.get(key);
+    if (list) list.push(req);
+    else byKey.set(key, [req]);
+  }
+
+  /** @type {Map<ResourceKind, Set<string>>} */
+  const existingCache = new Map();
+  /** @param {ResourceKind} kind @returns {Promise<Set<string>>} */
+  const listExisting = async (kind) => {
+    const hit = existingCache.get(kind);
+    if (hit) return hit;
+    /** @type {Set<string>} */
+    let set;
+    if (kind === 'kv_namespace') set = new Set((await api.listKvNamespaces()).values());
+    else if (kind === 'd1') set = new Set((await api.listD1Databases()).values());
+    else set = new Set(await api.listVectorizeIndexes());
+    existingCache.set(kind, set);
+    return set;
+  };
+
+  for (const [, reqs] of byKey) {
+    const { kind, binding } = reqs[0];
+
+    /** @type {Array<{value: string, script: string}>} */
+    const found = [];
+    for (const [script, bindings] of live) {
+      const hit = bindings.find((b) => b.kind === kind && b.binding === binding);
+      if (hit) found.push({ value: hit.value, script });
+    }
+    const distinct = [...new Set(found.map((f) => f.value))];
+
+    // 2a. 同一個 binding 名在不同 worker 上指向不同資源 → 分不出哪個才是使用者要的。
+    //     自己挑一個 = 有一半機率把另外那半的資料從畫面上抹掉。不猜。
+    if (distinct.length > 1) {
+      blockers.push(
+        `綁定「${binding}」在不同 worker 上指向不同的 ${KIND_LABEL[kind]}` +
+          `（${found.map((f) => `${f.script} → ${f.value}`).join('、')}）。` +
+          `分不出哪一顆才是你在用的，不猜——停手。`,
+      );
+      continue;
+    }
+
+    // 2b. 有人綁著它 → 這就是事實，沿用。名字長什麼樣完全不看。
+    if (distinct.length === 1) {
+      const value = distinct[0];
+      /** @type {Set<string>} */
+      let existing;
+      try {
+        existing = await listExisting(kind);
+      } catch (e) {
+        blockers.push(
+          `查不到帳號上的 ${KIND_LABEL[kind]} 清單，無法確認「${binding}」綁著的 ${value} 還在不在` +
+            `（${msg(e)}）。不確定就不動——停手。`,
+        );
+        continue;
+      }
+      if (!existing.has(value)) {
+        // 這正是 #97 的入口：舊版在這裡會安靜地新建一顆空的頂上去。
+        blockers.push(
+          `worker「${found[0].script}」的「${binding}」綁著 ${KIND_LABEL[kind]} ${value}，` +
+            `但這顆在你的 Cloudflare 帳號上找不到了。` +
+            `這裡**不會**幫你新建一顆空的頂上去（Arcrun#97 的災情就是那樣來的）——` +
+            `請先確認那顆資源是被刪掉了，還是這把 API token 看不到它。`,
+        );
+        continue;
+      }
+      adopt.push({ kind, binding, value, from: found[0].script });
+      continue;
+    }
+
+    // 2c. 沒有任何已部署的 worker 綁過它 → 新版本新增的 binding，或全新帳號。
+    //     這種情況下新建不會弄丟任何東西（本來就沒有東西可丟）。
+    create.push({
+      kind,
+      binding,
+      createName: reqs[0].createName,
+      wantedBy: [...new Set(reqs.map((r) => r.worker))],
+      alsoBind: [],
+    });
+  }
+
+  return { adopt, create: shareSameResource(adopt, create, byKey), blockers, liveVars };
+}
+
+/**
+ * 收斂「不同 binding 其實是同一顆資源」的情況。
+ *
+ * 判準是 **toml 自己宣告的名字**（`database_name` / `index_name`），不是使用者那側的資源名——
+ * cypher 的 `CREDENTIALS_DB` 與 kbdb 的 `DB` 都寫 `database_name = "arcrun-kbdb"`，
+ * 那是**我們**在宣告「這兩個綁定指向同一顆庫」，跟 #97 那種「拿名字去猜使用者的資源」是兩回事。
+ *
+ * 沒有這一步會出兩種錯：
+ *   ① 全新安裝時建出兩顆同名 D1，KBDB 的資料與 credential 目錄從此分家。
+ *   ② 一邊已部署（沿用既有）、另一邊沒有（新建一顆空的）→ 半套資料，比全壞更難查。
+ *
+ * @param {PlannedAdopt[]} adopt
+ * @param {PlannedCreate[]} create
+ * @param {Map<string, BindingRequirement[]>} byKey
+ * @returns {PlannedCreate[]}
+ */
+function shareSameResource(adopt, create, byKey) {
+  /** @param {ResourceKind} kind @param {string} binding @returns {string | undefined} */
+  const declaredName = (kind, binding) =>
+    byKey.get(bindingKey(kind, binding))?.[0]?.createName;
+
+  /** @type {PlannedCreate[]} */
+  const out = [];
+  /** @type {Map<string, PlannedCreate>} */
+  const groups = new Map();
+
+  for (const c of create) {
+    const groupKey = `${c.kind} ${c.createName}`;
+
+    // ① 已經有 binding 沿用到同一顆（依 toml 宣告）→ 跟著沿用，不要另外建一顆。
+    const twin = adopt.find(
+      (a) => a.kind === c.kind && declaredName(a.kind, a.binding) === c.createName,
+    );
+    if (twin) {
+      adopt.push({ kind: c.kind, binding: c.binding, value: twin.value, from: twin.from });
+      continue;
+    }
+
+    // ② 同一趟裡有多個 binding 要建同一顆 → 建一次，其他人共用。
+    const head = groups.get(groupKey);
+    if (head) {
+      head.alsoBind.push(c.binding);
+      head.wantedBy = [...new Set([...head.wantedBy, ...c.wantedBy])];
+      continue;
+    }
+    groups.set(groupKey, c);
+    out.push(c);
+  }
+  return out;
+}
+
+/**
+ * 照 plan 動手：沿用的原樣帶出來，該建的才建。
+ * 有任何 blocker 直接丟 ResourcePlanBlocked，**一顆都不建**。
+ *
+ * @param {ResourceApi} api
+ * @param {ResourcePlan} plan
+ * @returns {Promise<Map<string, ResolvedResource>>}
+ */
+export async function applyResourcePlan(api, plan) {
+  if (plan.blockers.length > 0) throw new ResourcePlanBlocked(plan.blockers);
+
+  /** @type {Map<string, ResolvedResource>} */
+  const out = new Map();
+  for (const a of plan.adopt) {
+    out.set(bindingKey(a.kind, a.binding), {
+      kind: a.kind,
+      binding: a.binding,
+      value: a.value,
+      origin: 'adopted',
+      from: a.from,
+    });
+  }
+  /** @type {string[]} */
+  const madeSoFar = [];
+  for (const c of plan.create) {
+    /** @type {string} */
+    let value;
+    try {
+      if (c.kind === 'kv_namespace') value = await api.createKvNamespace(c.createName);
+      else if (c.kind === 'd1') value = await api.createD1Database(c.createName);
+      else value = await api.createVectorizeIndex(c.createName);
+    } catch (e) {
+      // 半途失敗：已經建出來的那幾顆還沒被綁到任何 worker 上。**要講出來**——
+      // 不講的話它們就是帳號上一批沒人認得的孤兒，而且下次重跑會再建一批。
+      const orphans = madeSoFar.length > 0
+        ? `\n  已經建好但還沒綁上任何 worker 的：${madeSoFar.join('、')}（重跑前可先刪掉，或留著讓下次沿用）`
+        : '';
+      throw new Error(`建 ${KIND_LABEL[c.kind]}「${c.createName}」失敗：${msg(e)}${orphans}`);
+    }
+    madeSoFar.push(`${KIND_LABEL[c.kind]} ${c.createName}`);
+    for (const binding of [c.binding, ...c.alsoBind]) {
+      out.set(bindingKey(c.kind, binding), { kind: c.kind, binding, value, origin: 'created' });
+    }
+  }
+  return out;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// wrangler.toml → 需求清單
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * wrangler.toml 的 table 名 → 資源種類。需求解析與注入共用同一張表，兩邊才不會對不上。
+ * @type {Record<string, ResourceKind>}
+ */
+export const TABLE_KIND = {
+  kv_namespaces: 'kv_namespace',
+  d1_databases: 'd1',
+  vectorize: 'vectorize',
+};
+
+/**
+ * 從 wrangler.toml 抽出「這顆 worker 需要哪些資源綁定」。
+ *
+ * 刻意寫成行掃描而不引 TOML parser：注入端（injectWranglerConfig）本來就是純文字操作，
+ * 兩邊用同一種視角看這份檔案才不會對不上。註解掉的區塊**不算需求**
+ * （kbdb 的 `[[vectorize]]` 預設是註解狀態，要開語義查詢時才會被取消註解 → 那時才成為需求）。
+ *
+ * 也是「零依賴」的一部分：不引 TOML parser ⇒ 安裝器 import 這支不必多裝任何東西。
+ *
+ * @param {string} toml
+ * @returns {WranglerRequirements}
+ */
+export function parseWranglerRequirements(toml) {
+  let script = '';
+  let seenTable = false;
+  /** @type {WranglerRequirements['bindings']} */
+  const bindings = [];
+
+  /** @type {ResourceKind | null} */
+  let kind = null;
+  let binding = '';
+  let createName = '';
+
+  const flush = () => {
+    if (kind && binding) {
+      bindings.push({ kind, binding, createName: createName || binding });
+    }
+    kind = null;
+    binding = '';
+    createName = '';
+  };
+
+  for (const raw of toml.split('\n')) {
+    const line = raw.trim();
+    if (line === '' || line.startsWith('#')) continue;
+
+    const table = line.match(/^\[\[?([A-Za-z0-9_]+)\]?\]$/);
+    if (table) {
+      flush();
+      seenTable = true;
+      kind = TABLE_KIND[table[1]] ?? null;
+      continue;
+    }
+
+    const kv = line.match(/^([A-Za-z0-9_]+)\s*=\s*"([^"]*)"/);
+    if (!kv) continue;
+    const [, key, value] = kv;
+
+    if (!seenTable && key === 'name') {
+      script = value;
+      continue;
+    }
+    if (!kind) continue;
+    if (key === 'binding') binding = value;
+    // 只有 D1／Vectorize 在 toml 裡帶得出「名字」；KV 沒有，退回用 binding 名（見 flush）。
+    else if (key === 'database_name' || key === 'index_name') createName = value;
+  }
+  flush();
+
+  return { script, bindings };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Cloudflare `/settings` 回應 → 事實（兩條路都要用同一種眼睛看）
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * CF `GET /accounts/{id}/workers/scripts/{script}/settings` 回的 binding 原始形狀
+ * （同一種資源在不同 API 版本欄位名不一，故全都收）。
+ *
+ * @typedef {object} RawWorkerBinding
+ * @property {string} [type]
+ * @property {string} [name]
+ * @property {string} [namespace_id]
+ * @property {string} [id]
+ * @property {string} [database_id]
+ * @property {string} [index_name]
+ * @property {string} [text]  `plain_text` 綁定的值（#106；secret_text 不會回值，本來就讀不到，也不該讀）。
+ */
+
+/**
+ * 把 CF 的 binding 陣列收斂成規則認得的三種資源。不認得的型別直接略過。
+ *
+ * 🔴 這支**刻意放在規則裡**，不留在各自的 CF client：
+ *   「什麼才算『這顆 worker 綁著某顆資源』」是規則的一部分。
+ *   兩條路各自解讀 CF 回應 = 漂移會從這裡長回來（例如一邊認 `namespace_id`、
+ *   另一邊只認 `id`，於是一邊看得到綁定、另一邊看不到 → 後者又去新建了）。
+ *
+ * @param {RawWorkerBinding[]} raw
+ * @returns {LiveBinding[]}
+ */
+export function normalizeLiveBindings(raw) {
+  /** @type {LiveBinding[]} */
+  const out = [];
+  for (const b of raw) {
+    if (!b?.name) continue;
+    if (b.type === 'kv_namespace') {
+      const value = b.namespace_id ?? b.id;
+      if (value) out.push({ kind: 'kv_namespace', binding: b.name, value });
+    } else if (b.type === 'd1' || b.type === 'd1_database') {
+      const value = b.id ?? b.database_id;
+      if (value) out.push({ kind: 'd1', binding: b.name, value });
+    } else if (b.type === 'vectorize') {
+      if (b.index_name) out.push({ kind: 'vectorize', binding: b.name, value: b.index_name });
+    }
+  }
+  return out;
+}
+
+/**
+ * 抽出已部署 worker 上的 `plain_text` var（#106）。
+ *
+ * 只收 `plain_text`——**`secret_text` 一律不碰**（CF 本來就不回值，也不該被搬來搬去；
+ * wrangler deploy 不會動 secret，它們自己會留著）。
+ *
+ * @param {RawWorkerBinding[]} raw
+ * @returns {Record<string, string>}
+ */
+export function normalizeLiveVars(raw) {
+  /** @type {Record<string, string>} */
+  const out = {};
+  for (const b of raw) {
+    if (b?.type === 'plain_text' && b.name && typeof b.text === 'string') out[b.name] = b.text;
+  }
+  return out;
+}
@@ -0,0 +1,4 @@
+/** `node --import ./tests/register-ts-hooks.mjs --test ...` 的進入點：註冊 ts-hooks.mjs。 */
+import { register } from 'node:module';
+
+register('./ts-hooks.mjs', import.meta.url);
@@ -493,7 +493,7 @@ test('CfAccountClient.getScriptBindings：404 = 還沒部署；其他錯誤要 t
      new Response(JSON.stringify({ success: false, errors: [{ message: 'not found' }] }), { status: 404 })
    ) as typeof fetch;
    const cf = new CfAccountClient('a', 't');
-    assert.deepEqual(await cf.getScriptBindings('nope'), { deployed: false, bindings: [] });
+    assert.deepEqual(await cf.getScriptBindings('nope'), { deployed: false, bindings: [], vars: {} });

    globalThis.fetch = (async () =>
      new Response(JSON.stringify({ success: false, errors: [{ message: 'boom' }] }), { status: 500 })
@@ -526,6 +526,8 @@ test('CfAccountClient.getScriptBindings：讀得懂 CF 回的 kv/d1/vectorize
      { kind: 'd1', binding: 'DB', value: 'db1' },
      { kind: 'vectorize', binding: 'VECTORIZE', value: 'idx1' },
    ]);
+    // #106：plain_text 也要收下來（service 這種不認得的仍略過）。
+    assert.deepEqual(res.vars, { ENVIRONMENT: 'production' });
  } finally {
    globalThis.fetch = orig;
  }
@@ -0,0 +1,111 @@
+/**
+ * 「只有一份」的機械證明。
+ *
+ * leo 的驗收條件：「改完之後，`grep` 得出『決定用哪些資源』的邏輯**只有一個地方**。
+ * 兩個以上呼叫端各自有一份 ⇒ 不算完成。」
+ *
+ * 這份測試就是把那個 grep 寫成會紅的東西：
+ *   ① 規則的每一支函式，全 repo 只有 `shared/resource-rule/` 有實作
+ *      （`cli/src/lib/resource-rule/` 是它的逐位元組鏡射，由 sync 腳本產生並看守，不算第二份）
+ *   ② 鏡射與原稿逐位元組相同（sync --check 的同一道閘，這裡再測一次讓 `npm test` 也擋得住）
+ *   ③ 共用層不准長出依賴——有依賴就會有某條路吃不到它
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+
+const REPO = join(fileURLToPath(new URL('.', import.meta.url)), '..', '..');
+const SOURCE_DIR = join(REPO, 'shared/resource-rule');
+const MIRROR_DIR = join(REPO, 'cli/src/lib/resource-rule');
+
+/** 規則的實作特徵：這些**宣告**只准出現在原稿目錄（與它的鏡射）裡。 */
+const RULE_DECLARATIONS = [
+  'function planResources',
+  'function applyResourcePlan',
+  'function shareSameResource',
+  'function parseWranglerRequirements',
+  'function normalizeLiveBindings',
+  'function normalizeLiveVars',
+  'function createCloudflareResourceApi',
+];
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', '.wrangler', '.worker-builds', '.component-builds',
+  '.github-public', 'coverage',
+]);
+
+/** 只掃「人會寫程式的地方」；產生物與二進位不掃。 */
+function walk(dir: string, out: string[] = []): string[] {
+  for (const name of readdirSync(dir)) {
+    if (SKIP_DIRS.has(name)) continue;
+    const abs = join(dir, name);
+    const st = statSync(abs);
+    if (st.isDirectory()) walk(abs, out);
+    else if (/\.(ts|tsx|js|mjs|cjs)$/.test(name)) out.push(abs);
+  }
+  return out;
+}
+
+const sha256 = (b: Buffer): string => createHash('sha256').update(b).digest('hex');
+
+test('① 規則的實作全 repo 只有一份（原稿目錄 + 它的鏡射，沒有第三處）', () => {
+  const files = walk(REPO);
+  const offenders: string[] = [];
+
+  for (const abs of files) {
+    const rel = relative(REPO, abs);
+    // 原稿與鏡射本來就該有；測試檔在講規則、不是實作規則
+    if (rel.startsWith('shared/resource-rule/')) continue;
+    if (rel.startsWith('cli/src/lib/resource-rule/')) continue;
+    if (rel.startsWith('cli/tests/')) continue;
+    if (rel === 'scripts/sync-resource-rule.mjs') continue;
+
+    const src = readFileSync(abs, 'utf8');
+    for (const decl of RULE_DECLARATIONS) {
+      if (src.includes(decl)) offenders.push(`${rel} → ${decl}`);
+    }
+  }
+
+  assert.deepEqual(offenders, [],
+    '「決定用哪些資源」的實作出現在共用層之外——這正是本票要消滅的東西：\n' +
+    offenders.map((o) => `  • ${o}`).join('\n') +
+    '\n要改規則就改 shared/resource-rule/，呼叫端只准 import。');
+
+  console.log(`\n  ① 掃過 ${files.length} 個原始碼檔，${RULE_DECLARATIONS.length} 支規則函式的實作` +
+    ' 全部只出現在 shared/resource-rule/（＋機械鏡射）');
+});
+
+test('② CLI 帶的那份與原稿逐位元組相同（漂移＝第二份實作偷偷長出來）', () => {
+  const files = readdirSync(SOURCE_DIR).filter((f) => f.endsWith('.mjs')).sort();
+  assert.ok(files.length > 0, 'shared/resource-rule/ 裡沒有任何 .mjs 原稿');
+
+  const mirrored = readdirSync(MIRROR_DIR).filter((f) => f.endsWith('.mjs')).sort();
+  assert.deepEqual(mirrored, files, '鏡射目錄的檔案清單與原稿不一致');
+
+  for (const f of files) {
+    const a = sha256(readFileSync(join(SOURCE_DIR, f)));
+    const b = sha256(readFileSync(join(MIRROR_DIR, f)));
+    assert.equal(b, a, `cli/src/lib/resource-rule/${f} 與原稿不一致——不要手改產生物，` +
+      '改 shared/resource-rule/ 後跑 node scripts/sync-resource-rule.mjs');
+    console.log(`  ② ${f.padEnd(24)} sha256 ${a.slice(0, 16)}  原稿 = 鏡射`);
+  }
+});
+
+test('③ 共用層零外部依賴（只准 import 同目錄的兄弟檔）', () => {
+  for (const f of readdirSync(SOURCE_DIR).filter((x) => x.endsWith('.mjs'))) {
+    const src = readFileSync(join(SOURCE_DIR, f), 'utf8');
+    const imports = [...src.matchAll(/^\s*import\s[^'"]*['"]([^'"]+)['"]/gm)].map((m) => m[1]);
+    for (const spec of imports) {
+      assert.ok(spec.startsWith('./'),
+        `shared/resource-rule/${f} import 了 "${spec}"——共用層一旦有外部依賴，` +
+        '就會有某條路（Workers runtime／安裝器）吃不到它。');
+    }
+    assert.doesNotMatch(src, /require\(|from\s+['"]node:/,
+      `shared/resource-rule/${f} 用到 node 專屬 API——Cloudflare Workers 上跑不起來。`);
+    console.log(`  ③ ${f.padEnd(24)} import: ${imports.length ? imports.join(', ') : '（無）'}`);
+  }
+});
@@ -0,0 +1,21 @@
+/**
+ * 測試用 resolve hook：把 `./x.js` 這種 import 指回同名的 `./x.ts`（Arcrun#106 附帶修復）。
+ *
+ * 為什麼需要：`src/` 內部的 import 一律寫成 `.js`（NodeNext 慣例，編譯後才會有那個檔），
+ * 但測試是**直接載入 `src/**\/*.ts`**、不經過 tsc（`outDir: dist`，所以 `src/` 底下永遠不會有 .js）。
+ * Node 的型別剝離不會自己把 `.js` 對回 `.ts` ⇒ 三份測試在 node 22 上**一支都跑不起來**
+ * （`ERR_MODULE_NOT_FOUND: .../src/lib/cf-api.js`）——包含 #97 那份「使用者的東西還在不在」的迴歸守衛。
+ * 跑不起來的守衛等於沒有守衛，所以這裡補上。
+ *
+ * 只在「預設解析失敗」時才動作，且只換副檔名 → 對本來就解析得到的環境（新版 node / 已編譯）零影響。
+ */
+export async function resolve(specifier, context, next) {
+  try {
+    return await next(specifier, context);
+  } catch (err) {
+    if (typeof specifier === 'string' && specifier.endsWith('.js')) {
+      return next(specifier.slice(0, -3) + '.ts', context);
+    }
+    throw err;
+  }
+}
@@ -0,0 +1,159 @@
+/**
+ * 兩條路必須得出同一個答案 —— 本票的核心驗收。
+ *
+ * leo 2026-08-12：「根本就不應該在 CLI，我要的是一個大家都可以用到的規則。」
+ *
+ * 後果已經真的發生過：`acr` 那條有 Arcrun#97 的修法、安裝器那條沒有，
+ * 於是安裝器照名字找、找不到就建一顆空的綁上去 ⇒ 使用者的工作流與登入狀態整片消失。
+ *
+ * 這份測試把**同一個帳號狀態**餵給兩條路：
+ *   A. `acr` 那條：`CfAccountClient` + `resource-resolver`（CLI 真正跑的 import 鏈）
+ *   B. 安裝器那條：只 import `shared/resource-rule/`（安裝器唯一該碰的入口）
+ * 然後比對它們選出的 **resource id 必須相同**。
+ *
+ * 假的是 `fetch`，不是 `ResourceApi`——所以兩條路都真的走完 HTTP → 解析 → 判斷整條鏈。
+ * 只測判斷會漏掉「怎麼把 CF 回應讀成事實」，而 #97 的重演只要眼睛不一樣就夠了。
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+// ── A：acr 那條（CLI 真正用的東西）
+import { CfAccountClient } from '../src/lib/cf-api.ts';
+import { planResources, applyResourcePlan, bindingKey } from '../src/lib/resource-resolver.ts';
+import type { BindingRequirement } from '../src/lib/resource-resolver.ts';
+
+// ── B：安裝器那條（只碰 shared/）
+import { resolveInstanceResources } from '../../shared/resource-rule/installer-entry.mjs';
+
+// ── 共用 fixture
+import {
+  makeAccount,
+  requirements,
+  SCENARIOS,
+  WORKER_NEEDS,
+  type Scenario,
+} from '../../shared/resource-rule/tests/fixture-account.mjs';
+
+const ACCOUNT = 'acct-fixture';
+const TOKEN = 'tok-fixture';
+
+/** 把 fixture 的需求組成安裝器吃的 wrangler.toml 文字（它的入口是從 toml 讀需求的）。 */
+function tomlsFor(): string[] {
+  return Object.entries(WORKER_NEEDS).map(([script, need]) => {
+    let t = `name = "${script}"\ncompatibility_date = "2025-02-19"\n`;
+    for (const b of need.kv) t += `\n[[kv_namespaces]]\nbinding = "${b}"\nid = "PLACEHOLDER"\n`;
+    for (const d of need.d1) {
+      t += `\n[[d1_databases]]\nbinding = "${d.binding}"\ndatabase_name = "${d.database_name}"\ndatabase_id = "PLACEHOLDER"\n`;
+    }
+    return t;
+  });
+}
+
+/** A：跑 acr 那條。CfAccountClient 走 global fetch，所以這裡把它換成 fixture。 */
+async function runAcrPath(scenario: Scenario, mode: 'update' | 'init') {
+  const account = makeAccount(scenario);
+  const realFetch = globalThis.fetch;
+  globalThis.fetch = account.fetch;
+  try {
+    const api = new CfAccountClient(ACCOUNT, TOKEN);
+    const plan = await planResources(api, requirements() as BindingRequirement[], mode);
+    if (plan.blockers.length > 0) {
+      return { blocked: true, blockers: plan.blockers, bindings: {} as Record<string, string>, account };
+    }
+    const resolved = await applyResourcePlan(api, plan);
+    const bindings: Record<string, string> = {};
+    for (const [k, r] of resolved) bindings[k] = r.value;
+    return { blocked: false, blockers: [] as string[], bindings, account };
+  } finally {
+    globalThis.fetch = realFetch;
+  }
+}
+
+/** B：跑安裝器那條。只用 shared/ 的入口，fetch 直接注入。 */
+async function runInstallerPath(scenario: Scenario, mode: 'update' | 'init') {
+  const account = makeAccount(scenario);
+  const r = await resolveInstanceResources({
+    accountId: ACCOUNT,
+    apiToken: TOKEN,
+    wranglerTomls: tomlsFor(),
+    mode,
+    fetch: account.fetch,
+  });
+  return { blocked: r.blocked, blockers: r.blockers, bindings: r.bindings, account };
+}
+
+/** 把兩邊的決定印出來——PR 要貼的就是這張對照表。 */
+function report(scenario: Scenario, a: Record<string, string>, b: Record<string, string>): void {
+  const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+  console.log(`\n  ── ${scenario}：${SCENARIOS[scenario].label}`);
+  console.log(`     ${'binding'.padEnd(34)} ${'acr 選的'.padEnd(24)} 安裝器選的        一致?`);
+  for (const k of keys) {
+    const same = a[k] === b[k] ? '✓' : '✗';
+    console.log(`     ${k.padEnd(34)} ${(a[k] ?? '—').padEnd(24)} ${(b[k] ?? '—').padEnd(18)} ${same}`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+for (const scenario of ['fresh', 'installed', 'renamed'] as const) {
+  const mode = scenario === 'fresh' ? 'init' : 'update';
+
+  test(`兩條路一致 — ${scenario}：${SCENARIOS[scenario].label}`, async () => {
+    const a = await runAcrPath(scenario, mode);
+    const b = await runInstallerPath(scenario, mode);
+
+    assert.equal(a.blocked, b.blocked, '一邊停手、一邊照做 = 最危險的分歧');
+    assert.deepEqual(a.blockers, b.blockers, '停手的理由也要一樣');
+    report(scenario, a.bindings, b.bindings);
+    assert.deepEqual(
+      a.bindings,
+      b.bindings,
+      `${scenario}：兩條路選出的 resource id 不同——這就是 Arcrun#97 的形狀`,
+    );
+
+    // 建立行為也要一致（一邊沿用、一邊新建 = 使用者的東西在其中一條路上會消失）
+    assert.deepEqual(a.account.created, b.account.created, '兩條路「建了什麼」必須一樣');
+  });
+}
+
+// ── 三種情境各自該有的行為（不只是「兩邊一樣」，還要「一樣地對」）─────────────
+
+test('情境① 沒裝過 → 正常建新的（不能為了沿用而變成永遠不建）', async () => {
+  const { blocked, bindings, account } = await runInstallerPath('fresh', 'init');
+  assert.equal(blocked, false, '全新帳號要裝得起來');
+  assert.equal(account.created.kv.length, 9, `應新建 9 顆 KV，實際 ${account.created.kv.length}`);
+  assert.equal(account.created.d1.length, 1, `應新建 1 顆 D1，實際 ${account.created.d1.length}`);
+  // cypher 的 CREDENTIALS_DB 與 kbdb 的 DB 宣告同一個 database_name → 只該建一顆，兩邊共用
+  assert.equal(bindings['d1:CREDENTIALS_DB'], bindings['d1:DB'], '同一顆 D1 不該被建成兩顆');
+  console.log(`\n  ① 新建：KV ${account.created.kv.length} 顆、D1 ${account.created.d1.length} 顆` +
+    `（D1 共用：CREDENTIALS_DB = DB = ${bindings['d1:DB']}）`);
+});
+
+test('情境② 裝過了 → 沿用原本那幾顆，工作流與登入 session 都還在', async () => {
+  const { blocked, bindings, account } = await runInstallerPath('installed', 'update');
+  assert.equal(blocked, false);
+  assert.deepEqual(account.created, { kv: [], d1: [], vectorize: [] }, '更新不該建出任何新資源');
+
+  // 使用者的東西掛在資源 id 上：綁定還指向原本那顆 = 東西還在
+  assert.equal(bindings['kv_namespace:WEBHOOKS'], account.kvIdFor('WEBHOOKS'));
+  assert.equal(bindings['kv_namespace:SESSIONS_KV'], account.kvIdFor('SESSIONS_KV'));
+  assert.equal(bindings['d1:DB'], account.d1Id);
+  console.log(`\n  ② 沿用：WEBHOOKS → ${bindings['kv_namespace:WEBHOOKS']}` +
+    `（工作流 ${account.userData.workflows.length} 支還在）｜` +
+    `SESSIONS_KV → ${bindings['kv_namespace:SESSIONS_KV']}（登入 session 還在）｜` +
+    `DB → ${bindings['d1:DB']}（子庫 ${account.userData.libraries.length} 個還在）｜新建 0 顆`);
+});
+
+test('情境③ 資源在但名字與預期完全不同 → 仍然沿用（#97 的病根，專門驗）', async () => {
+  const { blocked, bindings, account } = await runInstallerPath('renamed', 'update');
+  assert.equal(blocked, false);
+  assert.deepEqual(account.created, { kv: [], d1: [], vectorize: [] },
+    '名字對不上就新建 = 正是 #97：一次更新生出 9 顆空 KV，使用者的東西從畫面上消失');
+  for (const b of ['WEBHOOKS', 'SESSIONS_KV', 'RECIPES', 'USERS_KV']) {
+    assert.equal(bindings[bindingKey('kv_namespace', b)], account.kvIdFor(b),
+      `${b} 沒有沿用到原本那顆`);
+  }
+  console.log(`\n  ③ 名字全不同（例：WEBHOOKS 那顆實際叫 "${SCENARIOS.renamed.titleFor('WEBHOOKS')}"）` +
+    ` → 仍沿用 ${bindings['kv_namespace:WEBHOOKS']}，新建 0 顆`);
+});
@@ -0,0 +1,243 @@
+/**
+ * Arcrun#106 迴歸守衛 —— 「更新完，設定頁還看得到版本號，而且是**這次**的版本號」
+ *
+ * 2026-08-12 實害：leo 更新完 leo21c，Portal 設定頁的版本欄變成
+ * 「無法讀取目前版本（知識庫服務可能正在啟動）」。
+ * 根因：`ARCRUN_BUNDLE_VERSION` 是部署時注入的 plain_text var，**只有安裝器會注入**；
+ * CLI 這條路重部署時 wrangler 整份覆蓋 toml，沒寫的 var 直接消失 ⇒ 標籤被洗掉。
+ * #97 修好了「櫃子」（KV/D1/Vectorize 沿用既有），**沒修「櫃子上的標籤」**。
+ *
+ * 這份測試守兩件相反的事（本次的核心判斷）：
+ *   · 設定類 var（安裝器注入的 PORTAL_MAIL_RELAY_BASE 之類）＝使用者實例的事實 → **沿用**
+ *   · 版本標籤 ARCRUN_BUNDLE_VERSION ＝這份成品的屬性 → **每趟重烙，絕不沿用舊值**
+ *     （沿用舊值 = 一個永遠停在安裝當天的假標籤，比沒有標籤更糟）
+ *
+ * 全部離線跑：真的 wrangler.toml + 真的 render/inject 程式碼，fetch 用假的，不碰任何實例。
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  renderWranglerToml,
+  preservedVars,
+  applyVars,
+  resolveBundleStamp,
+  CLI_MANAGED_VARS,
+  VERSION_STAMP_WORKER,
+  type DeployContext,
+} from '../src/lib/deploy.ts';
+import { planResources, type ResourceApi, type ScriptBindings } from '../src/lib/resource-resolver.ts';
+
+const REPO = join(fileURLToPath(new URL('.', import.meta.url)), '..', '..');
+const CYPHER_TOML = readFileSync(join(REPO, 'cypher-executor', 'wrangler.toml'), 'utf8');
+
+const CTX: DeployContext = {
+  accountId: 'acc-user-123',
+  apiToken: 'token',
+  workerSubdomain: 'user-sub',
+  selfHosted: true,
+  kbdbEmbed: true,
+};
+
+/** 一台「安裝器裝出來、已經跑過的」實例上，cypher worker 現在掛著的 plain_text var。 */
+const LIVE_VARS: Record<string, string> = {
+  ARCRUN_BUNDLE_VERSION: '1.4.29',                                  // 安裝當時的舊標籤
+  PORTAL_MAIL_RELAY_BASE: 'https://mail.example.com',               // 安裝器注入、repo toml 沒有 → 洗掉就寄不出信
+  CONSOLE_TENANT: 'someone-else',                                   // repo toml 寫死 "leo"，不能拿官方值蓋掉人家的
+  WORKER_SUBDOMAIN: 'user-sub',                                     // CLI 自己算
+  CF_ACCOUNT_ID: 'acc-user-123',                                    // CLI 自己算
+  MULTI_TENANT: 'false',                                            // CLI 自己算
+  ENVIRONMENT: 'production',                                        // 與 toml 同值 → 不必重寫
+};
+
+/** 從 render 過的 toml 讀 [vars] 區塊（只看未註解的行）。 */
+function readVars(toml: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  let inVars = false;
+  for (const raw of toml.split('\n')) {
+    const line = raw.trim();
+    if (/^\[\[?[A-Za-z0-9_]+\]?\]$/.test(line)) { inVars = line === '[vars]'; continue; }
+    if (!inVars || line.startsWith('#')) continue;
+    const m = line.match(/^([A-Za-z0-9_]+)\s*=\s*"([^"]*)"/);
+    if (m) out[m[1]] = m[2];
+  }
+  return out;
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ① 病灶本身：舊行為會把標籤洗掉
+// ═════════════════════════════════════════════════════════════════════════════
+
+test('#106 ①：repo 的 cypher toml 本來就沒有 ARCRUN_BUNDLE_VERSION——不補就是洗掉（病灶重現）', () => {
+  const rendered = renderWranglerToml(CYPHER_TOML, CTX, new Map());
+  assert.equal(
+    readVars(rendered).ARCRUN_BUNDLE_VERSION,
+    undefined,
+    '若這行開始有值，表示 toml 自己帶了版本標籤，本測試的前提要重寫',
+  );
+});
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ② 設定類 var：沿用實例上的事實
+// ═════════════════════════════════════════════════════════════════════════════
+
+test('#106 ②：安裝器注入、repo toml 沒有的 var 會被沿用（不再被重部署洗掉）', () => {
+  const keep = preservedVars(LIVE_VARS, CYPHER_TOML);
+  assert.equal(keep.PORTAL_MAIL_RELAY_BASE, 'https://mail.example.com');
+  // repo toml 寫死的是官方值，使用者實例上的值才是事實
+  assert.equal(keep.CONSOLE_TENANT, 'someone-else');
+  // 與 toml 同值 → 不需要重寫進去（雜訊）
+  assert.equal(keep.ENVIRONMENT, undefined);
+});
+
+test('#106 ③：CLI 自己算的 var 一律不沿用（沿用等於拿舊值蓋掉這趟的正解）', () => {
+  const keep = preservedVars({ ...LIVE_VARS, WORKER_SUBDOMAIN: 'OLD-sub', CF_ACCOUNT_ID: 'OLD-acc' }, CYPHER_TOML);
+  for (const managed of CLI_MANAGED_VARS) {
+    assert.equal(keep[managed], undefined, `${managed} 不該被沿用`);
+  }
+  // 而且注入完的 toml 裡，這些值仍是這趟算出來的那個
+  const rendered = renderWranglerToml(CYPHER_TOML, CTX, new Map(), keep);
+  const vars = readVars(rendered);
+  assert.equal(vars.WORKER_SUBDOMAIN, 'user-sub');
+  assert.equal(vars.CF_ACCOUNT_ID, 'acc-user-123');
+  assert.equal(vars.MULTI_TENANT, 'false');
+  assert.equal(vars.KBDB_BASE_URL, 'https://arcrun-kbdb.user-sub.workers.dev');
+});
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ③ 版本標籤：重烙，不沿用
+// ═════════════════════════════════════════════════════════════════════════════
+
+test('#106 ④：版本標籤取「發行頻道公告的 release」＋ 實際 commit，不是沿用舊值', async () => {
+  const fakeFetch = (async () =>
+    new Response(JSON.stringify({ release: '1.4.41', pin: 'ba81439' }), { status: 200 })) as typeof fetch;
+  const stamp = await resolveBundleStamp('main', 'f87d0e92f49690253e7c89c5badc82a08eb5d21b', fakeFetch);
+  assert.equal(stamp.version, '1.4.41');
+  assert.notEqual(stamp.version, LIVE_VARS.ARCRUN_BUNDLE_VERSION);   // ← 這就是本 issue
+  assert.equal(stamp.commit, 'f87d0e92f49690253e7c89c5badc82a08eb5d21b');
+  assert.match(stamp.version, /^\d+\.\d+\.\d+$/, 'Portal 拿它跟 /api/latest 比 semver，必須是純 semver');
+});
+
+test('#106 ⑤：查不到發行版號時誠實標成 commit 版，**不**沿用舊值、也不掰一個 semver', async () => {
+  const fakeFetch = (async () => { throw new Error('offline'); }) as typeof fetch;
+  const stamp = await resolveBundleStamp('main', 'f87d0e92f49690253e7c89c5badc82a08eb5d21b', fakeFetch);
+  assert.match(stamp.version, /^\d{4}-\d{2}-\d{2}\+f87d0e9$/);
+  assert.notEqual(stamp.version, LIVE_VARS.ARCRUN_BUNDLE_VERSION);
+  assert.doesNotMatch(stamp.version, /^\d+\.\d+\.\d+$/, '掰一個 semver 會讓 Portal 假裝「已是最新版」');
+});
+
+test('#106 ⑥：發行頻道回了不是 semver 的東西 → 當成查不到（不把垃圾當版號烙上去）', async () => {
+  const fakeFetch = (async () =>
+    new Response(JSON.stringify({ release: 'latest' }), { status: 200 })) as typeof fetch;
+  const stamp = await resolveBundleStamp('main', 'abc1234def', fakeFetch);
+  assert.match(stamp.version, /^\d{4}-\d{2}-\d{2}\+abc1234$/);
+});
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ④ 端到端（離線）：一台已安裝的實例跑一次更新，Portal 讀得到的那個欄位長什麼樣
+// ═════════════════════════════════════════════════════════════════════════════
+
+test('#106 ⑦：模擬更新——版本標籤變新、設定 var 一個不少、資源沿用不受影響', async () => {
+  const api: ResourceApi = {
+    async getScriptBindings(script: string): Promise<ScriptBindings> {
+      if (script !== VERSION_STAMP_WORKER) return { deployed: false, bindings: [], vars: {} };
+      return {
+        deployed: true,
+        bindings: [
+          { kind: 'kv_namespace', binding: 'WEBHOOKS', value: 'kv-webhooks' },
+          { kind: 'kv_namespace', binding: 'CREDENTIALS_KV', value: 'kv-creds' },
+          { kind: 'kv_namespace', binding: 'RECIPES', value: 'kv-recipes' },
+          { kind: 'kv_namespace', binding: 'USERS_KV', value: 'kv-users' },
+          { kind: 'kv_namespace', binding: 'SESSIONS_KV', value: 'kv-sessions' },
+          { kind: 'kv_namespace', binding: 'ANALYTICS_KV', value: 'kv-analytics' },
+          { kind: 'kv_namespace', binding: 'EXEC_CONTEXT', value: 'kv-exec' },
+          { kind: 'd1', binding: 'CREDENTIALS_DB', value: 'd1-kbdb' },
+        ],
+        vars: LIVE_VARS,
+      };
+    },
+    async listKvNamespaces() {
+      return new Map([
+        ['a', 'kv-webhooks'], ['b', 'kv-creds'], ['c', 'kv-recipes'], ['d', 'kv-users'],
+        ['e', 'kv-sessions'], ['f', 'kv-analytics'], ['g', 'kv-exec'],
+      ]);
+    },
+    async listD1Databases() { return new Map([['arcrun-kbdb', 'd1-kbdb']]); },
+    async listVectorizeIndexes() { return []; },
+    async createKvNamespace() { throw new Error('這趟不該新建任何 KV'); },
+    async createD1Database() { throw new Error('這趟不該新建 D1'); },
+    async createVectorizeIndex() { throw new Error('這趟不該新建 Vectorize'); },
+  };
+
+  const preview = renderWranglerToml(CYPHER_TOML, CTX, new Map());
+  const { parseWranglerRequirements } = await import('../src/lib/resource-resolver.ts');
+  const parsed = parseWranglerRequirements(preview);
+  const plan = await planResources(
+    api,
+    parsed.bindings.map((b) => ({ ...b, worker: parsed.script })),
+    'update',
+  );
+  assert.deepEqual(plan.blockers, []);
+  // 讀綁定時順手把 var 帶回來——不另外打一次 API
+  assert.equal(plan.liveVars.get(VERSION_STAMP_WORKER)?.PORTAL_MAIL_RELAY_BASE, 'https://mail.example.com');
+
+  const fakeFetch = (async () =>
+    new Response(JSON.stringify({ release: '1.4.41' }), { status: 200 })) as typeof fetch;
+  const stamp = await resolveBundleStamp('main', 'f87d0e92f49690253e7c89c5badc82a08eb5d21b', fakeFetch);
+  const extra = {
+    ...preservedVars(plan.liveVars.get(parsed.script), CYPHER_TOML),
+    ARCRUN_BUNDLE_VERSION: stamp.version,
+    ARCRUN_BUNDLE_COMMIT: stamp.commit!,
+  };
+
+  const deployed = readVars(renderWranglerToml(CYPHER_TOML, CTX, new Map(), extra));
+
+  // ① Portal 設定頁讀的就是這個欄位——更新完必須有值，且是**這趟**的版本
+  assert.equal(deployed.ARCRUN_BUNDLE_VERSION, '1.4.41');
+  assert.equal(deployed.ARCRUN_BUNDLE_COMMIT, 'f87d0e92f49690253e7c89c5badc82a08eb5d21b');
+  // ② 安裝器注入的設定沒有在更新中消失
+  assert.equal(deployed.PORTAL_MAIL_RELAY_BASE, 'https://mail.example.com');
+  assert.equal(deployed.CONSOLE_TENANT, 'someone-else');
+  // ③ CLI 自己算的仍然是這趟算出來的
+  assert.equal(deployed.WORKER_SUBDOMAIN, 'user-sub');
+  assert.equal(deployed.MULTI_TENANT, 'false');
+});
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ⑤ applyVars 的三種既有狀態 + 不弄壞別的區塊
+// ═════════════════════════════════════════════════════════════════════════════
+
+test('#106 ⑧：applyVars——改既有行／取消註解／插進 [vars]／連 [vars] 都沒有時新開一段', () => {
+  assert.match(applyVars('[vars]\nA = "old"\n', { A: 'new' }), /^\[vars\]\nA = "new"\n$/);
+  assert.match(applyVars('[vars]\n# A = "old"\n', { A: 'new' }), /A = "new"/);
+  assert.match(applyVars('[vars]\nB = "b"\n', { A: 'a' }), /\[vars\]\nA = "a"\nB = "b"/);
+  const noVars = applyVars('name = "w"\n', { A: 'a' });
+  assert.match(noVars, /\[vars\]\nA = "a"/);
+  assert.match(noVars, /^name = "w"/);
+});
+
+test('#106 ⑨：var 值裡的引號／反斜線會被轉義（不會產生壞掉的 toml）', () => {
+  const out = applyVars('[vars]\n', { A: 'say "hi"\\path' });
+  assert.match(out, /A = "say \\"hi\\"\\\\path"/);
+});
+
+test('#106 ⑨b：值裡有 $& / $1 也照原樣寫出（replace 反向參照陷阱）', () => {
+  assert.match(applyVars('[vars]\nA = "old"\n', { A: 'x$&y$1z' }), /A = "x\$&y\$1z"/);
+  assert.match(applyVars('[vars]\n', { A: 'x$&y' }), /A = "x\$&y"/);
+  // 怪名字不寫進去（不拿它組正規式）
+  assert.equal(applyVars('[vars]\n', { 'BAD NAME': 'v' }), '[vars]\n');
+});
+
+test('#106 ⑩：注入 var 不影響資源綁定解析（預覽與實際寫入看到的是同一份需求）', async () => {
+  const { parseWranglerRequirements } = await import('../src/lib/resource-resolver.ts');
+  const withoutVars = parseWranglerRequirements(renderWranglerToml(CYPHER_TOML, CTX, new Map()));
+  const withVars = parseWranglerRequirements(
+    renderWranglerToml(CYPHER_TOML, CTX, new Map(), { ARCRUN_BUNDLE_VERSION: '1.4.41', X: 'y' }),
+  );
+  assert.equal(withVars.script, withoutVars.script);
+  assert.deepEqual(withVars.bindings, withoutVars.bindings);
+});
@@ -6,6 +6,11 @@
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
+    // resource-rule.mjs 是共用規則的副本（純 JS + JSDoc，零依賴，見該檔開頭）。
+    // allowJs 讓 tsc 把它一起編進 dist（否則 npm 套件裡會缺這支 → 執行期 MODULE_NOT_FOUND）；
+    // checkJs 讓它的 JSDoc 型別真的被檢查，而不是靜靜地當 any。
+    "allowJs": true,
+    "checkJs": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "declaration": true,
@@ -2039,6 +2039,15 @@ function taipeiMonthDay(ms) { var d = new Date(ms + TAIPEI_OFFSET_MS); return {
  // 兩邊都是 semver（例 1.4.2），用數字逐段比，不用字串比（'1.4.10' < '1.4.9' 會出錯）。
  var INSTALLER_ORIGIN = 'https://install.arcrun.dev';

+  // Arcrun#106：版號後面可以帶 build metadata（`1.4.41+d61`、`1.4.41+a1b2c3d`）——
+  // 那是 semver 規格裡「比大小時要忽略」的那一段。舊寫法拿整串去比對正規式，
+  // 一律落到「較舊版本」（youlin 實例就是這樣，明明有版號卻顯示不出來）。
+  // 這裡只取前面的 `x.y.z` 當比較用的核心，顯示仍顯示完整原字串。
+  function semverCore(v) {
+    var m = String(v || '').match(/^(\d+\.\d+\.\d+)/);
+    return m ? m[1] : '';
+  }
+
  function cmpSemver(a, b) {
    var x = String(a || '').split('.').map(Number);
    var y = String(b || '').split('.').map(Number);
@@ -2055,9 +2064,14 @@ function taipeiMonthDay(ms) { var d = new Date(ms + TAIPEI_OFFSET_MS); return {
    var btn = $('st-ver-update');
    if (!line) return;

+    // #106：順便把 bundle_commit 帶回來（有注入才有）——版號是頻道編號，commit 才是「真的部了哪份碼」。
+    var mineCommit = '';
    var mineP = fetch(window.ARCRUN_API_BASE + '/health', { cache: 'no-store' })
      .then(function (r) { return r.ok ? r.json() : null; })
-      .then(function (j) { return (j && j.bundle_version) || ''; })
+      .then(function (j) {
+        mineCommit = (j && j.bundle_commit) || '';
+        return (j && j.bundle_version) || '';
+      })
      .catch(function () { return ''; });
    var latestP = fetch(INSTALLER_ORIGIN + '/api/latest')
      .then(function (r) { return r.ok ? r.json() : null; })
@@ -2070,15 +2084,19 @@ function taipeiMonthDay(ms) { var d = new Date(ms + TAIPEI_OFFSET_MS); return {
      if (!mine) { line.textContent = '無法讀取目前版本（知識庫服務可能正在啟動）'; return; }
      // 舊實例的 bundle_version 是舊格式（2026-07-31+8e83589），比不了 semver。
      // 這種情況一律當成「落後」——因為新版才會寫 semver 進來。
-      var mineIsSemver = /^\d+\.\d+\.\d+$/.test(mine);
+      // #106：`1.4.41+<commit>` 這種帶 build metadata 的**是** semver，取核心比即可。
+      var mineCore = semverCore(mine);
+      var mineIsSemver = !!mineCore;
+      // commit 是輔助資訊（有才顯示）：版號說「哪一版」，commit 說「真的是哪份碼」。
+      var commitNote = mineCommit ? '　<span class="muted">commit ' + esc(String(mineCommit).slice(0, 7)) + '</span>' : '';

      if (!latest) {
-        line.textContent = '目前版本 ' + mine + '（暫時查不到最新版，稍後再試）';
+        line.innerHTML = '目前版本 <strong>' + esc(mine) + '</strong>（暫時查不到最新版，稍後再試）' + commitNote;
        return;
      }
-      var behind = !mineIsSemver || cmpSemver(mine, latest) < 0;
+      var behind = !mineIsSemver || cmpSemver(mineCore, latest) < 0;
      if (!behind) {
-        line.innerHTML = '目前版本 <strong>' + esc(mine) + '</strong>　已是最新版';
+        line.innerHTML = '目前版本 <strong>' + esc(mine) + '</strong>　已是最新版' + commitNote;
        dot.style.display = 'none';
        btn.style.display = 'none';
        return;
@@ -15,11 +15,19 @@ export const healthRouter = new Hono<{ Bindings: Bindings }>();
 // 要在實例自己這一側就看得出來，不是等用戶登不進去才發現（#10「寧可明顯失敗」）。
 // 只回統計不回內容（帳號數／有沒有 console 帳密／分片數），不洩漏任何 email 或雜湊。
 // bundle_version 的既有行為不動（未注入就省略該欄——daemon 對空字串判 stale 是正確的）。
+// Arcrun#106（leo 08-12 實撞：更新完設定頁變成「無法讀取目前版本」）：
+// `bundle_version` 只在部署時被注入，而**只有安裝器會注入**——CLI 更新那條路重部署
+// 等於把這個標籤洗掉（wrangler deploy 整份覆蓋，toml 沒寫的 var 直接消失）。
+// 修在 CLI 那側（cli/src/lib/deploy.ts：既有 var 沿用 + 版本標籤每趟重烙）。
+// 這裡只多吐一個 `bundle_commit`：版號是「發行頻道的編號」，commit 才是「真的部了哪份碼」——
+// 兩個一起看才有辦法查「標籤有沒有跟成品漂掉」。沒注入就省略該欄（同 bundle_version 的既有行為）。
 healthRouter.get('/health', (c) => {
  const bundleVersion = c.env.ARCRUN_BUNDLE_VERSION;
+  const bundleCommit = c.env.ARCRUN_BUNDLE_COMMIT;
  return c.json({
    ok: true,
    ...(bundleVersion ? { bundle_version: bundleVersion } : {}),
+    ...(bundleCommit ? { bundle_commit: bundleCommit } : {}),
    auth_store: authStoreStatus(c.env),
    // arcrun-rag#38/#69/#25（2026-08-11）：安裝器判斷「要不要重推」只比 bundle_version——
    // 但這次要修的洞是「installer 從沒注入過 PORTAL_MAIL_RELAY_BASE」，跟 bundle 內容
@@ -75,6 +75,13 @@ export type Bindings = {
   * 未注入（本地 dev／舊實例）＝ undefined，/health 省略該欄。
   */
  ARCRUN_BUNDLE_VERSION?: string;
+  /**
+   * Arcrun#106：這份成品實際來自哪個 commit（40 碼 sha）。
+   * `ARCRUN_BUNDLE_VERSION` 是**發行頻道的編號**（semver，Portal/daemon 拿它比新舊），
+   * 這個是**真的部了哪份碼**——兩個一起吐，標籤跟成品漂掉時查得出來。
+   * 由 `acr init/update`（cli/src/lib/deploy.ts）注入；安裝器那條路沒有此 var → /health 省略該欄。
+   */
+  ARCRUN_BUNDLE_COMMIT?: string;
  // Platform telemetry api_key（可選，wrangler secret）
  // 對應 SDD .agents/specs/llm-interface/ M1.2
  // 設了會把 agent-telemetry block 都聚集在 platform_telemetry user_id 下
@@ -103,9 +110,8 @@ export type Bindings = {
  GITEA_TOKEN?: string; // wrangler secret（建議唯讀 scope token）
  GITEA_SPRINT_REPO?: string; // 預設 Leo/InkStoneCo
  GITEA_SPRINT_DIR?: string; // 預設 system-dev/docs/3-specs/autonomy-dispatch
-  // 安裝器部署時注入的 bundle 版本（格式 "YYYY-MM-DD/commit"，老實例無此 var）。
-  // daemon 比對此值決定是否提示用戶更新（/health 曝露，缺 var 時回空字串）。
-  ARCRUN_BUNDLE_VERSION?: string;
+  // （ARCRUN_BUNDLE_VERSION 原本在這裡重複宣告了一次——TS2300 重複識別字，
+  //   #106 順手併回上面那一處，說明同源，行為零變化。）
  // MCP access_token 存活秒數的「顯示鏡像」（console 設定頁 MCP TTL 佔位區塊用）。
  // 真相住在 mcp worker 的同名 env（mcp/src/types.ts，預設 2592000＝30 天）；cypher 這份
  // 只供顯示，兩處部署時要一致（#32 形態 config 同步教訓）。未設 → 頁面如實標「預設值」。
@@ -26,4 +26,33 @@ describe('GET /health — bundle_version 欄位', () => {
    expect(data.ok).toBe(true);
    expect(data.bundle_version).toBe('2026-07-28/6d06162');
  });
+
+  // Arcrun#106：CLI 更新那條路會多烙一個 commit（版號＝發行頻道編號，commit＝真的部了哪份碼）。
+  it('有 ARCRUN_BUNDLE_COMMIT 時一起回（acr update 注入情境）', async () => {
+    const fakeEnv = {
+      ARCRUN_BUNDLE_VERSION: '1.4.41',
+      ARCRUN_BUNDLE_COMMIT: 'f87d0e92f49690253e7c89c5badc82a08eb5d21b',
+    } as unknown as Bindings;
+    const res = await healthRouter.fetch(
+      new Request('http://localhost/health'),
+      fakeEnv,
+      {} as ExecutionContext,
+    );
+    const data = await res.json() as { bundle_version: string; bundle_commit: string };
+    expect(data.bundle_version).toBe('1.4.41');
+    expect(data.bundle_commit).toBe('f87d0e92f49690253e7c89c5badc82a08eb5d21b');
+  });
+
+  // 安裝器那條路沒有這個 var（回歸：不能因為多了新欄位就讓舊路徑多吐一個空字串出來）。
+  it('沒 ARCRUN_BUNDLE_COMMIT 就省略該欄（安裝器路徑不受影響）', async () => {
+    const fakeEnv = { ARCRUN_BUNDLE_VERSION: '1.4.41' } as unknown as Bindings;
+    const res = await healthRouter.fetch(
+      new Request('http://localhost/health'),
+      fakeEnv,
+      {} as ExecutionContext,
+    );
+    const data = await res.json() as { bundle_version: string; bundle_commit?: string };
+    expect(data.bundle_version).toBe('1.4.41');
+    expect(data.bundle_commit).toBeUndefined();
+  });
 });
@@ -0,0 +1,25 @@
+-- credential template seed（D38 圍牆修復，總管交辦，2026-08-07）
+-- SDD：無專屬 SDD（D38 事故修復任務，見 system-dev/wiki/decisions-summary.md D38 段）。
+--
+-- D38 鐵律（leo 2026-06-14 立、2026-08-07 擴大）：KBDB 三張表打天下，永遠不加新表；
+-- 新資料類型一律用 template + entries，同 0003_library_map.sql / 0004_execution_log_template.sql
+-- 的手法——對 templates 表 INSERT OR IGNORE 一列定義，不建新表、不動既有表的結構。
+--
+-- 這是「credential 目錄」的第二個家：原本 0002_credentials.sql 在 KBDB 裡多開了一張
+-- 獨立表（違規，見 kbdb-usage skill「反例」），本檔 + 0006_drop_credentials_table.sql
+-- 把它改回三張表的形狀——一筆 credential＝entries 表一列（entry_type='credential'，
+-- page_name=name 當冪等鍵，owner_id=api_key 做租戶隔離，其餘欄位打包進 metadata_json），
+-- 儲存精神比照既有 recipe_stat / execution_log（template 只負責文件化，實際資料不走
+-- entry_values 全展開的多列 record）。
+--
+-- 密文本體不在這裡：值仍住在 CF Workers per-script Secrets（掛在 cypher worker 上，管理
+-- API 唯寫，D19「擁有目錄，不擁有內容物」不變）。這張 template 定義的 slots 全部是目錄
+-- 欄位，零密文——與舊 0002_credentials.sql 的欄位定義一字不變，只是換了個家。
+INSERT OR IGNORE INTO templates (id, name, description, slots_json, created_by)
+VALUES (
+  'tpl-credential',
+  'credential',
+  'credential 目錄（D38 圍牆修復：改走 entries 表 entry_type=credential，取代舊 credentials 表；零密文，密文本體住 Workers per-script Secrets）',
+  '["name","service","sensitivity","secret_ref","last_used_at"]',
+  'system'
+);
@@ -0,0 +1,47 @@
+-- 退役 credentials 表（D38 圍牆修復，總管交辦，2026-08-07）
+-- SDD：無專屬 SDD（D38 事故修復任務，見 system-dev/wiki/decisions-summary.md D38 段）。
+--
+-- 這是本次唯一真的需要動表結構的一支 migration，理由（不是繞過鐵律，是鐵律要求的收尾）：
+--   D38 要求 KBDB 回到「只有三張核心表」的狀態。0002_credentials.sql 當初在 KBDB 裡多開了
+--   一張獨立表，是已知違規（kbdb-usage skill 明文列為反例）。要把違規清乾淨，唯一辦法就是
+--   真的把那張表拆掉——拆表本身不能只用 API 做（API 不提供「拆表」這種牆內維運操作，
+--   也不該提供），所以下面兩句 SQL 標 kbdb-sql-ok：這不是繞過圍牆去存取資料，是圍牆施工
+--   本身（kbdb/migrations/ 就是牆內，本檔存在的唯一目的就是讓舊表退場）。
+--
+-- 冪等設計（deploy.ts 每次部署都會重跑這支檔案，沒有 migration 追蹤表）：
+--   1. 先補一份空表存在保底——self-hosted 各實例套用進度不一，有些從沒跑過 0002（表從不
+--      存在）、有些已經跑過本檔一次（表已被拆）。沒有這一步，下面的搬資料/退場語句會因表
+--      不存在直接整支失敗（D1 對不存在的表沒有條件式跳過語法）。
+--   2. 把舊表裡「entries 還沒有對應列」的 row 搬進 entries（entry_type='credential'，
+--      page_name=name 冪等鍵，owner_id=api_key，其餘欄位打包進 metadata_json，欄位對應
+--      0005_credential_template.sql 定義的 slots）。NOT EXISTS 判斷防止重跑造成重複列。
+--   3. 搬完資料後表就沒有存在的理由，最後一步讓它退場。下次部署若又被步驟 1 重新墊一份
+--      空殼，也只是空表、立刻搬 0 筆、立刻退場，不影響任何人（真資料只會被搬一次，因為
+--      步驟 2 的判斷是看 entries 裡有沒有，不是看這是不是第一次跑）。
+CREATE TABLE IF NOT EXISTS credentials ( -- kbdb-sql-ok: 表退場施工步驟①保底存在，非資料存取違規，理由見檔頭
+  api_key      TEXT NOT NULL,
+  name         TEXT NOT NULL,
+  service      TEXT,
+  sensitivity  TEXT NOT NULL DEFAULT 'standard',
+  secret_ref   TEXT NOT NULL,
+  created_at   INTEGER NOT NULL,
+  last_used_at INTEGER,
+  PRIMARY KEY (api_key, name)
+);
+
+INSERT INTO entries (id, entry_type, owner_id, page_name, metadata_json, created_at, updated_at)
+SELECT
+  'e_cred_' || lower(hex(randomblob(8))),
+  'credential',
+  c.api_key,
+  c.name,
+  json_object('service', c.service, 'sensitivity', c.sensitivity, 'secret_ref', c.secret_ref, 'last_used_at', c.last_used_at),
+  c.created_at,
+  unixepoch()
+FROM credentials c
+WHERE NOT EXISTS (
+  SELECT 1 FROM entries e
+  WHERE e.entry_type = 'credential' AND e.owner_id = c.api_key AND e.page_name = c.name
+);
+
+DROP TABLE IF EXISTS credentials; -- kbdb-sql-ok: 表退場施工步驟③讓舊表退場，非資料存取違規，理由見檔頭
@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * sync-resource-rule.mjs — 把「該用哪些資源」這條規則的**唯一原稿**同步給需要打包的呼叫端。
+ *
+ * 【為什麼需要這支】
+ * 規則的原稿在 `shared/resource-rule/rule.mjs`（理由見該檔開頭）。
+ * 兩條路取用它的方式不同：
+ *
+ *   · **安裝器 / 任何 Worker**：本來就會下載這個 repo 的 archive 當部署來源，
+ *     直接 import `shared/resource-rule/rule.mjs`。**不需要副本，本支不管它。**
+ *
+ *   · **`acr` CLI**：`arcrun` 是獨立 npm 套件，`npm pack` 打不進套件目錄外的檔案
+ *     ⇒ 套件裡必須有一份。這支就是產生那一份的地方。
+ *
+ * 【這算不算「第二份實作」】
+ * 不算，而且是機械保證的：產生物是**逐位元組副本**，`--check` 一有差就 exit 1，
+ * 而 `npm run build` 與 `npm test` 都會先跑 `--check`。
+ * 也就是說「有人手改了 CLI 那一份」= build 紅、publish 擋下。
+ * ——同 `cli/harness/`（產生物進 repo ＋ `check:harness` 世代閘）的既有慣例，
+ *   不是為本票新發明的做法。
+ *
+ * 用法：
+ *   node scripts/sync-resource-rule.mjs           產生／更新副本
+ *   node scripts/sync-resource-rule.mjs --check    只檢查，有漂移就 exit 1（不寫檔）
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+
+// REPO 一律由本檔位置推導，不吃 cwd（比照 scripts/build-worker-artifacts.mjs）。
+const REPO = resolve(fileURLToPath(new URL('.', import.meta.url)), '..');
+const SOURCE_DIR = join(REPO, 'shared/resource-rule');
+
+/**
+ * 需要「套件內自帶一份」的呼叫端。**整個目錄原樣鏡射**（不是挑檔案）——
+ * 檔名與相對位置保持一致，`cf-resource-api.mjs` 裡的 `./rule.mjs` 才不用改寫。
+ * 安裝器不在此列：它直接讀 repo archive 裡的原稿，連副本都不需要。
+ */
+const MIRRORS = ['cli/src/lib/resource-rule'];
+
+const CHECK_ONLY = process.argv.includes('--check');
+
+/** @param {string|Buffer} b */
+const sha256 = (b) => createHash('sha256').update(b).digest('hex');
+
+if (!existsSync(SOURCE_DIR)) {
+  console.error(`❌ 找不到規則原稿目錄：${SOURCE_DIR}`);
+  process.exit(1);
+}
+
+/** 原稿目錄裡所有 .mjs（README / 測試不進副本）。 */
+const FILES = readdirSync(SOURCE_DIR).filter((f) => f.endsWith('.mjs')).sort();
+if (FILES.length === 0) {
+  console.error(`❌ ${SOURCE_DIR} 裡沒有任何 .mjs 原稿`);
+  process.exit(1);
+}
+
+let drifted = 0;
+for (const mirror of MIRRORS) {
+  for (const file of FILES) {
+    const src = readFileSync(join(SOURCE_DIR, file));
+    const srcHash = sha256(src);
+    const rel = `${mirror}/${file}`;
+    const abs = join(REPO, mirror, file);
+    const had = existsSync(abs) ? readFileSync(abs) : null;
+
+    if (had !== null && sha256(had) === srcHash) {
+      console.log(`✔ ${rel}  = 原稿（sha256 ${srcHash.slice(0, 12)}）`);
+      continue;
+    }
+
+    if (CHECK_ONLY) {
+      drifted++;
+      console.error(
+        had === null
+          ? `✗ ${rel} 不存在——跑 \`node scripts/sync-resource-rule.mjs\` 產生。`
+          : `✗ ${rel} 與原稿不一致（副本 ${sha256(had).slice(0, 12)} ≠ 原稿 ${srcHash.slice(0, 12)}）。\n` +
+            `  這一份是**產生物**，不要手改：規則要改就改 shared/resource-rule/${file}，` +
+            `然後跑 \`node scripts/sync-resource-rule.mjs\`。`,
+      );
+      continue;
+    }
+
+    mkdirSync(join(REPO, mirror), { recursive: true });
+    writeFileSync(abs, src);
+    console.log(`↻ ${rel}  ← shared/resource-rule/${file}（sha256 ${srcHash.slice(0, 12)}）`);
+  }
+
+  // 副本目錄裡多出來的 .mjs = 有人在產生物旁邊自己加了一支（第二份實作的常見長法）。
+  const mirrorAbs = join(REPO, mirror);
+  const extra = existsSync(mirrorAbs)
+    ? readdirSync(mirrorAbs).filter((f) => f.endsWith('.mjs') && !FILES.includes(f))
+    : [];
+  for (const f of extra) {
+    drifted++;
+    console.error(`✗ ${mirror}/${f} 在原稿目錄裡不存在——副本目錄不是放自己東西的地方。`);
+  }
+}
+
+if (drifted > 0) {
+  console.error(
+    `\n❌ ${drifted} 項與規則原稿脫節。` +
+      `\n「該用哪些資源」只能有一份實作（.claude/rules/07-thin-shell.md）——` +
+      `副本漂移就是第二份實作偷偷長出來的樣子。`,
+  );
+  process.exit(1);
+}
@@ -0,0 +1,138 @@
+# `shared/resource-rule` — 「這個實例該用哪些資源」的唯一一份規則
+
+> leo 2026-08-12：
+> ①「如果你沒有裝，就是新的；**如果你已經有，原來叫什麼名字就繼續用下去**。」
+> ②「**根本就不應該在 CLI，我要的是一個大家都可以用到的規則。**」
+
+① 是規則本身，② 是它該住哪裡。這個目錄就是 ②。
+
+---
+
+## 1. 規則（三句話）
+
+判準是「**這顆 worker 現在綁著誰**」，**不是**「有沒有叫這個名字的資源」。
+
+1. **已部署的 worker 上綁著什麼，那就是事實** → 原封不動沿用，不管那顆資源叫什麼名字。
+2. **只有「確定沒有任何人綁過它」才准新建**（新版本新增的 binding、或真的全新帳號）。
+3. **只要有一點說不準就整趟停手**——讀不到綁定／綁著的資源不見了／同一個 binding 指向兩顆／
+   該更新的 worker 一顆都不在 ⇒ **什麼都不建、什麼都不部署**，把話說清楚讓人來判斷。
+
+`planResources()`（不寫入，只出計畫）與 `applyResourcePlan()`（有 blocker 就拒絕執行）分兩段，
+所以「被擋下的時候一顆資源都不會被建出來」是**結構上的保證**，不是靠誰記得寫 early return。
+
+---
+
+## 2. 為什麼在這裡，不在 cypher-executor 的 API
+
+`.claude/rules/07-thin-shell.md` 的標準答案是「能力放 API」。這一條**不走那條路**，理由是自舉：
+
+| 問題 | 說明 |
+|---|---|
+| **cypher 可能還不存在** | 這條規則要在「決定怎麼裝」的當下就用得到，而安裝器的工作正是把 cypher 生出來。把規則放進 cypher = 要先有雞才能有蛋。 |
+| **輸入是使用者自己的帳號狀態** | 判斷的依據是使用者 Cloudflare 帳號上的綁定。送去平台託管的 worker 換一個答案 ⇒ ①「能不能安裝」綁在平台是否活著，②使用者的帳號拓撲交給第三方。 |
+| **它根本不需要是服務** | 這是**純函式**：唯一的 IO 由呼叫端注入（`ResourceApi`）。薄殼原則要求「能力只實作一次」，不是「能力一定要是 HTTP」。 |
+
+所以形態是**一份零依賴的 ESM**——Node 18+ 與 Cloudflare Workers runtime 都能直接 import，
+不必編譯、不必連網、不必先有任何 arcrun 元件活著。
+
+其他評估過的形態：**共用 npm 套件** → 要多發一個 package + token，且安裝器得先 `npm i` 才能判斷，
+自舉問題只是換個位置；**做成一顆零件** → 得用 TinyGo/AssemblyScript 重寫一次，那正是「第二份實作」。
+
+---
+
+## 3. 檔案
+
+| 檔案 | 內容 |
+|---|---|
+| `rule.mjs` | 規則本體：`planResources` / `applyResourcePlan` / `parseWranglerRequirements` ＋ 把 CF 回應讀成事實的 `normalizeLiveBindings` / `normalizeLiveVars` |
+| `cf-resource-api.mjs` | `ResourceApi` 的 CF REST 實作（只用 global `fetch`）。**眼睛也要共用**——見下 §5 |
+| `installer-entry.mjs` | 安裝器唯一該碰的入口：`resolveInstanceResources()` |
+| `tests/fixture-account.mjs` | 假 Cloudflare 帳號（`fetch` 替身）＋三種情境 |
+| `tests/demo.mjs` | `node shared/resource-rule/tests/demo.mjs`——零依賴、零建置就能跑的示範 |
+
+🔴 **零依賴是硬規則**：只准 import 同目錄的兄弟檔，不准碰 `node:*`。
+有外部依賴就會有某條路吃不到它。`cli/tests/single-implementation.test.ts` ③ 會擋。
+
+---
+
+## 4. 兩條路怎麼取用
+
+### 安裝器 / 任何 Worker（不需要副本）
+
+安裝器本來就會下載本 repo 的 archive 當部署來源（`.claude/rules/05-deploy-convention.md`
+「WASM 來源」），`shared/resource-rule/` 就在那份 archive 裡：
+
+```js
+import { resolveInstanceResources } from './shared/resource-rule/installer-entry.mjs';
+
+const r = await resolveInstanceResources({
+  accountId, apiToken,
+  wranglerTomls: [cypherToml, registryToml, mcpToml, kbdbToml],  // toml 的「內容」，不是路徑
+  mode: isUpdate ? 'update' : 'init',
+});
+
+if (r.blocked) {
+  // 🔴 一顆資源都沒被建。把 r.blockers 原文顯示給使用者，**不要自己「試著繼續」**。
+  return showAndStop(r.blockers);
+}
+// r.bindings  : { 'kv_namespace:WEBHOOKS': 'kvid-…', 'd1:DB': 'uuid-…', … }
+// r.origin    : { 'kv_namespace:WEBHOOKS': 'adopted' | 'created', … }
+// r.liveVars  : { 'arcrun-cypher-executor': { ARCRUN_BUNDLE_VERSION: '1.4.33', … } }  ← #106
+```
+
+**安裝器不准自己判斷要不要建資源**，也不准自己解讀 CF 的 binding 回應。只呼叫這一支。
+
+### `acr` CLI（需要一份鏡射）
+
+`arcrun` 是獨立 npm 套件，`npm pack` 打不進套件目錄外的檔案 ⇒ 套件裡必須自帶一份。
+`cli/src/lib/resource-rule/` 就是本目錄的**逐位元組鏡射**，由
+`node scripts/sync-resource-rule.mjs` 產生。
+
+**要改規則就改這個目錄，然後重跑 sync。** 手改鏡射會被擋下：
+`npm run build` 與 `npm test` 都先跑 `sync-resource-rule.mjs --check`，
+差一個位元組就 exit 1（同 `cli/harness/` 的產生物＋世代閘慣例）。
+
+---
+
+## 5. 為什麼連 CF client 也共用
+
+判斷一致還不夠，**看到的東西**也要一致。
+
+「已部署的 worker 綁著什麼」是從 `GET /workers/scripts/{script}/settings` 讀來的。
+兩條路各自寫一份 client，只要有一邊把 404 當錯誤、漏了 `per_page`、少認一種欄位名
+（`namespace_id` vs `id`），那一邊就會「看不到既有綁定」——
+而看不到既有綁定的下一步，依規則就是**新建**。
+
+**Arcrun#97 不需要規則寫錯，眼睛不一樣就足以重演。**
+所以 `cli/src/lib/cf-api.ts` 的 `CfAccountClient` 把 `ResourceApi` 那七個方法**全部委派**
+給 `cf-resource-api.mjs`，自己不留實作。
+
+---
+
+## 6. 驗收
+
+```bash
+cd cli && npm test          # 58 項，含下列三組
+node shared/resource-rule/tests/demo.mjs   # 安裝器那條路，零依賴獨立跑
+```
+
+| 測試 | 證的事 |
+|---|---|
+| `cli/tests/two-paths-agree.test.ts` | 同一個帳號狀態餵給 `acr` 那條與安裝器那條，**選出的 resource id 相同**、建的東西相同、停手的理由相同 |
+| `cli/tests/single-implementation.test.ts` | ①規則的 7 支函式全 repo 只有這裡有實作 ②鏡射逐位元組相同 ③共用層零依賴 |
+| `cli/tests/resource-adoption.test.ts` | #97 本身的迴歸（沿用／不多建／四種停手情境），改共用層後照樣全過 |
+
+三種情境（`tests/fixture-account.mjs` 的 `SCENARIOS`）：
+
+- `fresh` — 沒裝過 → **正常建新的**（不能為了沿用而變成永遠不建）
+- `installed` — 裝過了 → 沿用原本那幾顆，工作流與登入 session 都還在
+- `renamed` — **資源在但名字與預期完全不同** → 仍然沿用（#97 的病根，專門驗）
+
+---
+
+## 7. 相關
+
+- `Arcrun#97` — 「我按了更新，工作流和登入全不見了」：CLI 那條已修，本目錄是把同一條規則交給所有路徑
+- `Arcrun#106` — 重部署把 `plain_text` var（含版本標籤）洗掉：`liveVars` 就是那些標籤
+- `Arcrun#80` / `arcrun-rag#39` — 同一個「重複做 Arcrun 的工作」家族；Arcrun 是唯一編譯點的既有慣例
+- `.claude/rules/07-thin-shell.md` — 本目錄存在的依據
@@ -0,0 +1,202 @@
+// @ts-check
+/**
+ * cf-resource-api.mjs — 規則的**眼睛與手**：對 Cloudflare 帳號的那七個動作，也只有一份。
+ *
+ * `rule.mjs` 是純判斷，IO 由呼叫端注入（`ResourceApi`）。本檔就是那個注入物的正貨：
+ * 用 CF REST API 實作 `ResourceApi`，零依賴、只用 global `fetch`
+ * ⇒ Node 18+ 與 Cloudflare Workers runtime 都能直接跑。
+ *
+ * 【為什麼連這層也要共用】
+ * 判斷一致還不夠——**看到的東西**也要一致。
+ * 「已部署的 worker 綁著什麼」是從 `GET /workers/scripts/{script}/settings` 讀來的；
+ * 如果兩條路各自寫一份 client，隨便一個差異（打錯端點、把 404 當錯誤、漏了 per_page、
+ * 少認一種欄位名）都會讓其中一條路「看不到既有綁定」——而看不到既有綁定的下一步，
+ * 依規則就是**新建**。Arcrun#97 的災情不需要規則寫錯，只要眼睛不一樣就會重演。
+ *
+ * 這裡**故意只有 `ResourceApi` 那七個方法**。verifyAccess / 查 subdomain / KV 讀寫
+ * 這些跟「該用哪些資源」無關的帳號操作留在各自的呼叫端，不往共用層堆。
+ *
+ * 🔴 除了同目錄的 `./rule.mjs`，這支不准 import 任何東西——共用層的價值在於
+ *    「整個目錄複製到哪個 runtime 都能直接跑」，多一個外部依賴就少一條路吃得到。
+ */
+
+import { normalizeLiveBindings, normalizeLiveVars } from './rule.mjs';
+
+const CF_API_BASE = 'https://api.cloudflare.com/client/v4';
+
+/**
+ * @typedef {import('./rule.mjs').ResourceApi} ResourceApi
+ * @typedef {import('./rule.mjs').ScriptBindings} ScriptBindings
+ * @typedef {import('./rule.mjs').RawWorkerBinding} RawWorkerBinding
+ */
+
+/**
+ * @typedef {object} CfResourceApiOptions
+ * @property {string} accountId
+ * @property {string} apiToken
+ * @property {typeof globalThis.fetch} [fetch]
+ *   注入用（離線測試餵假帳號、或宿主要用自己的 fetch）。預設 global fetch。
+ */
+
+/**
+ * 建一個打真實 Cloudflare 的 `ResourceApi`。
+ *
+ * @param {CfResourceApiOptions} options
+ * @returns {ResourceApi & { cfRaw: (path: string, init?: RequestInit) => Promise<{ok: boolean, status: number, result?: any, error?: string}> }}
+ */
+export function createCloudflareResourceApi({ accountId, apiToken, fetch: fetchImpl }) {
+  const doFetch = fetchImpl ?? globalThis.fetch;
+  if (typeof doFetch !== 'function') {
+    throw new Error('createCloudflareResourceApi：這個執行環境沒有 fetch，請用 options.fetch 注入。');
+  }
+  const accountBase = `${CF_API_BASE}/accounts/${accountId}`;
+  const headers = {
+    Authorization: `Bearer ${apiToken}`,
+    'Content-Type': 'application/json',
+  };
+
+  /**
+   * 把 HTTP status 交回呼叫端自己判斷（要區分「404 不存在」和「其他錯誤」時用）。
+   * @param {string} path
+   * @param {RequestInit} [init]
+   * @returns {Promise<{ok: boolean, status: number, result?: any, error?: string}>}
+   */
+  async function cfRaw(path, init) {
+    const res = await doFetch(`${accountBase}${path}`, {
+      ...init,
+      headers: { ...headers, ...(init?.headers ?? {}) },
+    });
+    const data = await res.json().catch(() => null);
+    if (!res.ok || !data?.success) {
+      return {
+        ok: false,
+        status: res.status,
+        error:
+          (data?.errors ?? []).map((/** @type {{message?: string}} */ e) => e.message).filter(Boolean).join('; ') ||
+          `HTTP ${res.status}`,
+      };
+    }
+    return { ok: true, status: res.status, result: data.result };
+  }
+
+  /**
+   * @param {string} path
+   * @param {RequestInit} [init]
+   * @returns {Promise<any>}
+   */
+  async function cf(path, init) {
+    const { ok, status, result, error } = await cfRaw(path, init);
+    if (!ok) throw new Error(`CF API ${path} 失敗：${error ?? `HTTP ${status}`}`);
+    return result;
+  }
+
+  return {
+    cfRaw,
+
+    /**
+     * 讀一顆已部署 worker 現在綁著哪些資源——**使用者那側的事實**（Arcrun#97 的唯一真相源）。
+     *
+     * - script 不存在（404）→ `{ deployed: false }`，這是「還沒部署」，不是錯誤。
+     * - 其他任何失敗 → throw。呼叫端必須把它當「我不知道」而**不是**「它沒有」——
+     *   把查不到當成不存在，就是 #97 的根因。
+     *
+     * @param {string} script
+     * @returns {Promise<ScriptBindings>}
+     */
+    async getScriptBindings(script) {
+      const path = `/workers/scripts/${encodeURIComponent(script)}/settings`;
+      const res = await cfRaw(path);
+      if (!res.ok) {
+        if (res.status === 404) return { deployed: false, bindings: [], vars: {} };
+        throw new Error(`讀 ${script} 綁定失敗：${res.error}`);
+      }
+      /** @type {RawWorkerBinding[]} */
+      const raw = res.result?.bindings ?? [];
+      return {
+        deployed: true,
+        bindings: normalizeLiveBindings(raw),
+        vars: normalizeLiveVars(raw),
+      };
+    },
+
+    /** @returns {Promise<Map<string, string>>} title → id */
+    async listKvNamespaces() {
+      /** @type {Array<{id: string, title: string}>} */
+      const result = await cf('/storage/kv/namespaces?per_page=100');
+      const map = new Map();
+      for (const ns of result) map.set(ns.title, ns.id);
+      return map;
+    },
+
+    /** @returns {Promise<Map<string, string>>} name → uuid */
+    async listD1Databases() {
+      /** @type {Array<{uuid: string, name: string}>} */
+      const result = await cf('/d1/database?per_page=100');
+      const map = new Map();
+      for (const db of result) map.set(db.name, db.uuid);
+      return map;
+    },
+
+    /** @returns {Promise<string[]>} */
+    async listVectorizeIndexes() {
+      /** @type {Array<{name: string}>} */
+      const result = await cf('/vectorize/v2/indexes');
+      return (result ?? []).map((i) => i.name);
+    },
+
+    /**
+     * 無條件新建一顆 KV namespace。
+     *
+     * 🔴 Arcrun#97：這裡**故意沒有**「找不到同名就順手建一顆」的 ensure 版本。
+     * 「照名字找 → 找不到 → 新建 → 綁上去」正是把使用者實例洗成空的那條路
+     * （安裝器取的名字跟 binding 名不一樣，永遠對不上 ⇒ 每次更新都新建）。
+     * 要不要建一律先過 `planResources`。
+     *
+     * @param {string} title
+     * @returns {Promise<string>}
+     */
+    async createKvNamespace(title) {
+      const result = await cf('/storage/kv/namespaces', {
+        method: 'POST',
+        body: JSON.stringify({ title }),
+      });
+      return result.id;
+    },
+
+    /**
+     * 無條件新建 D1。沒有 ensure 版本，理由同 createKvNamespace（Arcrun#97）。
+     * @param {string} name
+     * @returns {Promise<string>}
+     */
+    async createD1Database(name) {
+      const result = await cf('/d1/database', {
+        method: 'POST',
+        body: JSON.stringify({ name }),
+      });
+      return result.uuid;
+    },
+
+    /**
+     * 新建 KBDB embed 用的 Vectorize index（**bge-m3 = 1024 維 / cosine**）。
+     * 已存在（409 / already exists）視為成功——並行或重跑不該炸。
+     * 沒有 ensure 版本：「要不要建」由 planResources 判斷，這裡只負責建（Arcrun#97）。
+     *
+     * @param {string} name
+     * @returns {Promise<string>}
+     */
+    async createVectorizeIndex(name) {
+      const res = await cfRaw('/vectorize/v2/indexes', {
+        method: 'POST',
+        body: JSON.stringify({
+          name,
+          config: { dimensions: 1024, metric: 'cosine' },
+          description: 'arcrun KBDB embed module — bge-m3 1024d (issue #7 / #59)',
+        }),
+      });
+      if (res.ok) return name;
+      const detail = (res.error ?? '').toLowerCase();
+      if (res.status === 409 || /already exists|duplicate|conflict/.test(detail)) return name;
+      throw new Error(`建 Vectorize index ${name} 失敗：${res.error}`);
+    },
+  };
+}
@@ -0,0 +1,100 @@
+// @ts-check
+/**
+ * installer-entry.mjs — 安裝器那條路的**唯一入口**。
+ *
+ * 安裝器（arcrun-rag `installer/oauth-prototype/worker.js`）不必、也不准自己判斷
+ * 「該建哪些資源」——它只要呼叫這一支，拿回「每個 binding 該用哪顆資源」。
+ *
+ * ```js
+ * import { resolveInstanceResources } from './shared/resource-rule/installer-entry.mjs';
+ *
+ * const r = await resolveInstanceResources({
+ *   accountId, apiToken,
+ *   wranglerTomls: [cypherToml, registryToml, mcpToml, kbdbToml],  // 字串陣列
+ *   mode: isUpdate ? 'update' : 'init',
+ * });
+ * if (r.blocked) {
+ *   // 🔴 一顆資源都沒被建。把 r.blockers 原文顯示給使用者，**不要自己「試著繼續」**。
+ *   return showAndStop(r.blockers);
+ * }
+ * // r.bindings: { 'kv_namespace:WEBHOOKS': 'kvid-…', 'd1:DB': 'uuid-…', … }
+ * // r.liveVars: { 'arcrun-cypher-executor': { ARCRUN_BUNDLE_VERSION: '1.4.33', … } }
+ * ```
+ *
+ * 為什麼安裝器不需要副本：安裝器本來就會下載本 repo 的 archive 當部署來源
+ * （見 `.claude/rules/05-deploy-convention.md`「WASM 來源」），
+ * `shared/resource-rule/` 就在那份 archive 裡，直接 import 即可——
+ * **不必再編一次、不必貼一份、也就不會有第二種答案。**
+ */
+
+import { planResources, applyResourcePlan, parseWranglerRequirements, ResourcePlanBlocked } from './rule.mjs';
+import { createCloudflareResourceApi } from './cf-resource-api.mjs';
+
+/**
+ * @typedef {object} ResolveOptions
+ * @property {string} accountId
+ * @property {string} apiToken
+ * @property {string[]} wranglerTomls  各 worker 的 wrangler.toml **內容**（不是路徑）。
+ * @property {'update' | 'init'} mode  這台照定義裝過了沒。
+ * @property {typeof globalThis.fetch} [fetch]  注入用（測試／宿主自帶 fetch）。
+ */
+
+/**
+ * @typedef {object} ResolveResult
+ * @property {boolean} blocked            true = 什麼都沒建、什麼都不該部署。
+ * @property {string[]} blockers          blocked 時的原因原文（要原樣轉給使用者）。
+ * @property {Record<string, string>} bindings   `${kind}:${binding}` → 資源 id／index 名。
+ * @property {Record<string, 'adopted'|'created'>} origin  同上 key → 這顆是沿用還是新建。
+ * @property {Record<string, Record<string, string>>} liveVars  script → 現有 plain_text var（#106）。
+ */
+
+/**
+ * 決定這台實例每個 binding 該用哪顆資源；照規則沿用既有、只在確定沒人綁過時才新建。
+ *
+ * @param {ResolveOptions} options
+ * @returns {Promise<ResolveResult>}
+ */
+export async function resolveInstanceResources({ accountId, apiToken, wranglerTomls, mode, fetch }) {
+  const api = createCloudflareResourceApi({ accountId, apiToken, fetch });
+
+  /** @type {import('./rule.mjs').BindingRequirement[]} */
+  const requirements = [];
+  for (const toml of wranglerTomls) {
+    const parsed = parseWranglerRequirements(toml);
+    if (!parsed.script) continue;  // 沒宣告 name 的 toml 不該存在；跳過而非亂猜
+    for (const b of parsed.bindings) requirements.push({ ...b, worker: parsed.script });
+  }
+
+  /** @param {string[]} blockers @returns {ResolveResult} */
+  const stop = (blockers) => ({ blocked: true, blockers, bindings: {}, origin: {}, liveVars: {} });
+
+  if (requirements.length === 0) {
+    return stop(['這批 wrangler.toml 裡讀不到任何資源綁定需求——不確定要裝什麼，停手。']);
+  }
+
+  let plan;
+  try {
+    plan = await planResources(api, requirements, mode);
+  } catch (e) {
+    return stop([`資源解析失敗（${e instanceof Error ? e.message : String(e)}）。沒有建立任何資源。`]);
+  }
+  if (plan.blockers.length > 0) return stop(plan.blockers);
+
+  /** @type {Map<string, import('./rule.mjs').ResolvedResource>} */
+  let resolved;
+  try {
+    resolved = await applyResourcePlan(api, plan);
+  } catch (e) {
+    return stop(e instanceof ResourcePlanBlocked ? e.blockers : [e instanceof Error ? e.message : String(e)]);
+  }
+
+  /** @type {Record<string, string>} */
+  const bindings = {};
+  /** @type {Record<string, 'adopted'|'created'>} */
+  const origin = {};
+  for (const [key, r] of resolved) {
+    bindings[key] = r.value;
+    origin[key] = r.origin;
+  }
+  return { blocked: false, blockers: [], bindings, origin, liveVars: Object.fromEntries(plan.liveVars) };
+}
@@ -0,0 +1,570 @@
+// @ts-check
+/**
+ * rule.mjs — 「這個實例該用哪些資源」的**唯一一份**規則。
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 這份檔案為什麼在這裡（`shared/`），不在 `cli/`
+ * ─────────────────────────────────────────────────────────────────────────────
+ * leo 2026-08-12：「根本就不應該在 CLI，我要的是一個大家都可以用到的規則。」
+ *
+ * `.claude/rules/07-thin-shell.md` 的判準口訣：
+ *   「這段邏輯換一個介面要不要重寫？」要重寫 → 它是能力，該在共用層。
+ *
+ * 「該沿用哪幾顆資源」換到安裝器就得重寫一次 ⇒ 它是**能力**，不是薄殼的事。
+ * 而它原本住在 `cli/src/lib/resource-resolver.ts` ⇒ 那本身就是違規，
+ * 後果也真的發生了：`acr` 那條有這條規則、安裝器那條沒有，於是安裝器照名字找、
+ * 找不到就建新的空的 ⇒ Arcrun#97「我按了更新，工作流和登入全不見了」。
+ *
+ * ── 為什麼不是 cypher-executor 的 API 端點（薄殼原則的標準答案）────────────
+ * **自舉**：這條規則要在「決定怎麼裝／怎麼更新」的當下就用得到，而那個當下
+ * cypher 可能還不存在（安裝器的工作正是把它生出來），或正要被覆蓋。
+ * 而且判斷的輸入是**使用者自己 Cloudflare 帳號上的綁定狀態**——
+ * 把它送去一顆平台託管的 worker 換一個答案，等於①讓「能不能安裝」綁在平台是否活著，
+ * ②把使用者的帳號拓撲交給第三方。兩件都不該為了形式上的漂亮而做。
+ *
+ * 薄殼原則要求的是「能力只實作一次」，不是「能力一定要是 HTTP」。
+ * 這條規則是**純函式**（唯一的 IO 由呼叫端注入 `ResourceApi`），
+ * 所以它用不著變成服務——一份零依賴的 ESM 就能讓每條路吃到同一份判斷。
+ *
+ * ── 怎麼讓兩條路吃到「同一份」而不是各留一份 ───────────────────────────────
+ * 本檔是**唯一被人手維護的實作**，零依賴、不吃任何 node 內建、Workers runtime 可直接跑。
+ *   · `acr`：`cli/src/lib/resource-rule.mjs` 是本檔的**逐位元組副本**，
+ *     由 `scripts/sync-resource-rule.mjs` 產生（CLI 要能單獨 npm publish，
+ *     套件目錄外的檔案打不進 tarball，故必須有這一份）。
+ *     `npm run build` / `npm test` 都會跑 `--check`，內容一漂就紅。
+ *     ——同 `cli/harness/`（產生物＋世代閘）的既有慣例。
+ *   · 安裝器 / 任何 Worker：安裝器本來就會下載本 repo 的 archive（部署來源，
+ *     見 `.claude/rules/05-deploy-convention.md`「WASM 來源」），
+ *     直接 import 這一份 `shared/resource-rule/rule.mjs` 即可，**不需要再編一次、也不留副本**。
+ *     用法見同目錄 README.md。
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 規則本身（leo 的兩句話）
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 「如果你沒有裝，就是新的；如果你已經有，原來叫什麼名字就繼續用下去。」
+ *
+ * 判準是「**這顆 worker 現在綁著誰**」，不是「有沒有叫這個名字的資源」：
+ *   1. **已部署的 worker 上綁著什麼，那就是事實** → 原封不動沿用，不管那顆資源叫什麼名字。
+ *   2. **只有「確定沒有任何人綁過它」才准新建**（新版本新增的 binding、或真的全新帳號）。
+ *   3. **只要有一點說不準就整趟停手**（讀不到綁定／綁著的資源不見了／同一個 binding 指向兩顆／
+ *      該更新的 worker 一顆都不在），**什麼都不建、什麼都不部署**，把話說清楚讓人來判斷。
+ *
+ * ── 為什麼拆成 plan / apply 兩段 ─────────────────────────────────────
+ *   `planResources()` **完全不寫入**，只回一份「要沿用什麼、要新建什麼、有什麼不敢動的」。
+ *   `applyResourcePlan()` 看到有任何 blocker 就直接拒絕執行。
+ *   ⇒「被擋下的時候一顆資源都不會被建出來」是**結構上的保證**，
+ *     不是靠某個人記得在對的地方寫 early return。#97 正是死在「先動手、後判斷」。
+ *
+ * 🔴 這份檔案沒有 import、也不准有。任何依賴都會讓某一條路吃不到它。
+ */
+
+/**
+ * 這支負責的資源種類。要加新種類（R2/Queue/Hyperdrive…）就加在這裡，
+ * 一律走同一道門——不准任何呼叫端自己「照名字 ensure」繞過去。
+ * @typedef {'kv_namespace' | 'd1' | 'vectorize'} ResourceKind
+ */
+
+/**
+ * 從已部署 worker 上讀回來的一條綁定。`value`：KV/D1 是資源 id，Vectorize 是 index 名。
+ * @typedef {object} LiveBinding
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} value
+ */
+
+/**
+ * @typedef {object} ScriptBindings
+ * @property {boolean} deployed
+ *   false = 這顆 worker 在帳號上還不存在（全新部署），不是「讀取失敗」。讀取失敗要 throw。
+ * @property {LiveBinding[]} bindings
+ * @property {Record<string, string>} [vars]
+ *   這顆 worker 現在掛著的 `plain_text` var（名 → 值）。
+ *
+ *   🔴 Arcrun#106：#97 只把「資源類」綁定當成事實沿用（KV/D1/Vectorize），
+ *     plain_text var 整批沒人管 ⇒ 重部署把它們洗成 repo toml 的預設值。
+ *     最痛的一個是 `ARCRUN_BUNDLE_VERSION`（安裝器注入的版本標籤）——
+ *     更新完就消失，Portal 設定頁變成「無法讀取目前版本」。
+ *     **保留了櫃子，沒保留櫃子上的標籤**。這個欄位就是那些標籤。
+ */
+
+/**
+ * 規則需要的 CF 能力（收窄成介面，方便離線測試餵假帳號，也讓安裝器用自己的 fetch 實作）。
+ * @typedef {object} ResourceApi
+ * @property {(script: string) => Promise<ScriptBindings>} getScriptBindings
+ * @property {() => Promise<Map<string, string>>} listKvNamespaces  title → id
+ * @property {() => Promise<Map<string, string>>} listD1Databases   name → uuid
+ * @property {() => Promise<string[]>} listVectorizeIndexes
+ * @property {(title: string) => Promise<string>} createKvNamespace
+ * @property {(name: string) => Promise<string>} createD1Database
+ * @property {(name: string) => Promise<string>} createVectorizeIndex
+ */
+
+/**
+ * 「這顆 worker 需要這個 binding」。createName 只在**真的要新建**時才會被拿來當名字用。
+ * @typedef {object} BindingRequirement
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} worker  需要它的 worker script 名（= wrangler.toml 的 `name`）。
+ * @property {string} createName
+ */
+
+/**
+ * @typedef {object} PlannedAdopt
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} value
+ * @property {string} from  從哪顆已部署的 worker 上讀到的
+ */
+
+/**
+ * @typedef {object} PlannedCreate
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} createName
+ * @property {string[]} wantedBy
+ * @property {string[]} alsoBind  其他也指向同一顆資源的 binding（見 shareSameResource）。建一顆，大家共用。
+ */
+
+/**
+ * @typedef {object} ResourcePlan
+ * @property {PlannedAdopt[]} adopt
+ * @property {PlannedCreate[]} create
+ * @property {string[]} blockers  非空 = 整趟停手。applyResourcePlan 會拒絕執行。
+ * @property {Map<string, Record<string, string>>} liveVars
+ *   每顆**已部署** worker 現在掛著的 plain_text var（script → 名/值）。未部署的不在裡面。
+ *
+ *   Arcrun#106：讀綁定的時候本來就把整份 `bindings[]` 拿回來了，var 就在同一份回應裡——
+ *   順手帶出來，**不另外打一次 API**，也不新增一種「查不到」的失敗模式
+ *   （讀不到綁定這件事已經在上面 blockers 那一關擋掉了）。
+ */
+
+/**
+ * @typedef {object} ResolvedResource
+ * @property {ResourceKind} kind
+ * @property {string} binding
+ * @property {string} value
+ * @property {'adopted' | 'created'} origin
+ * @property {string} [from]
+ */
+
+/**
+ * @typedef {object} WranglerRequirements
+ * @property {string} script  worker script 名（toml 頂層 `name`）。空字串 = 這份 toml 沒宣告 name（不該發生）。
+ * @property {Array<{kind: ResourceKind, binding: string, createName: string}>} bindings
+ */
+
+/** plan 被擋下時丟這個，讓呼叫端能把每一條原因原文轉給使用者。 */
+export class ResourcePlanBlocked extends Error {
+  /** @param {string[]} blockers */
+  constructor(blockers) {
+    super(`資源解析被擋下（${blockers.length} 項）`);
+    this.name = 'ResourcePlanBlocked';
+    /** @type {string[]} */
+    this.blockers = blockers;
+  }
+}
+
+/**
+ * @param {ResourceKind} kind
+ * @param {string} binding
+ * @returns {string}
+ */
+export function bindingKey(kind, binding) {
+  return `${kind}:${binding}`;
+}
+
+/** @type {Record<ResourceKind, string>} */
+export const KIND_LABEL = {
+  kv_namespace: 'KV namespace',
+  d1: 'D1 資料庫',
+  vectorize: 'Vectorize index',
+};
+
+/**
+ * @param {unknown} e
+ * @returns {string}
+ */
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+/**
+ * 決定每個 binding 要沿用哪顆資源／要不要新建，**不寫入任何東西**。
+ *
+ * @param {ResourceApi} api
+ * @param {readonly BindingRequirement[]} requirements
+ * @param {'update' | 'init'} mode
+ *   'update' = 這台照定義已經裝過了（見下方「一顆都不在」規則）；'init' = 全新安裝，允許從零建。
+ * @returns {Promise<ResourcePlan>}
+ */
+export async function planResources(api, requirements, mode) {
+  /** @type {string[]} */
+  const blockers = [];
+  /** @type {PlannedAdopt[]} */
+  const adopt = [];
+  /** @type {PlannedCreate[]} */
+  const create = [];
+
+  // ── 1. 先讀「即將被覆蓋的每一顆 worker」現在綁著什麼 ──────────────────
+  // 讀取失敗 ≠ 沒有綁。#97 的災情就是把「我查不到」當成「它不存在」。
+  const scripts = [...new Set(requirements.map((r) => r.worker))].sort();
+  /** @type {Map<string, LiveBinding[]>} */
+  const live = new Map();
+  /** @type {Map<string, Record<string, string>>} */
+  const liveVars = new Map();
+  let readFailed = false;
+  for (const script of scripts) {
+    try {
+      const res = await api.getScriptBindings(script);
+      if (res.deployed) {
+        live.set(script, res.bindings);
+        // #106：同一份回應裡的 plain_text var 一起收下（呼叫端要拿它決定哪些 var 該沿用）。
+        liveVars.set(script, res.vars ?? {});
+      }
+    } catch (e) {
+      readFailed = true;
+      blockers.push(
+        `讀不到已部署的 worker「${script}」目前綁著哪些資源（${msg(e)}）。` +
+          `不確定它現在用的是哪一顆，就不能重新綁——整趟更新停手，沒有動任何東西。`,
+      );
+    }
+  }
+
+  // 「這台照定義已經裝過了，卻一顆 worker 都找不到」= 我對不上它的實例（名字不同／token 看不到）。
+  // 這種時候繼續走下去，等於把一整套資源重新生一遍再綁上去——正是 #97 的形狀，只是換一道門進來。
+  if (mode === 'update' && !readFailed && live.size === 0 && scripts.length > 0) {
+    blockers.push(
+      `在這個 Cloudflare 帳號上找不到任何一顆要更新的 worker（找過：${scripts.join('、')}）。` +
+        `acr update 的前提是「這台已經裝好了」——對不上就不猜：` +
+        `可能是 API token 看得到的帳號不對，或這台實例的 worker 用了別的名字。` +
+        `已停手，沒有新建任何資源。`,
+    );
+  }
+
+  // ── 2. 逐個 binding 決定：沿用 / 新建 / 停手 ─────────────────────────
+  /** @type {Map<string, BindingRequirement[]>} */
+  const byKey = new Map();
+  for (const req of requirements) {
+    const key = bindingKey(req.kind, req.binding);
+    const list = byKey.get(key);
+    if (list) list.push(req);
+    else byKey.set(key, [req]);
+  }
+
+  /** @type {Map<ResourceKind, Set<string>>} */
+  const existingCache = new Map();
+  /** @param {ResourceKind} kind @returns {Promise<Set<string>>} */
+  const listExisting = async (kind) => {
+    const hit = existingCache.get(kind);
+    if (hit) return hit;
+    /** @type {Set<string>} */
+    let set;
+    if (kind === 'kv_namespace') set = new Set((await api.listKvNamespaces()).values());
+    else if (kind === 'd1') set = new Set((await api.listD1Databases()).values());
+    else set = new Set(await api.listVectorizeIndexes());
+    existingCache.set(kind, set);
+    return set;
+  };
+
+  for (const [, reqs] of byKey) {
+    const { kind, binding } = reqs[0];
+
+    /** @type {Array<{value: string, script: string}>} */
+    const found = [];
+    for (const [script, bindings] of live) {
+      const hit = bindings.find((b) => b.kind === kind && b.binding === binding);
+      if (hit) found.push({ value: hit.value, script });
+    }
+    const distinct = [...new Set(found.map((f) => f.value))];
+
+    // 2a. 同一個 binding 名在不同 worker 上指向不同資源 → 分不出哪個才是使用者要的。
+    //     自己挑一個 = 有一半機率把另外那半的資料從畫面上抹掉。不猜。
+    if (distinct.length > 1) {
+      blockers.push(
+        `綁定「${binding}」在不同 worker 上指向不同的 ${KIND_LABEL[kind]}` +
+          `（${found.map((f) => `${f.script} → ${f.value}`).join('、')}）。` +
+          `分不出哪一顆才是你在用的，不猜——停手。`,
+      );
+      continue;
+    }
+
+    // 2b. 有人綁著它 → 這就是事實，沿用。名字長什麼樣完全不看。
+    if (distinct.length === 1) {
+      const value = distinct[0];
+      /** @type {Set<string>} */
+      let existing;
+      try {
+        existing = await listExisting(kind);
+      } catch (e) {
+        blockers.push(
+          `查不到帳號上的 ${KIND_LABEL[kind]} 清單，無法確認「${binding}」綁著的 ${value} 還在不在` +
+            `（${msg(e)}）。不確定就不動——停手。`,
+        );
+        continue;
+      }
+      if (!existing.has(value)) {
+        // 這正是 #97 的入口：舊版在這裡會安靜地新建一顆空的頂上去。
+        blockers.push(
+          `worker「${found[0].script}」的「${binding}」綁著 ${KIND_LABEL[kind]} ${value}，` +
+            `但這顆在你的 Cloudflare 帳號上找不到了。` +
+            `這裡**不會**幫你新建一顆空的頂上去（Arcrun#97 的災情就是那樣來的）——` +
+            `請先確認那顆資源是被刪掉了，還是這把 API token 看不到它。`,
+        );
+        continue;
+      }
+      adopt.push({ kind, binding, value, from: found[0].script });
+      continue;
+    }
+
+    // 2c. 沒有任何已部署的 worker 綁過它 → 新版本新增的 binding，或全新帳號。
+    //     這種情況下新建不會弄丟任何東西（本來就沒有東西可丟）。
+    create.push({
+      kind,
+      binding,
+      createName: reqs[0].createName,
+      wantedBy: [...new Set(reqs.map((r) => r.worker))],
+      alsoBind: [],
+    });
+  }
+
+  return { adopt, create: shareSameResource(adopt, create, byKey), blockers, liveVars };
+}
+
+/**
+ * 收斂「不同 binding 其實是同一顆資源」的情況。
+ *
+ * 判準是 **toml 自己宣告的名字**（`database_name` / `index_name`），不是使用者那側的資源名——
+ * cypher 的 `CREDENTIALS_DB` 與 kbdb 的 `DB` 都寫 `database_name = "arcrun-kbdb"`，
+ * 那是**我們**在宣告「這兩個綁定指向同一顆庫」，跟 #97 那種「拿名字去猜使用者的資源」是兩回事。
+ *
+ * 沒有這一步會出兩種錯：
+ *   ① 全新安裝時建出兩顆同名 D1，KBDB 的資料與 credential 目錄從此分家。
+ *   ② 一邊已部署（沿用既有）、另一邊沒有（新建一顆空的）→ 半套資料，比全壞更難查。
+ *
+ * @param {PlannedAdopt[]} adopt
+ * @param {PlannedCreate[]} create
+ * @param {Map<string, BindingRequirement[]>} byKey
+ * @returns {PlannedCreate[]}
+ */
+function shareSameResource(adopt, create, byKey) {
+  /** @param {ResourceKind} kind @param {string} binding @returns {string | undefined} */
+  const declaredName = (kind, binding) =>
+    byKey.get(bindingKey(kind, binding))?.[0]?.createName;
+
+  /** @type {PlannedCreate[]} */
+  const out = [];
+  /** @type {Map<string, PlannedCreate>} */
+  const groups = new Map();
+
+  for (const c of create) {
+    const groupKey = `${c.kind} ${c.createName}`;
+
+    // ① 已經有 binding 沿用到同一顆（依 toml 宣告）→ 跟著沿用，不要另外建一顆。
+    const twin = adopt.find(
+      (a) => a.kind === c.kind && declaredName(a.kind, a.binding) === c.createName,
+    );
+    if (twin) {
+      adopt.push({ kind: c.kind, binding: c.binding, value: twin.value, from: twin.from });
+      continue;
+    }
+
+    // ② 同一趟裡有多個 binding 要建同一顆 → 建一次，其他人共用。
+    const head = groups.get(groupKey);
+    if (head) {
+      head.alsoBind.push(c.binding);
+      head.wantedBy = [...new Set([...head.wantedBy, ...c.wantedBy])];
+      continue;
+    }
+    groups.set(groupKey, c);
+    out.push(c);
+  }
+  return out;
+}
+
+/**
+ * 照 plan 動手：沿用的原樣帶出來，該建的才建。
+ * 有任何 blocker 直接丟 ResourcePlanBlocked，**一顆都不建**。
+ *
+ * @param {ResourceApi} api
+ * @param {ResourcePlan} plan
+ * @returns {Promise<Map<string, ResolvedResource>>}
+ */
+export async function applyResourcePlan(api, plan) {
+  if (plan.blockers.length > 0) throw new ResourcePlanBlocked(plan.blockers);
+
+  /** @type {Map<string, ResolvedResource>} */
+  const out = new Map();
+  for (const a of plan.adopt) {
+    out.set(bindingKey(a.kind, a.binding), {
+      kind: a.kind,
+      binding: a.binding,
+      value: a.value,
+      origin: 'adopted',
+      from: a.from,
+    });
+  }
+  /** @type {string[]} */
+  const madeSoFar = [];
+  for (const c of plan.create) {
+    /** @type {string} */
+    let value;
+    try {
+      if (c.kind === 'kv_namespace') value = await api.createKvNamespace(c.createName);
+      else if (c.kind === 'd1') value = await api.createD1Database(c.createName);
+      else value = await api.createVectorizeIndex(c.createName);
+    } catch (e) {
+      // 半途失敗：已經建出來的那幾顆還沒被綁到任何 worker 上。**要講出來**——
+      // 不講的話它們就是帳號上一批沒人認得的孤兒，而且下次重跑會再建一批。
+      const orphans = madeSoFar.length > 0
+        ? `\n  已經建好但還沒綁上任何 worker 的：${madeSoFar.join('、')}（重跑前可先刪掉，或留著讓下次沿用）`
+        : '';
+      throw new Error(`建 ${KIND_LABEL[c.kind]}「${c.createName}」失敗：${msg(e)}${orphans}`);
+    }
+    madeSoFar.push(`${KIND_LABEL[c.kind]} ${c.createName}`);
+    for (const binding of [c.binding, ...c.alsoBind]) {
+      out.set(bindingKey(c.kind, binding), { kind: c.kind, binding, value, origin: 'created' });
+    }
+  }
+  return out;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// wrangler.toml → 需求清單
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * wrangler.toml 的 table 名 → 資源種類。需求解析與注入共用同一張表，兩邊才不會對不上。
+ * @type {Record<string, ResourceKind>}
+ */
+export const TABLE_KIND = {
+  kv_namespaces: 'kv_namespace',
+  d1_databases: 'd1',
+  vectorize: 'vectorize',
+};
+
+/**
+ * 從 wrangler.toml 抽出「這顆 worker 需要哪些資源綁定」。
+ *
+ * 刻意寫成行掃描而不引 TOML parser：注入端（injectWranglerConfig）本來就是純文字操作，
+ * 兩邊用同一種視角看這份檔案才不會對不上。註解掉的區塊**不算需求**
+ * （kbdb 的 `[[vectorize]]` 預設是註解狀態，要開語義查詢時才會被取消註解 → 那時才成為需求）。
+ *
+ * 也是「零依賴」的一部分：不引 TOML parser ⇒ 安裝器 import 這支不必多裝任何東西。
+ *
+ * @param {string} toml
+ * @returns {WranglerRequirements}
+ */
+export function parseWranglerRequirements(toml) {
+  let script = '';
+  let seenTable = false;
+  /** @type {WranglerRequirements['bindings']} */
+  const bindings = [];
+
+  /** @type {ResourceKind | null} */
+  let kind = null;
+  let binding = '';
+  let createName = '';
+
+  const flush = () => {
+    if (kind && binding) {
+      bindings.push({ kind, binding, createName: createName || binding });
+    }
+    kind = null;
+    binding = '';
+    createName = '';
+  };
+
+  for (const raw of toml.split('\n')) {
+    const line = raw.trim();
+    if (line === '' || line.startsWith('#')) continue;
+
+    const table = line.match(/^\[\[?([A-Za-z0-9_]+)\]?\]$/);
+    if (table) {
+      flush();
+      seenTable = true;
+      kind = TABLE_KIND[table[1]] ?? null;
+      continue;
+    }
+
+    const kv = line.match(/^([A-Za-z0-9_]+)\s*=\s*"([^"]*)"/);
+    if (!kv) continue;
+    const [, key, value] = kv;
+
+    if (!seenTable && key === 'name') {
+      script = value;
+      continue;
+    }
+    if (!kind) continue;
+    if (key === 'binding') binding = value;
+    // 只有 D1／Vectorize 在 toml 裡帶得出「名字」；KV 沒有，退回用 binding 名（見 flush）。
+    else if (key === 'database_name' || key === 'index_name') createName = value;
+  }
+  flush();
+
+  return { script, bindings };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Cloudflare `/settings` 回應 → 事實（兩條路都要用同一種眼睛看）
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * CF `GET /accounts/{id}/workers/scripts/{script}/settings` 回的 binding 原始形狀
+ * （同一種資源在不同 API 版本欄位名不一，故全都收）。
+ *
+ * @typedef {object} RawWorkerBinding
+ * @property {string} [type]
+ * @property {string} [name]
+ * @property {string} [namespace_id]
+ * @property {string} [id]
+ * @property {string} [database_id]
+ * @property {string} [index_name]
+ * @property {string} [text]  `plain_text` 綁定的值（#106；secret_text 不會回值，本來就讀不到，也不該讀）。
+ */
+
+/**
+ * 把 CF 的 binding 陣列收斂成規則認得的三種資源。不認得的型別直接略過。
+ *
+ * 🔴 這支**刻意放在規則裡**，不留在各自的 CF client：
+ *   「什麼才算『這顆 worker 綁著某顆資源』」是規則的一部分。
+ *   兩條路各自解讀 CF 回應 = 漂移會從這裡長回來（例如一邊認 `namespace_id`、
+ *   另一邊只認 `id`，於是一邊看得到綁定、另一邊看不到 → 後者又去新建了）。
+ *
+ * @param {RawWorkerBinding[]} raw
+ * @returns {LiveBinding[]}
+ */
+export function normalizeLiveBindings(raw) {
+  /** @type {LiveBinding[]} */
+  const out = [];
+  for (const b of raw) {
+    if (!b?.name) continue;
+    if (b.type === 'kv_namespace') {
+      const value = b.namespace_id ?? b.id;
+      if (value) out.push({ kind: 'kv_namespace', binding: b.name, value });
+    } else if (b.type === 'd1' || b.type === 'd1_database') {
+      const value = b.id ?? b.database_id;
+      if (value) out.push({ kind: 'd1', binding: b.name, value });
+    } else if (b.type === 'vectorize') {
+      if (b.index_name) out.push({ kind: 'vectorize', binding: b.name, value: b.index_name });
+    }
+  }
+  return out;
+}
+
+/**
+ * 抽出已部署 worker 上的 `plain_text` var（#106）。
+ *
+ * 只收 `plain_text`——**`secret_text` 一律不碰**（CF 本來就不回值，也不該被搬來搬去；
+ * wrangler deploy 不會動 secret，它們自己會留著）。
+ *
+ * @param {RawWorkerBinding[]} raw
+ * @returns {Record<string, string>}
+ */
+export function normalizeLiveVars(raw) {
+  /** @type {Record<string, string>} */
+  const out = {};
+  for (const b of raw) {
+    if (b?.type === 'plain_text' && b.name && typeof b.text === 'string') out[b.name] = b.text;
+  }
+  return out;
+}
@@ -0,0 +1,60 @@
+// @ts-check
+/**
+ * demo.mjs — 安裝器那條路的**可獨立執行**證明。
+ *
+ *   node shared/resource-rule/tests/demo.mjs
+ *
+ * 這支只 import `shared/resource-rule/`，**沒有 node_modules、沒有建置步驟**——
+ * 跑得起來本身就是「安裝器把 repo archive 拉下來就能直接用」這句話的證據。
+ * （對照組：`acr` 那條要先 npm ci + TS 轉譯才跑得動。兩條路差在外殼，判斷是同一份。）
+ *
+ * 三種情境各跑一次，印出每個 binding 選到哪顆資源、以及這一趟建了幾顆。
+ */
+
+import { resolveInstanceResources } from '../installer-entry.mjs';
+import { makeAccount, SCENARIOS, WORKER_NEEDS } from './fixture-account.mjs';
+
+/** 用 fixture 的需求組出各 worker 的 wrangler.toml 內容。 */
+function tomls() {
+  return Object.entries(WORKER_NEEDS).map(([script, need]) => {
+    let t = `name = "${script}"\ncompatibility_date = "2025-02-19"\n`;
+    for (const b of need.kv) t += `\n[[kv_namespaces]]\nbinding = "${b}"\nid = "PLACEHOLDER"\n`;
+    for (const d of need.d1) {
+      t += `\n[[d1_databases]]\nbinding = "${d.binding}"\ndatabase_name = "${d.database_name}"\ndatabase_id = "PLACEHOLDER"\n`;
+    }
+    return t;
+  });
+}
+
+const order = /** @type {const} */ (['fresh', 'installed', 'renamed']);
+
+console.log('安裝器那條路（只 import shared/resource-rule/，零依賴、零建置）\n');
+
+for (const scenario of order) {
+  const mode = scenario === 'fresh' ? 'init' : 'update';
+  const account = makeAccount(scenario);
+  const r = await resolveInstanceResources({
+    accountId: 'acct-demo',
+    apiToken: 'tok-demo',
+    wranglerTomls: tomls(),
+    mode,
+    fetch: account.fetch,
+  });
+
+  console.log(`── ${scenario}（mode=${mode}）：${SCENARIOS[scenario].label}`);
+  if (r.blocked) {
+    console.log('   ⛔ 停手，一顆資源都沒建：');
+    for (const b of r.blockers) console.log(`      • ${b}`);
+    console.log('');
+    continue;
+  }
+  for (const key of Object.keys(r.bindings).sort()) {
+    console.log(`   ${key.padEnd(30)} → ${r.bindings[key].padEnd(26)} ${r.origin[key]}`);
+  }
+  console.log(
+    `   本趟新建：KV ${account.created.kv.length} 顆、D1 ${account.created.d1.length} 顆、` +
+      `Vectorize ${account.created.vectorize.length} 顆` +
+      `｜沿用既有版本標籤 ARCRUN_BUNDLE_VERSION=` +
+      `${r.liveVars['arcrun-cypher-executor']?.ARCRUN_BUNDLE_VERSION ?? '（無，全新安裝）'}\n`,
+  );
+}
@@ -0,0 +1,202 @@
+// @ts-check
+/**
+ * fixture-account.mjs — 一個假的 Cloudflare 帳號，做成 **`fetch` 替身**。
+ *
+ * 【為什麼是 fetch 替身，不是假的 ResourceApi 物件】
+ * 本票要證的是「`acr` 那條與安裝器那條，跑出來的決定必須一致」。
+ * 如果兩條路各自餵一個假的 `ResourceApi`，那就只測到了 `rule.mjs` 的判斷，
+ * **完全跳過了「怎麼把 CF 回應讀成事實」**——而 Arcrun#97 的重演只需要眼睛不一樣就夠了
+ * （一邊把 404 當錯誤、一邊漏認 `namespace_id`…）。
+ * 從 `fetch` 這一層假起，兩條路就是真的走完整條鏈：HTTP → 解析 → 判斷。
+ *
+ * 零依賴、純 ESM，Node 與 Workers 都能跑。
+ */
+
+/** arcrun 各 worker 在 wrangler.toml 裡宣告的 KV binding 名（= 需求，不是資源名）。 */
+export const KV_BINDINGS = [
+  'WEBHOOKS', 'CREDENTIALS_KV', 'RECIPES', 'USERS_KV', 'SESSIONS_KV',
+  'ANALYTICS_KV', 'EXEC_CONTEXT', 'SUBMISSIONS_KV', 'OAUTH_KV',
+];
+
+/** 這台實例上有資源綁定的四顆 worker，以及各自需要的綁定。 */
+export const WORKER_NEEDS = {
+  'arcrun-cypher-executor': {
+    kv: ['EXEC_CONTEXT', 'WEBHOOKS', 'CREDENTIALS_KV', 'ANALYTICS_KV', 'RECIPES', 'USERS_KV', 'SESSIONS_KV'],
+    d1: [{ binding: 'CREDENTIALS_DB', database_name: 'arcrun-kbdb' }],
+  },
+  'arcrun-registry': { kv: ['SUBMISSIONS_KV', 'ANALYTICS_KV'], d1: [] },
+  'arcrun-mcp': { kv: ['OAUTH_KV'], d1: [] },
+  'arcrun-kbdb': { kv: [], d1: [{ binding: 'DB', database_name: 'arcrun-kbdb' }] },
+};
+
+/**
+ * 把 WORKER_NEEDS 攤成 `BindingRequirement[]`——兩條路都用**同一份需求**進去，
+ * 才能證明差異（如果有）來自實作而不是輸入。
+ * @returns {Array<{kind: 'kv_namespace'|'d1', binding: string, worker: string, createName: string}>}
+ */
+export function requirements() {
+  const out = [];
+  for (const [worker, need] of Object.entries(WORKER_NEEDS)) {
+    for (const b of need.kv) out.push({ kind: 'kv_namespace', binding: b, worker, createName: b });
+    for (const d of need.d1) {
+      out.push({ kind: 'd1', binding: d.binding, worker, createName: d.database_name });
+    }
+  }
+  return out;
+}
+
+/**
+ * 三種情境。`titleFor` 決定「使用者帳號上那顆資源實際叫什麼名字」——
+ * 這正是 #97 的病根所在：規則**不准**拿名字當識別。
+ *
+ * @typedef {'fresh' | 'installed' | 'renamed'} Scenario
+ */
+
+/** @type {Record<Scenario, {label: string, deployed: boolean, titleFor: (binding: string) => string}>} */
+export const SCENARIOS = {
+  fresh: {
+    label: '沒裝過（全新帳號，一顆 worker 都沒有）',
+    deployed: false,
+    titleFor: (b) => b,
+  },
+  installed: {
+    label: '裝過了（安裝器命名慣例 arcrun-rag-<instance>-kv-<binding>）',
+    deployed: true,
+    titleFor: (b) => `arcrun-rag-yuga3bse-kv-${b.toLowerCase()}`,
+  },
+  renamed: {
+    label: '資源在，但名字與預期完全不同（使用者自己改過／別的安裝器版本取的名）',
+    deployed: true,
+    // 刻意取成跟 binding 名毫無關聯的字串：只要規則有一絲「照名字對號」就會在這裡露餡。
+    titleFor: (b) => `kv-${[...b].reduce((h, c) => (h * 31 + c.charCodeAt(0)) >>> 0, 7).toString(36)}`,
+  },
+};
+
+/**
+ * 建一個假帳號 + 對應的 `fetch` 替身。
+ *
+ * @param {Scenario} scenario
+ * @returns {{
+ *   fetch: typeof globalThis.fetch,
+ *   created: {kv: string[], d1: string[], vectorize: string[]},
+ *   userData: {workflows: string[], sessions: string[], libraries: string[]},
+ *   kvIdFor: (binding: string) => string | undefined,
+ *   d1Id: string,
+ *   requestLog: string[],
+ * }}
+ */
+export function makeAccount(scenario) {
+  const spec = SCENARIOS[scenario];
+  /** title → id */
+  const kv = new Map();
+  /** name → uuid */
+  const d1 = new Map();
+  /** @type {string[]} */
+  const vectorize = [];
+  /** script → CF `/settings` 回應裡的 bindings[] 原始形狀 */
+  const scripts = new Map();
+
+  const created = { kv: [], d1: [], vectorize: [] };
+  const requestLog = [];
+
+  // 使用者的東西——驗「更新完還在不在」用。掛在資源 id 上，不是掛在名字上。
+  const userData = {
+    workflows: ['webhook:leo:daily-digest', 'webhook:leo:inbox-sync', 'webhook:leo:rag-ingest'],
+    sessions: ['session:leo-abc123'],
+    libraries: ['general', '課程', '客戶', '研究'],
+  };
+
+  const kvIdByBinding = new Map();
+  const D1_ID = 'd1id-kbdb-REAL';
+
+  if (spec.deployed) {
+    // 帳號上已經有的資源（名字照該情境的慣例取，id 才是身分）
+    for (const b of KV_BINDINGS) {
+      const id = `kvid-${b.toLowerCase()}-REAL`;
+      kv.set(spec.titleFor(b), id);
+      kvIdByBinding.set(b, id);
+    }
+    d1.set('arcrun-rag-yuga3bse-kbdb', D1_ID);
+
+    // 已部署的 worker 上綁著它們——**這才是規則要看的事實**
+    for (const [script, need] of Object.entries(WORKER_NEEDS)) {
+      const bindings = [];
+      for (const b of need.kv) {
+        bindings.push({ type: 'kv_namespace', name: b, namespace_id: kvIdByBinding.get(b) });
+      }
+      for (const d of need.d1) bindings.push({ type: 'd1', name: d.binding, id: D1_ID });
+      // #106：plain_text var 也在同一份回應裡
+      bindings.push({ type: 'plain_text', name: 'ARCRUN_BUNDLE_VERSION', text: '1.4.33' });
+      scripts.set(script, bindings);
+    }
+  }
+
+  /** @param {unknown} result @param {number} [status] */
+  const ok = (result, status = 200) =>
+    new Response(JSON.stringify({ success: true, result, errors: [] }), {
+      status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  /** @param {string} message @param {number} status */
+  const fail = (message, status) =>
+    new Response(JSON.stringify({ success: false, result: null, errors: [{ message }] }), {
+      status,
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+  /** @type {typeof globalThis.fetch} */
+  // @ts-expect-error — 測試替身只實作用得到的那幾條路徑
+  const fakeFetch = async (input, init) => {
+    const url = new URL(typeof input === 'string' ? input : String(input));
+    const path = url.pathname.replace(/^\/client\/v4\/accounts\/[^/]+/, '');
+    const method = (init?.method ?? 'GET').toUpperCase();
+    requestLog.push(`${method} ${path}${url.search}`);
+    const body = init?.body ? JSON.parse(String(init.body)) : null;
+
+    // 已部署 worker 的綁定
+    const m = path.match(/^\/workers\/scripts\/([^/]+)\/settings$/);
+    if (m && method === 'GET') {
+      const script = decodeURIComponent(m[1]);
+      if (!scripts.has(script)) return fail('workers.api.error.script_not_found', 404);
+      return ok({ bindings: scripts.get(script) });
+    }
+
+    if (path === '/storage/kv/namespaces' && method === 'GET') {
+      return ok([...kv].map(([title, id]) => ({ id, title })));
+    }
+    if (path === '/storage/kv/namespaces' && method === 'POST') {
+      const id = `kvid-NEW-${created.kv.length + 1}`;
+      kv.set(body.title, id);
+      created.kv.push(body.title);
+      return ok({ id, title: body.title });
+    }
+    if (path === '/d1/database' && method === 'GET') {
+      return ok([...d1].map(([name, uuid]) => ({ uuid, name })));
+    }
+    if (path === '/d1/database' && method === 'POST') {
+      const uuid = `d1id-NEW-${created.d1.length + 1}`;
+      d1.set(body.name, uuid);
+      created.d1.push(body.name);
+      return ok({ uuid, name: body.name });
+    }
+    if (path === '/vectorize/v2/indexes' && method === 'GET') {
+      return ok(vectorize.map((name) => ({ name })));
+    }
+    if (path === '/vectorize/v2/indexes' && method === 'POST') {
+      vectorize.push(body.name);
+      created.vectorize.push(body.name);
+      return ok({ name: body.name });
+    }
+
+    return fail(`fixture 沒有實作這條路徑：${method} ${path}`, 501);
+  };
+
+  return {
+    fetch: fakeFetch,
+    created,
+    userData,
+    kvIdFor: (binding) => kvIdByBinding.get(binding),
+    d1Id: D1_ID,
+    requestLog,
+  };
+}
Author	SHA1	Message	Date
uncle6me-web	bb548b6fdf	refactor(shared): 「該用哪些資源」搬出 CLI——一份實作，acr 與安裝器吃同一條規則 leo 2026-08-12：「根本就不應該在 CLI，我要的是一個大家都可以用到的規則。」「這個實例該用哪些資源」換到安裝器就要重寫一次 ⇒ 依 rules/07-thin-shell.md 的判準它是能力，而它原本住在 cli/src/lib/resource-resolver.ts ⇒ 那本身就是違規。後果已經真的發生：acr 那條有 Arcrun#97 的修法、安裝器那條沒有，於是安裝器照名字找、找不到就建一顆空的綁上去 ⇒「我按了更新，工作流和登入全不見了」。規則搬到 shared/resource-rule/（零依賴 ESM，Node 與 Workers runtime 都直接跑）： · rule.mjs 規則本體＋把 CF 回應讀成事實的 normalizeLive* · cf-resource-api.mjs ResourceApi 的 CF REST 實作——眼睛也共用：兩條路各自解讀 CF 回應，只要一邊看不到既有綁定就會去新建， #97 不需要規則寫錯就能重演 · installer-entry.mjs 安裝器唯一該碰的入口 resolveInstanceResources() 不是做成 cypher 端點的理由（自舉）：這條規則要在「決定怎麼裝」的當下就用得到，而那時 cypher 可能還不存在（安裝器的工作正是把它生出來）；且輸入是使用者自己帳號的綁定狀態，不該送去平台換答案。它是純函式，用不著變成服務。只有一份，機械看守： · 安裝器直接 import repo archive 裡的原稿，不需要副本 · acr 因為 npm pack 打不進套件目錄外的檔案，帶一份逐位元組鏡射（scripts/sync-resource-rule.mjs 產生；build/test 先跑 --check，差一位元組就紅） ——同 cli/harness/ 產生物＋世代閘的既有慣例 · cli/tests/single-implementation.test.ts 掃全 repo：7 支規則函式的實作只有一處 CLI 淨 -496 行（邏輯是搬走，不是複製）。cf-api.ts 的 CfAccountClient 保留公開介面， ResourceApi 那七個方法全部委派共用 client。驗證：cli 58/58 綠（含新增的兩條路一致性 fixture ＋三種情境），tsc --noEmit 乾淨。	2026-08-12 23:37:01 +08:00
uncle6me-web	e05518a2b4	chore(builds): 重編成品——把 #107 的版本標籤修法放進執行檔出貨線第 1 站的 #93 新鮮度閘擋下：cypher-executor 成品記 10d150a，而 HEAD 已是 2129356（#107 改了 routes/health.ts 與 types.ts）。這是該閘今晚第三次擋對——沒有它，1.4.42 會送出一個「版本標籤修法只在源碼裡」的成品。 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-12 22:22:57 +08:00
Leo	21293568d5	Merge PR #107 : 更新完還看得到版本號——CLI 重部署不再把版本標籤洗掉（Arcrun#106）總管複驗（不聽自述，自己重跑並與 base 逐條比對）： cli main 是 0 pass / 3 fail（測試根本跑不起來）→ PR 49 pass / 0 fail ⇒ agent 那句「#97 的守衛測試一直沒在跑」是真的，又一個假綠 cypher 14 failed / 402 passed（base 14 / 400）；失敗清單 diff 無輸出＝零回歸設計比我建議的對：版本標籤每趟重烙、其他 vars 才沿用。我原本建議「一律沿用」會讓版本號永遠停在安裝當時。殘項（agent 誠實標的，不擋併）：沒在真實例上跑過、沒有真 Portal 截圖（它的環境指向 leo21c 紅線、無 youlin 憑證、瀏覽器未授權）。總管接手補這段。	2026-08-12 14:05:57 +00:00
uncle6me-web	53b05c6d3d	fix(cli): 更新完還看得到版本號——CLI 重部署不再把版本標籤（和你的設定）洗掉 leo 08-12 實撞：更新完 leo21c，Portal 設定頁的「版本」變成「無法讀取目前版本（知識庫服務可能正在啟動）」。版本號是 leo 唯一的驗收介面，看不到就等於他無法自己確認任何一次更新有沒有生效。根因（Arcrun#106）：`bundle_version` 來自部署時注入的 plain_text var `ARCRUN_BUNDLE_VERSION`，而只有安裝器會注入。wrangler deploy 是整份覆蓋， toml 沒寫的 var 直接消失 ⇒ CLI 更新那條路每跑一次就把標籤洗掉一次。 #97 修好了「櫃子」（KV/D1/Vectorize 沿用既有），沒修「櫃子上的標籤」。修法（兩種 var 走相反的規則，這是本次的判斷）： · 設定類 var ＝使用者實例的事實 → 沿用（讀綁定時同一份回應就帶回來，不多打 API） ——把 #97「已部署的 worker 上綁著什麼就是事實」原封不動套用到 plain_text var。 · 版本標籤＝這份成品的屬性 → 每趟重烙，絕不沿用舊值。沿用舊值會得到一個永遠停在安裝當天的假標籤——比沒有標籤更糟，因為它會讓人以為驗收過了。版號取部署當下發行頻道公告的 release（Portal/daemon 就是拿它當「最新版」比），另外把真正部署的 commit 一起烙上去（/health 多吐 `bundle_commit`）→ 漂掉查得出來。查不到 release 就誠實退成 `YYYY-MM-DD+<commit7>`，不掰一個 semver 假裝已是最新。順帶（都是同一條路上的東西）： · ref 先解析成 commit sha 再用 sha 下載 archive——不可變，順手解掉 branch tarball 被快取的老病 · Portal 版本行接受帶 build metadata 的 semver（`1.4.41+d61` 這種先前一律被當成「較舊版本」） · cli 測試在 node 22 上本來一支都跑不起來（.js→.ts 解析 + parameter property），補上 resolve hook ——#97 那份「使用者的東西還在不在」的迴歸守衛也在其中，跑不起來的守衛等於沒有守衛 · types.ts 的 ARCRUN_BUNDLE_VERSION 重複宣告（TS2300）併回一處驗證見 PR：cli 49/49 綠、cypher health 4/4 綠、Portal 版本行原始碼實跑五種情境、對真實已部署 worker 的唯讀 dry-run。未做：真實實例上的 acr update 端到端（本機唯一有憑證的帳號是 leo21c＝紅線禁碰，youlin 無憑證）。 Refs: Leo/Arcrun#106, #97, #95 Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-08-12 21:58:43 +08:00
uncle6me-web	f87d0e92f4	fix(migrations): 0005/0006 從來沒進過版控——被 `.sql` 規則吃掉，每個用戶都收到「部署物缺」 leo 更新 leo21c 時撞到（他問「部分失敗？」）： ✗ D1 migration: 部署物缺 kbdb/migrations/0005_credential_template.sql ✗ D1 migration: 部署物缺 kbdb/migrations/0006_drop_credentials_table.sql （四顆 worker cypher/registry/kbdb/mcp 全部 ✓，失敗的只有這兩個檔）根因不是誰忘了推：.gitignore:53 的 `.sql` 是為了擋 D1 匯出備份（整庫全量＝機敏），但它連 migration 一起吃掉。0001-0004 還在，只因為它們在該規則之前就 commit 了（gitignore 不影響已追蹤檔案）⇒ 0005/0006 從產生那天起就不在任何 clone 裡。 ⇒ 這不是 leo 一台的事：更新指令從 Gitea 抓 main，那兩個檔不在那裡 ⇒ 任何人裝／更新都會收到同一組失敗，包含全新安裝。修法照 rules/05-deploy-convention.md「WASM 來源」段已有的慣例（`.component-builds/*/component.wasm` 就是用否定規則放行的）： !kbdb/migrations/.sql 範圍實測（沒開太大）： kbdb/migrations/0005、0006 → 放行 backup-2026.sql / kbdb/backup-x.sql / dump.sql / cypher-executor/export.sql → 仍被擋進版控前確認過無機敏值：grep 命中的 token/secret/api_key 全是欄位名（api_key、secret_ref）與註解；無 >=20 位英數的疑似真值。殘項：leo21c 實查 templates 9 個、credential 不在其中 ⇒ 0005 從未套用，那台仍停在 D38 之前（credentials 走 0002 的獨立表）。要補套需另跑一次更新。 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-12 21:10:12 +08:00
uncle6me-web	ba152bc83a	chore(builds): 重編 tier2 成品——把 #105 放進執行檔（出貨路徑 A 的第 0 步） leo 選 A（把出貨線推到能出一版含 #105 的 bundle）。查證後發現最前面還有一層： cypher 源碼最後動 10d150a（#105）／成品最後動 a24f291（更早） mcp 源碼最後動 10d150a（#105）／成品最後動 8e10f1d（更早） ⇒ #105 改了 cypher 與 mcp 兩邊源碼，但沒有重編成品。這正是 Arcrun#93 那道「源碼比執行檔新就停下來」的閘要擋的狀態。用官方唯一編譯點 scripts/build-worker-artifacts.mjs（Arcrun#80 的機制，已存在）重編五顆，全部 5/5： arcrun-cypher-executor 571KB source=10d150ac arcrun-kbdb 146KB source=10d150ac arcrun-mcp 1152KB source=10d150ac arcrun-http-request 78KB source=1e85dfb4（未變） arcrun-code 150KB source=621cb8d9（未變）交叉驗證（不只信它自記的 commit）：/portal/data/ 這條 #105 才有的路徑在 arcrun-mcp 成品裡出現 8 次。下一步（等 leo 解閘）：把修好的引擎部署到 geek6688 當出貨機（ARCRUN_SHIP_BASE 可覆寫，預設是 leo21c——arcrun-rag#79 要搬離的正是這個），再從那台跑出貨線，第 17 站 purge 的 wait 節點才有帶修法的引擎可跑。 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-08-12 20:03:30 +08:00
Leo	89b80ff90e	Merge PR #105 : MCP 用登入者的身分查詢，不再去找服務內部金鑰總管複驗（不聽自述，自己重跑，並與 base `a24f291` 逐條比對）： mcp tsc 乾淨；vitest 113/113 綠 cypher 14 紅與 base 逐字元相同（diff 無輸出）；passed 386→400，新增 14 條全過 kbdb 5 紅與 base 相同安全邊界 11 條全綠（跨租戶 404／越庫 404／owner_id 由 server 定死）殘項（已記，不擋併）： · kbdb 的 owner_id 欄位改動沒有新測試守著（213 總數未變） · 工作流面仍靠 MCP_OWNER_NAMESPACE \|\| leo 那個巧合，本 PR 刻意沒動（拔了 arcrun_* 會全面失效） · 端到端 ❌ 未驗：要部署到 leo21c，那道閘要 leo 親手解	2026-08-12 11:42:03 +00:00