@tyhld/conductor 0.12.102 → 0.12.104

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} 単独行があれば完了とみなす。
@@ -4330,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),
@@ -4344,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 行と報告を、見張っている古い指示の完了として送ってしまう。
@@ -4546,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 でだけ復元する。
         // 失敗しても再試行しない（フラグを先に立てる＝起動を妨げない／多重実行防止）。
@@ -4700,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）。整っていなければ理由も一緒に届ける。
@@ -4960,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;
         }
         // ── アイドル判定（保守的・二重チェック） ──
@@ -5082,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,
@@ -5090,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 の基準）。
@@ -5160,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

@@ -21,7 +21,13 @@
  * 【★落ちたときは理由を残す（便 5a94ba06）】小さな headless 試験が落ちたら、その項目の detail に
  *   「結果の行の本文・stderr の末尾・終了コード」を残す（控えにも管制にも同じ中身が載る）。
  *   ④囲い・⑤通信の ✗ が「小さな試験が先に落ちたので確かめられなかった」ときは、そう読める文にする。
- *   ★合否と、落ちたら戻す動きは1つも変えない（FAIL は FAIL・やり直しを足さない）。
+ *
+ * 【★既知の一時障害1種類だけ、60秒後に1回だけやり直す（えふさん確定 2026-10-05）】
+ *   小さな headless 試験が落ちたら理由を分類し、Claude Code の「認証の更新が別の Claude Code の
+ *   処理と重なった」と【確かめられた】失敗のときだけ、60秒待って1回だけやり直す。2回目が通れば
+ *   その自己診断は合格（④囲い・⑤通信も2回目の結果で判定）。再失敗・別種類の失敗は、今までどおり
+ *   即 FAIL＝戻して配布を止める。★2回目のやり直しは無い。★「2回目が通った＝版は正常」とは
+ *   一般化しない（この1種類だけの例外）。やり直した事実は ⑥ の detail に残す（控えにも管制にも）。
  *
  * 【結果】手元の控え（~/.local/state/conductor/selfcheck/last.json と history/）に必ず残す。
  *   管制の口が在れば送る（★口が無い・届かないときも落ちない＝送れなかったことを控えに書くだけ）。
