@takagaki/cortex-decisions-viewer 0.12.29 → 0.12.31

package/dist/pending-ops.js

@@ -0,0 +1,874 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// 操作タブの仮置き（pending ops・#388）
+//
+// 「ビルド待ちの操作はすべて即時反映」（決定ログ 2026-09-03）を、操作タブの全操作に
+// 共通の 1 部品で当てる。**能力ごとに個別の仕組みを持たない**（Backlog だけ直して
+// Figma に残した前例を繰り返さない）。
+//
+// 流れ: 保存が成功 → `pendingOpOf` でエントリを作り localStorage に置く →
+// 描画は「本物の設定（4層合成）＋仮置き」を `applyPendingOps` で合成して出す →
+// 本物が追いついたら `prunePendingOps` が捨てる。
+//
+// **ここは純関数と定数だけを置く**（render.ts 冒頭の規約と同じ）。画面側（クライアントJS）は
+// toString() で実体を流し込んで使い、テストは同じ実体を直接呼ぶ。
+// **クロージャを持たないこと。** 参照してよいのは、クライアント側にも同名で注入している
+// 定数（PENDING_OPS_* と PENDING_KINDS）だけ。
+// ⚠ 定数そのものを export しない（CommonJS で `exports.X` に書き換わり、流し込んだ先で落ちる）。
+// テストから読む値は下の PENDING_OPS_LIMITS（入れ物）経由。
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PENDING_OPS_LIMITS = void 0;
+exports.pendingKindsTable = pendingKindsTable;
+exports.pendingOpsKey = pendingOpsKey;
+exports.pendingSlackChannelId = pendingSlackChannelId;
+exports.pendingIsSpaceRef = pendingIsSpaceRef;
+exports.pendingGoogleChatSpaceRef = pendingGoogleChatSpaceRef;
+exports.pendingRepo = pendingRepo;
+exports.pendingFigmaKey = pendingFigmaKey;
+exports.pendingDriveFolderId = pendingDriveFolderId;
+exports.backlogTargetOf = backlogTargetOf;
+exports.pendingIsSlackTeamId = pendingIsSlackTeamId;
+exports.pendingIssuesRef = pendingIssuesRef;
+exports.pendingLabel = pendingLabel;
+exports.pendingOpOf = pendingOpOf;
+exports.sanitizePendingOps = sanitizePendingOps;
+exports.rememberPendingOp = rememberPendingOp;
+exports.pendingSiteTimeMs = pendingSiteTimeMs;
+exports.pendingStale = pendingStale;
+exports.pendingOpBuildCaughtUp = pendingOpBuildCaughtUp;
+exports.pendingLiveRowMatches = pendingLiveRowMatches;
+exports.pendingOpLiveAgrees = pendingOpLiveAgrees;
+exports.pendingCountDelta = pendingCountDelta;
+exports.prunePendingOps = prunePendingOps;
+exports.pendingExternalMatches = pendingExternalMatches;
+exports.pendingExternalRow = pendingExternalRow;
+exports.pendingInternalOf = pendingInternalOf;
+exports.applyPendingOps = applyPendingOps;
+exports.pendingCapsOf = pendingCapsOf;
+exports.pendingRowNote = pendingRowNote;
+/** 念のための自動失効。本物が追いついたことを検出できなくても、これ以上は残さない */
+const PENDING_OPS_TTL_MS = 24 * 60 * 60 * 1000;
+/**
+ * 「保存より後に始まったビルドか」を判断するときの余裕。
+ * **トゥームストーン（TOMBSTONE_MARGIN_MS）・アイコンの仮置きと同じ 30 分**——
+ * 同じ性質の待ちなので、破棄の条件を別に持つと片方だけ直したときに挙動が割れる。
+ */
+const PENDING_OPS_MARGIN_MS = 30 * 60 * 1000;
+/** これだけ経っても live で確かめられない add の行には「反映を確認できていません」を出す */
+const PENDING_OPS_UNCONFIRMED_MS = 30 * 60 * 1000;
+/**
+ * live（op=state の registeredNow）の同意で仮置きを捨ててよくなるまでの余裕。
+ *
+ * 🔴 **保存直後の同意で捨ててはいけない。** op=state の据え置き（60 秒）は Lambda
+ * インスタンス単位のメモリで、保存を受けたインスタンスしか消せない。保存直後の取り直しが
+ * 同意しても、60 秒以内の再読み込み・取り直しが別インスタンスに当たると保存前の答えが返り、
+ * 仮置きを捨てていれば**消したはずの行が復活する**（Issue の症状そのもの・設計レビュー②の重大1）。
+ * 据え置き 60 秒に対して余裕を取り、保存から 5 分は同意しても残す（残っていても害は無い——
+ * remove は無い行を消すだけ・add は本物があれば足さない）。
+ */
+const PENDING_OPS_SETTLE_MS = 5 * 60 * 1000;
+exports.PENDING_OPS_LIMITS = {
+    ttlMs: PENDING_OPS_TTL_MS,
+    marginMs: PENDING_OPS_MARGIN_MS,
+    unconfirmedMs: PENDING_OPS_UNCONFIRMED_MS,
+    settleMs: PENDING_OPS_SETTLE_MS,
+};
+/**
+ * 仮置きの種別（intake の plan.kind と同じ語）→ 画面の能力名・アダプタ・registeredNow のキー。
+ *
+ * `cap` / `adapter` はタイルの「確認中」の鍵（pendingCaps と同じ形）、`reg` は
+ * op=state の registeredNow のキー（live が追いついたかの判定に使う）。
+ * `internal` は同期ソース（internalSources）の kind（Figma / Drive だけ）。
+ */
+const PENDING_KINDS = {
+    slack: { cap: "チャット", adapter: "slack", reg: "chat" },
+    "google-chat": { cap: "チャット", adapter: "google-chat", reg: "google-chat" },
+    github: { cap: "開発", adapter: "github", reg: "dev" },
+    figma: { cap: "デザイン", adapter: "figma", reg: "design", internal: "デザイン" },
+    drive: { cap: "共有資料", adapter: "google-drive", reg: "materials", internal: "共有資料" },
+    backlog: { cap: "課題管理", adapter: "backlog", reg: "issues" },
+};
+/** 対応表の読み出し（定数そのものは export しない・上の注意） */
+function pendingKindsTable() { return PENDING_KINDS; }
+/** localStorage の鍵。案件別（同一ブラウザで複数案件を見ても混ざらない・アイコンと同じ切り方） */
+function pendingOpsKey(projectKey) {
+    return projectKey ? "cortex-pending-ops:" + String(projectKey) : "";
+}
+// ---- URL の切り出し（サーバ logic.mjs の写し。ずれは parity テストが固定する） --------
+//
+// op=config の応答には正規化済みの ID が載らないので、画面側で切り出す。
+// **切り出せなければ仮置きしない**（従来どおり live の読み直しに任せる・安全側）。
+function pendingSlackChannelId(input) {
+    const s = String(input == null ? "" : input).trim();
+    if (/^[CG][A-Z0-9]{6,}$/.test(s))
+        return s;
+    const m = s.match(/\/archives\/([CG][A-Z0-9]{6,})/);
+    if (m)
+        return m[1];
+    // ブラウザのアドレスバーの形（#398）。**team_id は使わない**——どのワークスペースかは
+    // サーバが実測して決める。ここで取るのはチャンネルIDだけ
+    // （team_id の位置の形は shared/secret-names.mjs の isSlackTeamId と同じ。値は採らない）
+    const client = s.match(/^https?:\/\/app\.slack\.com\/client\/[TE][A-Z0-9]{6,20}\/([CG][A-Z0-9]{6,})/);
+    return client ? client[1] : null;
+}
+/**
+ * スペース ref の形（サーバの `GOOGLE_CHAT_SPACE_REF` の写し）。ずれは parity テストが固定する。
+ *
+ * **写しがこのファイルに 2 つあったのを 1 つに寄せた（#398）。** ビューアは infra を
+ * import できないので写し自体は無くせないが、**同じ判定を 2 度書かない**。
+ */
+function pendingIsSpaceRef(v) {
+    return /^spaces\/[A-Za-z0-9_-]+$/.test(String(v == null ? "" : v));
+}
+function pendingGoogleChatSpaceRef(input) {
+    const s = String(input == null ? "" : input).trim();
+    if (!s || s.length > 500)
+        return null;
+    // 素の `spaces/<ID>`（#389）。URL ではないのでホスト検査より前に見る
+    if (pendingIsSpaceRef(s))
+        return s;
+    if (!/^https?:\/\/(?:chat|mail)\.google\.com\//i.test(s))
+        return null;
+    if (/^https?:\/\/chat\.google\.com\/(?:u\/\d+\/)?(?:dm|app\/dm)\//i.test(s) ||
+        /^https?:\/\/mail\.google\.com\/[^#]*#chat\/dm\//i.test(s)) {
+        return null;
+    }
+    const m = s.match(/^https?:\/\/chat\.google\.com\/(?:u\/\d+\/)?(?:room|app\/(?:chat|join|management))\/([^/?#]+)/i) ||
+        s.match(/^https?:\/\/mail\.google\.com\/(?:chat|mail)\/u\/\d+\/[^#]*#chat\/space\/([^/?#]+)/i);
+    if (!m)
+        return null;
+    const ref = "spaces/" + m[1];
+    return pendingIsSpaceRef(ref) ? ref : null;
+}
+function pendingRepo(input) {
+    let s = String(input == null ? "" : input).trim();
+    if (!s)
+        return null;
+    s = s.replace(/^git@github\.com:/, "").replace(/^https?:\/\/github\.com\//, "");
+    s = s.replace(/\.git$/, "").replace(/^\/+/, "");
+    const parts = s.split("/").filter(function (p) { return !!p; });
+    if (parts.length < 2)
+        return null;
+    const repo = (parts[0] + "/" + parts[1]).toLowerCase();
+    return /^[a-z0-9._-]+\/[a-z0-9._-]+$/.test(repo) ? repo : null;
+}
+function pendingFigmaKey(input) {
+    const s = String(input == null ? "" : input).trim();
+    const m = s.match(/figma\.com\/(?:design|file|proto)\/([A-Za-z0-9_-]{8,})/);
+    if (m)
+        return m[1];
+    return /^[A-Za-z0-9_-]{8,}$/.test(s) ? s : null;
+}
+function pendingDriveFolderId(input) {
+    const s = String(input == null ? "" : input).trim();
+    const m = s.match(/\/drive\/(?:u\/\d+\/)?folders\/([A-Za-z0-9_-]+)/) ||
+        s.match(/[?&]id=([A-Za-z0-9_-]+)/);
+    if (m)
+        return m[1];
+    return /^[A-Za-z0-9_-]{10,}$/.test(s) ? s : null;
+}
+/**
+ * Backlog の URL → 接続先（ドメインとプロジェクトキー）。サーバ（logic.mjs の backlogTarget）と同じ形。
+ *
+ * もともと render.ts にあった写し（画面の接続先の復元・保存の突き合わせに使う）を、
+ * 仮置きも同じものを使うようにここへ移した。**写しは 1 つだけ**（parity テストが見張る）。
+ */
+function backlogTargetOf(input) {
+    const s = String(input == null ? "" : input).trim();
+    const m = s.match(/^https?:\/\/([a-z0-9-]+\.(?:backlog\.jp|backlog\.com|backlogtool\.com))\/(.*)$/i);
+    if (!m)
+        return null;
+    const domain = m[1].toLowerCase();
+    const rest = m[2];
+    // **数値のプロジェクトIDは弾く。** 取り違えの検査（艦隊のキーとの照合）を
+    // 迂回できてしまう。Backlog はドキュメントのURLをこの形でも出す
+    const num = /^[0-9]+$/;
+    const head = rest.match(/^(?:projects|document|wiki|find|board|gantt|git)\/([A-Za-z0-9_]+)(?:[/?#]|$)/);
+    if (head)
+        return num.test(head[1]) ? null : { domain: domain, projectKey: head[1].toUpperCase() };
+    const view = rest.match(/^view\/([A-Za-z0-9_]+)-\d+/);
+    if (view)
+        return num.test(view[1]) ? null : { domain: domain, projectKey: view[1].toUpperCase() };
+    return null;
+}
+/**
+ * Slack の team_id の形。**サーバの正本（shared/secret-names.mjs の `isSlackTeamId`）の写し**で、
+ * ずれは parity テストが固定する。
+ *
+ * 🔴 **狭くしないこと。** `T…` だけに絞ると **Enterprise Grid の `E…` を画面が弾き**、
+ * その組織のチャンネルだけ仮置きの行に札が出ない（サーバは受けているのに画面が捨てる形）。
+ */
+function pendingIsSlackTeamId(v) {
+    return /^[TE][A-Z0-9]{6,20}$/.test(String(v == null ? "" : v));
+}
+/** Backlog の接続先の鍵（render.ts の issuesRefOf と同形: ドメイン小文字 / キー大文字） */
+function pendingIssuesRef(domain, projectKey) {
+    return String(domain == null ? "" : domain).toLowerCase() + "/" + String(projectKey == null ? "" : projectKey).toUpperCase();
+}
+// ---- エントリを作る（op → kind / action / targetId の対応表はここ 1 つ） ------------
+/**
+ * 表示名の整形（サーバの cleanLabel の写し: 制御文字を落とし、連続空白を1つに畳み、
+ * 長すぎれば切る）。**空なら空文字**——サーバは null を返すが、画面側は `|| id` の
+ * 落とし先があるので文字列のまま扱う（parity テストは `|| null` にして突き合わせる）。
+ *
+ * 🔴 **連続空白の圧縮を落とさないこと（#391）。** サーバだけが畳むと、名前に連続空白を
+ * 含むチャンネルの update 仮置きが pendingOpLiveAgrees の名前比較で永久に同意せず、
+ * 24 時間（TTL）残り続ける。写しのずれはこの1行だけで起きる。
+ */
+function pendingLabel(s, max) {
+    const v = String(s == null ? "" : s)
+        .replace(/[\u0000-\u001f\u007f]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    const lim = max || 120;
+    return v.length > lim ? v.slice(0, lim) : v;
+}
+/**
+ * `op=config` に送った payload（と、必要なら応答）→ 仮置きのエントリ。作れなければ null。
+ *
+ * @param payload  送った中身（`payload.op` を見る）。refresh-channel-name は送っていない
+ *                 `name`（引けた名前）を呼び出し側が添える
+ * @param ctx      { projectKey, now, generatedAt, targets? }
+ *                 targets は Backlog の解除で表示中の一覧（ドメインを補うため・無くてもよい）
+ *
+ * **応答に正規化済みの ref / name が載るようになったら、ここで `ctx.response` を先に読む**
+ * （intake 側 3 行の追加で Google Chat の名前も即時に出せる。今回は intake を触らない）。
+ */
+function pendingOpOf(payload, ctx) {
+    if (!payload || typeof payload !== "object" || !ctx || !ctx.projectKey)
+        return null;
+    const op = String(payload.op || "");
+    const make = (kind, action, targetId, data) => {
+        const id = targetId == null ? "" : String(targetId);
+        if (!id)
+            return null;
+        return {
+            v: 1,
+            projectKey: String(ctx.projectKey),
+            kind: kind,
+            targetId: id,
+            action: action,
+            payload: data || {},
+            committedAt: typeof ctx.now === "number" ? ctx.now : Date.now(),
+            baseBuildId: typeof ctx.generatedAt === "string" ? ctx.generatedAt : "",
+        };
+    };
+    switch (op) {
+        case "add-channel": {
+            const id = pendingSlackChannelId(payload.url);
+            const data = { name: pendingLabel(payload.name) || id };
+            if (payload.workspace)
+                data.workspace = String(payload.workspace);
+            // **どの組織のチャンネルかは、サーバの実測を応答から受け取る（#391）。**
+            // 画面はワークスペースを送らない（プルダウンは 2026-08-20 に廃止）ので、
+            // これが無いと仮置きの行にだけ組織の札が出ない＝本物の行と見た目が食い違う。
+            // 🔴 **文字列 1 欄で運ぶ**（"unknown" / "internal" / team_id）。真偽値を増やすと
+            // sanitizePendingOps の許可リストの例外が増え、篩が篩の意味を失う。
+            // 応答に無ければ載せない——載せないことが「まだ分からない」の表明になる
+            const org = ctx.response && typeof ctx.response.slackOrg === "string" ? ctx.response.slackOrg : "";
+            if (org)
+                data.slackOrg = org;
+            return make("slack", "add", id, data);
+        }
+        case "remove-channel":
+            return make("slack", "remove", payload.ref);
+        case "refresh-channel-name": {
+            const name = pendingLabel(payload.name);
+            return name ? make("slack", "update", payload.ref, { name: name }) : null;
+        }
+        case "set-notify":
+            return typeof payload.value === "boolean" ? make("slack", "update", payload.ref, { notify: payload.value }) : null;
+        case "add-google-chat-space": {
+            const ref = pendingGoogleChatSpaceRef(payload.url);
+            // 名前は画面に欄が無い（サーバが引く）。live が来るまでは ref で出す
+            return make("google-chat", "add", ref, { name: ref || "" });
+        }
+        case "remove-google-chat-space":
+            return make("google-chat", "remove", payload.ref);
+        case "add-github-source": {
+            const repo = pendingRepo(payload.repo);
+            return make("github", "add", repo, { name: repo || "", type: "github-issues" });
+        }
+        case "remove-github-source":
+            return make("github", "remove", pendingRepo(payload.repo));
+        case "add-figma-file": {
+            const key = pendingFigmaKey(payload.url);
+            return make("figma", "add", key, { name: pendingLabel(payload.name) || key || "" });
+        }
+        case "remove-figma-file":
+            return make("figma", "remove", pendingFigmaKey(payload.url) || payload.key);
+        case "add-drive-folder": {
+            const id = pendingDriveFolderId(payload.url);
+            return make("drive", "add", id, { name: pendingLabel(payload.name) });
+        }
+        case "remove-drive-folder":
+            return make("drive", "remove", pendingDriveFolderId(payload.url) || payload.id);
+        case "backlog-target-add": {
+            const t = backlogTargetOf(payload.url);
+            return t ? make("backlog", "add", pendingIssuesRef(t.domain, t.projectKey), { domain: t.domain, projectKey: t.projectKey }) : null;
+        }
+        case "backlog-target-remove": {
+            // **鍵はドメイン込み（issuesRefOf と同形）。** projectKey だけで丸めると、2 つのドメインに
+            // 同じキーがある案件で片方の解除が両方を消し、live の同意も成立せず 24 時間消えたままになる。
+            // 送る payload にはドメインが無いので、表示中の一覧（ctx.targets）から引く。引けなければ仮置きしない
+            const key = String(payload.backlogProjectKey || "").trim().toUpperCase();
+            if (!/^[A-Z0-9_]{1,64}$/.test(key))
+                return null;
+            let domain = "";
+            for (const t of (ctx.targets || [])) {
+                if (t && String(t.projectKey || "").toUpperCase() === key && t.domain) {
+                    domain = String(t.domain);
+                    break;
+                }
+            }
+            return domain ? make("backlog", "remove", pendingIssuesRef(domain, key)) : null;
+        }
+        default:
+            return null;
+    }
+}
+// ---- localStorage の生値の検査 -------------------------------------------------
+/**
+ * localStorage の生値 → 通ってよいエントリだけ。**通らなかったものは黙って落とす。**
+ * 形の版（v）と案件キーはアイコンの仮置きと同じ検査。
+ */
+function sanitizePendingOps(raw, projectKey) {
+    const out = [];
+    if (!Array.isArray(raw) || !projectKey)
+        return out;
+    for (const e of raw) {
+        if (!e || typeof e !== "object")
+            continue;
+        if (e.v !== 1 || e.projectKey !== String(projectKey))
+            continue;
+        if (!PENDING_KINDS[e.kind])
+            continue;
+        if (e.action !== "add" && e.action !== "remove" && e.action !== "update")
+            continue;
+        if (typeof e.targetId !== "string" || !e.targetId)
+            continue;
+        if (typeof e.committedAt !== "number" || !isFinite(e.committedAt))
+            continue;
+        const payload = {};
+        const src = e.payload && typeof e.payload === "object" ? e.payload : {};
+        // 通してよい payload の欄（葉は文字列か、notify だけ真偽値）。関数の中に置くのは、
+        // クライアントへ toString() で流し込んだ先でも同じ一覧を参照できるようにするため
+        const fields = ["name", "workspace", "notify", "domain", "projectKey", "type", "slackOrg"];
+        for (const f of fields) {
+            if (!Object.prototype.hasOwnProperty.call(src, f))
+                continue;
+            if (f === "notify") {
+                if (src[f] === true || src[f] === false)
+                    payload[f] = src[f];
+            }
+            else if (typeof src[f] === "string")
+                payload[f] = src[f];
+        }
+        out.push({
+            v: 1,
+            projectKey: String(projectKey),
+            kind: e.kind,
+            targetId: e.targetId,
+            action: e.action,
+            payload: payload,
+            committedAt: e.committedAt,
+            baseBuildId: typeof e.baseBuildId === "string" ? e.baseBuildId : "",
+        });
+    }
+    out.sort(function (a, b) { return a.committedAt - b.committedAt; });
+    return out;
+}
+// ---- 後勝ちの合成 ----------------------------------------------------------
+/**
+ * 同じ (kind, targetId) は後勝ち。
+ * - add / remove は既存を全部捨てて置き換える（add → remove で行は消え、remove → add で戻る）
+ * - update は既存の add があれば**その payload に畳む**（add の行を残す）。無ければ既存の
+ *   update と payload を合成して置き換える（name と notify は別の操作で入るので、欄をまたいで捨てない）
+ */
+function rememberPendingOp(list, entry) {
+    const cur = list || [];
+    if (!entry)
+        return cur.slice();
+    const same = function (e) { return e.kind === entry.kind && e.targetId === entry.targetId; };
+    if (entry.action === "update") {
+        let folded = false;
+        const out = cur.map(function (e) {
+            if (!same(e) || e.action !== "add")
+                return e;
+            folded = true;
+            const merged = {};
+            for (const k in e.payload)
+                if (Object.prototype.hasOwnProperty.call(e.payload, k))
+                    merged[k] = e.payload[k];
+            for (const k in entry.payload)
+                if (Object.prototype.hasOwnProperty.call(entry.payload, k))
+                    merged[k] = entry.payload[k];
+            return { v: 1, projectKey: e.projectKey, kind: e.kind, targetId: e.targetId, action: e.action, payload: merged, committedAt: e.committedAt, baseBuildId: e.baseBuildId };
+        });
+        if (folded)
+            return out;
+        // 既存の update があれば **payload を合成して** 置き換える（add に畳むときと同じ）。
+        // 欄ごとに捨てると、通知先 ON → 名前の取り直し の順に押したとき notify の仮置きが消え、
+        // 据え置きの窓で再読み込みすると通知先が OFF に見える（実装レビュー④）
+        const merged = {};
+        for (const e of cur) {
+            if (!same(e) || e.action !== "update")
+                continue;
+            for (const k in e.payload)
+                if (Object.prototype.hasOwnProperty.call(e.payload, k))
+                    merged[k] = e.payload[k];
+        }
+        for (const k in entry.payload)
+            if (Object.prototype.hasOwnProperty.call(entry.payload, k))
+                merged[k] = entry.payload[k];
+        const rest = cur.filter(function (e) { return !(same(e) && e.action === "update"); });
+        rest.push({ v: 1, projectKey: entry.projectKey, kind: entry.kind, targetId: entry.targetId, action: entry.action, payload: merged, committedAt: entry.committedAt, baseBuildId: entry.baseBuildId });
+        return rest;
+    }
+    const kept = cur.filter(function (e) { return !same(e); });
+    kept.push(entry);
+    return kept;
+}
+// ---- 失効 ----------------------------------------------------------------
+/** SITE.generatedAt（"2026-09-03 00:00 UTC" / ISO）→ ms。読めなければ NaN */
+function pendingSiteTimeMs(s) {
+    if (typeof s !== "string" || !s)
+        return NaN;
+    return Date.parse(s.replace(" UTC", "Z").replace(" ", "T"));
+}
+/**
+ * **「操作より後のビルドが来たか」の唯一の判定（#391）。**
+ *
+ * 削除のトゥームストーン・アイコンの反映待ち・操作タブの仮置きは、どれも「押した結果が
+ * 次のビルドで本物になるまでブラウザが覚えておく」という同じ性質の待ちで、破棄の条件も
+ * 同じだった。**同じものが 3 実装あると、片方だけ直したときに挙動が割れる**（値が同じ
+ * うちは誰も気づかない）ので、ここ 1 つに寄せてある。
+ *
+ * 判定: いま画面が持っている世代（nowMs）が、**押した時刻＋余裕**と**押したとき見ていた
+ * 世代＋余裕**の両方より新しい。generatedAt はコミット時点ではない——押す前に始まった
+ * ビルドが後から完成すると、世代は押した時刻より新しいのに操作は入っていない。
+ * ビルドの所要時間とクライアント時計のずれを見て余裕（既定 30 分）を取る。
+ *
+ * **主軸はサーバ時刻同士の比較**（現行の世代と、押した画面の gen0）。クライアントの時計が
+ * 大きく狂っていても機能が丸ごとは死なない（進んだ時計なら破棄が遅れるだけ）。
+ * gen0 を持たない古い形式のエントリは at だけで見る（後方互換・安全側）。
+ * nowMs が読めない（NaN）ときは false ＝**隠し続ける／残し続ける側に倒す**（嘘の再表示より安全）。
+ *
+ * @param at     押した時刻（ms・クライアント時計）
+ * @param gen0   押した画面の世代（generatedAt の文字列）。読めなければ at だけで見る
+ * @param nowMs  いまの世代（ms）
+ *
+ * ⚠ 余裕は引数にしない。3 経路とも 30 分で、可変にすると**呼び出しが 1 つも無い引数**が
+ * 残る（壊しても何も起きない＝変異検証の網から静かに漏れる形）。
+ */
+function pendingStale(at, gen0, nowMs) {
+    const margin = PENDING_OPS_MARGIN_MS;
+    if (typeof nowMs !== "number" || isNaN(nowMs))
+        return false;
+    if (typeof at !== "number" || !isFinite(at))
+        return false;
+    if (!(nowMs > at + margin))
+        return false;
+    const g = pendingSiteTimeMs(gen0);
+    if (isNaN(g))
+        return true;
+    return nowMs > g + margin;
+}
+/**
+ * 本物の一覧の世代が追いついたか。**判定の実体は pendingStale**（トゥームストーン・
+ * アイコンの反映待ちと同じもの・#391）。
+ *
+ * 🔴 **世代は「一覧の下地」のもの（fleet-status の generatedAt）を渡すこと。** ページの
+ * generatedAt（SITE.generatedAt）は記録の追加でも進むが、一覧の下地は夜間の自己チェックの
+ * 成果物なので、ページが新しくても下地は古いままのことがある（設計レビュー②の中3）。
+ * 生成時刻はコミット時点ではない（保存前に始まった実行が後から完成する）ので余裕を取る。
+ */
+function pendingOpBuildCaughtUp(e, siteNowMs) {
+    if (!e)
+        return false;
+    return pendingStale(e.committedAt, e.baseBuildId, siteNowMs);
+}
+/** registeredNow の行が、このエントリの対象か */
+function pendingLiveRowMatches(kind, r, targetId) {
+    if (!r)
+        return false;
+    if (kind === "figma")
+        return String(r.key) === targetId;
+    if (kind === "drive")
+        return String(r.id) === targetId;
+    if (kind === "backlog")
+        return pendingIssuesRef(r.domain, r.projectKey) === targetId;
+    return String(r.ref) === targetId;
+}
+/**
+ * live（op=state の registeredNow）が仮置きと同じことを言っているか。
+ *
+ * **保存から 5 分（PENDING_OPS_SETTLE_MS）を過ぎてから出した要求の答えだけを信じる。**
+ * 据え置きの古い答えが仮置きと食い違っていても残す——その局面こそ仮置きが要る場面。
+ * 5 分以内の同意で捨てないのは、別インスタンスの据え置きが保存前の答えを返す窓があるため
+ * （PENDING_OPS_SETTLE_MS の項）。同意していれば本物の行が出ているので、残っていても害は無い。
+ * その kind のキーが配列で無ければ判断しない（読めなかった＝分からない）。
+ */
+function pendingOpLiveAgrees(e, live, liveAt) {
+    if (!e || !live || typeof live !== "object")
+        return false;
+    // 保存から据え置きの余裕（PENDING_OPS_SETTLE_MS）を過ぎてから出した要求の答えだけを信じる
+    if (typeof liveAt !== "number" || !(liveAt >= e.committedAt + PENDING_OPS_SETTLE_MS))
+        return false;
+    const meta = PENDING_KINDS[e.kind];
+    if (!meta)
+        return false;
+    const rows = live[meta.reg];
+    if (!Array.isArray(rows))
+        return false;
+    let found = null;
+    for (const r of rows)
+        if (pendingLiveRowMatches(e.kind, r, e.targetId)) {
+            found = r;
+            break;
+        }
+    if (e.action === "remove") {
+        if (found)
+            return false;
+        // 🔴 **github は「読み取り停止中」（exclude）の行が live の dev に載らない（#391）。**
+        // dev だけを見ると、exclude された行の remove は**保存が効く前から**「無い＝同意」に
+        // なり、5 分で仮置きが捨てられて、まとめ表の行が次のビルドまで戻る（点滅する）。
+        // devExcluded を返すサーバなら、そちらにも無いことまで確かめてから同意する。
+        // 返さない古いサーバでは従来どおり（dev だけ）——判断材料が無いのに厳しくすると、
+        // 普通のリポジトリの解除まで 24 時間残る
+        if (e.kind === "github" && Array.isArray(live.devExcluded)) {
+            for (const r of live.devExcluded)
+                if (pendingLiveRowMatches(e.kind, r, e.targetId))
+                    return false;
+        }
+        return true;
+    }
+    if (e.action === "add")
+        return !!found;
+    if (!found)
+        return false;
+    const p = e.payload || {};
+    // 名前は緩く比べる（サーバは cleanLabel 済み・画面は先頭の # を剥いで出す）。厳密一致だと
+    // 表記の差だけで 24 時間残る
+    const loose = function (s) { return String(s == null ? "" : s).trim().replace(/^#+/, ""); };
+    if (typeof p.name === "string" && loose(found.name) !== loose(p.name))
+        return false;
+    if (typeof p.notify === "boolean" && (found.notify === true) !== p.notify)
+        return false;
+    return true;
+}
+/**
+ * タイルの「登録件数」に仮置きを加減する（設計レビュー②の重大2）。
+ *
+ * タイルと接続マップの語は registeredNow の**件数**から導く（registeredCountOf → deriveCapTile）ので、
+ * 一覧だけ仮置きで足し引きしても「行は消えたのにタイルは登録済み 1 件」「行は 1 件なのに未接続」が並ぶ。
+ * live の行に無い add は +1、live の行に在る remove は −1（本物が既に追いついていれば 0）。
+ *
+ * @param live registeredNow（無ければ 0）
+ * @param regKey registeredNow のキー（chat / google-chat / dev / design / materials / issues）
+ */
+function pendingCountDelta(list, live, regKey) {
+    const rows = live && typeof live === "object" && Array.isArray(live[regKey]) ? live[regKey] : null;
+    if (!rows)
+        return 0;
+    let delta = 0;
+    for (const e of list || []) {
+        const meta = e && PENDING_KINDS[e.kind];
+        if (!meta || meta.reg !== regKey)
+            continue;
+        let found = false;
+        for (const r of rows)
+            if (pendingLiveRowMatches(e.kind, r, e.targetId)) {
+                found = true;
+                break;
+            }
+        if (e.action === "add" && !found)
+            delta += 1;
+        if (e.action === "remove" && found)
+            delta -= 1;
+    }
+    return delta;
+}
+/**
+ * 失効したエントリを落とす。
+ *
+ * @param ctx { now: Date.now(), siteNowMs: 画面の generatedAt の ms, live: LIVE_REGISTERED, liveAt: live が届いた時刻 }
+ */
+function prunePendingOps(list, ctx) {
+    const c = ctx || {};
+    const now = typeof c.now === "number" ? c.now : Date.now();
+    return (list || []).filter(function (e) {
+        if (!e)
+            return false;
+        if (now > e.committedAt + PENDING_OPS_TTL_MS)
+            return false;
+        if (pendingOpBuildCaughtUp(e, c.siteNowMs))
+            return false;
+        if (pendingOpLiveAgrees(e, c.live, c.liveAt))
+            return false;
+        return true;
+    });
+}
+// ---- 合成 ----------------------------------------------------------------
+/** 外部ソース（externalSources）の行が、このエントリの対象か。Slack は ref のみ（subtractRemovedRegistered と同じ理由） */
+function pendingExternalMatches(kind, s, targetId) {
+    if (!s || !s.ref || String(s.ref) !== targetId)
+        return false;
+    if (kind === "slack")
+        return s.type === "slack";
+    if (kind === "google-chat")
+        return s.type === "google-chat";
+    if (kind === "github")
+        return String(s.type || "").indexOf("github") === 0;
+    return false;
+}
+/** 仮置きの add で足す行（registeredRowsToAdd と同じ形＋ pending の印） */
+function pendingExternalRow(e) {
+    const p = e.payload || {};
+    const row = {};
+    if (e.kind === "slack") {
+        row.type = "slack";
+        row.name = p.name || e.targetId;
+        row.ref = e.targetId;
+        // channels.json に書いた行＝ derived（dev-sources 側の宣言ではない）
+        row.origin = "derived";
+        if (p.workspace)
+            row.workspace = p.workspace;
+        if (p.notify === true)
+            row.notify = true;
+        // **サーバが実測した組織を、本物の行と同じ欄に展開する（#391）。**
+        // 展開できたときだけ pendingOrg を立てる——立っていない行に札を出すと、
+        // 測れていないのに「クラスメソッド」と名乗る（画面側の既定がそれなので）
+        // 値は 3 通りだけ通す（"unknown" / "internal" / team_id）。**"internal" を team_id として
+        // 札に出さない**ための門で、形の検査はサーバの正本（pendingIsSlackTeamId）と同じにする
+        // ——狭くすると Enterprise Grid（E…）の組織だけ札が出ない
+        const org = typeof p.slackOrg === "string" ? p.slackOrg : "";
+        if (org === "unknown") {
+            row.pendingOrg = true;
+            row.orgUnknown = true;
+        }
+        else if (org === "internal") {
+            row.pendingOrg = true;
+        }
+        else if (pendingIsSlackTeamId(org)) {
+            row.pendingOrg = true;
+            row.workspace = org;
+        }
+    }
+    else if (e.kind === "google-chat") {
+        row.type = "google-chat";
+        row.name = p.name || e.targetId;
+        row.ref = e.targetId;
+    }
+    else {
+        row.type = p.type || "github-issues";
+        row.name = e.targetId;
+        row.ref = e.targetId;
+        row.origin = "explicit";
+    }
+    row.pending = true;
+    row.pendingAt = e.committedAt;
+    return row;
+}
+function pendingInternalOf(list, kind) {
+    for (const s of list || [])
+        if (s && s.kind === kind)
+            return s;
+    return null;
+}
+/**
+ * 本物の設定（4層合成の結果）に仮置きを重ねる。**描画の手前のここ 1 箇所で合成する**
+ * （一覧・タイル・接続マップの注記は全部 fleetVal を通るので、描画側に散らすと食い違う）。
+ *
+ * - remove: 行を消す。Drive は 0 件になったら `on → empty`、Backlog は単数欄を先頭に揃える
+ *   （subtractRemovedRegistered と同じ倒し方）
+ * - add: 同じ鍵の行が**既にあれば何もしない**（本物が先に来ている）。無ければ
+ *   registeredRowsToAdd と同じ形の行を足し、`pending: true` / `pendingAt` を付ける
+ *   （Drive は行が ID 文字列なので `drivePending: { id: committedAt }` を内部ソースに付ける）
+ * - update: Slack の `name` / `notify` だけ差し替える
+ */
+function applyPendingOps(view, list) {
+    const v = view || {};
+    const ops = list || [];
+    if (!ops.length)
+        return v;
+    let externals = (v.externalSources || []).slice();
+    let internals = (v.internalSources || []).slice();
+    let bt = v.backlogTarget;
+    let extChanged = false;
+    let intChanged = false;
+    let btChanged = false;
+    const putInternal = function (kind, patch) {
+        for (let i = 0; i < internals.length; i++) {
+            if (internals[i] && internals[i].kind === kind) {
+                internals[i] = Object.assign({}, internals[i], patch);
+                return;
+            }
+        }
+        internals.push(Object.assign({ kind: kind }, patch));
+    };
+    for (const e of ops) {
+        if (!e || !PENDING_KINDS[e.kind])
+            continue;
+        const p = e.payload || {};
+        if (e.kind === "slack" || e.kind === "google-chat" || e.kind === "github") {
+            const idx = externals.findIndex(function (s) { return pendingExternalMatches(e.kind, s, e.targetId); });
+            if (e.action === "remove") {
+                // **Slack は origin が "derived" の行だけ消す**（subtractRemovedRegistered と同じ守り）。
+                // dev-sources.json 側にも宣言された行（both / explicit）は channels.json から消しても
+                // エンジンがまだ読む——消すと「読まれているのに画面に無い」逆向きの嘘になり、
+                // live が追いついた後に復活する（設計レビュー②の中5）。そういう行は従来どおり取り消し線のまま
+                //
+                // **「読み取り停止中」（goldState: "excluded"）の GitHub 行も、押したら消す（#391）。**
+                // サーバの applyRemoveGithubSource は sources と exclude の両方から実際に消すので、
+                // 保存は完全に効いている。ここで守ると「押しても何も起きない」＝保存が失敗したのと
+                // 区別が付かない。消えたままにする仕掛けは 2 つ: 同意の判定（pendingOpLiveAgrees が
+                // devExcluded も見る）と、引き算（subtractRemovedRegistered が devExcluded で判断する）
+                const removable = function (s) {
+                    return pendingExternalMatches(e.kind, s, e.targetId) && (e.kind !== "slack" || s.origin === "derived");
+                };
+                if (!externals.some(removable))
+                    continue;
+                externals = externals.filter(function (s) { return !removable(s); });
+                extChanged = true;
+            }
+            else if (e.action === "add") {
+                if (idx >= 0)
+                    continue;
+                externals.push(pendingExternalRow(e));
+                extChanged = true;
+            }
+            else if (e.kind === "slack" && idx >= 0) {
+                const patch = {};
+                if (typeof p.name === "string" && p.name)
+                    patch.name = p.name;
+                if (typeof p.notify === "boolean")
+                    patch.notify = p.notify;
+                externals[idx] = Object.assign({}, externals[idx], patch);
+                extChanged = true;
+            }
+        }
+        else if (e.kind === "figma") {
+            const cur = pendingInternalOf(internals, "デザイン");
+            const files = (cur && cur.figmaFiles) || [];
+            const has = files.some(function (f) { return f && String(f.key) === e.targetId; });
+            if (e.action === "remove") {
+                if (!has)
+                    continue;
+                putInternal("デザイン", { figmaFiles: files.filter(function (f) { return !f || String(f.key) !== e.targetId; }) });
+                intChanged = true;
+            }
+            else if (e.action === "add") {
+                if (has)
+                    continue;
+                putInternal("デザイン", { figmaFiles: files.concat([{ key: e.targetId, name: p.name || e.targetId, pending: true, pendingAt: e.committedAt }]) });
+                intChanged = true;
+            }
+        }
+        else if (e.kind === "drive") {
+            const cur = pendingInternalOf(internals, "共有資料");
+            const ids = (cur && cur.driveFolderIds) || [];
+            const has = ids.indexOf(e.targetId) >= 0;
+            if (e.action === "remove") {
+                if (!has)
+                    continue;
+                const kept = ids.filter(function (id) { return id !== e.targetId; });
+                const names = {};
+                for (const id of kept)
+                    if (cur.driveFolderNames && cur.driveFolderNames[id])
+                        names[id] = cur.driveFolderNames[id];
+                const patch = { driveFolderIds: kept, driveFolderNames: names };
+                if (cur.drivePending && cur.drivePending[e.targetId] != null) {
+                    const pend = Object.assign({}, cur.drivePending);
+                    delete pend[e.targetId];
+                    patch.drivePending = pend;
+                }
+                // 0 件になったら empty に倒す（on のときだけ。broken / off は別の答えなので潰さない）
+                if (!kept.length && cur.driveState === "on")
+                    patch.driveState = "empty";
+                putInternal("共有資料", patch);
+                intChanged = true;
+            }
+            else if (e.action === "add") {
+                if (has)
+                    continue;
+                const names = Object.assign({}, (cur && cur.driveFolderNames) || {});
+                if (p.name)
+                    names[e.targetId] = p.name;
+                const pend = Object.assign({}, (cur && cur.drivePending) || {});
+                pend[e.targetId] = e.committedAt;
+                const patch = { driveFolderIds: ids.concat([e.targetId]), driveFolderNames: names, drivePending: pend };
+                // 一覧そのものが driveState 無しでは描かれない。無い／0 件（empty）なら on にする
+                if (!cur || !cur.driveState || cur.driveState === "empty")
+                    patch.driveState = "on";
+                putInternal("共有資料", patch);
+                intChanged = true;
+            }
+        }
+        else if (e.kind === "backlog") {
+            const cur = bt && Array.isArray(bt.targets) ? bt.targets : bt && bt.domain && bt.projectKey ? [bt] : [];
+            // 突き合わせはドメイン込み（同じキーが 2 つのドメインにある案件で片方だけを消す）
+            const has = cur.some(function (t) { return t && pendingIssuesRef(t.domain, t.projectKey) === e.targetId; });
+            let next = null;
+            if (e.action === "remove" && has) {
+                next = cur.filter(function (t) { return !t || pendingIssuesRef(t.domain, t.projectKey) !== e.targetId; });
+            }
+            else if (e.action === "add" && !has && p.domain && p.projectKey) {
+                next = cur.concat([{ domain: p.domain, projectKey: p.projectKey, pending: true, pendingAt: e.committedAt }]);
+            }
+            if (!next)
+                continue;
+            const patch = Object.assign({}, bt || {}, { targets: next });
+            if (next.length) {
+                patch.domain = next[0].domain;
+                patch.projectKey = next[0].projectKey;
+            }
+            else {
+                delete patch.domain;
+                delete patch.projectKey;
+            }
+            bt = patch;
+            btChanged = true;
+        }
+    }
+    if (!extChanged && !intChanged && !btChanged)
+        return v;
+    const out = Object.assign({}, v);
+    if (extChanged)
+        out.externalSources = externals;
+    if (intChanged)
+        out.internalSources = internals;
+    if (btChanged)
+        out.backlogTarget = bt;
+    return out;
+}
+// ---- タイルと行の語 --------------------------------------------------------
+/**
+ * 仮置きを持つ能力／アダプタの鍵（pendingCaps と同じ形: `能力` と `能力\tアダプタ`）。
+ * タイルは「登録状況を確認中です」に倒す——仮置きの add で 0 → 1 件になった能力に
+ * 「未接続」と言わせないため（語は増やさない）。
+ */
+function pendingCapsOf(list) {
+    const out = {};
+    for (const e of list || []) {
+        const meta = e && PENDING_KINDS[e.kind];
+        if (!meta)
+            continue;
+        out[meta.cap] = 1;
+        out[meta.cap + "\t" + meta.adapter] = 1;
+    }
+    return out;
+}
+/**
+ * 仮置きの行に出す語。印の無い行は空文字。
+ * 「反映待ち」／ 30 分経っても live で確かめられなければ「反映を確認できていません」。
+ */
+function pendingRowNote(row, nowMs) {
+    if (!row || row.pending !== true)
+        return "";
+    if (typeof row.pendingAt === "number" && typeof nowMs === "number" && nowMs > row.pendingAt + PENDING_OPS_UNCONFIRMED_MS) {
+        return "反映を確認できていません";
+    }
+    return "反映待ち";
+}