@takagaki/cortex-decisions-viewer 0.7.1 → 0.9.0

package/dist/render.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSETTLED_LIMITS = exports.REFLECT_OPS = exports.REFLECTING_LIMITS = void 0;
 exports.renderSite = renderSite;
+exports.livePending = livePending;
+exports.nextCheckDelay = nextCheckDelay;
+exports.settledPending = settledPending;
+exports.sanitizeRegisteredNow = sanitizeRegisteredNow;
+exports.chatRowsToAdd = chatRowsToAdd;
+exports.devRowsToAdd = devRowsToAdd;
+exports.designRowsToAdd = designRowsToAdd;
+exports.materialRowsToAdd = materialRowsToAdd;
+exports.issueRowsToAdd = issueRowsToAdd;
+exports.unsettledRegisteredCount = unsettledRegisteredCount;
+exports.registeredRowsToAdd = registeredRowsToAdd;
+exports.mergeRegisteredFleet = mergeRegisteredFleet;
+exports.nextStateDelay = nextStateDelay;
 exports.renderConnectionMap = renderConnectionMap;
 /** SiteDataを単一の自己完結HTML（埋め込みデータ+CSS+JS）にレンダリングする */
 function renderSite(site) {
@@ -179,6 +193,12 @@ const CM_TOOL_LABEL = {
 function sourceNeedsAttention(s) {
     if (s.gate === "ok")
         return false;
+    // 🔴 **測っていない行を警告に数えない（段階1）。** 状態が無いのは「実測して分からなかった」
+    // ではなく「まだ誰も測っていない」——いま登録したばかりの行がこれになる。数えると
+    // **登録した直後に「⚠️ 1件に問題」と出て、タイルが警告色になる**（登録は成功している）。
+    // `unknown` は残す——あちらは測ったうえで分からなかった、という別の事実。
+    if (s.gate == null || s.gate === "")
+        return false;
     if (s.goldState === "excluded")
         return false;
     return true;
@@ -310,6 +330,494 @@ function backlogTargetOf(input) {
         return num.test(view[1]) ? null : { domain: domain, projectKey: view[1].toUpperCase() };
     return null;
 }
+/**
+ * 反映待ちの期限。**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秒             |
+ *
+ * 必要な余裕は 最悪400秒 ＋ op=state のキャッシュ60秒 ＋ 取り直し間隔とのズレ60秒 = 520秒。
+ * 10分では余裕が1分20秒しかなく、自己チェックが待ち行列（concurrency）に入れば超える。
+ *
+ * 🔴 **期限が無いと、反映が来ない案件で「反映中」が永久に出て、本当の「未設定」を隠す。**
+ * 完了 run の 8%（9/112）は failure で、失敗した run はコミットしない。つまり
+ * 8%程度の確率で「15分間 反映中 → 未設定に戻る」が起きる（設計どおりの挙動）。
+ */
+const REFLECT_TTL_MS = 15 * 60 * 1000;
+/** 自動で取り直す間隔。60秒（op=state のキャッシュと同じ粒度） */
+const REFLECT_POLL_MS = 60 * 1000;
+/**
+ * 期限と間隔を**テストから固定するための入れ物**（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;
+}
+// ---------------------------------------------------------------------------
+// 登録の即時値（registeredNow）— **まとめ表がまだ知らない行を足す**（段階1）
+//
+// 守るべき不変条件は3つ:
+//   1. **足すだけ・置き換えない**（origin / goldState / notify / gate はまとめ表にしか無い）
+//   2. **既知の欄だけ・葉は文字列だけ**（ライブ専用のキーなので build.ts の網にかからない）
+//   3. **正規化しない**（engine が読むのは生値。揃えにいくと「画面には出るのに読まれない」行ができる）
+// ---------------------------------------------------------------------------
+/** 応答のキー（ASCII）→ 画面の能力名。**対応表はここ1つだけ** */
+const REGISTERED_CAP_NAMES = {
+    chat: "チャット",
+    dev: "開発",
+    design: "デザイン",
+    materials: "共有資料",
+    issues: "課題管理",
+};
+/** 通してよい欄。**ここに無い欄は1つも通さない**（Lambda 側の列挙と同じ形） */
+const REGISTERED_FIELDS = {
+    chat: ["ref", "name", "workspace"],
+    dev: ["ref", "type"],
+    design: ["key", "name"],
+    materials: ["id", "name"],
+    issues: ["domain", "projectKey"],
+};
+/** 欠けていたら行として読めない欄（「cm1.backlog.jp / 」のような半端な行を出さない） */
+const REGISTERED_REQUIRED = {
+    chat: ["ref"],
+    dev: ["ref"],
+    design: ["key"],
+    materials: ["id"],
+    issues: ["domain", "projectKey"],
+};
+/** 開発の種別に許す値。**知らない値は落とす**（画面のラベル・振り分けが決まらない） */
+const REGISTERED_DEV_TYPES = ["github-issues", "github-discussions"];
+/**
+ * 応答の registeredNow を、画面が扱ってよい形へ畳む。**通らなかったものは黙って落とす。**
+ *
+ * 返すのは能力ごとの配列だけ（`asOf` は落とす——「◯◯時点」の出し分けは段階3で1箇所にする）。
+ * 1能力も読めなければ null。
+ */
+function sanitizeRegisteredNow(v) {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return null;
+    const out = {};
+    let any = false;
+    for (const cap in REGISTERED_FIELDS) {
+        if (!Object.prototype.hasOwnProperty.call(REGISTERED_FIELDS, cap))
+            continue;
+        const rows = v[cap];
+        if (!Array.isArray(rows))
+            continue; // 配列でなければキーごと落とす（0件と混ぜない）
+        const keep = [];
+        for (const r of rows) {
+            if (r == null || typeof r !== "object" || Array.isArray(r))
+                continue;
+            const item = {};
+            for (const f of REGISTERED_FIELDS[cap]) {
+                const fv = r[f];
+                if (typeof fv !== "string" || fv === "")
+                    continue; // 葉は文字列だけ
+                item[f] = fv;
+            }
+            if (cap === "dev" && item.type && REGISTERED_DEV_TYPES.indexOf(item.type) < 0)
+                delete item.type;
+            let full = true;
+            for (const f of REGISTERED_REQUIRED[cap])
+                if (!item[f])
+                    full = false;
+            if (full)
+                keep.push(item);
+        }
+        out[cap] = keep;
+        any = true;
+    }
+    return any ? out : null;
+}
+/**
+ * チャットの行で、まとめ表がまだ知らないもの。
+ *
+ * 🔴 **鍵はチャンネルID＋ワークスペース。** チャンネルIDはワークスペースの中でしか
+ * 一意でないので、IDだけで突き合わせると別ワークスペースの同IDを同じものと見て
+ * 行が出ない（#104 で同じ理由の事故がある）。
+ */
+function chatRowsToAdd(externals, rows) {
+    const have = {};
+    for (const s of externals || []) {
+        if (!s || s.type !== "slack" || !s.ref)
+            continue;
+        have[String(s.workspace || "") + "\t" + String(s.ref)] = true;
+    }
+    const out = [];
+    for (const r of rows || []) {
+        if (!r || !r.ref)
+            continue;
+        if (have[String(r.workspace || "") + "\t" + String(r.ref)])
+            continue;
+        const row = { type: "slack", name: r.name || r.ref, ref: r.ref };
+        if (r.workspace)
+            row.workspace = r.workspace;
+        out.push(row);
+    }
+    return out;
+}
+/**
+ * 開発の行で、まとめ表がまだ知らないもの。**鍵は `owner/repo` の生文字列。**
+ *
+ * **種別（issues / discussions）は登録ファイルの宣言をそのまま使う。** 無いときだけ
+ * Issues に倒す——ここで決め打ちすると、Discussions だけを登録した案件のラベルが嘘になる。
+ */
+function devRowsToAdd(externals, rows) {
+    const have = {};
+    for (const s of externals || []) {
+        if (!s || String(s.type || "").indexOf("github") !== 0 || !s.ref)
+            continue;
+        have[String(s.ref)] = true;
+    }
+    const out = [];
+    for (const r of rows || []) {
+        if (!r || !r.ref)
+            continue;
+        if (have[String(r.ref)])
+            continue;
+        out.push({ type: r.type || "github-issues", name: r.ref, ref: r.ref });
+    }
+    return out;
+}
+/** デザインの行で、まとめ表がまだ知らないもの（鍵はファイルキー） */
+function designRowsToAdd(files, rows) {
+    const have = {};
+    for (const f of files || [])
+        if (f && f.key)
+            have[String(f.key)] = true;
+    const out = [];
+    for (const r of rows || []) {
+        if (!r || !r.key || have[String(r.key)])
+            continue;
+        // 名前は人が入力した別名。無ければキーを出す（既存の行と同じ扱い）
+        out.push({ key: r.key, name: r.name || r.key });
+    }
+    return out;
+}
+/** 共有資料の行で、まとめ表がまだ知らないもの（鍵はフォルダID） */
+function materialRowsToAdd(ids, rows) {
+    const have = {};
+    for (const id of ids || [])
+        if (typeof id === "string" && id)
+            have[id] = true;
+    const out = [];
+    for (const r of rows || []) {
+        if (!r || !r.id || have[String(r.id)])
+            continue;
+        const row = { id: r.id };
+        if (r.name)
+            row.name = r.name;
+        out.push(row);
+    }
+    return out;
+}
+/**
+ * 課題管理の行で、まとめ表がまだ知らないもの。
+ *
+ * **畳み方は `targetsGenerationOf`（サーバの `targetsGeneration`）と同じ**
+ * ——ドメインは小文字・キーは大文字。ここだけ別の畳み方にすると、同じ接続先が
+ * 二重に並ぶ（片方は削除ボタンを持たない）。
+ */
+function issueRowsToAdd(targets, rows) {
+    const key = (d, k) => String(d).toLowerCase() + "/" + String(k).toUpperCase();
+    const have = {};
+    for (const t of targets || [])
+        if (t && t.domain && t.projectKey)
+            have[key(t.domain, t.projectKey)] = true;
+    const out = [];
+    for (const r of rows || []) {
+        if (!r || !r.domain || !r.projectKey)
+            continue;
+        if (have[key(r.domain, r.projectKey)])
+            continue;
+        out.push({ domain: r.domain, projectKey: r.projectKey });
+    }
+    return out;
+}
+/** 同期ソース（internalSources）から、その能力の1件を取る */
+function internalOf(list, kind) {
+    for (const s of list || [])
+        if (s && s.kind === kind)
+            return s;
+    return null;
+}
+/**
+ * まとめ表に足りない行を数える。**「未確定の列がある間は取り直す」の判断材料。**
+ *
+ * 数えるのは「登録ファイルには有るのに、まとめ表がまだ答えていない行」だけ。
+ * まとめ表が既に持っている行は、状態（gate）が無くても数えない——**取り直しても
+ * 変わらない**（夜間の実測が入るまで誰も測らない）ので、数えると15分間ずっと
+ * GitHub を叩き続けることになる。
+ */
+function unsettledRegisteredCount(view, reg) {
+    if (!reg)
+        return 0;
+    const rows = registeredRowsToAdd(view, reg);
+    return rows.externalSources.length + rows.design.length + rows.materials.length + rows.issues.length;
+}
+/** 足すべき行を能力ごとに求める（マージと件数の唯一の出どころ） */
+function registeredRowsToAdd(view, reg) {
+    const v = view || {};
+    const r = reg || {};
+    const internals = v.internalSources || [];
+    const design = internalOf(internals, REGISTERED_CAP_NAMES.design);
+    const materials = internalOf(internals, REGISTERED_CAP_NAMES.materials);
+    const bt = v.backlogTarget;
+    const targets = bt && Array.isArray(bt.targets) ? bt.targets : bt ? [bt] : [];
+    return {
+        externalSources: chatRowsToAdd(v.externalSources, r.chat).concat(devRowsToAdd(v.externalSources, r.dev)),
+        design: designRowsToAdd(design && design.figmaFiles, r.design),
+        materials: materialRowsToAdd(materials && materials.driveFolderIds, r.materials),
+        issues: issueRowsToAdd(targets, r.issues),
+    };
+}
+/**
+ * まとめ表の3キー（externalSources / internalSources / backlogTarget）に、足りない行を足す。
+ *
+ * **足すだけ。** 既存の行・欄は1つも書き換えない。
+ *
+ * ⚠ 同期ソースの行がまだ無い能力（＝夜間バッチが一度も走っていない案件）には、
+ * **その能力の行を作る**——作らないと、登録した Figma ファイル・Drive フォルダを
+ * 置く場所が画面に無い。作る行は `kind` と一覧だけで、最終同期・件数・ラベルは装わない。
+ * 共有資料だけは `driveState` が無いと一覧そのものが描かれないので、
+ * **登録ファイルを実際に読めたという根拠がある場合に限り** `on` を置く
+ * （まとめ表が持っている値は上書きしない）。
+ */
+function mergeRegisteredFleet(view, reg) {
+    const v = view || {};
+    const out = {
+        externalSources: v.externalSources,
+        internalSources: v.internalSources,
+        backlogTarget: v.backlogTarget,
+    };
+    if (!reg)
+        return out;
+    const add = registeredRowsToAdd(v, reg);
+    if (add.externalSources.length)
+        out.externalSources = (v.externalSources || []).concat(add.externalSources);
+    if (add.design.length || add.materials.length) {
+        const internals = (v.internalSources || []).slice();
+        const put = (kind, patch) => {
+            for (let i = 0; i < internals.length; i++) {
+                if (internals[i] && internals[i].kind === kind) {
+                    internals[i] = Object.assign({}, internals[i], patch);
+                    return;
+                }
+            }
+            internals.push(Object.assign({ kind: kind }, patch));
+        };
+        if (add.design.length) {
+            const cur = internalOf(internals, REGISTERED_CAP_NAMES.design);
+            put(REGISTERED_CAP_NAMES.design, { figmaFiles: ((cur && cur.figmaFiles) || []).concat(add.design) });
+        }
+        if (add.materials.length) {
+            const cur = internalOf(internals, REGISTERED_CAP_NAMES.materials);
+            const ids = ((cur && cur.driveFolderIds) || []).concat(add.materials.map((x) => x.id));
+            const names = Object.assign({}, (cur && cur.driveFolderNames) || {});
+            for (const x of add.materials)
+                if (x.name)
+                    names[x.id] = x.name;
+            const patch = { driveFolderIds: ids, driveFolderNames: names };
+            // まとめ表が状態を持っていないときだけ置く（持っている値には触らない）
+            if (!cur || !cur.driveState)
+                patch.driveState = "on";
+            put(REGISTERED_CAP_NAMES.materials, patch);
+        }
+        out.internalSources = internals;
+    }
+    if (add.issues.length) {
+        const bt = v.backlogTarget;
+        const cur = bt && Array.isArray(bt.targets) ? bt.targets : bt && bt.domain && bt.projectKey ? [bt] : [];
+        const targets = cur.concat(add.issues);
+        // 単数の2つは**先頭の接続先と同じ値**（この配列を持たない読み手のために残っている欄）
+        out.backlogTarget = Object.assign({}, bt || {}, {
+            domain: targets[0].domain,
+            projectKey: targets[0].projectKey,
+            targets: targets,
+        });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// 未確定の列がある間の取り直し（段階1の前提）
+//
+// 🔴 **これが無いと、登録したあと画面が二度と更新されない。** 60秒ごとの取り直しは
+// これまで「反映中」の記録がある間だけ張られていたが、registeredNow が入ると
+// 追加した瞬間に「もう出ている」と判定されて記録が消える。
+//
+// **上限とタブ非表示の扱いは、反映待ち（livePending / nextCheckDelay）と同じ考え方にする。**
+//   - 上限は**経過時間**で見る（回数カウンタで数えない）。バックグラウンドタブの
+//     スロットリングやスリープ復帰は、経過時間で見る限り自己修復する
+//   - **可視性のイベントは足さない。** 遅れて起きたタイマがその回で期限切れを落とすので、
+//     非表示のあいだは自然に間隔が伸びるだけ。イベントを足すと、復帰の瞬間に
+//     全タブが同時に叩く形を新しく作ることになる
+// ---------------------------------------------------------------------------
+/** 未確定の行があっても、取り直しを続ける上限（開始からの経過）。反映待ちと同じ15分 */
+const UNSETTLED_TTL_MS = 15 * 60 * 1000;
+/** 取り直しの間隔。60秒（op=state のキャッシュと同じ粒度） */
+const UNSETTLED_POLL_MS = 60 * 1000;
+/**
+ * 期限と間隔を**テストから固定するための入れ物**（REFLECTING_LIMITS と同じ作法）。
+ *
+ * ⚠ **定数そのものを export してはいけない**（CommonJS へ落ちるときに `exports.X` へ
+ * 書き換えられ、toString() で流し込んだ先には exports が無い）。
+ */
+exports.UNSETTLED_LIMITS = { ttlMs: UNSETTLED_TTL_MS, pollMs: UNSETTLED_POLL_MS };
+/**
+ * 次に取り直すまでの ms。もう取り直す必要が無ければ null。
+ *
+ * @param count  未確定の行数（0 なら張らない）
+ * @param since  取り直しを始めた時刻（Date.now()）
+ *
+ * 🔴 **経過は「上」だけでなく「下」も見る**（livePending と同じ理由）。端末の時計が
+ * 進んだ状態で始めて NTP で戻ると、`since` が未来になり**永久に期限が切れない**。
+ */
+function nextStateDelay(count, since, now) {
+    if (!(count > 0))
+        return null;
+    const age = now - since;
+    if (!Number.isFinite(age) || age < 0)
+        return null;
+    const left = UNSETTLED_TTL_MS - age;
+    if (left <= 0)
+        return null;
+    return left < UNSETTLED_POLL_MS ? left : UNSETTLED_POLL_MS;
+}
 function capabilityState(cap, ctx) {
     // **能力→パイプラインの対応はここに持つ。** 呼び出し側に渡させると、
     // クライアント側（この関数を .toString() で受け取る側）が同じ表を書き写すことになり、
@@ -1589,6 +2097,34 @@ ${capabilityDisplayState.toString()}
 ${backlogTargetOf.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()}
+  // 登録の即時値（registeredNow）の受け入れとマージ。**判定の実体はビルド時の定義**
+  //  ——画面側に書き写すと、許可リストが2枚になって列挙し忘れが静かに消える
+var REGISTERED_CAP_NAMES = ${JSON.stringify(REGISTERED_CAP_NAMES)};
+var REGISTERED_FIELDS = ${JSON.stringify(REGISTERED_FIELDS)};
+var REGISTERED_REQUIRED = ${JSON.stringify(REGISTERED_REQUIRED)};
+var REGISTERED_DEV_TYPES = ${JSON.stringify(REGISTERED_DEV_TYPES)};
+var UNSETTLED_TTL_MS = ${JSON.stringify(UNSETTLED_TTL_MS)};
+var UNSETTLED_POLL_MS = ${JSON.stringify(UNSETTLED_POLL_MS)};
+${sanitizeRegisteredNow.toString()}
+${chatRowsToAdd.toString()}
+${devRowsToAdd.toString()}
+${designRowsToAdd.toString()}
+${materialRowsToAdd.toString()}
+${issueRowsToAdd.toString()}
+${internalOf.toString()}
+${registeredRowsToAdd.toString()}
+${unsettledRegisteredCount.toString()}
+${mergeRegisteredFleet.toString()}
+${nextStateDelay.toString()}
   // 「はじめに」セクションのチュートリアルデータ（ビルド時に埋め込み。ボタンURL・チャレンジ4の決定は解決済み）
   var TUTORIAL = (function () {
     var elx = document.getElementById("tutorial-data");
@@ -2145,6 +2681,19 @@ ${capabilityState.toString()}
     "no_token": { text: "トークン未設定", cls: "ds-gate-muted" },
     "unknown": { text: "不明", cls: "ds-gate-muted" },
   };
+  /* ---------------------------------------------------------------------------
+   * まだ誰も測っていない行（段階1）
+   *
+   * いま登録したばかりで、夜間の実測にも「接続を確認」にも掛かっていない状態。
+   * **「未接続」とも「不明」とも書かない**——前者は測って繋がっていなかった、
+   * 後者は測って分からなかった、という別の事実で、どちらも読み手に
+   * 「直す必要がある」と読ませる（登録そのものは成功している）。
+   *
+   * 🔴 **DS_GATE には入れない。** あちらは**実測が返す語彙**で、判定側（slack-gate.mjs）と
+   * 1対1で一致していることをテストが見張っている（足し忘れた判定が「不明」に落ちる事故の番人）。
+   * 未測定は実測の結果ではないので、同じ表に混ぜるとその番人が意味を失う。
+   * ------------------------------------------------------------------------- */
+  var DS_GATE_PENDING = { text: "登録状況を確認中です", cls: "ds-gate-muted" };
   /* ---------------------------------------------------------------------------
    * no_token には**経路が2つある**（2026-08-18 の不具合報告）
    *
@@ -2249,6 +2798,10 @@ ${capabilityState.toString()}
       // github-issues / github-discussions のどちらも同じ原因（組織単位の App）
       if (String(s.type || "").indexOf("github") === 0) return DS_GATE_NO_TOKEN.github;
     }
+    // 🔴 **状態が無い行を「不明」に落とさない（段階1）。** 「不明」は実測して分からなかった
+    // という意味で、まだ測っていない行に出すと嘘になる。**知らない値は従来どおり「不明」**
+    // ——そちらは engine が新しい状態を足したのに画面が知らない、という別の事実
+    if (s.gate == null || s.gate === "") return DS_GATE_PENDING;
     return DS_GATE[s.gate] || DS_GATE["unknown"];
   }
   /**
@@ -2960,10 +3513,23 @@ ${capabilityState.toString()}
    */
   var LIVE_REALTIME = null;
   /**
-   * 接続状況の値を引く。ライブがあればライブ、無ければ静的ビルドの値。
+   * いま登録ファイルに何が書いてあるか（op=state の registeredNow・段階1）。取得前は null。
+   *
+   * **まとめ表（fleet）とは別に持つ。** fleet は夜間バッチの成果物の射影で、こちらは
+   * いまのリポジトリを読んだ結果。同じ入れ物に混ぜると、上に出す「◯◯時点」がどちらを
+   * 指すのか説明できなくなる（realtime を別に持っているのと同じ理由）。
+   */
+  var LIVE_REGISTERED = null;
+  /** マージ済みの3キー（作り直しは setLive* だけが行う） */
+  var MERGED = null;
+  /** マージの対象になるキー。これ以外は素の値をそのまま返す */
+  var MERGE_KEYS = { externalSources: 1, internalSources: 1, backlogTarget: 1 };
+
+  /**
+   * 接続状況の素の値（まとめ表だけ）。ライブがあればライブ、無ければ静的ビルドの値。
    * SITE 側はキー名が fleetGeneratedAt だけ異なる（他は fleet-status.json と同名）。
    */
-  function fleetVal(key) {
+  function rawFleetVal(key) {
     // **ライブが取れたら、そちらだけを見る（キー単位で静的へ落ちない）。**
     // キーごとにフォールバックすると、たとえば externalSources はライブ・secretSources は
     // 前日のビルド、という**2つの時点が混ざった画面**になる。上に出す「◯◯時点」は1つしか
@@ -2974,6 +3540,378 @@ ${capabilityState.toString()}
     return SITE[key === "generatedAt" ? "fleetGeneratedAt" : key];
   }
 
+  /**
+   * 画面が読む値。**まとめ表がまだ知らない行を足したもの**を返す（段階1）。
+   *
+   * 🔴 **ここ1箇所で足す。** 一覧・能力タイル・接続マップの注記は全部この関数を通るので、
+   * 足す場所を描画側に散らすと「タイルは1件・一覧は2件」のような食い違いが必ず出る。
+   */
+  function fleetVal(key) {
+    if (LIVE_REGISTERED && MERGE_KEYS[key]) {
+      if (!MERGED) MERGED = mergeRegisteredFleet(rawView(), LIVE_REGISTERED);
+      return MERGED[key];
+    }
+    return rawFleetVal(key);
+  }
+
+  /** まとめ表がまだ答えていない行の数（取り直しを続けるかの判断） */
+  function unsettledNow() {
+    return unsettledRegisteredCount(rawView(), LIVE_REGISTERED);
+  }
+
+  /** まとめ表（夜間の成果物）だけの3キー。**状態の判定には必ずこちらを渡す** */
+  function rawView() {
+    return {
+      externalSources: rawFleetVal("externalSources"),
+      internalSources: rawFleetVal("internalSources"),
+      backlogTarget: rawFleetVal("backlogTarget"),
+    };
+  }
+
+  /**
+   * まとめ表がまだ知らない行を持っている能力（段階1）。
+   *
+   * 🔴 **その能力の状態を「接続OK」「未接続」「未使用」のどれとも言わないため。**
+   * 足した行を状態の判定に混ぜると「1行あるのだから繋がっている」と読んで**接続OK**に落ち、
+   * 同じ画面で**タイルは接続OK・行は「登録状況を確認中です」**が並ぶ。かといって夜間の値を
+   * そのまま出すと、**行はもう出ているのに「接続先が設定されていません」**と言う。
+   * どちらも嘘なので、**行と同じ語**（登録状況を確認中です）に倒す。
+   */
+  function pendingCaps() {
+    if (!LIVE_REGISTERED) return {};
+    var add = registeredRowsToAdd(rawView(), LIVE_REGISTERED);
+    var out = {};
+    for (var i = 0; i < add.externalSources.length; i++) out[externalCapability(add.externalSources[i].type)] = 1;
+    if (add.design.length) out[REGISTERED_CAP_NAMES.design] = 1;
+    if (add.materials.length) out[REGISTERED_CAP_NAMES.materials] = 1;
+    if (add.issues.length) out[REGISTERED_CAP_NAMES.issues] = 1;
+    return out;
+  }
+  /** その能力に、まとめ表がまだ知らない行があるか */
+  function capPending(cap) { return !!pendingCaps()[cap]; }
+
+  /**
+   * 能力の状態を決めるときに渡す値。**足した行は混ぜない**（誰も測っていないので状態を持たない）。
+   *
+   * ⚠ **これ単体を壊してもテストは赤くならない。** 画面に出る語は capPending が先に
+   * 「登録状況を確認中です」へ倒すので、条件（足した行がある）が同じこの2つは常に一緒に効く。
+   * それでも素の値を渡すのは、**判定関数に嘘の材料を渡さない**ためで、表示側の都合が
+   * 変わったとき（例えば pending の語をやめたとき）に「接続OK」が復活しないようにする。
+   */
+  function stateCtx() {
+    return {
+      capabilities: rawFleetVal("capabilities") || {},
+      internals: rawFleetVal("internalSources") || [],
+      externals: rawFleetVal("externalSources") || [],
+      pipes: rawFleetVal("pipelines") || [],
+    };
+  }
+
+  // ---------- 反映待ち（「⏳ 反映中」）----------
+  //
+  // ## 何のためか
+  //
+  // 設定を保存してから画面に出るまで、自己チェック（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") || [];
+    for (var i = 0; i < list.length; i++) if (list[i] && list[i].kind === cap) return list[i];
+    return null;
+  }
+
+  /**
+   * 能力ごとの「**スナップショットが答えている集合**」。
+   *
+   * 🔴 **「画面に出ているか」で判定してはいけない。** 追加・削除の応答には一覧が
+   * 添えられていて 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 して
+  // 消えるので、これが無いと**登録した直後に画面が二度と更新されなくなる。**
+  //
+  // 経路は増やさない（loadLiveFleet 1本）。取得の口が2つになると、上に出す
+  // 「◯◯時点」がどちらの値を指すのか説明できなくなる。
+
+  /** 取り直しのタイマ（setTimeout の連鎖。setInterval は使わない） */
+  var stateTimer = null;
+  /** 取り直しを始めた時刻。**上限は経過時間で見る**（回数で数えない） */
+  var stateSince = null;
+
+  /**
+   * 取り直しの予約を、いまの状況に合わせ直す。
+   *
+   * 🔴 **未確定の行が無ければタイマを張らない。** テストは load の後に fetch を注入するので、
+   * 無条件に張ると jsdom が閉じられず node --test が返らなくなる（反映待ちで実際に踏んだ形）。
+   */
+  function refreshStateTimer() {
+    var n = unsettledNow();
+    if (!n) {
+      if (stateTimer) { clearTimeout(stateTimer); stateTimer = null; }
+      stateSince = null;
+      return;
+    }
+    if (stateTimer) return;
+    if (!SITE.intake || typeof fetch !== "function") return;
+    if (stateSince == null) stateSince = Date.now();
+    var delay = nextStateDelay(n, stateSince, Date.now());
+    if (delay == null) return;
+    stateTimer = setTimeout(stateTick, delay);
+  }
+
+  function stateTick() {
+    stateTimer = null;
+    // 応答が届いた時点で refreshStateTimer が呼ばれ、まだ足りなければ次を張る。
+    // **期限に達していれば張られない**（無限に叩き続けない）
+    loadLiveFleet();
+  }
+
+  function reflectTick() {
+    reflectTimer = null;
+    var live = reflectingNow();
+    // **期限に達した回でも、一度だけ描き直してから止める。** これが無いと
+    // 「取り直しは止まったのに反映中の文字が残る」時間ができる
+    repaintReflect(document);
+    // **新しい取得経路を作らない。** 2箇所になると「いつ時点の値か」が説明できなくなる
+    if (live.length) loadLiveFleet();
+    scheduleReflectRefresh();
+  }
+
   /**
    * その能力にそのアダプタの操作を出してよいか（#125②）。
    *
@@ -3019,7 +3957,17 @@ ${capabilityState.toString()}
     return (tool && CM_TOOL_LABEL_C[tool]) || cap;
   }
 
-  function openCapabilityModal(cap, items, note) {
+  /**
+   * @param noteIsUnset その説明が「未接続（unset）」由来か。
+   *   🔴 **反映待ちで抑制してよいのはこれだけ。** この経路は「未接続」「OFFに設定されて
+   *   います」「**設定に異常があります**」を同じ枠で運んでいる。無条件に抑制すると、
+   *   保存直後の15分間、異常が画面から消える——直したい誤読より悪い
+   */
+  function openCapabilityModal(cap, items, note, noteIsUnset) {
+    // **開いた能力を覚えて、その登録ファイルを読みに行く（段階1）。** 全能力を毎回
+    // 読ませない代わりに、見ている能力だけを取りに行く
+    noteOpenCap(cap);
+    // 見出しは押したタイルのツール名（Backlog・Google ドライブ…）。capToolLabel の説明を参照
     var m = makeModal(capToolLabel(cap), true);
     // **何が読み取られるのかを必ず書く。** 一覧に並ぶものと読み取られるものの関係は、
     // 書いていないと分からない（チャットは「載っていれば全部」、開発はリポジトリ単位でOFFできる）
@@ -3031,7 +3979,25 @@ ${capabilityState.toString()}
     // **なぜこの状態なのかを、押した先でも読めるようにする（#125②）。** タイルは常時出す
     // ようになったので、未接続の能力を押したときに中身が空になる場面が増えた。
     // 「設定できるものがありません」だけだと、繋げないのか繋ぐ必要が無いのかが分からない
-    if (note) m.modal.appendChild(el("p", { class: "modal-desc", text: note }));
+    if (note) {
+      var noteEl = el("p", { class: "modal-desc", text: note });
+      // 反映が届いたら**届いたスナップショットから引き直す**（開いた時点の
+      // 「未接続（…）」へ戻さない）。作り方はタイル側の modalNote と同じ式。
+      // ⚠ 引き直しでは能力の代表アダプタの状態を使う（openCapabilityModal は
+      // どのアダプタのタイルから開かれたかを知らない。カタログは今日どの能力も1個）
+      if (noteIsUnset) reflectMark(noteEl, cap, "desc", function () {
+        // 足した行があるなら、この一文（接続先が設定されていません）はもう事実ではない
+        if (capPending(cap)) return { text: "", hidden: true };
+        var capsNow = fleetVal("capabilities") || {};
+        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 === "" };
+      });
+      m.modal.appendChild(noteEl);
+    }
     if (!items.length) {
       m.modal.appendChild(el("p", { class: "ds-empty", text: "この能力にはまだ設定できるものがありません。" }));
     }
@@ -3110,11 +4076,18 @@ ${capabilityState.toString()}
     //
     // **取得できたかで文言を変える。** 静的ビルドの値をそのまま「現在値」として見せると、
     // まさにここが警告している誤読を自分で起こす。取りに行って失敗したことは隠さない。
+    // 🔴 **足した行があるときは「次回の実行後」と言い切らない（段階1）。** 一覧には
+    // 夜間の値といま読み取った登録が並んでいるので、「反映されるのは次回の実行後」は
+    // **もう出ている行について嘘**になる。時刻を2つ出す形（どの行がいつの値か）は
+    // 段階3で1箇所にまとめるので、ここでは**但し書きを1行足すだけ**にとどめる。
     var asOf = fleetVal("generatedAt") ? dsFmtTime(fleetVal("generatedAt")) : "";
+    var hasPending = Object.keys(pendingCaps()).length > 0;
     if (asOf) {
       var asOfText = LIVE_FLEET_FAILED
         ? "最新の接続状況を取得できませんでした。表示しているのは " + asOf + " 時点の情報です。"
-        : "接続状況は " + asOf + " 時点の自動チェック結果です。設定を変えた場合、ここに反映されるのは次回の実行後になります。";
+        : hasPending
+          ? "接続状況は " + asOf + " 時点の自動チェック結果です。いま登録した分も一覧に出していますが、読み取れているかどうかが分かるのは次回の自動チェックの後になります。"
+          : "接続状況は " + asOf + " 時点の自動チェック結果です。設定を変えた場合、ここに反映されるのは次回の実行後になります。";
       sec.appendChild(el("p", {
         class: "datasources-asof" + (LIVE_FLEET_FAILED ? " is-stale" : ""),
         text: asOfText,
@@ -3232,9 +4205,29 @@ ${capabilityState.toString()}
           col.appendChild(el("span", { class: "ds-drive-note", text: "Drive自動同期は未設定（手動で置いたファイルの変換のみ）" }));
         }
         // 未使用（enabled: false）はグレー行。アダプターの存在は見せつつ、この案件では設定されていないことを示す
-        var inactive = s.enabled === false;
+        // 🔴 **足した行がある能力では「未使用」と言わない（段階1）。** enabled は夜間の値で、
+        // いま登録した行が一覧に出ているのに「この案件では設定されていません」と並ぶ
+        var inactive = s.enabled === false && !capPending(s.kind);
         if (inactive) {
-          col.appendChild(el("span", { class: "ds-inactive-note", text: "未使用（この案件では設定されていません）" }));
+          // **反映待ちのあいだは「⏳ 反映中」に差し替える（消さない）。** 消すと
+          // .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 };
+            },
+          ));
         }
         // id は接続マップのノードclickの飛び先（アンカー）
         // **id は付けない。** #101 以前はこのカードが接続マップの飛び先だったが、
@@ -3313,19 +4306,8 @@ ${capabilityState.toString()}
         // 追加のときにワークスペースを選ばせるのをやめたので、
         // 「どの組織のものか」「その組織とつながっているか」を画面が言う。
         // 分け方は groupSlackByOrg（純関数）が全部持っている
-        if (g.type === "slack") {
-          slackRows(g.items, meta).forEach(function (n) { pushCap("チャット", n); });
-          return;
-        }
-        // **GitHub も組織ごとに分ける（2026-08-20・Slack からの横展開）。**
-        // それまでは「リポジトリの一覧」と「組織ごとの接続状況」が**別々に並んで**おり、
-        // どの行がどの組織のものか、行を見ても分からなかった。
-        if (g.type === "__github__") {
-          // **meta は行ごとに引く。** issues と discussions が混ざるので、
-          // グループの type から1つに決められない
-          githubRows(g.items).forEach(function (n) { pushCap("開発", n); });
-          return;
-        }
+        // **一覧は下で1つの箱にまとめて出す**（開いたままでも差し替えられるように）
+        if (g.type === "slack" || g.type === "__github__") return;
         var cards = el("div", { class: "ds-list" });
         g.items.forEach(function (s) { cards.appendChild(extSourceCard(s, meta)); });
         if (g.items.length >= 4) {
@@ -3353,6 +4335,50 @@ ${capabilityState.toString()}
       });
     }
 
+    // ---- チャットと開発の一覧（開いたままでも追いつく形）----
+    //
+    // 🔴 **行が1件も無くても箱を出す。** 立ち上げ直後の案件＝**この仕組みが一番効く案件**は
+    // ここが空だが、モーダルを開いたままチャンネルを足すのはまさにその案件。
+    // 箱が無いと、足した行を入れる場所が画面に存在しない。
+    //
+    // **Slack は組織ごと（slackRows）・GitHub も組織ごと（githubRows）。**
+    // それまでは「行の一覧」と「組織ごとの接続状況」が別々に並んでいて、
+    // どの行がどの組織の話なのか読めなかった（2026-08-20 に揃えた）。
+    function liveExternals(kind) {
+      return (fleetVal("externalSources") || []).filter(function (s) {
+        return kind === "slack" ? s.type === "slack" : String(s.type || "").indexOf("github") === 0;
+      });
+    }
+    /** 行の見た目を決める値だけを並べる（時刻など毎回変わる値は入れない） */
+    function externalsSig(kind, extra) {
+      return JSON.stringify([liveExternals(kind), extra]);
+    }
+    /**
+     * **空の箱を置いてよいのは、そこへ足せる案件だけ。** 投入の口を持たない構成
+     * （素の Decisions ビュー）で行も無い能力に空の箱を積むと、押しても何も無いモーダルになる。
+     */
+    function liveListWanted(kind) { return !!SITE.intake || liveExternals(kind).length > 0; }
+    if (liveListWanted("slack")) pushCap("チャット", liveList(
+      "チャット",
+      function () { return externalsSig("slack", slackWorkspaces()); },
+      function (box) {
+        var items = liveExternals("slack");
+        if (!items.length) return;
+        var meta = DS_TYPE["slack"] || { icon: "🔗", label: "Slack" };
+        slackRows(items, meta).forEach(function (n) { box.appendChild(n); });
+      },
+    ));
+    if (liveListWanted("github")) pushCap("開発", liveList(
+      "開発",
+      function () { return externalsSig("github", fleetVal("githubOwners") || null); },
+      function (box) {
+        var items = liveExternals("github");
+        if (!items.length) return;
+        // **meta は行ごとに引く**（issues と discussions でアイコンとラベルが違う）
+        githubRows(items).forEach(function (n) { box.appendChild(n); });
+      },
+    ));
+
     // **追加フォームはグループの外に置く。** グループは0件だと描かれず、4件以上だと
     // 畳まれる（既定は閉）。中に入れると**新規案件（0件）＝一番追加したい場面**で消える。
     var adders = renderExternalAdders();
@@ -3539,9 +4565,17 @@ ${capabilityState.toString()}
      * @param derived engine が導出した5値（capabilities 由来）。古いデータでは null
      * @param adapter このタイルのアダプタ（件数の出し分けに使う）
      */
-    function tileSub(cap, st, derived, adapter) {
-      var internal = internals.filter(function (s) { return s.kind === cap; })[0];
-      var live = sources.filter(function (s) { return externalCapability(s.type) === cap; });
+    /**
+     * タイルの2行目。
+     *
+     * @param ins  内部ソースの一覧 / @param srcs 外部ソースの一覧。
+     *   **引数で受ける**（節を作ったときの値を掴まない）。反映が届いたあと、
+     *   節を作り直せない場面（モーダルを開いたまま）でも、**届いた一覧で
+     *   引き直す**ために同じ関数を使う——写経すると片方だけ古くなる
+     */
+    function tileSub(cap, st, derived, adapter, ins, srcs) {
+      var internal = ins.filter(function (s) { return s.kind === cap; })[0];
+      var live = srcs.filter(function (s) { return externalCapability(s.type) === cap; });
       var parts = [];
       // **導出が on 以外なら、導出の語を優先する（#125②）。** broken は状態としては
       // 警告（⚠️）だが、原因は「設定そのものが壊れている」であって同期の失敗ではない。
@@ -3650,10 +4684,13 @@ ${capabilityState.toString()}
      */
     function renderAdapterTile(cap, items, adapter, derived, ai) {
       var meta = CAP_META[cap] || { icon: "🔗", desc: "" };
+      // 🔴 **状態はまとめ表の素の値で決める（段階1）。** ここに足した行を混ぜると、
+      // 登録直後の1行で「使っている」と判定され、誰も測っていないのに**接続OK**に落ちる
+      // （同じ画面の行は「登録状況を確認中です」）。足した行の扱いは pendingSub が持つ
       var st = derived === "unset" && capabilityDisplayState(cap, caps) !== "unset"
         // カタログにあるが導出が答えていないアダプタ（今日は発生しない。#107 の前方互換）
         ? "idle"
-        : capabilityState(cap, { capabilities: caps, internals: internals, externals: sources, pipes: pipes });
+        : capabilityState(cap, stateCtx());
       // **ロゴはタイルの左に独立して置く。** 名前の行に入れると名前の高さに
       // 縛られて小さくなる。ロゴで能力を見分けられるのが一覧の主な用途
       var logo = ADAPTER_ICONS[adapter];
@@ -3663,10 +4700,38 @@ ${capabilityState.toString()}
       // カタログ外の値はここへ来ない（capabilityAdapter が弾く）。旧データの "none" だけは
       // 素通しすると顧客の画面に「none」というタイル名が出るので、上で空にしてある
       var rawTool = adapter || "";
+      // **2行目は反映待ちのあいだ「⏳ 反映中」にする。** モーダルを開かなくても分かる
+      // ようにするのが目的だが、別のバッジを足すのではなく**この行を差し替える**
+      // ——抑制しないと、同じタイルの中で「⏳ 反映中」と「⦿ 未接続」が並んで矛盾する。
+      // **抑制するのは unset のときだけ**（off / broken は残す。R4 と同じ理由）
+      // まとめ表がまだ知らない行がある能力は、**行と同じ語**に倒す（未接続とも接続OKとも言わない）
+      var pend = capPending(cap);
+      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),
+      });
+      // **反映が届いたら、届いたスナップショットから引き直す。** 下地へ戻すと
+      // 「⏳ 反映中」→「⦿ 未接続」になる——データが正しくなったあとに嘘をつく。
+      // 状態の語も色（ds-gate-*）も、判定はタイルを作るときと同じ式で引く
+      if (derived === "unset") reflectMark(subEl, cap, "sub", function (n) {
+        var capsNow = fleetVal("capabilities") || {};
+        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());
+        var pendNow = capPending(cap);
+        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),
+          hidden: false,
+        };
+      });
       var body = el("div", { class: "ds-tile-body" }, [
         el("div", { class: "ds-tile-name", text: (rawTool && (CM_TOOL_LABEL_C[rawTool] || rawTool)) || cap }),
         el("div", { class: "ds-tile-desc", text: meta.desc }),
-        el("div", { class: "ds-tile-sub ds-gate-" + st, text: tileSub(cap, st, derived, adapter) }),
+        subEl,
       ]);
       // **なぜその状態なのかを添える（#125②）。** engine が書いた一文（detail）で、
       // 「何が無いのか」を出す。on のときは読み取り範囲（件数）が既に同じ行にある。
@@ -3720,10 +4785,13 @@ ${capabilityState.toString()}
         body,
         el("span", { class: "ds-tile-chev", text: "›" }),
       ]);