@@ -645,6 +651,53 @@ export function headlessFailureDetail(h) {
     out.push(`手がかり: 終了コード ${h.exitCode === null ? '不明' : h.exitCode}`);
     return out;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// 失敗の分類と、1回だけのやり直し（えふさん確定 2026-10-05）
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 「認証の更新の重なり」と判定できたときだけ待つ間（★60秒・えふさん確定 2026-10-05）。
+ *   ★やり直しは60秒後に【1回だけ】（2回目のやり直しは無い）。
+ */
+export const SELFCHECK_AUTH_RETRY_WAIT_MS = 60_000;
+/**
+ * 「認証の更新の重なり」の文（★実物で確かめた形）。
+ *
+ * 【実物 2026-10-05】FshimaNP 09:17:28Z（きっかけ after-rollback・0.12.102）と
+ *   TYHLD-OTA 11:43:43Z（きっかけ after-conductor・0.12.101）の「結果の行の本文」が、どちらも
+ *   `Failed to refresh OAuth token: another Claude Code process is refreshing it or exited mid-refresh.
+ *    This is usually transient; retry in a minute, and if it persists close other Claude Code processes
+ *    or sign in again` だった（終了コード 1・結果の行は subtype=success のまま is_error=true・使用量 0・
+ *   tool が1つも動かず「AI に届く前に終わった」）。
+ * ★2つとも当たることを求める。片方だけ・文が少し違う物は「別種類の失敗」として扱う（やり直さない）。
+ */
+const AUTH_REFRESH_CONFLICT_PATTERNS = [
+    /failed to refresh oauth token/i,
+    /another\b[^.]{0,60}\bprocess is refreshing it\b/i,
+];
+/**
+ * 小さな試験の失敗を分類する（★やり直してよいのは1種類だけ）。
+ *   「認証の更新の重なり」と判定するのは、次の【両方】を満たす失敗だけ。
+ *     (a) 結果の行の本文が、Claude Code の「認証の更新が別の処理と重なった」の文に当たる
+ *     (b) AI に届く前に終わっている（使用量 0・tool が1つも動いていない）
+ *   ★迷う物は 'other'（＝やり直さない）へ倒す。「2回目が通った＝版は正常」とは一般化しない。
+ */
+export function classifyHeadlessFailure(h) {
+    // 流していない（claude が無い・雛形を読めない）＝この種類ではない。
+    if (!h.ran)
+        return 'other';
+    // (a) 結果の行の本文
+    const text = h.summary?.result?.text ?? '';
+    if (!text.trim())
+        return 'other';
+    if (!AUTH_REFRESH_CONFLICT_PATTERNS.every((re) => re.test(text)))
+        return 'other';
+    // (b) AI に届く前に終わっている
+    if (reachedModel(h))
+        return 'other';
+    if ((h.summary?.toolResults.length ?? 0) > 0)
+        return 'other';
+    return 'auth-refresh-conflict';
+}
 /** 小さな試験と MCP の確かめで claude に渡す環境（★中継と同じ形・src/headless.ts）。 */
 function probeEnv(d, claudeBin) {
     const env = { ...d.env };
@@ -653,15 +706,23 @@ function probeEnv(d, claudeBin) {
     env.PATH = buildWorkerPath(env.PATH, claudeBin);
     return env;
 }
-/** ⑥ 小さな headless 試験を1回流す。 */
-function runHeadlessProbe(d, claudeBin, runDir) {
+/**
+ * 1回目／やり直しの作業場所の名前（★やり直しは別のフォルダで流す）。
+ *   同じフォルダで流すと、1回目に外へ書けてしまった跡（probe.txt）が残り、
+ *   やり直しの「囲いの外へ書けたか」を誤って open と読む。
+ */
+export function probeWorkName(attempt) {
+    return attempt === 1 ? 'work' : 'work-retry2';
+}
+/** ⑥ 小さな headless 試験を1回流す（attempt=2 はやり直しの回）。 */
+function runHeadlessProbe(d, claudeBin, runDir, attempt = 1) {
     const res = { summary: null, exitCode: null, outsideWrite: 'unknown', net: {}, probeRan: false, error: null, ran: false, stderr: '' };
     if (!claudeBin) {
         res.error = 'claude が無いので流していません';
         return res;
     }
-    const work = path.join(runDir, 'work');
-    const outside = path.join(runDir, 'outside');
+    const work = path.join(runDir, probeWorkName(attempt));
+    const outside = path.join(runDir, attempt === 1 ? 'outside' : 'outside-retry2');
     const outsideFile = path.join(outside, 'probe.txt');
     mkdirSync(path.join(work, '.claude'), { recursive: true });
     mkdirSync(outside, { recursive: true });
@@ -699,6 +760,38 @@ function runHeadlessProbe(d, claudeBin, runDir) {
         res.net[m[1]] = m[2];
     return res;
 }
+/**
+ * 小さな試験の1回の結果から ⑥ の項目を作る（★1回目もやり直しも【同じ読み方】で判定する）。
+ *   合否は職人の言葉でなく、終了コード・結果の行・tool の結果で決める（便 b7bd5e43 から変えない）。
+ */
+export function judgeHeadlessProbe(h) {
+    const item = { key: 'headless', label: '小さな headless 試験', ok: null, detail: [] };
+    const sum = h.summary;
+    if (h.error)
+        note(item, safeDetail(h.error));
+    if (!sum || !sum.result)
+        fail(item, 'fault', `結果の行がありません（終了 ${h.exitCode}）`);
+    else {
+        if (h.exitCode === 0)
+            pass(item, '終了コード 0');
+        else
+            fail(item, 'fault', `終了コード ${h.exitCode}`);
+        if (sum.result.subtype === 'success' && !sum.result.isError)
+            pass(item, '結果の行が success');
+        else
+            fail(item, 'fault', `結果の行が ${sum.result.subtype ?? '不明'}（is_error=${sum.result.isError}）`);
+        if (h.probeRan)
+            pass(item, '囲いの中で Bash の台本が動きました（tool の結果で確認）');
+        else
+            fail(item, 'fault', 'tool の結果に台本の目印がありません（Bash が動いていない）');
+    }
+    // ★落ちたときは「なぜ落ちたか」の手がかりを必ず残す（控えにも管制にも・便 5a94ba06）。
+    //   通ったときは1行も足さない（出力は今までと同じ）。
+    if (item.ok === false)
+        for (const line of headlessFailureDetail(h))
+            note(item, line);
+    return item;
+}
 /** ＋番人：入っている番人に、止めるべき物と通すべき物を1つずつ判定させる。 */
 function checkGuard(d, work) {
     const item = { key: 'guard', label: '番人', ok: null, detail: [] };
@@ -856,34 +949,30 @@ export async function runSelfcheck(d, trigger) {
         const network = net.item;
         const guard = checkGuard(d, path.join(runDir, 'work'));
         // ⑥ 小さな試験（③の MCP・④の書き込み・⑤の内側の通信もここで見る）
-        const headless = { key: 'headless', label: '小さな headless 試験', ok: null, detail: [] };
-        const h = runHeadlessProbe(d, claude.bin, runDir);
-        const sum = h.summary;
-        if (h.error)
-            note(headless, safeDetail(h.error));
-        if (!sum || !sum.result)
-            fail(headless, 'fault', `結果の行がありません（終了 ${h.exitCode}）`);
-        else {
-            if (h.exitCode === 0)
-                pass(headless, '終了コード 0');
-            else
-                fail(headless, 'fault', `終了コード ${h.exitCode}`);
-            if (sum.result.subtype === 'success' && !sum.result.isError)
-                pass(headless, '結果の行が success');
-            else
-                fail(headless, 'fault', `結果の行が ${sum.result.subtype ?? '不明'}（is_error=${sum.result.isError}）`);
-            if (h.probeRan)
-                pass(headless, '囲いの中で Bash の台本が動きました（tool の結果で確認）');
-            else
-                fail(headless, 'fault', 'tool の結果に台本の目印がありません（Bash が動いていない）');
+        //
+        // ★1回目が「認証の更新の重なり」と判定できたときだけ、60秒待って【1回だけ】やり直す
+        //   （えふさん確定 2026-10-05）。2回目が通ればその自己診断は合格＝④囲い・⑤通信も2回目の結果で
+        //   判定する。2回目が落ちたら（理由が何であっても）FAIL＝今までどおり戻す・配布を止める。
+        //   ★別種類の失敗は1回も待たずに即 FAIL。きっかけ（daily・after-conductor・after-claude・
+        //     after-rollback）を問わず同じ動きにする。
+        let h = runHeadlessProbe(d, claude.bin, runDir, 1);
+        let headless = judgeHeadlessProbe(h);
+        let probeAttempt = 1;
+        if (headless.ok === false && classifyHeadlessFailure(h) === 'auth-refresh-conflict') {
+            const sleep = d.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+            await sleep(SELFCHECK_AUTH_RETRY_WAIT_MS);
+            h = runHeadlessProbe(d, claude.bin, runDir, 2);
+            headless = judgeHeadlessProbe(h);
+            probeAttempt = 2;
+            // ★やり直した事実を残す（控え・管制の両方に・合格した回でも「再試行で通った」と読める）。
+            const sec = Math.round(SELFCHECK_AUTH_RETRY_WAIT_MS / 1000);
+            note(headless, headless.ok === false
+                ? `1回目は認証の更新の重なりで落ちました・${sec}秒後の2回目も落ちました`
+                : `1回目は認証の更新の重なりで落ちました・${sec}秒後の2回目で通りました`);
         }
-        // ★落ちたときは「なぜ落ちたか」の手がかりを必ず残す（控えにも管制にも・便 5a94ba06）。
-        //   通ったときは1行も足さない（出力は今までと同じ）。
-        if (headless.ok === false)
-            for (const line of headlessFailureDetail(h))
-                note(headless, line);
+        const sum = h.summary;
         // ③ MCP（★落ち着くまで確かめる・便が実際に使う登録を見る＝settleMcp）
-        const mcp = await settleMcp(d, claude.bin, path.join(runDir, 'work'), sum?.mcp ?? null);
+        const mcp = await settleMcp(d, claude.bin, path.join(runDir, probeWorkName(probeAttempt)), sum?.mcp ?? null);
         const seen = mcp.source === 'mcp-list' ? `claude mcp list で確かめた・${mcp.tries}回目` : mcp.source === 'init' ? '小さな試験の最初の行' : '一覧なし';
         const mineOf = (st) => (mcp.list ?? []).filter((s) => /ai-kana/i.test(s.name) && s.status === st).map((s) => s.name);
         if (mcp.state === 'connected') {
@@ -960,7 +1049,8 @@ export async function runSelfcheck(d, trigger) {
         rmSync(runDir, { recursive: true, force: true });
         // ★道具（Claude Code）が作業場所ごとに /tmp/claude-<uid>/ の下へ作る記録も消す（便 e9276b86）。
         //   作業場所は毎回名前が違うので、消さないと自己診断のたびに1つずつ溜まる（ノートPCで9つ）。
-        for (const dir of [runDir, path.join(runDir, 'work')]) {
+        //   ★やり直しの回の作業場所（work-retry2）も同じように消す。
+        for (const dir of [runDir, path.join(runDir, probeWorkName(1)), path.join(runDir, probeWorkName(2))]) {
             const trace = claudeTraceDir(dir, d.claudeTmpRoot);
             if (trace)
                 rmSync(trace, { recursive: true, force: true });

package/package.json

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