@tyhld/conductor 0.12.93 → 0.12.95

package/dist/headless.js

@@ -19,7 +19,7 @@ import { createInterface } from 'node:readline';
 import { createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { CENTRAL_BUSY_HOLD_MAX_MS, RELAY_DELIVER_MAX, RELAY_FETCH_TIMEOUT_MS, RELAY_HEARTBEAT_INTERVAL_MS, RELAY_RESTORE_ORPHANS_ENABLED, buildAnchor, buildSendText, canDeliver, completeWithReport, createRelayState, deliverJobEndFacts, deliveryReport, fetchCommand, fetchCommandStatus, fetchControl, fetchOrphans, flushPendingJobEndFacts, isTerminalCommandStatus, kindOf, markDelivered, noteCentralDown, noteCentralUp, noteDrain, noteReadiness, patchStatus, recoverStuckProcessedReports, reconnectDelayMs, FINISH_GATE_KINDS, reportDelivery, selectOrphanToRestore, sendHeartbeat, } from './relay.js';
+import { CENTRAL_BUSY_HOLD_MAX_MS, RELAY_DELIVER_MAX, RELAY_FETCH_TIMEOUT_MS, RELAY_HEARTBEAT_INTERVAL_MS, RELAY_RESTORE_ORPHANS_ENABLED, ackResumeSignal, buildAnchor, buildSendText, canDeliver, completeWithReport, createRelayState, deliverJobEndFacts, deliveryReport, fetchCommand, fetchCommandStatus, fetchControl, fetchOrphans, flushPendingJobEndFacts, isTerminalCommandStatus, kindOf, markDelivered, noteCentralDown, noteCentralUp, noteDrain, noteReadiness, patchStatus, recoverStuckProcessedReports, reconnectDelayMs, FINISH_GATE_KINDS, reportDelivery, selectOrphanToRestore, sendHeartbeat, } from './relay.js';
 import { claudePinPath, readClaudePinLine, } from './autoupdate-flags.js';
 const log = (msg) => {
     console.log(`[headless] ${msg}`);
@@ -78,6 +78,36 @@ export function extractProgressLine(text) {
 }
 /** resume 時に職人へ渡す続行指示。 */
 const RESUME_PROMPT = '前回の作業の続きを行ってください。中断された箇所から再開してください。';
+/**
+ * 続行の指示を組み立てる。添える物が無ければ、今までと1バイトも同じ文を返す。
+ *
+ * 【なぜ結果を載せるか】本番操作を待って閉じた便は、起きた瞬間に「何が終わったのか」を
+ *   知らないと、同じ待ちをもう一度始めてしまう。だから「前の値 → 後の値」をその場で渡す。
+ * ★秘密の値は載せない（載るのは管制が合図に入れた設定値だけ＝鍵や合言葉は合図に入れない）。
+ */
+export function buildResumePrompt(note) {
+    const n = (note ?? '').trim();
+    if (n.length === 0)
+        return RESUME_PROMPT;
+    return `${n}\n\n${RESUME_PROMPT}`;
+}
+/**
+ * 再開の合図から「続行の指示に載せる文」を作る。載せる物が無ければ null。
+ * 形は取り決め v1 のとおり（1行目＝何が終わったか／以後＝操作ごとに 前の値 → 後の値）。
+ */
+export function resumeNoteFromSignal(signal) {
+    if (signal.outcome !== 'succeeded')
+        return null;
+    const lines = ['本番操作が終わりました。続きを行ってください。'];
+    for (const r of signal.results ?? []) {
+        const what = r.summary ?? r.kind ?? '本番操作';
+        const kindNote = r.summary !== undefined && r.kind !== undefined ? `（${r.kind}）` : '';
+        const before = r.before ?? '不明';
+        const after = r.after ?? '不明';
+        lines.push(`・${what}${kindNote}: ${before} → ${after}`);
+    }
+    return lines.join('\n');
+}
 /** 実行ログの保存先ルート。 */
 export const RUNS_DIR = path.join(os.homedir(), '.local', 'state', 'conductor', 'runs');
 /** セッションありと見なす最低実行時間(ms)。これより短いとセッションファイルが無い可能性が高い。 */
@@ -161,6 +191,9 @@ export function saveLastJob(site, record) {
     catch (err) {
         log(`WARN last-job の保存に失敗: ${err instanceof Error ? err.message : String(err)}`);
     }
+    // ★「この便を前回どの試行まで走らせたか」も残す（再開の合図で続きから起こすときに使う）。
+    //   直前の1件だけでは、間に別の便が走ると上書きされて照合できなくなる。
+    rememberResumable(site, record.commandId, record.attempt, record.body);
 }
 /** 直前に終わった仕事を読む。無ければ null。 */
 export function loadLastJob(site) {
@@ -1031,7 +1064,12 @@ export function buildWorkerPath(currentPath, claudeBin, nodeExecPath = process.e
     const rest = (currentPath ?? '').split(':').filter((d) => d !== '' && !front.includes(d));
     return [...front, ...rest].join(':');
 }
-export function spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume) {
+export function spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume, 
+/**
+ * resume のときに続行の指示へ足す文（例「本番操作が終わりました。前の値 → 後の値」）。
+ * ★渡さなければ今までと1バイトも同じ続行の指示になる。
+ */
+resumeNote) {
     // 前の失敗の理由を持ち越さない（理由の無い失敗に古い理由が付かないように）
     lastSpawnError = '';
     const resolved = resolveClaudeBin();
@@ -1159,7 +1197,7 @@ export function spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume) {
             noteHandoffFailed(`職人の処理へ本文を渡せませんでした（標準入力: ${err.message}）`);
         });
         const text = isResume
-            ? RESUME_PROMPT
+            ? buildResumePrompt(resumeNote)
             : buildSendText(cmd.body, cfg.site, buildAnchor(cmd.id), kindOf(cfg));
         try {
             // ★書き出しが本当に流れ切ってから 'done' にする（返事を待たずに「渡せた」と言わない）。
@@ -1740,6 +1778,306 @@ export async function restoreHeadlessOrphans(cfg, state) {
         `孤児を復元して再開しました (session=${sessionId}, attempt ${attempt}/${HEADLESS_MAX_ATTEMPTS})`);
 }
 // ─────────────────────────────────────────────────────────────────────────────
+// 再開の合図（本番操作窓口・再開の取り決め v1）
+//
+// 管制が「本番操作が終わった」と知らせてきたときに、待っている【同じ便】を続きから起こす。
+// ★起こすのは同じ便の続きだけ。新しい便を機械が選ぶ道はここに作らない
+//   （「候補から自動投函はしない」の決まりは1行も変えない）。
+// ★合図が無いあいだは、ここは何もしない＝今までと1バイトも動きが変わらない。
+// ─────────────────────────────────────────────────────────────────────────────
+/** 使い終わった合図を覚えておく件数の上限（古い物から落とす）。 */
+export const RESUME_MEMO_MAX = 200;
+/**
+ * 中央の便の状態のうち、続きから起こしてよい物（★終端は含めない）。
+ *   perm_wait … 人の手番で止まっている（本番操作待ちの便はここで待つ）。この現場を占有し続ける。
+ *   sent      … 配達済みのまま（管制が戻した・まだ閉じていない）。
+ * ★done / failed / dismissed / queued では起こさない（終わった便・まだ配っていない便を起こさない）。
+ */
+export const RESUMABLE_CENTRAL_STATUSES = new Set(['perm_wait', 'sent']);
+/** 「この便は続きから起こせる」の控えを覚えておく件数の上限。 */
+export const RESUMABLE_MEMO_MAX = 20;
+/** 現場ごとの「使い終わった合図」の記録ファイル。 */
+export function resumeMemoPath(site) {
+    return path.join(ACTIVE_JOB_DIR, `resume-signals-${site}.json`);
+}
+/** 現場ごとの「続きから起こせる便」の控えファイル。 */
+export function resumableMemoPath(site) {
+    return path.join(ACTIVE_JOB_DIR, `resumable-${site}.json`);
+}
+function readJsonArray(file) {
+    try {
+        if (!existsSync(file))
+            return [];
+        const raw = readFileSync(file, 'utf8').trim();
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** 使い終わった合図のIDを読む（★同じ合図で2回起こさないための記録）。 */
+export function loadResumeMemo(site) {
+    return readJsonArray(resumeMemoPath(site))
+        .filter((v) => typeof v === 'string' && v.length > 0);
+}
+/**
+ * 合図を「使い終わった」として記録する。
+ * ★起こす【前】に書く。書けなければ起こさない（二重に起こさないことを、失敗しても守る）。
+ * 返り: 書けたか。
+ */
+export function markResumeSignalUsed(site, signalId) {
+    try {
+        const kept = loadResumeMemo(site).filter((id) => id !== signalId);
+        kept.push(signalId);
+        mkdirSync(ACTIVE_JOB_DIR, { recursive: true });
+        writeFileSync(resumeMemoPath(site), JSON.stringify(kept.slice(-RESUME_MEMO_MAX)) + '\n');
+        return true;
+    }
+    catch (err) {
+        log(`WARN 合図の記録に失敗: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+/** 控えに残す便の本文の上限（記録ファイルを太らせない）。 */
+export const RESUMABLE_BODY_MAX = 4_000;
+/**
+ * 便が終わるたびに「続きから起こせる」控えを残す。
+ *
+ * 【なぜ直前の1件では足りないか】`last-job-<現場>.json` は現場に1件しか無いので、
+ *   本番操作を待つ便を閉じたあと同じ現場で別の便が走ると上書きされ、
+ *   「前回どの試行まで走ったか」が分からなくなる＝照合できず起こせない。
+ *   数件ぶん覚えておけば、間に別の便が入っても同じ便を続きから起こせる。
+ */
+export function rememberResumable(site, commandId, attempt, body = '') {
+    if (!commandId)
+        return;
+    try {
+        const kept = readJsonArray(resumableMemoPath(site))
+            .filter((v) => v !== null && typeof v === 'object'
+            && typeof v.commandId === 'string'
+            && typeof v.attempt === 'number')
+            .filter((r) => r.commandId !== commandId);
+        kept.push({
+            commandId,
+            attempt,
+            finishedAt: Date.now(),
+            ...(body ? { body: body.slice(0, RESUMABLE_BODY_MAX) } : {}),
+        });
+        mkdirSync(ACTIVE_JOB_DIR, { recursive: true });
+        writeFileSync(resumableMemoPath(site), JSON.stringify(kept.slice(-RESUMABLE_MEMO_MAX)) + '\n');
+    }
+    catch (err) {
+        log(`WARN 続きから起こせる控えの保存に失敗: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+/** その便の「続きから起こせる」控えを返す。無ければ null（＝照合できない）。 */
+export function resumableFor(site, commandId) {
+    for (const r of readJsonArray(resumableMemoPath(site))) {
+        if (r === null || typeof r !== 'object')
+            continue;
+        const rec = r;
+        if (rec.commandId === commandId && typeof rec.attempt === 'number' && rec.attempt >= 1) {
+            return rec;
+        }
+    }
+    return null;
+}
+/**
+ * 合図を起こしてよいか確かめる（★通信をしない部分だけ・Fail Closed）。
+ *
+ * 確かめる物は4つ: 現場・所有者(PC)・作業場所・結末。
+ * 加えて「前回どの試行まで走ったか」が分からなければ起こさない（続きの場所が決まらない）。
+ * ★中央の便の状態の確かめは、呼び出し側（通信あり）で行う。
+ */
+export function checkResumeSignal(signal, cfg, deps) {
+    if (signal.site !== cfg.site) {
+        return { ok: false, reason: `現場が違う（合図=${signal.site} 自分=${cfg.site}）`, final: false, ack: false };
+    }
+    if (signal.machine !== cfg.machine) {
+        return { ok: false, reason: `所有者(PC)が違う（合図=${signal.machine} 自分=${cfg.machine}）`, final: false, ack: false };
+    }
+    if (signal.workDir !== cfg.workDir) {
+        return { ok: false, reason: `作業場所が違う（合図=${signal.workDir} 自分=${cfg.workDir}）`, final: false, ack: true };
+    }
+    if (signal.gitOrigin !== undefined) {
+        const current = deps.currentGitOrigin ?? null;
+        if (current === null) {
+            return { ok: false, reason: '今のリポの origin を取得できない（確認不能）', final: false, ack: true };
+        }
+        if (current !== signal.gitOrigin) {
+            return { ok: false, reason: `リポが違う（合図=${signal.gitOrigin} 自分=${current}）`, final: false, ack: true };
+        }
+    }
+    if (signal.outcome !== 'succeeded') {
+        const label = signal.outcome === 'rejected' ? '却下' : signal.outcome === 'expired' ? '時間切れ' : '失敗';
+        const why = signal.reason ? `：${signal.reason}` : '';
+        return {
+            ok: false,
+            reason: `本番操作は${label}でした${why}。便は起こしません（勝手に先へ進めません）。`,
+            final: true,
+            ack: true,
+        };
+    }
+    if (deps.prevAttempt === null) {
+        return {
+            ok: false,
+            reason: 'この便を前回どこまで走らせたかの控えがこのPCに無い（確認不能）',
+            final: false,
+            ack: true,
+        };
+    }
+    return { ok: true, prevAttempt: deps.prevAttempt };
+}
+/**
+ * まだ使っていない・自分（この現場とPC）宛の合図が指している便IDを返す。
+ * ★取り残しの後始末が、これから起こす便に done を書いてしまわないように渡す。
+ */
+export function resumeGuardCommandIds(signals, cfg, used) {
+    const usedSet = new Set(used);
+    const ids = new Set();
+    for (const s of signals ?? []) {
+        if (usedSet.has(s.id))
+            continue;
+        if (s.site !== cfg.site || s.machine !== cfg.machine)
+            continue;
+        ids.add(s.commandId);
+    }
+    return [...ids];
+}
+/**
+ * 再開の合図を1件だけ処理する。
+ * 返り: true = この周はここで終える（起こした／返事をした）／false = 合図は無かった。
+ *
+ * ★1周で扱うのは1件だけ（1現場同時1便を崩さない）。
+ */
+export async function handleResumeSignals(cfg, state, signals) {
+    if (signals === undefined || signals.length === 0)
+        return false; // ★合図なし＝今までと同じ
+    if (state.job !== null)
+        return false; // 走っている便がある＝触らない
+    const used = new Set(loadResumeMemo(cfg.site));
+    for (const signal of signals) {
+        if (used.has(signal.id))
+            continue; // ★同じ合図は1回だけ
+        const resumable = resumableFor(cfg.site, signal.commandId);
+        const check = checkResumeSignal(signal, cfg, {
+            prevAttempt: resumable?.attempt ?? null,
+            currentGitOrigin: signal.gitOrigin !== undefined ? resolveGitOrigin(cfg.workDir) : null,
+        });
+        if (!check.ok) {
+            if (!check.ack)
+                continue; // 自分宛でない＝黙って見送る（ほかのPCの合図）
+            log(`site=${cfg.site} id=${signal.commandId} 再開の合図: 起こしません（${check.reason}）`);
+            if (check.final) {
+                // ★却下・失敗・時間切れ: 理由を便へ返して畳む（再開しない・別の道を探さない）。
+                markResumeSignalUsed(cfg.site, signal.id);
+                await sendCommandEvents(cfg, signal.commandId, [{
+                        type: 'error',
+                        text: check.reason.slice(0, EVENT_TEXT_MAX),
+                        at: new Date().toISOString(),
+                        attempt: 0,
+                    }]);
+            }
+            await ackResumeSignal(cfg, signal, {
+                accepted: false,
+                final: check.final,
+                reason: check.reason,
+            });
+            return true;
+        }
+        // ★中央の便の状態を確かめる（Fail Closed）。
+        //   起こしてよいのは「まだ終わっていない・この現場を占有している」状態だけ
+        //   （perm_wait＝人の手番で止まっている／sent＝配達済みのまま）。
+        //   終端（done・failed・dismissed）や確かめられないときは起こさない。
+        const centralStatus = await fetchCommandStatus(cfg, signal.commandId);
+        if (centralStatus === null || !RESUMABLE_CENTRAL_STATUSES.has(centralStatus)) {
+            const reason = centralStatus === null
+                ? '中央の便の状態を確かめられない（次の周でやり直します）'
+                : `中央の便の状態が再開してよい状態ではない（${centralStatus}）`;
+            log(`site=${cfg.site} id=${signal.commandId} 再開の合図: 起こしません（${reason}）`);
+            await ackResumeSignal(cfg, signal, { accepted: false, final: false, reason });
+            return true;
+        }
+        // ★配達の決まりはそのまま（放棄済み・配達回数上限の便は起こさない）。
+        if (!canDeliver(state.relay, signal.commandId)) {
+            const reason = `配達の上限（${RELAY_DELIVER_MAX}）か放棄済みのため起こしません`;
+            log(`site=${cfg.site} id=${signal.commandId} 再開の合図: ${reason}`);
+            await ackResumeSignal(cfg, signal, { accepted: false, final: true, reason });
+            markResumeSignalUsed(cfg.site, signal.id);
+            return true;
+        }
+        // ★起こす前に「使った」を書く。書けないときは起こさない（二重に起こす方へ倒さない）。
+        if (!markResumeSignalUsed(cfg.site, signal.id)) {
+            const reason = '合図を使った記録を手元に書けないため起こしません（二重に起こさないため）';
+            log(`site=${cfg.site} id=${signal.commandId} 再開の合図: ${reason}`);
+            await ackResumeSignal(cfg, signal, { accepted: false, final: false, reason });
+            return true;
+        }
+        const attempt = check.prevAttempt + 1;
+        state.attempts.set(signal.commandId, attempt);
+        const sessionId = sessionIdForCommand(signal.commandId, check.prevAttempt);
+        const note = resumeNoteFromSignal(signal);
+        const body = resumable?.body ?? '';
+        const cmd = { id: signal.commandId, body };
+        const job = spawnClaudeProcess(cfg, cmd, sessionId, attempt, true, note);
+        if (job === null) {
+            const why = `${lastSpawnError || 'claude が見つかりません'}（再開を中止）`;
+            await patchStatus(cfg, signal.commandId, 'failed', why.slice(0, EVENT_TEXT_MAX));
+            await sendCommandEvents(cfg, signal.commandId, [{
+                    type: 'error',
+                    text: why.slice(0, EVENT_TEXT_MAX),
+                    at: new Date().toISOString(),
+                    attempt,
+                }]);
+            state.relay.abandoned.add(signal.commandId);
+            await ackResumeSignal(cfg, signal, { accepted: false, final: true, reason: why, attempt });
+            log(`ERROR site=${cfg.site} id=${signal.commandId} 再開の合図: ${why}`);
+            return true;
+        }
+        state.job = job;
+        saveActiveJob(cfg.site, {
+            commandId: signal.commandId,
+            body,
+            sessionId,
+            attempt,
+            startedAt: Date.now(),
+            site: cfg.site,
+            machine: cfg.machine,
+            workDir: cfg.workDir,
+            gitOrigin: resolveGitOrigin(cfg.workDir) ?? undefined,
+            pid: job.process.pid,
+        });
+        markDelivered(state.relay, signal.commandId);
+        state.relay.lastHeartbeatAt = null;
+        noteReadiness(state.relay, 'delivered', signal.commandId);
+        // ★人の手番で止まっていた便は、起こしたら配達済み(sent)へ戻す（管制が「作業中」と出せる形）。
+        //   既に sent の便には書かない（同じ状態を書き直さない）。
+        if (centralStatus !== 'sent') {
+            await patchStatus(cfg, signal.commandId, 'sent');
+        }
+        await sendCommandEvents(cfg, signal.commandId, [{
+                type: 'resumed',
+                text: `本番操作の完了を受けて続きから起こしました（attempt ${attempt}）`.slice(0, EVENT_TEXT_MAX),
+                at: new Date().toISOString(),
+                attempt,
+            }]);
+        // ★起こした事実と結果を管制へ返す（起こしたあとに返す＝「起こした」とだけ言える形）。
+        await ackResumeSignal(cfg, signal, {
+            accepted: true,
+            final: true,
+            reason: note ?? '続きから起こしました',
+            attempt,
+        });
+        log(`site=${cfg.site} id=${signal.commandId} ` +
+            `再開の合図で続きから起こしました (session=${sessionId}, attempt ${attempt})`);
+        return true;
+    }
+    return false;
+}
+// ─────────────────────────────────────────────────────────────────────────────
 // 取り残しの後始末（便 6ebba0d0 の項目4）
 // ─────────────────────────────────────────────────────────────────────────────
 /**
@@ -1834,7 +2172,16 @@ export async function headlessTick(cfg, state, hooks) {
         //   「実プロセスが無い・報告は渡し済み・管制ではまだ終わっていない」便に done を書く。
         //   ★自分の PC・自分の現場の便だけ（判定は recoverStuckProcessedReports 側）。
         //   ★停止トグルの確認より後に置く＝止められている現場では1バイトも書かない。
-        await recoverStuckCommands(cfg, { trackedIds: headlessTrackedCommandIds(state), state });
+        //   ★これから続きから起こす便（再開の合図が来ている便）には書かない＝起こす前に
+        //     done を書いてしまうと、照合（中央の状態が sent）で起こせなくなる。
+        //   ★合図が無いあいだは、手元の記録も読まない（今までと同じ動きのまま）。
+        const resumeGuard = (ctl.resumeRequests?.length ?? 0) > 0
+            ? resumeGuardCommandIds(ctl.resumeRequests, cfg, loadResumeMemo(cfg.site))
+            : [];
+        await recoverStuckCommands(cfg, {
+            trackedIds: [...headlessTrackedCommandIds(state), ...resumeGuard],
+            state,
+        });
         // ── 異常終了後の自動再開（pendingRetry）──
         if (state.pendingRetry !== null) {
             const retry = state.pendingRetry;
@@ -1873,6 +2220,13 @@ export async function headlessTick(cfg, state, hooks) {
                 `自動再開しました (session=${sessionId}, attempt ${retry.attempt}/${HEADLESS_MAX_ATTEMPTS})`);
             return;
         }
+        // ── 再開の合図（本番操作窓口・取り決め v1）──
+        //   管制が「本番操作が終わった」と知らせてきた便を、続きから起こす。
+        //   ★起こすのは同じ便の続きだけ（新しい便を機械が選ばない）。
+        //   ★合図が無いあいだは何もしない＝ここより下は今までと同じ順で動く。
+        //   ★自動再開（pendingRetry）の後・新しい便を取る前に置く＝走っている便を割り込まない。
+        if (await handleResumeSignals(cfg, state, ctl.resumeRequests))
+            return;
         // ── 入れ替え待ちの札（便 b7bd5e43・A2）──
         //   札が在るあいだは新しい便を【取りに行かない】。管制に積まれた便はそのまま待つ＝
         //   失われない・失敗にならない・試行回数も配達回数も使わない。札が外れたら次の周で今までどおり取る。

package/dist/relay.js

@@ -221,6 +221,93 @@ export function parseSentAt(raw) {
  */
 export const DISPATCH_DECISIONS_MAX = 10;
 export const DISPATCH_DECISION_CHARS = 300;
+/** 本番操作の結末（★この4つだけ受け取る。succeeded 以外では便を起こさない）。 */
+export const RESUME_SIGNAL_OUTCOMES = ['succeeded', 'rejected', 'failed', 'expired'];
+/** 合図に載せられる結果の件数の上限（本文を太らせない）。 */
+export const RESUME_SIGNAL_RESULTS_MAX = 10;
+/** 合図の文字欄1つの上限（理由・値など）。 */
+export const RESUME_SIGNAL_TEXT_MAX = 200;
+/** 1回の control で受け取る合図の件数の上限。 */
+export const RESUME_SIGNAL_MAX = 10;
+/** 文字欄を1つ読む。空・文字でない物は undefined。長すぎる物は切り詰める。 */
+function resumeText(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const t = raw.trim();
+    if (t.length === 0)
+        return undefined;
+    return [...t].length > RESUME_SIGNAL_TEXT_MAX
+        ? `${[...t].slice(0, RESUME_SIGNAL_TEXT_MAX - 1).join('')}…`
+        : t;
+}
+/**
+ * 管制の応答から合図の一覧を読む。★形が整っている物だけを受け取り、ほかは黙って捨てる。
+ *
+ * 【なぜ厳しく読むか】ここで受け取った合図は職人を起こす。形の怪しい物を「たぶん大丈夫」で
+ *   通すと、宛先の違う便を起こしうる。欠けている物は推測で埋めない（Fail Closed）。
+ */
+export function parseResumeSignals(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        const id = resumeText(e.id);
+        const commandId = resumeText(e.commandId);
+        const site = resumeText(e.site);
+        const machine = resumeText(e.machine);
+        const workDir = resumeText(e.workDir);
+        const outcomeRaw = typeof e.outcome === 'string' ? e.outcome.trim() : '';
+        if (!id || !commandId || !site || !machine || !workDir)
+            continue;
+        if (!RESUME_SIGNAL_OUTCOMES.includes(outcomeRaw))
+            continue;
+        const signal = {
+            id, commandId, site, machine, workDir,
+            outcome: outcomeRaw,
+        };
+        const reason = resumeText(e.reason);
+        if (reason !== undefined)
+            signal.reason = reason;
+        const gitOrigin = resumeText(e.gitOrigin);
+        if (gitOrigin !== undefined)
+            signal.gitOrigin = gitOrigin;
+        const issuedAt = resumeText(e.issuedAt);
+        if (issuedAt !== undefined)
+            signal.issuedAt = issuedAt;
+        if (Array.isArray(e.results)) {
+            const results = [];
+            for (const r of e.results.slice(0, RESUME_SIGNAL_RESULTS_MAX)) {
+                if (r === null || typeof r !== 'object')
+                    continue;
+                const rr = r;
+                const one = {};
+                const kind = resumeText(rr.kind);
+                if (kind !== undefined)
+                    one.kind = kind;
+                const summary = resumeText(rr.summary);
+                if (summary !== undefined)
+                    one.summary = summary;
+                const before = resumeText(rr.before);
+                if (before !== undefined)
+                    one.before = before;
+                const after = resumeText(rr.after);
+                if (after !== undefined)
+                    one.after = after;
+                if (Object.keys(one).length > 0)
+                    results.push(one);
+            }
+            if (results.length > 0)
+                signal.results = results;
+        }
+        out.push(signal);
+        if (out.length >= RESUME_SIGNAL_MAX)
+            break;
+    }
+    return out;
+}
 /** 連続スキップ何回でアイドル誤判定の疑いをWARNするか（観測のみ・送信挙動は変えない）。 */
 export const RELAY_SKIP_WARN_THRESHOLD = 6;
 /** 初期状態を作る。 */
@@ -977,6 +1064,215 @@ export function takeCodexNotice(site, env = process.env) {
     }
     return latest;
 }
+// ───────────────────────────────────────────────────────────────────────────
+// Codex の最後の返事に書いてもらう「機械で読める囲み」（便 cfa9eeec）
+//
+// 【なぜ要るか（実測 2026-10-04・codex-cli 0.160.0・便 f8ac8674 / 4c9f5049）】
+//   Codex の現場へ配る便の末尾が Claude 用のままで、Codex にはできない2つを求めていた:
+//     ① ai-kana の MCP（conductor_complete）… Codex にはつながっていない＝「利用可能なツールに無い」。
+//        毎便その断りが報告に入り、結果（outcome・PR 番号・次の独立作業候補）が管制に入らなかった。
+//     ② 作業フォルダの外（~/.local/state/conductor/reports/）への報告ファイル … 囲いが止める
+//        （Read-only file system）。毎回書こうとして失敗していた。
+//   どちらも「道具を増やす」のではなく、【いま既に通っている道】＝Codex の notify で届く
+//   「最後の返事」に機械で読める囲みを書いてもらい、配り役がそれを読んで報告ファイルを組み立てる。
+//
+// 【★受け側（管制）の口は1つも変えない】配り役が書く報告ファイルは、職人が書く物とまったく同じ形
+//   （6欄の囲み＋本文）。だから完了の道（completeWithReport）・回収の道（sendPendingReportFiles）・
+//   形の確かめ（reportDelivery）は1行も変わらない。
+//
+// 【★囲みが無い・読めないときは今までと同じ動きに倒す】最後の返事をそのまま報告として渡し、
+//   便を完了にする（実測で通っていた道を塞がない）。
+// ───────────────────────────────────────────────────────────────────────────
+/** 囲みの始まりの印（★Codex の便の配達文と同じ字面を使う）。 */
+export const CODEX_REPORT_BEGIN = '=== CONDUCTOR_REPORT ===';
+/**
+ * 囲みの終わりの印。
+ * ★`CONDUCTOR_REPORT_END` にしない理由: 画面に報告を出させていた昔の目印（`REPORT_END`）を
+ *   字面で含んでしまい、「古い指示が残っていないか」を見る検査と紛れるため（2026-09-07 に廃止した方式）。
+ */
+export const CODEX_REPORT_END = '=== END_CONDUCTOR_REPORT ===';
+/**
+ * 最後の返事から囲みの中身を切り出す（★印の行は含めない）。見つからなければ null。
+ *   - 囲みが閉じていなければ、返事の最後までを囲みの中身として読む（途中で切れた返事を救う）。
+ *   - 印の行に飾り（``` ・ ** ・ # ・ 引用の >）が付いていても読む（会話の返事は飾られやすい）。
+ * 返り: inner＝囲みの中の行／rest＝囲みを外した残り（＝報告の本文になる）。
+ */
+export function sliceCodexReportBlock(reply) {
+    const lines = String(reply ?? '').replace(/\r/g, '').split('\n');
+    const begin = lines.findIndex((l) => isCodexReportMark(l, 'CONDUCTOR_REPORT'));
+    if (begin < 0)
+        return null;
+    let end = -1;
+    for (let i = begin + 1; i < lines.length; i += 1) {
+        if (isCodexReportMark(lines[i], 'END_CONDUCTOR_REPORT')) {
+            end = i;
+            break;
+        }
+    }
+    const inner = lines.slice(begin + 1, end < 0 ? lines.length : end);
+    const rest = [...lines.slice(0, begin), ...(end < 0 ? [] : lines.slice(end + 1))]
+        .join('\n')
+        .trim();
+    return { inner, rest };
+}
+/** 印の行か（飾り・前後の `=` を落として、語そのものと突き合わせる）。 */
+function isCodexReportMark(line, word) {
+    const bare = String(line ?? '')
+        .trim()
+        .replace(/^[`*#>\s]+/, '')
+        .replace(/[`*\s]+$/, '')
+        .replace(/^=+/, '')
+        .replace(/=+$/, '')
+        .trim()
+        .toUpperCase();
+    return bare === word;
+}
+/**
+ * 囲みの中身を欄ごとに読む（★読み方は parseReport の囲みと同じ＝「key: 値」と「- 」の箇条書き）。
+ * 囲みが無ければ null。
+ */
+export function parseCodexReportBlock(reply) {
+    const block = sliceCodexReportBlock(reply);
+    if (block === null)
+        return null;
+    const fields = new Map();
+    const evidence = [];
+    let lastKey = '';
+    for (const line of block.inner) {
+        const bullet = /^\s*[-*]\s+(.*)$/.exec(line);
+        if (bullet !== null) {
+            if (lastKey === 'evidence' && bullet[1].trim() !== '')
+                evidence.push(bullet[1].trim());
+            continue;
+        }
+        const kv = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/.exec(line);
+        if (kv === null)
+            continue; // 読めない行は捨てる（欄の解釈を壊さない）
+        lastKey = kv[1].toLowerCase();
+        const value = kv[2].trim();
+        if (lastKey === 'evidence') {
+            if (value !== '')
+                evidence.push(value);
+            continue;
+        }
+        fields.set(lastKey, value);
+    }
+    return {
+        instructionId: nonEmpty(fields.get('instruction_id')),
+        site: nonEmpty(fields.get('site')),
+        outcome: pickOutcome(fields.get('outcome')),
+        createdAt: nonEmpty(fields.get('created_at')),
+        evidence,
+        prNumber: pickPrNumber(fields.get('pr_number')),
+        nextWork: nonEmpty(fields.get('next_work')),
+        rest: block.rest,
+    };
+}
+/**
+ * outcome の語を1つだけ取り出す（★2つ以上書かれていたら「読めない」に倒す）。
+ * 配達文の説明文（「pushed か no_change か blocked のどれか1つ」）をそのまま写した返事を
+ * pushed と読んでしまわないため。
+ */
+function pickOutcome(raw) {
+    const text = String(raw ?? '');
+    const hit = REPORT_OUTCOMES.filter((o) => new RegExp(`(^|[^a-z_])${o}([^a-z_]|$)`).test(text));
+    return hit.length === 1 ? hit[0] : null;
+}
+/** PR 番号（数字だけ）。「なし」「-」など数字が無ければ null。 */
+function pickPrNumber(raw) {
+    const m = /(\d{1,7})/.exec(String(raw ?? ''));
+    if (m === null)
+        return null;
+    const n = Number(m[1]);
+    return Number.isSafeInteger(n) && n > 0 ? n : null;
+}
+/** 囲みの instruction_id が、いま追っている便の物か（頭だけ書かれていても通す）。 */
+export function codexReportIdMatches(blockId, commandId) {
+    if (blockId === null)
+        return true; // 書かれていない＝配り役が知っている便IDで埋める
+    const got = blockId.trim();
+    if (got === commandId)
+        return true;
+    return got.length >= 8 && commandId.startsWith(got);
+}
+/**
+ * 囲みから【職人が書く物とまったく同じ形の報告】を組み立てる。読めなければ null。
+ *
+ * 【★読めたと認める条件】囲みが在る／instruction_id が食い違わない／site が食い違わない／
+ *   outcome が3つの語のどれか1つ／evidence が1件以上。
+ *   ★instruction_id・site は【配り役が知っている値】で書く（職人の写し間違いで別の便の報告にしない）。
+ * 【created_at が無いとき】配り役が受け取った時刻を入れ、入れたことを本文に1行で書く（作り話にしない）。
+ */
+export function buildCodexReportText(reply, opts) {
+    const block = parseCodexReportBlock(reply);
+    if (block === null)
+        return null;
+    if (!codexReportIdMatches(block.instructionId, opts.commandId))
+        return null;
+    if (block.site !== null && block.site !== opts.site)
+        return null;
+    if (block.outcome === null)
+        return null;
+    if (block.evidence.length === 0)
+        return null;
+    const filledAt = block.createdAt === null ? new Date(opts.now ?? Date.now()).toISOString() : null;
+    const head = [
+        '---',
+        `instruction_id: ${opts.commandId}`,
+        `site: ${opts.site}`,
+        `outcome: ${block.outcome}`,
+        `created_at: ${block.createdAt ?? filledAt}`,
+        'evidence:',
+        ...block.evidence.map((e) => `  - ${e}`),
+        '---',
+        '',
+    ];
+    const body = [
+        '（この報告は、職人の最後の返事の囲みから配り役が組み立てました）',
+        `結末（outcome）: ${block.outcome}`,
+        `PR番号: ${block.prNumber === null ? 'なし' : block.prNumber}`,
+        `次の独立作業候補: ${block.nextWork ?? '（囲みに書かれていません）'}`,
+        ...(filledAt === null ? [] : [`created_at は囲みに無かったので、配り役が受け取った時刻を入れました`]),
+        '',
+        block.rest,
+    ];
+    const text = `${head.join('\n')}${body.join('\n')}`.trim();
+    // ★形が整っていない物は書かない（書きかけを完了の材料にしない・便 461be339 と同じ判定を使う）。
+    return reportShapeMissing(text).length === 0 ? text : null;
+}
+/**
+ * Codex の最後の返事の囲みを読み、報告ファイル（職人が書く物と同じ形）を置く。
+ *   - 既に報告ファイルが在るときは【上書きしない】（職人が書けた現場を壊さない）。
+ *   - 囲みが無い・読めない・書けないときは wrote:false＝呼び出し側は今までの動きに倒す。
+ */
+export function intakeCodexReport(reply, opts) {
+    const env = opts.env;
+    if (reportPhase(opts.commandId, env) !== 'none') {
+        return { wrote: false, file: null, note: '報告ファイルが既にあるので囲みからは作りません' };
+    }
+    const text = buildCodexReportText(reply, { commandId: opts.commandId, site: opts.site, 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)
@@ -1156,8 +1452,9 @@ export function buildSendText(body, site, anchor, kind = 'claude', context) {
         ? anchor.slice(SEND_ANCHOR_PREFIX.length + 1)
         : anchor;
     // ★Claude の職人には「便の終え方」の1行だけを付ける（書き方の正本は鉄則の「便の終え方」の節）。
-    //   ★Codex の職人には今までどおり全文を付ける。鉄則（~/.claude/skills）は Codex には届かないため。
-    const guide = kind === 'codex' ? fullCompletionGuide(site, commandId) : shortCompletionLine(site, commandId);
+    //   ★Codex の職人には Codex にできることだけを頼む全文を付ける（便 cfa9eeec・codexCompletionGuide）。
+    //     鉄則（~/.claude/skills）は Codex には届かないので、全文で渡すのは今までどおり。
+    const guide = kind === 'codex' ? codexCompletionGuide(site, commandId) : shortCompletionLine(site, commandId);
     const full = `${body}\n\n${dispatchContextBlock(context)}${guide}` +
         // アンカー（管理用ジョブ印）は必ず本文の最後に置く。完了検出の境界として使う。
         `（管理用ジョブ印・変更不要: ${anchor}）`;
@@ -1203,9 +1500,14 @@ export function shortCompletionLine(site, commandId) {
         `完了の知らせ: conductor_complete を commandId="${commandId}" で1回だけ（nextWork は必ず書く）。`);
 }
 /**
- * 全文の完了案内（★Codex の職人向け・Claude 向けは shortCompletionLine）。
- * ★ここに書いてある決まりは、鉄則の「便の終え方」の節と中身を同じに保つ
- *   （試験 relay-finish-guide-equivalence が1つずつ突き合わせる）。
+ * 便の終え方の【全文＝正本の物差し】。
+ *
+ * ★この全文は、もう誰にも送らない（便 cfa9eeec）。本物は次の2つ:
+ *   ・Claude の職人 … 1行（shortCompletionLine）＋鉄則の「便の終え方」の節
+ *   ・Codex の職人 … Codex にできることだけを頼む全文（codexCompletionGuide）
+ * ★残してある理由: 「寄せる前の決まりを1つも失っていない」ことを測る物差しだから
+ *   （試験 relay-finish-guide-equivalence が、この全文と「1行＋鉄則の節」を1つずつ突き合わせる）。
+ *   ここに書いてある決まりは、鉄則の「便の終え方」の節と中身を同じに保つ。
  */
 export function fullCompletionGuide(site, commandId) {
     const marker = `DONE:${site}`;
@@ -1261,6 +1563,60 @@ export function fullCompletionGuide(site, commandId) {
         // ★nextWork（次の独立作業候補）は必ず書く（conductor_complete の説明と同じ・便 a5306df2 で両方にそろえた）。
         `nextWork（次の独立作業候補）は必ず書いてください（無ければ「なし」と理由）。\n\n`);
 }
+/**
+ * Codex の職人へ付ける完了案内（便 cfa9eeec・★Claude 向けは shortCompletionLine）。
+ *
+ * 【なぜ分けたか（実測 2026-10-04・codex-cli 0.160.0・便 f8ac8674 / 4c9f5049）】
+ *   Claude 用の全文は、Codex にできない2つを求めていた＝毎便、無駄な失敗になっていた:
+ *     ① ai-kana の MCP（完了の知らせの道具）… Codex にはつながっていない＝呼べない。
+ *     ② 作業フォルダの外への報告ファイル … 囲いが止める（Read-only file system）。
+ *   どちらも頼まない。かわりに【いま既に通っている道】＝Codex の notify で届く「最後の返事」に、
+ *   機械で読める囲みを書いてもらう。配り役がそれを読んで、職人が書く物と同じ形の報告ファイルを
+ *   組み立て、いまの完了の道へそのまま流す（intakeCodexReport・受け側の口は1つも変えない）。
+ *
+ * 【★.git への書き込み（実測の違い）】便 f8ac8674 は「止められたら回避せず報告」だけを書いていたので、
+ *   Codex は承認を求めずに blocked で終えた。便 4c9f5049 で「正規の手順で承認を1回だけ求めてよい」と
+ *   書いたら、承認されて記録（コミット 04c108f）まで通った。その1〜2文をここに入れておく。
+ *
+ * 【★この文に入れない物（試験で固定）】完了の知らせの道具の名前・報告ファイルの置き場。
+ *   どちらも Codex にはできない＝書くと毎便失敗して報告が汚れる。
+ */
+export function codexCompletionGuide(site, commandId) {
+    const marker = `DONE:${site}`;
+    return (
+    // ★確認カードを非エンジニアが読める日本語にする（調査 2987cb8f）。Codex でも確認は同じ形で出る。
+    `作業中にユーザー確認（許可を求めるプロンプト）が出る操作では、その一言説明（description）を` +
+        `英語ではなく日本語で、「プルリクエストを作成する」「テストを実行する」のように` +
+        `「何をするか」が一目で分かる簡潔な形（〜を作成する／実行する／削除する 等）で書いてください` +
+        `（この説明は管制の確認カードにそのまま表示され、非エンジニアのお客さまが読んで許可を判断します）。\n\n` +
+        // ★記録（.git への書き込み）が囲いに止められたときの進み方（実測 f8ac8674 → 4c9f5049）。
+        `記録（git add・git commit）が囲い（サンドボックス）に止められたときは、正規の手順で承認を1回だけ求めてよいです。` +
+        `断られた・求める手段が無かったときは、別のやり方（設定の書き換え・囲いを外す起動・.git を別の場所に作る 等）で` +
+        `通そうとせず、そのまま報告して終えてください。\n\n` +
+        // ★報告は「最後の返事」に書いてもらう（作業フォルダの外へは書けない＝囲いが止める）。
+        `作業がすべて完了したら、報告を【この会話の最後の返事】に書いてください` +
+        `（変更ファイル・要点・チェック結果を簡潔に）。` +
+        `★報告を作業フォルダの外のファイルへ書こうとしないでください（囲いが止めます）。\n` +
+        `★最後の返事の先頭に、次の囲みをそのまま付けてください（ここが機械の読み口です。1行に1項目・左の語と「: 」は変えない）。\n` +
+        `1行目: ${CODEX_REPORT_BEGIN}\n` +
+        `2行目: instruction_id: ${commandId}\n` +
+        `3行目: site: ${site}\n` +
+        `4行目: outcome: pushed / no_change / blocked のどれか1つだけを書く` +
+        `（pushed＝変更して送った、no_change＝変更不要だった、blocked＝衝突・要判断・許可待ち等で完了できなかった。★選んだ1語だけを書く）\n` +
+        `5行目: created_at: 書いた日時（例 2026-10-04T18:00:00+09:00）\n` +
+        `6行目: evidence:（この行は「evidence:」だけにして、次の行から「- 」で始めて1行に1つ書く。` +
+        `例「- PR https://github.com/...」「- CI test pass」「- main に入った」。★1件以上必ず書く）\n` +
+        `次の行: pr_number: PR 番号（数字だけ。無ければ なし）\n` +
+        `次の行: next_work: 次の独立作業候補（無ければ「なし」と、なぜ無いかの理由）\n` +
+        `最後の行: ${CODEX_REPORT_END}\n` +
+        `この囲みの下に、いつもどおりの報告本文を書いてください（本文が空だと未完成と見なされます）。\n` +
+        `そして返事のいちばん最後の行に ${marker} とだけ出力してください。\n\n` +
+        // ★道具は呼ばせない（Codex にはつながっていない）。囲みが書けなかったときの倒れ方も書いておく。
+        `★完了の知らせと、管制へ結果（outcome・PR 番号・次の独立作業候補）を入れる作業は、配り役が行います。` +
+        `あなたは上の囲みと ${marker} を書くだけでよく、道具（MCP）を呼ぶ必要はありません。` +
+        `囲みが書けなかったときも、いつもどおり最後の返事に報告を書いて ${marker} で終えてください` +
+        `（配り役がその返事をそのまま報告として受け取ります）。\n\n`);
+}
 // ───────────────────────────────────────────────────────────────────────────
 // tmux I/O（失敗は握りつぶして null/false。送らない側に倒すため）
 // ───────────────────────────────────────────────────────────────────────────
@@ -2574,7 +2930,12 @@ export async function fetchControl(cfg) {
         // per-site 子トグル。boolean ならその値、欠落/不正は undefined＝ON(稼働)フォールバック。
         const enabledRaw = data?.relayEnabled;
         const relayEnabled = typeof enabledRaw === 'boolean' ? enabledRaw : undefined;
-        return { relayHalted: halted, ok: true, detail: '', relayEnabled };
+        // ★再開の合図（取り決め v1）。欄が無い管制では空になる＝今までと同じ動きになる。
+        const signals = parseResumeSignals(data?.resumeRequests);
+        return {
+            relayHalted: halted, ok: true, detail: '', relayEnabled,
+            ...(signals.length > 0 ? { resumeRequests: signals } : {}),
+        };
     }
     catch (err) {
         return {
@@ -2584,6 +2945,48 @@ export async function fetchControl(cfg) {
         };
     }
 }
+/**
+ * 再開の合図に返事をする（取り決め v1）。
+ *   POST {url}/api/conductor/resume-signals/{合図ID}/ack
+ *   body: { commandId, site, machine, accepted, final, reason?, attempt? }
+ *
+ * 【accepted】起こしたか（true）／起こさなかったか（false）。
+ * 【final】★この合図はもう使わないか。
+ *   - true  … 畳んでよい（起こした／却下・失敗で起こさないと決めた）。
+ *   - false … まだ畳まない（照合できない・中央の状態を確かめられない＝次の周でやり直す）。
+ *
+ * 【届かなくても二重には起こさない】「同じ合図を1回だけ」は中継の手元の記録で守る。
+ *   だから返事が落ちても、同じ合図で2回起こすことは起きない。返事は「管制が畳むための知らせ」。
+ *   ★返事の口が無い管制（404）でも、起こす側の動きは変えない（false を返すだけ）。
+ */
+export async function ackResumeSignal(cfg, signal, opts) {
+    const url = `${cfg.url}/api/conductor/resume-signals/${encodeURIComponent(signal.id)}/ack`;
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { ...authHeaders(cfg), 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                commandId: signal.commandId,
+                site: signal.site,
+                machine: signal.machine,
+                accepted: opts.accepted,
+                final: opts.final,
+                ...(opts.reason !== undefined ? { reason: opts.reason.slice(0, 500) } : {}),
+                ...(opts.attempt !== undefined ? { attempt: opts.attempt } : {}),
+            }),
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            log(`site=${cfg.site} 再開の合図の返事 -> HTTP ${res.status} NG`);
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        log(`site=${cfg.site} 再開の合図の返事 -> 失敗: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
 /**
  * 自分宛(machine+site)の queued 指示を取得。先頭1件だけ返す（1現場同時1指示）。
  * 空/エラー/不正は null。
@@ -3641,9 +4044,21 @@ export async function relayTick(cfg, state, hooks) {
             if (kindOf(cfg) === 'codex') {
                 const notice = takeCodexNotice(cfg.site);
                 if (notice !== null) {
+                    // ★最後の返事の囲みを読み、職人が書く物と同じ形の報告ファイルを組み立てる（便 cfa9eeec）。
+                    //   書けたら【いまの完了の道】へそのまま流す（受け側の口は1つも変えない）。
+                    //   囲みが無い・読めないときは、今までと同じ動き（返事をそのまま報告にして完了）に倒す。
+                    const intake = intakeCodexReport(notice.report, {
+                        commandId: state.pending.id,
+                        site: cfg.site,
+                    });
+                    log(`site=${cfg.site} id=${state.pending.id} ${intake.note}`);
                     const report = notice.report.trim().length > 0 ? notice.report : null;
-                    if (await patchStatus(cfg, state.pending.id, 'done', report)) {
-                        log(`site=${cfg.site} id=${state.pending.id} done（Codexの通知${report != null ? '・報告添付' : ''}）`);
+                    const written = intake.wrote
+                        ? await completeWithReport(cfg, state.pending.id, log)
+                        : await patchStatus(cfg, state.pending.id, 'done', report);
+                    if (written) {
+                        log(`site=${cfg.site} id=${state.pending.id} done（Codexの通知` +
+                            `${intake.wrote ? '・囲みから報告ファイル' : report != null ? '・報告添付' : ''}）`);
                         // ★終了の事実を同じ項目で届ける（便 915694ac・1-3）。この配り方では実プロセスを
                         //   中継が持っていないので、終わりは【つかめていない】と伝える（終了コードは null）。
                         //   届けるのは「中継が完了を確かめた」という事実だけ。★作り話の終了を送らない。
@@ -3656,7 +4071,8 @@ export async function relayTick(cfg, state, hooks) {
                             exitSignal: null,
                             reportDelivered: report != null || reportDelivery(state.pending.id).delivered,
                             processEndObserved: false,
-                            detail: '配り役が完了の知らせで確かめた（職人の処理は中継が持っていない）',
+                            detail: '配り役が完了の知らせで確かめた（職人の処理は中継が持っていない）' +
+                                (intake.wrote ? '／最後の返事の囲みから報告ファイルを組み立てた' : ''),
                         }, { logLine: log });
                         state.pending = null;
                     }

package/package.json

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