@takagaki/cortex-decisions-viewer 0.12.3 → 0.12.5

package/dist/render.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNSETTLED_LIMITS = exports.REFLECT_OPS = exports.REFLECTING_LIMITS = void 0;
+exports.UNSETTLED_LIMITS = exports.LIVE_CONFIRM_LIMITS = void 0;
 exports.renderSite = renderSite;
-exports.livePending = livePending;
-exports.nextCheckDelay = nextCheckDelay;
-exports.settledPending = settledPending;
 exports.sanitizeRegisteredNow = sanitizeRegisteredNow;
 exports.sanitizeStateNow = sanitizeStateNow;
 exports.overlayStateOnFleet = overlayStateOnFleet;
@@ -343,169 +340,49 @@ function backlogTargetOf(input) {
         return num.test(view[1]) ? null : { domain: domain, projectKey: view[1].toUpperCase() };
     return null;
 }
+// ---------------------------------------------------------------------------
+// 画面が「まだ答えが無い」あいだの見切り。
+//
+// **ここは純関数と定数だけを置く。** 画面側（クライアントJS）は toString() で実体を
+// 流し込んで使い、テストは同じ実体を直接呼ぶ。クロージャの中に書くと DOM 経由でしか
+// 触れず、判定を壊してもテストが気づけない。
+//
+// **クロージャを持たないこと**（外の変数を掴むと、流し込んだ先で undefined を参照して壊れる）。
+// 参照してよいのは、クライアント側にも同名で注入している定数だけ。
+//
+// **「⏳ 反映中」の機構（Reflecting 型・REFLECT_OPS・livePending / settledPending /
+// nextCheckDelay と localStorage の記録）は 2026-08-25 に退役した（#221）。**
+// あれは「保存したのに一覧が変わらない」空白を埋めるためのもので、**埋める空白そのものが
+// 無くなった**——画面は登録ファイルの現在値（registeredNow）を読み、足した行・消した行を
+// その場で見せる。取り直しの間隔も未確定件数ベース（UNSETTLED_TTL_MS）へ移してある。
+// 戻したくなったら、その削除コミットを revert すればよい。
+// ---------------------------------------------------------------------------
 /**
- * 反映待ちの期限。**15分。**
- *
- * 実測（cortex-context「セットアップ状況の自己チェック」の完了 run 112件、
- * うち workflow_dispatch 51件）:
- *
- *   |      | 全体(112) | dispatch のみ(51) |
- *   | min  | 4秒       | 6秒               |
- *   | p50  | 41秒      | 47秒              |
- *   | p90  | 57秒      | 62秒              |
- *   | p95  | 65秒      | ―                 |
- *   | max  | 400秒     | 400秒             |
+ * ライブ確認（op=state）の見切り（#256・設計v2 の1）。
  *
- * 必要な余裕は 最悪400秒 ＋ op=state のキャッシュ60秒 ＋ 取り直し間隔とのズレ60秒 = 520秒。
- * 10分では余裕が1分20秒しかなく、自己チェックが待ち行列（concurrency）に入れば超える。
+ * 通常応答は1〜2秒・Lambda のコールドスタートを含めても10秒で足りる。
+ * **10秒「確認中」が出続けるのは、嘘を断言するより許容できる。**
  *
- * 🔴 **期限が無いと、反映が来ない案件で「反映中」が永久に出て、本当の「未設定」を隠す。**
- * 完了 run の 8%（9/112）は failure で、失敗した run はコミットしない。つまり
- * 8%程度の確率で「15分間 反映中 → 未設定に戻る」が起きる（設計どおりの挙動）。
+ * 🔴 **これは「取り直しの予約」ではない。** 60秒の取り直し（UNSETTLED_POLL_MS）を
+ * 数えているテストは、この見切りを数から除くこと。
  */
-const REFLECT_TTL_MS = 15 * 60 * 1000;
-/** 自動で取り直す間隔。60秒（op=state のキャッシュと同じ粒度） */
-const REFLECT_POLL_MS = 60 * 1000;
+const LIVE_CONFIRM_TIMEOUT_MS = 10000;
 /**
- * 期限と間隔を**テストから固定するための入れ物**（infra の STATE_LIMITS と同じ形）。
+ * 見切りを**テストから固定するための入れ物**（infra の STATE_LIMITS と同じ作法）。
  *
  * ⚠ **定数そのものを export してはいけない。** `export const` は CommonJS へ落ちるときに
  * 参照が `exports.X` へ書き換えられ、**toString() で流し込んだ先には exports が無いので
  * クライアントJSが丸ごと落ちる**（実際に踏んだ）。流し込む関数から参照する値は、
  * export しないローカルの const に置くこと。
  */
-exports.REFLECTING_LIMITS = { ttlMs: REFLECT_TTL_MS, pollMs: REFLECT_POLL_MS };
-/**
- * 記録してよい操作の対応表。**既定は「記録しない」（null）。**
- *
- * 🔴 **settle できない操作を記録すると、期限まで「反映中」が出っぱなしになり、
- * 本当の状態を隠す。** 「現れた／消えた」で判定できるものだけを載せる。
- *
- * @see CONFIG_OPS（infra/lambda/intake/logic.mjs）— **突き合わせるテストがある**。
- *   op を足してここに書き忘れると、その操作だけ黙って反映中にならない／
- *   settle できないものを記録して出っぱなしになる、という気づきにくい壊れ方をする
- */
-exports.REFLECT_OPS = {
-    // ---- 記録する ----
-    // 接続先の追加・削除。一覧に「現れた／消えた」で反映を判定できる
-    "backlog-target-add": { cap: "課題管理", dir: "add", from: "url" },
-    // **削除はキーだけを送る**（サーバもキーだけで消す）ので、スペースは問わない
-    //
-    // ⚠ **最後の1件を外したときは、反映が届いても settle しない**（engine を読んで確認・2026-08-21）。
-    // engine の fleet-status は、正本（issues-config.json）が空になると
-    // 同期ミラー（issues/backlog-settings.json）の旧値へフォールバックし、
-    // backlogTarget に旧 domain / projectKey を載せ続ける（capabilities も on のまま）。
-    // ミラーは履歴保全のため**画面から外しても残す設計**なので、この値は消えない。
-    // つまり「消えた」を観測できるのは、ミラーが1つも無い案件（一度も同期していない）だけ。
-    // それ以外では**期限（15分）で落ちる**——嘘は残らないが、その間「反映中」と出る。
-    // 直すなら engine 側（backlogTarget.source === "secrets" かつ configPath === null を
-    // 「正本に接続先が無い」として画面に伝える）で、これは「未設定」の意味を変える
-    // 製品判断なので別issueにする。
-    "backlog-target-remove": { cap: "課題管理", dir: "remove", from: "backlogProjectKey" },
-    // ---- 記録しない ----
-    // **値の変更**。読み取りの ON/OFF は「現れた／消えた」では判定できない
-    "set-github-source-enabled": null,
-    // **表示名の取り直し**。sendConfig を通らない2本目の書き込み口でもある
-    "refresh-channel-name": null,
-    // 以下は add / remove の形だが、**その能力の「反映中」はまだ作っていない**。
-    // 追加フォームには既存の控え（.ds-pending-item「追加済み・反映中」）が出ており、
-    // 二重に出さないため、統合は別issueにする（設計 追補 中2）
-    "add-channel": null,
-    "remove-channel": null,
-    "add-github-source": null,
-    "remove-github-source": null,
-    "add-figma-file": null,
-    "remove-figma-file": null,
-    "add-drive-folder": null,
-    "remove-drive-folder": null,
-    // 1件だけ持てた頃の置き換え。いまの画面は出さない（backlog-target-add に統合済み）
-    "set-backlog-target": null,
-};
-/**
- * 期限内のものだけ返す。
- *
- * 🔴 **経過時間（now - at）で判定すること。** 取り直した回数で数えると、
- * スリープ復帰やバックグラウンドタブのスロットリングで期限が伸びる。
- *
- * 🔴 **経過時間は「上」だけでなく「下」も見る。** 上限（age < 期限）しか見ないと、
- * **at が未来の記録は永久に期限が切れない**——
- *   - at = now + 1時間 … 1時間15分ずっと「反映中」
- *   - at = Infinity     … 永久に「反映中」のまま60秒ごとに取り直し続ける
- * 実在する経路: **端末の時計が進んだ状態で記録し、NTP で戻る**／別バージョンが書いた値／
- * localStorage の手編集。「期限が必ず切れるから嘘は残らない」というこの設計の
- * 唯一の安全弁が、入口で成立しなくなる。
- */
-function livePending(list, now) {
-    const out = [];
-    for (const e of list || []) {
-        // NaN・欠けた at・未来の at・Infinity はここで落ちる
-        const age = e ? now - e.at : NaN;
-        if (!e || !Number.isFinite(age) || !(age >= 0 && age < REFLECT_TTL_MS))
-            continue;
-        out.push(e);
-    }
-    return out;
-}
-/**
- * 次に取り直すまでの ms。もう取り直す必要が無ければ null。
- *
- * 🔴 **最後の1回は期限ちょうどに来る**（min(60秒, 期限 − 経過)）。
- * 固定60秒で張ると、最後の確認が期限の60秒前になり、そこから期限までに反映が来ても
- * 誰も見ない。さらに**期限そのものに誰も描き直さない**ので、「取り直しは止まったのに
- * 反映中の文字が残る」時間ができる。
- */
-function nextCheckDelay(list, now) {
-    const live = livePending(list, now);
-    if (!live.length)
-        return null;
-    let deadline = Infinity;
-    for (const e of live)
-        deadline = Math.min(deadline, e.at + REFLECT_TTL_MS);
-    const left = deadline - now;
-    return left < REFLECT_POLL_MS ? left : REFLECT_POLL_MS;
-}
-/**
- * 反映が来たものを落とす。
- *
- * @param presentByCap 能力ごとの「**スナップショットが答えている集合**」。
- *   🔴 **「画面に出ているか」を渡してはいけない。** 追加・削除の応答には一覧が添えられ、
- *   その場で画面が差し替わるので、記録した瞬間に反映済みと判定されて消える
- *   （＝機能が丸ごと no-op になる）。渡すのは「未設定」を出すか決めているのと
- *   同じ関数の戻り値（画面側は backlogTargetsNow）。
- *   その能力を判定できないときは null を渡す——落とさず、期限に任せる。
- */
-function settledPending(list, presentByCap) {
-    const out = [];
-    for (const e of list || []) {
-        const present = presentByCap ? presentByCap[e.cap] : null;
-        if (!present) {
-            out.push(e);
-            continue;
-        }
-        let hit = false;
-        for (const p of present) {
-            if (!p || !p.projectKey)
-                continue;
-            if (String(p.projectKey).toUpperCase() !== String(e.projectKey).toUpperCase())
-                continue;
-            // 空の domain は「どのスペースでもよい」（削除はキーだけを送るため）
-            if (e.domain && String(p.domain || "").toLowerCase() !== String(e.domain).toLowerCase())
-                continue;
-            hit = true;
-        }
-        // 消す操作は「消えたら反映済み」。ここを add と同じにすると、削除した接続先が
-        // 消えたその瞬間から期限まで「反映中」と言い続ける
-        const reflected = e.dir === "remove" ? !hit : hit;
-        if (!reflected)
-            out.push(e);
-    }
-    return out;
-}
+exports.LIVE_CONFIRM_LIMITS = { timeoutMs: LIVE_CONFIRM_TIMEOUT_MS };
 // ---------------------------------------------------------------------------
 // 登録の即時値（registeredNow）— **まとめ表がまだ知らない行を足す**（段階1）
 //
 // 守るべき不変条件は3つ:
-//   1. **足すだけ・置き換えない**（origin / goldState / notify / gate はまとめ表にしか無い）
+//   1. **足すだけ・置き換えない**（実測（gate / gateAt / needed）はまとめ表と状態ストアに
+//      しか無く、既存の行の欄は書き換えない。チャットの登録メタ（origin / goldState /
+//      notify）は 2026-08-25 から**足す行にだけ**載る——#221）
 //   2. **既知の欄だけ・葉は文字列だけ**（ライブ専用のキーなので build.ts の網にかからない）
 //   3. **正規化しない**（engine が読むのは生値。揃えにいくと「画面には出るのに読まれない」行ができる）
 // ---------------------------------------------------------------------------
@@ -520,11 +397,16 @@ const REGISTERED_CAP_NAMES = {
 /**
  * 通してよい欄。**ここに無い欄は1つも通さない**（Lambda 側の列挙と同じ形）
  *
- * 🔴 **`orgUnknown` は真偽値**（他の欄は全部文字列）。**この1欄だけの例外**で、
+ * 🔴 **真偽値は `orgUnknown` と `notify` の2欄だけ**（他の欄は全部文字列）。
  * 篩の側にも `=== true` の分岐がある——`sanitizeRegisteredNow` を参照
+ *
+ * 🔴 **チャットの登録メタ（origin / goldState / notify）を通す（2026-08-25・#221）。**
+ * これが無いと、いま足した行の「登録を解除」「通知先」が出ない——夜間バッチが
+ * 追いつく翌朝まで、**追加した直後の主役の行だけ操作の無い行**になる。
+ * `orgUnknown` で同じ穴を1つ埋めた（0.12.1）のに、同族の3欄が残っていた。
  */
 const REGISTERED_FIELDS = {
-    chat: ["ref", "name", "workspace", "orgUnknown"],
+    chat: ["ref", "name", "workspace", "orgUnknown", "origin", "goldState", "notify"],
     dev: ["ref", "type"],
     design: ["key", "name"],
     materials: ["id", "name"],
@@ -564,13 +446,18 @@ function sanitizeRegisteredNow(v) {
             const item = {};
             for (const f of REGISTERED_FIELDS[cap]) {
                 const fv = r[f];
-                // 🔴 **真偽値を通すのは orgUnknown だけ**（2026-08-25）。葉を文字列に限った篩が
-                // この印を落としており、**追加した直後のチャンネルから「Slack ワークスペースに
-                // 接続する」の導線が消えていた**（顧客Slackを繋ぐ唯一の入口）。
+                // 🔴 **真偽値を通すのは orgUnknown と notify の2欄だけ**（2026-08-25）。葉を文字列に
+                // 限った篩がこの印を落としており、**追加した直後のチャンネルから「Slack ワークスペースに
+                // 接続する」の導線（orgUnknown）と「通知先」の札（notify）が消えていた**。
                 // **`=== true` に限る。** 文字列の "true" や 1 を真と読むと、意図しない値が
-                // 「組織不明」の案内を呼び、直すものが無い人に接続を勧めることになる。
-                // 例外はこの1欄だけ——他の欄まで真偽値を通すと、許可リストが篩の意味を失う
-                if (f === "orgUnknown") {
+                // 「組織不明」の案内を呼んで直すものが無い人に接続を勧め、通知していない
+                // チャンネルに「通知先」と書くことになる。
+                //
+                // **false はキーごと落とす。** 読み手は `=== true` で見る（`s.notify === true` /
+                // `r.orgUnknown === true`）ので、false を載せても意味は同じ——載せないほうが
+                // 「印が無い」と「印が false」の2通りを画面に持ち込まない。
+                // 例外はこの2欄だけ——他の欄まで真偽値を通すと、許可リストが篩の意味を失う
+                if (f === "orgUnknown" || f === "notify") {
                     if (fv === true)
                         item[f] = true;
                     continue;
@@ -685,9 +572,20 @@ function overlayStateOnFleet(view, rows, generatedAt) {
  * 一意でないので、IDだけで突き合わせると別ワークスペースの同IDを同じものと見て
  * 行が出ない（#104 で同じ理由の事故がある）。
  *
- * 🔴 **`orgUnknown` の印をここで落とさない（2026-08-25）。** 落とすと、この関数が作る行
- * （＝追加した直後の主役）が `groupSlackByOrg` で社内の組に落ち、
- * **「Slack ワークスペースに接続する」が画面から消える**——顧客Slackを繋ぐ唯一の入口。
+ * 🔴 **登録メタ（orgUnknown / origin / goldState / notify）をここで落とさない（2026-08-25）。**
+ * 篩を通しても**この関数がコピーしなければ行に乗らない**——0.12.1 で orgUnknown を
+ * 篩に通したときに、ここへのコピーを1行足して初めて画面が直った。落とすと:
+ *
+ *   - `orgUnknown` … 行が `groupSlackByOrg` で社内の組に落ち、
+ *     **「Slack ワークスペースに接続する」が画面から消える**（顧客Slackを繋ぐ唯一の入口）
+ *   - `origin`     … 「登録を解除」の出し分けが `s.origin !== "explicit"` なので、
+ *     欄が無い行にも出る。いまは derived しか来ないので結果は同じだが、
+ *     **判定の材料を欠いたまま偶然合っている**状態を残さない
+ *   - `goldState`  … `sourceNeedsAttention` と「読み取り停止中」の札が見る。slack は
+ *     常に `"on"` なので表示は変わらないが、まとめ表の行と**同じ形にしておく**
+ *     （片方に無い欄があると、差し替わった瞬間だけ判定が変わる経路ができる）
+ *   - `notify`     … **「通知先」の札が追加直後に出ない。** 通知が飛ぶチャンネルなのに
+ *     画面がそう言わないのは、行の意味を取り違えさせる
  */
 function chatRowsToAdd(externals, rows) {
     const have = {};
@@ -707,6 +605,13 @@ function chatRowsToAdd(externals, rows) {
             row.workspace = r.workspace;
         if (r.orgUnknown === true)
             row.orgUnknown = true;
+        if (r.origin)
+            row.origin = r.origin;
+        if (r.goldState)
+            row.goldState = r.goldState;
+        // **真偽値の印は true のときだけ載せる**（読み手は `s.notify === true`。篩の項を参照）
+        if (r.notify === true)
+            row.notify = true;
         out.push(row);
     }
     return out;
@@ -1048,22 +953,23 @@ function mergeRegisteredFleet(view, reg) {
 // 未確定の列がある間の取り直し（段階1の前提）
 //
 // 🔴 **これが無いと、登録したあと画面が二度と更新されない。** 60秒ごとの取り直しは
-// これまで「反映中」の記録がある間だけ張られていたが、registeredNow が入ると
-// 追加した瞬間に「もう出ている」と判定されて記録が消える。
+// 退役した「反映中」の記録がある間だけ張られていた（#221）。**取り直しの根拠を
+// 「まだ答えが無い行があること」に移したのがここ**——registeredNow が入ると、
+// 追加した瞬間に「もう出ている」と判定されて記録のほうは消えてしまう。
 //
-// **上限とタブ非表示の扱いは、反映待ち（livePending / nextCheckDelay）と同じ考え方にする。**
+// **上限とタブ非表示の扱いは、次の2つを守る。**
 //   - 上限は**経過時間**で見る（回数カウンタで数えない）。バックグラウンドタブの
 //     スロットリングやスリープ復帰は、経過時間で見る限り自己修復する
 //   - **可視性のイベントは足さない。** 遅れて起きたタイマがその回で期限切れを落とすので、
 //     非表示のあいだは自然に間隔が伸びるだけ。イベントを足すと、復帰の瞬間に
 //     全タブが同時に叩く形を新しく作ることになる
 // ---------------------------------------------------------------------------
-/** 未確定の行があっても、取り直しを続ける上限（開始からの経過）。反映待ちと同じ15分 */
+/** 未確定の行があっても、取り直しを続ける上限（開始からの経過）。15分 */
 const UNSETTLED_TTL_MS = 15 * 60 * 1000;
 /** 取り直しの間隔。60秒（op=state のキャッシュと同じ粒度） */
 const UNSETTLED_POLL_MS = 60 * 1000;
 /**
- * 期限と間隔を**テストから固定するための入れ物**（REFLECTING_LIMITS と同じ作法）。
+ * 期限と間隔を**テストから固定するための入れ物**（infra の STATE_LIMITS と同じ作法）。
  *
  * ⚠ **定数そのものを export してはいけない**（CommonJS へ落ちるときに `exports.X` へ
  * 書き換えられ、toString() で流し込んだ先には exports が無い）。
@@ -1075,8 +981,9 @@ exports.UNSETTLED_LIMITS = { ttlMs: UNSETTLED_TTL_MS, pollMs: UNSETTLED_POLL_MS
  * @param count  未確定の行数（0 なら張らない）
  * @param since  取り直しを始めた時刻（Date.now()）
  *
- * 🔴 **経過は「上」だけでなく「下」も見る**（livePending と同じ理由）。端末の時計が
- * 進んだ状態で始めて NTP で戻ると、`since` が未来になり**永久に期限が切れない**。
+ * 🔴 **経過は「上」だけでなく「下」も見る。** 端末の時計が進んだ状態で始めて
+ * NTP で戻ると、`since` が未来になり**永久に期限が切れない**——上限（`age < 期限`）
+ * しか見ないと、この画面は60秒ごとに永久に Lambda を叩き続ける。
  */
 function nextStateDelay(count, since, now) {
     if (!(count > 0))
@@ -2364,6 +2271,11 @@ a.ds-name:hover { text-decoration: underline; }
 /* 宣言はあるが実体が繋がっていない。未使用（グレー）とも接続済み（青）とも違うことを見せる */
 .cm-node.cm-idle rect { fill: var(--surface); stroke: #cbd5e1; stroke-dasharray: 4 3; }
 .cm-node.cm-idle .cm-sync { fill: #b45309; }
+/* ライブ確認の応答を待っている間（#256）。**状態を何も言っていない見た目にする。**
+   破線（未使用・未接続）にも青（接続OK）にもしない——どちらも状態の断言になる。
+   語彙は一覧側の「登録状況を確認中です」（ds-gate-muted）と同じ灰色に揃える */
+.cm-node.cm-pending rect { fill: var(--surface); stroke: var(--border); }
+.cm-node.cm-pending .cm-sync { fill: #6b7280; }
 .cm-label { font-size: 13.5px; font-weight: 600; fill: var(--text); }
 .cm-node.cm-warn .cm-label { fill: #92400e; }
 .cm-node.cm-off .cm-label { fill: #9ca3af; }
@@ -2391,6 +2303,9 @@ a.ds-name:hover { text-decoration: underline; }
 .cm-link.cm-warn { stroke: #d97706; }
 .cm-link.cm-off { stroke: #d1d5db; opacity: .6; }
 .cm-link.cm-idle { stroke: #cbd5e1; opacity: .7; }
+/* 確認中の線（#256）。**薄い中立**——流れ（animation）を付けない。
+   動いている線は「いまデータが通っている」と読めるので、確認中に出すと断言になる */
+.cm-link.cm-pending { stroke: #cbd5e1; opacity: .4; }
 /* 線は6本とも焼いて、出す/出さないをここで切り替える（0.12.0・renderConnectionMap の項）。
    SVG 要素に HTML の hidden 属性は効かないので、クラスで消す */
 .cm-link.is-hidden { display: none; }
@@ -2796,15 +2711,9 @@ ${backlogTargetOf.toString()}
 ${issuesRefOf.toString()}
 ${sourceNeedsAttention.toString()}
 ${capabilityState.toString()}
-  // 反映待ち（⏳ 反映中）の判定。**期限・間隔・対応表もビルド時の定義から流し込む**
-  //  ——画面側に書き写すと、片方だけ動かしたときに死角（取り直しは止まったのに
-  //  反映中が残る時間）ができ、しかも画面は正常に見えるので気づけない
-var REFLECT_TTL_MS = ${JSON.stringify(REFLECT_TTL_MS)};
-var REFLECT_POLL_MS = ${JSON.stringify(REFLECT_POLL_MS)};
-var REFLECT_OPS = ${JSON.stringify(exports.REFLECT_OPS)};
-${livePending.toString()}
-${nextCheckDelay.toString()}
-${settledPending.toString()}
+  // ライブ確認の見切り（#256）。**書き写さない**——テストが固定している値と
+  // 画面が使う値が割れると、「10秒で戻る」検査が通ったまま実機では戻らなくなる
+var LIVE_CONFIRM_TIMEOUT_MS = ${JSON.stringify(LIVE_CONFIRM_TIMEOUT_MS)};
   // 登録の即時値（registeredNow）の受け入れとマージ。**判定の実体はビルド時の定義**
   //  ——画面側に書き写すと、許可リストが2枚になって列挙し忘れが静かに消える
 var REGISTERED_CAP_NAMES = ${JSON.stringify(REGISTERED_CAP_NAMES)};
@@ -4562,79 +4471,6 @@ ${deriveCapTile.toString()}
     return d && d !== "on" ? d : null;
   }
 
-  // ---------- 反映待ち（「⏳ 反映中」）----------
-  //
-  // ## 何のためか
-  //
-  // 設定を保存してから画面に出るまで、自己チェック（fleet-status.json の作り直し）に
-  // 数分かかる。その間、画面は「未設定」「未接続」「未使用」と出す
-  // ——**保存はできているのに、事実に反する。** 利用者は「保存できていない」と読んで
-  // 同じ操作を繰り返し、「既に登録されています」と言われる（この repo が何度も踏んだ形）。
-  //
-  // **嘘をやめる。** 反映待ちのあいだは「未設定」と言わず「反映中」と言う。
-  //
-  // ## 出すのは状態だけ。行は先出ししない
-  //
-  // 行そのものを先に出すと、保存に失敗していても入っているように見えて気づけないし、
-  // 反映が来ないまま消えない行は削除もできない幽霊になる（撤去した pendingGold の
-  // 「（画面反映待ち）」バッジと同じ罠）。**必ず期限切れする**ので、反映が来なければ
-  // 元の「未設定」に戻る＝嘘が残らない。
-  //
-  // ## 期限は Date.now() - at で見る
-  //
-  // 🔴 **回数カウンタで数えない。** バックグラウンドタブのスロットリングやスリープ復帰は、
-  // 経過時間で見る限り自己修復する（遅れて起きたタイマがその回で期限切れを落とす）。
-
-  /** 取り直しのタイマ（setTimeout の連鎖。setInterval は使わない） */
-  var reflectTimer = null;
-
-  /**
-   * 保存先のキー。**案件ごとに分ける**（tutStoreKey と同じ作法）。
-   *
-   * intake が無い案件では案件キーが空文字になるが、それでも他案件のキーとは別物なので、
-   * 別の案件の反映待ちを読むことはない。
-   *
-   * **cortex.pendingGold: と紛らわしい名前にしない。** 前方一致で掃除するコードが
-   * 後から書かれると事故る（撤去済みの pendingGold と別語にしてある）。
-   */
-  function reflectStoreKey() {
-    return "cortex.reflecting:" + ((SITE.intake && SITE.intake.projectKey) || "");
-  }
-
-  /**
-   * localStorage は使えない環境がある（プライベートモード等）。**必ず try/catch で囲む**
-   *
-   * 🔴 **読み込み側でも「既定は記録しない」を効かせる。** 書き込み側（reflectEntryOf）が
-   * REFLECT_OPS に無い op を弾いても、localStorage の中身は**別バージョンの画面・
-   * 手編集・壊れた値**でいくらでも汚れる。settledPending は「判定できない能力は
-   * 落とさない（期限に任せる）」設計なので、**表に無い cap の記録は期限（15分）まで
-   * そのまま「反映中」として画面に出る**——本当の状態を隠す。
-   * op / cap / dir を対応表と突き合わせ、1つでも食い違えば落とす。
-   */
-  function readReflecting() {
-    try {
-      var raw = localStorage.getItem(reflectStoreKey());
-      var v = raw ? JSON.parse(raw) : null;
-      if (!Array.isArray(v)) return [];
-      return v.filter(function (e) {
-        if (!e || typeof e.at !== "number" || !Number.isFinite(e.at)) return false;
-        if (!e.cap || !e.projectKey) return false;
-        var d = REFLECT_OPS[String(e.op)];
-        // 対応表に無い op（記録してはいけないもの・未知のもの）は落とす
-        if (!d) return false;
-        // 表と食い違う cap / dir も落とす（表の cap 以外は settle できない）
-        return d.cap === e.cap && d.dir === e.dir;
-      });
-    } catch (e) { return []; }
-  }
-
-  function writeReflecting(list) {
-    try {
-      if (!list || !list.length) localStorage.removeItem(reflectStoreKey());
-      else localStorage.setItem(reflectStoreKey(), JSON.stringify(list));
-    } catch (e) {}
-  }
-
   /** その能力の情報源（fleet のスナップショット由来） */
   function internalSourceOf(cap) {
     var list = fleetVal("internalSources") || [];
@@ -4749,183 +4585,12 @@ ${deriveCapTile.toString()}
     if (KEY_SLOTS.figma) fn(KEY_SLOTS.figma);
   }
 
-  /**
-   * 能力ごとの「**スナップショットが答えている集合**」。
-   *
-   * 🔴 **「画面に出ているか」で判定してはいけない。** 追加・削除の応答には一覧が
-   * 添えられていて adoptTargets がその場で差し替えるので、**記録した瞬間に
-   * 「もう出ている」と判定されて消え、機能が丸ごと無意味になる**（査読者が実測）。
-   *
-   * 引くのは backlogTargetsNow ——「未設定」を出すか決めているのと**同一の関数**。
-   * 別々に書くと、片方が「未設定」と言い、もう片方が「反映済み」と言う状態を作れてしまう。
-   *
-   * 載っていない能力は判定できない（null）＝落とさず期限に任せる。
-   * ただし REFLECT_OPS がその能力の op を記録しないので、実際には溜まらない。
-   */
-  function reflectPresent() {
-    var out = {};
-    out["課題管理"] = backlogTargetsNow(internalSourceOf("課題管理"));
-    return out;
-  }
-
-  /** いま「反映中」と言うべきもの。**読むたびに期限切れ・反映済みを落として保存し直す** */
-  function reflectingNow() {
-    var before = readReflecting();
-    if (!before.length) return before;
-    var after = settledPending(livePending(before, Date.now()), reflectPresent());
-    if (after.length !== before.length) writeReflecting(after);
-    return after;
-  }
-
-  /** 送った操作から反映待ちの1件を組み立てる。**対応表に無い op は必ず null** */
-  function reflectEntryOf(op, payload, refreshUrl) {
-    var d = REFLECT_OPS[String(op)];
-    if (!d) return null;
-    var t = null;
-    if (d.from === "url") t = backlogTargetOf(payload.url);
-    else if (d.from === "backlogProjectKey") t = { domain: "", projectKey: String(payload.backlogProjectKey || "").toUpperCase() };
-    // 対象を特定できないものは記録しない（settle できず、期限まで出っぱなしになる）
-    if (!t || !t.projectKey) return null;
-    return {
-      cap: d.cap, op: String(op), dir: d.dir,
-      domain: t.domain || "", projectKey: t.projectKey,
-      at: Date.now(), url: refreshUrl || "",
-    };
-  }
-
-  /**
-   * 反映待ちとして記録し、その場で画面を「反映中」に差し替える。
-   *
-   * **同じ接続先の古い記録は捨てる**（追加のあと削除、のような入れ違いを残さない）。
-   */
-  function rememberReflecting(payload, refreshUrl) {
-    var e = reflectEntryOf(payload && payload.op, payload || {}, refreshUrl);
-    if (!e) return;
-    var list = readReflecting().filter(function (x) {
-      return !(x.cap === e.cap && x.projectKey === e.projectKey && x.domain === e.domain);
-    });
-    list.push(e);
-    writeReflecting(list);
-    // **開いているモーダルの中も含めてその場で差し替える。** 削除で最後の1件を外すと
-    // 応答で一覧が空になり「未設定」の1行が出る——記録しただけでは、その嘘が残る
-    repaintReflect(document);
-    scheduleReflectRefresh();
-  }
-
-  // 差し替える文言。**engine 側の文言は変えない**——engine の detail は
-  // 「そのスナップショット時点では未設定だった」という事実で、嘘ではない。
-  // 変えるのは画面の出し分けだけ。
-  var REFLECT_TEXT = {
-    empty: "⏳ 反映中 — いま変更した接続先を画面に反映しています（数分かかります）。",
-    note: "⏳ 反映中（いま変更した内容を画面に反映しています）",
-    sub: "⏳ 反映中",
-    // 見出し下の説明は出さない（下の「反映中」が説明している）
-    desc: "",
-  };
-
-  /**
-   * 反映が終わったときに、その箇所を**いまのスナップショットから引き直す**関数を
-   * 走らせている最中か。
-   *
-   * 引き直しは一覧の描き直し（paint）まで含み、その中でまた applyReflect が呼ばれる。
-   * 目印が無いと無限に呼び合うので、内側は下地（data-reflect-base）に落とす。
-   */
-  var reflectRestoring = false;
-
-  /**
-   * 「未設定」と言っている箇所に印を付ける。反映待ちのあいだだけ文言を差し替える。
-   *
-   * @param role empty=一覧の0件行 / note=能力カードの「未使用」 /
-   *   sub=タイルの2行目 / desc=モーダルの見出し下
-   * @param fresh 🔴 **反映が届いたときに、届いたデータからこの箇所を引き直す関数。**
-   *   引数はその節点。{ text, hidden } の形で返す（返さなければ下地へ落とす）。
-   *   **省くと「反映中 → 未設定」に戻る**——applyReflect のコメントを読むこと。
-   */
-  function reflectMark(node, cap, role, fresh) {
-    node.setAttribute("data-reflect-cap", cap);
-    node.setAttribute("data-reflect-role", role);
-    node.setAttribute("data-reflect-base", node.textContent || "");
-    if (fresh) node.__reflectFresh = fresh;
-    applyReflect(node, reflectingNow());
-    return node;
-  }
-
-  function applyReflect(node, live) {
-    var cap = node.getAttribute("data-reflect-cap");
-    var role = node.getAttribute("data-reflect-role");
-    var hit = null;
-    for (var i = 0; i < live.length; i++) if (live[i].cap === cap) { hit = live[i]; break; }
-    if (!hit) {
-      // ------------------------------------------------------------------
-      // 反映が来た（あるいは期限が切れた）。
-      //
-      // 🔴 **下地（data-reflect-base）へ戻してはいけない。** 下地は
-      // **モーダルを開いた時点＝古いスナップショットで作った文字列**で、その中身は
-      // 「未接続」「未設定」「未使用」——**この機能が直そうとしている誤読そのもの**。
-      // しかも settle が起きるのは「**新しいスナップショットが届いた**」瞬間なので、
-      // 戻した先は既に事実ではない。
-      //
-      // モーダルを開いたまま待つと refreshDataSources が下地を作り直さない
-      // （開いているモーダルの中身が切り離されるため、あのガードは外せない）ので、
-      // 「⏳ 反映中」→（数分）→「未設定」が**閉じるかリロードするまで残った**。
-      //
-      // **届いたデータで引き直す。** 引き直せない箇所だけ下地に落とす。
-      // ------------------------------------------------------------------
-      var f = null;
-      if (node.__reflectFresh && !reflectRestoring) {
-        reflectRestoring = true;
-        try { f = node.__reflectFresh(node); } catch (e) { f = null; }
-        reflectRestoring = false;
-      }
-      node.textContent = f && typeof f.text === "string" ? f.text : (node.getAttribute("data-reflect-base") || "");
-      node.hidden = !!(f && f.hidden);
-      return;
-    }
-    var t = REFLECT_TEXT[role] || "";
-    node.textContent = t;
-    // 「出さない」箇所は空にして hidden にする。**消さずに残す**のは、
-    // 反映が終わったときに元の文へ戻す先が要るため
-    node.hidden = t === "";
-    if (role === "empty" && hit.url) {
-      node.appendChild(document.createTextNode(" "));
-      node.appendChild(el("a", { href: hit.url, target: "_blank", rel: "noopener", text: "反映の状況 →" }));
-    }
-  }
-
-  /**
-   * 反映中の箇所だけを描き直す。
-   *
-   * 🔴 **これが「モーダルを開いたまま待つ」への答え。** 画面へ反映する唯一の手段だった
-   * refreshDataSources は、モーダルが開いている間は何もしない（下地を入れ替えると
-   * 開いているモーダルの中身が切り離されるので、**そのガードは外せない**）。
-   * ここは該当箇所だけを局所的に差し替えるので、開いたままでも追いつく。
-   */
-  function repaintReflect(root) {
-    if (!root || !root.querySelectorAll) return;
-    var live = reflectingNow();
-    var nodes = root.querySelectorAll("[data-reflect-role]");
-    for (var i = 0; i < nodes.length; i++) applyReflect(nodes[i], live);
-  }
-
-  /**
-   * 次の取り直しを予約する。
-   *
-   * 🔴 **反映待ちが1件も無ければタイマを張らない。** typeof fetch のガードでは足りない
-   * ——テストは load の**後**に fetch を注入するので、そこで張ってしまうと
-   * jsdom が閉じられず node --test が返らなくなる（この repo で実際に踏んだ形）。
-   */
-  function scheduleReflectRefresh() {
-    if (reflectTimer) return;
-    var delay = nextCheckDelay(reflectingNow(), Date.now());
-    if (delay == null) return;
-    reflectTimer = setTimeout(reflectTick, delay);
-  }
-
   // ---------- 未確定の行がある間の取り直し（段階1の前提）----------
   //
-  // 🔴 **「反映中」の記録がある間だけ取り直す**のをやめ、**まとめ表がまだ答えていない
-  // 行がある間**取り直す。registeredNow が入ると「反映中」は追加した瞬間に settle して
-  // 消えるので、これが無いと**登録した直後に画面が二度と更新されなくなる。**
+  // 🔴 **取り直しの根拠は「まとめ表がまだ答えていない行があること」。** 退役した
+  // 「反映中」の記録（#221）はこれを持てなかった——registeredNow が入ると、記録は
+  // 追加した瞬間に「もう出ている」と判定されて消えるので、**登録した直後に画面が
+  // 二度と更新されない**状態になっていた。
   //
   // 経路は増やさない（loadLiveFleet 1本）。取得の口が2つになると、上に出す
   // 「◯◯時点」がどちらの値を指すのか説明できなくなる。
@@ -4963,17 +4628,6 @@ ${deriveCapTile.toString()}
     loadLiveFleet();
   }
 
-  function reflectTick() {
-    reflectTimer = null;
-    var live = reflectingNow();
-    // **期限に達した回でも、一度だけ描き直してから止める。** これが無いと
-    // 「取り直しは止まったのに反映中の文字が残る」時間ができる
-    repaintReflect(document);
-    // **新しい取得経路を作らない。** 2箇所になると「いつ時点の値か」が説明できなくなる
-    if (live.length) loadLiveFleet();
-    scheduleReflectRefresh();
-  }
-
   /**
    * その能力にそのアダプタの操作を出してよいか（#125②）。
    *
@@ -5042,22 +4696,32 @@ ${deriveCapTile.toString()}
     // ようになったので、未接続の能力を押したときに中身が空になる場面が増えた。
     // 「設定できるものがありません」だけだと、繋げないのか繋ぐ必要が無いのかが分からない
     if (note) {
-      var noteEl = el("p", { class: "modal-desc", text: note });
-      // 反映が届いたら**届いたスナップショットから引き直す**（開いた時点の
-      // 「未接続（…）」へ戻さない）。作り方はタイル側の modalNote と同じ式。
+      // 🔴 **未接続の一文だけは、開いた時点の値で引き直す。** 渡された note は
+      // **タイルを作ったときの**スナップショット由来で、そのあとライブ確認や登録の
+      // 反映が届いている。とくに**登録した行がある能力に「接続先が設定されていません」**
+      // と出すのは、この画面が何度も直してきた嘘（タイル側は抑制をこちらへ委ねている
+      // ——renderAdapterTile の modalNote の項）。
+      //
+      // 抑制してよいのは unset 由来のときだけ。この経路は「OFFに設定されています」
+      // 「**設定に異常があります**」も同じ枠で運んでいるので、無条件に引き直すと
+      // 異常が画面から消える——直したい誤読より悪い。
+      //
       // ⚠ 引き直しでは能力の代表アダプタの状態を使う（openCapabilityModal は
       // どのアダプタのタイルから開かれたかを知らない。カタログは今日どの能力も1個）
-      if (noteIsUnset) reflectMark(noteEl, cap, "desc", function () {
+      var noteText = note;
+      if (noteIsUnset) {
         // 足した行があるなら、この一文（接続先が設定されていません）はもう事実ではない
-        if (capPending(cap)) return { text: "", hidden: true };
         var capsNow = capsView();
         var dNow = capabilityDisplayState(cap, capsNow);
         var infoNow = capsNow[cap];
-        var t = dNow && dNow !== "on" && infoNow && infoNow.detail
-          ? (CAP_STATE_TEXT[dNow] || "") + "（" + infoNow.detail + "）"
-          : "";
-        return { text: t, hidden: t === "" };
-      });
+        noteText = capPending(cap) || !(dNow && dNow !== "on" && infoNow && infoNow.detail)
+          ? ""
+          : (CAP_STATE_TEXT[dNow] || "") + "（" + infoNow.detail + "）";
+      }
+      var noteEl = el("p", { class: "modal-desc", text: noteText });
+      // **消さずに hidden で伏せる。** 節点を残しておかないと、この一文を探している
+      // 検査が「文言が変わった」と「箱ごと無くなった」を見分けられない
+      noteEl.hidden = noteText === "";
       m.modal.appendChild(noteEl);
     }
     if (!items.length) {
@@ -5277,25 +4941,8 @@ ${deriveCapTile.toString()}
         // いま登録した行が一覧に出ているのに「この案件では設定されていません」と並ぶ
         var inactive = s.enabled === false && !capPending(s.kind);
         if (inactive) {
-          // **反映待ちのあいだは「⏳ 反映中」に差し替える（消さない）。** 消すと
-          // .ds-inactive の灰色だけが残り、なぜ灰色なのかが読めなくなる
-          col.appendChild(reflectMark(
-            el("span", { class: "ds-inactive-note", text: "未使用（この案件では設定されていません）" }),
-            s.kind, "note",
-            // **反映が届いたら、届いたスナップショットで判定し直す。** 下地へ戻すと
-            // 「⏳ 反映中」→「未使用（この案件では設定されていません）」になり、
-            // データが正しくなった**あと**に嘘をつく。灰色の見た目もここで外す
-            //（節ごとの作り直しはモーダルを閉じるまで走らない）
-            function (n) {
-              var srcNow = internalSourceOf(s.kind);
-              var stillInactive = !!(srcNow && srcNow.enabled === false) && !capPending(s.kind);
-              if (!stillInactive) {
-                var card = n && n.closest ? n.closest(".ds-card") : null;
-                if (card) card.classList.remove("ds-inactive");
-              }
-              return { text: "未使用（この案件では設定されていません）", hidden: !stillInactive };
-            },
-          ));
+          // **灰色（.ds-inactive）だけにしない。** 注記が無いと、なぜ灰色なのかが読めない
+          col.appendChild(el("span", { class: "ds-inactive-note", text: "未使用（この案件では設定されていません）" }));
         }
         // id は接続マップのノードclickの飛び先（アンカー）
         // **id は付けない。** #101 以前はこのカードが接続マップの飛び先だったが、
@@ -5713,7 +5360,11 @@ ${deriveCapTile.toString()}
      *   ——ここで引き直すと、タイルの色（st）を決めた材料と2回引くことになり、
      *   片方だけずれる余地ができる。null なら規則5＝従来表示へフォールバック
      */
-    function tileSub(cap, st, derived, adapter, ins, srcs, derive) {
+    /**
+     * @param confirming 初回のライブ確認を待っている（#256）。**状態の断言だけを
+     *   「確認中」に差し替える**——件数・最終同期は焼いた事実なので下でそのまま積む
+     */
+    function tileSub(cap, st, derived, adapter, ins, srcs, derive, confirming) {
       var internal = ins.filter(function (s) { return s.kind === cap; })[0];
       var live = srcs.filter(function (s) { return externalCapability(s.type) === cap; });
       var parts = [];
@@ -5724,7 +5375,13 @@ ${deriveCapTile.toString()}
       //
       // 🔴 **ここが正本からの導出（下）より先。** 意図的に OFF にした能力に
       // 「登録済み（接続は未確認です）」と出さないため（deriveCapTile の項）
-      if (derived && derived !== "on") {
+      if (confirming) {
+        // 🔴 **確認中は状態を言わない（#256）。** 下の分岐はどれも焼いた値からの断言で、
+        // ライブが届くと訂正される＝瞬きの出どころ。**語は既存の中間状態と揃える**
+        //（DS_GATE_PENDING「登録状況を確認中です」）——新しい言い方を増やすと、
+        // 同じ画面で「確認中」を意味する語が2つ並ぶ
+        parts.push(DS_GATE_PENDING.text);
+      } else if (derived && derived !== "on") {
         parts.push((CAP_STATE_MARK[st] || "") + (CAP_STATE_TEXT[derived] || "状態が判定できません"));
       } else if (derive) {
         // 🔴 **正本（登録・実測）からの導出（0.12.0・#231 / #235 / #227）。**
@@ -5871,42 +5528,33 @@ ${deriveCapTile.toString()}
       // カタログ外の値はここへ来ない（capabilityAdapter が弾く）。旧データの "none" だけは
       // 素通しすると顧客の画面に「none」というタイル名が出るので、上で空にしてある
       var rawTool = adapter || "";
-      // **2行目は反映待ちのあいだ「⏳ 反映中」にする。** モーダルを開かなくても分かる
-      // ようにするのが目的だが、別のバッジを足すのではなく**この行を差し替える**
-      // ——抑制しないと、同じタイルの中で「⏳ 反映中」と「⦿ 未接続」が並んで矛盾する。
-      // **抑制するのは unset のときだけ**（off / broken は残す。R4 と同じ理由）
-      // まとめ表がまだ知らない行がある能力は、**行と同じ語**に倒す（未接続とも接続OKとも言わない）
+      // **2行目の状態は、まとめ表がまだ知らない行がある能力では断言しない**——
+      // **行と同じ語**に倒す（未接続とも接続OKとも言わない）。モーダルを開かなくても
+      // 分かるようにするのが目的で、別のバッジを足すのではなくこの行を差し替える
+      // ——並べると、同じタイルの中で2つの答えが矛盾する。
+      // **倒すのは unset のときだけ**（off / broken は残す。R4 と同じ理由）
       // 🔴 **導出が答えているなら、「登録状況を確認中です」より導出が勝つ（0.12.0）。**
       // あの語は「まとめ表しか材料が無く、登録の現在値が分からない」ときの折衷だった。
       // 正本（registeredNow）を読むようになった今は分かる——外した直後は「未接続」、
       // 足した直後は「登録済み（まだ取り込みがありません）」と、**何が起きたかを言える**。
       // ここを逆にすると、まとめ表が追いつく翌朝まで「確認中です」が居座る
       var pend = capPending(cap) && !derive;
+      // 🔴 **初回のライブ確認が答えるまで、状態を断言しない（#256・設計v2 の5）。**
+      // この2行目は焼いた capabilities 由来の状態を先に言っていたので、図と同じ瞬き
+      // （旧状態を見せて1〜2秒後に訂正）をタイルでも起こしていた。**兄弟機能の同型の
+      // 穴は同便で掃く**——図だけ直すと、同じ画面の下半分で同じ嘘が続く。
+      //
+      // **差し替えるのは状態の語だけ。** 件数・名前・最終同期は焼いた**事実**なので
+      // そのまま残す（ライブで訂正されるのは事実ではなく状態の解釈）。対象は導出が
+      // 答える能力だけ（derived が null / "on"）＝図と同じ規則5の線引き。
+      var confirming = liveConfirming() && (derived === null || derived === "on");
       var subEl = el("div", {
-        class: "ds-tile-sub " + (pend ? DS_GATE_PENDING.cls : "ds-gate-" + st),
-        text: pend ? DS_GATE_PENDING.text : tileSub(cap, st, derived, adapter, internals, sources, derive),
-      });
-      // **反映が届いたら、届いたスナップショットから引き直す。** 下地へ戻すと
-      // 「⏳ 反映中」→「⦿ 未接続」になる——データが正しくなったあとに嘘をつく。
-      // 状態の語も色（ds-gate-*）も、判定はタイルを作るときと同じ式で引く
-      if (derived === "unset") reflectMark(subEl, cap, "sub", function (n) {
-        var capsNow = capsView();
-        var insNow = fleetVal("internalSources") || [];
-        var srcsNow = fleetVal("externalSources") || [];
-        var dNow = adapter === capabilityAdapter(cap, capsNow) ? capabilityDisplayState(cap, capsNow) : "unset";
-        var stNow = dNow === "unset" && capabilityDisplayState(cap, capsNow) !== "unset"
-          ? "idle"
-          : capabilityState(cap, stateCtx());
-        // 正本からの導出も、タイルを作るときと同じ式で引き直す（0.12.0）。
-        // ここを省くと、反映が届いた瞬間だけ「● 接続OK」へ戻る
-        var deriveNow = dNow && dNow !== "on" ? null : capDerivation(cap);
-        if (deriveNow) stNow = deriveNow.state;
-        var pendNow = capPending(cap) && !deriveNow;
-        n.className = "ds-tile-sub " + (pendNow ? DS_GATE_PENDING.cls : "ds-gate-" + stNow);
-        return {
-          text: pendNow ? DS_GATE_PENDING.text : tileSub(cap, stNow, dNow, adapter, insNow, srcsNow, deriveNow),
-          hidden: false,
-        };
+        class: "ds-tile-sub " + (confirming || pend ? DS_GATE_PENDING.cls : "ds-gate-" + st),
+        // **反映待ち（pend）の形は変えない。** あちらは「足した行がまとめ表に載るまで」の
+        // 折衷で、件数を添えると足した分を数えたようにも読める。確認中は焼いた件数を残す
+        text: pend
+          ? DS_GATE_PENDING.text
+          : tileSub(cap, st, derived, adapter, internals, sources, derive, confirming),
       });
       var body = el("div", { class: "ds-tile-body" }, [
         el("div", { class: "ds-tile-name", text: (rawTool && (CM_TOOL_LABEL_C[rawTool] || rawTool)) || cap }),
@@ -5975,7 +5623,7 @@ ${deriveCapTile.toString()}
         el("span", { class: "ds-tile-chev", text: "›" }),
       ]);
       // ⚠ **ここで足した行（段階1）を見て抑制しない。** unset の一文は開くときに引き直される
-      // （openCapabilityModal の reflectMark の fresh 側が capPending を見る）ので二重になるうえ、
+      // （openCapabilityModal が capPending を見る）ので二重になるうえ、
       // ここで抑えると off / broken まで消える——R4 で「消さない」と決めたもの
       var modalNote = derived && derived !== "on" && capInfo && capInfo.detail
         ? CAP_STATE_TEXT[derived] + "（" + capInfo.detail + "）"
@@ -6748,29 +6396,12 @@ ${deriveCapTile.toString()}
     var listEl = el("div", { class: "ds-list" });
     // **0件の1行は一覧の外に置く**（Figma / Drive と同じ形）。中に .ds-card として
     // 置くと「行が1件ある」と読まれ、一覧を数えるテストにも行として数えられる
-    // **反映待ちのあいだは「未設定」と言わない。** 保存はできているので事実に反する
+    //
+    // **出し入れは paint() が持つ。** 開いたまま待っているあいだに新しい値が届いたときの
+    // 差し替えは box.__rebuild（取り直しの応答から呼ばれる）——0件の1行だけを
+    // 別経路で追いつかせると、行の一覧と食い違う瞬間ができる
     var EMPTY_TEXT = "同期する接続先はまだ登録されていません（未設定）。";
-    var emptyEl = reflectMark(
-      el("p", { class: "ds-empty", text: EMPTY_TEXT }),
-      "課題管理", "empty",
-      // 🔴 **反映が届いたら、届いた一覧で描き直す。** 下地（＝この0件の文言）へ戻すと、
-      // 反映が届いた瞬間に「⏳ 反映中」→「同期する接続先はまだ登録されていません（未設定）。」
-      // になり、**行があるのに無いと言う**。settle は「新しいスナップショットが届いた」
-      // ことなので、そのデータで一覧を作り直す（adoptTargets と同じ形）。
-      // モーダルを開いたまま待っているときは、これが唯一の描き直しの機会
-      function () {
-        // まだ箱を作っていない（＝最初の描画の途中）。paint() は箱へ出し入れするので、
-        // ここで走らせない。最初の描画はこの直後の paint() が受け持つ
-        if (!box) return null;
-        // 🔴 **応答の一覧を上書きしない。** 追加・削除の応答に添えられた一覧
-        //（adoptTargets）は、この画面が持っている中でいちばん新しい正本。
-        // スナップショットから引き直すと、外したばかりの接続先が戻って見える
-        if (adopted) return null;
-        targets = backlogTargetsNow(internalSourceOf("課題管理"));
-        paint();
-        return { text: EMPTY_TEXT, hidden: false };
-      },
-    );
+    var emptyEl = el("p", { class: "ds-empty", text: EMPTY_TEXT });
     // 追加・削除の結果はここに1つだけ出す（行を描き直しても消えない位置）
     var msg = el("div", { class: "ds-toggle-msg" });
 
@@ -6863,9 +6494,6 @@ ${deriveCapTile.toString()}
       var here = emptyEl.parentNode === box;
       if (!targets.length && !here) box.insertBefore(emptyEl, listEl.nextSibling);
       else if (targets.length && here) box.removeChild(emptyEl);
-      // **出し入れのたびに反映中を当て直す。** 外している間の描き直しはこの行に届かない
-      // ので、戻すときに当てないと古い文言のまま出る
-      applyReflect(emptyEl, reflectingNow());
       // 🔴 **鍵の欄の出し入れは、描き直しのたびに当て直す（2026-08-22）。** 最初の1件を
       // 足した瞬間に欄が現れ、最後の1件を外した瞬間に消えるのはここが効いているから。
       // 節ごとの差し替え（refreshDataSources）はモーダルが開いている間は何もしない
@@ -7696,28 +7324,14 @@ ${deriveCapTile.toString()}
         msg.appendChild(document.createTextNode(" "));
         msg.appendChild(el("a", { href: j.runsUrl, target: "_blank", rel: "noopener", text: "実行状況を見る →" }));
       }
-      // **画面への反映も起きていることを伝える。** 一覧はスナップショットから描かれるので、
-      // 「保存した」だけでは「一覧が変わらない＝失敗した」と読まれる。
-      // 数分かかること・再読み込みで正式な一覧に載ることまで書く（黙っていると待てない）
-      // 反映にかかる時間はサーバの文言（reflectionNote）が言うので、ここでは繰り返さない。
-      // 二重に書くと同じ一文に同じ話が並ぶ
-      if (j.refreshUrl) {
-        msg.appendChild(document.createTextNode(" "));
-        msg.appendChild(el("a", { href: j.refreshUrl, target: "_blank", rel: "noopener", text: "反映の状況 →" }));
-      }
+      // **「反映の状況 →」のリンクは無くなった（#221・2026-08-25）。** 指していたのは
+      // 「画面を追いつかせるための fleet-status の実行」で、その起動ごと撤去した
+      // ——保存の直後に読み直す（下の loadLiveFleet）ので、待つ対象がもう無い。
+      // 応答に refreshUrl が載ることも二度と無い（Lambda 側で撤去済み）。
+
       // 🔴 **語を戻すのは onDone より先。** removeButton の onDone は押せない状態へ
       // 戻す（外した行のボタン）ので、後に置くと「処理中…」の語が居座る
       endBusy();
-      // **反映待ちとして記録する。** 一覧はスナップショットから描かれるので、
-      // 保存できていても数分は「未設定」と出る。その間だけ「⏳ 反映中」に差し替える。
-      //
-      // ⚠ **onDone の中に置かない。** removeRow は onDone に null を渡しているので、
-      // 中に置くと**接続先の「削除」だけ黙って記録されない**（remove の判定が守りたい当のケース）。
-      //
-      // - changed === false（既に同じものが入っていた）は記録しない——待つものが無い
-      // - refreshUrl が無い（自己チェックを起こせなかった）ときも記録しない
-      //   ——待っても来ないので「反映中」が嘘になる
-      if (j.changed !== false && j.refreshUrl) rememberReflecting(payload, j.refreshUrl);
       // **保存が効いたら、いまの登録を読み直す（段階1）。** 一覧はまとめ表（夜間バッチ）から
       // 描かれるので、保存しただけでは行が出ない。ここで読み直すと、登録ファイルの中身が
       // 返ってきて**足りない行として一覧に出る**——さらに「まとめ表がまだ答えていない行」が
@@ -8398,7 +8012,7 @@ ${deriveCapTile.toString()}
    * 🔴 **チャンネルやフォルダを足すのは「モーダルを開いたまま」。** 節ごとの差し替え
    * （refreshDataSources）はモーダルが開いている間は何もしない——下地を入れ替えると
    * 開いているモーダルの中身が切り離され、入力中の値も「保存中…」も消えるので、
-   * **あのガードは外せない**。だから「反映中」と同じく、**その箇所だけを差し替える口**を置く。
+   * **あのガードは外せない**。だから**その箇所だけを差し替える口**を置く。
    *
    * 差し替えるのは**レコードの一覧だけ**（追加フォーム・鍵の欄・結果メッセージは触らない）。
    * 課題管理の adoptTargets が先にこの形を採っている。
@@ -8447,6 +8061,57 @@ ${deriveCapTile.toString()}
    * **操作タブに入り直したときだけ**もう一度取りに行く（ポーリングはしない）。
    */
   var liveFleetRequested = false;
+
+  /* ---------------------------------------------------------------------------
+   * 「確認中 → 確定」の2段表示（#256）
+   * ---------------------------------------------------------------------------
+   * 図とタイルの初期表示は**夜間ビルド時点の状態を断言**していた。ページを開くと
+   * ライブ確認（op=state）が走り、届いた瞬間に正本からの導出で当て直すので、
+   * 焼いた状態とライブが食い違う案件では**「先に旧状態を見せて、あとで訂正する」
+   * 瞬き**になる（リロード直後に線が一瞬つながって見え、1〜2秒後に消える）。
+   *
+   * **旧状態の先行断言をやめる。** 取得が始まる瞬間に「確認中」へ倒し、応答が届いて
+   * から確定する。図の形（ノード・線のジオメトリ）は焼いたものをそのまま使う
+   * ——捨てるとオフライン時のフォールバックと曲線の正本を失う。
+   * ------------------------------------------------------------------------- */
+
+  /**
+   * ライブ確認が実際に飛ぶ構成か。**loadLiveFleet の発火条件そのもの。**
+   *
+   * 🔴 **「確認中」を出すかどうかも、この1本で決める（設計v2 の2）。** 条件を書き写すと、
+   * intake が無い案件・fetch を持たない環境では**取得が始まらないのに確認中が出たまま
+   * 固まる**——直そうとした瞬きより悪い（永久に何も言わない画面になる）。
+   */
+  function liveConfirmPossible() {
+    return !!SITE.intake && typeof fetch === "function";
+  }
+  /**
+   * 最初のライブ確認が答えたか（成功・失敗・見切りのどれでも立つ）。
+   *
+   * **能力ごとに持たない。** 応答の到着は1回で、届いたあとに能力ごとの語を決めるのは
+   * 導出（capDerivation）の仕事。ここを能力ごとに割ると判定が2箇所になる。
+   */
+  var liveAnswered = false;
+  /**
+   * 図を「確認中」にしたか。**ページ生存中の最初の取得の1回だけ（設計v3）。**
+   *
+   * loadLiveFleet は初回以外にも何度も呼ばれる（能力モーダルを開くたびの noteOpenCap・
+   * 反映待ちの60秒ポーリング・保存直後の freshWanted 再取得）。呼び出しごとに確認中へ
+   * 戻すと、**確定済みのノードが無関係な操作のたびに確認中→再確定を繰り返す**
+   * ——直す前より体感が悪い再発になる。2回目以降は confirming 段を経ず、
+   * applyStateToConnMap の冪等な当て直しに直接委ねる。
+   */
+  var connMapConfirmingShown = false;
+  /** いま「確認中」を出す局面か（図の初回切り替えとタイルの両方が見る） */
+  function liveConfirming() {
+    return liveConfirmPossible() && !liveAnswered;
+  }
+  /**
+   * 図の3行目に出す確認中の語。一覧側は DS_GATE_PENDING（「登録状況を確認中です」）で、
+   * 図は幅が 148px しかないので短くする。**語彙は同じ「確認中」に揃える。**
+   */
+  var CONN_CONFIRMING_TEXT = "確認中…";
+
   /**
    * op=state に送る能力。**常に全能力**（0.12.0・#231 の正本化）。
    *
@@ -8529,17 +8194,33 @@ ${deriveCapTile.toString()}
     if (fresh) freshWanted = true;
     if (liveFleetRequested) return;
     var intake = SITE.intake;
-    if (!intake) return;
-    // **fetch の有無を確かめてから呼ぶ。** テスト環境（JSDOM）は window.fetch を持たない。
-    // 素で呼ぶと描画中の ReferenceError になり、「画面が例外を出さずに描き切る」検査を割る。
-    if (typeof fetch !== "function") return;
+    // **intake が無い／fetch が無い（JSDOM）なら取りに行かない。** 素で fetch を呼ぶと
+    // 描画中の ReferenceError になり、「画面が例外を出さずに描き切る」検査を割る。
+    // 判定は liveConfirmPossible に一本化してある——「確認中」を出す条件と同じでないと、
+    // 取得が始まらない案件に確認中が出たまま残る（#256）
+    if (!liveConfirmPossible()) return;
     liveFleetRequested = true;
     var useFresh = freshWanted;
     freshWanted = false;
+    // 🔴 **図を確認中に倒すのは、fetch を発火する直前の1回だけ（#256・設計v3）。**
+    // ここより後（応答の中）でやると意味が無く、ここより前（関数の入口）でやると
+    // 取りに行かない経路でも確認中になる
+    if (!connMapConfirmingShown) {
+      connMapConfirmingShown = true;
+      showConfirmingConnMap();
+    }
+    // **10秒で見切る（設計v2 の1）。** 応答が返らないまま待ち続けると、確認中が永久に
+    // 残る＝「何も言わない画面」になる。見切ったら失敗と同じ扱い（焼いた表示へ復元）。
+    // AbortController が無い環境では見切らない（素の fetch は中断できない）
+    var ctrl = typeof AbortController === "function" ? new AbortController() : null;
+    var giveUp = ctrl ? setTimeout(function () { ctrl.abort(); }, LIVE_CONFIRM_TIMEOUT_MS) : null;
+    /** 見切りのタイマを外す。**応答が来たら必ず呼ぶ**（残すと次の取得を巻き込んで中断する） */
+    var clearGiveUp = function () { if (giveUp != null) { clearTimeout(giveUp); giveUp = null; } };
     var pfx = intake.url + (intake.url.indexOf("?") === -1 ? "?" : "&");
     fetch(pfx + "op=state&t=" + encodeURIComponent(intake.token), {
       method: "POST",
       headers: { "content-type": "application/json" },
+      signal: ctrl ? ctrl.signal : undefined,
       // **常に全能力を要求する（ALL_STATE_CAPS の項）。** 知らない値は Lambda 側が黙って
       // 捨てる（断らない）ので、画面と Lambda の版が食い違っても接続状況の表示は消えない
       // **保存直後だけ据え置きを迂回させる。** これが無いと、サーバが保存前の答えを返し、
@@ -8548,8 +8229,15 @@ ${deriveCapTile.toString()}
     })
       // **非2xxも失敗として扱う。** ビューアとLambdaの版は独立に進むので、
       // op=state 未対応のLambdaは 400 を返す。通信エラーだけを見ていると空表示になる。
-      .then(function (res) { if (!res.ok) throw new Error("http " + res.status); return res.json(); })
+      .then(function (res) {
+        clearGiveUp();
+        if (!res.ok) throw new Error("http " + res.status);
+        return res.json();
+      })
       .then(function (j) {
+        // 🔴 **タイルの「確認中」を解くのは、下地を作り直す前（#256）。** 後に置くと、
+        // 応答が届いた回のタイルだけ確認中のまま残る（次の再描画まで訂正が出ない）
+        liveAnswered = true;
         // **fleet より先に読む。** fleet-status.json をまだ持たない案件（立ち上げ直後）は
         // 下で throw するが、リアルタイム同期の可否は索引由来なので独立に決まる
         LIVE_REALTIME = (j && j.realtime) || null;
@@ -8577,10 +8265,9 @@ ${deriveCapTile.toString()}
         // モーダルが開いている間・入力中は何もせずに戻るので、中に入れると
         // **モーダルを開いたまま最初の応答が届いた回だけ、図が「接続OK」のまま残る**
         applyStateToConnMap();
-        // **モーダルを開いたままでも「反映中」だけは追いつかせる。** refreshDataSources は
+        // **モーダルを開いたままでも一覧は追いつかせる。** refreshDataSources は
         // モーダルが開いている間・入力中は何もしない（下地を入れ替えると開いているモーダルの
-        // 中身が切り離される）ので、局所的に差し替える口をここに置く
-        repaintReflect(document);
+        // 中身が切り離される）ので、開いている一覧だけを差し替える口をここに置く
         repaintOpenLists();
         // まだ足りない行があるなら取り直しを続ける（無くなったら止める）
         refreshStateTimer();
@@ -8588,13 +8275,20 @@ ${deriveCapTile.toString()}
         if (freshWanted) loadLiveFleet();
       })
       .catch(function () {
+        clearGiveUp();
         // 静的ビルドの値で描き続ける。ただし「古いかもしれない」ことは画面に出す
         LIVE_FLEET = null;
         LIVE_FLEET_FAILED = true;
         liveFleetRequested = false;
+        liveAnswered = true;
         MERGED = null;
+        // 🔴 **確認中に倒した図を焼いた表示へ戻す（#256・設計v2 の3）。** ライブが
+        // 取れなかったときのフォールバックはここに残る——戻さないと「確認中…」の
+        // ままの図が残り、オフラインでは**何も分からない画面**になる。
+        // 「この図は◯◯時点です」の注記は既存のまま（ライブが取れていないときは
+        // 図も一覧も同じ焼いた時点なので、注記なしが正直・設計v2 の4）
+        restoreConfirmingConnMap();
         refreshDataSources();
-        repaintReflect(document);
         repaintOpenLists();
         // **失敗しても取り直しは続ける**（期限が来れば止まる）。ここで止めると、
         // 一時的な失敗のあと画面が二度と追いつかない
@@ -8611,9 +8305,6 @@ ${deriveCapTile.toString()}
     // **まとめ表がまだ答えていない行があれば取り直す。** 取得前は0件なので、
     // 実際に張られるのは応答が届いてから（loadLiveFleet が呼び直す）
     refreshStateTimer();
-    // **反映待ちがあれば自動で取り直す（再読み込みしても続く）。** 反映待ちが
-    // 1件も無ければタイマは張らない
-    scheduleReflectRefresh();
     // **取り込みカードと鍵カードは能力セクションへ移した**（#101）。
     // ここで再度出すと二重になる。手動投入は 会議 / 共有資料 の中にある。
   }
@@ -9141,6 +8832,10 @@ ${deriveCapTile.toString()}
    *
    * **導出が答えない能力（規則5・設定が on 以外）は触らない。** 焼いた図がそのまま
    * 残る＝従来表示へのフォールバック。タイル側と同じ規律。
+   *
+   * 🔴 **触らない能力は「焼いた表示に戻す」（#256・設計v2 の3）。** 確認中に倒した
+   * あとで素通りすると、規則5の「焼いた図のまま」が**「確認中のまま固まる」に化ける**
+   * ——応答は届いているのに、その能力だけ永久に何も言わない図になる。
    */
   function applyStateToConnMap() {
     var wrap = app.querySelector(".conn-map");
@@ -9148,9 +8843,9 @@ ${deriveCapTile.toString()}
     for (var cap in TILE_CAPS) {
       if (!Object.prototype.hasOwnProperty.call(TILE_CAPS, cap)) continue;
       // 設定そのものが OFF / 異常 / 未設置なら、その語（焼いた図）が正しい
-      if (capConfigState(cap)) continue;
+      if (capConfigState(cap)) { restoreBakedConnMap(cap); continue; }
       var d = capDerivation(cap);
-      if (!d) continue; // 規則5: 材料が無い → 焼いた図のまま
+      if (!d) { restoreBakedConnMap(cap); continue; } // 規則5: 材料が無い → 焼いた図のまま
       var node = wrap.querySelector('[data-target="ds-' + cap + '"]');
       if (!node) continue;
       node.setAttribute("class", "cm-node cm-" + d.state);
@@ -9169,7 +8864,102 @@ ${deriveCapTile.toString()}
         link.setAttribute("class", "cm-link cm-" + d.state
           + (d.state === "ok" || d.state === "warn" ? "" : " is-hidden"));
       }
+      // 確定したので退避は要らない（設計v3）。**残すと、あとの取得が失敗したときに
+      // 確定済みの表示へ焼いた値が上書きされる**——訂正した嘘が戻ってくる
+      forgetBakedConnMap(node, link);
+    }
+  }
+
+  /**
+   * 図の状態表現を「確認中」に倒す（#256）。**形は触らない。**
+   *
+   * 呼ぶのは loadLiveFleet が最初に fetch を発火する直前の1回だけ
+   *（connMapConfirmingShown の項）。**「確認中にしてから取得を始める」順序にする**
+   * ことで、取得が始まらない経路（intake の無い案件・fetch の無い環境）では
+   * 確認中が絶対に出ない構造にしている（設計v2 の2）。
+   *
+   * 🔴 **上書きする直前に、焼いた表示を DOM のデータ属性へ退避する（設計v2 の3）。**
+   * 退避を JS の変数に持つと、再描画・デバッグのときに DOM と食い違う。属性なら
+   * **DOM が正本**のまま——「いま確認中の能力はどれか」も属性の有無で読める。
+   *
+   * **対象は applyStateToConnMap が当て直す能力だけ**（capConfigState が答えない＝
+   * derived が null / "on"）。OFF・異常・未設置の語は設定そのものの話で、ライブが
+   * 届いても変わらない——確認中にしたら、応答が来ても戻す相手がいなくなる。
+   *
+   * ⚠ **⚠️バッジ（cm-badge）は触らない。** あれは applyStateToConnMap も当て直して
+   * いない（ビルド時に warn のノードにだけ焼かれ、以後そのまま）。確認中の間だけ
+   * 隠すと、応答で warn が確定したときに**失敗が図から消えたまま**になる
+   * ——「cm-warn を隠さない」の逆をこちらの都合で作る。バッジごと2段化するなら、
+   * 6ノードに常時バッジを焼いて表示を切り替える形（線と同じ）にする別便が要る。
+   */
+  function showConfirmingConnMap() {
+    var wrap = app.querySelector(".conn-map");
+    if (!wrap) return;
+    for (var cap in TILE_CAPS) {
+      if (!Object.prototype.hasOwnProperty.call(TILE_CAPS, cap)) continue;
+      if (capConfigState(cap)) continue;
+      var node = wrap.querySelector('[data-target="ds-' + cap + '"]');
+      if (!node) continue;
+      node.setAttribute("data-cm-baked-class", node.getAttribute("class") || "");
+      node.setAttribute("class", "cm-node cm-pending");
+      var sync = node.querySelector(".cm-sync");
+      if (sync) {
+        // **data-ts は残して textContent だけ差し替える（設計v2 の3）。** 外すと
+        // 復元したときに時刻の整形（renderConnMap の [data-ts]）が二度と効かない
+        sync.setAttribute("data-cm-baked-text", sync.textContent);
+        sync.textContent = CONN_CONFIRMING_TEXT;
+      }
+      var link = wrap.querySelector('.cm-link[data-cm-cap="' + cap + '"]');
+      if (link) {
+        // **薄い中立の線を出す（is-hidden を外す）。** 線が消えていると「未接続」を
+        // 断言したことになる。確認中は接続OK/未接続のどちらも言わない
+        link.setAttribute("data-cm-baked-class", link.getAttribute("class") || "");
+        link.setAttribute("class", "cm-link cm-pending");
+      }
+    }
+  }
+
+  /**
+   * 確認中に倒した能力を、焼いた表示へ戻す（#256・設計v2 の3）。
+   *
+   * 呼ぶのは2箇所——**ライブが取れなかったとき**（失敗・非2xx・見切り。全能力ぶん）と、
+   * **応答は届いたが導出が答えなかった能力**（applyStateToConnMap の continue）。
+   *
+   * 退避属性が無ければ何もしない。**「確認中でない能力を戻す」経路を作らない**
+   * ——確定済みのノードに焼いた値を書けば、それは訂正の取り消しになる。
+   */
+  function restoreBakedConnMap(cap) {
+    var wrap = app.querySelector(".conn-map");
+    if (!wrap) return;
+    var node = wrap.querySelector('[data-target="ds-' + cap + '"]');
+    if (!node || !node.hasAttribute("data-cm-baked-class")) return;
+    node.setAttribute("class", node.getAttribute("data-cm-baked-class"));
+    var sync = node.querySelector(".cm-sync");
+    if (sync && sync.hasAttribute("data-cm-baked-text")) {
+      sync.textContent = sync.getAttribute("data-cm-baked-text");
+    }
+    var link = wrap.querySelector('.cm-link[data-cm-cap="' + cap + '"]');
+    if (link && link.hasAttribute("data-cm-baked-class")) {
+      link.setAttribute("class", link.getAttribute("data-cm-baked-class"));
+    }
+    forgetBakedConnMap(node, link);
+  }
+
+  /** 確認中に倒した全能力を焼いた表示へ戻す（ライブが1件も取れなかったとき） */
+  function restoreConfirmingConnMap() {
+    for (var cap in TILE_CAPS) {
+      if (Object.prototype.hasOwnProperty.call(TILE_CAPS, cap)) restoreBakedConnMap(cap);
+    }
+  }
+
+  /** 退避を捨てる（確定した／戻し終えた）。属性の有無が「確認中か」の正本 */
+  function forgetBakedConnMap(node, link) {
+    if (node) {
+      node.removeAttribute("data-cm-baked-class");
+      var sync = node.querySelector(".cm-sync");
+      if (sync) sync.removeAttribute("data-cm-baked-text");
     }
+    if (link) link.removeAttribute("data-cm-baked-class");
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takagaki/cortex-decisions-viewer",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "description": "Cortexの意思決定記録（Decisions/*.md）を静的サイトにビルドして閲覧する。各レコードに「Edit on GitHub」リンクを付与する。",
   "license": "UNLICENSED",
   "private": false,