@takagaki/cortex-decisions-viewer 0.12.129 → 0.12.132

package/dist/render.js

@@ -2471,6 +2471,10 @@ function sanitizeGithubOwnersNow(v) {
         const row = { owner, appInstalled: r.appInstalled === true ? true : r.appInstalled === false ? false : null };
         if (typeof r.repos === "number" && Number.isFinite(r.repos) && r.repos >= 0)
             row.repos = r.repos;
+        // その案件のテナントのアプリの slug（行の「入れる」リンクの宛先・cortex-engine #1328 T-6）。🔴 slug の形だけを残す
+        // （画面がリンクに組み立てる）。⚠ この関数は toString で埋め込みJSへ入るので、正規表現は関数の中に逆斜線なしで書く
+        if (typeof r.appSlug === "string" && /^[a-z0-9][a-z0-9-]{0,33}$/.test(r.appSlug))
+            row.appSlug = r.appSlug;
         out.push(row);
     }
     return out.length ? out : null;
@@ -5716,6 +5720,17 @@ a.ds-tile:hover { text-decoration: none; }
 .ds-gate-ok { color: #1f7a45; }
 .ds-gate-warn { color: #b45309; }
 .ds-gate-muted { color: #6b7280; }
+/* 行の事実の札（c-07 の 2 本目）: 固定 IP 経由・リアルタイム同期の稼働中／未受信。
+   .ds-gate（届くか札は 1 つ）とは別の部品。状態の色（緑・橙）は使わず、事実の弱い札として読ませる */
+.ds-route-chip, .ds-rt-chip { display: inline-flex; align-items: baseline; gap: 6px; flex: 0 0 auto; padding: 1px 8px; border-radius: 999px; border: 1px solid var(--border); font-size: 11.5px; color: #6b7280; background: #fff; }
+.ds-rt-chip.is-live { color: #1c7a43; border-color: #b7e0c6; background: #e8f6ed; }
+.ds-rt-at { font-size: 11px; color: var(--muted); font-weight: 400; }
+/* 一覧の下の 1 行の一手（リアルタイム同期の設定・［設定する］で手順が開く）と、ふだん見えない「その他」 */
+.ds-rt-help { margin: 8px 0 0; font-size: 12px; line-height: 1.7; color: #6b7280; }
+.ds-more { margin-top: 14px; }
+.ds-more > summary { cursor: pointer; color: var(--muted); font-size: 12px; }
+.ds-more[open] > summary { margin-bottom: 8px; }
+.ds-more-key { margin: 6px 0 0; font-size: 12.5px; color: var(--text); display: flex; align-items: center; flex-wrap: wrap; gap: 8px; }
 /* 行の状態に添える「次に誰が何をするか」（2026-08-18）。**必ず自分の行を占める**
    （flex: 1 1 100%）——状態バッジの横に押し込むと、いちばん読ませたい一文が
    カード幅に負けて省略される。状態の語より弱く、しかし読める大きさで出す */
@@ -10088,6 +10103,18 @@ ${calendarAddUrl.toString()}
         resting: function (row) { return slackRowHelpParts(row); },
       },
     },
+    // 🔴 **Backlog の行の一手（c-07 の 2 本目）。** 行の中身（そのスペースのキーの有無・同期経路・
+    // スペースの数）で決まるので関数で持つ。row は { domain, projectKey, gate }。
+    // DS_GATE_CAP.issues は札（APIキーが未登録です）だけを持ち、help を持たせない（一手の置き場は 1 か所）。
+    // 部品の型は 文字列 / { copy, bare } / { act: "backlog-key" | "backlog-route-on", label, space }
+    backlog: {
+      no_token: {
+        resting: function (row) { return backlogRowHelpParts(row); },
+      },
+      unreachable: {
+        resting: function (row) { return backlogRowHelpParts(row); },
+      },
+    },
     github: {
       // 🔴 **読めない行の中に、理由に合った一手だけを出す（#1233）。** 全体の帯は撤去した。
       // 一手は組織の App の導入状況（githubRowHelpParts）で決まるので、関数で持つ
@@ -10140,10 +10167,18 @@ ${calendarAddUrl.toString()}
     var owner = String(row.ref || "").split("/")[0];
     var meta = owner ? githubOwnerMeta(owner) : null;
     if (meta && meta.source === "unknown") return null;
-    if (row.gate === "unreachable" && meta && meta.appInstalled === true) {
-      return ["GitHub App の設定で、このリポジトリを選んでください。", { link: "インストール設定を開く →", kind: "settings" }];
-    }
-    return ["この組織に Cortex の GitHub App を入れてください。", { link: "GitHub App を入れる →", kind: "install" }];
+    // 🔴 リンクの宛先は、その組織について窓口が答えたアプリ（案件のテナントのアプリ・#1328 T-6）。
+    // 正本（op=state）が答えている画面で slug が無い組織は「分からない」回なので、**宛先を出さず文だけ**にする
+    // （当社のアプリへ落とすと、会社ごとのアプリの会社の画面で別のアプリを入れさせる）。
+    // 当社のアプリの定数へ落とすのは、正本の答えがまだ無い画面（まとめ表だけ）のときだけ
+    var slug = githubAppSlugOf(meta);
+    var linkable = !!slug || !LIVE_GH_OWNERS;
+    var pick = row.gate === "unreachable" && meta && meta.appInstalled === true;
+    var say = pick ? "GitHub App の設定で、このリポジトリを選んでください。" : "この組織に Cortex の GitHub App を入れてください。";
+    if (!linkable) return [say];
+    // 部品には行の生の値を渡す（宛先の検めは githubAppLinkUrl が持つ。ここの slug はリンクを出すかの判断だけ）
+    var raw = meta && meta.appSlug;
+    return [say, pick ? { link: "インストール設定を開く →", kind: "settings", slug: raw } : { link: "GitHub App を入れる →", kind: "install", slug: raw }];
   }
   /**
    * Slack の「理由不明」の行（unreachable・組織不明の仮置き）に出す一手（c-07）。
@@ -10185,9 +10220,10 @@ ${calendarAddUrl.toString()}
     var p = el("p", { class: cls });
     parts.forEach(function (part) {
       if (typeof part === "string") p.appendChild(document.createTextNode(part));
-      else if (part && part.link) p.appendChild(el("a", { href: githubAppLinkUrl(part.kind), target: "_blank", rel: "noopener", text: part.link }));
-      else if (part && part.copy) p.appendChild(copyInline(part.copy, true));
-      else if (part && part.act) { var an = actNode(part.act); if (an) p.appendChild(an); }
+      else if (part && part.link) p.appendChild(el("a", { href: githubAppLinkUrl(part.kind, part.slug), target: "_blank", rel: "noopener", text: part.link }));
+      // bare … 文面に値が含まれているので［コピー］だけを出す（固定 IP の依頼文）
+      else if (part && part.copy) p.appendChild(copyInline(part.copy, !part.bare));
+      else if (part && part.act) { var an = actNode(part.act, part.label, part.space); if (an) p.appendChild(an); }
     });
     return p;
   }
@@ -10195,11 +10231,18 @@ ${calendarAddUrl.toString()}
    * 行の一手に置くボタン（c-07）。**押せないボタンは作らない**（null）。
    *   - "connect" … ［接続する］。Slack の承認画面へ送る（slackConnectInline）。投入の口が無ければ null
    *   - "figma-key" … ［トークンを入れる］／［トークンを入れ直す］。下の「Figma のトークン」の欄の入力へ移る
+   *   - "backlog-key" … ［入れる］／［入れ直す］。**そのスペースの**鍵カードを開いて入力へ移る（arg＝スペース）。
+   *     受け皿が無いスペースには作らない（別のスペースの欄へ落とさない）
+   *   - "backlog-route-on" … ［切り替える］。同期経路を固定 IP 経由にする（setBacklogRoute）
    * @param label 省略時は既定の語
+   * @param arg   部品が要る材料（backlog-key のスペース）
    */
-  function actNode(act, label) {
+  function actNode(act, label, arg) {
     if (!SITE.intake) return null;
     if (act === "connect") return slackConnectInline(label || "接続する");
+    // Backlog の行の一手（c-07 の 2 本目）。arg はスペース（ドメイン）。**受け皿が無ければ作らない**
+    if (act === "backlog-key") return backlogKeyJump(arg, label || "入れる");
+    if (act === "backlog-route-on") return backlogRouteOnButton(label || "切り替える");
     // 鍵の欄（KEY_SLOTS.figma）が無い構成では、移る先が無いので出さない
     if (act === "figma-key") return secretKindsShown().indexOf("figma") >= 0 ? figmaKeyJump(label || "トークンを入れる") : null;
     return null;
@@ -10317,7 +10360,7 @@ ${calendarAddUrl.toString()}
    *
    * **ここを通さずに語を書き写さないこと。** 行バッジ・能力タイルの要約・
    * 「接続を確認」の結果が同じ関数を通るので、片方だけ古くなることが構造的に起きない
-   * （attentionSummary / probeVerdict の項に、実際に割れた経緯がある）。
+   * （attentionSummary の項に、実際に割れた経緯がある）。
    */
   function dsGateOf(s) {
     if (s.gate === "no_token") {
@@ -11197,7 +11240,7 @@ ${calendarAddUrl.toString()}
         var again = !!(x.ref && seenRef[x.ref]);
         if (x.ref) seenRef[x.ref] = 1;
         var rowCard = extSourceCard(x, DS_TYPE[x.type] || { icon: "🔗", label: x.type || "その他" }, { quietHelp: again });
-        // 同じリポの issues / discussions を、接続確認の結果で揃えるための目印（syncGithubSiblingRows）
+        // 同じリポの issues / discussions の行の目印（同じ dev 行から描くので、判定は 1 つの描き直しで揃う）
         if (rowCard && rowCard.setAttribute && x.ref) rowCard.setAttribute("data-ref", x.ref);
         return rowCard;
       });
@@ -11217,28 +11260,6 @@ ${calendarAddUrl.toString()}
     return out;
   }
 
-  /**
-   * 「接続を確認」の結果を、同じリポジトリの兄弟の行（issues / discussions）へそろえる。
-   *
-   * 帯は撤去した（#1233）。残すのは「行は 2 本でも接続は 1 つ」なので押した行と同じ判定に
-   * そろえる仕事だけ。**条件なしで毎回そろえる**（帯の有無・状態の変化に依らない）。
-   * 兄弟は同じ親（一覧・確かめられなかった組織の箱）の直下にいる。
-   */
-  function syncGithubSiblingRows(card, ref, ok) {
-    var parent = card.parentNode;
-    if (!parent || !ref) return;
-    var gateSrc = card.querySelector(".ds-gate");
-    var sibs = parent.querySelectorAll(":scope > .ds-card[data-ref]");
-    for (var si = 0; gateSrc && si < sibs.length; si++) {
-      var sib = sibs[si];
-      if (sib === card || sib.getAttribute("data-ref") !== ref) continue;
-      var sg = sib.querySelector(".ds-gate");
-      if (sg) { sg.className = gateSrc.className; sg.textContent = gateSrc.textContent; }
-      var sh = sib.querySelectorAll(".ds-gate-help");
-      for (var hi = 0; hi < sh.length; hi++) sh[hi].hidden = ok;
-    }
-  }
-
   /** 確かめられなかった組織の案内。**導線は出さない** */
   function githubUnsureNodes(g) {
     var o = g.meta || {};
@@ -11337,6 +11358,15 @@ ${calendarAddUrl.toString()}
     if (min < 60 * 24) return Math.floor(min / 60) + "時間前";
     return dsFmtTime(iso);
   }
+  /**
+   * 「◯分前に確認」の語。**「たった今」だけは「たった今確認」**（「たった今に確認」は日本語として崩れる）。
+   * 読めない値は空文字（呼び側が出し分けを切る）。行・タイル・押した直後の行は全部これを通す
+   */
+  function agoConfirmedText(iso) {
+    var ago = rtAgo(iso);
+    if (!ago) return "";
+    return ago === "たった今" ? "たった今確認" : ago + "に確認";
+  }
   // 名前表示: url があれば新しいタブで正本を開くリンクにする
   function dsNameEl(text, url) {
     if (url) return el("a", { class: "ds-name", href: url, target: "_blank", rel: "noopener", text: text });
@@ -11429,11 +11459,19 @@ ${calendarAddUrl.toString()}
    * **GitHub 側の画面が変わったらここが最初に嘘になる。** 宛先を変えるときは
    * 「githubConfigureUrl」（サーバ）と揃えること。
    */
-  function githubAppLinkUrl(kind) {
+  function githubAppLinkUrl(kind, slug) {
     // 「kind」: "install"（組織に App を入れる）／"settings"（入っている App の対象リポジトリを選ぶ）。
-    // いまは同じ宛先（App 個別ページ）。会社ごとの App（classmethod-cortex-portal #254）が動くと
-    // 宛先が変わるので、**行の案内のリンクは全部ここを通す**（URL を 1 か所から作る）
-    return ({ install: GITHUB_APP_INSTALL_URL, settings: GITHUB_APP_INSTALL_URL })[kind] || GITHUB_APP_INSTALL_URL;
+    // いまは同じ宛先（App 個別ページ）。**行の案内のリンクは全部ここを通す**（URL を 1 か所から作る）。
+    // 「slug」: その組織について窓口が答えた、案件のテナントのアプリ（会社ごとのアプリ・cortex-engine #1328 T-6）。
+    // 🔴 ここでも形を検める（まとめ表の行は許可リストを通らない）。無ければ当社の読む App（定数）
+    var s = githubAppSlugOf({ appSlug: slug });
+    var url = s ? "https://github.com/apps/" + encodeURIComponent(s) + "/installations/new" : GITHUB_APP_INSTALL_URL;
+    return ({ install: url, settings: url })[kind] || url;
+  }
+  /** 行の slug（形が合わなければ null）。⚠ 埋め込みJSなので、正規表現は逆斜線なしで書く */
+  function githubAppSlugOf(meta) {
+    var v = meta && meta.appSlug;
+    return typeof v === "string" && /^[a-z0-9][a-z0-9-]{0,33}$/.test(v) ? v : null;
   }
 
   /**
@@ -11857,8 +11895,8 @@ ${calendarAddUrl.toString()}
     var v = derivePendingTile(regKey, live, LIVE_STATE);
     if (!v) return null;
     if (v.kind === "ok") {
-      var ago = rtAgo(v.at);
-      return { text: CAP_STATE_MARK.ok + "接続OK" + (ago ? " " + ago + "に確認" : ""), cls: "ds-gate-ok" };
+      var ago = agoConfirmedText(v.at);
+      return { text: CAP_STATE_MARK.ok + "接続OK" + (ago ? " " + ago : ""), cls: "ds-gate-ok" };
     }
     var first = v.rows[0];
     var gate;
@@ -12201,13 +12239,33 @@ ${calendarAddUrl.toString()}
     for (var i = 0; i < KEY_CARDS.length; i++) {
       // **対応表に無い種別は隠さない**（keyTargetCount の既定と同じく出す側に倒す）。
       // 3つ目の鍵が足されて分岐を書き忘れた場合は key-card-visibility の [全種0件] が落ちる
-      KEY_CARDS[i].el.hidden = shown[KEY_CARDS[i].kind] === false;
+      var hide = shown[KEY_CARDS[i].kind] === false;
+      // 🔴 **Backlog の行の中のカードは、0 件の判定（上）に加えて「見せる理由があるとき」だけ見せる**
+      //（c-07 の 2 本目）。0 件が勝つ——0 件のあいだは理由があっても出さない（順序の逆な案内になる）
+      if (!hide && KEY_CARDS[i].compact) hide = !backlogKeyCardWanted(KEY_CARDS[i]);
+      KEY_CARDS[i].el.hidden = hide;
+      if (!hide && KEY_CARDS[i].compact && KEY_CARDS[i].refresh) KEY_CARDS[i].refresh();
     }
     eachKeySlot(function (slot) {
       slot.hidden = !slot.querySelector("[data-secret-kind]:not([hidden])");
     });
   }
 
+  /**
+   * Backlog の行の中の鍵カードを、いま見せるか（c-07 の 2 本目・スペースごとの判定）。次の 4 つのどれか:
+   *   ① キーが要る（backlogKeyNeededForSpace＝登録状況が「未登録」・足した直後で答えがまだ無い等）
+   *   ② 一手の［入れる］／［入れ直す］・「その他」の［入れ直す］が押された（forced）
+   *   ③ 触り始めた（開いた・値がある・結果の文がある）。🔴 **保存直後の「✓ 保存しました」と入力中の値を畳まない**（#223）
+   * 使えているスペースのカードは、ふだん隠れている（DOM には常に在る＝入力中の値・結果は消えない）。
+   */
+  function backlogKeyCardWanted(ent) {
+    if (ent.forced) return true;
+    if (ent.fold && ent.fold.open) return true;
+    if (ent.input && ent.input.value !== "") return true;
+    if (ent.msg && ent.msg.textContent !== "") return true;
+    return backlogKeyNeededForSpace(ent.space);
+  }
+
   /** いま在る鍵の受け皿（.ds-keyrow）を順に渡す。置き場の正本は KEY_SLOTS */
   function eachKeySlot(fn) {
     var slots = KEY_SLOTS.backlog || {};
@@ -12548,6 +12606,10 @@ ${calendarAddUrl.toString()}
       // 🔴 **Google Drive 専用の説明文（c-07・新設）。** SharePoint 等の別のアダプタの窓には出さない
       // （Markdown 化の約束は Drive の取り込みの話）。追加の欄の手順 3 が持っていた文
       m.modal.appendChild(el("p", { class: "modal-desc", text: "ここに並んでいるフォルダの中身を、毎晩 共有資料 にコピーして Markdown 化します。やめるには「このフォルダを外す」を押してください。" }));
+    } else if (cap === "課題管理" && (!adapter || adapter === "backlog")) {
+      // 🔴 **Backlog の説明文（c-07 の 2 本目・新設）。** 追加の欄の説明から外した 3 つを、ここに 1 回だけ置く:
+      // 何が同期されるか・起票先は変わらないこと（2026-08-20 に追加の確認をやめたとき追加の欄へ移した文）・止め方
+      m.modal.appendChild(el("p", { class: "modal-desc", text: "ここに並んでいる Backlog プロジェクトの課題・ドキュメント・Wiki を毎晩同期します。接続先を足しても、ビューアからの起票先は変わりません。やめるには「この接続先を外す」を押してください。" }));
     } else if (cap === "開発") {
       // 🔴 **開発の開示文は「記録に使う・決定の抽出には使わない」（#660）。** 2026-09-18 の
       // オーナー決定でソースの性質は種類で固定になり、GitHub は「作業の記録」に固定された。
@@ -12587,16 +12649,17 @@ ${calendarAddUrl.toString()}
           ? ""
           : (CAP_STATE_TEXT[dNow] || "状態が判定できません") + "（" + detailNow + "）";
       }
-      // 🔴 **Figma・Drive の「未接続（…が登録されていません）」は作らない（c-07）。** 0 件のとき、
+      // 🔴 **Figma・Drive・Backlog の「未接続（…が登録されていません）」は作らない（c-07）。** 0 件のとき、
       // 同じ窓に一覧の ds-empty「…はまだ登録されていません。」が出ていて二重だった。しかも一覧は
       // liveList で追加に追随するが、この一文は開いた時点の値なので、1 件足すと「未接続」が足した行の
-      // 上に残る。**一覧の 1 行だけ**を残す。off・broken の一文は残す（Backlog・Slack・GitHub も触らない）。
+      // 上に残る。**一覧の 1 行だけ**を残す。off・broken の一文は残す（Slack・GitHub は触らない）。
       // 🔴 **「登録されていません」と言うだけの一文だけを落とす。** 「雛形のプレースホルダです」のように、
       // 一覧の 1 行が言わない手がかりを運ぶ一文は残す（なぜ未接続扱いなのかが読めなくなる）
       var unsetDup = noteIsUnset
         && /登録されていません/.test(noteText)
         && ((cap === "デザイン" && (!adapter || adapter === "figma"))
-          || (cap === "共有資料" && (!adapter || adapter === "google-drive")));
+          || (cap === "共有資料" && (!adapter || adapter === "google-drive"))
+          || (cap === "課題管理" && (!adapter || adapter === "backlog")));
       if (!unsetDup) {
         var noteEl = el("p", { class: "modal-desc", text: noteText });
         // **消さずに hidden で伏せる。** 節点を残しておかないと、この一文を探している
@@ -12706,6 +12769,8 @@ ${calendarAddUrl.toString()}
     KEY_SLOTS = { backlog: {}, backlogNamed: false, figma: null };
     // 鍵カードも受け皿と同じく作り直す（前回の切り離されたカードを掴んだままにしない）
     KEY_CARDS = [];
+    // Backlog の節の行の控え・結果の帯・描き直しの口も作り直す（切り離された古い節を掴んだままにしない）
+    BACKLOG_UI = { rows: [], msg: null, repaintRows: null };
     // 作り直しはスナップショットから描き直すこと。応答で採った件数はここで捨てる
     ADOPTED_TARGET_COUNT = null;
     var internals = fleetVal("internalSources") || [];
@@ -13908,34 +13973,26 @@ ${calendarAddUrl.toString()}
    * DS_GATE_NO_TOKEN が持っていて、どちらも dsGateOf を通して取る。ここで文面を
    * 書き写すと、**同じ行の状態バッジと確認結果で語が割れる**（この節で3回直した形）。
    *
+   * **結果の描画は行の関数 1 本（cortex-engine #1328）。** 押した結果は applyProbeResult が
+   * ストアの行と同じ形で LIVE_STATE に置き、行を描き直す。押下の処理は札・時刻・説明文を
+   * 自分で描かない（以前の probeHelpNodes / probeVerdict は撤去した。開き直した行と形が割れ、
+   * 押した直後に 2 回見た目が変わっていた）。
+   *
    * 他アダプタ（Backlog / Figma / Drive）を足すときの拡張点:
    *   - 判定と語彙は infra/lambda/shared/slack-gate.mjs 側に足す（画面は DS_GATE のまま）
-   *   - この節に増やすのは probeHelpNodes の「次の一手」だけ。**アダプタ固有の分岐を
-   *     probeVerdict に入れない**（入れた瞬間に判定が画面側にも生まれる）
-   *   - 送る種別（probeTypeOf）と、行に出す条件（下の extSourceCard）に足す
+   *   - **次の一手は DS_GATE の help（行の常時表示と同じ表）に足す。**この節に判定の分岐を作らない
+   *   - 送る種別（probeTypeOf）・ストアの能力名（probeCapOfType）と、行に出す条件
+   *     （下の extSourceCard）に足す
    *
    * **開発（GitHub）は #234 で足した。** 判定は shared/github-gate.mjs、次の一手は
    * サーバの needed（理由と設定ページのURLを1文で持つ）をそのまま出している
    * ——画面に分岐が生まれないよう、言い分けを全部あちらに置いた
    *
    * **Google Chat は #347 で足した。** 判定は shared/google-chat-gate.mjs で、夜間の実測と
-   * 同じ叩き先・同じスコープで測る。次の一手（googleChatProbeHelpNodes）は行の常時表示と
+   * 同じ叩き先・同じスコープで測る。次の一手は行の常時表示と
    * 同じ表（DS_GATE の help）から引くだけで、画面に判定の分岐は無い
    * ------------------------------------------------------------------------- */
 
-  /**
-   * 確認結果の状態バッジ。**既存の dsGateOf をそのまま通す。**
-   *
-   * こうしておくと no_token の社内/顧客の出し分け（DS_GATE_NO_TOKEN）が確認結果にも
-   * そのまま効く。写経すると、同じ画面で行は「管理者の設定が必要です」・確認結果は
-   * 「トークン未設定」になり、社内チャンネルを登録した人が**また**顧客ワークスペースの
-   * 接続へ吸い込まれる（2026-08-18 の不具合そのもの）。
-   */
-  function probeVerdict(s, r) {
-    // reason は GitHub のテナント外の断り（#841）。無ければ従来どおり
-    return dsGateOf({ type: s.type, workspace: s.workspace, gate: r.gate, reason: r.reason });
-  }
-
   /**
    * 確認したいアダプタの種別（「op=probe」 の 「type」）。**画面の種別をそのまま送らない**
    * ——「github-issues」 / 「github-discussions」 は同じ1つのリポジトリの読み取りで、
@@ -13973,179 +14030,6 @@ ${calendarAddUrl.toString()}
     return p;
   }
 
-  /**
-   * 開発（GitHub）の確認結果の本文（#233 / #234）。
-   *
-   * **理由と対処はサーバが1文で持っている**（「shared/github-gate.mjs」 の 「needed」）。
-   * 「App が入っていない」と「App は入っているがこのリポジトリが選ばれていない」の
-   * 言い分けも、設定ページの URL もあちらが決める——**画面で分岐を書き足さない**
-   * （書いた瞬間に判定が2箇所になり、夜間の実測とボタンでずれる）。
-   * **ただし状態に応じた定型の1文だけは画面の表（DS_GATE_RESTING_HELP の probed）から引く**
-   * （#346 → #356）——「request は組織オーナーの承認待ち」のような GitHub 側の意味は、
-   * サーバの2つの書き手が別々に文を作るので、片方だけ古くなる。
-   *
-   * 🔴 **行の常時表示（resting）を押した結果に繰り返さない（#356）。** 0.12.22 では admin の
-   * 4文が行と押した結果の両方に出ていた。行の1文は押した瞬間に隠れ、needed が同じ操作
-   * （Configure から追加）を宛先つきで言うので、ここは needed が言わない1文だけ
-   */
-  function githubProbeHelpNodes(r) {
-    if (r.gate === "ok") return [];
-    if (r.needed) {
-      var nodes = [neededNode(r.needed)];
-      // 状態に応じた1文は**行と同じ表から引く**（ここに文を直書きすると表と割れる）
-      var probed = probedHelpPartsOf("github", r.gate);
-      if (probed) nodes.push(restingHelpNode(probed, "ds-probe-help"));
-      return nodes;
-    }
-    // needed が無いのは gate に落とし込めなかったとき。**生のエラーは隠さない**
-    return [el("p", { class: "ds-probe-help", text: "GitHub の応答：" + (r.error || "不明") + "。時間をおいて再度お試しください。" })];
-  }
-
-  /**
-   * Google Chat の確認結果の本文（#347）。
-   *
-   * **判定は infra/lambda/shared/google-chat-gate.mjs にしか無い。** ここが返すのは
-   * 「次の一手」だけで、状態の語（バッジ）は probeVerdict が dsGateOf から取る。
-   *
-   * **文を書き写さない。** 「アプリと統合から追加してください」「管理者の設定が済むと…」は
-   * 行の常時表示（DS_GATE の 「help」）が既に持っている——写経すると、同じ行の常時表示と
-   * 押した結果で語が割れる（この節が何度も直してきた形）。DS_GATE から引いて1文だけ出す。
-   *
-   * ⚠ **403（Workspace 管理者の承認待ち）は #521 で「admin_approval_pending」に分類済み。**
-   * 機械語（「permission_denied」）はもう出さない。**「時間をおいて」とも言わない**
-   * ——待っても直らない（管理者が承認するまで同じ応答が返る）。401 / 429 は依然
-   * Phase 0 未採取で「unknown」のまま、サーバの機械語をそのまま出す。
-   */
-  function googleChatProbeHelpNodes(s, r) {
-    // 成功。**1行で終わり**（状態の語が既に「接続OK」と出ている）
-    if (r.gate === "ok") return [];
-    // not_in_space / no_credentials / admin_approval_pending は行の常時表示と同じ文面
-    // （DS_GATE から引く。依頼文の details も gateHelpNodes 経由で同じものが出る）。
-    // 押した瞬間に行側の 「.ds-gate-help」 は隠れるので、二重には出ない
-    var gate = dsGateOf({ type: s.type, gate: r.gate });
-    var nodes = gateHelpNodes(gate, "ds-probe-help");
-    if (nodes.length) return nodes;
-    var p = function (t) { return el("p", { class: "ds-probe-help", text: t }); };
-    if (r.gate === "unreachable") {
-      // 帯（「アクセス不可」）が症状を言っている。**ここは一手だけ**
-      return [p("時間をおいて、もう一度「接続を確認」を押してください。")];
-    }
-    // unknown。**生の機械語を隠さない**——「不明」だけだと切り分けが始められない
-    return [p("Google Chat の応答：" + (r.error || "不明") + "。cortex の担当者にこの語をお伝えください。")];
-  }
-
-  /**
-   * 「アクセス不可」の次の一手（0.12.2・実オンボーディングで踏んだ）。
-   *
-   * ## なぜ2つの導線を併記するのか
-   *
-   * それまでは「見つからないか、アーカイブされています。不要なら登録を解除」だけを
-   * 出していた。**この行がまさに、まだ読めていない主役の行**なのに、
-   * 生きているチャンネルを読めるようにする道が1本も書かれていなかった。
-   *
-   * 原因は**行の分類では絞れない**:
-   *
-   *   - 非公開チャンネルは、招待されるまで「存在しない」と返る（招待で直る）
-   *   - Slack コネクトの共有チャンネルは、**URL がどちらの組織のドメインにもなりうる**。
-   *     だから「クラスメソッド」に分類された行の正しい対処が
-   *     **ワークスペース接続（OAuth）** のこともある
-   *     （実測: 招待しようとしたら「組織外のユーザー」で断られた）
-   *
-   * **どちらかに賭けて片方だけ出すと、外したほうの人は詰まる。** 招待だけを出すと
-   * 何度招待しても直らないものを繰り返させ、接続だけを出すと招待で済む人に
-   * 「直らない処方」を渡す。**両方出して、読む人に選ばせる**のが正しい
-   * （組織不明の案内が同じ判断をしている）。
-   *
-   * ## 社内/顧客で出し分けない
-   *
-   * no_token は出し分けている（社内は画面から設定できるものが本当に無い）が、
-   * こちらは**分類そのものが当てにならない**のが問題の本体なので、
-   * 同じ理屈を持ち込むと直したい誤読を画面の側から作り直すことになる。
-   */
-  function slackUnreachableHelpNodes() {
-    var out = [];
-    out.push(el("p", { class: "ds-probe-help", text: "Cortex からこのチャンネルが見えませんでした。次のどれかです。" }));
-    var ul = el("ul", { class: "ds-probe-help ds-probe-why" });
-    // **押したあと何をするかまで書く。** 直したあと表示が変わらないと「効かなかった」と
-    // 読まれる——この画面の一覧は夜間のスナップショットなので、その場で確かめる手段は
-    // 「接続を確認」をもう一度押すこと以外に無い
-    ul.appendChild(el("li", {
-      text: "非公開チャンネル … 下のコマンドをそのチャンネルに貼って Cortex を招待してから、もう一度「接続を確認」を押してください",
-    }));
-    // 🔴 **指す先の常設ボタンは撤去した（c-07）ので、同じ段にインラインの［接続する］を置く**
-    var connectLi = el("li", {
-      text: "お客様の Slack、または Slack コネクトで共有されたチャンネル … "
-        + "［接続する］から、そのワークスペースに Cortex を追加するリクエストを送ってください。"
-        + "接続できたら、もう一度「接続を確認」を押してください",
-    });
-    var connectBtn = actNode("connect");
-    if (connectBtn) connectLi.appendChild(connectBtn);
-    ul.appendChild(connectLi);
-    ul.appendChild(el("li", {
-      text: "アーカイブ・削除された、URL が違う … 「登録を解除」を押してください",
-    }));
-    out.push(ul);
-    // **手で打たせない**（copyRow のコメント）。招待の候補を出したなら、
-    // そのコマンドも同じ場所に無いと、貼る文字列を探しに行くことになる
-    out.push(copyRow("/invite @Cortex"));
-    return out;
-  }
-
-  /**
-   * 判定ごとの表示。**成功は1行で終わらせ、失敗は「理由＋次の一手」だけを残す。**
-   *
-   * ## 短くした理由（2026-08-19・オーナー指示）
-   *
-   * 「接続を確認を押して出てくる文言が長ったらしい」。実際、成功時に4行出ていた。
-   * **成功時は「読めている」以上の情報が要らない。**
-   *
-   * ## ただし失敗時は削りすぎない
-   *
-   * 短くしすぎると、今日と同じ「画面を見ても次に何をすればいいか決まらない」状態に戻る
-   * （それで半日かかった）。落とすのは**内部の仕組みの説明**——「設定ファイルの表示名だけが
-   * 書き換わります」「読み取りの対象・範囲は変わりません」のような、読む人の次の行動を
-   * 変えない文。残すのは「何が起きているか」と「次に何をするか」だけ。
-   *
-   * 状態の語そのものは DS_GATE / DS_GATE_NO_TOKEN が持つ（probeVerdict 経由）ので、
-   * ここが返すのは**それに足りない分だけ**。二重に言わない。
-   *
-   * @returns 本文に並べるノード（0〜2個）
-   */
-  function probeHelpNodes(s, r) {
-    var p = function (t) { return el("p", { class: "ds-probe-help", text: t }); };
-    if (probeTypeOf(s.type) === "github") return githubProbeHelpNodes(r);
-    if (probeTypeOf(s.type) === "google-chat") return googleChatProbeHelpNodes(s, r);
-    // 成功。**1行で終わり。** 状態の語（「接続OK」）が既に出ているので本文は空
-    if (r.gate === "ok") return [];
-    if (r.gate === "not_in_channel") {
-      // 状態の語が「Slackで招待してください」なので、説明は足さずコマンドだけ出す。
-      // **手で打たせない**——打ち間違いは黙って失敗し、「招待したのに読まれない」に見える
-      return [copyRow("/invite @Cortex")];
-    }
-    if (r.gate === "missing_scope") {
-      // 不足スコープは頭のバッジ横に出る（probeSection）。ここは次の一手だけ
-      return [p("招待では直りません。cortex の担当者にこのスコープ名をお伝えください。")];
-    }
-    if (r.gate === "no_token") {
-      // **社内/顧客の出し分けは変えない。** 社内は画面から設定できるものが無いので
-      // 連絡先、顧客は接続へ誘導する（2026-08-18 の不具合の再発防止）。
-      // 長い説明は落とし、次の行動の1行だけ残す
-      if (isInternalSlack(s)) return [p("cortex の担当者にご連絡ください。")];
-      // 常設のボタンは撤去した（c-07）。同じ段にインラインの［接続する］を置く
-      var connectP = p("この Slack を Cortex に接続してください。");
-      var connectNow = actNode("connect");
-      if (connectNow) connectP.appendChild(connectNow);
-      return [connectP];
-    }
-    if (r.gate === "unreachable") {
-      // **ここだけ本文が2つ以上になる（0.12.2）。** 原因が3つあり、しかも
-      // 行の分類では絞れないので、候補と導線を並べる（関数側に理由がある）
-      return slackUnreachableHelpNodes();
-    }
-    // unknown。**生のエラーは隠さない**——「不明」だけだと切り分けが始められない
-    return [p("Slack の応答：" + (r.error || "不明") + "。時間をおいて再度お試しください。")];
-  }
-
   /**
    * 表示名を Slack の実名へ**自動で揃える**（2026-08-19・オーナー判断）。
    *
@@ -14188,6 +14072,9 @@ ${calendarAddUrl.toString()}
       // 一覧は夜間のスナップショットなので、その場では変わらない。行だけ追いつかせる
       var nameEl = card.querySelector(".ds-name");
       if (nameEl) nameEl.textContent = slackDisplayName(r.name);
+      // 押した結果で行が描き直されていると、上の card は切り離されている。仮置き（notePendingOp）から描き直す
+      repaintOpenLists();
+      refreshDataSources();
     }).catch(function () { /* 揃えられなくても疎通確認の結果は出したまま */ });
   }
 
@@ -14214,32 +14101,25 @@ ${calendarAddUrl.toString()}
    *
    * @returns { btn, detail } btn は行に、detail は行の下に置く
    */
-  function probeSection(s, card, gateEl) {
+  function probeSection(s, card) {
     var btn = el("button", { class: "ds-toggle-btn", type: "button", text: "接続を確認" });
     var wrap = el("div", { class: "ds-probe" });
     var head = el("div", { class: "ds-probe-head" });
+    // 失敗の 1 文だけをここへ出す。**結果（判定・時刻・次の一手）は行そのものが持つ**
     var msg = el("span", { class: "ds-toggle-msg" });
-    var at = el("span", { class: "ds-probe-at" });
-    var body = el("div");
     head.appendChild(msg);
-    head.appendChild(at);
     wrap.appendChild(head);
-    wrap.appendChild(body);
 
     btn.addEventListener("click", async function () {
       var intake = SITE.intake;
       if (!intake) return;
-      // 押している間はボタンごと「確認中…」にする（#222・beginBusy の項）。
-      // **語は下の ds-toggle-msg と揃える**——同じ操作を2つの語で言わない
+      // 押している間は**ボタンだけ**が「確認中…」になる（#222・beginBusy の項）。
+      // 🔴 行の中身は変えない——ここで札・時刻・説明文を別の形で描くと、結果が出たあとの
+      // 行（開き直したときと同じ形）と 2 回見た目が変わる（cortex-engine #1328 のちらつき）
       var endBusy = beginBusy(btn, "確認中…");
-      // **押されて初めて枠を出す（2026-08-20・オーナー指摘）。**
-      // それまでは中身が空でも点線だけが全行に出ており、**何も意味していなかった**。
-      // 押した結果があるときだけ、行と結果を分ける線になる
-      wrap.className = "ds-probe is-shown";
+      wrap.className = "ds-probe";
       msg.className = "ds-toggle-msg";
-      msg.textContent = "確認中…";
-      at.textContent = "";
-      body.textContent = "";
+      msg.textContent = "";
       // **種別はサーバの語彙に畳む**（github-issues / github-discussions → github）。
       // ワークスペースは Slack にしか無い概念なので、他アダプタでは載せない
       var payload = { type: probeTypeOf(s.type), ref: s.ref };
@@ -14249,69 +14129,31 @@ ${calendarAddUrl.toString()}
         var j = await res.json().catch(function () { return {}; });
         if (!res.ok) {
           // サーバの文言をそのまま出す（回数制限の案内・未対応のアダプタの説明を含んでいる）
+          wrap.className = "ds-probe is-shown";
           msg.className = "ds-toggle-msg is-error";
           msg.textContent = "✗ " + (j.message || "確認できませんでした。");
           endBusy();
           return;
         }
-        msg.className = "ds-toggle-msg" + (j.gate === "ok" ? " is-ok" : " is-error");
-        msg.textContent = j.gate === "ok" ? "✓" : "✗";
-        var v = probeVerdict(s, j);
-        gateEl.className = "ds-gate " + v.cls;
-        gateEl.textContent = v.text;
-        // 🔴 **「活動を記録中」の札も、押した結果で出し入れする（#660）。** ここを忘れると、
-        // アクセス不可の行を直して押したときに**行は「接続OK」なのに札だけ消えたまま**に
-        // なり、「決定の材料になっている」と読める（逆向きも同じで、届かなくなった行が
-        // 「記録中」と言い続ける）。**判定は 「devExcludedBadgeVisible」 1 本**——
-        // 描画時と押した後で別の条件を書くと、同じ行が 2 つのことを言う
-        var exBadgeNow = card.querySelector(".badge.ds-not-ingested");
-        if (exBadgeNow) {
-          exBadgeNow.hidden = !devExcludedBadgeVisible({
-            ingestExcluded: s.ingestExcluded, goldState: s.goldState, gate: j.gate,
-          });
-        }
-        // 古い「X分前に確認」を残さない（下に出るいまの結果と、時刻が2つ並ぶ）
-        var oldAt = card.querySelector(".ds-gate-at");
-        if (oldAt) oldAt.remove();
-        // 古い run の導線も残さない（#560）。「いま測った結果」の横に夜間の run のログが並ぶ形になる
-        removeRunTrail(card);
-        // 🔴 **古いスコープ名の札も必ず消してから出し直す。** 行には夜間の判定に添えた
-        // 札が出ていることがあり（段B）、置き換えた「接続OK」の横に古いスコープ名が
-        // 残ると、同じ行が2つのことを言う——この節が何度も直してきた形そのもの。
-        // 押し直すたびに札が増えていくのも、まとめてここで断つ
-        var oldScopes = card.querySelectorAll(".ds-probe-scope");
-        for (var oi = 0; oi < oldScopes.length; oi++) oldScopes[oi].remove();
-        // 不足スコープは**状態の語のすぐ横**に出す（「権限が足りません：groups:read」）。
-        // 本文へ落とすと、いちばん要る情報が説明文に埋もれる。
-        // ⚠ **札にするのは Slack のスコープ名だけ。** GitHub の needed は URL 込みの
-        // 一文なので、札に押し込むとバッジの横で折り返して読めない（本文へ出す）
-        if (j.gate === "missing_scope" && probeTypeOf(s.type) === "slack") {
-          head.appendChild(el("code", { class: "ds-probe-scope", text: j.needed || "不明" }));
-        }
-        at.textContent = "いま測った結果（" + (dsFmtTime(j.checkedAt) || "たった今") + "）";
-        probeHelpNodes(s, j).forEach(function (n) { body.appendChild(n); });
-        // **夜間の判定に添えてあった案内は隠す。** 置き換えた判定と食い違う案内が
-        // 下に残ると、同じ行に2つのことが書いてある状態になる。
-        // **1つ目だけでなく全部隠す（#346）。** 理由文（.ds-gate-reason）・定型補足
-        // （.ds-gate-resting）・DS_GATE の help のどれが付いていても、押した結果と
-        // 食い違う案内を残さない
-        var stale = card.querySelectorAll(".ds-gate-help");
-        for (var si = 0; si < stale.length; si++) stale[si].hidden = true;
         // 表示名を Slack の実名へ自動で揃える（差分表示も更新ボタンも出さない）。
         // **GitHub は揃えない。** 行の名前は owner/repo そのもので、書き換える口
         //（op=config の refresh-channel-name）は channels.json 専用
         if (s.type === "slack") autoAlignName(s, j, card);
-        // ストアにも 「button」 の行が書かれている（#576）。**取りに行くのは 1 回だけ**——
-        // 届いた行でモーダルを閉じたときにタイルが引き直され、登録直後のタイルが行と同じ
-        // 「接続OK」になる（「pendingTileVerdict」）。ここで取らないと、画面がストアの行を
-        // 読むのは次の op=state（追加行が未確定の 15 分間は 60 秒ごと・過ぎていれば
-        // 再読み込みまで）で、「接続を確認 → 閉じる → その場で接続OK」にならない。
-        // 据え置きあり＝GitHub は叩かない（ストアの行は据え置きの対象外で毎回引く）。
-        // 取り込む能力の即答（appendDispatchProbe）は先に同じ 1 行を持っている
-        // 同じリポジトリの兄弟の行（issues / discussions）も同じ判定にそろえる
-        if (probeTypeOf(s.type) === "github") syncGithubSiblingRows(card, s.ref, j.gate === "ok");
-        reloadLiveState();
+        // 🔴 **結果は、ストアの行と同じ形で LIVE_STATE に置いて、行を描き直す**（applyProbeResult）。
+        // 判定・時刻・「活動を記録中」の札・スコープ名の札・次の一手・兄弟の行（issues /
+        // discussions）の判定は、全部この描き直しが決める。ここで DOM を別の形で書き足すと、
+        // 開き直した行と形が割れる（#1328）
+        try {
+          applyProbeResult(probeCapOfType(s.type), s.ref, s.workspace || "", {
+            gate: j.gate,
+            checkedAt: j.checkedAt,
+            needed: j.needed || "",
+            // サーバがストアへ書く値と同じ（op=probe の保存側の項）
+            detail: j.reason || j.error || (j.gate === "ok" ? "" : j.gate),
+          });
+        } catch (drawErr) { /* 描き直しの不調を「通信に失敗」と言わない（測れた事実は取れている）。続く読み直しに任せる */ }
       } catch (e) {
+        wrap.className = "ds-probe is-shown";
         msg.className = "ds-toggle-msg is-error";
         msg.textContent = "✗ 通信に失敗しました。";
       }
@@ -14320,6 +14162,84 @@ ${calendarAddUrl.toString()}
     return { btn: btn, detail: wrap };
   }
 
+  /**
+   * 押した直後の結果を、**接続状態ストアの行と同じ形**で LIVE_STATE に置き、一覧を描き直す。
+   *
+   * 🔴 **行の見た目を決める関数は、開き直したときと同じ 1 本（extSourceCard など）。** 押下の処理は
+   * 札・時刻・説明文を自分で描かない。以前は押下が「いま測った結果」の枠を先に描き、直後の
+   * reloadLiveState で行がいつもの形に描き直されて、2 回見た目が変わっていた（cortex-engine #1328）。
+   *
+   * 形はサーバが書く行（by が button の行）と同じに揃える。続く reloadLiveState が本物の行で
+   * 置き換えても DOM は変わらない。**語彙に無い値は行ごと落とす**（sanitizeStateNow）——
+   * その場合は描き直しの代わりに reloadLiveState に任せる。
+   *
+   * @param capId 接続状態ストアの能力名（chat / google-chat / dev / issues / materials / design）
+   * @param r { gate, checkedAt, needed, detail }
+   */
+  function applyProbeResult(capId, ref, workspace, r) {
+    var row = {
+      cap: capId, question: "reachable", ref: String(ref), status: String(r.gate || ""),
+      at: r.checkedAt ? String(r.checkedAt) : new Date().toISOString(),
+      by: "button", needed: String(r.needed || ""), detail: String(r.detail || ""),
+    };
+    if (workspace) row.workspace = String(workspace);
+    var want = stateRefKey(capId, ref, workspace);
+    var next = (LIVE_STATE || []).filter(function (x) {
+      return !(x && x.cap === capId && x.question === "reachable" && stateRefKey(capId, x.ref, x.workspace) === want);
+    });
+    next.push(row);
+    var clean = sanitizeStateNow(next);
+    // 行が語彙に無く落ちたときは据え置き（reloadLiveState が本物を持ってくる）
+    if (clean && clean.some(function (x) { return x.cap === capId && x.question === "reachable" && x.at === row.at && stateRefKey(capId, x.ref, x.workspace) === want; })) {
+      // 押した結果の控え。**すでに飛んでいる読み直し（押す前の行を返す）や、保存が追いつく前の読み直しが
+      // 届いても、行が古い判定へ戻らない**ように、本物の行が追いつくまで重ねる（「mergeProbeLocal」）
+      PROBE_LOCAL[capId + "\t" + want] = { row: row, t: Date.now() };
+      LIVE_STATE = clean;
+      MERGED = null;
+      repaintOpenLists();
+      refreshDataSources();
+    }
+    // 本物の行を 1 回だけ取りに行く（据え置きのまま・「reloadLiveState」の項）
+    reloadLiveState();
+  }
+
+  /** 押した結果の行の控え（鍵は 能力＋畳んだ ref）。本物の行が同じ時刻以降で届いたら捨てる */
+  var PROBE_LOCAL = {};
+  /**
+   * 読み直しで届いた LIVE_STATE に、まだ追いつかれていない押した結果を重ねる。
+   * 🔴 重ねないと、押した瞬間に飛んでいた読み直し（押す前の行）が届いた回だけ、行が古い判定に戻る（#1328）
+   */
+  function mergeProbeLocal() {
+    var keys = Object.keys(PROBE_LOCAL);
+    if (!keys.length) return;
+    var rows = (LIVE_STATE || []).slice();
+    keys.forEach(function (k) {
+      var local = PROBE_LOCAL[k].row;
+      // 10 分たっても本物が追いつかなければ控えを捨てる（本物の行に任せる）
+      if (Date.now() - PROBE_LOCAL[k].t > 10 * 60 * 1000) { delete PROBE_LOCAL[k]; return; }
+      var want = stateRefKey(local.cap, local.ref, local.workspace);
+      var caught = false;
+      for (var i = 0; i < rows.length; i++) {
+        var x = rows[i];
+        if (x && x.cap === local.cap && x.question === "reachable" && stateRefKey(x.cap, x.ref, x.workspace) === want) {
+          if (String(x.at) >= String(local.at)) caught = true;
+          else rows.splice(i, 1);
+          break;
+        }
+      }
+      if (caught) { delete PROBE_LOCAL[k]; return; }
+      rows.push(local);
+    });
+    LIVE_STATE = sanitizeStateNow(rows);
+  }
+
+  /** 画面の種別 → 接続状態ストアの能力名（「接続を確認」の行） */
+  function probeCapOfType(type) {
+    if (String(type || "").indexOf("github") === 0) return "dev";
+    if (type === "google-chat") return "google-chat";
+    return "chat";
+  }
+
   function removeChannelButton(s, card) {
     return removeButton({
       label: "登録を解除",
@@ -14565,7 +14485,7 @@ ${calendarAddUrl.toString()}
     }
     var ipLabel = ip ? "固定の送信元 IP（" + ip + "）" : "固定の送信元 IP";
     if (keyState === "no") {
-      return "同期は" + ipLabel + "から行います。お客様にこの IP の許可を依頼し、上の「Backlog のAPIキー」を登録すると同期が始まります。";
+      return "同期は" + ipLabel + "から行います。お客様にこの IP の許可を依頼し、接続先の行の「API キーを入れてください」から登録すると同期が始まります。";
     }
     // 2 文に収める（実装レビューの指摘）。押した直後の帯（サーバの文面）も「許可を依頼」を言うが、
     // 帯は数秒で読み終える結果で、この行は次に開いたときも残る状態——役目が違うので両方に置く
@@ -14635,16 +14555,9 @@ ${calendarAddUrl.toString()}
         // 切り替えていた）はサーバが changed:false・route 無しで返すので、onDone だと
         // スイッチが古い向きのまま「✓ 変更はありません」が出て、次の取り直しまで直らない。
         // onSaved は res.ok なら changed を問わず流れる（冪等な op の受け口）
-        await sendConfig({ op: "backlog-route-set", route: next ? "fixed-ip" : "runner" }, msg, null, null, {
-          onSaved: function (j) {
-            // **応答の値を正とする。** 無ければ送った向き（サーバは断らなかった＝正本はその向き）
-            LIVE_BACKLOG_ROUTE = backlogRouteOf(j && j.route) || (next ? "fixed-ip" : "runner");
-            if (j && j.fixedEgressIp) LIVE_FIXED_IP = String(j.fixedEgressIp);
-            live.__rebuild();
-            // changed:false では sendConfig が読み直しを起こさない。正本の値で画面を揃えるために自分で起こす
-            if (j && j.changed === false) loadLiveFleet(true);
-          },
-        });
+        // 🔴 **操作は setBacklogRoute に 1 本化している（タイルの［切り替える］と同じ関数）。**
+        // 応答の値を正とする・changed:false では取り直す・確認ダイアログは出さない（A4）は、そちらが持つ
+        await setBacklogRoute(next, msg, { after: function () { live.__rebuild(); } });
         // 断られた・通信に失敗したときはこのボタンが残っている（成功時は描き直されて外れている）
         btn.disabled = disabled;
         btn.classList.remove("is-busy");
@@ -14654,9 +14567,332 @@ ${calendarAddUrl.toString()}
     });
     wrap.appendChild(live);
     wrap.appendChild(msg);
+    // 節が当て直すための口（「その他」の中のスイッチ・c-07 の 2 本目）
+    wrap.__live = live;
     return wrap;
   }
 
+  /* ---------------------------------------------------------------------------
+   * Backlog の窓を、GitHub・Figma・Slack・Google Drive・Google Chat の窓にそろえる（c-07 の 2 本目）
+   *
+   * 考え方は 4 つ（GitHub の窓 #1233・4 窓 #1257 と同じ）:
+   *   1. 追加の欄は入力と［追加］だけ
+   *   2. 前提が足りないと分かったタイルの中にだけ、理由に合った一手を 1 行で出す
+   *   3. 窓全体を囲む箱・常設の欄を出さない（キーの欄・IP 制限のスイッチ・リアルタイムの大きな箱は引っ込めた）
+   *   4. 説明は上部の説明文に 1 回だけ
+   *
+   * 部品の置き場:
+   *   - 一手 … DS_GATE_RESTING_HELP.backlog → backlogRowHelpParts（行の中身で決まる）
+   *   - キーの欄 … これまでと同じスペースごとの受け皿（KEY_SLOTS.backlog・#223）に同じカード。
+   *     変えるのは見え方だけ（syncKeyCardVisibility の backlogKeyCardWanted）
+   *   - 同期経路の切り替え … setBacklogRoute に 1 本化。入口はタイルの一手・［接続を確認］の結果・「その他」のスイッチ
+   *   - 札（事実）… 経路札「固定 IP 経由」・リアルタイム札（appendBacklogChips）
+   * ------------------------------------------------------------------------- */
+
+  /**
+   * 節（backlogTargetsSection）がいま描いている行と、結果の帯・行の描き直しの口。
+   * 一手の文・鍵カードの見え方・ボタンが、節の外から引くための置き場（節を作り直すたびに入れ替わる）。
+   * 🔴 **鍵の置き場の正本は KEY_SLOTS。ここは行の控えだけ**（#223 の「節の中に受け皿の控えを持たない」は守る）。
+   */
+  var BACKLOG_UI = { rows: [], msg: null, repaintRows: null };
+
+  /** いま見えている行のスペース（小文字・重複なし） */
+  function backlogDomainsNow() {
+    var out = [];
+    var rows = BACKLOG_UI.rows || [];
+    for (var i = 0; i < rows.length; i++) {
+      var d = String(rows[i].domain || "").toLowerCase();
+      if (d && out.indexOf(d) < 0) out.push(d);
+    }
+    return out;
+  }
+
+  /** そのスペースの行のどれかが、届くかを測られているか */
+  function backlogSpaceMeasured(domain) {
+    var rows = BACKLOG_UI.rows || [];
+    for (var i = 0; i < rows.length; i++) {
+      if (String(rows[i].domain || "").toLowerCase() !== domain) continue;
+      if (reachableStateOf("issues", issuesRefOf(rows[i].domain, rows[i].projectKey))) return true;
+    }
+    return false;
+  }
+
+  /** 正本（secretsNow）に、そのスペースの行が来ているか（unknown の行も数える） */
+  function backlogSecretsRowFor(domain) {
+    var rows = LIVE_SECRETS;
+    if (!Array.isArray(rows)) return false;
+    for (var i = 0; i < rows.length; i++) {
+      if (rows[i] && rows[i].kind === "backlog" && rows[i].space === domain) return true;
+    }
+    return false;
+  }
+
+  /**
+   * そのスペースに「API キーを入れてください」を出すか。**カードの見え方（2.4）と行の一手が同じ 1 本を通る。**
+   *   - 登録状況が「未登録」→ 出す（正本が言うので、行の札が古くても従う）
+   *   - 登録状況が分からない（複数スペースで答えが無い）とき:
+   *       · その行の札が「APIキーが未登録です」→ 出す
+   *       · 🔴 **そのスペースの答えの行が無く、どの行も測られていない → 出す**（足した直後の新しいスペース。
+   *         ここを隠すと、足した行に鍵を入れる口がどこにも無い＝#223・#138 の再発）。見せる側に倒す
+   *   - 登録済み → 出さない（前夜の古い札には従わない）
+   * @param gate その行の届くかの状態（無ければ null）
+   */
+  function backlogKeyNeeded(domain, gate) {
+    var st = secretStateOf("backlog", domain, backlogDomainsNow().length);
+    if (st.known === "no") return true;
+    if (st.known === "unknown") {
+      if (gate === "no_token") return true;
+      if (!backlogSpaceMeasured(domain) && !backlogSecretsRowFor(domain)) return true;
+    }
+    return false;
+  }
+
+  /** そのスペースの鍵カードを見せるか（行のどれかが要るか。行が無ければ要らない） */
+  function backlogKeyNeededForSpace(space) {
+    var domains = backlogDomainsNow();
+    var dom = space || (domains.length === 1 ? domains[0] : "");
+    if (!dom) return false;
+    var rows = BACKLOG_UI.rows || [];
+    for (var i = 0; i < rows.length; i++) {
+      if (String(rows[i].domain || "").toLowerCase() !== dom) continue;
+      var r = reachableStateOf("issues", issuesRefOf(rows[i].domain, rows[i].projectKey));
+      if (backlogKeyNeeded(dom, r ? r.status : null)) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Backlog の行に出す一手のパーツ（無ければ null）。**スペースをまたがない**（ボタンはその行のスペースの受け皿だけを引く）。
+   *
+   *   キーが要る        → 「API キーを入れてください。［入れる］」（複数スペースならスペース名つき）
+   *   読めない・通常経路 → 「読めません。API キーを入れ直してください。［入れ直す］ Backlog に IP 制限があるなら、固定 IP 経由で読んでください。［切り替える］」
+   *   読めない・固定 IP  → 「お客様に固定の送信元 IP（…）の許可を依頼してください。［コピー］ 許可済みなら、API キーを入れ直してください。［入れ直す］」
+   *   読めない・経路不明 → 「読めません。API キーを入れ直してください。［入れ直す］」（切り替えが押せるか分からないので［切り替える］は出さない）
+   *
+   * 🔴 **理由の語（HTTP の番号等）には依存しない。** 401・403・404 は画面から見分けられないので、読めない行は広い方の 1 行。
+   * IP 制限と確定できるのは［接続を確認］の応答の reason だけ（appendBacklogProbeSwitch）。
+   * 🔴 **投入の口（SITE.intake）が無い案件では出さない**（押せない案内を置かない）。
+   * @param row { domain, projectKey, gate }
+   */
+  function backlogRowHelpParts(row) {
+    if (!row || !SITE.intake) return null;
+    var dom = String(row.domain || "").toLowerCase();
+    var multi = backlogDomainsNow().length > 1;
+    if (backlogKeyNeeded(dom, row.gate)) {
+      return [(multi ? dom + " の " : "") + "API キーを入れてください。", { act: "backlog-key", space: dom, label: "入れる" }];
+    }
+    if (row.gate !== "unreachable") return null;
+    var reenter = { act: "backlog-key", space: dom, label: "入れ直す" };
+    var route = LIVE_BACKLOG_ROUTE;
+    if (route === "fixed-ip") {
+      // IP が取れていなければ IP も［コピー］も出さない（嘘の値を書かない・#516）
+      var ip = LIVE_FIXED_IP;
+      var head = ip
+        ? ["お客様に固定の送信元 IP（" + ip + "）の許可を依頼してください。", { copy: ip, bare: true }]
+        : ["お客様に固定の送信元 IP の許可を依頼してください。"];
+      return head.concat([" 許可済みなら、API キーを入れ直してください。", reenter]);
+    }
+    var base = ["読めません。API キーを入れ直してください。", reenter];
+    if (route === "runner") {
+      // 切り替えは案件全体の経路（スペースごとではない）。複数スペースでは強めに言う
+      var scope = multi
+        ? "この案件の Backlog 全体（すべてのスペース）の読み方が変わります。"
+        : "この案件の Backlog 全体の読み方が変わります。";
+      return base.concat([" Backlog に IP 制限があるなら、固定 IP 経由で読んでください。" + scope, { act: "backlog-route-on", label: "切り替える" }]);
+    }
+    return base;
+  }
+
+  /**
+   * Backlog の行の最後に一手を 1 段だけ足す。**一手を出した回は engine の理由文を重ねない**（行の補足は最大 1 段）。
+   * 一手が無い状態（読めている・測っていない・取り込みの失敗など）は、これまでどおり appendReachableReason に任せる。
+   */
+  function appendBacklogRowHelp(row, t, ref) {
+    var r = reachableStateOf("issues", ref);
+    var gate = r ? r.status : null;
+    var info = { domain: t.domain, projectKey: t.projectKey, gate: gate };
+    // 読めない・鍵が無い札は表（DS_GATE_RESTING_HELP.backlog）から、それ以外（読めている・測っていない）は
+    // 「鍵が要るか」だけを見る（登録状況の正本が言うので、行の札が古くても従う）
+    var parts = gate === "no_token" || gate === "unreachable"
+      ? restingHelpPartsOf("backlog", gate, info)
+      : backlogRowHelpParts(info);
+    if (parts) {
+      row.appendChild(restingHelpNode(parts, "ds-gate-help ds-gate-resting"));
+      return row;
+    }
+    return appendReachableReason(row, "issues", ref);
+  }
+
+  /** そのスペースの鍵の受け皿（無ければ null）。名無しの受け皿は、スペースが 1 つ以下のあいだだけ代わりを務める（ensureKeySlots の項） */
+  function backlogKeySlotFor(space) {
+    var slots = KEY_SLOTS.backlog || {};
+    var d = String(space || "").toLowerCase();
+    if (d && slots[d]) return slots[d];
+    if (slots[""] && backlogDomainsNow().length <= 1) return slots[""];
+    return null;
+  }
+
+  /** そのスペースの鍵カードの控え（無ければ null）。**ほかのスペースのカードへ落とさない** */
+  function backlogKeyEntryFor(space) {
+    var d = String(space || "").toLowerCase();
+    var list = [];
+    for (var i = 0; i < KEY_CARDS.length; i++) {
+      if (KEY_CARDS[i].kind === "backlog" && KEY_CARDS[i].compact) list.push(KEY_CARDS[i]);
+    }
+    for (var j = 0; j < list.length; j++) if (d && list[j].space === d) return list[j];
+    if (backlogDomainsNow().length <= 1) {
+      for (var k = 0; k < list.length; k++) if (list[k].space === "") return list[k];
+    }
+    return null;
+  }
+
+  /** そのスペースの鍵カードを見せて、入力へ移る（［入れる］・［入れ直す］）。見つからなければ false */
+  function openBacklogKeyCard(space) {
+    var ent = backlogKeyEntryFor(space);
+    if (!ent) return false;
+    ent.forced = true;
+    ent.fold.open = true;
+    syncKeyCardVisibility();
+    try { if (ent.input.scrollIntoView) ent.input.scrollIntoView({ block: "center" }); } catch (e) { /* 動かせなくても focus は試す */ }
+    ent.input.focus();
+    return true;
+  }
+
+  /**
+   * ［入れる］／［入れ直す］。**そのスペースの受け皿が無ければ作らない**（別のスペースの欄へ移さない）。
+   * 🔴 **作る条件は受け皿（KEY_SLOTS）だけ。カードの控えは押した時点で引く**——節は鍵カードより先に組み立てられる
+   *（buildDataSources の順序）ので、行を描く時点ではカードがまだ無い。受け皿は節が先に作っている
+   */
+  function backlogKeyJump(space, label) {
+    if (secretKindsShown().indexOf("backlog") < 0) return null;
+    if (!backlogKeySlotFor(space)) return null;
+    var btn = el("button", { class: "ds-toggle-btn ds-act-inline", type: "button", text: label || "入れる" });
+    btn.addEventListener("click", function () { openBacklogKeyCard(space); });
+    return btn;
+  }
+
+  /**
+   * 同期経路の切り替え（固定 IP 経由 ⇄ 通常）。**スイッチ（「その他」）とタイルの［切り替える］が同じこの関数を呼ぶ**
+   * ——操作を 2 本書かない（op・値・確認なし・応答の route を正とする・changed:false の取り直しは 1 つだけ持つ）。
+   * 🔴 **確認ダイアログは出さない（#503 A4）。** 可逆（「その他」のスイッチで戻せる）・押した記録はサーバの監査に残る。
+   * @param next    true＝固定 IP 経由にする
+   * @param msgEl   結果の帯（一覧の外に置いたもの。描き直しで消えない）
+   * @param opts    { after: 成功後に呼ぶ（スイッチの描き直し）, hint: 成功した帯に添える 1 文 }
+   */
+  function setBacklogRoute(next, msgEl, opts) {
+    return sendConfig({ op: "backlog-route-set", route: next ? "fixed-ip" : "runner" }, msgEl, null, null, {
+      onSaved: function (j) {
+        // **応答の値を正とする。** 無ければ送った向き（サーバは断らなかった＝正本はその向き）
+        LIVE_BACKLOG_ROUTE = backlogRouteOf(j && j.route) || (next ? "fixed-ip" : "runner");
+        if (j && j.fixedEgressIp) LIVE_FIXED_IP = String(j.fixedEgressIp);
+        if (opts && typeof opts.after === "function") opts.after();
+        // 札・一手は行にあるので、行も描き直す（接続先の集合は触らない）
+        if (typeof BACKLOG_UI.repaintRows === "function") BACKLOG_UI.repaintRows();
+        if (opts && opts.hint && LIVE_BACKLOG_ROUTE === "fixed-ip" && !(j && j.changed === false)) {
+          msgEl.appendChild(document.createTextNode(" " + opts.hint));
+        }
+        // changed:false では sendConfig が読み直しを起こさない。正本の値で画面を揃えるために自分で起こす
+        if (j && j.changed === false) loadLiveFleet(true);
+      },
+    });
+  }
+
+  /** 読めなかったタイルの［切り替える］。結果は一覧の外の帯（節の msg）に出す。成功したら行が描き直されてこのボタンは外れる */
+  function backlogRouteOnButton(label) {
+    var btn = el("button", { class: "ds-toggle-btn ds-act-inline", type: "button", text: label || "切り替える" });
+    btn.addEventListener("click", async function () {
+      if (btn.disabled) return;
+      var msg = BACKLOG_UI.msg;
+      if (!msg) return;
+      btn.disabled = true;
+      btn.classList.add("is-busy");
+      await setBacklogRoute(true, msg, { hint: "元に戻すには、下の「その他」から同期経路を切り替えてください。" });
+      // 断られた・通信に失敗したときはこのボタンが残っている
+      btn.disabled = false;
+      btn.classList.remove("is-busy");
+    });
+    return btn;
+  }
+
+  /**
+   * ［接続を確認］の結果が IP 制限（応答の reason が ip-restricted）で、いまが通常の経路のときだけ、
+   * 結果の文の横に［切り替える］を足す。**IP 制限と確定できるのはこの応答だけ**（行の札からは見分けられない）。
+   */
+  function appendBacklogProbeSwitch(note, capId, j) {
+    if (capId !== "issues" || !j || j.reason !== "ip-restricted") return;
+    if (!SITE.intake || LIVE_BACKLOG_ROUTE !== "runner") return;
+    note.appendChild(document.createTextNode(" "));
+    note.appendChild(backlogRouteOnButton("切り替える"));
+  }
+
+  /**
+   * リアルタイム同期（Backlog Webhook）の受信の事実。専用 URL が無い案件は null（出さない）。
+   * **ready でないうちは受信実績を読まない**（索引の行が無いのに lastEventAt だけ来ていても信じない）。
+   * **時刻が読めない値は稼働中に数えない。**
+   */
+  function backlogRealtimeFacts() {
+    var wh = SITE.backlogWebhook;
+    if (!wh || !wh.url || !wh.token) return null;
+    var rt = LIVE_REALTIME;
+    var ready = !!(rt && rt.ready);
+    var receipts = (ready && rt.targets ? rt.targets : []).map(function (t) {
+      return { key: t && t.projectKey ? String(t.projectKey).toLowerCase() : "", ago: t && t.lastEventAt ? rtAgo(t.lastEventAt) : "" };
+    });
+    return {
+      receipts: receipts,
+      anyLive: receipts.some(function (r) { return !!r.ago; }),
+      viaFixedIp: !!(rt && rt.via === "fixed-ip"),
+    };
+  }
+
+  /** プロジェクトキーが同じ行が、いまの一覧にいくつあるか（受信実績はスペースを持たない） */
+  function backlogKeyRowCount(projectKey) {
+    var key = String(projectKey || "").toLowerCase();
+    var n = 0;
+    var rows = BACKLOG_UI.rows || [];
+    for (var i = 0; i < rows.length; i++) if (String(rows[i].projectKey || "").toLowerCase() === key) n++;
+    return n;
+  }
+
+  /** その行のキーの受信時刻（読めるもの）。無ければ空文字 */
+  function backlogRowReceiptAgo(facts, projectKey) {
+    var key = String(projectKey || "").toLowerCase();
+    for (var i = 0; i < facts.receipts.length; i++) {
+      if (facts.receipts[i].key === key && facts.receipts[i].ago) return facts.receipts[i].ago;
+    }
+    return "";
+  }
+
+  /**
+   * 行に足す札（状態ではなく事実）。**ds-gate クラスは付けない**（「.ds-gate は届くか札 1 つ」の見張りを壊さない）。
+   *   - 経路札「固定 IP 経由」… 同期経路が固定 IP のとき（案件単位なので全行に出る）
+   *   - リアルタイム札「稼働中」… その行のキーの受信実績があるとき
+   *   - リアルタイム札「未受信」… **他の行に稼働があって**この行に受信が無いとき（増やした接続先が来ていないことに気づける・#123）
+   * 🔴 **プロジェクトキーが複数の行で重なるときはリアルタイム札を出さない**（どのスペースの受信か決まらない＝嘘を言わない）。
+   * 投入の口が無い案件には出さない。
+   */
+  function appendBacklogChips(row, t) {
+    if (!SITE.intake) return row;
+    if (LIVE_BACKLOG_ROUTE === "fixed-ip") {
+      row.appendChild(el("span", { class: "ds-route-chip", title: "この案件の Backlog は、固定の送信元 IP から読んでいます", text: "固定 IP 経由" }));
+    }
+    var facts = backlogRealtimeFacts();
+    if (!facts || backlogKeyRowCount(t.projectKey) > 1) return row;
+    var ago = backlogRowReceiptAgo(facts, t.projectKey);
+    var title = facts.viaFixedIp || LIVE_BACKLOG_ROUTE === "fixed-ip"
+      ? "反映は受信から数分後です"
+      : "反映は受信から約1分後です（1分ごとにまとめて取り込みます）";
+    if (ago) {
+      row.appendChild(el("span", { class: "ds-rt-chip is-live", title: title }, [
+        el("span", { text: "リアルタイム同期：稼働中" }),
+        el("span", { class: "ds-rt-at", text: ago === "たった今" ? "たった今受信" : ago + "に受信" }),
+      ]));
+    } else if (facts.anyLive) {
+      row.appendChild(el("span", { class: "ds-rt-chip is-waiting", title: "この接続先の Webhook はまだ届いていません", text: "リアルタイム同期：未受信" }));
+    }
+    return row;
+  }
+
   /**
    * Backlog のAPIキーを、どのスペースの棚へ入れるか（#138）。
    *
@@ -14771,6 +15007,9 @@ ${calendarAddUrl.toString()}
    *   **この印のものだけ**消す——「取り込み: 〜に成功」の横の語（別の行のもの）は残す
    */
   function runTrailNodes(row, kind) {
+    // 🔴 「その場で確認」は「◯分前に確認」の横に出さない（時刻が出ていて、重ねると同じことを 2 度言う）。
+    // 押した直後の行と開き直した行で形が割れないよう、書き手が button の行は語を持たない
+    if (kind === "gate" && row && row.by === "button") return [];
     var word = runSourceWordOf(row);
     var node = word ? el("span", { class: "ds-run-src", text: word }) : null;
     if (!node) return [];
@@ -14785,15 +15024,6 @@ ${calendarAddUrl.toString()}
     return f;
   }
 
-  /**
-   * 「いま測った結果」に差し替えるとき、**「◯分前に確認」に添えた**古い出どころの語を外す
-   * （同じ行が 2 つのことを言わない）。「取り込み: 〜に成功」の横の語は別の行のものなので残す
-   */
-  function removeRunTrail(scope) {
-    var old = scope.querySelectorAll('.ds-run-src[data-trail="gate"]');
-    for (var i = 0; i < old.length; i++) old[i].remove();
-  }
-
   /**
    * 接続先1件の「取り込み」の表示。**測っていなければ何も出さない（null）。**
    *
@@ -14886,8 +15116,8 @@ ${calendarAddUrl.toString()}
     if (!r) return row;
     var gate = dsGateForCap(capId, r.status);
     row.appendChild(el("span", { class: "ds-gate " + gate.cls, text: gate.text }));
-    var when = rtAgo(r.at);
-    if (when) row.appendChild(el("span", { class: "ds-gate-at", text: when + "に確認" }));
+    var when = agoConfirmedText(r.at);
+    if (when) row.appendChild(el("span", { class: "ds-gate-at", text: when }));
     // run の無い書き手は出どころの語を添える（#560）
     runTrailNodes(r, "gate").forEach(function (n) { row.appendChild(n); });
     return row;
@@ -14931,7 +15161,7 @@ ${calendarAddUrl.toString()}
    * -------------------------------------------------------------------------
    * #548 までは、この3つは中央が鍵を読まない（#105 決定5）ので、押すとその案件の同期が
    * 1回起きるだけだった。オーナーがその境界を覆し、いまは「接続を確認」は Slack / GitHub と
-   * 同じく**中央がその場で叩いて答えを返す**（即答・「showProbeVerdict」）。同期を1回
+   * 同じく**中央がその場で叩いて答えを返す**（即答・「applyProbeResult」）。同期を1回
    * 起こす従来の動きは「今すぐ同期」（送る値に 「sync: true」）に移った。
    *
    * 待ちの仕組み（下）は「今すぐ同期」と、Backlog が IP 制限で叩けず夜間と同じ経路へ
@@ -15020,6 +15250,7 @@ ${calendarAddUrl.toString()}
    * 登録簿が読めない・ロール未登録・起動失敗が、全部ここへ来る）。
    */
   function probeDeclined(note, key, j) {
+    note.hidden = false;
     note.textContent = (j && j.message) || "確認できませんでした。";
     delete PROBE_WAITS[key];
   }
@@ -15032,13 +15263,15 @@ ${calendarAddUrl.toString()}
    * 🔴 **控えた 「at」 で待つ（🔴2・壁時計を使わない）。** 押した時刻で見ると、
    * 端末の時計がずれている人には永久に届かない（または届く前に届いたことになる）。
    */
-  function probeEnterWait(note, key, capId, ref, before, j) {
+  function probeEnterWait(note, key, capId, ref, before, j, reason) {
     PROBE_WAITS[key] = {
+      reason: reason || "",
       cap: capId, ref: ref,
       at: (before && before.at) || "",
       startedAt: Date.now(),
       message: (j && j.message) || "",
     };
+    note.hidden = false;
     probeWaitNote(note, PROBE_WAITS[key]);
     // 待っているあいだは取り直しを回す（届いた行で一覧が描き直される）
     refreshStateTimer();
@@ -15047,58 +15280,9 @@ ${calendarAddUrl.toString()}
   /** 待ちの 1 文（#548）。「同期を開始しました」等、サーバの文言をそのまま出す */
   function probeWaitNote(note, wait) {
     note.textContent = (wait && wait.message) || "";
-  }
-
-  /**
-   * 即答（#548 の direct）を行に映す。**「probeSection」 と同じ見た目にする**——
-   * 夜間のスナップショットの判定といま測った判定を**同じ行に並べない**ため
-   * （並べると「⚠️ と 接続OK が同時に出ている」になり、この節で何度も直してきた
-   * 食い違いを画面の側から作ることになる）。置き換えたことが分かるよう、
-   * いつ測ったかを必ず添える。
-   *
-   * 🔴 **札が無い行もある**（一度も測っていない接続先＝ 「appendReachableChip」 が
-   * 何も足していない行）。その場合は札を作って**ボタンの前**に差し込む——後ろに置くと
-   * 行の読み順（札 → ボタン）が崩れる。
-   *
-   * @param anchor 差し込む位置の目印（1つ目のボタン）
-   */
-  function showProbeVerdict(row, capId, anchorIn, j) {
-    var gate = dsGateForCap(capId, j.gate);
-    // 差し込む位置は**行の最初のボタン**の前（「外す」が出る行では「外す」の前）。
-    // 「接続を確認」の前に置くと、外せる行だけ「外す → 札 → ボタン」の並びになる（🟡10）
-    var anchor = anchorIn;
-    var btns = row.querySelectorAll(".ds-toggle-btn");
-    for (var bi = 0; bi < btns.length; bi++) {
-      // **行の直下にあるボタンだけ**が目印になれる（入れ子の中のボタンの前には差し込めない）
-      if (btns[bi].parentNode === row) { anchor = btns[bi]; break; }
-    }
-    var chip = row.querySelector(".ds-gate");
-    if (!chip) {
-      chip = el("span", { class: "ds-gate" });
-      row.insertBefore(chip, anchor);
-    }
-    chip.className = "ds-gate " + gate.cls;
-    chip.textContent = gate.text;
-    var at = row.querySelector(".ds-gate-at");
-    if (!at) {
-      at = el("span", { class: "ds-gate-at" });
-      row.insertBefore(at, anchor);
-    }
-    at.textContent = "いま測った結果（" + (dsFmtTime(j.checkedAt) || "たった今") + "）";
-    // 古い run の導線も外す（#560）。残すと「いま測った結果」の横に夜間の run のログが並ぶ
-    removeRunTrail(row);
-    // **夜間の判定に添えてあった案内は隠す。** 置き換えた判定と食い違う案内が下に残ると、
-    // 同じ行が2つのことを言う（probeSection の stale 処理と同じ）
-    var stale = row.querySelectorAll(".ds-gate-help");
-    for (var si = 0; si < stale.length; si++) stale[si].hidden = true;
-    // **押し直しで段が増えないよう、前回の結果は消してから出す**（probeSection の札と同じ）
-    var old = row.querySelectorAll(".ds-probe-help");
-    for (var oi = 0; oi < old.length; oi++) old[oi].remove();
-    // 次の一手は語の表（DS_GATE_CAP）が持っていればそれ。無ければ判定器の1文（detail）
-    // ——どちらも**1段だけ**（帯は症状・行は一手・繰り返さない）
-    var nodes = gateHelpNodes(gate, "ds-probe-help");
-    if (!nodes.length && j.detail) nodes = [el("p", { class: "ds-probe-help", text: String(j.detail) })];
-    nodes.forEach(function (n) { row.appendChild(n); });
+    // IP 制限の確定は［接続を確認］の応答だけ。待ちが持つ reason で、描き直しのたびに［切り替える］を足す
+    //（結果は行を描く側に一本化。textContent で子を消すので二重にならない）
+    if (wait && wait.reason === "ip-restricted") appendBacklogProbeSwitch(note, wait.cap, { reason: wait.reason });
   }
 
   /**
@@ -15129,9 +15313,11 @@ ${calendarAddUrl.toString()}
     else note.hidden = true;
 
     checkBtn.addEventListener("click", async function () {
+      // 押している間は**ボタンだけ**が「確認中…」になる。行の中身は変えない（#1328）。
+      // 前回の返事（「同期を開始しました」等）は押した時点で消す
       var endBusy = beginBusy(checkBtn, "確認中…");
-      note.hidden = false;
-      note.textContent = "確認中…";
+      note.hidden = true;
+      note.textContent = "";
       // 🔴 **押す前に、いまの行の 「at」 を控える（🔴2）。** 行が無ければ空文字
       //（どんな 「at」 が来ても「新しい」と読める）。使うのは IP 制限で倒れた回だけだが、
       // 応答が返ってからでは「押す前の行」を控えられない
@@ -15149,7 +15335,8 @@ ${calendarAddUrl.toString()}
           // 語が返らない回＝この場では叩けなかった回。Backlog の IP 制限
           //（「reason」 が 「ip-restricted」）で夜間と同じ経路へ倒したときと、
           // 即答をまだ知らない古い Lambda が相手のとき。どちらも従来どおり待つ
-          probeEnterWait(note, key, capId, ref, before, j);
+          // IP 制限と確定できるのはこの応答だけ（reason）。［切り替える］は待ちの文を描く側（probeWaitNote）が足す
+          probeEnterWait(note, key, capId, ref, before, j, j.reason);
           endBusy();
           return;
         }
@@ -15158,11 +15345,11 @@ ${calendarAddUrl.toString()}
         delete PROBE_WAITS[key];
         note.hidden = true;
         note.textContent = "";
-        showProbeVerdict(row, capId, checkBtn, j);
-        // ストアにも 「button」 の行が書かれている。**取りに行くのは1回だけ**——
-        // 届いた行で一覧が描き直され、この行の札が正本の値に揃う
-        reloadLiveState();
+        // 🔴 結果は行を描く関数に渡して描き直す（札・時刻・次の一手は行が決める。#1328）。
+        // 次の一手は語の表が持っていればそれ、無ければ判定器の 1 文（detail）——どちらも行の側の規則
+        applyProbeResult(capId, ref, "", { gate: j.gate, checkedAt: j.checkedAt, needed: "", detail: j.detail || "" });
       } catch (e) {
+        note.hidden = false;
         note.textContent = "通信に失敗しました。";
         delete PROBE_WAITS[key];
       }
@@ -15237,7 +15424,35 @@ ${calendarAddUrl.toString()}
    */
   function backlogPaintSigOf(list) {
     return ingestSigOf(list) + "|" + (list || []).map(function (t) { return t && t.pending === true ? "p" : "-"; }).join(",")
-      + "|" + reachSigOf("issues", (list || []).map(function (t) { return issuesRefOf(t.domain, t.projectKey); }));
+      + "|" + reachSigOf("issues", (list || []).map(function (t) { return issuesRefOf(t.domain, t.projectKey); }))
+      + "|" + backlogFactsSigOf();
+  }
+  /**
+   * 行の札・一手が読む**一覧の外の事実**の署名（c-07 の 2 本目・設計レビュー🔴1）。
+   * 同期経路・固定 IP・そのスペースのキーの登録状況・リアルタイムの受信は、接続先の集合や「届くか」と別に変わる。
+   * 混ぜないと、**接続先を足した後（応答の一覧を採った後）や切り替えの後に、行の札・一手が描き直されない**。
+   */
+  function backlogFactsSigOf() {
+    var secrets = [];
+    if (Array.isArray(LIVE_SECRETS)) {
+      for (var i = 0; i < LIVE_SECRETS.length; i++) {
+        var r = LIVE_SECRETS[i];
+        if (r && r.kind === "backlog") secrets.push((r.space || "") + ":" + r.state);
+      }
+    }
+    var rt = LIVE_REALTIME;
+    var rtRows = rt && rt.ready && Array.isArray(rt.targets)
+      ? rt.targets.map(function (t) { return (t && t.projectKey) + "@" + (t && t.lastEventAt); })
+      : [];
+    return JSON.stringify([
+      LIVE_BACKLOG_ROUTE === undefined ? "?" : LIVE_BACKLOG_ROUTE,
+      LIVE_FIXED_IP,
+      secrets,
+      (fleetVal("secretSources") || {}).backlog || "",
+      fleetVal("secretSpaces") || null,
+      rtRows,
+      rt && rt.via || "",
+    ]);
   }
 
   /**
@@ -15299,6 +15514,8 @@ ${calendarAddUrl.toString()}
     var editable = backlogTargetsEditable();
     /** 追加・削除の応答で一覧を受け取ったか（受け取っていたら、そちらが正本） */
     var adopted = false;
+    /** 「その他」（1 回だけ作る）。paint() は作る前には当て直さない */
+    var moreEl = null;
 
     // **Slack / GitHub / Figma / Drive と同じレコードの行にする（2026-08-21・オーナー指摘）。**
     // それまでは「現在の接続先」というラベル付きの独自レイアウト（.ds-current /
@@ -15336,11 +15553,13 @@ ${calendarAddUrl.toString()}
       // 理由の1段は**行の最後**（ボタンより後ろ）に置く（appendReachableReason の項）
       var issuesRef = issuesRefOf(t.domain, t.projectKey);
       appendReachableChip(row, "issues", issuesRef);
+      // 札（事実）: 固定 IP 経由・リアルタイム同期の稼働中／未受信（c-07 の 2 本目）。届くか札・確認時刻の後、最初のボタンの前
+      appendBacklogChips(row, t);
       // 「接続を確認」（#523 S3）。**外す権限が無くても押せる**——読むだけの操作で、
       // 押せる人を絞らない（決定7）。ボタンの並びは Slack の行と同じ（外すボタンの後ろ）
       if (!editable) {
         appendDispatchProbe(row, "issues", issuesRef);
-        return appendReachableReason(row, "issues", issuesRef);
+        return appendBacklogRowHelp(row, t, issuesRef);
       }
       var btn = el("button", { class: "ds-toggle-btn ds-danger", type: "button", text: "この接続先を外す" });
       btn.addEventListener("click", async function () {
@@ -15362,7 +15581,8 @@ ${calendarAddUrl.toString()}
       });
       row.appendChild(btn);
       appendDispatchProbe(row, "issues", issuesRef);
-      return appendReachableReason(row, "issues", issuesRef);
+      // 🔴 **一手は行の最後（ボタンより後ろ）に 1 段だけ。** 読めている行・測っていない行には何も出さない
+      return appendBacklogRowHelp(row, t, issuesRef);
     }
 
     /**
@@ -15388,6 +15608,8 @@ ${calendarAddUrl.toString()}
 
     function paint() {
       while (listEl.firstChild) listEl.removeChild(listEl.firstChild);
+      // 一手・札・鍵カードの見え方が引く行の控え（行を描く前に入れ替える）
+      BACKLOG_UI.rows = targets;
       var shown = grouped(targets);
       // そのスペースの**最後の行**を覚えておく（鍵の欄はそこへ入れる）
       var lastRowOf = {};
@@ -15423,6 +15645,8 @@ ${calendarAddUrl.toString()}
       // 足した瞬間に欄が現れ、最後の1件を外した瞬間に消えるのはここが効いているから。
       // 節ごとの差し替え（refreshDataSources）はモーダルが開いている間は何もしない
       syncKeyCardVisibility();
+      // 一覧の下の一手・「その他」も、行と同じ材料で当て直す（まだ作っていない最初の 1 回は飛ばす）
+      if (typeof refreshExtras === "function" && moreEl) refreshExtras();
     }
 
     /**
@@ -15569,8 +15793,16 @@ ${calendarAddUrl.toString()}
      * 入力中の鍵と「保存中…」は保たれる。
      */
     box.__rebuild = function () {
-      // 🔴 応答に添えられた一覧（adoptTargets）のほうが新しい。上書きしない
-      if (adopted) return;
+      // 🔴 応答に添えられた一覧（adoptTargets）のほうが新しい。**接続先の集合は上書きしない。**
+      // ただし行の札・一手が読む外の事実（経路・固定 IP・キーの登録状況・リアルタイムの受信）は
+      // 集合と別に変わるので、署名が変わったときは**行だけ**描き直す（c-07 の 2 本目・設計レビュー🔴1）
+      if (adopted) {
+        var sigAdopted = backlogPaintSigOf(targets);
+        if (sigAdopted === lastIngestSig) return;
+        lastIngestSig = sigAdopted;
+        paint();
+        return;
+      }
       var next = backlogTargetsNow(internalSourceOf(REGISTERED_CAP_NAMES.issues));
       // 🔴 **変化が無いと言えるのは、接続先の集合と取り込みの状態が両方同じときだけ（段C）。**
       // 世代だけで判断すると、**応答を待たずにモーダルを開いた人には取り込みが永久に出ない**
@@ -15583,6 +15815,16 @@ ${calendarAddUrl.toString()}
       ensureKeySlots();
       paint();
     };
+    /**
+     * 行だけを描き直す口（切り替え・キー保存の後に呼ぶ）。**接続先の集合は触らない。**
+     * 応答の一覧を採った後でも、行の札・一手は最新の事実で描かれる（lastIngestSig も揃える）
+     */
+    box.__repaintRows = function () {
+      lastIngestSig = backlogPaintSigOf(targets);
+      paint();
+    };
+    BACKLOG_UI.repaintRows = box.__repaintRows;
+    BACKLOG_UI.msg = msg;
     // 接続先がまだ無い案件の受け皿は、0件の1行の直後に置く（行が無いので中へ入れられない）
     if (KEY_SLOTS.backlog[""]) box.appendChild(KEY_SLOTS.backlog[""]);
     if (editable) {
@@ -15592,27 +15834,11 @@ ${calendarAddUrl.toString()}
         title: "＋ 接続先を追加",
         placeholder: "https://<スペース>.backlog.jp/projects/<プロジェクトキー>",
         requiredNote: "BacklogのURLを入力してください（プロジェクトキーが入った形。数字だけのURLは受け付けません）。",
-        // **手順のリストにする（2026-08-20・Slack からの横展開）。**
-        // **リスト（ol.sec-steps）そのものは維持する**——他の能力の手順と形を揃える。
-        //
-        // **鍵の発行手順は二重に持たない。** 正本は接続先の行の下にある鍵の欄
-        //（SECRET_FORMS.backlog の how）で、ここからは参照するだけ。
-        //
-        // ## 4行 → 2行に圧縮した（2026-08-21・オーナー指摘「何も変わってない気がする」）
-        //
-        // **この欄は URL を貼るだけ**なので、4行の説明が読む負担に見合わない。
-        // ただし**落としてよいのは1行目だけ**だった（欄を見れば分かる内容）。残り3つは
-        // ここ以外に置き場が無いので、**消さずに2行へ畳んでいる**:
-        //   - 「起票先は変わりません」… 追加の確認をやめたとき（2026-08-20）に
-        //     ここへ移してきたもの。落とすと知る手段が無くなる
-        //   - 「スペースごとに別のキー」… 鍵の欄からは読めない。1スペースの案件は
-        //     行が1本しか無いので、これから2つ目を足す人に「別の鍵が要る」が届かない
-        //   - 「案件専用URLの登録」… 救出先の realtimeSyncCard() は稼働中の案件では
-        //     手順一式を <details> に畳むので、**いちばん要る人に対して閉じている**
-        hint: [
-          "URL を貼ると同期先が増えます。ビューアからの起票先は変わりません（スペースごとに別のAPIキーが要ります）。",
-          "リアルタイム同期を使うなら、追加した Backlog プロジェクトにも、このプロジェクト専用URLの登録が要ります（同じURLを使います）。",
-        ],
+        // 🔴 **追加の欄は URL の入力と［追加］だけ（c-07 の 2 本目）。** 手順の文は置かない（hint を渡さない）。
+        // 外した情報の行き先:
+        //   - 「起票先は変わりません」「毎晩同期します」「外すには」… 上部の説明文（openCapabilityModal）
+        //   - 「スペースごとに別のAPIキー」… 足した行の一手「◯◯ の API キーを入れてください」と、「その他」のスペースごとの行
+        //   - 「専用 URL の登録が要ります」… 追加した行のリアルタイム札（未受信）と、一覧の下の一手［設定する］
         build: function (url) {
           return { op: "backlog-target-add", url: url, baseGeneration: targetsGenerationOf(targets) };
         },
@@ -15621,7 +15847,86 @@ ${calendarAddUrl.toString()}
       }));
     }
     box.appendChild(msg);
+
+    // 投入の口（intake）が無い案件には、一手も「その他」も出さない（押せない案内を置かない）
+    if (editable) {
+      // ---- 一覧の下の一手（リアルタイム同期）と、ふだん見えない「その他」（c-07 の 2 本目）----
+      //
+      // 🔴 **リアルタイム同期は大きな箱を常設しない。** 稼働中は行の札だけ。受信が無い・一部だけのときだけ、
+      // 一覧の下に 1 行の一手（［設定する］で手順と専用 URL が開く）。全部稼働中なら、URL の再確認は「その他」に置く。
+      // 🔴 **「その他」は 1 回だけ作る**（結果の帯・開閉を描き直しで消さない）。中の一覧は liveList で追いつかせる。
+      var rtOpen = false;
+      var rtBox = liveList("backlog-realtime", function () {
+        var st = backlogRealtimeState();
+        return JSON.stringify([st ? [st.total, st.live] : null, backlogFactsSigOf()]);
+      }, function (b) {
+        var st = backlogRealtimeState();
+        // 稼働中の行が無い／一部だけのときだけ。全部稼働中は何も出さない（再確認は「その他」）
+        if (!st || st.live === st.total) return;
+        var text = st.live === 0
+          ? "リアルタイム同期（任意）を使うと、Backlog の変更をすぐ取り込めます。"
+          : "まだ受信していない接続先があります（Backlog プロジェクトごとに Webhook の登録が要ります）。";
+        var setup = el("div", { class: "rt-card rt-setup" }, realtimeSetupNodes());
+        setup.hidden = !rtOpen;
+        var openBtn = el("button", { class: "ds-toggle-btn ds-act-inline", type: "button", text: "設定する", "aria-expanded": rtOpen ? "true" : "false" });
+        openBtn.addEventListener("click", function () {
+          rtOpen = !rtOpen;
+          setup.hidden = !rtOpen;
+          openBtn.setAttribute("aria-expanded", rtOpen ? "true" : "false");
+        });
+        b.appendChild(el("p", { class: "ds-rt-help" }, [document.createTextNode(text), openBtn]));
+        b.appendChild(setup);
+      });
+      box.appendChild(rtBox);
+
+      var routeWrap = backlogRouteSwitch();
+      var keyRows = liveList("backlog-key-rows", function () {
+        var ds = backlogDomainsNow();
+        return JSON.stringify(ds.map(function (d) { return [d, secretStateOf("backlog", d, ds.length).known]; }));
+      }, function (b) {
+        var ds = backlogDomainsNow();
+        ds.forEach(function (d) {
+          var st = secretStateOf("backlog", d, ds.length);
+          var word = st.known === "yes" ? "登録済みです" : st.known === "no" ? "未登録です" : "確認中です";
+          // ボタンはそのスペースの鍵カードを開く（受け皿が無ければ作らない）
+          b.appendChild(el("p", { class: "ds-more-key" }, [
+            el("span", { text: d + "：API キーは" + word }),
+            backlogKeyJump(d, st.known === "no" ? "入れる" : "入れ直す"),
+          ]));
+        });
+      });
+      var rtMore = liveList("backlog-realtime-more", function () {
+        var st = backlogRealtimeState();
+        return JSON.stringify([st ? [st.total, st.live] : null, backlogFactsSigOf()]);
+      }, function (b) {
+        var st = backlogRealtimeState();
+        if (!st || st.live !== st.total) return;
+        var fold = el("details", { class: "rt-card rt-steps-fold" }, [
+          el("summary", { text: "リアルタイム同期（任意）の設定手順と専用 URL（再確認・張り替え用）" }),
+        ]);
+        realtimeSetupNodes().forEach(function (n) { fold.appendChild(n); });
+        b.appendChild(fold);
+      });
+      moreEl = el("details", { class: "ds-more" }, [
+        el("summary", { text: "その他" }),
+        routeWrap,
+        keyRows,
+        rtMore,
+      ]);
+      box.appendChild(moreEl);
+      refreshExtras();
+    }
     return box;
+
+    /** 「その他」の出し入れと、中の一覧の追いつかせ。**出すのは接続先が 1 件以上、または経路が固定 IP のとき**（ON は 0 件でも戻せる） */
+    function refreshExtras() {
+      if (!moreEl) return;
+      moreEl.hidden = !(keyTargetCount("課題管理") > 0 || LIVE_BACKLOG_ROUTE === "fixed-ip");
+      rtBox.__rebuild();
+      if (routeWrap.__live) routeWrap.__live.__rebuild();
+      keyRows.__rebuild();
+      rtMore.__rebuild();
+    }
   }
 
   /** 接続先を外すときの確認。**最後の1件は、止まるものを名指しで伝える** */
@@ -15736,20 +16041,13 @@ ${calendarAddUrl.toString()}
       // 接続先の正本（issues-config.json）は雛形から作られるので、立ち上げ直後の案件にも
       // 実在する。同期ミラーの有無で門前払いすると、**新規案件がこの画面から
       // Backlog に繋げない**——設定UIを置いている意味が無くなる
+      // 🔴 **同期経路のスイッチ・リアルタイム同期は、節の中（一覧の下の一手と「その他」）に移した**
+      // （c-07 の 2 本目）。ここでは節だけを置く
       box.appendChild(backlogTargetsSection(s));
       // **「この画面からは接続先を変更できません」の枝は撤去した（#516）。** ゲートが
       // 「intake があるか」になり、この関数は intake の無い案件では上で return しているので、
       // 到達しない枝だった（到達不能な枝は変異検証の網から漏れる）。
       //
-      // **接続先の下・リアルタイム同期の上に、同期経路のスイッチを置く（#516・設計 v2 §6）。**
-      // #497 の「固定 IP 経由で同期できます（切り替えは運用側）」の案内と画面の IP 定数は
-      // これに置き換わった——切り替えは担当者が自分で押す。
-      box.appendChild(backlogRouteSwitch());
-      // **接続先の下に置く。** リアルタイム同期は「どのプロジェクトを見るか」が
-      // 決まった後の話で、順序が逆だと、接続先を設定していない案件が先に
-      // Webhook を貼りに行く（貼っても届かない）
-      var rt = realtimeSyncCard();
-      if (rt) box.appendChild(rt);
       used = true;
     }
 
@@ -16956,7 +17254,7 @@ ${calendarAddUrl.toString()}
     var gateEl = el("span", { class: "ds-gate " + gate.cls, text: gate.text });
     // 状態ストア由来の判定には「いつ確かめたか」を必ず添える
     var gateAtEl = s.gateAt
-      ? el("span", { class: "ds-gate-at", text: rtAgo(s.gateAt) + "に確認" })
+      ? el("span", { class: "ds-gate-at", text: agoConfirmedText(s.gateAt) })
       : null;
     // run の無い書き手は出どころの語を添える（#560）。overlay が写した 「gateRunUrl」 / 「gateBy」 から決める
     var gateTrail = s.gateAt ? runTrailNodes({ runUrl: s.gateRunUrl || "", by: s.gateBy || "" }, "gate") : [];
@@ -17116,7 +17414,7 @@ ${calendarAddUrl.toString()}
     // **origin === "explicit" でも出す。** 確認は読むだけで、どの登録ファイル由来かに
     // 関係なく効く（書き込みになる「表示名を更新する」だけが由来で出し分かれる）
     if (SITE.intake && probeTypeOf(s.type) && s.ref) {
-      var probe = probeSection(s, card, gateEl);
+      var probe = probeSection(s, card);
       // **ボタンは行の中（「登録を解除」の隣）。** 独立した段を作ると1行が2段になる
       card.appendChild(probe.btn);
       appendRowHelp();
@@ -17500,6 +17798,8 @@ ${calendarAddUrl.toString()}
         LIVE_REGISTERED = sanitizeRegisteredNow(j && j.registeredNow);
         LIVE_REGISTERED_AT = startedAt;
         LIVE_STATE = sanitizeStateNow(j && j.stateNow);
+        // 押した結果が本物の行に追いつくまで重ねる（mergeProbeLocal の項）
+        mergeProbeLocal();
         // **欄の有無をそのまま覚える。** sanitize を通した後では「読めて0件」が消える
         LIVE_STATE_SEEN = !!(j && Array.isArray(j.stateNow));
         // **カレンダーの行だけは sanitize の前に数える**（#428・上の宣言の項）
@@ -17847,51 +18147,24 @@ ${calendarAddUrl.toString()}
   }
 
   /**
-   * リアルタイム同期（Backlog Webhook）の設定手順（#113）。
-   *
-   * **出すのは「手順どおり設定すれば実際に効く案件」だけ。** 判断は Lambda（op=state）が返す
-   * realtime に委ねる——画面が持っている静的データからは「ルーティング索引に自分の行が
-   * あるか」が分からないし、2箇所で判定すると片方だけがずれる。
-   *   - via: "fixed-ip"  … 固定 IP 経由で同期する案件（#516・#503 設計 v3 §6）。手順は同じ。
-   *                        反映が「約1分」ではなく「数分」になることだけを言う
-   *   - ready: false     … 索引にまだ行が無い。設定しても届かないので手順を出さない
-   *   「supported: false（固定 IP は未対応）」の枝は撤去した——固定 IP 案件でも Webhook を
-   *   受ける（分類 A2）。その値を返す古い Lambda に当たっても、手順を出す側に倒す
+   * リアルタイム同期（Backlog Webhook）の設定手順ひとそろい（#113）。**大きな箱では出さない**（c-07 の 2 本目）:
+   * 稼働中は行の札だけ。受信が無い・一部だけのときの一手［設定する］の中と、全部稼働中のときの「その他」の中に、
+   * この同じ部品を置く。**URL が無い案件には呼ばない**（backlogRealtimeFacts が null）。
    *
+   * 🔴 **手順の部品は変えない**（貼り付け先・URL・コピー・チェックする 10 種・秘密の注意・反映の目安）。
+   * チェック名は受信側が処理する 10 種を全部並べる（「等」で省くと、課題の 3 つだけにチェックして
+   * 「設定した」と思い、Wiki とドキュメントの更新が夜間まで届かない）。増減するときは受信側
+   *（backlog-webhook/logic.mjs の HANDLED_TYPES）と揃える——ずれると realtime-sync-card.test.mjs が赤くなる。
    * **URLに載せるトークンは案件別**（SITE.backlogWebhook）。艦隊共通トークンを載せると、
-   * この画面を見られる人が全案件ぶんの偽イベントを投げられる（types.ts の backlogWebhook 参照）。
-   *
-   * **既に回っている案件には、手順より先に「動いている」ことを出す（#123）。** 設定手順は
-   * まだ繋いでいない人のためのもので、繋ぎ終わった案件の担当者が知りたいのは
-   * 「ちゃんと届いているか」。手順は畳んで残す（URLの再確認・張り替えに要る）。
+   * この画面を見られる人が全案件ぶんの偽イベントを投げられる。
+   * 固定 IP 経由か（#516）は **op=state の realtime.via**（受信を同期するのはサーバ側の索引が決める）で言う。
    */
-  function realtimeSyncCard() {
+  function realtimeSetupNodes() {
     var rt = LIVE_REALTIME;
-    // 固定 IP 経由か（#516）。**経路の正本は op=state の realtime.via**——スイッチの状態
-    //（LIVE_BACKLOG_ROUTE）から引かない。あちらは押した直後に先に変わるが、受信したイベントを
-    // どちらが同期するかはサーバ側の索引が決めるので、同じ応答の値で言う
     var viaFixedIp = !!(rt && rt.via === "fixed-ip");
     var wh = SITE.backlogWebhook;
-    // **URLが無い案件には出さない。** 貼るものが無い手順は、一番読めない形になる
-    if (!wh || !wh.url || !wh.token) return null;
-    // **索引に行があるか（ready）でカードごと隠さない（2026-08-24 オーナー決定）。**
-    // それまでは「手順どおり設定すれば実際に効く案件だけに出す」としていたが、
-    // ready の材料（ルーティング索引の行）は**設定を始める前には揃わない**ので、
-    // これから設定する人ほど手順に辿り着けなかった。索引がまだ追いついていない案件も、
-    // 取得前・取得失敗（rt が null）も、手順は出す——URLは案件専用で、先に貼っておいても
-    // 困らない。ready のときだけ受信実績の行を足す
-    var ready = !!(rt && rt.ready);
+    if (!wh || !wh.url || !wh.token) return [];
     var url = wh.url + (wh.url.indexOf("?") === -1 ? "?" : "&") + "t=" + encodeURIComponent(wh.token);
-    // 接続先ごとの受信実績（#123）。**配列で受ける**——1案件＝複数 Backlog プロジェクトは
-    // 確定した将来要件（#107）で、今日は必ず1件。**時刻が読めない値は稼働中に数えない**
-    // ——「最終受信: NaN分前」を出すくらいなら、未設定と同じ手順の画面のほうがまだ読める
-    // **ready でないうちは受信実績を読まない。** ready の材料は索引の行（＝自リポ宛だと
-    // 確かめられた行）で、それが無いのに lastEventAt だけ来ている応答を信じると、
-    // **届いていない案件に「✓ 稼働中」を出す**——一番出してはいけない嘘になる
-    var targets = (ready && rt.targets ? rt.targets : []).map(function (t) {
-      return { projectKey: t && t.projectKey ? String(t.projectKey) : "", ago: t && t.lastEventAt ? rtAgo(t.lastEventAt) : "" };
-    });
-    var live = targets.some(function (t) { return t.ago; });
 
     // URLは**選択できる形**で出す（コピーボタンが使えない環境でも手で取れるように）
     var field = el("input", { class: "sec-input rt-url", type: "text", readonly: "readonly", spellcheck: "false" });
@@ -17918,16 +18191,10 @@ ${calendarAddUrl.toString()}
       } catch (e) { fallback(); }
     });
 
-    // 手順ひとそろい（貼り付け先・URL・注意書き）。稼働中の案件ではこれを畳む
-    var steps = [
+    return [
       el("ol", { class: "rt-steps" }, [
         el("li", { text: "Backlog のプロジェクト設定 → インテグレーション → Webhook を開く" }),
         el("li", { text: "「WebHook URL」に、下の（このプロジェクト専用の）URL を貼り付ける" }),
-        // **チェック名は受信側が処理する10種を全部並べる。** 「等」で省くと、担当者は
-        // 課題の3つだけにチェックして「設定した」と思い、Wikiとドキュメントの更新は
-        // 夜間まで届かない（画面は稼働中と出るので、欠けていることに気づけない）。
-        // ここを増減するときは受信側（backlog-webhook/logic.mjs の HANDLED_TYPES）と
-        // 揃える——ずれると realtime-sync-card.test.mjs が赤くなる。
         // **「他はチェック不要」とは言い切らない。** 未対応の type（ドキュメントの更新等）は
         // 「無視した」ログから見つける設計なので、外させると発見の経路が塞がる
         el("li", { text: "通知イベントで次の10個にチェックを入れて保存する（他のイベントはチェックしても取り込まれません）" }, [
@@ -17940,72 +18207,26 @@ ${calendarAddUrl.toString()}
       ]),
       el("div", { class: "rt-url-row" }, [field, copyBtn]),
       msg,
-      // **この画面は顧客も見る。** URLに秘密が入っていることと、その扱いを書いておく
+      // **この画面は顧客も見る。** URLに秘密が入っていることと、その扱いを書いておく（秘密の扱いの文は縮めない）
       el("p", { class: "sec-note", text: "このURLはこのプロジェクト専用です（他のプロジェクトには届きません）。秘密のトークンを含むので、貼り付け先は、いま設定している Backlog プロジェクトの設定欄だけにしてください。" }),
-      // 固定 IP 経由の案件は反映が「約1分」にならない（1分のまとめ＋固定 IP の同期の起動で数分）。
-      // **同じ行を差し替える**——2 行に分けると「約1分」と「数分」が並んで矛盾する
+      // 固定 IP 経由の案件は反映が「約1分」にならない。**同じ行を差し替える**（2 行に分けると矛盾する）
       el("p", { class: "sec-how", text: viaFixedIp
         ? "固定 IP 経由で同期します（反映は受信から数分後です）。初回は上の接続先の設定と、夜間同期が一度済んでいることが前提になります。"
         : "反映は受信から約1分後です（1分ごとのミニバッチでまとめて取り込みます）。初回は上の接続先の設定と、夜間同期が一度済んでいることが前提になります。" }),
     ];
+  }
 
-    if (live) {
-      // 稼働中。**先頭は状態、手順は畳む。**「畳んである中に何があるか」を summary に書く
-      // ——ただの「詳細」だと、URLを張り替えたい人がここを開く手掛かりを持てない
-      var det = el("details", { class: "rt-steps-fold" }, [
-        el("summary", { text: "設定手順とプロジェクト専用URLを表示（URLの再確認・張り替え用）" }),
-      ]);
-      for (var i = 0; i < steps.length; i++) det.appendChild(steps[i]);
-      // 接続先ごとに1行。**1件のときはプロジェクトキーを出さない**——どれのことかは
-      // 自明なので、キーを添えると「他にもあるのか」と読ませる余計な情報になる。
-      // 複数のときは、どの接続先の話かが分からないと行が読めないので必ず添える
-      var lines = el("div", { class: "rt-live-lines" }, targets.map(function (t) {
-        var label = targets.length > 1 && t.projectKey ? t.projectKey + ": " : "";
-        // 受信実績がまだ無い接続先も**黙って落とさない**。1つでも動いていれば
-        // カードは稼働中の形になるので、落とすと「増やした接続先が来ていない」に気づけない
-        return el("p", {
-          class: t.ago ? "rt-live-line" : "rt-live-line is-waiting",
-          text: t.ago ? label + "最終受信: " + t.ago : label + "まだ受信していません",
-        });
-      }));
-      return el("div", { class: "ops-card rt-card is-live" }, [
-        el("div", { class: "ops-card-head" }, [
-          el("span", { class: "ops-card-icon", text: "⚡" }),
-          // **「（任意）」を付ける（2026-08-21・オーナー指摘「リアルタイム同期は
-          // オプションなので、一番下に配置してほしい」）。** 設定しなくても毎晩の同期で
-          // 反映されるので、必須の手順と並べると「まだ終わっていない」と読まれる。
-          // ⚠ **改名箇所は2つある**（稼働中の枝と未設定の枝）。片方だけ直すと、
-          // **これから設定する人にだけ「（任意）」が付かない**＝一番読ませたい人に届かない
-          el("h3", { class: "ops-card-title", text: "リアルタイム同期（任意）" }),
-          el("span", { class: "rt-live-badge", text: "✓ 稼働中" }),
-        ]),
-        lines,
-        // 固定 IP 経由の案件は「すぐ」ではなく「数分」（手順は畳んであるので、ここでも言う）
-        el("p", { class: "ops-card-desc", text: viaFixedIp
-          ? "Backlog の変更を固定 IP 経由で取り込んでいます（反映まで数分・毎晩の同期を待ちません）。設定は済んでいるので、このままお使いください。"
-          : "Backlog の変更をすぐ取り込んでいます（毎晩の同期を待ちません）。設定は済んでいるので、このままお使いください。" }),
-        det,
-      ]);
-    }
-
-    // まだ受け入れ体制が整っていない案件（接続先がこれから・索引が追いついていない）には、
-    // **次の一手だけを1行足す。** 担当者への連絡は促さない——この画面で完結する話だから
-    var head = [
-      el("div", { class: "ops-card-head" }, [
-        el("span", { class: "ops-card-icon", text: "⚡" }),
-        // **稼働中の枝と同じ見出しにする**（上の ⚠ 参照。片方だけ直すと、
-        // これから設定する人にだけ「（任意）」が付かない）
-        el("h3", { class: "ops-card-title", text: "リアルタイム同期（任意）" }),
-      ]),
-      el("p", { class: "ops-card-desc", text: "Backlog で課題やコメントが変わったときに、その内容をすぐ取り込みます（毎晩の同期を待たずに反映されます）。Backlog 側で一度だけ設定してください。" }),
-    ];
-    if (!ready) {
-      head.push(el("p", {
-        class: "sec-how",
-        text: "上の「接続先」を先に設定してから貼り付けてください。設定した直後は、この画面が追いつくまで少し時間がかかることがあります。",
-      }));
-    }
-    return el("div", { class: "ops-card rt-card" }, head.concat(steps));
+  /**
+   * リアルタイム同期の「いまの様子」。専用 URL が無い案件・投入の口が無い案件・接続先が 0 件のあいだは null（何も出さない）。
+   * total＝行の数、live＝そのキーの受信実績がある行の数（ready かつ時刻が読めるものだけ）。
+   */
+  function backlogRealtimeState() {
+    var facts = backlogRealtimeFacts();
+    var rows = BACKLOG_UI.rows || [];
+    if (!facts || !SITE.intake || !rows.length) return null;
+    var live = 0;
+    for (var i = 0; i < rows.length; i++) if (backlogRowReceiptAgo(facts, rows[i].projectKey)) live++;
+    return { facts: facts, total: rows.length, live: live };
   }
 
   /**
@@ -18181,6 +18402,33 @@ ${calendarAddUrl.toString()}
     return !!((fleetVal("secretSources") || {})[kind]);
   }
 
+  /**
+   * 鍵カードの登録状況の 1 行を、答え（secretStateOf）に合わせる。**作るときと、見せる瞬間の当て直し
+   * （Backlog の行の中のカード・c-07 の 2 本目）が同じこの 1 本を通る**——文言が 2 か所に割れない。
+   * 🔴 **画面に出すのは「登録済み」の 1 語だけ（#841）。** 取得元の値は仕組みの名前
+   *（保管庫のサービス名・旧名の区別）で、読む人が自分の画面で探せない。値に関わらず同じ 1 語にし、
+   * **生の値は data-src に置く**（判定の is-managed は生の値のまま。前方一致で見る＝旧名の移行期の取りこぼし防止）。
+   * 🔴 **「登録済み」は「読めている」を意味しない。** 「接続OK」「同期OK」とは書かない。
+   * 🔴 **断定しない（レビュー指摘）。** 黙って消すと、利用者は「入っているのか未登録なのか」も
+   * 「なぜ表示が無いのか」も知る手段が無い。
+   */
+  function applySecretState(node, st) {
+    if (st.known === "yes") {
+      var src = st.src || "";
+      node.className = "sec-state" + (src.indexOf("Secrets Manager") === 0 ? " is-managed" : "");
+      node.setAttribute("data-src", src);
+      node.textContent = "登録済み";
+    } else if (st.known === "no") {
+      node.className = "sec-state is-none";
+      node.removeAttribute("data-src");
+      node.textContent = "未登録";
+    } else {
+      node.className = "sec-state is-unknown";
+      node.removeAttribute("data-src");
+      node.textContent = "登録状況を確認中です（スペースごとの状況は、次回の自動チェックのあとに表示されます）";
+    }
+  }
+
   /**
    * @param opts { space, stateSpace, spaceCount, inRow }
    *   space      … 保存時に名乗る Backlog スペース（名乗らないときは空）
@@ -18193,6 +18441,10 @@ ${calendarAddUrl.toString()}
     var stateSpace = (opts && opts.stateSpace) || "";
     var spaceCount = (opts && opts.spaceCount) || 0;
     var inRow = !!(opts && opts.inRow);
+    // 🔴 **Backlog の行の中のカードは新しい見え方（c-07 の 2 本目）。** 見出しを持たず（行の中なので「何の鍵か」は
+    // 一手の文が言う）、ふだんは隠れていて、キーが無いと分かったとき・［入れる］／［入れ直す］を押したとき・
+    // 触り始めた後だけ見える（syncKeyCardVisibility）。旧カード（行の外・intake 無しの案件）と Figma は従来どおり。
+    var compact = kind === "backlog" && inRow;
     /**
      * 鍵がどこまで効くのか（#229）。**置き場所だけでは伝わらないので、言葉にする。**
      *
@@ -18207,7 +18459,6 @@ ${calendarAddUrl.toString()}
     // 画面で分かるようにする（接続状況は夜間バッチのスナップショットなので、
     // 保存の直後は前日の値のまま。時刻は上の節に出している）。
     var st = secretStateOf(kind, stateSpace, spaceCount);
-    var src = st.known === "yes" ? st.src : "";
     var cardTitle = meta.title;
     // 🔴 **「登録済み」は「読めている」を意味しない。** 鍵が入っていても、そのアカウントから
     // プロジェクトが見えなければ同期は失敗する。**「接続OK」「同期OK」とは書かないこと**
@@ -18221,16 +18472,8 @@ ${calendarAddUrl.toString()}
     //（保管庫のサービス名・旧名の区別）で、読む人が自分の画面で探せない。値に関わらず
     // 同じ 1 語にし、**生の値は data-src に置く**（判定の is-managed は生の値のまま）。
     // 知らない値が来ても生で出さない——project-wording.test.mjs が画面の語を見張る
-    var state = st.known === "yes"
-      ? el("p", { class: "sec-state" + (src.indexOf("Secrets Manager") === 0 ? " is-managed" : ""),
-                  "data-src": src,
-                  text: "登録済み" })
-      : st.known === "no"
-        ? el("p", { class: "sec-state is-none", text: "未登録" })
-        // **断定しない（レビュー指摘）。** 黙って消すと、利用者は
-        // 「入っているのか未登録なのか」も「なぜ表示が無いのか」も知る手段が無い
-        : el("p", { class: "sec-state is-unknown",
-                    text: "登録状況を確認中です（スペースごとの状況は、次回の自動チェックのあとに表示されます）" });
+    var state = el("p", { class: "sec-state" });
+    applySecretState(state, st);
 
     var input = el("input", { class: "sec-input", type: "password", placeholder: "トークンを貼り付け", autocomplete: "off" });
     var btn = el("button", { class: "ds-toggle-btn", type: "button", text: "保存" });
@@ -18274,6 +18517,12 @@ ${calendarAddUrl.toString()}
         // 入れた値は画面に残さない（肩越しに見えるのを防ぐ）
         input.value = "";
         endBusy();
+        // 🔴 **Backlog の行の中のカードは、保存したら行の一手を当て直す**（「API キーを入れてください」を
+        // 登録状況の正本に合わせて消す・c-07 の 2 本目）。正本（secretsNow）は取り直しで届く
+        if (compact) {
+          if (typeof BACKLOG_UI.repaintRows === "function") BACKLOG_UI.repaintRows();
+          loadLiveFleet(true);
+        }
       } catch (e) {
         msg.className = "ds-toggle-msg is-error";
         msg.textContent = "✗ 通信に失敗しました。";
@@ -18315,10 +18564,14 @@ ${calendarAddUrl.toString()}
     // input のノードを直接触るし、テストも card.querySelector("input.sec-input") で掴む。
     // ⚠ **<summary> は button ではない**ので、「保存」を掴む既存の取り方は変わらない。
     var inputFold = el("details", { class: "sec-input-fold" }, [
-      el("summary", { class: "sec-input-summary", text: st.known === "yes" ? "入れ直す" : "登録する" }),
+      // Backlog の行の中のカードは、一手の語（［入れる］・［入れ直す］）と揃える。Figma は「登録する」のまま
+      el("summary", { class: "sec-input-summary", text: st.known === "yes" ? "入れ直す" : (compact ? "入れる" : "登録する") }),
     ]);
     inputFold.appendChild(input);
     inputFold.appendChild(el("div", { class: "ds-toggle" }, [btn, msg]));
+    // 🔴 **値の扱いの 1 文は、開いた中に残す**（顧客に鍵の貼り付けを求める画面でいちばん落としてはいけない説明・#101）。
+    // 短くした版（行の中のカード）。「他のプロジェクトには影響しません」は仕組みの事実で、利用者が選ぶものではないので外す
+    if (compact) inputFold.appendChild(el("p", { class: "sec-note", text: "入れた値は保存だけでき、あとから表示されません。" }));
 
     // ライブ取得後に状態の行だけを差し替えるための目印（カードごと作り直すと入力が消える）
     //
@@ -18329,8 +18582,10 @@ ${calendarAddUrl.toString()}
     //     押すまで見えないと成立しない
     //   - .sec-preferred … 「誰のアカウントで発行するのか」を**手順より先に**伝える行。
     //     未登録のときだけ出る＝これから貼る人にだけ出るので、畳むと存在理由が消える
+    var preferred = meta.selfServe ? el("p", { class: "sec-preferred", text: meta.selfServe.text }) : null;
     var card = el("div", { class: "ops-card" + (inRow ? " ds-keycard" : ""), "data-secret-kind": kind }, [
-      el("div", { class: "ops-card-head" }, [
+      // 行の中の Backlog カードは見出しを持たない（何の鍵かは一手の文が言う）
+      compact ? null : el("div", { class: "ops-card-head" }, [
         el("span", { class: "ops-card-icon", text: meta.icon }),
         el("h3", { class: "ops-card-title", text: cardTitle }),
       ]),
@@ -18344,19 +18599,39 @@ ${calendarAddUrl.toString()}
       // **未登録のときだけ、先に試すべき手を出す。** 既に動いているカードに
       // 「まずこれをやれ」と出すと、直す必要が無いものを触らせることになる。
       // **「確認中」にも出さない**——入っているかもしれないものを触らせない
-      st.known === "no" && meta.selfServe ? el("p", { class: "sec-preferred", text: meta.selfServe.text }) : null,
+      st.known === "no" ? preferred : null,
       inputFold,
       guidanceBox,
       // **扱いの説明はカードに持たせる。** 節の見出しの下に置いていたときは、
       // #101 でカードだけがモーダルへ移り、説明だけが画面から消えた。
       // 顧客にトークンの貼り付けを求める画面で、貼った値がどう扱われるかの
       // 説明が落ちるのは、いちばん落としてはいけない種類の欠落
-      el("p", { class: "sec-note", text: "入れた値はここには表示されません（保存だけできます）。保存先はプロジェクトごとに分かれているので、他のプロジェクトには影響しません。" }),
+      // 行の中の Backlog カードは、同じ 1 文を開いた中（上の inputFold）に短くして持つ
+      compact ? null : el("p", { class: "sec-note", text: "入れた値はここには表示されません（保存だけできます）。保存先はプロジェクトごとに分かれているので、他のプロジェクトには影響しません。" }),
     ]);
     // **作った鍵カードは1枚残らずここに載せる。** 出し入れ（接続先が0件のときに畳む）は
     // DOM 検索ではなくこの控えで回す——カードは能力モーダルの中身で、タイルを押すまで
-    // 文書に入っていないため（syncKeyCardVisibility の項）
-    KEY_CARDS.push({ kind: kind, el: card });
+    // 文書に入っていないため（syncKeyCardVisibility の項）。
+    // compact（Backlog の行の中）のカードは、見え方の規則（backlogKeyCardWanted）が要る材料を一緒に持つ:
+    // space＝状態を引くスペース（行のドメイン。名無しの受け皿は空文字）・forced＝一手・「その他」から開かれた・
+    // fold／input／msg＝触り始めたかの判定と、入力への移動・refresh＝見せる瞬間の状態の当て直し
+    var entry = { kind: kind, el: card, compact: compact, space: stateSpace, forced: false, fold: inputFold, input: input, msg: msg };
+    if (compact) {
+      entry.refresh = function () {
+        // 作ったときの答えは古いことがある（取り直しが後から届く）。見せる瞬間に状態の行と summary と
+        // 「自分で繋げばよい」の 1 行を当て直す（入れた直後に前の答えのまま出さない・#227）
+        var now = secretStateOf(kind, stateSpace, backlogDomainsNow().length);
+        applySecretState(state, now);
+        var sum = inputFold.querySelector(".sec-input-summary");
+        if (sum) sum.textContent = now.known === "yes" ? "入れ直す" : "入れる";
+        if (preferred) {
+          var want = now.known === "no";
+          if (want && !preferred.parentNode) card.insertBefore(preferred, inputFold);
+          else if (!want && preferred.parentNode) preferred.parentNode.removeChild(preferred);
+        }
+      };
+    }
+    KEY_CARDS.push(entry);
     return card;
   }