+      // ⚠ **ここで足した行（段階1）を見て抑制しない。** unset の一文は開くときに引き直される
+      // （openCapabilityModal の reflectMark の fresh 側が capPending を見る）ので二重になるうえ、
+      // ここで抑えると off / broken まで消える——R4 で「消さない」と決めたもの
       var modalNote = derived && derived !== "on" && capInfo && capInfo.detail
         ? CAP_STATE_TEXT[derived] + "（" + capInfo.detail + "）"
         : "";
-      tile.addEventListener("click", function () { openCapabilityModal(cap, items, modalNote); });
+      tile.addEventListener("click", function () { openCapabilityModal(cap, items, modalNote, derived === "unset"); });
       sec.appendChild(tile);
     }
 
@@ -4240,6 +5308,8 @@ ${capabilityState.toString()}
   function backlogTargetsSection(s) {
     var targets = backlogTargetsNow(s);
     var editable = backlogTargetsEditable();
+    /** 追加・削除の応答で一覧を受け取ったか（受け取っていたら、そちらが正本） */
+    var adopted = false;
 
     // **Slack / GitHub / Figma / Drive と同じレコードの行にする（2026-08-21・オーナー指摘）。**
     // それまでは「現在の接続先」というラベル付きの独自レイアウト（.ds-current /
@@ -4247,7 +5317,29 @@ ${capabilityState.toString()}
     var listEl = el("div", { class: "ds-list" });
     // **0件の1行は一覧の外に置く**（Figma / Drive と同じ形）。中に .ds-card として
     // 置くと「行が1件ある」と読まれ、一覧を数えるテストにも行として数えられる
-    var emptyEl = el("p", { class: "ds-empty", text: "同期する接続先はまだ登録されていません（未設定）。" });
+    // **反映待ちのあいだは「未設定」と言わない。** 保存はできているので事実に反する
+    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 };
+      },
+    );
     // 追加・削除の結果はここに1つだけ出す（行を描き直しても消えない位置）
     var msg = el("div", { class: "ds-toggle-msg" });
 
