@tyhld/conductor 0.11.1 → 0.11.2

package/README.md

@@ -160,6 +160,17 @@ conductor start -a "ログイン画面を実装中"
 | `CONDUCTOR_RELAY_ENABLED` | – | `true` で relay（指示の取得→アイドル時のみ tmux 送信→完了検出）を有効化 | `false` |
 | `CONDUCTOR_RELAY_INTERVAL_SEC` | – | relay のポーリング間隔（秒） | `15` |
 | `CONDUCTOR_NUDGE_DIR` | – | 耳 → relay の呼び鈴（空ファイル）の置き場 | `$XDG_RUNTIME_DIR/conductor` |
+| `RELAY_FETCH_TIMEOUT_MS` | – | 管制への問い合わせ1回の上限（ミリ秒）。返らない通信で relay が固まらないための上限 | `20000` |
+| `RELAY_RECONNECT_BASE_MS` | – | 管制へつながらないときの、最初の再試行までの待ち（ミリ秒）。以後 倍々に伸ばす | `5000` |
+| `RELAY_RECONNECT_MAX_MS` | – | 再試行の待ちの上限（ミリ秒）。★上限に達したあとも永久に試し続けます | `60000` |
+
+> **管制につながらないとき（★relay は止まりません）**：管制（中央）が落ちる・切れる・応答しない・
+> 401 や 5xx を返す——このいずれでも relay は**止まらず待って再試行**します。待ちは
+> 5秒 → 10 → 20 → 40 → 60秒 と伸び、60秒で頭打ち（以後は60秒おきに永久に）。つながらない間は
+> 画面に `管制につながらない・再試行中（N回目・次は◯秒後）` を**毎回1行**出し続け（黙りません）、
+> つながったら `管制に再接続しました` を1行出して**通常の間隔（15秒）へ自動で戻り**、
+> 自分の生存報告を1回送り直します。**安全のため、つながらない間は職人へ便を配りません**
+> （管制と話せないのに送るのは危険）。人が exit → 再起動する必要はありません。
 
 > **relay（ADR-029 段階3 / 既定 off）**：`CONDUCTOR_RELAY_ENABLED=true` のときだけ、
 > 中央から自分宛(machine+site)の指示を取得し、**送信先のtmuxセッション（名前 = 現場名 site）が

package/dist/cli.js

@@ -13,8 +13,9 @@ import { execFileSync, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import os from 'node:os';
-import { createRelayState, parseAgentKind, relayTick, tmuxHasSession } from './relay.js';
+import { RELAY_FETCH_TIMEOUT_MS, createRelayState, parseAgentKind, reconnectDelayMs, relayTick, tmuxHasSession, } from './relay.js';
 import { createRelayRunner } from './relay-runner.js';
+import { installProcessGuards } from './process-guard.js';
 import { registerNudgeTarget, unregisterNudgeTarget, watchNudges, } from './nudge.js';
 import { startEar } from './ear.js';
 import { loadEarConfig } from './ear-routing.js';
@@ -169,6 +170,9 @@ async function sendReport(cfg) {
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify(body),
+            // ★上限時間（relay の fetch と同じ理由）。管制が「つながるが何も返さない」状態のとき、
+            //   上限が無いと送信が返らず、30秒ごとの報告が返らないまま積み上がる。
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
         });
         const ok = res.ok ? 'OK' : 'NG';
         console.log(`[conductor] ${time} site=${cfg.site} status=${cfg.status} -> HTTP ${res.status} ${ok}`);
