@takagaki/cortex-decisions-viewer 0.7.1 → 0.8.0

package/dist/render.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REFLECT_OPS = exports.REFLECTING_LIMITS = void 0;
 exports.renderSite = renderSite;
+exports.livePending = livePending;
+exports.nextCheckDelay = nextCheckDelay;
+exports.settledPending = settledPending;
 exports.renderConnectionMap = renderConnectionMap;
 /** SiteDataを単一の自己完結HTML（埋め込みデータ+CSS+JS）にレンダリングする */
 function renderSite(site) {
@@ -310,6 +314,164 @@ 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;
+}
 function capabilityState(cap, ctx) {
     // **能力→パイプラインの対応はここに持つ。** 呼び出し側に渡させると、
     // クライアント側（この関数を .toString() で受け取る側）が同じ表を書き写すことになり、
@@ -1589,6 +1751,15 @@ ${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()}
   // 「はじめに」セクションのチュートリアルデータ（ビルド時に埋め込み。ボタンURL・チャレンジ4の決定は解決済み）
   var TUTORIAL = (function () {
     var elx = document.getElementById("tutorial-data");
@@ -2974,6 +3145,269 @@ ${capabilityState.toString()}
     return SITE[key === "generatedAt" ? "fleetGeneratedAt" : key];
   }
 
+  // ---------- 反映待ち（「⏳ 反映中」）----------
+  //
+  // ## 何のためか
+  //
+  // 設定を保存してから画面に出るまで、自己チェック（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);
+  }
+
+  function reflectTick() {
+    reflectTimer = null;
+    var live = reflectingNow();
+    // **期限に達した回でも、一度だけ描き直してから止める。** これが無いと
+    // 「取り直しは止まったのに反映中の文字が残る」時間ができる
+    repaintReflect(document);
+    // **新しい取得経路を作らない。** 2箇所になると「いつ時点の値か」が説明できなくなる
+    if (live.length) loadLiveFleet();
+    scheduleReflectRefresh();
+  }
+
   /**
    * その能力にそのアダプタの操作を出してよいか（#125②）。
    *
@@ -3019,7 +3453,14 @@ ${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) {
+    // 見出しは押したタイルのツール名（Backlog・Google ドライブ…）。capToolLabel の説明を参照
     var m = makeModal(capToolLabel(cap), true);
     // **何が読み取られるのかを必ず書く。** 一覧に並ぶものと読み取られるものの関係は、
     // 書いていないと分からない（チャットは「載っていれば全部」、開発はリポジトリ単位でOFFできる）
@@ -3031,7 +3472,23 @@ ${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 () {
+        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: "この能力にはまだ設定できるものがありません。" }));
     }
@@ -3234,7 +3691,25 @@ ${capabilityState.toString()}
         // 未使用（enabled: false）はグレー行。アダプターの存在は見せつつ、この案件では設定されていないことを示す
         var inactive = s.enabled === false;
         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);
+              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 以前はこのカードが接続マップの飛び先だったが、
@@ -3539,9 +4014,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 は状態としては
       // 警告（⚠️）だが、原因は「設定そのものが壊れている」であって同期の失敗ではない。
@@ -3663,10 +4146,30 @@ ${capabilityState.toString()}
       // カタログ外の値はここへ来ない（capabilityAdapter が弾く）。旧データの "none" だけは
       // 素通しすると顧客の画面に「none」というタイル名が出るので、上で空にしてある
       var rawTool = adapter || "";
+      // **2行目は反映待ちのあいだ「⏳ 反映中」にする。** モーダルを開かなくても分かる
+      // ようにするのが目的だが、別のバッジを足すのではなく**この行を差し替える**
+      // ——抑制しないと、同じタイルの中で「⏳ 反映中」と「⦿ 未接続」が並んで矛盾する。
+      // **抑制するのは unset のときだけ**（off / broken は残す。R4 と同じ理由）
+      var subEl = el("div", { class: "ds-tile-sub ds-gate-" + st, 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 pipesNow = fleetVal("pipelines") || [];
+        var dNow = adapter === capabilityAdapter(cap, capsNow) ? capabilityDisplayState(cap, capsNow) : "unset";
+        var stNow = dNow === "unset" && capabilityDisplayState(cap, capsNow) !== "unset"
+          ? "idle"
+          : capabilityState(cap, { capabilities: capsNow, internals: insNow, externals: srcsNow, pipes: pipesNow });
+        n.className = "ds-tile-sub ds-gate-" + stNow;
+        return { 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 のときは読み取り範囲（件数）が既に同じ行にある。
@@ -3723,7 +4226,7 @@ ${capabilityState.toString()}
       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 +4743,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 +4752,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 +4859,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 +4869,9 @@ ${capabilityState.toString()}
      * （＝他の人が先に変えていた。409 の文面をこちらの言葉に差し替える判断に使う）。
      */
     function adoptTargets(list) {
+      // **応答の一覧を受け取ったら、以後はスナップショットから引き直さない**
+      //（応答のほうが新しい。反映待ちが終わっても、この一覧を上書きしない）
+      adopted = true;
       var before = targetsGenerationOf(targets);
       var next = [];
       for (var i = 0; i < list.length; i++) {
@@ -4939,6 +5472,16 @@ ${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);
       // **何も変わっていないなら「追加した」と見せない。** 既に同じものが入っていた場合
       // サーバは 200 + changed:false を返す。ここを res.ok だけで判定すると
       // 「変更はありません」と言いながら追加した行が出る
@@ -5606,6 +6149,10 @@ ${capabilityState.toString()}
         LIVE_FLEET_FAILED = false;
         liveFleetRequested = false;
         refreshDataSources();
+        // **モーダルを開いたままでも「反映中」だけは追いつかせる。** refreshDataSources は
+        // モーダルが開いている間・入力中は何もしない（下地を入れ替えると開いているモーダルの
+        // 中身が切り離される）ので、局所的に差し替える口をここに置く
+        repaintReflect(document);
       })
       .catch(function () {
         // 静的ビルドの値で描き続ける。ただし「古いかもしれない」ことは画面に出す
@@ -5613,6 +6160,7 @@ ${capabilityState.toString()}
         LIVE_FLEET_FAILED = true;
         liveFleetRequested = false;
         refreshDataSources();
+        repaintReflect(document);
       });
   }
 
@@ -5620,6 +6168,9 @@ ${capabilityState.toString()}
     renderConnMap();
     renderDataSources();
     loadLiveFleet();
+    // **反映待ちがあれば自動で取り直す（再読み込みしても続く）。** 反映待ちが
+    // 1件も無ければタイマは張らない
+    scheduleReflectRefresh();
     // **取り込みカードと鍵カードは能力セクションへ移した**（#101）。
     // ここで再度出すと二重になる。手動投入は 会議 / 共有資料 の中にある。
   }

package/package.json

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