@@ -4332,6 +5424,9 @@ ${capabilityState.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());
     }
 
     /**
@@ -4339,6 +5434,9 @@ ${capabilityState.toString()}
      * （＝他の人が先に変えていた。409 の文面をこちらの言葉に差し替える判断に使う）。
      */
     function adoptTargets(list) {
+      // **応答の一覧を受け取ったら、以後はスナップショットから引き直さない**
+      //（応答のほうが新しい。反映待ちが終わっても、この一覧を上書きしない）
+      adopted = true;
       var before = targetsGenerationOf(targets);
       var next = [];
       for (var i = 0; i < list.length; i++) {
@@ -4384,8 +5482,23 @@ ${capabilityState.toString()}
 
     // **box を先に作る。** paint() は 0件の1行を box へ出し入れするので、
     // 箱が無いと最初の描画で「未設定」の行が出ない
-    var box = el("div", {}, [listEl]);
+    var box = el("div", { "data-live-cap": REGISTERED_CAP_NAMES.issues }, [listEl]);
     paint();
+    /**
+     * 取り直しで新しい値が届いたときの差し替え（段階1）。**一覧だけを描き直す。**
+     *
+     * モーダルを開いたまま接続先を足すのが普通の使い方なので、ここが無いと
+     * 足した接続先は閉じるまで画面に出ない。paint() は鍵の欄を作り直さず入れ直すだけなので、
+     * 入力中の鍵と「保存中…」は保たれる。
+     */
+    box.__rebuild = function () {
+      // 🔴 応答に添えられた一覧（adoptTargets）のほうが新しい。上書きしない
+      if (adopted) return;
+      var next = backlogTargetsNow(internalSourceOf(REGISTERED_CAP_NAMES.issues));
+      if (targetsGenerationOf(next) === targetsGenerationOf(targets)) return;
+      targets = next;
+      paint();
+    };
     // 接続先がまだ無い案件の受け皿は、0件の1行の直後に置く（行が無いので中へ入れられない）
     if (keySlots[""]) box.appendChild(keySlots[""]);
     if (editable) {
@@ -4557,9 +5670,17 @@ ${capabilityState.toString()}
         // **ON/OFFのトグルは出さない。** フォルダを追加した時点で取り込みは始まる
         // （applyAddDriveFolder が enabled を立てる）ので「始める」を押す機会が無い。
         // 止めたいならフォルダを外す——登録そのものが意思表示、という会議と同じ考え方。
-        var folders = s.driveFolderIds || [];
+        // **一覧は開いたままでも差し替わる箱に入れる（段階1）。** 追加は「モーダルを開いたまま」
+        // 行われるので、ここが固定だと足したフォルダは閉じるまで画面に出ない
+        var driveNow = function () { return internalSourceOf("共有資料") || s; };
+        box.appendChild(liveList("共有資料", function () {
+          var d = driveNow();
+          return JSON.stringify([d.driveFolderIds || [], d.driveFolderNames || {}, d.driveState || ""]);
+        }, function (listBox) {
+        var src = driveNow();
+        var folders = src.driveFolderIds || [];
         // 名前は任意。**無ければIDを出す**（既存の案件は名前を持っていない）
-        var fnames = s.driveFolderNames || {};
+        var fnames = src.driveFolderNames || {};
         if (folders.length) {
           var dlist = el("div", { class: "ds-list" });
           folders.forEach(function (id) {
@@ -4599,8 +5720,8 @@ ${capabilityState.toString()}
             }));
             dlist.appendChild(row);
           });
-          box.appendChild(dlist);
-        } else if (s.driveState === "empty") {
+          listBox.appendChild(dlist);
+        } else if (src.driveState === "empty") {
           // **0件を黙って見せない。** 追加フォームだけだと「まだ登録していない」のか
           // 「読めていない」のか区別できない。
           //
@@ -4608,8 +5729,9 @@ ${capabilityState.toString()}
           // driveFolderIds を「1件以上あるときだけ」出すので、キーの有無では
           // 未取得（unset / broken）と0件を見分けられない。unset / broken は
           // 上の分岐で先に返しているので、ここへ来る empty は「読めていて0件」だけ。
-          box.appendChild(el("p", { class: "ds-empty", text: "取り込み対象のフォルダはまだ登録されていません。" }));
+          listBox.appendChild(el("p", { class: "ds-empty", text: "取り込み対象のフォルダはまだ登録されていません。" }));
         }
+        }));
         box.appendChild(addForm({
           title: "＋ Google Drive のフォルダを追加",
           placeholder: "https://drive.google.com/drive/folders/…",
@@ -4636,7 +5758,11 @@ ${capabilityState.toString()}
     if (s.kind === "デザイン" && usable("デザイン", "figma")) {
       // 登録済みファイルを1件ずつ外せるようにする（6ファイル抱えている案件があり、
       // 古いスプリントのファイルを外したいのが実際に起きる操作）。
-      var figs = s.figmaFiles || [];
+      // **一覧は開いたままでも差し替わる箱に入れる（段階1）。** 追加は「モーダルを開いたまま」
+      // 行われるので、ここが固定だと足したファイルは閉じるまで画面に出ない
+      var figsOf = function () { return (internalSourceOf("デザイン") || {}).figmaFiles || []; };
+      box.appendChild(liveList("デザイン", function () { return JSON.stringify(figsOf()); }, function (listBox) {
+      var figs = figsOf();
       // **残り件数は「押した時点」で数える。** 一覧（figs）は夜間バッチのスナップショットで、
       // このページを開いている間はもちろん、その日のうちに再読み込みしても更新されない。
       // 描画時点の件数で判定すると、3件を1件ずつ外していったとき最後の1件でも警告が出ない。
@@ -4684,12 +5810,13 @@ ${capabilityState.toString()}
           }));
           flist.appendChild(row);
         });
-        box.appendChild(flist);
+        listBox.appendChild(flist);
       } else {
         // **0件を黙って見せない。** 追加フォームだけだと「まだ登録していない」のか
         // 「読めていない」のか区別できない（Driveは driveState で理由まで出している）
-        box.appendChild(el("p", { class: "ds-empty", text: "同期対象のFigmaファイルはまだ登録されていません。" }));
+        listBox.appendChild(el("p", { class: "ds-empty", text: "同期対象のFigmaファイルはまだ登録されていません。" }));
       }
+      }));
       // **鍵の欄は一覧の直後に1つ（2026-08-21・オーナー指摘）。**
       // Backlog と違い、Figma の鍵は**案件に1本**（ファイルごとではない）。
       // 行ごとに出すと同じ欄が並ぶだけなので、一覧をひとまとまりと見て、その下に置く。
