@tyhld/conductor 0.12.106 → 0.12.108

package/dist/relay.js

@@ -421,6 +421,250 @@ export function saveCodexTurn(cfg, state, env = process.env) {
     if (writeCodexTurnRecord(cfg.site, rec, env))
         state.codexTurnDisk = text;
 }
+// ───────────────────────────────────────────────────────────────────────────
+// 画面の合図で閉じる前に知らせを待ち、閉じた後に届いた知らせも結び直す（★便 36236d41）
+//
+// 【何が起きていたか（実物 2026-10-05・調査 f567f8d8 の形B）】
+//   便 351dea1c は 12:12:22 に「done（報告ファイルなし＝完了のみ）」で閉じ、その 16 秒後の
+//   12:12:38 に終わりの知らせが届いた。閉じた便には追跡（pending）が無いので、知らせは
+//   judgeCodexNotice の「追っている便が無いあいだに届いた知らせ」として控えへ回り、
+//   報告の本文は控えに在るのに管制には1文字も載らなかった。
+//
+// 【直し方（2つ）】
+//   ① 画面の合図を拾っても【すぐには閉じない】。その便の印が合う知らせを
+//      RELAY_CODEX_DONE_NOTICE_WAIT_MS だけ待つ（待つあいだも毎周、知らせを先に見る＝
+//      届けば今までの「知らせの道」で本文つきに閉じる）。★待つあいだ次の便は配らない
+//      （追跡が外れないので relayTick が取得へ進まない＝同じ画面で便が重ならない）。
+//   ② 待っても来なければ今までどおり「完了のみ」で閉じるが、その便を
+//      RELAY_CODEX_CLOSED_REMEMBER_MS のあいだ覚えておく（★現場ごとの控えに持つ＝
+//      配り役を入れ直しても引き継ぐ）。そのあいだに印が合う知らせが届いたら、控えへ回さずに
+//      報告ファイルを組み立て、【いま在る「後から届ける道」】（sendPendingReportFiles）で
+//      管制へ届ける。★便の状態は1文字も書かない（完了にしない・二重完了にしない）。
+//
+// 【★取り違えない守りは1つも緩めない】結び直すのは「便の印（jobId）が一致した行」だけ
+//   （takeCodexNoticesForJobId）。印が無い・合わない知らせは今までどおりどの便にも結び付けない。
+//   使った行は受け皿から取り除くので同じ知らせを2回使わない。既に報告が在る便には
+//   2つ目の本文を足さない（intakeCodexLateReport が reportPhase で止める）。
+// ───────────────────────────────────────────────────────────────────────────
+/**
+ * 画面の合図を拾ってから、終わりの知らせを待つ上限（★1か所の定数）。
+ *   実物（便 351dea1c）では 16 秒後に届いた。余裕を見て 60 秒。
+ */
+export const RELAY_CODEX_DONE_NOTICE_WAIT_MS = 60 * 1000;
+/** 「完了のみ」で閉じた便を覚えておく長さ（★1か所の定数）。 */
+export const RELAY_CODEX_CLOSED_REMEMBER_MS = 15 * 60 * 1000;
+/** 覚えておく便の件数の上限（古い物から落とす＝控えが際限なく育たない）。 */
+export const RELAY_CODEX_CLOSED_REMEMBER_MAX = 20;
+/** 「知らせ0件」のまま閉じた便が何件続いたら管制へ知らせるか（★1か所の定数）。 */
+export const RELAY_CODEX_SILENT_CLOSE_ALERT_AT = 2;
+/** 空の控え（読めない・無いときの既定）。 */
+export function emptyCodexWatchRecord() {
+    return { closed: [], silent: 0, told: false };
+}
+/** この現場の見張りの控えのパス。 */
+export function codexWatchFile(site, env = process.env) {
+    const safe = String(site ?? '').replace(/[^A-Za-z0-9_-]/g, '').slice(0, 128) || 'unknown';
+    return path.join(relayStateDir(env), `codex-watch-${safe}.json`);
+}
+/** 控えを読む（無い・読めない・形が違うときは空の控え＝★配り役を止めない）。 */
+export function readCodexWatchRecord(site, env = process.env) {
+    try {
+        const o = JSON.parse(readFileSync(codexWatchFile(site, env), 'utf8'));
+        const closed = [];
+        if (Array.isArray(o.closed)) {
+            for (const e of o.closed) {
+                if (typeof e !== 'object' || e === null)
+                    continue;
+                const r = e;
+                const id = typeof r.id === 'string' ? r.id.trim() : '';
+                const at = typeof r.at === 'number' && Number.isFinite(r.at) ? r.at : null;
+                if (id === '' || at === null)
+                    continue;
+                closed.push({ id, at });
+            }
+        }
+        const silent = typeof o.silent === 'number' && Number.isFinite(o.silent)
+            ? Math.max(0, Math.floor(o.silent))
+            : 0;
+        return { closed, silent, told: o.told === true };
+    }
+    catch {
+        return emptyCodexWatchRecord();
+    }
+}
+/** 控えを書く（★書けなくても配り役は止まらない＝今までどおりメモリの中身で動く）。 */
+export function writeCodexWatchRecord(site, rec, env = process.env) {
+    const file = codexWatchFile(site, env);
+    try {
+        mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        writeFileSync(file, `${JSON.stringify(rec)}\n`, { encoding: 'utf8', mode: 0o600 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 覚えておく便の一覧を整える純粋関数（I/Oなし）。
+ *   - 覚えておく長さ（RELAY_CODEX_CLOSED_REMEMBER_MS）を過ぎた便を落とす。
+ *   - 件数の上限（RELAY_CODEX_CLOSED_REMEMBER_MAX）を超えた分は、古い物から落とす。
+ *   - 同じ便IDは1件に畳む（新しい時刻を残す）。
+ */
+export function pruneClosedCodexJobs(closed, now) {
+    const byId = new Map();
+    for (const c of closed) {
+        if (now - c.at >= RELAY_CODEX_CLOSED_REMEMBER_MS)
+            continue;
+        const prev = byId.get(c.id);
+        if (prev === undefined || c.at > prev)
+            byId.set(c.id, c.at);
+    }
+    return [...byId.entries()]
+        .map(([id, at]) => ({ id, at }))
+        .sort((a, b) => a.at - b.at)
+        .slice(-RELAY_CODEX_CLOSED_REMEMBER_MAX);
+}
+/**
+ * 画面の合図を拾った周に「すぐ閉じるか・知らせを待つか」を決める純粋関数（I/Oなし）。
+ *
+ * ★Codex の現場だけ。Claude の現場は 'close'＝今までどおり1バイトも変わらない。
+ * ★`screenDoneSince === null`（合図を見つけた最初の周）は必ず 'wait'＝その周では閉じない。
+ */
+export function decideCodexDoneHold(args) {
+    if (args.kind !== 'codex')
+        return 'close';
+    if (args.screenDoneSince === null)
+        return 'wait';
+    return args.now - args.screenDoneSince >= RELAY_CODEX_DONE_NOTICE_WAIT_MS ? 'close' : 'wait';
+}
+/**
+ * 「この現場の Codex から終わりの知らせが届かない」を管制へ知らせるかを決める純粋関数。
+ *
+ * ★その現場につき1回だけ（told）。知らせが戻ると呼ぶ側が told を false に戻すので、
+ *   次に途切れたときにまた1回だけ鳴る。★3件目・4件目では鳴らさない。
+ */
+export function decideCodexSilentAlert(args) {
+    if (args.told)
+        return false;
+    return args.count >= RELAY_CODEX_SILENT_CLOSE_ALERT_AT;
+}
+/** 管制へ知らせる1行（★純粋関数・秘密も便の状態も1文字も入れない）。 */
+export function codexSilentCloseNoticeText(site, count) {
+    return (`この現場（${site}）の Codex から、終わりの知らせが届いていません（${count}便 続けて）。` +
+        '報告の本文が管制に載りません。Codex の立ち上げ直しが要るかもしれません。');
+}
+/**
+ * 見張りの控えをメモリへ読み込む（★Codex の現場だけ・無ければ空から始める）。
+ *   既に読み込んであれば何もしない（毎周ファイルを読まない）。
+ */
+export function loadCodexWatch(cfg, state, env = process.env) {
+    if (kindOf(cfg) !== 'codex')
+        return null;
+    if (state.codexWatch === null) {
+        state.codexWatch = readCodexWatchRecord(cfg.site, env);
+        state.codexWatchDisk = JSON.stringify(state.codexWatch);
+    }
+    return state.codexWatch;
+}
+/** いまの見張りの控えをファイルへ写す（★中身が変わっていなければ書かない）。 */
+export function saveCodexWatch(cfg, state, env = process.env) {
+    if (kindOf(cfg) !== 'codex' || state.codexWatch === null)
+        return;
+    const text = JSON.stringify(state.codexWatch);
+    if (text === state.codexWatchDisk)
+        return;
+    // まだ控えが無く、書くことも何も無い＝ファイルを作らない。
+    if (state.codexWatchDisk === null &&
+        state.codexWatch.closed.length === 0 &&
+        state.codexWatch.silent === 0 &&
+        !state.codexWatch.told) {
+        return;
+    }
+    if (writeCodexWatchRecord(cfg.site, state.codexWatch, env))
+        state.codexWatchDisk = text;
+}
+/**
+ * 「終わりの知らせが1件でも届いた」を記録する（★数えを 0 に戻す・便 36236d41）。
+ *   次に途切れたときに、また1回だけ管制へ知らせられるよう told も戻す。
+ */
+export function noteCodexNoticeHeard(cfg, state, env = process.env) {
+    const w = loadCodexWatch(cfg, state, env);
+    if (w === null)
+        return;
+    w.silent = 0;
+    w.told = false;
+}
+/**
+ * 「知らせ0件のまま便を閉じた」を数え、その便を覚えておく（★便 36236d41）。
+ * 返り: 続いた件数と、管制へ知らせるべきか。
+ *
+ * ★ここでは管制へ何も送らない・便の状態も書かない（送るのは呼ぶ側＝sendCommandNotice）。
+ */
+export function noteCodexSilentClose(cfg, state, jobId, opts = {}) {
+    const now = opts.now ?? Date.now();
+    const w = loadCodexWatch(cfg, state, opts.env);
+    if (w === null)
+        return { count: 0, tell: false };
+    w.closed = pruneClosedCodexJobs([...w.closed, { id: jobId, at: now }], now);
+    w.silent += 1;
+    const tell = decideCodexSilentAlert({ count: w.silent, told: w.told });
+    if (tell)
+        w.told = true;
+    return { count: w.silent, tell };
+}
+/**
+ * 「完了のみ」で閉じた便へ後から届いた知らせを、その便の報告として結び直す（★便 36236d41）。
+ *
+ * ★取るのは【便の印が一致した行】だけ（takeCodexNoticesForJobId）。印が無い・合わない知らせは
+ *   1行も触らない＝受け皿に残り、今までどおりどの便にも結び付かない。
+ * ★便の状態は1文字も書かない（完了にしない・二重完了にしない）。報告ファイルを置くだけで、
+ *   管制へ渡すのは既にある「後から届ける道」（sendPendingReportFiles）の仕事。
+ * ★一度結び直した便は覚えている一覧から外す＝同じ知らせを2回使わない。
+ */
+export function relinkClosedCodexNotices(cfg, state, deps = {}, env = process.env) {
+    if (kindOf(cfg) !== 'codex')
+        return;
+    const take = deps.takeNotices ?? ((site, id) => takeCodexNoticesForJobId(site, id, env));
+    const intake = deps.intake ??
+        ((reply, o) => intakeCodexLateReport(reply, { ...o, env }));
+    const clock = deps.now ?? (() => Date.now());
+    const logLine = deps.logLine ?? log;
+    const w = loadCodexWatch(cfg, state, env);
+    if (w === null)
+        return;
+    const now = clock();
+    const pruned = pruneClosedCodexJobs(w.closed, now);
+    if (pruned.length !== w.closed.length) {
+        const dropped = w.closed.length - pruned.length;
+        w.closed = pruned;
+        logLine(`site=${cfg.site} 「完了のみ」で閉じた便 ${dropped} 件は、覚えておく` +
+            `${Math.round(RELAY_CODEX_CLOSED_REMEMBER_MS / 60000)}分を過ぎたので忘れます` +
+            '（以後その便の知らせは、今までどおり控えへ回ります）');
+    }
+    if (w.closed.length === 0)
+        return;
+    for (const job of [...w.closed]) {
+        const mine = take(cfg.site, job.id);
+        if (mine.length === 0)
+            continue;
+        // 2件以上あれば【新しい方】を使う（受け皿は古い順）。
+        const notice = mine[mine.length - 1];
+        state.codexNoticeSeen = true;
+        // ★知らせが戻った＝「届かない」の数えを 0 に戻す（次に途切れたらまた1回鳴る）。
+        w.silent = 0;
+        w.told = false;
+        // ★同じ知らせを2回使わない＝取り込みの成否にかかわらず、覚えている一覧から外す。
+        w.closed = w.closed.filter((c) => c.id !== job.id);
+        const got = intake(notice.report, {
+            commandId: job.id,
+            site: cfg.site,
+            turnId: notice.turnId ?? null,
+        });
+        logLine(`site=${cfg.site} id=${job.id} 便を閉じたあとに届いた終わりの知らせを、この便の報告として` +
+            `結び直しました（印が一致・閉じてから${Math.round((now - job.at) / 1000)}秒）: ${got.note}` +
+            '／★便の状態は書き換えていません（本文は後から届ける道で管制へ渡します）');
+    }
+}
 /**
  * 受け皿の名前をそろえる仕事（登録簿の書き出し・読まれない受け皿の始末）の間隔。
  *   ★配達の判断には1バイトも関わらない。フォルダを見に行くので毎周はやらない。
@@ -450,6 +694,8 @@ export function createRelayState() {
         codexTurnLoaded: false,
         codexTurnDisk: null,
         codexTrayTidiedAt: null,
+        codexWatch: null,
+        codexWatchDisk: null,
         central: { failures: 0, detail: '', downSince: null },
         readiness: createReadiness(),
     };
@@ -1924,6 +2170,95 @@ export function intakeCodexReport(reply, opts) {
     }
     return { wrote: true, file, note: `最後の返事の囲みから報告ファイルを組み立てました: ${file}` };
 }
+/**
+ * 囲みが読めない返事を、そのまま本文にした報告ファイルの中身にする（★便 36236d41）。
+ * 返事が空なら null（作り話の報告を置かない）。
+ *
+ * 【なぜ要るか】「完了のみ」で閉じた便へ後から届いた知らせを管制へ渡す道は、既にある
+ *   「後から届ける道」（sendPendingReportFiles）しかない。その道は【形が整った報告ファイル】
+ *   しか送らない（reportShapeMissing）。だから囲みが無い返事も、配り役が知っている値で
+ *   6欄の形にそろえる必要がある。
+ * 【★作り話にしない】配り役が埋めたのは instruction_id・site・created_at・outcome だけで、
+ *   どれも「配り役が知っている事」か「埋めたと本文に書いた事」に限る。
+ *   ★outcome は職人が書いていないので `blocked`（人の判断が要る）に倒し、
+ *     「職人は結末を書いていない」と本文に明記する。pushed（済んだ）へ倒さない。
+ */
+export function buildCodexReplyOnlyReportText(reply, opts) {
+    const body = String(reply ?? '').trim();
+    if (body === '')
+        return null;
+    const at = new Date(opts.now ?? Date.now()).toISOString();
+    const turn = (opts.turnId ?? '').toString().trim();
+    const text = [
+        '---',
+        `instruction_id: ${opts.commandId}`,
+        `site: ${opts.site}`,
+        // ★職人が結末を書いていない＝人の判断が要る物として渡す（済んだことにしない）。
+        'outcome: blocked',
+        `created_at: ${at}`,
+        'evidence:',
+        `  - 配り役が、便を閉じたあとに届いた終わりの知らせを、この便の報告として結び直しました${turn === '' ? '' : `（ターン=${turn}）`}`,
+        '---',
+        '',
+        '（この報告は、職人の最後の返事を配り役がそのまま本文として渡した物です）',
+        '★職人の返事に機械で読める囲みが無かったので、結末（outcome）は職人が書いていません。',
+        `　配り役は人の判断が要る物として blocked に倒し、created_at は受け取った時刻（${at}）を入れました。`,
+        '',
+        body,
+    ].join('\n');
+    return reportShapeMissing(text).length === 0 ? text : null;
+}
+/**
+ * 便を閉じたあとに届いた知らせから、報告ファイルを置く（★便 36236d41）。
+ *   ① 囲みが読めれば、職人が書く物とまったく同じ形で置く（intakeCodexReport と同じ）。
+ *   ② 囲みが読めなければ、返事をそのまま本文にして置く（buildCodexReplyOnlyReportText）。
+ * ★既に報告が在る便には何も書かない（2つ目の本文を足さない・職人が書けた物を壊さない）。
+ * ★便の状態は1文字も書かない。管制へ渡すのは既にある「後から届ける道」の仕事。
+ */
+export function intakeCodexLateReport(reply, opts) {
+    const env = opts.env;
+    if (reportPhase(opts.commandId, env) !== 'none') {
+        return {
+            wrote: false,
+            file: null,
+            note: '報告ファイルが既にあるので、後から届いた知らせからは作りません（2つ目の本文を足さない）',
+        };
+    }
+    const fromBlock = intakeCodexReport(reply, opts);
+    if (fromBlock.wrote)
+        return fromBlock;
+    const text = buildCodexReplyOnlyReportText(reply, {
+        commandId: opts.commandId,
+        site: opts.site,
+        turnId: opts.turnId ?? null,
+        now: opts.now,
+    });
+    if (text === null) {
+        return {
+            wrote: false,
+            file: null,
+            note: '後から届いた知らせに本文が無いので、報告ファイルは作りません',
+        };
+    }
+    const file = path.join(reportWriteDir(env), reportFileName(opts.commandId));
+    try {
+        mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        writeFileSync(file, `${text}\n`, { encoding: 'utf8', mode: 0o600 });
+    }
+    catch (err) {
+        return {
+            wrote: false,
+            file: null,
+            note: '後から届いた知らせの報告ファイルを置けませんでした: ' +
+                (err instanceof Error ? err.message : String(err)),
+        };
+    }
+    return {
+        wrote: true,
+        file,
+        note: `後から届いた知らせの返事をそのまま本文にして報告ファイルを組み立てました: ${file}`,
+    };
+}
 export function sliceForDoneScan(text, anchor, wide) {
     const below = sliceBelowAnchor(text, anchor);
     if (below !== null)
@@ -1959,6 +2294,73 @@ export function countStandaloneDone(text, site) {
             n += 1;
     return n;
 }
+// ───────────────────────────────────────────────────────────────────────────
+// 終わりの印が【行の中】に描かれても拾う（★Codex だけ・便 0029ef4d）
+//
+// 【何が起きたか（実物 2026-10-05 夜・便 cd7d9ea8・配り役 0.12.101）】
+//   Codex は 23:33 に返事を終え、入力待ち（`› Ask Codex to do anything`）に戻っていた。
+//   ところが返事の本文が表（マークダウンの table）で終わっていたため、Codex の画面は
+//   そのあとの2行まで【表の行として】描いた:
+//       型   =====原文ここまで=====   そのまま使える物   …
+//       型   DONE:codex-probe
+//   既存の判定（isStandaloneDoneLine）は「印と装飾を除いて何も残らない行」だけを完了とみなすので、
+//   行の頭に残った `型` のせいで永久に成立しない。配り役の記録には 178 秒めから
+//   「画面=待機」と出ていたのに、完了は 15 分の上限まで拾えず、報告本文も載らなかった。
+//
+// 【直し方の筋】印の【描かれ方】だけに頼らない。「この行は印で終わっている」＋「職人は入力待ちに
+//   戻っている」の2つで読む。印の【前】に何が付いていてもよく、印の【後ろ】に字が残っていたら拾わない。
+//
+// 【★指示文のこだま（画面に出る指示の写し）を終わりと取り違えない】守りは3重で、1つも緩めない:
+//   ① 印の【後ろ】に字が残る行は拾わない … 配達文の「最終行: DONE:{現場} とだけ出力」は
+//      印の後ろに字が続くので、この1つ目で落ちる。
+//   ② 入力欄に写った行（行頭が Codex のカーソル `›`）・アンカーを含む行は拾わない。
+//      貼った本文の写しは必ずこの形で描かれる（実測）。
+//   ③ 床（配った時点の数）より増えたときだけ完了とみなす … 端末の折り返しがたまたま印の直後で
+//      切れて①②をすり抜けても、配った直後の周で床に取り込まれるので完了にならない。
+// ───────────────────────────────────────────────────────────────────────────
+/**
+ * 印の【後ろ】に残っていても「字が無い」とみなす飾り。
+ *   既存の単独行の判定（isStandaloneDoneLine）の飾りに、表・区切りの罫線と Codex のカーソルを足す。
+ *   ★既存の判定そのものは1文字も変えない（Claude の道を動かさないため）。
+ */
+const TRAILING_DONE_DECOR_RE = /[│|>›⏺●○•*·─━┃┆┊╎—–\s]/g;
+/**
+ * 1行が「`DONE:{site}` で終わっている行」か（★印の前に何が付いていてもよい）。
+ *   - 印より後ろに、飾りと空白以外が1字も残っていないこと。
+ *   - 行頭が Codex のカーソル（`›`）の行＝入力欄に写った指示文は拾わない。
+ *   - アンカー（`CONDUCTOR_JOB`）を含む行＝貼った本文の写しは拾わない。
+ */
+export function isTrailingDoneLine(line, marker) {
+    const at = line.lastIndexOf(marker);
+    if (at < 0)
+        return false;
+    if (line.slice(at + marker.length).replace(TRAILING_DONE_DECOR_RE, '').length > 0)
+        return false;
+    const head = line.trim();
+    if (head.startsWith(CODEX_MENU_CURSOR))
+        return false;
+    if (line.includes(SEND_ANCHOR_PREFIX))
+        return false;
+    return true;
+}
+/** テキスト中に「`DONE:{site}` で終わる行」が1つでもあるか。 */
+export function hasTrailingDone(text, site) {
+    const marker = `DONE:${site}`;
+    return text
+        .replace(/\r/g, '')
+        .split('\n')
+        .some((line) => isTrailingDoneLine(line, marker));
+}
+/** テキスト中の「`DONE:{site}` で終わる行」の数（★床の基準に使う）。 */
+export function countTrailingDone(text, site) {
+    const marker = `DONE:${site}`;
+    const lines = text.replace(/\r/g, '').split('\n');
+    let n = 0;
+    for (const line of lines)
+        if (isTrailingDoneLine(line, marker))
+            n += 1;
+    return n;
+}
 /**
  * 追跡中（pending）の便について、画面から完了の合図を読む（★I/Oなし＝単体テスト可能）。
  *
@@ -1984,6 +2386,25 @@ export function scanDoneForPending(cap, site, anchor, opts) {
         return { done: true, floor: opts.doneFloor };
     return { done: false, floor: Math.min(opts.doneFloor, seen) };
 }
+/**
+ * 「職人は入力待ちに戻っている」ときだけ、行の中に描かれた終わりの印を読む（★I/Oなし）。
+ *
+ * ★上の scanDoneForPending（今までの道）は1バイトも変えない。これは【それが空振りしたときだけ】
+ *   足す2本目の道で、Codex の便で `idle:true` の周にしか効かない。
+ *   - `idle:false`（まだ手を動かしている・Claude の現場）… 何も読まない・床も動かさない。
+ *   - 床が在る … 配った時点の数より増えたときだけ完了。増えていなければ観測した数まで床を下げる。
+ *   - 床が無い（孤児の復元など）… 今までの単独行の判定と同じ危険度で、1本でも在れば完了。
+ */
+export function scanTrailingDoneForPending(cap, site, opts) {
+    if (!opts.idle)
+        return { done: false, floor: opts.floor };
+    if (opts.floor === null)
+        return { done: hasTrailingDone(cap, site), floor: null };
+    const seen = countTrailingDone(cap, site);
+    if (seen > opts.floor)
+        return { done: true, floor: opts.floor };
+    return { done: false, floor: Math.min(opts.floor, seen) };
+}
 /**
  * アンカー基準の完了判定（根治の中核）。
  *   「アンカーより下の領域」に DONE:{site} 単独行があれば完了とみなす。
@@ -4289,6 +4710,71 @@ export async function sendHeartbeat(cfg, id, busy = false, liveness) {
         log(`site=${cfg.site} id=${id} heartbeat -> 失敗: ${err instanceof Error ? err.message : String(err)}（縮退で安全）`);
     }
 }
+// ───────────────────────────────────────────────────────────────────────────
+// 「職人は入力待ちに戻っているが、終わりの印が見つからない」を管制へ知らせる（便 0029ef4d）
+//
+// 【なぜ要るか（実物 2026-10-05 夜・便 cd7d9ea8）】配り役の記録には 178 秒めから
+//   「完了待ち（画面=待機）」と出ていた。＝配り役は「職人の手は止まっている」と分かっていたのに、
+//   その事実は手元の記録にしか残らず、管制には何も届かなかった。管制の画面では
+//   「返事待ち（15分）→ 確認しています（30分）→ 回収必要」と時間だけが進み、人が Codex の画面を
+//   見るまで誰も気づけなかった。
+//
+// 【どの口を使うか（★管制のリポは触らない）】既にある出来事の口
+//   `POST /api/conductor/commands/{id}/events`（画面なし方式の職人が進捗を送っている口）へ、
+//   既にある種類 `progress` で1行送るだけ。★便の状態は1文字も書かない（完了にしない・
+//   `lastSeenAt` も動かさない＝管制の時間切れの働きを遅らせない）。
+// ───────────────────────────────────────────────────────────────────────────
+/** 「入力待ちなのに印が無い」を管制へ知らせるまでの待ち（★短すぎると普通の間（ま）で鳴る）。 */
+export const RELAY_IDLE_NO_DONE_NOTICE_MS = 5 * 60 * 1000;
+/**
+ * この周で「入力待ちなのに終わりの印が無い」を管制へ知らせるかを決める純粋関数。
+ *
+ * ★1便に1回だけ（told）。★Codex の現場だけ（Claude は画面なし方式＝終わりを実プロセスで掴める）。
+ * ★印が見つかった周・まだ手を動かしている周では鳴らさない（idleNoDoneSince が null に戻る）。
+ */
+export function decideIdleNoDoneNotice(args) {
+    if (args.kind !== 'codex')
+        return false;
+    if (args.told)
+        return false;
+    if (!args.idle || args.doneSeen)
+        return false;
+    if (args.idleNoDoneSince === null)
+        return false;
+    return args.now - args.idleNoDoneSince >= RELAY_IDLE_NO_DONE_NOTICE_MS;
+}
+/** 管制へ知らせる1行の本文（★純粋関数・秘密は1文字も入れない）。 */
+export function idleNoDoneNoticeText(site, idleSeconds) {
+    return (`職人（Codex）は入力待ちに戻っていますが、終わりの印（DONE:${site}）が画面に見つかりません` +
+        `（入力待ちになってから約${Math.max(0, Math.round(idleSeconds))}秒）。` +
+        '返事を書き終えているのに印の書き方が違う／印が表の行として描かれた、のどちらかの可能性があります。');
+}
+/**
+ * 管制の出来事の口へ1行送る（★最善努力。失敗は握りつぶしてログだけ）。
+ *   便の状態は書かない・報告も送らない＝この呼び出しで便が完了になることは無い。
+ */
+export async function sendCommandNotice(cfg, commandId, text, opts = {}) {
+    const doFetch = opts.fetchImpl ?? fetch;
+    const logLine = opts.logLine ?? log;
+    const at = new Date(opts.now?.() ?? Date.now()).toISOString();
+    try {
+        const res = await doFetch(`${cfg.url}/api/conductor/commands/${encodeURIComponent(commandId)}/events`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${cfg.token}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ events: [{ type: 'progress', text, at, attempt: 1 }] }),
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
+        });
+        if (res.ok)
+            return true;
+        logLine(`site=${cfg.site} id=${commandId} 気づきの知らせ -> HTTP ${res.status}（送れなくても作業は止めません）`);
+        return false;
+    }
+    catch (err) {
+        logLine(`site=${cfg.site} id=${commandId} 気づきの知らせ -> 失敗: ` +
+            `${err instanceof Error ? err.message : String(err)}（送れなくても作業は止めません）`);
+        return false;
+    }
+}
 /** 便の終わりの関門の種類（控えの数え方の見出し。★`finish_gate.py` の GATE_KINDS と同じ語）。 */
 export const FINISH_GATE_KINDS = ['report', 'pr', 'background'];
 /** 届けられなかった「終了の事実」の置き場。 */
@@ -4520,6 +5006,8 @@ export function startKeepalive(state, pending, now) {
         lastHeartbeatAt: null,
         lastCentralProbeAt: null,
         screenDoneUsable: true,
+        // ★2本目の物差しの床を引き継ぐ（★引き継がないと、履歴に残る前の便の印を拾いかねない）。
+        ...(pending.doneFloorLoose != null ? { doneFloorLoose: pending.doneFloorLoose } : {}),
     };
     return true;
 }
@@ -4558,6 +5046,7 @@ const DEFAULT_KEEPALIVE_DEPS = {
     completeFromFile: (cfg, id) => completeWithReport(cfg, id),
     takeNotices: (site, id) => takeCodexNoticesForJobId(site, id),
     centralStatus: (cfg, id) => fetchCommandStatus(cfg, id),
+    notice: (cfg, id, text) => sendCommandNotice(cfg, id, text),
     now: () => Date.now(),
     logLine: (msg) => log(msg),
 };
@@ -4571,7 +5060,7 @@ export async function keepaliveTick(cfg, state, deps = {}) {
     const ka = state.keepalive;
     if (!ka)
         return;
-    const { capture, heartbeat, complete, completeFromFile, takeNotices, centralStatus: getStatus, now: clock, logLine, } = {
+    const { capture, heartbeat, complete, completeFromFile, takeNotices, centralStatus: getStatus, notice: sendNotice, now: clock, logLine, } = {
         ...DEFAULT_KEEPALIVE_DEPS,
         ...deps,
     };
@@ -4586,6 +5075,8 @@ export async function keepaliveTick(cfg, state, deps = {}) {
         const notice = mine.length === 0 ? null : mine[mine.length - 1];
         if (notice !== null) {
             state.codexNoticeSeen = true;
+            // ★知らせが届いた＝「この現場から知らせが来ない」の数えを 0 に戻す（便 36236d41）。
+            noteCodexNoticeHeard(cfg, state);
             // ★この便のターンは終わった＝「前のターンが途中」の札も下ろす。
             if (state.codexTurnOpen !== null && state.codexTurnOpen.jobId === ka.id) {
                 state.codexTurnOpen = null;
@@ -4637,12 +5128,26 @@ export async function keepaliveTick(cfg, state, deps = {}) {
     //   生存通知の可否(alive)は従来どおり busy ∪ メニュー＝1文字も変えない。
     const kaBusySignal = cap !== null && hasBusySignalFor(cap, kindOf(cfg));
     const kaMenu = cap !== null && hasChoiceMenuFor(cap, kindOf(cfg));
+    const kaIdle = cap !== null && looksIdleFor(cap, kindOf(cfg));
+    // ★見張りでも、今までの道（単独行）が空振りしたら2本目の道を見る（便 0029ef4d）。
+    //   Codex の便で入力待ちの周だけ・引き継いだ床より増えたときだけ＝守りは1つも緩めない。
+    const kaTrailingScan = ka.screenDoneUsable && below !== null && kindOf(cfg) === 'codex'
+        ? scanTrailingDoneForPending(below, ka.site, {
+            idle: kaIdle,
+            floor: ka.doneFloorLoose ?? null,
+        })
+        : null;
+    // ★床は下がるだけ（古い印の行が履歴から流れたぶんだけ下げる＝あとで出た合図を取りこぼさない）。
+    if (kaTrailingScan !== null && ka.doneFloorLoose != null && kaTrailingScan.floor !== ka.doneFloorLoose) {
+        ka.doneFloorLoose = kaTrailingScan.floor;
+    }
+    const kaTrailingDone = kaTrailingScan?.done === true;
     const action = decideKeepalive({
         expired,
         capOk: cap !== null,
-        doneSeen: ka.screenDoneUsable && below !== null && hasStandaloneDone(below, ka.site),
+        doneSeen: (ka.screenDoneUsable && below !== null && hasStandaloneDone(below, ka.site)) || kaTrailingDone,
         alive: cap !== null && (kaBusySignal || kaMenu),
-        idle: cap !== null && looksIdleFor(cap, kindOf(cfg)),
+        idle: kaIdle,
         throttleOk: ka.lastHeartbeatAt === null || now - ka.lastHeartbeatAt >= RELAY_HEARTBEAT_INTERVAL_MS,
         // ★中央への答え合わせのしぼり。生存通知と同じ150秒（RELAY_HEARTBEAT_INTERVAL_MS）。
         centralProbeOk: ka.lastCentralProbeAt === null || now - ka.lastCentralProbeAt >= RELAY_HEARTBEAT_INTERVAL_MS,
@@ -4683,6 +5188,25 @@ export async function keepaliveTick(cfg, state, deps = {}) {
         return;
     }
     if (action === 'done') {
+        // ── 画面の合図で【すぐには閉じない】（★Codex だけ・便 36236d41） ──
+        //   追跡（pending）と同じ race が見張りでも起きる（合図の直後に知らせが届く）。
+        //   合図を拾っても閉じず、短く待つ＝上の受け皿の読みが毎周いちばん先に走るので、
+        //   届いたらそちらの道で本文つきに閉じる。★待っても来なければ今までどおり閉じる。
+        if (kindOf(cfg) === 'codex') {
+            const kaHold = decideCodexDoneHold({
+                kind: 'codex',
+                screenDoneSince: ka.screenDoneSince ?? null,
+                now,
+            });
+            if (kaHold === 'wait') {
+                if (ka.screenDoneSince == null) {
+                    ka.screenDoneSince = now;
+                    logLine(`site=${cfg.site} id=${ka.id} 見張りで画面の終わりの合図を見つけました。` +
+                        `終わりの知らせを最大${Math.round(RELAY_CODEX_DONE_NOTICE_WAIT_MS / 1000)}秒待ちます`);
+                }
+                return;
+            }
+        }
         // ★冪等（2026-09-21）: 報告が既に処理済み＝この便はもう渡してある。送らずに畳むだけ。
         //   実測 2026-09-20: 職人が MCP で完了した便に、見張りが画面の DONE でもう一度完了を送っていた。
         if (reportPhase(ka.id) === 'processed') {
@@ -4702,7 +5226,22 @@ export async function keepaliveTick(cfg, state, deps = {}) {
             if (report !== null)
                 markReportProcessed(ka.id); // ★消さずに処理済みへ（二度送らない）
             logLine(`site=${cfg.site} id=${ka.id} 見張り終了: 画面のDONEを検出し完了を報告` +
+                // ★どちらの物差しで拾ったかを残す（便 0029ef4d・あとで原因を追えるように）。
+                `${kaTrailingDone ? '（印は行の中に描かれていました）' : ''}` +
                 `${report != null ? '（報告添付）' : kaDelivery.phase === 'none' ? '' : `（${kaDelivery.note}）`}`);
+            // ── 「知らせ0件」のまま閉じた（★便 36236d41） ──
+            //   この道を通った＝この便の終わりの知らせは1件も来なかった（来ていれば上の受け皿の道で
+            //   閉じている）。現場ごとに数え、続いたら管制へ1回だけ知らせる。あわせて便を覚えておく。
+            if (kindOf(cfg) === 'codex') {
+                const silent = noteCodexSilentClose(cfg, state, ka.id, { now });
+                logLine(`site=${cfg.site} id=${ka.id} 終わりの知らせが1件も来ないまま閉じました` +
+                    `（この現場で ${silent.count} 便 続けて）`);
+                if (silent.tell) {
+                    const text = codexSilentCloseNoticeText(cfg.site, silent.count);
+                    logLine(`WARN site=${cfg.site} id=${ka.id} ${text}`);
+                    await sendNotice(cfg, ka.id, text);
+                }
+            }
             // ★終わったら必ず手を下ろす（挙げっぱなしにすると現場が長くふさがる）。
             noteBusyEdge(state, cfg.site, ka.id, false, logLine);
             state.keepalive = null;
@@ -4842,6 +5381,12 @@ export async function relayTick(cfg, state, hooks) {
         // pending 分岐も新規指示の取得も従来どおり動く（pending を落とす目的を殺さない）。
         // 停止中(relayHalted)でも続けるのは、既に送った指示の後始末は進めるという既存方針と同じ。
         await keepaliveTick(cfg, state);
+        // ── 「完了のみ」で閉じた便へ後から届いた知らせを結び直す（★便 36236d41） ──
+        // ★追跡中でも見張り中でも、どの周でも必ず通す。ここを通さないと、下の pending 分岐の
+        //   受け皿の読み（pickCodexNoticeFor は受け皿を空にする）や、配る直前の空にしで、
+        //   閉じた便の知らせが控えへ回ってしまい、本文が永久に管制へ載らない。
+        // ★取るのは印が一致した行だけ・便の状態は1文字も書かない（relinkClosedCodexNotices）。
+        relinkClosedCodexNotices(cfg, state);
         // ── 届いていない「終了の事実」の送り直し（★便 915694ac・黙って捨てない） ──
         //   既に送った便の後始末なので、停止中(relayHalted)でも続ける（keepaliveTick と同じ方針）。
         await flushPendingJobEndFacts(cfg, { logLine: log });
@@ -4934,6 +5479,8 @@ export async function relayTick(cfg, state, hooks) {
                 }
                 const notice = pick.notice;
                 if (notice !== null) {
+                    // ★知らせが届いた＝「この現場から知らせが来ない」の数えを 0 に戻す（便 36236d41）。
+                    noteCodexNoticeHeard(cfg, state);
                     // ★この便のターンは終わった＝「前のターンが途中」の札を下ろす。
                     if (state.codexTurnOpen !== null && state.codexTurnOpen.jobId === state.pending.id) {
                         state.codexTurnOpen = null;
@@ -4979,6 +5526,8 @@ export async function relayTick(cfg, state, hooks) {
             if (state.pending.doneFloor != null && state.pending.doneFloorSettled !== true) {
                 // 配達のエコーを含んだ数も床に取り込む（PendingEntry.doneFloorSettled の説明）。
                 state.pending.doneFloor = Math.max(state.pending.doneFloor, countStandaloneDone(cap, cfg.site));
+                // ★2本目の物差し（行の中に描かれた印）の床も、同じ周に決め終える（PendingEntry.doneFloorLoose）。
+                state.pending.doneFloorLoose = Math.max(state.pending.doneFloorLoose ?? 0, countTrailingDone(cap, cfg.site));
                 state.pending.doneFloorSettled = true;
             }
             const scan = scanDoneForPending(cap, cfg.site, state.pending.anchor, {
@@ -4988,7 +5537,74 @@ export async function relayTick(cfg, state, hooks) {
             if (state.pending.doneFloor != null && scan.floor !== state.pending.doneFloor) {
                 state.pending.doneFloor = scan.floor;
             }
-            if (scan.done) {
+            // ★今までの道が空振りしたときだけ、2本目の道を見る（便 0029ef4d）。
+            //   「職人は入力待ちに戻っている」＋「この行は印で終わっている」の2つで読むので、
+            //   印が表の行として描かれても（行の頭に別の字が付いても）拾える。
+            //   ★Codex の便で入力待ちの周にしか効かない＝Claude の現場は1バイトも変わらない。
+            const idle = looksIdleFor(cap, kindOf(cfg));
+            const looseScan = scanTrailingDoneForPending(cap, cfg.site, {
+                idle: kindOf(cfg) === 'codex' && idle && !scan.done,
+                floor: state.pending.doneFloorLoose ?? null,
+            });
+            if (state.pending.doneFloorLoose != null && looseScan.floor !== state.pending.doneFloorLoose) {
+                state.pending.doneFloorLoose = looseScan.floor;
+            }
+            if (looseScan.done && !scan.done) {
+                log(`site=${cfg.site} id=${state.pending.id} 終わりの印を【行の中】で見つけました` +
+                    '（職人は入力待ちに戻っています・印が表の行として描かれた形）');
+            }
+            // ── 「入力待ちなのに印が見つからない」を管制へ1回だけ知らせる（便 0029ef4d） ──
+            //   ★便の状態は書かない（完了にしない）。知らせるだけ。
+            const doneSeenNow = scan.done || looseScan.done;
+            if (!idle || doneSeenNow) {
+                state.pending.idleNoDoneSince = null;
+            }
+            else if (state.pending.idleNoDoneSince == null) {
+                state.pending.idleNoDoneSince = Date.now();
+            }
+            if (decideIdleNoDoneNotice({
+                kind: kindOf(cfg),
+                idle,
+                doneSeen: doneSeenNow,
+                idleNoDoneSince: state.pending.idleNoDoneSince ?? null,
+                now: Date.now(),
+                told: state.pending.idleNoDoneTold === true,
+            })) {
+                state.pending.idleNoDoneTold = true;
+                const idleSec = (Date.now() - (state.pending.idleNoDoneSince ?? Date.now())) / 1000;
+                const text = idleNoDoneNoticeText(cfg.site, idleSec);
+                log(`WARN site=${cfg.site} id=${state.pending.id} ${text}`);
+                await sendCommandNotice(cfg, state.pending.id, text, { logLine: log });
+                if (state.pending === null)
+                    return; // 念のため（送信中に追跡が畳まれた場合）
+            }
+            if (doneSeenNow) {
+                // ── 画面の合図で【すぐには閉じない】（★Codex だけ・便 36236d41） ──
+                // 実物 351dea1c は画面の合図で閉じた 16 秒後に知らせが届き、本文が控えへ回った。
+                // そこで合図を拾っても閉じず、その便の印が合う知らせを短く待つ（上の受け皿の読みが
+                // 毎周いちばん先に走るので、届いたらそちらの道で本文つきに閉じる）。
+                // ★追跡は外れないので、待つあいだ次の便は配られない（同じ画面で便が重ならない）。
+                // ★ここで return するので生存通知も送らない＝管制の時間切れの働きを1秒も遅らせない。
+                const hold = decideCodexDoneHold({
+                    kind: kindOf(cfg),
+                    screenDoneSince: state.pending.screenDoneSince ?? null,
+                    now: Date.now(),
+                });
+                if (hold === 'wait') {
+                    if (state.pending.screenDoneSince == null) {
+                        state.pending.screenDoneSince = Date.now();
+                        log(`site=${cfg.site} id=${state.pending.id} 画面の終わりの合図を見つけました。` +
+                            `終わりの知らせを最大${Math.round(RELAY_CODEX_DONE_NOTICE_WAIT_MS / 1000)}秒待ちます` +
+                            '（待つあいだ次の便は配りません）');
+                    }
+                    return;
+                }
+                if (kindOf(cfg) === 'codex') {
+                    log(`WARN site=${cfg.site} id=${state.pending.id} 終わりの知らせが` +
+                        `${Math.round(RELAY_CODEX_DONE_NOTICE_WAIT_MS / 1000)}秒来なかったので「完了のみ」で閉じます` +
+                        `（この便を${Math.round(RELAY_CODEX_CLOSED_REMEMBER_MS / 60000)}分のあいだ覚えておき、` +
+                        'あとで届いた知らせはこの便の報告として結び直します）');
+                }
                 // ★報告は画面から読まない。職人が書いたファイルを読む（relayReportDirs / readReport）。
                 //   画面を読む方式は窓が 16〜34 行しかなく、9/5 以降 162 回すべて失敗していた（調査 d1d16a56）。
                 // ★「届いた」は形まで見る（便 461be339）。整っていなければ理由も一緒に届ける。
@@ -5009,6 +5625,22 @@ export async function relayTick(cfg, state, hooks) {
                         detail: '配り役が画面の完了の合図で確かめた（職人の処理は中継が持っていない）'
                             + (doneDelivery.note !== null ? `／${doneDelivery.note}` : ''),
                     }, { logLine: log });
+                    // ── 「知らせ0件」のまま閉じた（★便 36236d41） ──
+                    //   この道を通った＝この便の終わりの知らせは1件も来なかった（来ていれば上の
+                    //   受け皿の道で閉じている）。現場ごとに数え、続いたら管制へ1回だけ知らせる。
+                    //   ★あわせてこの便を覚えておく＝あとで届いた知らせを報告として結び直せる。
+                    if (kindOf(cfg) === 'codex') {
+                        const closedId = state.pending.id;
+                        const silent = noteCodexSilentClose(cfg, state, closedId);
+                        log(`site=${cfg.site} id=${closedId} 終わりの知らせが1件も来ないまま閉じました` +
+                            `（この現場で ${silent.count} 便 続けて）`);
+                        if (silent.tell) {
+                            const text = codexSilentCloseNoticeText(cfg.site, silent.count);
+                            log(`WARN site=${cfg.site} id=${closedId} ${text}`);
+                            // ★便の状態は1文字も書かない（出来事の口へ1行送るだけ）。
+                            await sendCommandNotice(cfg, closedId, text, { logLine: log });
+                        }
+                    }
                     state.pending = null;
                 }
                 return; // sent 中は新規取得しない
@@ -5035,7 +5667,7 @@ export async function relayTick(cfg, state, hooks) {
             //     ・それ以外の周      … 150秒（RELAY_HEARTBEAT_INTERVAL_MS・生存通知と同じ時計）に1回
             //   ＝HTTP の増分は1指示あたり最大で150秒に1回。画面の読み取りが外れても、中央で終わった便は
             //     必ず150秒以内の周で追跡解除され、次の便が配られる。
-            const idle = looksIdleFor(cap, kindOf(cfg));
+            // ★画面の待機の読み（idle）は、上の完了検出の手前で1回だけ測って使い回す（値は同じ・純粋関数）。
             const probeBase = state.pending.lastStatusProbeAt ?? state.pending.sentAt;
             const probeDue = Date.now() - probeBase >= RELAY_HEARTBEAT_INTERVAL_MS;
             const askedCentral = state.pending.sentMarked && (idle || probeDue);
@@ -5396,7 +6028,14 @@ export async function relayTick(cfg, state, hooks) {
             delivered: true,
             sentMarked: false,
             screenDoneWide: codexFloor !== null,
-            ...(codexFloor !== null ? { doneFloor: codexFloor, doneFloorSettled: false } : {}),
+            ...(codexFloor !== null
+                ? {
+                    doneFloor: codexFloor,
+                    // ★2本目の物差し（行の中に描かれた印）の床も、同じ画面から数えて覚える（便 0029ef4d）。
+                    doneFloorLoose: countTrailingDone(guardCap, cfg.site),
+                    doneFloorSettled: false,
+                }
+                : {}),
             ...(useAck ? { markAs: 'delivering' } : {}),
         };
         // 累計配達回数を通算（絶対上限 RELAY_DELIVER_MAX の基準）。
@@ -5468,6 +6107,9 @@ export async function relayTick(cfg, state, hooks) {
     finally {
         // ★どの道で抜けても、札の中身を控えへ写す（中身が変わっていなければ書かない）。
         saveCodexTurn(cfg, state);
+        // ★見張りの控え（覚えている便・知らせが来ない数え）も同じ作法で写す（便 36236d41）。
+        //   配り役を入れ直しても引き継ぐ＝閉じた便の結び直しと数えが途切れない。
+        saveCodexWatch(cfg, state);
         state.running = false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyhld/conductor",
-  "version": "0.12.106",
+  "version": "0.12.108",
   "description": "采配くん管制の見守りアプリ（conductor-agent）。各PCで常駐し、中央(devlog-tracker)へ定期的に生存報告(heartbeat)を送る常駐CLI。",
   "type": "module",
   "bin": {

package/scripts/codex/codex-notify.py

@@ -59,6 +59,19 @@
     ④ それも分からなければ作業フォルダの名前（今までどおり）。
   ★どれでも決められない知らせは【捨てない】。理由つきで控え（UNRESOLVED_FILE）へ残す。
 
+【★呼ばれた事を1行だけ残す（2026-10-06・便 36236d41）】
+  調査 f567f8d8 で分かったいちばん痛い所は、「受け口が呼ばれたが黙って終わった」と
+  「受け口が一度も呼ばれていない」を、実物で分けられないことだった（受け口は自分の動いた
+  記録を1行も残していなかった）。だから Codex が知らせを出していないのか、受け口が
+  捨てているのかを、人が確かめる材料が無かった。
+  そこで、呼ばれるたびに受け皿の置き場の中の1つのファイル（CALLS_FILE）へ1行だけ足す。
+    ・時刻／type／どう扱ったか（CALL_HOW_*）／現場名／便の印が在ったか／本文の字数
+  ★本文・指示文・作業フォルダより下の中身は【1文字も書かない】（字数と有無だけ）。
+  ★名前は `_calls.log`＝配り役は受け皿（`<現場>.jsonl`）として読まないし、
+    読まれない受け皿の始末（relay.ts の sweepStrayCodexNotices）の対象にもならない。
+  ★行数に上限（CALLS_MAX_LINES）を付け、古い物から落とす。
+  ★記録を書けなくても、知らせの本体は今までどおり書く・終了コードは 0 のまま。
+
 【やること】残す通知だけを、現場ごとの受け皿へ1行足す。
   置き場: $CONDUCTOR_CODEX_NOTIFY_DIR（既定 $HOME/.tyhld/codex-notify）/<現場>.jsonl
   ★中央へは送らない。送るのは relay の仕事（完了の経路は1本に保つ）。
@@ -98,6 +111,24 @@ UNRESOLVED_FILE = '_unresolved.skipped.jsonl'
 #   ★relay.ts の CODEX_SKIPPED_NOTICE_MAX_LINES と同じ値にそろえる。
 UNRESOLVED_MAX_LINES = 200
 
+# 「呼ばれた事」の記録（★受け皿でも控えでもない・配り役は読まない名前にする）。
+#   `.jsonl` で終わらない＝relay.ts の takeCodexNotices（`<現場>.jsonl`）も
+#   sweepStrayCodexNotices（`.jsonl` だけを見る）も、このファイルには一切触らない。
+CALLS_FILE = '_calls.log'
+
+# 記録に残す行数の上限（古い物から落とす）。
+CALLS_MAX_LINES = 500
+
+# どう扱ったか（★この5通りだけ）。
+CALL_HOW_TRAY = 'tray'                      # 受け皿へ書いた
+CALL_HOW_INTERNAL = 'internal-turn'         # Codex 内部のターンなので捨てた
+CALL_HOW_UNRESOLVED = 'unresolved-site'     # 現場を決められず控えへ回した
+CALL_HOW_BAD_ARGS = 'bad-args'              # この受け口が読めない引数だった
+CALL_HOW_WRITE_FAILED = 'write-failed'      # 書けなかった
+
+# type に書いてよい字（★届いた値をそのまま書かない＝記録の行を壊させない）。
+TYPE_OK = re.compile(r'[^A-Za-z0-9._-]')
+
 
 def notify_dir(env=None):
     env = os.environ if env is None else env
@@ -325,29 +356,95 @@ def keep_unresolved(payload, report, why, env=None):
         return ''
 
 
+def call_line(how, why, payload=None, site='', report=''):
+    """「呼ばれた事」の1行（★本文・指示文・作業フォルダは1文字も入れない）。"""
+    raw_type = ''
+    if isinstance(payload, dict):
+        raw_type = TYPE_OK.sub('', str(payload.get('type') or ''))[:40]
+    return json.dumps(
+        {
+            'at': datetime.datetime.now(datetime.timezone.utc).isoformat(),
+            'type': raw_type,
+            'how': how,
+            'why': why,
+            'site': site or None,
+            # ★印そのものは書かない（有無だけ）。
+            'jobStamp': job_id_of(payload) is not None if isinstance(payload, dict) else False,
+            # ★本文は書かない（字数だけ）。
+            'reportChars': len(report or ''),
+        },
+        ensure_ascii=False,
+    )
+
+
+def record_call(how, why, payload=None, site='', report='', env=None):
+    """呼ばれた事を記録に1行足す。返り: 書けたファイル／''。
+
+    ★ここで何が起きても例外を外に出さない・終了コードを変えない（Codex を止めない）。
+      記録が書けないことは、知らせの本体を書かない理由にはしない（呼ぶ順も本体の【後】）。
+    """
+    try:
+        target_dir = notify_dir(env)
+        if not target_dir:
+            return ''
+        file = os.path.join(target_dir, CALLS_FILE)
+        line = call_line(how, why, payload, site, report)
+        os.makedirs(target_dir, exist_ok=True)
+        kept = []
+        if os.path.exists(file):
+            with open(file, encoding='utf-8') as f:
+                kept = [l for l in f.read().split('\n') if l.strip()]
+        lines = (kept + [line])[-CALLS_MAX_LINES:]
+        with open(file, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(lines) + '\n')
+        return file
+    except Exception:  # noqa: BLE001
+        return ''
+
+
 def main(argv):
     raw = ' '.join(argv[1:]).strip()
     if not raw:
+        record_call(CALL_HOW_BAD_ARGS, 'no-args')
         return 0
     try:
         payload = json.loads(raw)
     except Exception:  # noqa: BLE001
+        record_call(CALL_HOW_BAD_ARGS, 'not-json')
         return 0  # 読めない通知は黙って捨てる（Codex を止めない）
     keep, site, report, reason = decide(payload)
     if not keep:
         # ★現場を決められなかった知らせだけは、捨てずに控えへ残す（便 684ac785）。
         if reason.startswith('unresolved-site:'):
-            keep_unresolved(payload, report, reason[len('unresolved-site:'):])
+            wrote = keep_unresolved(payload, report, reason[len('unresolved-site:'):])
+            record_call(
+                CALL_HOW_UNRESOLVED if wrote else CALL_HOW_WRITE_FAILED,
+                reason if wrote else 'unresolved-unwritable',
+                payload,
+                report=report,
+            )
+            return 0
+        record_call(
+            CALL_HOW_INTERNAL if reason == 'internal-turn' else CALL_HOW_BAD_ARGS,
+            reason,
+            payload,
+            report=report,
+        )
         return 0
     target_dir = notify_dir()
     if not target_dir:
+        record_call(CALL_HOW_WRITE_FAILED, 'no-notify-dir', payload, site, report)
         return 0
     try:
         os.makedirs(target_dir, exist_ok=True)
         with open(os.path.join(target_dir, f'{site}.jsonl'), 'a', encoding='utf-8') as f:
             f.write(notice_line(payload, site, report) + '\n')
     except Exception:  # noqa: BLE001
+        # ★知らせの本体を書けなかった事も記録に残す（「呼ばれていない」と区別できるようにする）。
+        record_call(CALL_HOW_WRITE_FAILED, 'tray-write-error', payload, site, report)
         return 0
+    # ★記録は本体を書いた【後】に足す（記録が書けなくても本体は残る）。
+    record_call(CALL_HOW_TRAY, reason, payload, site, report)
     return 0