@tyhld/conductor 0.12.95 → 0.12.97

package/dist/relay.js

@@ -310,6 +310,12 @@ export function parseResumeSignals(raw) {
 }
 /** 連続スキップ何回でアイドル誤判定の疑いをWARNするか（観測のみ・送信挙動は変えない）。 */
 export const RELAY_SKIP_WARN_THRESHOLD = 6;
+/**
+ * Codex の前のターンが終わるのを待つ上限（これを過ぎたら札を下ろして配る）。
+ *   ★「終わりの知らせが来ない機体でも現場が永久にふさがらない」ための最後の砦。
+ *   中央が便を抱える上限（CENTRAL_BUSY_HOLD_MAX_MS＝3時間）と同じ値にそろえる。
+ */
+export const RELAY_CODEX_TURN_HOLD_MAX_MS = CENTRAL_BUSY_HOLD_MAX_MS;
 /** 初期状態を作る。 */
 export function createRelayState() {
     return {
@@ -329,6 +335,8 @@ export function createRelayState() {
         busyRaisedId: null,
         nudgedAt: null,
         lastNudgeLogAt: null,
+        codexTurnOpen: null,
+        codexNoticeSeen: false,
         central: { failures: 0, detail: '', downSince: null },
         readiness: createReadiness(),
     };
@@ -532,6 +540,31 @@ export function markDelivered(state, id) {
 // 純粋関数（外部I/Oなし＝単体テスト/ドライランしやすい）
 // ───────────────────────────────────────────────────────────────────────────
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// ── 行ごとの記録（jsonl）の読み方 ───────────────────────────────────────────
+//
+// 【なぜ要るか（実測 2026-10-04・0.12.95 の公開の流れ）】
+//   行ごとの記録は「書き手が1行を足している最中」に読めてしまう。1行が数千文字あると、
+//   書き込みが途中まで見える瞬間があり、その切れた行を JSON として読むと必ず失敗する
+//   （SyntaxError: Unterminated string in JSON）。
+// 【考え方（これ1つで通す）】★読むのは【最後の改行まで】。
+//   改行で終わっていない末尾の行は「まだ書きかけ」として扱い、次に読むときに拾う。
+//   ＝落ちない・取りこぼさない。見張りの流し読み（view-stream の readNew）と同じ考え。
+// 【どこに効かせるか】★読んだあとに【消す】所（Codex の受け皿）だけは、これが無いと
+//   書きかけの1行を捨てたうえにファイルを消すので、その完了が永久に失われる。
+//   一方、行ごとに try/catch で飛ばして次の回に読み直す所（受領確認・受付の確かめ）は
+//   それ自体で落ちないので変えない（最後の1行に改行が無い記録を読み落とさないため）。
+/**
+ * 書き終わった行（改行で終わっている行）だけを古い順に返す純粋関数。
+ * 末尾の書きかけ（改行で終わっていない残り）は返さない（＝次に読むときに拾う）。
+ */
+export function completeJsonlLines(text) {
+    const end = text.lastIndexOf('\n');
+    return end < 0 ? [] : text.slice(0, end).split('\n');
+}
+/** 末尾に書きかけの行（改行で終わっていない残り）が在るか。純粋関数。 */
+export function hasPartialJsonlTail(text) {
+    return text.length > 0 && !text.endsWith('\n');
+}
 /** 末尾の空行を除いた「末尾 RELAY_TAIL_LINES 行」を文字列で返す。静止比較の単位。 */
 export function tailOf(text) {
     const lines = text.replace(/\r/g, '').split('\n');
@@ -1022,34 +1055,63 @@ export function codexNotifyDir(env = process.env) {
     return home ? path.join(home, '.tyhld', 'codex-notify') : '';
 }
 /**
- * 受け皿から「まだ渡していない完了」を1件取り出し、ファイルを空にする（＝二重に使わない）。
- * 返り: 最新の1件 / null（無い・読めない）。
+ * 書きかけの行が末尾に在るとき、書き終わるのを待つ長さ。これを過ぎても改行が来なければ
+ * 書き手が落ちた残骸とみなし、今までどおり捨てて進む（＝受け皿が詰まらない）。
+ */
+const CODEX_NOTICE_PARTIAL_WAIT_MS = 5_000;
+/**
+ * 受け皿に溜まっている「終わりの知らせ」を【全件】取り出し、ファイルを空にする（＝二重に使わない）。
+ * 返り: 古い順の一覧（無い・読めない・まだ書きかけのときは空）。
  * ★読めない・壊れている行は捨てる。relay を止めない（フックと同じ作法）。
+ * ★ただし【書きかけの行】は捨てない。捨てて消すと、書き終わったその1行＝完了の知らせが
+ *   永久に失われる（受け口は1件を1行で書き、書き込みは途中まで見えることがある）。
+ *   書きかけが在る間は何も取らずに次の回へ回す（ファイルも消さない）。
+ *
+ * 【★なぜ「全件」にしたか（実測 2026-10-04・便 1c39ac8f / 1427b428）】
+ *   従来は最新の1件だけを返し、同じ回に溜まっていた他の行は黙って消えていた。
+ *   ところが受け皿には【どの便にも結び付かないターンの知らせ】が混ざる（Codex 内部の
+ *   会話をまとめ直すターン・人が手で打ったターン・便を閉じたあとに終わったターン）。
+ *   1件に潰してしまうと、それが「どの便の物か」を見分ける材料ごと失われる。
+ *   取り出した全件を judgeCodexNotice で1件ずつ見分ける形にして、使わなかった物は
+ *   理由つきで控えへ書き残す（recordSkippedCodexNotices）。
  */
-export function takeCodexNotice(site, env = process.env) {
+export function takeCodexNotices(site, env = process.env) {
     const dir = codexNotifyDir(env);
     if (!dir)
-        return null;
+        return [];
     const file = path.join(dir, `${site}.jsonl`);
     let raw;
     try {
         raw = readFileSync(file, 'utf8');
     }
     catch {
-        return null; // まだ1件も来ていない
+        return []; // まだ1件も来ていない
     }
-    const lines = raw.split('\n').map((l) => l.trim()).filter((l) => l.length > 0);
-    let latest = null;
+    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 lines = completeJsonlLines(raw).map((l) => l.trim()).filter((l) => l.length > 0);
+    const out = [];
     for (const line of lines) {
         try {
             const o = JSON.parse(line);
             if (typeof o.site === 'string' && o.site === site) {
-                latest = {
+                out.push({
                     site: o.site,
                     report: typeof o.report === 'string' ? o.report : '',
                     threadId: o.threadId ?? null,
                     turnId: o.turnId ?? null,
-                };
+                    jobId: typeof o.jobId === 'string' && o.jobId.trim() !== '' ? o.jobId.trim() : null,
+                    at: parseNoticeAt(o.at),
+                });
             }
         }
         catch {
@@ -1062,7 +1124,141 @@ export function takeCodexNotice(site, env = process.env) {
     catch {
         /* 消せなくても致命ではない（次回 latest が同じでも patchStatus 側が冪等） */
     }
-    return latest;
+    return out;
+}
+/** 受け口が書いた時刻（ISO の文字列・ミリ秒の数）を ms に読む。読めなければ null。 */
+function parseNoticeAt(raw) {
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return raw;
+    if (typeof raw === 'string' && raw.trim() !== '') {
+        const ms = Date.parse(raw.trim());
+        if (Number.isFinite(ms))
+            return ms;
+    }
+    return null;
+}
+/**
+ * 受け皿から「まだ渡していない完了」を1件取り出す（最新の1件・ファイルは空にする）。
+ * ★takeCodexNotices の薄い包み。どの便の物かの見分けはしない＝relay の本線では使わない
+ *   （本線は pickCodexNoticeFor。こちらは受け皿の読み方そのものを確かめるために残す）。
+ */
+export function takeCodexNotice(site, env = process.env) {
+    const all = takeCodexNotices(site, env);
+    return all.length === 0 ? null : all[all.length - 1];
+}
+/** 控えに残す行数の上限（古い物から落とす＝受け皿の隣で際限なく育たせない）。 */
+export const CODEX_SKIPPED_NOTICE_MAX_LINES = 200;
+/**
+ * 完了に使わなかった知らせを、理由つきで控えへ書き残す（★捨てない）。
+ * 置き場: 受け皿と同じフォルダの `<現場>.skipped.jsonl`。返り: 書けたファイル／null。
+ *
+ * 【なぜ要るか】「別の便の知らせだったので完了にしなかった」を、人があとから1か所で確かめられる
+ *   ようにする。relay の記録（ログ）には理由の1行だけを出し、報告の中身はこちらに残す。
+ */
+export function recordSkippedCodexNotices(site, entries, env = process.env) {
+    if (entries.length === 0)
+        return null;
+    const dir = codexNotifyDir(env);
+    if (!dir)
+        return null;
+    const file = path.join(dir, `${site}.skipped.jsonl`);
+    let kept = [];
+    try {
+        kept = completeJsonlLines(readFileSync(file, 'utf8')).filter((l) => l.trim() !== '');
+    }
+    catch {
+        kept = []; // まだ控えが無い
+    }
+    const added = entries.map((e) => JSON.stringify({
+        skippedAt: new Date().toISOString(),
+        why: e.why,
+        site: e.notice.site,
+        jobId: e.notice.jobId ?? null,
+        at: e.notice.at === null || e.notice.at === undefined ? null : new Date(e.notice.at).toISOString(),
+        threadId: e.notice.threadId ?? null,
+        turnId: e.notice.turnId ?? null,
+        report: e.notice.report,
+    }));
+    const lines = [...kept, ...added].slice(-CODEX_SKIPPED_NOTICE_MAX_LINES);
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(file, `${lines.join('\n')}\n`, 'utf8');
+        return file;
+    }
+    catch {
+        return null; // 控えが書けなくても完了の道は止めない（理由はログに1行出してある）
+    }
+}
+/** 印を短く見せる（記録に出す用）。 */
+function shortJobId(raw) {
+    const s = (raw ?? '').trim();
+    return s === '' ? '無し' : s.slice(0, 8);
+}
+/**
+ * 終わりの知らせが【その便の物か】を見分ける純粋関数。
+ *
+ * 【根拠（実測 2026-10-04・現場 codex-probe・配り役 0.12.92）】
+ *   便 1c39ac8f は、Codex 内部の「会話をまとめ直す」ターンの知らせ（本文が
+ *   `{"summary":…,"next_action":null}`）で、まだ作業中なのに done になった。
+ *   その便の【本当のターン】はそのあと終わり、知らせは受け皿に残ったまま誰も取らなかった。
+ *   次の便 1427b428 を配った19秒後、配り役はその残り物を読んで、
+ *   **前の便の停止報告を next の便の完了として取り込んだ**。
+ *   従来の判定は「現場が一致・最新の1件」だけで、便の印も時刻も見ていなかった。
+ *
+ * 【見分け方（上から順に効く）】
+ *   ① 便の印（受け口が指示本文の `CONDUCTOR_JOB:<id>` から写した jobId）が在れば、それで決める。
+ *   ② 報告の囲みに書かれた便IDが食い違えば、別の便の知らせ。
+ *   ③ 印が無ければ時刻で決める＝「その便を配ったあとに終わったターンか」。
+ *   ④ 印も時刻も無い古い形は、この便の物として扱う（配達の直前に受け皿を空にしてあるので、
+ *      残っている物はこの便を配ったあとに届いた物だけ＝取りこぼさない）。
+ */
+export function judgeCodexNotice(notice, job) {
+    if (job === null) {
+        return { accept: false, why: '追っている便が無いあいだに届いた知らせ' };
+    }
+    const jobId = (notice.jobId ?? '').trim();
+    if (jobId !== '' && !codexReportIdMatches(jobId, job.id)) {
+        return { accept: false, why: `別の便のターンの知らせ（便の印=${shortJobId(jobId)}）` };
+    }
+    const block = parseCodexReportBlock(notice.report);
+    if (block !== null && !codexReportIdMatches(block.instructionId, job.id)) {
+        return {
+            accept: false,
+            why: `報告の囲みの便IDが別の便（囲みの印=${shortJobId(block.instructionId)}）`,
+        };
+    }
+    if (jobId !== '')
+        return { accept: true, why: '便の印が一致した' };
+    const at = notice.at ?? null;
+    if (at !== null) {
+        return at >= job.sentAt
+            ? { accept: true, why: 'この便を配ったあとに終わったターンの知らせ' }
+            : { accept: false, why: 'この便を配る前に終わったターンの知らせ' };
+    }
+    return {
+        accept: true,
+        why: '便の印も時刻も無い古い形（配る直前に受け皿を空にしてあるので、この便のターンとして扱う）',
+    };
+}
+/**
+ * 受け皿を空にして、【その便の物だと確かめられた知らせ】だけを返す。
+ * 確かめられなかった知らせは完了に使わず、理由つきで控えへ書き残す（捨てない）。
+ * job に null を渡すと「全件を控えへ回す」＝受け皿を空にするだけになる（配る直前の空にし／始末）。
+ */
+export function pickCodexNoticeFor(site, job, env = process.env) {
+    const all = takeCodexNotices(site, env);
+    let notice = null;
+    const skipped = [];
+    for (const n of all) {
+        const v = judgeCodexNotice(n, job);
+        if (v.accept) {
+            notice = n; // 2件以上あれば新しい方を使う（古い順に見ている）
+        }
+        else {
+            skipped.push({ notice: n, why: v.why });
+        }
+    }
+    return { notice, skipped, skippedFile: recordSkippedCodexNotices(site, skipped, env) };
 }
 // ───────────────────────────────────────────────────────────────────────────
 // Codex の最後の返事に書いてもらう「機械で読める囲み」（便 cfa9eeec）
@@ -2606,6 +2802,8 @@ export function hasSubmittedRecord(cwd, commandId, sinceMs, env = process.env) {
             const text = readFileSync(file, 'utf8');
             if (!text.includes(needle))
                 continue;
+            // ★書きかけの行（改行が来ていない末尾）は JSON として読めないので下の catch で飛ばす＝
+            //   relay は落ちず、次の回に書き終わってから拾う（★最後の1行に改行が無い記録も読み落とさない）。
             for (const line of text.split('\n')) {
                 if (!line.includes(needle))
                     continue;
@@ -2693,6 +2891,8 @@ export function hasJobStampSince(cwd, commandId, sinceMs, env = process.env) {
             const text = readFileSync(file, 'utf8');
             if (!text.includes(needle))
                 continue;
+            // ★書きかけの行（改行が来ていない末尾）は JSON として読めないので下の catch で飛ばす＝
+            //   relay は落ちず、次の回に書き終わってから拾う（★最後の1行に改行が無い記録も読み落とさない）。
             for (const line of text.split('\n')) {
                 if (!hasExactJobStamp(line, commandId))
                     continue;
@@ -4042,8 +4242,25 @@ export async function relayTick(cfg, state, hooks) {
             // ★Codex は完了と報告が notify でデータとして届く（ADR-021）。画面より先にそちらを見る。
             //   届いていれば、そのまま【既存の完了経路】へ橋渡しする（道は1本のまま）。
             if (kindOf(cfg) === 'codex') {
-                const notice = takeCodexNotice(cfg.site);
+                // ★その便の物だと確かめられた知らせだけを受け取る（便 99fc49c0）。確かめられない知らせでは
+                //   どの便も完了にしない（捨てずに、理由つきで控えへ残す＝pickCodexNoticeFor）。
+                const pick = pickCodexNoticeFor(cfg.site, {
+                    id: state.pending.id,
+                    sentAt: state.pending.sentAt,
+                });
+                if (pick.notice !== null || pick.skipped.length > 0)
+                    state.codexNoticeSeen = true;
+                for (const s of pick.skipped) {
+                    log(`WARN site=${cfg.site} id=${state.pending.id} 終わりの知らせを完了に使いませんでした` +
+                        `（${s.why}・turn=${s.notice.turnId ?? '不明'}）` +
+                        `${pick.skippedFile === null ? '' : `→ 控え: ${pick.skippedFile}`}`);
+                }
+                const notice = pick.notice;
                 if (notice !== null) {
+                    // ★この便のターンは終わった＝「前のターンが途中」の札を下ろす。
+                    if (state.codexTurnOpen !== null && state.codexTurnOpen.jobId === state.pending.id) {
+                        state.codexTurnOpen = null;
+                    }
                     // ★最後の返事の囲みを読み、職人が書く物と同じ形の報告ファイルを組み立てる（便 cfa9eeec）。
                     //   書けたら【いまの完了の道】へそのまま流す（受け側の口は1つも変えない）。
                     //   囲みが無い・読めないときは、今までと同じ動き（返事をそのまま報告にして完了）に倒す。
@@ -4288,6 +4505,26 @@ export async function relayTick(cfg, state, hooks) {
         // ── 入れ替え待ちの札（便 b7bd5e43）──札が在るあいだは新しい便を取りに行かない。
         if (!noteDrain(state, cfg.site))
             return;
+        // ── Codex のターンの始末（★便 99fc49c0・根治の要） ──
+        // 追っている便が無いあいだに届いた終わりの知らせは、【どの便の完了にも使わない】。
+        // 便を閉じたあとに終わったターンの知らせがここで受け皿から取り除かれるので、次の便を
+        // 配ったときに受け皿に残っていて誤って取り込まれる、という筋道が構造的に消える。
+        // ★併せて「前のターンがまだ途中」の札を下ろす（終わったと分かったので次を配れる）。
+        if (kindOf(cfg) === 'codex') {
+            const left = pickCodexNoticeFor(cfg.site, null);
+            if (left.skipped.length > 0) {
+                state.codexNoticeSeen = true;
+                log(`site=${cfg.site} 追っている便が無いあいだに届いた終わりの知らせ ${left.skipped.length} 件は、` +
+                    `どの便の完了にも使わず理由つきで記録しました` +
+                    `${left.skippedFile === null ? '' : `（控え: ${left.skippedFile}）`}`);
+                const open = state.codexTurnOpen;
+                if (open !== null &&
+                    left.skipped.some((s) => codexReportIdMatches(s.notice.jobId ?? null, open.jobId))) {
+                    state.codexTurnOpen = null;
+                    log(`site=${cfg.site} id=${open.jobId} のターンが終わったと分かりました（次の便を配れます）`);
+                }
+            }
+        }
         // ── 新規指示の取得 ──
         const cmd = await fetchCommand(cfg);
         if (!cmd) {
@@ -4309,6 +4546,23 @@ export async function relayTick(cfg, state, hooks) {
                 '以後この指示は配達しない（無限ループの構造的封じ込め）');
             return;
         }
+        // ── Codex の前のターンが終わるまで配らない（★便 99fc49c0） ──
+        // 画面の読みとは別に、配り役が自分で配った便のターンが終わったことをデータで確かめる。
+        // ★受け口の知らせを一度も見ていない現場では止めない（受け口が入っていない機体で
+        //   現場が永久にふさがらないため）。上限を過ぎたときも札を下ろして進む。
+        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) {
+                noteReadiness(state, 'busy', cmd.id);
+                log(`site=${cfg.site} id=${cmd.id} 前の便(id=${open.jobId})のターンがまだ終わっていないので配りません` +
+                    `（${Math.round(held / 1000)}秒待っています）`);
+                return;
+            }
+            log(`WARN site=${cfg.site} id=${cmd.id} 前の便(id=${open.jobId})のターンの終わりの知らせが` +
+                `${Math.round(RELAY_CODEX_TURN_HOLD_MAX_MS / 60000)}分来ないので、札を下ろして配ります`);
+            state.codexTurnOpen = null;
+        }
         // ── アイドル判定（保守的・二重チェック） ──
         if (!tmuxHasSession(cfg.site)) {
             log(`site=${cfg.site} id=${cmd.id} tmux未起動のため送らずスキップ`);
@@ -4373,6 +4627,19 @@ export async function relayTick(cfg, state, hooks) {
             ? { parentCommandId: cmd.parentCommandId ?? null, decisions: cmd.decisions ?? [] }
             : undefined;
         const text = buildSendText(cmd.body, cfg.site, anchor, kindOf(cfg), context);
+        // ── 配る直前に受け皿を空にする（★便 99fc49c0・取り違えの根を断つ） ──
+        // ここに残っている知らせは、どれも【この便を配る前に終わったターン】の物。完了に使わず、
+        // 理由つきで控えへ回す。こうしておけば、以後この便の待ちで受け皿に現れる知らせは
+        // 「この便を配ったあとに届いた物」だけになる＝古い形（印も時刻も無い）でも取り違えない。
+        if (kindOf(cfg) === 'codex') {
+            const stale = pickCodexNoticeFor(cfg.site, null);
+            if (stale.skipped.length > 0) {
+                state.codexNoticeSeen = true;
+                log(`site=${cfg.site} id=${cmd.id} 配る前に受け皿に在った終わりの知らせ ${stale.skipped.length} 件は、` +
+                    `完了に使わず理由つきで記録して空にしました` +
+                    `${stale.skippedFile === null ? '' : `（控え: ${stale.skippedFile}）`}`);
+            }
+        }
         const sendStartedAt = Date.now();
         // ★Claude の職人へは受領確認を使う（便 7d810bbb）。Codex は会話の記録の形が違うので今までどおり。
         const useAck = kindOf(cfg) === 'claude';
@@ -4421,6 +4688,9 @@ export async function relayTick(cfg, state, hooks) {
         };
         // 累計配達回数を通算（絶対上限 RELAY_DELIVER_MAX の基準）。
         markDelivered(state, cmd.id);
+        // ★Codex へ配った＝この便のターンが始まった。終わりの知らせを確かめるまで次は配らない。
+        if (kindOf(cfg) === 'codex')
+            state.codexTurnOpen = { jobId: cmd.id, since: sentAt };
         // 新しい指示の生存ハートビートは先頭から数え直す（前指示のスロットルを引き継がない）。
         state.lastHeartbeatAt = null;
         noteReadiness(state, 'delivered', cmd.id);

package/package.json

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

package/scripts/codex/codex-notify.py

@@ -14,25 +14,49 @@
    "input-messages":["<送った指示>"],
    "last-assistant-message":"<職人の最後の発言>"}
 
-【★ふるい分け（実測に基づく）】1回の作業で通知が2件飛ぶ。
-  1件は Codex 内部の「会話に題名を付ける」ターンで、次の特徴を持つ:
+【★ふるい分け（実測に基づく）】1回の作業で通知が2件以上飛ぶ。
+  人の指示の完了ではない「Codex 内部のターン」が混ざり、次の特徴を持つ:
     ・input-messages[0] が英文の指示で始まる
       （実測値: "Generate a concise, single-line task title of at most 36 characters…"）
-    ・last-assistant-message が {"title":"…"} という JSON 文字列
-  この2つのどちらかに当たる通知は【捨てる】。人が出した指示の完了だけを残す。
+    ・last-assistant-message が JSON の物そのもの
+      （実測値: {"title":"…"} ／ {"summary":"…","next_action":null}）
+  これに当たる通知は【捨てる】。人が出した指示の完了だけを残す。
+
+  ★`{"summary":…}`（会話をまとめ直すターン）を落とすようにしたのは 2026-10-04 の実地の事故から。
+    便 1c39ac8f は、このターンの知らせを「便の完了」として取り込まれ、Codex がまだ作業中の
+    13:09:40 に done になった（本文は前の仕事の要約だった）。受け皿の実物にはこの形が5件
+    溜まっていた（~/.tyhld/codex-notify/video-lab.jsonl）。
+    判定は「本文まるごとが JSON の物（dict）なら内部のターン」に一般化した。職人の報告は
+    地の文なので当たらない。★ただし管制の報告の囲みを含む本文は、念のため必ず残す。
+
+【★便の印と時刻を書く（2026-10-04・便 99fc49c0）】
+  受け皿の1行に、次の2つを足す。
+    ・jobId … 届いた指示本文の末尾の管理用ジョブ印 `CONDUCTOR_JOB:<id>` から写した便のID。
+               人が手で打ったターンには印が無いので None。
+    ・at    … この行を書いた時刻（ISO8601・UTC）。
+  これが無かったせいで、配り役は「最新の1行＝いま追っている便の完了」としか読めず、
+  前の便のターンの知らせを次の便の完了として取り込んだ（便 1427b428 が19秒で done）。
 
 【やること】残す通知だけを、現場ごとの受け皿へ1行足す。
   置き場: $CONDUCTOR_CODEX_NOTIFY_DIR（既定 $HOME/.tyhld/codex-notify）/<現場>.jsonl
   ★中央へは送らない。送るのは relay の仕事（完了の経路は1本に保つ）。
   ★何があっても exit 0（Codex の動作を止めない）。
 """
+import datetime
 import json
 import os
+import re
 import sys
 
 # 内部の「題名を付ける」ターンの目印（実測値の先頭部分）。
 TITLE_TURN_PROMPT = 'Generate a concise, single-line task title'
 
+# 管制の報告の囲み（この字面を含む本文は、形が JSON に見えても内部のターンとして落とさない）。
+REPORT_MARK = 'CONDUCTOR_REPORT'
+
+# 指示本文の末尾に付く管理用ジョブ印。
+JOB_STAMP = re.compile(r'CONDUCTOR_JOB:\s*([0-9A-Za-z][0-9A-Za-z-]{7,})')
+
 
 def notify_dir(env=None):
     env = os.environ if env is None else env
@@ -49,7 +73,7 @@ def site_of(cwd):
 
 
 def is_internal_turn(payload):
-    """Codex 内部の「題名を付ける」ターンなら True（＝人の指示の完了ではない）。"""
+    """Codex 内部のターン（題名を付ける・会話をまとめ直す）なら True（＝人の指示の完了ではない）。"""
     msgs = payload.get('input-messages')
     if isinstance(msgs, list) and msgs and isinstance(msgs[0], str):
         if TITLE_TURN_PROMPT in msgs[0]:
@@ -57,11 +81,32 @@ def is_internal_turn(payload):
     last = payload.get('last-assistant-message')
     if isinstance(last, str):
         stripped = last.strip()
-        if stripped.startswith('{') and '"title"' in stripped:
-            return True
+        if REPORT_MARK in stripped:
+            return False  # 管制の報告の囲みが在る本文は、必ず残す
+        if stripped.startswith('{') and stripped.endswith('}'):
+            try:
+                parsed = json.loads(stripped)
+            except Exception:  # noqa: BLE001
+                parsed = None
+            if isinstance(parsed, dict):
+                return True  # 本文まるごとが JSON の物＝内部のターン（title / summary など）
     return False
 
 
+def job_id_of(payload):
+    """届いた指示本文の末尾の管理用ジョブ印から便のIDを読む。無ければ None。"""
+    msgs = payload.get('input-messages')
+    if not isinstance(msgs, list):
+        return None
+    found = None
+    for m in msgs:
+        if not isinstance(m, str):
+            continue
+        for hit in JOB_STAMP.finditer(m):
+            found = hit.group(1)  # 同じ本文に複数在れば最後の物（末尾の印）
+    return found
+
+
 def decide(payload):
     """受け取った通知をどう扱うか。返り: (残すか, 現場名, 報告本文, 理由)"""
     if not isinstance(payload, dict):
@@ -69,7 +114,7 @@ def decide(payload):
     if payload.get('type') != 'agent-turn-complete':
         return False, '', '', 'other-type'
     if is_internal_turn(payload):
-        return False, '', '', 'internal-title-turn'
+        return False, '', '', 'internal-turn'
     site = site_of(payload.get('cwd'))
     if not site:
         return False, '', '', 'no-site'
@@ -99,6 +144,9 @@ def main(argv):
                 'report': report,
                 'threadId': payload.get('thread-id'),
                 'turnId': payload.get('turn-id'),
+                # ★どの便のターンの知らせかを配り役が確かめられるようにする（便 99fc49c0）。
+                'jobId': job_id_of(payload),
+                'at': datetime.datetime.now(datetime.timezone.utc).isoformat(),
             },
             ensure_ascii=False,
         )