@@ -4939,6 +6066,22 @@ ${capabilityState.toString()}
         msg.appendChild(el("a", { href: j.refreshUrl, target: "_blank", rel: "noopener", text: "反映の状況 →" }));
       }
       btn.disabled = false;
+      // **反映待ちとして記録する。** 一覧はスナップショットから描かれるので、
+      // 保存できていても数分は「未設定」と出る。その間だけ「⏳ 反映中」に差し替える。
+      //
+      // ⚠ **onDone の中に置かない。** removeRow は onDone に null を渡しているので、
+      // 中に置くと**接続先の「削除」だけ黙って記録されない**（remove の判定が守りたい当のケース）。
+      //
+      // - changed === false（既に同じものが入っていた）は記録しない——待つものが無い
+      // - refreshUrl が無い（自己チェックを起こせなかった）ときも記録しない
+      //   ——待っても来ないので「反映中」が嘘になる
+      if (j.changed !== false && j.refreshUrl) rememberReflecting(payload, j.refreshUrl);
+      // **保存が効いたら、いまの登録を読み直す（段階1）。** 一覧はまとめ表（夜間バッチ）から
+      // 描かれるので、保存しただけでは行が出ない。ここで読み直すと、登録ファイルの中身が
+      // 返ってきて**足りない行として一覧に出る**——さらに「まとめ表がまだ答えていない行」が
+      // できるので、まとめ表が追いつくまで取り直しが続く。
+      // 取得中なら何もしない（応答後に catchUpOpenCaps が拾う）
+      if (j.changed !== false) loadLiveFleet();
       // **何も変わっていないなら「追加した」と見せない。** 既に同じものが入っていた場合
       // サーバは 200 + changed:false を返す。ここを res.ok だけで判定すると
       // 「変更はありません」と言いながら追加した行が出る
