@tyhld/conductor 0.12.92 → 0.12.94

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) {
@@ -996,7 +1029,47 @@ function closeLog(ws) {
  *   失敗の理由は lastSpawnError に入る。
  */
 export let lastSpawnError = '';
-export function spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume) {
+/** 職人の PATH で「古い node が先に来ない」ように見る道具の名前。 */
+const NODE_TOOLS = ['node', 'npm', 'npx'];
+/**
+ * 職人（claude -p）の子プロセスへ渡す PATH を作る（便 24c9b6b6・e9276b86）。
+ *
+ * 【なぜ要るか（実物 2026-10-03・TYHLD-OTA 便 f770cd9d／ノートPC 便 4cf71dde）】
+ *   systemd の常駐はシェルの PATH を継承しないので、nvm の bin が職人の PATH に無い。
+ *   以前は claude が nvm の bin に居たので、claude の bin を足すだけで npm・npx も一緒に見えていた。
+ *   Claude Code を公式の入れ方（~/.local/bin/claude）にそろえた後は、足されるのが ~/.local/bin だけになり、
+ *   職人の bash で `npm: command not found`。node だけは /usr/local/bin/node（nvm への近道）で見えていた。
+ *   ★/usr/bin/node（v18）が別に在る機もあるので、PATH の順が崩れると古い node が動く。
+ *
+ * 【決め方】
+ *   - 中継を動かしている node（process.execPath＝conductor-run が選んだ配布物の node）の bin を必ず足す。
+ *     ＝職人の node・npm・npx は、中継と同じ版になる（その bin に npm・npx が同居する入れ方＝nvm 等）。
+ *   - claude の bin も足す（便 24c9b6b6）。ただし claude の bin に node・npm・npx のどれかが在るとき
+ *     （/usr/bin・nvm の別の版など）は、中継の node の bin をその前に置く＝古い node が先に来ない。
+ *     claude の bin に node 類が無いとき（~/.local/bin などの公式の入れ方）は、claude の bin を先に置く
+ *     ＝職人の bash の `claude` は中継が選んだ claude のまま。
+ *   - 2つは既に PATH に在っても先頭へ寄せる（後ろに残っていると、先に在る古い node が勝つため）。重複させない。
+ *   - PATH が空でも動く。
+ */
+export function buildWorkerPath(currentPath, claudeBin, nodeExecPath = process.execPath, hasTool = (dir, name) => existsSync(path.join(dir, name))) {
+    const nodeDir = path.dirname(nodeExecPath);
+    const claudeDir = path.dirname(claudeBin);
+    let front;
+    if (nodeDir === claudeDir)
+        front = [nodeDir];
+    else if (NODE_TOOLS.some((t) => hasTool(claudeDir, t)))
+        front = [nodeDir, claudeDir];
+    else
+        front = [claudeDir, nodeDir];
+    const rest = (currentPath ?? '').split(':').filter((d) => d !== '' && !front.includes(d));
+    return [...front, ...rest].join(':');
+}
+export function spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume, 
+/**
+ * resume のときに続行の指示へ足す文（例「本番操作が終わりました。前の値 → 後の値」）。
+ * ★渡さなければ今までと1バイトも同じ続行の指示になる。
+ */
+resumeNote) {
     // 前の失敗の理由を持ち越さない（理由の無い失敗に古い理由が付かないように）
     lastSpawnError = '';
     const resolved = resolveClaudeBin();
@@ -1025,15 +1098,9 @@ export function spawnClaudeProcess(cfg, cmd, sessionId, attempt, isResume) {
     env.CONDUCTOR_SITE = cfg.site;
     env.CONDUCTOR_MACHINE = cfg.machine;
     env.CONDUCTOR_WORK_DIR = cfg.workDir;
-    // ★claude が見つかった bin ディレクトリを PATH の先頭に足す（便 24c9b6b6）。
-    //   systemd 経由の起動では nvm の bin が PATH に無いため、子プロセスの bash から
-    //   claude・node・npm・pnpm が command not found になる。resolveClaudeBin() が
-    //   信頼したディレクトリだけを足す。重複させない・PATH が空でも動く。
-    const claudeBinDir = path.dirname(claudeBin);
-    const currentPath = env.PATH ?? '';
-    if (!currentPath.split(':').includes(claudeBinDir)) {
-        env.PATH = currentPath ? `${claudeBinDir}:${currentPath}` : claudeBinDir;
-    }
+    // ★職人の PATH の先頭に、中継を動かしている node の bin と claude の bin を足す
+    //   （便 24c9b6b6・e9276b86）。決め方は buildWorkerPath の説明を見ること。
+    env.PATH = buildWorkerPath(env.PATH, claudeBin);
     // ★テスト用: CONDUCTOR_CLAUDE_CONFIG_DIR を設定すると、claude の設定フォルダを差し替える。
     //   本物のログインを壊さずに認証エラーを再現できる（空のフォルダを指す → not logged in）。
     //   本番では設定しない（claude は既定の ~/.claude を使う）。
@@ -1130,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' にする（返事を待たずに「渡せた」と言わない）。
@@ -1711,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）
 // ─────────────────────────────────────────────────────────────────────────────
 /**
@@ -1805,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;
@@ -1844,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/realtime-parse.js

@@ -22,6 +22,14 @@ export const EAR_REFRESH_FALLBACK_MS = 8 * 60 * 60 * 1000;
 /** 再接続の待ち（指数バックオフ）の初期値と上限。 */
 export const EAR_RETRY_BASE_MS = 5 * 1000;
 export const EAR_RETRY_MAX_MS = 5 * 60 * 1000;
+/**
+ * 鍵が通らない（401・403）ときの聞き直しの待ち（指数バックオフ）の初期値と上限（便 e9276b86）。
+ *   【実物 2026-10-03 03:04〜03:24Z】鍵が通らない機から realtime-token が 2〜4秒おきに聞き直され、20分で 401 が189件。
+ *   鍵は待っても直らない（人が入れ直すまで同じ答え）ので、ふつうの切断（5秒から）より長く空ける。
+ *   ★1分 → 2分 → 4分 …と広げ、30分で頭打ち。つながっているときの速さ（合図・取り直し）は変えない。
+ */
+export const EAR_AUTH_RETRY_BASE_MS = 60 * 1000;
+export const EAR_AUTH_RETRY_MAX_MS = 30 * 60 * 1000;
 /** 購読設定が無い（unsupported）ときに問い直す間隔(ms)。中央の設定投入に自然に追従するため。 */
 export const EAR_UNSUPPORTED_RETRY_MS = 30 * 60 * 1000;
 /**
@@ -108,6 +116,15 @@ export function computeRefreshDelayMs(expiresAt, nowMs) {
         return clamp(EAR_REFRESH_FALLBACK_MS);
     return clamp(at - nowMs - EAR_REFRESH_MARGIN_MS);
 }
+/** 中央の答えが「鍵が通らない」か（401・403）。 */
+export function isAuthRejected(r) {
+    return r.kind === 'error' && (r.status === 401 || r.status === 403);
+}
+/** 鍵が通らないときの待ち(ms)。続けて断られた回数に応じて 1分 → 2分 → 4分 …と広げ、30分で頭打ち。 */
+export function computeAuthRetryDelayMs(failures) {
+    const n = failures < 0 ? 0 : failures;
+    return Math.min(EAR_AUTH_RETRY_MAX_MS, EAR_AUTH_RETRY_BASE_MS * 2 ** Math.min(n, 20));
+}
 /** 再接続の待ち(ms)。試行回数に応じて 5s → 10s → 20s …と広げ、5分で頭打ちにする。 */
 export function computeRetryDelayMs(attempt) {
     const n = attempt < 0 ? 0 : attempt;

package/dist/realtime.js

@@ -30,7 +30,7 @@
  *   読めなければ「耳なし＝各relayのポーリングのみ」で静かに動き続ける。
  */
 import { describeTransport, resolveWebSocketTransport } from './websocket-transport.js';
-import { EAR_NO_SITE_RETRY_MS, EAR_NUDGE_MIN_GAP_MS, EAR_TOKEN_FETCH_TIMEOUT_MS, EAR_UNSUPPORTED_RETRY_MS, computeRefreshDelayMs, computeRetryDelayMs, parseRealtimeConnection, readSignalSite, } from './realtime-parse.js';
+import { EAR_NO_SITE_RETRY_MS, EAR_NUDGE_MIN_GAP_MS, EAR_TOKEN_FETCH_TIMEOUT_MS, EAR_UNSUPPORTED_RETRY_MS, computeAuthRetryDelayMs, computeRefreshDelayMs, computeRetryDelayMs, isAuthRejected, parseRealtimeConnection, readSignalSite, } from './realtime-parse.js';
 // 読み取りと間合いの計算は src/realtime-parse.ts に分けてある（外部I/Oなし＝単体テスト可能）。
 // 従来どおり `./realtime.js` からも使えるよう、ここで通しておく。
 export * from './realtime-parse.js';
@@ -60,7 +60,7 @@ export async function fetchRealtimeConnection(cfg, site) {
             signal: AbortSignal.timeout(EAR_TOKEN_FETCH_TIMEOUT_MS),
         });
         if (!res.ok)
-            return { kind: 'error', detail: `HTTP ${res.status}` };
+            return { kind: 'error', detail: `HTTP ${res.status}`, status: res.status };
         const data = await res.json().catch(() => null);
         return parseRealtimeConnection(data);
     }
@@ -78,12 +78,17 @@ async function loadCreateClient() {
         return null;
     }
 }
+const DEFAULT_IO = {
+    fetchConnection: fetchRealtimeConnection,
+    loadCreateClient,
+    resolveTransport: resolveWebSocketTransport,
+};
 /**
  * 指示の着信合図を受け取る耳を1本張る（★このPCに1本だけ＝耳プロセスからのみ呼ぶ）。
  *
  * 呼び出し側は各relayのポーリングを止めないこと——耳が死んでいる間はポーリングが肩代わりする。
  */
-export function startRealtimeEar(cfg, handlers) {
+export function startRealtimeEar(cfg, handlers, io = DEFAULT_IO) {
     const { siteForToken, onSignal } = handlers;
     let stopped = false;
     let client = null;
@@ -96,6 +101,18 @@ export function startRealtimeEar(cfg, handlers) {
     let lastNudgeSite = null;
     /** 再接続の予約が二重に積まれないようにする（切断イベントは連続で飛んでくる）。 */
     let reconnectArmed = false;
+    /**
+     * 鍵が通らない（401・403）と続けて断られた回数（便 e9276b86）。★接続情報が取れたときだけ 0 に戻す
+     *   （購読の SUBSCRIBED では戻さない＝別の線の知らせで待ちが縮まない）。
+     */
+    let authFailures = 0;
+    /**
+     * いま張っている線の世代（便 e9276b86）。片付けるたびに1つ進める。
+     *   ★片付けた古い線から遅れて届く CLOSED などの知らせは、世代が違うので無視する。
+     *   （以前は、期限の手前の張り直しで古い線を片付けると、その CLOSED で2本目の張り直しが走り、
+     *    聞き直しが重なっていた。）
+     */
+    let generation = 0;
     const clearTimers = () => {
         if (retryTimer) {
             clearTimeout(retryTimer);
@@ -122,16 +139,28 @@ export function startRealtimeEar(cfg, handlers) {
         }
         channel = null;
         client = null;
+        generation += 1;
     };
-    /** 一拍おいて張り直す。理由はログに残す（凝らない＝最悪はポーリングが拾う）。 */
-    const scheduleReconnect = (reason) => {
+    /**
+     * 一拍おいて張り直す。理由はログに残す（凝らない＝最悪はポーリングが拾う）。
+     *   authRejected＝鍵が通らない（401・403）ときは、ふつうの切断より長く空ける（便 e9276b86）。
+     */
+    const scheduleReconnect = (reason, authRejected = false) => {
         if (stopped || reconnectArmed)
             return;
         reconnectArmed = true;
         teardown();
-        const delay = computeRetryDelayMs(attempt);
-        attempt += 1;
-        log(`${reason} → ${Math.round(delay / 1000)}秒後に張り直します（この間は各relayの15秒ポーリングが肩代わり）`);
+        let delay;
+        if (authRejected) {
+            delay = computeAuthRetryDelayMs(authFailures);
+            authFailures += 1;
+        }
+        else {
+            delay = computeRetryDelayMs(attempt);
+            attempt += 1;
+        }
+        log(`${reason} → ${Math.round(delay / 1000)}秒後に張り直します（この間は各relayの15秒ポーリングが肩代わり）` +
+            (authRejected ? '。★鍵が通りません（~/.conductor.env の合言葉を確かめてください）' : ''));
         clearTimers();
         retryTimer = setTimeout(() => {
             reconnectArmed = false;
@@ -168,7 +197,7 @@ export function startRealtimeEar(cfg, handlers) {
     const connect = async () => {
         if (stopped)
             return;
-        const createClient = await loadCreateClient();
+        const createClient = await io.loadCreateClient();
         if (createClient === null) {
             log('@supabase/supabase-js が読めないため耳は張りません（各relayの15秒ポーリングでこれまでどおり動きます）');
             return; // 依存は実行中に生えないので再試行しない。
@@ -176,7 +205,7 @@ export function startRealtimeEar(cfg, handlers) {
         // ★どの Node(18/20/22) でも耳が張れるようにする（実機 Node 20 の「native WebSocket not found」根治）。
         //   標準の WebSocket が無い機では同梱の ws を supabase-js の transport へ渡す。
         //   どちらも用意できなければ耳は張らない——が、プロセスは落とさない（ポーリングが肩代わりする）。
-        const transport = await resolveWebSocketTransport();
+        const transport = await io.resolveTransport();
         if (transport === null) {
             log('この機には標準のWebSocketが無く、同梱のWebSocket部品(ws)も読めないため耳は張りません' +
                 '（npm install で解消します。それまでも各relayの15秒ポーリングでこれまでどおり動きます）');
@@ -189,7 +218,9 @@ export function startRealtimeEar(cfg, handlers) {
             retryTimer = setTimeout(() => void connect(), EAR_NO_SITE_RETRY_MS);
             return;
         }
-        const result = await fetchRealtimeConnection(cfg, site);
+        const result = await io.fetchConnection(cfg, site);
+        if (stopped)
+            return;
         if (result.kind === 'unsupported') {
             log(`中央から購読設定が返らないため耳は張りません（${result.detail}）。` +
                 `各relayの15秒ポーリングで動き続け、${Math.round(EAR_UNSUPPORTED_RETRY_MS / 60000)}分後にもう一度問い合わせます`);
@@ -198,10 +229,12 @@ export function startRealtimeEar(cfg, handlers) {
             return;
         }
         if (result.kind === 'error') {
-            scheduleReconnect(`接続情報を取得できません（${result.detail}）`);
+            scheduleReconnect(`接続情報を取得できません（${result.detail}）`, isAuthRejected(result));
             return;
         }
+        authFailures = 0;
         const conn = result.conn;
+        const myGeneration = generation;
         try {
             client = createClient(conn.supabaseUrl, conn.supabaseAnonKey, {
                 auth: { persistSession: false, autoRefreshToken: false },
@@ -221,7 +254,8 @@ export function startRealtimeEar(cfg, handlers) {
                 .channel(spec.channel)
                 .on('postgres_changes', filterOpt, handleSignal)
                 .subscribe((status, err) => {
-                if (stopped)
+                // ★片付けた古い線の知らせは無視する（張り直しを重ねない・便 e9276b86）。
+                if (stopped || myGeneration !== generation)
                     return;
                 if (status === 'SUBSCRIBED') {
                     attempt = 0;

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;
 /** 初期状態を作る。 */
@@ -2574,7 +2661,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 +2676,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。

package/dist/selfcheck.js

@@ -27,7 +27,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { CLAUDE_MIN_VERSION, claudeUpdateHint, compareVersions, lastClaudePinStatus, resolveClaudeBin, } from './headless.js';
+import { buildWorkerPath, CLAUDE_MIN_VERSION, claudeUpdateHint, compareVersions, lastClaudePinStatus, resolveClaudeBin, } from './headless.js';
 import { fetchControl } from './relay.js';
 import { readDrain } from './autoupdate-flags.js';
 // ─────────────────────────────────────────────────────────────────────────────
@@ -538,9 +538,7 @@ function probeEnv(d, claudeBin) {
     const env = { ...d.env };
     delete env.CLAUDECODE;
     delete env.ANTHROPIC_API_KEY;
-    const binDir = path.dirname(claudeBin);
-    if (!(env.PATH ?? '').split(':').includes(binDir))
-        env.PATH = env.PATH ? `${binDir}:${env.PATH}` : binDir;
+    env.PATH = buildWorkerPath(env.PATH, claudeBin);
     return env;
 }
 /** ⑥ 小さな headless 試験を1回流す。 */
@@ -841,8 +839,31 @@ export async function runSelfcheck(d, trigger) {
     finally {
         // ★一時の作業場所は必ず消す（外に書けてしまった物も含めて）。
         rmSync(runDir, { recursive: true, force: true });
+        // ★道具（Claude Code）が作業場所ごとに /tmp/claude-<uid>/ の下へ作る記録も消す（便 e9276b86）。
+        //   作業場所は毎回名前が違うので、消さないと自己診断のたびに1つずつ溜まる（ノートPCで9つ）。
+        for (const dir of [runDir, path.join(runDir, 'work')]) {
+            const trace = claudeTraceDir(dir, d.claudeTmpRoot);
+            if (trace)
+                rmSync(trace, { recursive: true, force: true });
+        }
     }
 }
+/**
+ * Claude Code が作業場所ごとに作る記録の置き場（★実物 2026-10-03・Claude Code 2.1.287）。
+ *   `/tmp/claude-<uid>/` の下に、作業場所のパスの英数字以外を `-` に替えた名前で作る
+ *   （例 /home/u/.local/state/conductor/selfcheck/run-…/work → -home-u--local-state-conductor-selfcheck-run-…-work）。
+ * ★消してよいのは自己診断の作業場所の分だけ。名前に selfcheck の run- が入らなければ null（他人の物に触らない）。
+ */
+export function claudeTraceDir(workDir, root = defaultClaudeTmpRoot()) {
+    const name = workDir.replace(/[^a-zA-Z0-9]/g, '-');
+    if (!/-selfcheck-run-/.test(name))
+        return null;
+    return path.join(root, name);
+}
+function defaultClaudeTmpRoot() {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
+    return path.join('/tmp', `claude-${uid}`);
+}
 /** 画面に出す形（人が読む）。 */
 export function formatSelfcheck(r) {
     const lines = [

package/package.json

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

package/sales-template/setup.sh

@@ -1290,6 +1290,49 @@ else
   cleanup_stale_units || warn "古いユニットの掃除に失敗しました（インストールは続行します）。"
 fi
 
+# --- 画面なし方式（headless）の機では、足す現場も画面なし方式で立てる（便 e9276b86） ---
+# 【なぜ要るか（実物 2026-10-03・TYHLD-GOTO・TYHLD-OTA）】
+#   1行インストーラ（install.sh）は最初の現場に drop-in（headless.conf）を置いて画面なし方式にする。
+#   ところが2つ目の現場を `conductor setup 現場名` で足すと drop-in が無く、古い方式（tmux）で立った
+#   （管制で「AI担当は休止中」。人が drop-in を手で置いて直した）。⑧の案内も tmux の3行を出していた。
+# 【決め方】次のどれかなら、この機は画面なし方式＝この現場にも install.sh と同じ drop-in を置く。
+#   ① CONDUCTOR_RUNNER_MODE=headless で呼ばれた（install.sh から）。★=tmux と明示されたら置かない。
+#   ② この機のほかの現場（またはテンプレート全体）の drop-in に画面なし方式の指定が在る。
+#   ★どれにも当たらない機（もとから tmux 方式の機）は、1つも変えない。Mac（launchd）も変えない。
+HEADLESS_LINE='Environment=CONDUCTOR_RUNNER_MODE=headless'
+HEADLESS_DROPIN_DIR="$HOME/.config/systemd/user/conductor@${SITE}.service.d"
+HEADLESS_DROPIN="$HEADLESS_DROPIN_DIR/headless.conf"
+machine_is_headless() {
+  case "${CONDUCTOR_RUNNER_MODE:-}" in
+    headless) return 0 ;;
+    tmux) return 1 ;;
+  esac
+  local f
+  for f in "$HOME"/.config/systemd/user/conductor@*.service.d/*.conf; do
+    [[ -f "$f" ]] || continue
+    grep -qxF "$HEADLESS_LINE" "$f" && return 0
+  done
+  return 1
+}
+HEADLESS_ADDED=0
+if [[ "$OS_KIND" != "mac" ]] && machine_is_headless; then
+  if [[ -f "$HEADLESS_DROPIN" ]] && grep -qxF "$HEADLESS_LINE" "$HEADLESS_DROPIN"; then
+    echo "[setup] 画面なし方式: この現場には設定済みです（${HEADLESS_DROPIN}）"
+  else
+    mkdir -p "$HEADLESS_DROPIN_DIR"
+    cat > "$HEADLESS_DROPIN" <<DROPIN
+# setup.sh が設定: この機は画面なし方式（headless）なので、この現場も同じ方式で動かす。
+# ★tmux に切り替えたいときはこのファイルを消して systemctl --user daemon-reload。
+[Service]
+${HEADLESS_LINE}
+DROPIN
+    HEADLESS_ADDED=1
+    echo "[setup] 画面なし方式を設定しました（drop-in: ${HEADLESS_DROPIN}）"
+  fi
+  # ⑧ の案内を画面なし方式に切り替える。
+  CONDUCTOR_RUNNER_MODE=headless
+fi
+
 # ★常駐の設置だけが OS で分かれる（ADR-019・案C）。ここより上も下も1本のまま。
 if [[ "$OS_KIND" == "mac" ]]; then
   SVC_INSTALL="$SCRIPT_DIR/launchd/install.sh"
@@ -1298,6 +1341,10 @@ else
 fi
 if [[ -f "$SVC_INSTALL" ]]; then
   bash "$SVC_INSTALL" "$SITE" "$PROJECT_DIR"
+  # ★もう動いていた現場（setup のやり直し）は enable --now では読み直さないので、入れ直して効かせる。
+  if [[ "$HEADLESS_ADDED" == "1" ]]; then
+    systemctl --user restart "conductor@${SITE}.service" 2>/dev/null || true
+  fi
 else
   warn "常駐の設置スクリプトが見つかりません: $SVC_INSTALL（スキップ）"
   echo "[setup] 手動で設定する場合は sales-template/${SVC_KIND}/ を参照してください。"
@@ -1452,12 +1499,13 @@ if [[ "${CONDUCTOR_RUNNER_MODE:-}" == "headless" ]]; then
   合言葉を入れ直す: rm ~/.conductor.env   → そのあと setup.sh をもう一度実行
 
 ──────────────────────────────────────────────────────────
-職人の画面を手で開きたいとき（tmux 方式・補助）
+職人の画面を手で開きたいとき（見るだけ・補助）
 ──────────────────────────────────────────────────────────
 
-  tmux new-session -d -s "$SITE" -c "$PROJECT_DIR"
-  tmux send-keys -t "$SITE" "unset ANTHROPIC_API_KEY && claude" C-m
-  tmux attach -t "$SITE"
+  画面なし方式では、職人の画面を手で立ち上げません（立ち上げると、便と同じ現場で2人目の職人が動きます）。
+  職人がいま何をしているかは、管制の画面か、次の1行で見られます（見るだけ・入力はできません）:
+
+  kc ${SITE}        （kc が無いときは  conductor view ${SITE}）
 
 GUIDE
 else

package/skills/conductor-craftsman/SKILL.md

@@ -132,6 +132,10 @@ description: 采配くんの便（プロンプト末尾に CONDUCTOR_JOB:<id>
     - **なぜ（置き場の話）。** 実機 2026-09-03: ai-saku の画面便（PR#258・PR#269）で、検品用の使い捨てページ `_layout-check.html` をリポジトリ直下に作り、`rm -rf` で消そうとして止められ、人が2回消した。**禁止の一覧と番人の制限は正しい（緩めない）。悪いのは置き場。**
     - **なぜ（後片付けの話を改めた理由）。** 旧い文言は「リポジトリ直下は番人が `rm` を止めるので自分で消さず報告」だった。実測（便 fb248f6e）では、`-f` を付けない `rm -r` と実在のパスの名指しなら、リポジトリ直下の自分の作業ファイルも通る。止まるのは `-f` 付きと変数・`*` 入りだけ。**止まらない形を「止まる」と書いていると、職人が自分の残骸を残したまま便を終える**ので、実物に合わせた（番人・禁止の一覧は1行も変えていない）。
     - 置き場を `/tmp/claude-1000/` にすれば、止められることも、残骸がコミットに混ざることも起きない（根治＝鉄則10）。Playwright の検品ページも同じ（鉄則8-④）。
+    - **空振り確認（直しをわざと外して、試験が落ちるのを見る）も、使い捨ての複製の中だけで行う（えふさん確定 2026-10-03・便 4cf71dde の要判断②）。**
+      - 形: `git clone --no-hardlinks <リポの実在のパス> /tmp/claude-1000/karaburi-<便IDの頭8文字>` → その中で直しを外す → 試験を流す → 終わったら `rm -r /tmp/claude-1000/karaburi-<便IDの頭8文字>`（`-f` を付けない・名指し）。
+      - ★**作業ツリーの中で直しを外さない**（戻し忘れがそのまま PR に入る）。★**`git worktree` を使わない**：囲いが `.git/worktrees` を読み取り専用で重ねるので、`git worktree remove` が「Device or resource busy」で止まり、職人が片付けられない（便 4cf71dde で再現）。複製なら囲いにも番人にも止められずに片付く。
+      - 複製の中でも記録に入れるときは名指しで `git add <ファイル>`（鉄則1-④）。複製は GitHub へ push しない。
 14. **`.env` 類（`.env`・`.env.local`・`.env.example` などの雛形も含む）は職人が書き換えない（えふさん確定 2026-09-18・便 3d11f913）**
     - **番人は `.env` 本体も `.env.example` などの雛形も、書き込みを止める**（Write／Edit の設定 deny と、Bash の `echo`／`tee`／`sed -i`／`cp`／`mv` などを、経路を問わず同じ結果にそろえた）。読み込みは今までどおり（雛形は読める・本物は読めない）。
     - **なぜ。** 雛形（`.env.example`）は普通は秘密値を置かないが、「exampleだから常に安全」と番人へ例外を作ると、将来誤って実値が書かれたときの穴になる（利便性より安全側・えふさん確定）。