@tyhld/conductor 0.12.101 → 0.12.103

package/dist/autoupdate.js

@@ -520,6 +520,40 @@ function waitingForHuman(d, now) {
         detail: `自己診断を測り直しましたが、まだ通りません（${r.failedKeys.join(',') || '不明'}${r.humanOnly ? '・人の操作待ち' : ''}）`,
     };
 }
+/**
+ * 最後の自己診断が「仕組みの異常（🟡・fault）」で落ちたままなら、HELD_RECHECK_MS ごとに測り直す（便 cbc27db6）。
+ *
+ * 【なぜ要るか（実物 2026-10-05 00:19Z・メインPC）】
+ *   スリープから起きた直後の毎日の自己診断で、「管制との通信」の1行だけが時間切れで落ちた
+ *   （ほかの項目は全部通っていた）＝回線が戻りきる前の、その場かぎりの失敗。
+ *   ところがこの FAIL は【次の毎日の自己診断（翌日）まで残る】。そのあいだ管制は🟡のままで、
+ *   この機は後続の順番から外れ、新しい版を受け取れない。人が手で流し直すまで戻らなかった。
+ *   ＝人の手で直すのではなく、更新係が測り直して、通ったら自分で元に戻れるようにする（根治）。
+ *
+ * 【緩めていない所】
+ *   ★合否の決め方は1つも変えない。通らなければ今までどおり FAIL のまま（管制が🟡にし、順番から外す）。
+ *   ★入れ替えの直後（after-conductor・after-claude）の FAIL には当てない。
+ *     あちらは phase が swapped / held で先に処理されるので、ここまで来ない（戻す → 自己診断のまま）。
+ *   ★測り直すたびに小さな試験の費用がかかるので、間隔は held の測り直しと同じ（それより短くしない）。
+ *   ★常駐がまだ起きていない起動時（boot）は測らない（常駐が動いていない＝落ちて当たり前）。
+ *   ★通ったことは自己診断自身が管制へ届ける（更新係は届け直さない）。
+ */
+function recheckAfterFault(d, now) {
+    if (d.boot)
+        return '';
+    const last = readLastSelfcheck(d.home);
+    if (!last || last.pass || last.humanOnly)
+        return '';
+    const age = last.finishedAt === null ? Infinity : now.getTime() - last.finishedAt;
+    if (age < HELD_RECHECK_MS)
+        return '';
+    const r = d.runSelfcheck('daily');
+    const detail = r.pass
+        ? '仕組みの異常（🟡）で落ちていた自己診断を測り直したら通りました（管制へも届きました）'
+        : `仕組みの異常（🟡）の自己診断を測り直しましたが、まだ通りません（${r.failedKeys.join(',') || '不明'}）`;
+    d.log(detail);
+    return detail;
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // 1回ぶん
 // ─────────────────────────────────────────────────────────────────────────────
@@ -579,6 +613,10 @@ export async function runUpdater(d) {
     // ③-2 人の操作待ち（🔵）で自己診断が落ちたままなら、測り直してから先へ進む（便 4cf71dde）。
     //   ★落ちたまま入れ替えると、同じ理由で落ちて戻し、版に疑いが付く（実物 2026-10-03 02:43Z・ノートPC）。
     const human = waitingForHuman(d, now);
+    // ③-3 仕組みの異常（🟡）で自己診断が落ちたままなら、held と同じ間隔で測り直す（便 cbc27db6）。
+    //   ★その場かぎりの時間切れで落ちた FAIL が翌日まで残り、この機が順番から外れたままになるのを直す。
+    //   ★入れ替えるかどうかの決め方は1つも変えない（通らなければ今までどおり FAIL のまま）。
+    const refault = recheckAfterFault(d, now);
     // ④ どの部品を動かすか（★conductor の目標が今と違うあいだは Claude Code を動かさない）。
     const claudeNow = d.resolveClaude();
     let comp = null;
@@ -614,7 +652,8 @@ export async function runUpdater(d) {
         // ★後続の機は候補を探さない・候補の自己診断を流さない（役は管制が決める・欄が無ければ今までどおり）。
         if (target.role !== 'follower')
             await reportCandidates(d, s, installed, claudeNow?.version ?? null);
-        return done(d, s, 'none', `目標の版と同じです（conductor ${installed ?? '不明'}・Claude Code ${claudeNow?.version ?? '不明'}）`);
+        const same = `目標の版と同じです（conductor ${installed ?? '不明'}・Claude Code ${claudeNow?.version ?? '不明'}）`;
+        return done(d, s, 'none', refault ? `${same}。${refault}` : same);
     }
     if (human.waiting) {
         removeDrain(d, s);

package/dist/relay.js

@@ -316,6 +316,111 @@ export const RELAY_SKIP_WARN_THRESHOLD = 6;
  *   中央が便を抱える上限（CENTRAL_BUSY_HOLD_MAX_MS＝3時間）と同じ値にそろえる。
  */
 export const RELAY_CODEX_TURN_HOLD_MAX_MS = CENTRAL_BUSY_HOLD_MAX_MS;
+/**
+ * 配り役が現場ごとの控えを置く場所（★再起動で消えない・報告の置き場と同じ親の下）。
+ *   環境変数 `CONDUCTOR_RELAY_STATE_DIR` を指定したときはそこだけ（試験・特殊な機体向け）。
+ */
+export function relayStateDir(env = process.env) {
+    const explicit = (env.CONDUCTOR_RELAY_STATE_DIR ?? '').trim();
+    if (explicit)
+        return explicit;
+    const home = env.HOME ?? os.homedir();
+    const state = (env.XDG_STATE_HOME ?? '').trim() || path.join(home, '.local', 'state');
+    return path.join(state, 'conductor', 'relay');
+}
+/** この現場の「Codex のターンの札」の控えのパス。 */
+export function codexTurnFile(site, env = process.env) {
+    const safe = String(site ?? '').replace(/[^A-Za-z0-9_-]/g, '').slice(0, 128) || 'unknown';
+    return path.join(relayStateDir(env), `codex-turn-${safe}.json`);
+}
+/** 控えを読む。無い・読めない・形が違うときは null（★配り役を止めない）。 */
+export function readCodexTurnRecord(site, env = process.env) {
+    try {
+        const o = JSON.parse(readFileSync(codexTurnFile(site, env), 'utf8'));
+        const jobId = typeof o.jobId === 'string' && o.jobId.trim() !== '' ? o.jobId.trim() : null;
+        const since = typeof o.since === 'number' && Number.isFinite(o.since) ? o.since : null;
+        return {
+            jobId,
+            since: jobId === null ? null : since,
+            noticeSeen: o.noticeSeen === true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** 控えを書く（★書けなくても配り役は止まらない＝今までどおりメモリの札で動く）。 */
+export function writeCodexTurnRecord(site, rec, env = process.env) {
+    const file = codexTurnFile(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;
+    }
+}
+/**
+ * 「Codex の前のターンの札」を下ろしてよいかを決める純粋関数（I/Oなし＝単体テスト可能）。
+ *
+ * 【なぜ知らせ1本に頼らないか（調査 b9f6f53e の重大発見1・2）】札が下りる唯一の道は
+ *   「終わりの知らせが受け皿に届くこと」だった。実測 2026-10-05、走行中のターンへ人が
+ *   手で文を入れた便（9fb59241）では知らせが1行も出ず、現場が最長3時間ふさがった。
+ *   そこで出口を1本足す：★画面が待機（作業中の印が無い）で、かつその便が管制で終端
+ *   （done / failed / timeout など）なら、ターンは終わっている。
+ * ★画面が作業中に見えるあいだは下ろさない＝長いターンの途中で次の便を割り込ませない
+ *   （この札の本来の目的は1バイトも弱めない）。
+ * ★画面が読めない・管制に聞けないときも下ろさない（断定しない＝保守側）。
+ */
+export function decideCodexTurnRelease(input) {
+    if (input.heldMs >= RELAY_CODEX_TURN_HOLD_MAX_MS)
+        return 'release-max';
+    if (input.screenIdle === true && input.centralFinished === true)
+        return 'release-finished';
+    return 'hold';
+}
+/**
+ * 札の控えを読み込む（★起動後の最初の1周だけ・Codex の現場だけ）。
+ *   控えに「まだ途中のターン」が在れば、メモリの札として引き継ぐ＝配り役を入れ直しても
+ *   長いターンの途中に次の便を割り込ませない。受け口の知らせを見た事実も引き継ぐ。
+ */
+export function loadCodexTurnOnce(cfg, state, env = process.env, logLine = log) {
+    if (state.codexTurnLoaded)
+        return;
+    state.codexTurnLoaded = true;
+    if (kindOf(cfg) !== 'codex')
+        return;
+    const rec = readCodexTurnRecord(cfg.site, env);
+    if (rec === null)
+        return;
+    state.codexTurnDisk = JSON.stringify(rec);
+    if (rec.noticeSeen)
+        state.codexNoticeSeen = true;
+    if (rec.jobId !== null && state.codexTurnOpen === null) {
+        state.codexTurnOpen = { jobId: rec.jobId, since: rec.since ?? Date.now() };
+        logLine(`site=${cfg.site} id=${rec.jobId} のターンは控えでまだ途中でした` +
+            '（札を引き継ぎます＝入れ直しても状態が食い違わない）');
+    }
+}
+/** いまの札を控えへ写す（★中身が変わっていなければ書かない）。書けなくても配り役は止まらない。 */
+export function saveCodexTurn(cfg, state, env = process.env) {
+    if (kindOf(cfg) !== 'codex')
+        return;
+    const rec = {
+        jobId: state.codexTurnOpen?.jobId ?? null,
+        since: state.codexTurnOpen?.since ?? null,
+        noticeSeen: state.codexNoticeSeen,
+    };
+    const text = JSON.stringify(rec);
+    if (text === state.codexTurnDisk)
+        return;
+    // まだ控えが無く、書くことも何も無い（札なし・知らせ未観測）＝ファイルを作らない。
+    if (state.codexTurnDisk === null && rec.jobId === null && !rec.noticeSeen)
+        return;
+    if (writeCodexTurnRecord(cfg.site, rec, env))
+        state.codexTurnDisk = text;
+}
 /**
  * 受け皿の名前をそろえる仕事（登録簿の書き出し・読まれない受け皿の始末）の間隔。
  *   ★配達の判断には1バイトも関わらない。フォルダを見に行くので毎周はやらない。
@@ -342,6 +447,8 @@ export function createRelayState() {
         lastNudgeLogAt: null,
         codexTurnOpen: null,
         codexNoticeSeen: false,
+        codexTurnLoaded: false,
+        codexTurnDisk: null,
         codexTrayTidiedAt: null,
         central: { failures: 0, detail: '', downSince: null },
         readiness: createReadiness(),
@@ -1163,6 +1270,89 @@ export function takeCodexNotice(site, env = process.env) {
     const all = takeCodexNotices(site, env);
     return all.length === 0 ? null : all[all.length - 1];
 }
+/**
+ * 受け皿から【便の印がこの便と一致する知らせ】だけを取り出す（★ほかの行は受け皿に残す）。
+ *
+ * 【なぜ「全件を空にする」takeCodexNotices と別に要るか（便 b4747dd7）】
+ *   見張り（keepalive）へ移った便の報告本文を拾うために受け皿を見るが、そのとき受け皿には
+ *   【いま追跡中（pending）の別の便の知らせ】が混ざっていることがある。全件を空にすると、
+ *   追跡中の便の知らせを横から奪ってその便の報告を落としてしまう。だから一致した行だけを
+ *   取り、残りはそのまま受け皿に戻す（★本線の pickCodexNoticeFor の取り分を1行も減らさない）。
+ * ★一致の判定は【便の印（jobId）】だけ。印が無い行は取らない（別の便の知らせを取り違えない）。
+ * ★書きかけの行は取らない・消さない（takeCodexNotices と同じ守り）。
+ */
+export function takeCodexNoticesForJobId(site, commandId, env = process.env) {
+    const dir = codexNotifyDir(env);
+    if (!dir)
+        return [];
+    const file = path.join(dir, `${site}.jsonl`);
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch {
+        return []; // まだ1件も来ていない
+    }
+    if (hasPartialJsonlTail(raw)) {
+        let writing = false;
+        try {
+            writing = Date.now() - statSync(file).mtimeMs < CODEX_NOTICE_PARTIAL_WAIT_MS;
+        }
+        catch {
+            writing = false; // 時刻が読めなければ、今までどおり進む
+        }
+        if (writing)
+            return []; // 書き終わってから、次の回で拾う
+    }
+    const whole = completeJsonlLines(raw);
+    // 末尾の書きかけ（改行で終わっていない残り）は、そのまま受け皿に残す。
+    const partial = hasPartialJsonlTail(raw) ? raw.slice(raw.lastIndexOf('\n') + 1) : '';
+    const mine = [];
+    const keep = [];
+    for (const line of whole) {
+        const t = line.trim();
+        if (t === '')
+            continue;
+        let o = null;
+        try {
+            o = JSON.parse(t);
+        }
+        catch {
+            o = null;
+        }
+        const jobId = typeof o?.jobId === 'string' ? o.jobId.trim() : '';
+        if (o !== null &&
+            o.site === site &&
+            jobId !== '' &&
+            codexReportIdMatches(jobId, commandId)) {
+            mine.push({
+                site,
+                report: typeof o.report === 'string' ? o.report : '',
+                threadId: o.threadId ?? null,
+                turnId: o.turnId ?? null,
+                jobId,
+                at: parseNoticeAt(o.at),
+            });
+        }
+        else {
+            keep.push(line); // ★自分の物でない行は1字も変えずに受け皿へ戻す
+        }
+    }
+    if (mine.length === 0)
+        return []; // 何も取らなかった＝受け皿も書き換えない
+    const rest = keep.length === 0 && partial === '' ? '' : `${keep.map((l) => `${l}\n`).join('')}${partial}`;
+    try {
+        if (rest === '')
+            unlinkSync(file);
+        else
+            writeFileSync(file, rest, { encoding: 'utf8', mode: 0o600 });
+    }
+    catch {
+        // 書き戻せなくても、取った知らせはそのまま使う（完了を落とさない）。
+        // ★同じ行をもう一度読んでも、完了の書き込み自体は冪等（patchStatus / completeWithReport）。
+    }
+    return mine;
+}
 /** 控えに残す行数の上限（古い物から落とす＝受け皿の隣で際限なく育たせない）。 */
 export const CODEX_SKIPPED_NOTICE_MAX_LINES = 200;
 /**
@@ -1759,6 +1949,41 @@ export function hasStandaloneDone(text, site) {
     const lines = text.replace(/\r/g, '').split('\n');
     return lines.some((line) => isStandaloneDoneLine(line, marker));
 }
+/** テキスト中の「DONE:{site} 単独行」の数（★床（doneFloor）の基準に使う）。 */
+export function countStandaloneDone(text, site) {
+    const marker = `DONE:${site}`;
+    const lines = text.replace(/\r/g, '').split('\n');
+    let n = 0;
+    for (const line of lines)
+        if (isStandaloneDoneLine(line, marker))
+            n += 1;
+    return n;
+}
+/**
+ * 追跡中（pending）の便について、画面から完了の合図を読む（★I/Oなし＝単体テスト可能）。
+ *
+ * 【3つの道（上から順に効く）】
+ *   ① アンカーが画面に見える … 今までどおり「アンカーより下」だけを見る（Claude の道・1文字も変えない）。
+ *   ② アンカーが見えず、床が無い … 今までどおり（wide なら全画面／そうでなければ false）。
+ *   ③ アンカーが見えず、床が在る（★Codex・便 b4747dd7）… 全画面の `DONE:{site}` 単独行を数え、
+ *      【配った時点の数（床）より増えていたら】完了とみなす。増えていなければ、観測した数まで
+ *      床を下げる（古い DONE 行が履歴から流れたぶんだけ下がる＝そのあと出た合図を取りこぼさない）。
+ *
+ * ★床を上げないのが要。上げてしまうと、この便が出した DONE 行が床に混ざり、完了が永久に成立しない。
+ */
+export function scanDoneForPending(cap, site, anchor, opts) {
+    const below = sliceBelowAnchor(cap, anchor);
+    if (below !== null)
+        return { done: hasStandaloneDone(below, site), floor: opts.doneFloor };
+    if (!opts.wide)
+        return { done: false, floor: opts.doneFloor };
+    if (opts.doneFloor === null)
+        return { done: hasStandaloneDone(cap, site), floor: null };
+    const seen = countStandaloneDone(cap, site);
+    if (seen > opts.doneFloor)
+        return { done: true, floor: opts.doneFloor };
+    return { done: false, floor: Math.min(opts.doneFloor, seen) };
+}
 /**
  * アンカー基準の完了判定（根治の中核）。
  *   「アンカーより下の領域」に DONE:{site} 単独行があれば完了とみなす。
@@ -3491,6 +3716,8 @@ export async function fetchControl(cfg) {
         return {
             relayHalted: true,
             ok: false,
+            // ★例外で落ちた＝時間切れ・回線の失敗。断られた答え（HTTP 非2xx）はここへ来ない（上で返している）。
+            transient: true,
             detail: err instanceof Error ? err.message : String(err),
         };
     }
@@ -4328,6 +4555,8 @@ const DEFAULT_KEEPALIVE_DEPS = {
     capture: (site) => tmuxCapture(site),
     heartbeat: (cfg, id, busy) => sendHeartbeat(cfg, id, busy === true),
     complete: (cfg, id, report) => patchStatus(cfg, id, 'done', report),
+    completeFromFile: (cfg, id) => completeWithReport(cfg, id),
+    takeNotices: (site, id) => takeCodexNoticesForJobId(site, id),
     centralStatus: (cfg, id) => fetchCommandStatus(cfg, id),
     now: () => Date.now(),
     logLine: (msg) => log(msg),
@@ -4342,10 +4571,53 @@ export async function keepaliveTick(cfg, state, deps = {}) {
     const ka = state.keepalive;
     if (!ka)
         return;
-    const { capture, heartbeat, complete, centralStatus: getStatus, now: clock, logLine } = {
+    const { capture, heartbeat, complete, completeFromFile, takeNotices, centralStatus: getStatus, now: clock, logLine, } = {
         ...DEFAULT_KEEPALIVE_DEPS,
         ...deps,
     };
+    // ── 見張りに移った便の「終わりの知らせ」を取り込む（★Codex・便 b4747dd7） ──
+    // 15分を超えたターンの便は、追跡（pending）が切れたあとに知らせが届く。従来はその知らせを
+    // 「追っている便が無い」として控えへ回していたので、報告本文が1文字も管制に載らなかった
+    // （実測 2026-10-05: f7059eb5 は 15分13秒・dc60bf38 は 19分24秒で、どちらも本文なし）。
+    // ★取るのは【便の印がこの便と一致する行】だけ。ほかの行は受け皿に残す（追跡中の便の取り分を奪わない）。
+    if (kindOf(cfg) === 'codex') {
+        const mine = takeNotices(ka.site, ka.id);
+        // 2件以上あれば【新しい方】を使う（受け皿は古い順）。
+        const notice = mine.length === 0 ? null : mine[mine.length - 1];
+        if (notice !== null) {
+            state.codexNoticeSeen = true;
+            // ★この便のターンは終わった＝「前のターンが途中」の札も下ろす。
+            if (state.codexTurnOpen !== null && state.codexTurnOpen.jobId === ka.id) {
+                state.codexTurnOpen = null;
+                logLine(`site=${cfg.site} id=${ka.id} のターンが終わったと分かりました（次の便を配れます）`);
+            }
+            const intake = intakeCodexReport(notice.report, { commandId: ka.id, site: cfg.site });
+            logLine(`site=${cfg.site} id=${ka.id} ${intake.note}`);
+            const body = notice.report.trim().length > 0 ? notice.report : null;
+            const ok = intake.wrote
+                ? await completeFromFile(cfg, ka.id)
+                : await complete(cfg, ka.id, body);
+            if (!ok)
+                return; // 書けなければ畳まない（次の周でやり直す。知らせは使い切っている＝囲みは報告ファイルに残る）
+            logLine(`site=${cfg.site} id=${ka.id} 見張り終了: 追跡が切れたあとに届いた終わりの知らせで完了を報告` +
+                `（印が一致${intake.wrote ? '・囲みから報告ファイル' : body !== null ? '・報告添付' : ''}）`);
+            await deliverJobEndFacts(cfg, {
+                commandId: ka.id,
+                site: cfg.site,
+                finishedAt: new Date().toISOString(),
+                endKind: 'completed',
+                exitCode: null,
+                exitSignal: null,
+                reportDelivered: body != null || reportDelivery(ka.id).delivered,
+                processEndObserved: false,
+                detail: '配り役が完了の知らせで確かめた（追跡が切れたあとに届いた知らせ・職人の処理は中継が持っていない）' +
+                    (intake.wrote ? '／最後の返事の囲みから報告ファイルを組み立てた' : ''),
+            }, { logLine });
+            noteBusyEdge(state, cfg.site, ka.id, false, logLine);
+            state.keepalive = null;
+            return;
+        }
+    }
     // ★窓の持ち主が替わったら、画面からの完了検出はやめる（取り違えた完了を構造的に防ぐ）。
     //   別の指示が同じ窓で動くと、その出力も古いアンカーより下に並ぶため、そのまま読むと
     //   新しい指示の DONE 行と報告を、見張っている古い指示の完了として送ってしまう。
@@ -4544,6 +4816,9 @@ export async function relayTick(cfg, state, hooks) {
     // 次のtick間隔が自動的に通常（15秒）へ戻る。★判定ロジックはこの値を一切参照しない（観測専用）。
     state.promptPending = false;
     try {
+        // ── Codex のターンの札の控えを読み込む（★起動後1回・便 b4747dd7） ──
+        // 配り役を入れ直しても、長いターンの途中に次の便を割り込ませない（loadCodexTurnOnce の説明）。
+        loadCodexTurnOnce(cfg, state);
         // ── sent孤児の復元(2-b・起動後1回) ──
         // cli.ts を触らず「起動時1回」を実現するため、最初の tick でだけ復元する。
         // 失敗しても再試行しない（フラグを先に立てる＝起動を妨げない／多重実行防止）。
@@ -4698,8 +4973,22 @@ export async function relayTick(cfg, state, hooks) {
                     return;
                 }
             }
-            const below = sliceForDoneScan(cap, state.pending.anchor, state.pending.screenDoneWide);
-            if (below !== null && hasStandaloneDone(below, cfg.site)) {
+            // ★Codex はアンカーが画面に出ない（長い貼り付けを畳んで表示する）ので、床（doneFloor）を
+            //   使って「配った時点より DONE 行が増えたか」で見る（scanDoneForPending の説明・便 b4747dd7）。
+            //   Claude は従来どおり「アンカーより下」だけを見る＝動きは1バイトも変わらない。
+            if (state.pending.doneFloor != null && state.pending.doneFloorSettled !== true) {
+                // 配達のエコーを含んだ数も床に取り込む（PendingEntry.doneFloorSettled の説明）。
+                state.pending.doneFloor = Math.max(state.pending.doneFloor, countStandaloneDone(cap, cfg.site));
+                state.pending.doneFloorSettled = true;
+            }
+            const scan = scanDoneForPending(cap, cfg.site, state.pending.anchor, {
+                wide: state.pending.screenDoneWide,
+                doneFloor: state.pending.doneFloor ?? null,
+            });
+            if (state.pending.doneFloor != null && scan.floor !== state.pending.doneFloor) {
+                state.pending.doneFloor = scan.floor;
+            }
+            if (scan.done) {
                 // ★報告は画面から読まない。職人が書いたファイルを読む（relayReportDirs / readReport）。
                 //   画面を読む方式は窓が 16〜34 行しかなく、9/5 以降 162 回すべて失敗していた（調査 d1d16a56）。
                 // ★「届いた」は形まで見る（便 461be339）。整っていなければ理由も一緒に届ける。
@@ -4958,14 +5247,26 @@ export async function relayTick(cfg, state, hooks) {
         if (kindOf(cfg) === 'codex' && state.codexTurnOpen !== null && state.codexNoticeSeen) {
             const open = state.codexTurnOpen;
             const held = Date.now() - open.since;
-            if (held < RELAY_CODEX_TURN_HOLD_MAX_MS) {
+            // ★知らせ1本に頼らない出口（便 b4747dd7・調査 b9f6f53e の直す案②）。
+            //   画面が待機で、かつその便が管制で終端なら、ターンは終わっている＝札を下ろして配る。
+            //   ★画面が作業中に見えるあいだは下ろさない（長いターンの途中に割り込まない守りは残す）。
+            const holdCap = (hooks?.capture ?? tmuxCapture)(cfg.site);
+            const screenIdle = holdCap === null ? null : looksIdleFor(holdCap, kindOf(cfg));
+            const centralFinished = screenIdle === true ? isCentralFinished(await fetchCommandStatus(cfg, open.jobId)) : null;
+            const release = decideCodexTurnRelease({ heldMs: held, screenIdle, centralFinished });
+            if (release === 'hold') {
                 noteReadiness(state, 'busy', cmd.id);
                 log(`site=${cfg.site} id=${cmd.id} 前の便(id=${open.jobId})のターンがまだ終わっていないので配りません` +
-                    `（${Math.round(held / 1000)}秒待っています）`);
+                    `（${Math.round(held / 1000)}秒待っています・画面=` +
+                    `${screenIdle === null ? '読めない' : screenIdle ? '待機' : '作業中'}` +
+                    `${screenIdle === true ? '・管制=終端でない' : ''}）`);
                 return;
             }
-            log(`WARN site=${cfg.site} id=${cmd.id} 前の便(id=${open.jobId})のターンの終わりの知らせが` +
-                `${Math.round(RELAY_CODEX_TURN_HOLD_MAX_MS / 60000)}分来ないので、札を下ろして配ります`);
+            log(release === 'release-finished'
+                ? `site=${cfg.site} id=${cmd.id} 前の便(id=${open.jobId})は画面が待機で管制でも終端です` +
+                    '→札を下ろして配ります（終わりの知らせは来ていません）'
+                : `WARN site=${cfg.site} id=${cmd.id} 前の便(id=${open.jobId})のターンの終わりの知らせが` +
+                    `${Math.round(RELAY_CODEX_TURN_HOLD_MAX_MS / 60000)}分来ないので、札を下ろして配ります`);
             state.codexTurnOpen = null;
         }
         // ── アイドル判定（保守的・二重チェック） ──
@@ -5080,6 +5381,12 @@ export async function relayTick(cfg, state, hooks) {
         //   届く先が本物の職人の箱であることは、直前の tmuxHasSession / isIdleStable / looksLikeAgent が
         //   確認済み。だから「送れた＝配達できた」と扱ってよい。
         const sentAt = Date.now();
+        // ★Codex はアンカーが画面に出ない（長い貼り付けを畳んで表示する）＝アンカーより下を見る
+        //   完了検出が原理的に成立せず、毎回 15分の上限を待ち切っていた（調査 b9f6f53e・直す案①）。
+        //   配達したという事実は send-keys の成否で確定しているので、見張りと同じ理屈で全画面を
+        //   見てよい。取り違えを防ぐため【配った時点に見えていた DONE 行の数】を床として覚え、
+        //   床より増えたときだけ完了とみなす（PendingEntry.doneFloor の説明）。
+        const codexFloor = kindOf(cfg) === 'codex' ? countStandaloneDone(guardCap, cfg.site) : null;
         state.pending = {
             id: cmd.id,
             site: cfg.site,
@@ -5088,7 +5395,8 @@ export async function relayTick(cfg, state, hooks) {
             body: cmd.body,
             delivered: true,
             sentMarked: false,
-            screenDoneWide: false,
+            screenDoneWide: codexFloor !== null,
+            ...(codexFloor !== null ? { doneFloor: codexFloor, doneFloorSettled: false } : {}),
             ...(useAck ? { markAs: 'delivering' } : {}),
         };
         // 累計配達回数を通算（絶対上限 RELAY_DELIVER_MAX の基準）。
@@ -5158,6 +5466,8 @@ export async function relayTick(cfg, state, hooks) {
         await sendAckAtCentral(cfg, state);
     }
     finally {
+        // ★どの道で抜けても、札の中身を控えへ写す（中身が変わっていなければ書かない）。
+        saveCodexTurn(cfg, state);
         state.running = false;
     }
 }

package/dist/selfcheck.js

@@ -235,6 +235,12 @@ export function aiKanaMcpState(mcp) {
 export const MCP_SETTLE_TRIES = 3;
 export const MCP_SETTLE_WAIT_MS = 5_000;
 export const MCP_LIST_TIMEOUT_MS = 45_000;
+/**
+ * 「緊急停止の読み取り」が時間切れ・回線の失敗で通らなかったとき、読み直すまでの待ち（便 cbc27db6）。
+ *   ★読み直しは1回だけ（回線が戻るのを待つだけなので、何度も読まない）。
+ *   ★管制が断った答え（HTTP 401・403・500 など）は読み直さない＝この待ちも入らない。
+ */
+export const CONTROL_RETRY_WAIT_MS = 5_000;
 /**
  * `claude mcp list` の出力を読む（★実機 2026-10-03・Claude Code 2.1.287 の形）。
  *   `claude.ai ai-kana: https://… - ✔ Connected` ／ `ai-kana: https://… (HTTP) - ! Needs authentication` ／
@@ -459,11 +465,30 @@ async function checkCentral(d) {
         return item;
     }
     const site = d.env.CONDUCTOR_SITE || 'selfcheck';
-    const ctl = await withFetch(d, () => fetchControl({ url, token, machine: d.machine, site }));
+    const read = () => withFetch(d, () => fetchControl({ url, token, machine: d.machine, site }));
+    let ctl = await read();
+    /** 1回目が「その場かぎりの失敗」で通らなかったときの、その理由（読み直していなければ null）。 */
+    let firstDetail = null;
+    if (!ctl.ok && ctl.transient) {
+        // ★時間切れ・回線の失敗のときだけ、少し待って1回だけ読み直す（便 cbc27db6）。
+        //   実物 2026-10-05 00:19Z メインPC：スリープから起きた直後の毎日の自己診断で、回線が戻りきる前に
+        //   読んで時間切れ（The operation was aborted due to timeout）。ほかは全部通っているのに FAIL になり、
+        //   🟡 が次の日の自己診断まで残って、この機が後続の順番から外れた。
+        //   ★管制が断った答え（HTTP 401・403・500 など）と応答が不正は読み直さない（待っても変わらない）。
+        firstDetail = ctl.detail;
+        const sleep = d.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+        await sleep(CONTROL_RETRY_WAIT_MS);
+        ctl = await read();
+    }
+    const again = firstDetail === null
+        ? ''
+        : ctl.ok
+            ? `・1回目は通りませんでした（${firstDetail}）・2回目で通りました`
+            : `・1回目も通りませんでした（${firstDetail}）`;
     if (ctl.ok)
-        pass(item, `緊急停止の読み取りが通りました（停止中=${ctl.relayHalted ? 'はい' : 'いいえ'}）`);
+        pass(item, `緊急停止の読み取りが通りました（停止中=${ctl.relayHalted ? 'はい' : 'いいえ'}）${again}`);
     else
-        fail(item, 'fault', `緊急停止の読み取りが通りません（${ctl.detail}）`);
+        fail(item, 'fault', `緊急停止の読み取りが通りません（${ctl.detail}）${again}`);
     return item;
 }
 /** relay.ts の fetch を試験で差し替えるための包み（globalThis.fetch を一時的に置き換える）。 */

package/package.json

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