@@ -5573,6 +6716,51 @@ ${capabilityState.toString()}
   }
 
 
+  /* ---------------------------------------------------------------------------
+   * 開いたままのモーダルへ届ける（段階1）
+   *
+   * 🔴 **チャンネルやフォルダを足すのは「モーダルを開いたまま」。** 節ごとの差し替え
+   * （refreshDataSources）はモーダルが開いている間は何もしない——下地を入れ替えると
+   * 開いているモーダルの中身が切り離され、入力中の値も「保存中…」も消えるので、
+   * **あのガードは外せない**。だから「反映中」と同じく、**その箇所だけを差し替える口**を置く。
+   *
+   * 差し替えるのは**レコードの一覧だけ**（追加フォーム・鍵の欄・結果メッセージは触らない）。
+   * 課題管理の adoptTargets が先にこの形を採っている。
+   *
+   * 🔴 **中身が変わっていなければ何もしない。** 60秒ごとの取り直しのたびに作り直すと、
+   * 「削除しました」の表示や取り消し線（.ds-removed）が黙って消える。
+   * ------------------------------------------------------------------------- */
+
+  /**
+   * 開いたままでも追いつく一覧。
+   *
+   * @param cap   どの能力の一覧か（差し替えの対象を絞るためだけに使う）
+   * @param sig   いまのデータを表す文字列。**変わったときだけ**作り直す
+   * @param build 中身を作る（box を渡すので、その中へ appendChild する）
+   */
+  function liveList(cap, sig, build) {
+    var box = el("div", { class: "ds-livelist", "data-live-cap": cap });
+    box.__rebuild = function () {
+      var next = sig();
+      if (next === box.__sig) return;
+      box.__sig = next;
+      while (box.firstChild) box.removeChild(box.firstChild);
+      build(box);
+    };
+    box.__rebuild();
+    return box;
+  }
+
+  /** 開いているモーダルの中の一覧だけを差し替える（下地は触らない） */
+  function repaintOpenLists() {
+    var overlay = app.querySelector(".modal-overlay");
+    if (!overlay) return;
+    var nodes = overlay.querySelectorAll("[data-live-cap]");
+    for (var i = 0; i < nodes.length; i++) {
+      if (typeof nodes[i].__rebuild === "function") nodes[i].__rebuild();
+    }
+  }
+
   /**
    * 取得中フラグ。**完了しても寝かせたままにしない。**
    * 一度 true のままだと、タブを移動して戻ってきても再取得せず、設定を変えた人が
@@ -5580,6 +6768,43 @@ ${capabilityState.toString()}
    * **操作タブに入り直したときだけ**もう一度取りに行く（ポーリングはしない）。
    */
   var liveFleetRequested = false;
