@tyhld/conductor 0.12.107 → 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)
@@ -4711,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),
 };
@@ -4724,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,
     };
@@ -4739,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;
@@ -4850,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') {
@@ -4872,6 +5229,19 @@ export async function keepaliveTick(cfg, state, deps = {}) {
                 // ★どちらの物差しで拾ったかを残す（便 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;
@@ -5011,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 });
@@ -5103,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;
@@ -5201,6 +5579,32 @@ export async function relayTick(cfg, state, hooks) {
                     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）。整っていなければ理由も一緒に届ける。
@@ -5221,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 中は新規取得しない
@@ -5687,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.107",
+  "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