@takagaki/cortex-decisions-viewer 0.12.29 → 0.12.30

package/dist/pending-ops.js

@@ -0,0 +1,751 @@
+"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.pendingGoogleChatSpaceRef = pendingGoogleChatSpaceRef;
+exports.pendingRepo = pendingRepo;
+exports.pendingFigmaKey = pendingFigmaKey;
+exports.pendingDriveFolderId = pendingDriveFolderId;
+exports.backlogTargetOf = backlogTargetOf;
+exports.pendingIssuesRef = pendingIssuesRef;
+exports.pendingLabel = pendingLabel;
+exports.pendingOpOf = pendingOpOf;
+exports.sanitizePendingOps = sanitizePendingOps;
+exports.rememberPendingOp = rememberPendingOp;
+exports.pendingSiteTimeMs = pendingSiteTimeMs;
+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,})/);
+    return m ? m[1] : null;
+}
+function pendingGoogleChatSpaceRef(input) {
+    const s = String(input == null ? "" : input).trim();
+    if (!s || s.length > 500)
+        return null;
+    if (!/^https?:\/\/(?:chat|mail)\.google\.com\//i.test(s))
+        return null;
+    if (/^https?:\/\/chat\.google\.com\/(?:u\/\d+\/)?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\/([^/?#]+)/i) ||
+        s.match(/^https?:\/\/mail\.google\.com\/(?:chat|mail)\/u\/\d+\/[^#]*#chat\/space\/([^/?#]+)/i);
+    if (!m)
+        return null;
+    const ref = "spaces/" + m[1];
+    return /^spaces\/[A-Za-z0-9_-]+$/.test(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;
+}
+/** 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 と同じ考え方: 制御文字を落とし、長すぎれば切る） */
+function pendingLabel(s, max) {
+    const v = String(s == null ? "" : s).replace(/[\u0000-\u001f\u007f]/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);
+            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"];
+        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"));
+}
+/**
+ * 本物の一覧の世代が追いついたか。**判定の形はアイコン（iconPendingStale）・トゥームストーンと同じ**
+ * ——いま画面が持っている世代が、保存時刻＋余裕 と 保存時に見ていた世代＋余裕 の両方より新しい。
+ *
+ * 🔴 **世代は「一覧の下地」のもの（fleet-status の generatedAt）を渡すこと。** ページの
+ * generatedAt（SITE.generatedAt）は記録の追加でも進むが、一覧の下地は夜間の自己チェックの
+ * 成果物なので、ページが新しくても下地は古いままのことがある（設計レビュー②の中3）。
+ * 生成時刻はコミット時点ではない（保存前に始まった実行が後から完成する）ので余裕を取る。
+ */
+function pendingOpBuildCaughtUp(e, siteNowMs) {
+    if (!e || typeof siteNowMs !== "number" || isNaN(siteNowMs))
+        return false;
+    const byAt = siteNowMs > e.committedAt + PENDING_OPS_MARGIN_MS;
+    const gen0 = pendingSiteTimeMs(e.baseBuildId);
+    if (isNaN(gen0))
+        return byAt;
+    return byAt && siteNowMs > gen0 + PENDING_OPS_MARGIN_MS;
+}
+/** 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")
+        return !found;
+    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;
+    }
+    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）。そういう行は従来どおり取り消し線のまま
+                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 "反映待ち";
+}

package/dist/render.js

@@ -32,6 +32,8 @@ exports.deriveCapTile = deriveCapTile;
 exports.renderConnectionMap = renderConnectionMap;
 const node_crypto_1 = require("node:crypto");
 const meet_guide_images_1 = require("./meet-guide-images");
+// 操作タブの仮置き（#388）。判定の実体はあちら——ここは流し込みと配線だけ
+const pending_ops_1 = require("./pending-ops");
 /**
  * SiteDataをHTMLにレンダリングする。
  *
@@ -477,7 +479,8 @@ function capabilityDisplayState(cap, caps) {
     return s === "empty" ? "unset" : s;
 }
 /**
- * 貼られたURLから Backlog の接続先を読む。
+ * 貼られたURLから Backlog の接続先を読む——実体は pending-ops.ts の backlogTargetOf
+ *（仮置きも同じ切り出しを使うので、写しを 1 つにするためあちらへ移した・#388）。
  *
  * **クライアントへは .toString() で渡す。** テンプレート文字列の中に正規表現を
  * 手で書くと、バックスラッシュが二重に潰れて別物になる（実際に
@@ -486,26 +489,8 @@ function capabilityDisplayState(cap, caps) {
  *
  * **判定の正本は Lambda 側**（そちらが書き込む）。ここは確認文の表示用で、
  * 食い違うと「画面はこう見せたのに別のものが書かれた」になるので、
- * 同じ形かをテストで突き合わせている。
+ * 同じ形かをテストで突き合わせている（pending-ops-parity.test.mjs）。
  */
-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;
-}
 // ---------------------------------------------------------------------------
 // 画面が「まだ答えが無い」あいだの見切り。
 //
@@ -2952,6 +2937,8 @@ a.ds-tile:hover { text-decoration: none; }
 /* どの Slack ワークスペースのチャンネルか（#104）。**由来のバッジと同じ強さにする**——
    「Gold 対象か」より弱い、どれのことかを見分けるための情報。強くすると判断のバッジと競る */
 .badge.ds-workspace { background: transparent; color: var(--muted); border: 1px solid var(--border); }
+/* 仮置きの行の印（#388）。控えめに——本物が追いつけば消える印なので目立たせない */
+.badge.ds-pending-badge { background: transparent; color: var(--muted); border: 1px dashed var(--border); font-weight: 500; }
 /* 接続済み Slack ワークスペースの一覧（#104）。追加フォームの中に置く */
 .ds-ws-list { display: flex; flex-direction: column; gap: 6px; margin: 8px 0 10px; }
 .ds-ws { display: flex; align-items: baseline; gap: 10px; flex-wrap: wrap; font-size: 12.5px; }
@@ -3390,7 +3377,7 @@ ${adapterResolved.toString()}
 ${capabilityAdapter.toString()}
 ${capabilityRawState.toString()}
 ${capabilityDisplayState.toString()}
-${backlogTargetOf.toString()}
+${pending_ops_1.backlogTargetOf.toString()}
 ${issuesRefOf.toString()}
 ${sourceNeedsAttention.toString()}
 ${capabilityState.toString()}
@@ -3417,6 +3404,36 @@ ${subtractRemovedRegistered.toString()}
 ${registeredRowsToAdd.toString()}
 ${unsettledRegisteredCount.toString()}
 ${mergeRegisteredFleet.toString()}
+  // 操作タブの仮置き（#388）。**判定の実体は pending-ops.ts**——画面側に書き写すと
+  // 対応表が2枚になる。定数は同名で注入する（流し込んだ関数がこの名前を参照する）
+var PENDING_OPS_TTL_MS = ${JSON.stringify(pending_ops_1.PENDING_OPS_LIMITS.ttlMs)};
+var PENDING_OPS_MARGIN_MS = ${JSON.stringify(pending_ops_1.PENDING_OPS_LIMITS.marginMs)};
+var PENDING_OPS_UNCONFIRMED_MS = ${JSON.stringify(pending_ops_1.PENDING_OPS_LIMITS.unconfirmedMs)};
+var PENDING_OPS_SETTLE_MS = ${JSON.stringify(pending_ops_1.PENDING_OPS_LIMITS.settleMs)};
+var PENDING_KINDS = ${JSON.stringify((0, pending_ops_1.pendingKindsTable)())};
+${pending_ops_1.pendingOpsKey.toString()}
+${pending_ops_1.pendingSlackChannelId.toString()}
+${pending_ops_1.pendingGoogleChatSpaceRef.toString()}
+${pending_ops_1.pendingRepo.toString()}
+${pending_ops_1.pendingFigmaKey.toString()}
+${pending_ops_1.pendingDriveFolderId.toString()}
+${pending_ops_1.pendingLabel.toString()}
+${pending_ops_1.pendingOpOf.toString()}
+${pending_ops_1.sanitizePendingOps.toString()}
+${pending_ops_1.rememberPendingOp.toString()}
+${pending_ops_1.pendingSiteTimeMs.toString()}
+${pending_ops_1.pendingOpBuildCaughtUp.toString()}
+${pending_ops_1.pendingLiveRowMatches.toString()}
+${pending_ops_1.pendingOpLiveAgrees.toString()}
+${pending_ops_1.prunePendingOps.toString()}
+${pending_ops_1.pendingExternalMatches.toString()}
+${pending_ops_1.pendingExternalRow.toString()}
+${pending_ops_1.pendingInternalOf.toString()}
+${pending_ops_1.applyPendingOps.toString()}
+${pending_ops_1.pendingCapsOf.toString()}
+${pending_ops_1.pendingRowNote.toString()}
+${pending_ops_1.pendingCountDelta.toString()}
+${pending_ops_1.pendingIssuesRef.toString()}
 var STATE_STATUSES = ${JSON.stringify(STATE_STATUSES)};
 var STATE_ROW_FIELDS = ${JSON.stringify(STATE_ROW_FIELDS)};
 ${sanitizeStateNow.toString()}
@@ -6073,6 +6090,91 @@ ${deriveCapTile.toString()}
    * 指すのか説明できなくなる（realtime を別に持っているのと同じ理由）。
    */
   var LIVE_REGISTERED = null;
+  /**
+   * いまの LIVE_REGISTERED を取りに行った時刻（op=state の要求を出した時刻・#388）。
+   * 仮置きの失効「保存より後の live が同じことを言っている」の根拠。届いた時刻ではなく
+   * **出した時刻**——保存前に出した要求の答えが保存後に届いても、保存前の内容だから
+   */
+  var LIVE_REGISTERED_AT = null;
+  /**
+   * 操作タブの仮置き（#388・「ビルド待ちの操作はすべて即時反映」の全面適用）。
+   *
+   * 保存が効いた操作を localStorage に置き、本物（4層合成の結果）に重ねて描く。
+   * 本物が追いついたら prunePendingOps が捨てる。**読み書きはこの4つの関数だけ**が行う。
+   * null は「まだ読んでいない」。読んだ後は配列（空でも）。
+   */
+  var PENDING_OPS = null;
+  function pendingOpsStoreKey() {
+    return pendingOpsKey(SITE.intake ? SITE.intake.projectKey : "");
+  }
+  function readPendingOps() {
+    var key = pendingOpsStoreKey();
+    if (!key) return [];
+    try {
+      var raw = localStorage.getItem(key);
+      return raw ? sanitizePendingOps(JSON.parse(raw), SITE.intake.projectKey) : [];
+    } catch (e) { return []; }
+  }
+  function writePendingOps(list) {
+    var key = pendingOpsStoreKey();
+    if (!key) return;
+    // 書けなくても操作は成功したまま進める（次の取り直し・次のビルドで本物が出る）
+    try {
+      if (list && list.length) localStorage.setItem(key, JSON.stringify(list));
+      else localStorage.removeItem(key);
+    } catch (e) {}
+  }
+  /**
+   * いま効いている仮置き。**呼ぶたびに失効を評価する**（安いので）。減ったら書き戻し、
+   * 合成のキャッシュ（MERGED）も捨てる——捨てないと、失効した仮置きが描かれ続ける
+   */
+  function pendingOpsNow() {
+    if (PENDING_OPS === null) PENDING_OPS = readPendingOps();
+    if (!PENDING_OPS.length) return PENDING_OPS;
+    // 世代は**一覧の下地**（fleet-status の generatedAt）で見る。ページの generatedAt は
+    // 記録の追加でも進むので、それで捨てると下地の古い行が残ったまま仮置きだけ消える
+    var kept = prunePendingOps(PENDING_OPS, {
+      now: Date.now(),
+      siteNowMs: siteTimeMs(rawFleetVal("generatedAt")),
+      live: LIVE_REGISTERED,
+      liveAt: LIVE_REGISTERED_AT,
+    });
+    if (kept.length !== PENDING_OPS.length) {
+      PENDING_OPS = kept;
+      writePendingOps(kept);
+      MERGED = null;
+    }
+    return PENDING_OPS;
+  }
+  /**
+   * 保存が効いた操作を仮置きにする。**成功（2xx かつ changed !== false）のときだけ呼ぶ**
+   * ——失敗した操作を「入っている」ように見せない（#184 の懸念その1）。
+   * 作れたエントリを返す（切り出せない入力では null＝従来どおり live の読み直しに任せる）
+   */
+  function notePendingOp(payload, targets) {
+    if (!SITE.intake) return null;
+    var entry = pendingOpOf(payload, {
+      projectKey: SITE.intake.projectKey,
+      now: Date.now(),
+      // 保存時に見ていた一覧の下地の世代（pendingOpsNow の項）。まとめ表が無い案件は空
+      generatedAt: rawFleetVal("generatedAt") || "",
+      // Backlog の解除は送る payload にドメインが無いので、表示中の一覧から補う
+      targets: targets || null,
+    });
+    if (!entry) return null;
+    // **書く前に読み直す。** メモリの一覧に足して書き戻すだけだと、別のタブが書いた仮置きを
+    // 上書きで落とす（同じ案件を 2 タブで操作するのは普通にある）
+    PENDING_OPS = readPendingOps();
+    PENDING_OPS = rememberPendingOp(pendingOpsNow(), entry);
+    writePendingOps(PENDING_OPS);
+    MERGED = null;
+    return entry;
+  }
+  /** 仮置きの行の印（「反映待ち」／「反映を確認できていません」）。印の無い行は null */
+  function pendingBadgeEl(row) {
+    var note = pendingRowNote(row, Date.now());
+    return note ? el("span", { class: "badge ds-pending-badge", text: note }) : null;
+  }
   // 接続状態ストアの行（届くか・取り込めたか）。op=state の stateNow から
   var LIVE_STATE = null;
   /**
@@ -6135,12 +6237,15 @@ ${deriveCapTile.toString()}
    * 足す場所を描画側に散らすと「タイルは1件・一覧は2件」のような食い違いが必ず出る。
    */
   function fleetVal(key) {
-    if ((LIVE_REGISTERED || LIVE_STATE) && MERGE_KEYS[key]) {
-      // 登録の追加 → 状態の上書き、の順で1回だけ合成する。
+    // 仮置き（#388）は live が無くても合成する——リロード直後（op=state 未着）に
+    // 消したはずの行が出ないため。失効の評価もここで済む（pendingOpsNow の項）
+    var pend = MERGE_KEYS[key] ? pendingOpsNow() : [];
+    if ((LIVE_REGISTERED || LIVE_STATE || pend.length) && MERGE_KEYS[key]) {
+      // 登録の追加 → 仮置き → 状態の上書き、の順で1回だけ合成する。
       // 状態ストアの答えは常に勝つ（まとめ表は gate を焼き込まない。overlayStateOnFleet の項）
       if (!MERGED) {
         MERGED = overlayStateOnFleet(
-          mergeRegisteredFleet(rawView(), LIVE_REGISTERED),
+          applyPendingOps(mergeRegisteredFleet(rawView(), LIVE_REGISTERED), pend),
           LIVE_STATE,
         );
       }
@@ -6217,6 +6322,9 @@ ${deriveCapTile.toString()}
 
   /** まとめ表がまだ答えていない行の数（取り直しを続けるかの判断） */
   function unsettledNow() {
+    // ⚠ 仮置き（#388）は数えない。数えると保存のたびに 60 秒の取り直しが 15 分張られ、
+    // 据え置きの古い答えが返る間は GitHub の枠を削るだけになる。仮置きは次の op=state
+    //（タブへ入り直す・モーダルを開く・再読み込み）か次のビルドで失効すれば足りる
     return unsettledRegisteredCount(rawView(), LIVE_REGISTERED);
   }
 
@@ -6239,9 +6347,11 @@ ${deriveCapTile.toString()}
    * どちらも嘘なので、**行と同じ語**（登録状況を確認中です）に倒す。
    */
   function pendingCaps() {
-    if (!LIVE_REGISTERED) return {};
+    // 仮置き（#388）を持つ能力も同じ語（登録状況を確認中です）に倒す——add で 0 → 1 件に
+    // なった能力に「未接続」と言わせない・remove で 1 → 0 件になった能力に「接続OK」と言わせない
+    var out = pendingCapsOf(pendingOpsNow());
+    if (!LIVE_REGISTERED) return out;
     var add = registeredRowsToAdd(rawView(), LIVE_REGISTERED);
-    var out = {};
     for (var i = 0; i < add.externalSources.length; i++) {
       var addType = add.externalSources[i].type;
       out[externalCapability(addType)] = 1;
@@ -6348,11 +6458,14 @@ ${deriveCapTile.toString()}
     // アダプタが分かるタイルにまで合算を掛けると、相手の名簿の答えが自分の件数に混ざる
     //（gc の名簿が空＝0 が、まだ読めていない chat の null を上書きして Slack を未接続にする）。
     // 片方しか読めなかった回は読めた方だけで数える（両方 null のときだけ null）
+    // 仮置き（#388）の分を加減する。一覧だけ足し引きしてタイルの件数を触らないと、
+    // 「行は消えたのにタイルは登録済み 1 件」「行は 1 件なのにタイルは未接続」が並ぶ
+    var pendOps = pendingOpsNow();
     if (cap === "チャット" && !adapter) {
       var a = LIVE_REGISTERED["chat"];
       var b = LIVE_REGISTERED["google-chat"];
-      var an = Array.isArray(a) ? a.length : null;
-      var bn = Array.isArray(b) ? b.length : null;
+      var an = Array.isArray(a) ? a.length + pendingCountDelta(pendOps, LIVE_REGISTERED, "chat") : null;
+      var bn = Array.isArray(b) ? b.length + pendingCountDelta(pendOps, LIVE_REGISTERED, "google-chat") : null;
       // **片方でも読めなかった（null）なら合算も null（#153 実装レビュー4）。** null を 0 に
       // 畳むと、channels.json の読み取りが失敗した回に「登録0件→未接続」と断定する——
       // サーバの契約（読めなかった能力のキーは出さない＝0件と混ぜない）をここで壊さない
@@ -6360,7 +6473,7 @@ ${deriveCapTile.toString()}
       return an + bn;
     }
     var list = LIVE_REGISTERED[meta.id];
-    return Array.isArray(list) ? list.length : null;
+    return Array.isArray(list) ? list.length + pendingCountDelta(pendOps, LIVE_REGISTERED, meta.id) : null;
   }
 
   /**
@@ -8133,6 +8246,8 @@ ${deriveCapTile.toString()}
     if (s.workspace) payload.workspace = s.workspace;
     callIntake("config", payload).then(function (res) {
       if (!res.ok) return;
+      // 仮置き（#388）: リロードしても新しい名前で出る。送っていない name を判定用に添える
+      notePendingOp({ op: "refresh-channel-name", ref: s.ref, name: r.name });
       // 一覧は夜間のスナップショットなので、その場では変わらない。行だけ追いつかせる
       var nameEl = card.querySelector(".ds-name");
       if (nameEl) nameEl.textContent = slackDisplayName(r.name);
@@ -8378,7 +8493,12 @@ ${deriveCapTile.toString()}
     var out = [];
     for (var i = 0; i < raw.length; i++) {
       var x = raw[i];
-      if (x && x.domain && x.projectKey) out.push({ domain: String(x.domain), projectKey: String(x.projectKey) });
+      if (x && x.domain && x.projectKey) {
+        var row = { domain: String(x.domain), projectKey: String(x.projectKey) };
+        // 仮置きの印（#388）は行に持ち回る（targetsGenerationOf は domain / projectKey しか見ない）
+        if (x.pending === true) { row.pending = true; row.pendingAt = x.pendingAt; }
+        out.push(row);
+      }
     }
     if (out.length) return out;
     // 🔴 **正本（issues-config.json）が読めていて0件のときは、url から復元しない（段A補）。**
@@ -8575,6 +8695,10 @@ ${deriveCapTile.toString()}
       return r ? r.status + "@" + r.at : "-";
     }).join(",");
   }
+  /** 取り直しで描き直すかの署名: 取り込みの状態＋仮置きの印（#388・印だけ残さないため） */
+  function backlogPaintSigOf(list) {
+    return ingestSigOf(list) + "|" + (list || []).map(function (t) { return t && t.pending === true ? "p" : "-"; }).join(",");
+  }
 
   /**
    * Figmaファイル1件の「取り込み」の行（接続状態ストア・段C第二弾）。**無ければ null。**
@@ -8658,6 +8782,8 @@ ${deriveCapTile.toString()}
           el("span", { class: "ds-type", text: "Backlog" }),
           dsNameEl(t.domain + " / " + t.projectKey, "https://" + t.domain + "/projects/" + t.projectKey),
         ]),
+        // 仮置きの行（#388）の印。無ければ null
+        pendingBadgeEl(t),
         // この接続先の取り込みが最後にどうなったか（段C）。測っていなければ null
         ingestedEl(ingestedStateOf(t.domain, t.projectKey), "課題管理"),
       ]);
@@ -8832,7 +8958,12 @@ ${deriveCapTile.toString()}
     }
 
     function targetsHooks() {
-      return { onTargets: adoptTargets, staleNote: TARGETS_RACE_NOTE };
+      return {
+        onTargets: adoptTargets,
+        staleNote: TARGETS_RACE_NOTE,
+        // 仮置き（#388）の鍵にドメインを入れるため、表示中の一覧を渡す（解除の payload にはキーしか無い）
+        pendingTargets: function () { return targets; },
+      };
     }
 
     // **鍵の欄の受け皿を、行のスペースごとに1つ用意する（2026-08-21・オーナー指摘）。**
@@ -8872,7 +9003,7 @@ ${deriveCapTile.toString()}
     var box = el("div", { "data-live-cap": REGISTERED_CAP_NAMES.issues }, [listEl]);
     paint();
     /** いま描いてある取り込みの状態（段C）。接続先の集合とは別に変わるので、別に覚える */
-    var lastIngestSig = ingestSigOf(targets);
+    var lastIngestSig = backlogPaintSigOf(targets);
     /**
      * 取り直しで新しい値が届いたときの差し替え（段階1）。**一覧だけを描き直す。**
      *
@@ -8887,7 +9018,7 @@ ${deriveCapTile.toString()}
       // 🔴 **変化が無いと言えるのは、接続先の集合と取り込みの状態が両方同じときだけ（段C）。**
       // 世代だけで判断すると、**応答を待たずにモーダルを開いた人には取り込みが永久に出ない**
       //（届いた応答で集合は変わらないので、ここで飛ばされる）。ingestSigOf の項に経緯
-      var sig = ingestSigOf(next);
+      var sig = backlogPaintSigOf(next);
       if (targetsGenerationOf(next) === targetsGenerationOf(targets) && sig === lastIngestSig) return;
       targets = next;
       lastIngestSig = sig;
@@ -9071,7 +9202,8 @@ ${deriveCapTile.toString()}
         var driveNow = function () { return internalSourceOf("共有資料") || s; };
         box.appendChild(liveList("共有資料", function () {
           var d = driveNow();
-          return JSON.stringify([d.driveFolderIds || [], d.driveFolderNames || {}, d.driveState || ""]);
+          // 仮置きの印（drivePending）も署名に入れる——外れたときに印だけ残さない（#388）
+          return JSON.stringify([d.driveFolderIds || [], d.driveFolderNames || {}, d.driveState || "", d.drivePending || {}]);
         }, function (listBox) {
         var src = driveNow();
         var folders = src.driveFolderIds || [];
@@ -9091,6 +9223,10 @@ ${deriveCapTile.toString()}
                 el("span", { class: "ds-type", text: "Google Drive" }),
                 dsNameEl(fname || id, "https://drive.google.com/drive/folders/" + id),
               ]),
+              // 仮置きの行（#388）の印。Drive は行が ID 文字列なので drivePending から引く
+              pendingBadgeEl(src.drivePending && src.drivePending[id] != null
+                ? { pending: true, pendingAt: src.drivePending[id] }
+                : null),
             ]);
             // **名前を出したときはIDも併記する。** 同名のフォルダを見分けられなくなるのと、
             // 「このIDを外す」という確認文と画面の表示が食い違うのを防ぐ
@@ -9233,6 +9369,8 @@ ${deriveCapTile.toString()}
               el("span", { class: "ds-type", text: "Figma" }),
               dsNameEl(f.name || f.key, "https://www.figma.com/design/" + f.key),
             ]),
+            // 仮置きの行（#388）の印。無ければ null
+            pendingBadgeEl(f),
             // このファイルの取り込みが最後にどうなったか（段C）。測っていなければ null
             ingestedEl(designIngestedStateOf(f.key), "デザイン"),
           ]);
@@ -9632,9 +9770,16 @@ ${deriveCapTile.toString()}
         endBusy();
         return;
       }
+      // 🔴 **仮置き（#388）はここで作る**（文面の前）。作れたときはサーバの文面を**先頭の 1 文だけ**に
+      // する——続きの「一覧への反映には数分かかります（再読み込みで最新になります）」は、
+      // その場で「反映待ち」の行が出ている横では嘘（intake の文面は本便では触らない）。
+      // **changed:false では書かない**（何も変わっていないのに追加したと見せない）
+      var pendingEntry = j.changed !== false
+        ? notePendingOp(payload, hooks && typeof hooks.pendingTargets === "function" ? hooks.pendingTargets() : null)
+        : null;
       msg.className = "ds-toggle-msg is-ok";
       msg.textContent = "";
-      msg.appendChild(document.createTextNode("✓ " + (j.message || "保存しました。")));
+      msg.appendChild(document.createTextNode("✓ " + ((pendingEntry ? noteHeadline(j.message) : j.message) || "保存しました。")));
       // **起動できたときだけ導線を出す。** 押した直後に「効いたか」を確かめられるのが要点。
       // 起動できなかった案件（権限・スタブ未配布）ではリンクを出さない——押しても何も無い
       if (j.runsUrl) {
@@ -9663,6 +9808,18 @@ ${deriveCapTile.toString()}
       //
       // **既存4呼び出しの onDone 意味論には触れない。** 使い分けは呼び出し側の責任で、
       // 冪等な op（棚の2つ）だけがこちらを使う。
+      // 🔴 **仮置き（#388）の反映。** add は行を足す・remove は行を消す・update は欄を差し替える。
+      // add / remove は開いている一覧を描き直す。update（通知先の入り切り・名前）は
+      // 呼び出し側がその場で行を直しているので、描き直して「✓」を消さない。
+      // remove は行ごと「✓ 解除しました」が消えるので、先頭の 1 文をトーストで出す
+      if (pendingEntry && pendingEntry.action !== "update") {
+        // 応答が一覧を添えてくる口（Backlog の onTargets）は結果の表示が一覧の外にあるので、重ねない
+        if (pendingEntry.action === "remove" && !(hooks && hooks.onTargets)) {
+          showToast(noteHeadline(j.message) || "登録を解除しました。");
+        }
+        repaintOpenLists();
+        refreshDataSources();
+      }
       if (hooks && typeof hooks.onSaved === "function") hooks.onSaved(j);
       // **保存が効いたら、いまの登録を読み直す（段階1）。** 一覧はまとめ表（夜間バッチ）から
       // 描かれるので、保存しただけでは行が出ない。ここで読み直すと、登録ファイルの中身が
@@ -9677,7 +9834,8 @@ ${deriveCapTile.toString()}
       // 正しく反映できる。**流れるのは res.ok かつ changed !== false のときだけ**で、
       // removeButton 経由の onDone（引数を取らない）には届かない——受け側は
       // j が undefined でも動く形に保つこと（既存の4呼び出しは引数を取らない）
-      if (onDone && j.changed !== false) onDone(j);
+      // 第2引数は仮置きの結果（#388）。控えを出すかの判断に使う（addForm）。既存の受け側は見ない
+      if (onDone && j.changed !== false) onDone(j, { pending: pendingEntry });
     } catch (e) {
       msg.className = "ds-toggle-msg is-error";
       msg.textContent = "✗ 通信に失敗しました。";
@@ -9685,6 +9843,13 @@ ${deriveCapTile.toString()}
     }
   }
 
+  /** サーバの文面の先頭の1文（「。」まで）。空なら空文字 */
+  function noteHeadline(text) {
+    var s = String(text || "");
+    var i = s.indexOf("。");
+    return i < 0 ? s : s.slice(0, i + 1);
+  }
+
   /**
    * 危険な方向にだけ出す確認。**何が起きるかを具体に書く**（「よろしいですか」だけにしない）。
    *
@@ -9952,12 +10117,15 @@ ${deriveCapTile.toString()}
       var added = main.value.trim();
       var addedName = name ? name.value.trim() : "";
       var payload = opts.build(added, addedName, wsSelect ? wsSelect.value : "");
-      sendConfig(payload, msg, btn, function () {
+      sendConfig(payload, msg, btn, function (j, info) {
         // 追加できたら入力欄を空にする（同じものを二度押ししないように）
         main.value = "";
         if (name) name.value = "";
         // 応答で本物の一覧が描き直される口では、控えを出さない（同じものが2回並ぶ）
         if (opts.hooks) return;
+        // 仮置き（#388）が作れたときも同じ——一覧に「反映待ち」の行が出ている。
+        // 作れなかった（URL を切り出せなかった）ときだけ従来の控えに落ちる
+        if (info && info.pending) return;
         // **追加したものをその場に出す。** 上の一覧は fleet-status.json（夜間スナップショット）
         // から描かれているので、追加してもその場では変わらない。何も変わらないと
         // 「追加できていない」と読まれ、もう一度押して「既に登録されています」になる
@@ -10085,7 +10253,9 @@ ${deriveCapTile.toString()}
     // 折りたたみの見出しでまとめるのをやめた（オーナー指摘「複雑になっちゃってる」）ので、
     // **どの組織かを言うのは行のラベルだけ**になった。社内に何も出さないと、
     // ラベルの無い行が「社内」なのか「まだ分かっていない」のかを読み分けられない。
-    if (s.type === "slack") {
+    // **仮置きの行（#388）には出さない。** どの組織かはサーバが追加時に実測して書くが
+    // 応答には載らないので、ここで「クラスメソッド」と名乗ると嘘になる（本物の行が来れば付く）
+    if (s.type === "slack" && s.pending !== true) {
       // **順序は groupSlackByOrg と揃える（workspace が先）。**
       // 逆にすると、判定が済んで workspace が入った行に古い印が残っているとき、
       // **並びは「Hapio AI」なのにラベルだけ「組織が分かりません」**になる
@@ -10147,7 +10317,12 @@ ${deriveCapTile.toString()}
     //
     // ⚠ **s.origin 自体は残す。** 「登録から削除」を出すかどうかの判定に使っている
     //（自動検出の行に削除を出すと、押しても翌日戻ってくる）。**札を出さないだけ**
-    var gate = dsGateOf(s);
+    // 仮置きの行（#388）は状態の語を「反映待ち」に**差し替える**（Slack / Google Chat /
+    // GitHub の3種はここ1箇所）。gate が無い行は「登録状況を確認中です」になるので、
+    // そこへ札を足すと待ちの語が2つ並ぶ
+    var gate = s.pending === true
+      ? { text: pendingRowNote(s, Date.now()), cls: DS_GATE_PENDING.cls }
+      : dsGateOf(s);
     // **「接続を確認」が押されたら、この要素を live の判定で置き換える**（probeSection）。
     // 2つの判定を同じ行に並べないため、参照を持っておく
     var gateEl = el("span", { class: "ds-gate " + gate.cls, text: gate.text });
@@ -10188,8 +10363,10 @@ ${deriveCapTile.toString()}
     if (SITE.intake && s.type === "slack" && s.ref && s.origin !== "explicit") {
       card.appendChild(removeChannelButton(s, card));
       // 通知先の入り切り。**解除と同じ条件で出す**——書き換える先は違う（notify.json）が、
-      // どちらも「チャット/channels.json に登録がある行」でしか効かない
-      card.appendChild(notifyToggle(s, badges));
+      // どちらも「チャット/channels.json に登録がある行」でしか効かない。
+      // 仮置きの行（#388）には出さない——ワークスペースが未確定で、顧客ワークスペースなら
+      // 押しても断られる（本物の行が来てから）
+      if (s.pending !== true) card.appendChild(notifyToggle(s, badges));
     }
     // Google Chat のスペースの登録解除（#153）。#155 のモデル（載っていること自体が
     // 読み取りの意思決定・止める手段は登録解除）に Slack と同型で揃える。
@@ -10600,6 +10777,8 @@ ${deriveCapTile.toString()}
     // 捨てる（断らない）ので、画面と Lambda の版が食い違っても接続状況の表示は消えない
     // **保存直後だけ据え置きを迂回させる。** これが無いと、サーバが保存前の答えを返し、
     // 足りない行が0件になって取り直しも張られない＝手で再読み込みするまで追いつかない
+    // 仮置きの失効判定は「要求を出した時刻」で見る（LIVE_REGISTERED_AT の項）
+    var startedAt = Date.now();
     callIntake(
       "state",
       useFresh ? { caps: ALL_STATE_CAPS, fresh: true } : { caps: ALL_STATE_CAPS },
@@ -10623,6 +10802,7 @@ ${deriveCapTile.toString()}
         // （＝立ち上げ直後＝この仕組みが一番効く案件）は下で throw するので、
         // ここより後に置くと**その案件だけ素通り**する
         LIVE_REGISTERED = sanitizeRegisteredNow(j && j.registeredNow);
+        LIVE_REGISTERED_AT = startedAt;
         LIVE_STATE = sanitizeStateNow(j && j.stateNow);
         // **欄の有無をそのまま覚える。** sanitize を通した後では「読めて0件」が消える
         LIVE_STATE_SEEN = !!(j && Array.isArray(j.stateNow));

package/package.json

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