+  /**
+   * この画面で開いた能力（op=state に送る識別子）。
+   *
+   * 🔴 **開いている能力の分だけ読む。** Lambda は指定された能力の登録ファイルだけを
+   * 読む（ツリー1本＋ファイルの本数）。全能力を毎回読ませると GitHub の枠を削る。
+   *
+   * **一度開いたら覚えておく（閉じても外さない）。** 外すと、次の取り直しで
+   * その能力の行が応答から消え、**タイルの件数だけが行ったり来たりする**。
+   */
+  var OPEN_CAPS = [];
+  /** 画面の能力名 → op=state の識別子（対応表の実体は REGISTERED_CAP_NAMES） */
+  function stateCapIdOf(cap) {
+    for (var id in REGISTERED_CAP_NAMES) {
+      if (Object.prototype.hasOwnProperty.call(REGISTERED_CAP_NAMES, id) && REGISTERED_CAP_NAMES[id] === cap) return id;
+    }
+    return null;
+  }
+  /** 取得中に開かれた能力があれば、もう一度だけ取りに行く */
+  function catchUpOpenCaps() {
+    if (OPEN_CAPS.length === liveFleetSentCaps.length) return;
+    loadLiveFleet();
+  }
+  /** 能力を開いた（＝その登録ファイルを読んでよい）。増えたときだけ取り直す */
+  function noteOpenCap(cap) {
+    var id = stateCapIdOf(cap);
+    if (!id || OPEN_CAPS.indexOf(id) >= 0) return;
+    OPEN_CAPS.push(id);
+    loadLiveFleet();
+  }
+  /**
+   * 直近の取得に載せた能力の一覧。
+   *
+   * **取得中に能力を開いた分を取りこぼさないため。** 取得中の loadLiveFleet は
+   * 何もせずに戻るので、これが無いと「開いたのに、その能力だけ永久に読まれない」
+   * （しかも次の取り直しは未確定の行が無いので張られない＝二度と追いつかない）。
+   */
+  var liveFleetSentCaps = [];
   function loadLiveFleet() {
     if (liveFleetRequested) return;
     var intake = SITE.intake;
@@ -5588,11 +6813,14 @@ ${capabilityState.toString()}
     // 素で呼ぶと描画中の ReferenceError になり、「画面が例外を出さずに描き切る」検査を割る。
     if (typeof fetch !== "function") return;
     liveFleetRequested = true;
+    liveFleetSentCaps = OPEN_CAPS.slice();
     var pfx = intake.url + (intake.url.indexOf("?") === -1 ? "?" : "&");
     fetch(pfx + "op=state&t=" + encodeURIComponent(intake.token), {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: "{}",
+      // **開いている能力を伝える。** 知らない値は Lambda 側が黙って捨てる（断らない）ので、
+      // 画面と Lambda の版が食い違っても接続状況の表示は消えない
+      body: JSON.stringify({ caps: OPEN_CAPS }),
     })
       // **非2xxも失敗として扱う。** ビューアとLambdaの版は独立に進むので、
       // op=state 未対応のLambdaは 400 を返す。通信エラーだけを見ていると空表示になる。
@@ -5601,18 +6829,39 @@ ${capabilityState.toString()}
         // **fleet より先に読む。** fleet-status.json をまだ持たない案件（立ち上げ直後）は
         // 下で throw するが、リアルタイム同期の可否は索引由来なので独立に決まる
         LIVE_REALTIME = (j && j.realtime) || null;
+        // 🔴 **registeredNow も fleet より先に読む。** まとめ表をまだ持たない案件
+        // （＝立ち上げ直後＝この仕組みが一番効く案件）は下で throw するので、
+        // ここより後に置くと**その案件だけ素通り**する
+        LIVE_REGISTERED = sanitizeRegisteredNow(j && j.registeredNow);
+        MERGED = null;
         if (!j || !j.fleet) throw new Error("no fleet");
         LIVE_FLEET = normalizeFleet(j.fleet);
         LIVE_FLEET_FAILED = false;
         liveFleetRequested = false;
+        MERGED = null;
         refreshDataSources();
+        // **モーダルを開いたままでも「反映中」だけは追いつかせる。** refreshDataSources は
+        // モーダルが開いている間・入力中は何もしない（下地を入れ替えると開いているモーダルの
+        // 中身が切り離される）ので、局所的に差し替える口をここに置く
+        repaintReflect(document);
+        repaintOpenLists();
+        // まだ足りない行があるなら取り直しを続ける（無くなったら止める）
+        refreshStateTimer();
+        catchUpOpenCaps();
       })
       .catch(function () {
         // 静的ビルドの値で描き続ける。ただし「古いかもしれない」ことは画面に出す
         LIVE_FLEET = null;
         LIVE_FLEET_FAILED = true;
         liveFleetRequested = false;
+        MERGED = null;
         refreshDataSources();
+        repaintReflect(document);
+        repaintOpenLists();
+        // **失敗しても取り直しは続ける**（期限が来れば止まる）。ここで止めると、
+        // 一時的な失敗のあと画面が二度と追いつかない
+        refreshStateTimer();
+        catchUpOpenCaps();
       });
   }
 
@@ -5620,6 +6869,12 @@ ${capabilityState.toString()}
     renderConnMap();
     renderDataSources();
     loadLiveFleet();
+    // **まとめ表がまだ答えていない行があれば取り直す。** 取得前は0件なので、
+    // 実際に張られるのは応答が届いてから（loadLiveFleet が呼び直す）
+    refreshStateTimer();
+    // **反映待ちがあれば自動で取り直す（再読み込みしても続く）。** 反映待ちが
+    // 1件も無ければタイマは張らない
+    scheduleReflectRefresh();
     // **取り込みカードと鍵カードは能力セクションへ移した**（#101）。
     // ここで再度出すと二重になる。手動投入は 会議 / 共有資料 の中にある。
   }