@@ -186,6 +190,9 @@ async function sendReport(cfg) {
 /** `conductor start`: 起動直後に1回 + 以後 intervalSec ごとに報告し続ける。 */
 async function start(args) {
     const cfg = loadConfig(args);
+    // ★例外1発で常駐が黙って死ぬ道を塞ぐ（2026-09-06 の根治・src/process-guard.ts）。
+    //   受けて1行出して続ける。★職人（CC2）が落ちた場合の肩代わりはしない（それは人へ見せる）。
+    installProcessGuards({ tag: 'relay' });
     console.log(`[conductor] 開始: machine=${cfg.machine} site=${cfg.site} status=${cfg.status} ` +
         `interval=${cfg.intervalSec}s url=${cfg.url}`);
     console.log('[conductor] 停止するには Ctrl+C を押してください。');
@@ -216,10 +223,20 @@ async function start(args) {
             `（tmuxセッション "${cfg.site}" がアイドルのときだけ送信します）`);
         const relayState = createRelayState();
         relayRunner = createRelayRunner({
-            tick: () => relayTick(cfg, relayState),
-            // 承認プロンプト待ちの間だけ短い間隔。それ以外は従来どおり
-            // （★間隔は耳を付けても変えない＝線が切れている間はこのポーリングがそのまま肩代わりする保険）。
-            nextDelayMs: () => (relayState.promptPending ? cfg.promptIntervalSec : cfg.relayIntervalSec) * 1000,
+            tick: () => relayTick(cfg, relayState, {
+                // ★管制へつながらない状態から戻った瞬間に1回だけ呼ばれる。
+                //   既にある口（現場の生存報告）を1回叩き、管制の一覧の札をすぐ正しく戻す。
+                onCentralReconnect: () => {
+                    console.log('[relay] 管制へ現場の生存報告を1回送り直します（再接続の直後）');
+                    void sendReport(cfg);
+                },
+            }),
+            // ★管制へつながらない間だけ、再試行の間隔（5秒→10→20→40→60秒・上限後は60秒のまま永久に）。
+            //   つながっていれば従来どおり: 承認プロンプト待ちの間だけ短い間隔、それ以外は通常間隔
+            //   （★間隔は耳を付けても変えない＝線が切れている間はこのポーリングがそのまま肩代わりする保険）。
+            nextDelayMs: () => relayState.central.failures > 0
+                ? reconnectDelayMs(relayState.central.failures)
+                : (relayState.promptPending ? cfg.promptIntervalSec : cfg.relayIntervalSec) * 1000,
             onError: (err) => {
                 // ループは絶対に止めない（1回の失敗で relay が死ぬと配達も承認も止まる）。
                 const msg = err instanceof Error ? err.message : String(err);
@@ -389,6 +406,11 @@ function printUsage() {
         '  CONDUCTOR_RELAY_INTERVAL_SEC  relayポーリング間隔・秒（既定: 15）',
         '  CONDUCTOR_RELAY_PROMPT_INTERVAL_SEC  承認待ちの間だけ使う短い間隔・秒（既定: 3）',
         '',
+        '管制につながらないとき（★relayは止まりません。待って再試行し、戻ったら自動で通常へ）:',
+        '  RELAY_FETCH_TIMEOUT_MS    管制への問い合わせ1回の上限・ミリ秒（既定: 20000）',
+        '  RELAY_RECONNECT_BASE_MS   再試行の最初の待ち・ミリ秒（既定: 5000。以後 倍々に伸ばす）',
+        '  RELAY_RECONNECT_MAX_MS    再試行の待ちの上限・ミリ秒（既定: 60000。★上限後も永久に試し続けます）',
+        '',
         '耳（ADR-066 / この機に1本だけ動かす常駐。systemd の conductor-ear.service 推奨）:',
         '  conductor ear は、指示が積まれた合図(Supabase Realtime)をPCにつき1本の接続で受け取り、',
         '  その現場の relay へ「今すぐ1周」だけを伝えます（合図に指示本文もトークンも載りません）。',

package/dist/process-guard.js

@@ -0,0 +1,63 @@
+/**
+ * @tyhld/conductor — 常駐（relay）が「例外1発で黙って死ぬ」道を塞ぐ番人。
+ *
+ * 【なぜ要るか（実地 2026-09-06）】
+ *   relay の中の1周（relayTick）が投げた例外は回し役(createRelayRunner)が受けて続行するが、
+ *   その【外】で起きた失敗は誰も受けない:
+ *     ① 未処理の Promise 拒否（unhandledRejection）
+ *          `void something()` の形で投げっぱなしにした非同期処理が転ぶと、Node 15 以降は
+ *          既定でプロセスごと終了する。relay には `void relayRunner.run()`、耳の合図受け、
+ *          停止処理など「投げっぱなし」の呼び出しが複数ある。
+ *     ② 捕まえていない例外（uncaughtException）
+ *          タイマーのコールバックやイベントハンドラの中で投げた例外は try/catch を素通りする。
+ *   どちらも起きるとプロセスが消える＝その現場の便が誰にも配られなくなる。
+ *
+ * 【どう塞ぐか】
+ *   受けて、1行出して、続ける。relay の仕事は「便を運ぶこと」で、1つの失敗で運行そのものを
+ *   止める理由にはならない。次の1周が来れば普通は何事もなかったように動く。
+ *
+ * 【★肩代わりしないもの（えふさん決定 2026-09-06）】
+ *   ここが守るのは【relay 自身のプロセス】だけ。職人（CC2 / claude）が本当に落ちた場合は、
+ *   relay が代わりに仕事を進めたり、落ちたことを隠したりしない。職人が居ない現場では
+ *   これまでどおり「tmux未起動のため送らずスキップ」と出して止まり、人に見えるようにする。
+ *
+ * 【多重登録しない】
+ *   同じプロセスで2回呼ばれても増えないようにする（登録が増えると1つの失敗で何行も出る）。
+ */
+/** ログの体裁は relay と揃える（[relay] 時刻 本文）。 */
+const stamp = () => new Date().toLocaleTimeString();
+/** このプロセスで既に登録したか（多重登録の防止）。 */
+let installed = false;
+/** テスト用: 登録済みの印を戻す。本番の経路からは呼ばない。 */
+export function resetProcessGuardsForTest() {
+    installed = false;
+}
+/**
+ * 「例外で黙って死ぬ」2つの道を塞ぐ。登録できた事象名を返す。
+ *
+ * ★ここで process.exit() は絶対に呼ばない。落とすために作った番人ではない。
+ */
+export function installProcessGuards(opts = {}) {
+    const logger = opts.logger ?? ((msg) => console.log(msg));
+    const target = opts.target ?? process;
+    const tag = opts.tag ?? 'relay';
+    if (installed)
+        return { installed: false, events: [] };
+    installed = true;
+    const describe = (err) => {
+        if (err instanceof Error) {
+            const stack = (err.stack ?? '').split('\n').slice(0, 3).join(' / ');
+            return stack.trim() || err.message;
+        }
+        return String(err);
+    };
+    target.on('unhandledRejection', (reason) => {
+        logger(`[${tag}] ${stamp()} WARN 未処理の失敗を受け止めました（${describe(reason)}）` +
+            '／★止まらずこのまま続けます');
+    });
+    target.on('uncaughtException', (err) => {
+        logger(`[${tag}] ${stamp()} WARN 捕まえていない例外を受け止めました（${describe(err)}）` +
+            '／★止まらずこのまま続けます');
+    });
+    return { installed: true, events: ['unhandledRejection', 'uncaughtException'] };
+}

package/dist/relay-runner.js

@@ -13,8 +13,16 @@
  *   - 同時に走る tick は1つだけ（走行中の run() は「終わったらもう1周」の予約として畳む）。
  *   - 予約中のタイマーは常に1本だけ（走り出す前に必ず消す）。
  *   - tick が投げた例外でループを止めない（1回の失敗で配達も承認も止まってはいけない）。
+ *   - ★stop() を呼ばれない限り、次の1周の予約は【必ず】積まれる（nextDelayMs が投げても保険の
+ *     間隔で積み直す）。予約が1回でも消えると relay は誰にも気づかれずに永久に止まる。
  *   - stop() 後は新しい tick を始めない・新しい予約も積まない。
  */
+/**
+ * nextDelayMs() が答えを返せなかったときに使う保険の間隔(ms)。
+ *   ★「次を積まない」という選択肢は持たない。予約が消えた瞬間に relay は黙って止まるので、
+ *   どんな異常でも必ず何秒か後にもう一度回す。値は通常のポーリング間隔（15秒）に合わせる。
+ */
+export const RELAY_RUNNER_FALLBACK_DELAY_MS = 15 * 1000;
 export function createRelayRunner(args) {
     const { tick, nextDelayMs, onError } = args;
     let timer = null;
@@ -27,6 +35,26 @@ export function createRelayRunner(args) {
             timer = null;
         }
     };
+    /**
+     * 次の1周を必ず予約する。★ここで例外を出して予約を失うと、relay は【黙って永久に止まる】。
+     *   nextDelayMs() は呼び出し側の関数なので、いつか投げるかもしれない前提で扱う。
+     *   投げたら理由を報せたうえで保険の間隔(RELAY_RUNNER_FALLBACK_DELAY_MS)で必ず積み直す。
+     */
+    const scheduleNext = () => {
+        if (stopped)
+            return;
+        clearTimer();
+        let delay = RELAY_RUNNER_FALLBACK_DELAY_MS;
+        try {
+            const wanted = nextDelayMs();
+            if (Number.isFinite(wanted) && wanted >= 0)
+                delay = wanted;
+        }
+        catch (err) {
+            onError?.(err);
+        }
+        timer = setTimeout(() => void run(), delay);
+    };
     const run = async () => {
         if (stopped)
             return;
@@ -48,12 +76,11 @@ export function createRelayRunner(args) {
             } while (nudged && !stopped);
         }
         finally {
+            // ★予約は finally の中で積む。busy を戻したあと予約する前に何かが起きても
+            //   「走ってもいない・予約も無い」で静止する道を残さないため。
             busy = false;
+            scheduleNext();
         }
-        if (stopped)
-            return;
-        clearTimer();
-        timer = setTimeout(() => void run(), nextDelayMs());
     };
     return {
         run,

package/dist/relay.js

@@ -147,6 +147,36 @@ export const RELAY_STATUS_FETCH_TIMEOUT_MS = envPositiveNumber('RELAY_STATUS_FET
  *   環境変数 RELAY_HEARTBEAT_INTERVAL_MS で上書き可（正の数のみ）。
  */
 export const RELAY_HEARTBEAT_INTERVAL_MS = envPositiveNumber('RELAY_HEARTBEAT_INTERVAL_MS', 150 * 1000);
+/**
+ * 管制(devlog-tracker)への問い合わせ1回あたりの上限時間(ms)。既定20秒。
+ *
+ * 【なぜ要るか＝★「黙って止まる」の根っこ（実地 2026-09-06・1日2回）】
+ *   以前 fetchControl / fetchCommand / patchStatus / sendHeartbeat の fetch には
+ *   【時間の上限が1つも無かった】。管制が落ちて「つながるけれど何も返さない」状態になると、
+ *   その fetch は返ってこない。すると:
+ *     ① relayTick が終わらない（state.running が true のまま）
+ *     ② 回し役(createRelayRunner)の busy が true のまま＝【次の予約が二度と積まれない】
+ *   ＝プロセスは生きているのに relay の輪が永久に止まる。systemd から見れば「動いている」ので
+ *   自動再起動もかからず、ログにも何も出ない。人が exit → 全現場再起動しないと戻らない。
+ *   これが「管制が落ちる→relayが止まる→便が『待っています』のまま溜まる」の正体。
+ *
+ * 【根治】全ての管制向け fetch に上限時間を付ける。返ってこない通信は必ず例外になり、
+ *   既存の catch が受けて「失敗」として扱われる＝輪は必ず次へ進む。
+ *   環境変数 RELAY_FETCH_TIMEOUT_MS で上書き可（正の数のみ）。
+ */
+export const RELAY_FETCH_TIMEOUT_MS = envPositiveNumber('RELAY_FETCH_TIMEOUT_MS', 20 * 1000);
+/**
+ * 管制へつながらないときの、再試行の【最初の】待ち時間(ms)。既定5秒。
+ *   短く始めて、失敗のたびに倍にし、RELAY_RECONNECT_MAX_MS で頭打ちにする（reconnectDelayMs）。
+ *   環境変数 RELAY_RECONNECT_BASE_MS で上書き可（正の数のみ）。
+ */
+export const RELAY_RECONNECT_BASE_MS = envPositiveNumber('RELAY_RECONNECT_BASE_MS', 5 * 1000);
+/**
+ * 再試行の待ち時間の上限(ms)。既定60秒。★上限に達したあとも【永久に】60秒ごとに試し続ける。
+ *   諦めて止まる道は作らない（止まると人が全現場を再起動する羽目になる＝今回の事故そのもの）。
+ *   環境変数 RELAY_RECONNECT_MAX_MS で上書き可（正の数のみ）。
+ */
+export const RELAY_RECONNECT_MAX_MS = envPositiveNumber('RELAY_RECONNECT_MAX_MS', 60 * 1000);
 /**
  * 「実際に処理中のときだけ出る、確実なシグナル」だけを持つ（小文字化して部分一致で判定）。
  * 一つでも末尾付近にあれば送らない。
@@ -199,8 +229,55 @@ export function createRelayState() {
         abandoned: new Set(),
         promptPending: false,
         busyRaisedId: null,
+        central: { failures: 0, detail: '', downSince: null },
     };
 }
+/**
+ * 管制へつながらないときの、次の再試行までの待ち時間(ms)。純粋関数（I/Oなし＝単体テスト可能）。
+ *
+ *   failures=1 → 5秒 / 2 → 10秒 / 3 → 20秒 / 4 → 40秒 / 5以降 → 60秒（上限）
+ *
+ * ★上限に達しても null は返さない＝「もう試さない」という答えを持たない。
+ *   管制はいつか必ず戻る。戻るまで60秒おきに叩き続けるのが正しい（諦めたら人が全現場を再起動する）。
+ * ★failures=0（つながっている）を渡すのは呼び出し側の誤りなので、最初の待ち時間を返す（安全側）。
+ */
+export function reconnectDelayMs(failures) {
+    const n = Math.max(1, Math.floor(failures));
+    // 2^(n-1) 倍。指数が大きいと Infinity になり得るので、先に上限で切ってから返す。
+    const raw = RELAY_RECONNECT_BASE_MS * 2 ** (n - 1);
+    return Number.isFinite(raw) ? Math.min(raw, RELAY_RECONNECT_MAX_MS) : RELAY_RECONNECT_MAX_MS;
+}
+/**
+ * 管制へ届かなかったことを1回記録し、画面に出す1行を作る（★黙らないための口）。
+ *   返す文字列をそのままログに出す想定。★呼ぶたびに出す＝つながらない間ずっと出続ける。
+ */
+export function noteCentralDown(state, detail, nowMs) {
+    const link = state.central;
+    if (link.failures === 0)
+        link.downSince = nowMs;
+    link.failures += 1;
+    link.detail = detail;
+    const waitSec = Math.round(reconnectDelayMs(link.failures) / 1000);
+    const downSec = link.downSince === null ? 0 : Math.max(0, Math.round((nowMs - link.downSince) / 1000));
+    return (`WARN 管制につながらない・再試行中（${link.failures}回目・次は${waitSec}秒後）` +
+        `${downSec > 0 ? `／切れてから${downSec}秒` : ''}（理由: ${detail}）` +
+        '★relayは止まっていません。つながり次第そのまま再開します');
+}
+/**
+ * 管制へ届いたことを記録する。切れていたなら「戻った」1行を返し、そうでなければ null。
+ *   ★戻った瞬間に1行出す＝人が「復旧した」と分かる。通常時は何も出さない（ログを埋めない）。
+ */
+export function noteCentralUp(state, nowMs) {
+    const link = state.central;
+    if (link.failures === 0)
+        return null; // ずっとつながっている＝何も言うことはない。
+    const downSec = link.downSince === null ? 0 : Math.max(0, Math.round((nowMs - link.downSince) / 1000));
+    const tries = link.failures;
+    link.failures = 0;
+    link.detail = '';
+    link.downSince = null;
+    return `管制に再接続しました（${tries}回の再試行・${downSec}秒ぶり）。通常の間隔に戻ります`;
+}
 /**
  * この command をまだ配達してよいか。純粋関数（I/Oなし＝単体テスト可能）。
  *   - 既に放棄済み(abandoned) → false。
@@ -1162,7 +1239,11 @@ export async function fetchControl(cfg) {
         // ★段3: 許可応答(permAnswer)の宛先特定用だった ?machine= は、答えを届ける役目ごと撤去したので
         //   付けない。応答に permAnswer が載っていても relay は読まない（中央側の受け口整理は段3-B）。
         const url = `${cfg.url}/api/conductor/control?site=${encodeURIComponent(cfg.site)}`;
-        const res = await fetch(url, { headers: authHeaders(cfg) });
+        // ★上限時間は必須（RELAY_FETCH_TIMEOUT_MS のコメント参照）。無いと管制の無応答で輪が永久に止まる。
+        const res = await fetch(url, {
+            headers: authHeaders(cfg),
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
+        });
         if (!res.ok) {
             return { relayHalted: true, ok: false, detail: `HTTP ${res.status}` };
         }
@@ -1192,7 +1273,11 @@ export async function fetchCommand(cfg) {
     const u = `${cfg.url}/api/conductor/commands` +
         `?machine=${encodeURIComponent(cfg.machine)}&site=${encodeURIComponent(cfg.site)}`;
     try {
-        const res = await fetch(u, { headers: authHeaders(cfg) });
+        // ★上限時間は必須（無応答の管制で輪が永久に止まるのを防ぐ・RELAY_FETCH_TIMEOUT_MS 参照）。
+        const res = await fetch(u, {
+            headers: authHeaders(cfg),
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
+        });
         if (!res.ok) {
             log(`site=${cfg.site} commands取得 -> HTTP ${res.status} NG`);
             return null;
@@ -1232,6 +1317,8 @@ export async function patchStatus(cfg, id, status, report) {
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify(payload),
+            // ★上限時間は必須（無応答の管制で輪が永久に止まるのを防ぐ・RELAY_FETCH_TIMEOUT_MS 参照）。
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
         });
         if (res.status === 409) {
             log(`site=${cfg.site} id=${id} ${status}遷移 -> 409 安全弁により中止`);
@@ -1379,7 +1466,11 @@ export async function sendHeartbeat(cfg, id, busy = false) {
                 body: JSON.stringify({ busy: true }),
             }
             : { method: 'PATCH', headers: authHeaders(cfg) };
-        const res = await fetch(`${cfg.url}/api/conductor/commands/${encodeURIComponent(id)}/seen`, init);
+        const res = await fetch(`${cfg.url}/api/conductor/commands/${encodeURIComponent(id)}/seen`, {
+            ...init,
+            // ★上限時間は必須（無応答の管制で輪が永久に止まるのを防ぐ・RELAY_FETCH_TIMEOUT_MS 参照）。
+            signal: AbortSignal.timeout(RELAY_FETCH_TIMEOUT_MS),
+        });
         if (!res.ok) {
             log(`site=${cfg.site} id=${id} heartbeat -> HTTP ${res.status} NG（次回再試行・縮退で安全）`);
         }
@@ -1659,22 +1750,7 @@ export async function restoreOrphans(cfg, state) {
     state.pending = orphanToPending(pick);
     log(`site=${cfg.site} id=${pick.id} を sent孤児から pending へ復元（★配達はしない・DONE待ちと生存通知だけ）`);
 }
-// ───────────────────────────────────────────────────────────────────────────
-// relay 本体（1ポーリング分）
-// ───────────────────────────────────────────────────────────────────────────
-/**
- * relay の1tick。CONDUCTOR_RELAY_INTERVAL_SEC ごとに呼ばれる想定。
- *
- * 流れ:
- *   - pending(送信済みDONE待ち)があれば、完了マーカー検出だけ行う
- *     （sent 中はサーバも新規指示を返さないので取得しない）。停止中でも継続する
- *     （既に送った指示の後始末は進める）。
- *   - 緊急停止フラグを確認。停止中なら新規の取得・送信は一切しない。
- *   - pending が無く停止中でもなければ、取得 → アイドル判定 → 配達 →「配達済み(sent)」を管制へ記録。
- *
- * すべての判定は保守的（少しでも怪しければ送らない／次回再挑戦）。
- */
-export async function relayTick(cfg, state) {
+export async function relayTick(cfg, state, hooks) {
     if (state.running)
         return; // 前回の tick が走行中ならスキップ
     state.running = true;
@@ -1871,19 +1947,41 @@ export async function relayTick(cfg, state) {
             }
             return; // sent 中は新規取得しない
         }
+        // ── 管制との線を確かめる（★止まらない・黙らないの要・2026-09-06 の根治） ──
+        // 通信不能・切断・タイムアウト・401・5xx は【すべてここ】に来る（fetchControl が ok=false にする）。
+        //   ・配達は安全側で止める（管制と話せないのに職人へ送るのは危険）＝これは従来どおり。
+        //   ・★relay 自体は止まらない。毎tick 1行出しながら、5秒→10→20→40→60秒 と間隔を伸ばして
+        //     永久に試し続ける（間隔の決定は cli.ts の適応スケジューラが state.central を見て行う）。
+        //   ・つながったら回数を0に戻し、通常の間隔（15秒）へ自動で戻る。
+        const ctl = await fetchControl(cfg);
+        if (!ctl.ok) {
+            log(noteCentralDown(state, ctl.detail, Date.now()));
+            // ★lastHalted（管制のスイッチの記憶）はここでは触らない。通信の失敗はスイッチではないので、
+            //   混ぜると復帰時に「停止が解除されました」という無関係な行が出る（人を混乱させる）。
+            return;
+        }
+        const reconnected = noteCentralUp(state, Date.now());
+        if (reconnected !== null) {
+            log(reconnected);
+            // ★戻ったら「自分は生きている」を管制へ1回知らせる（管制の一覧の札を正しく戻すため）。
+            //   使うのは既にある口だけ（新しいAPIは作らない）:
+            //     ① 追跡中の指示があれば、次tickの生存通知をスロットル無しで出せるよう時計を戻す。
+            //     ② 現場の生存報告(POST /api/conductor/report)を1回。呼び出し側(cli.ts)が持っている。
+            state.lastHeartbeatAt = null;
+            if (state.keepalive !== null)
+                state.keepalive.lastHeartbeatAt = null;
+            hooks?.onCentralReconnect?.();
+        }
         // ── 停止フラグ確認（新規の取得・送信のみ止める） ──
-        // 停止条件は3つ: ①通信不能（安全側）②グローバル緊急停止 relayHalted（後方互換）
-        //   ③この現場の子トグル relayEnabled=false（ADR-038）。relayEnabled が undefined（未取得）は
+        // 停止条件は2つ: ①グローバル緊急停止 relayHalted（後方互換）
+        //   ②この現場の子トグル relayEnabled=false（ADR-038）。relayEnabled が undefined（未取得）は
         //   ON(稼働)扱いでフォールバックする（停止しない）。ログは状態が変わった時だけ出す。
-        const ctl = await fetchControl(cfg);
         const haltedBySite = ctl.relayEnabled === false;
         if (ctl.relayHalted || haltedBySite) {
             if (state.lastHalted !== true) {
-                log(!ctl.ok
-                    ? `中央と通信できないため安全側で送信を停止します（${ctl.detail}）`
-                    : haltedBySite
-                        ? `この現場(${cfg.site})の relay送信トグルがOFF(停止)のため送信しません`
-                        : 'relay停止中(緊急停止スイッチON)のため送信しません');
+                log(haltedBySite
+                    ? `この現場(${cfg.site})の relay送信トグルがOFF(停止)のため送信しません`
+                    : 'relay停止中(緊急停止スイッチON)のため送信しません');
             }
             state.lastHalted = true;
             return;

package/package.json

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