@tyhld/conductor 0.12.83 → 0.12.85

package/dist/selfcheck.js

@@ -0,0 +1,743 @@
+/**
+ * @tyhld/conductor — 自己診断（`conductor selfcheck`・便 b7bd5e43・設計 3ed9e2b2 の A1）。
+ *
+ * 【何のためか】自社PCの自動更新（えふさん確定 2026-10-02）で、
+ *   「conductor 更新 → 自己診断 → PASS → Claude Code 更新 → 自己診断 → PASS」の判定に使う。
+ *   毎日1回（ADR-026 の9）と更新の直後を【同じ道具】で行い、きっかけの名前だけを変える。
+ *
+ * 【見る物（えふさん確定の6項目＋番人）】
+ *   ① conductor 起動   … 常駐（conductor@*・耳）が動いているか／常駐が動かしている版
+ *   ② Claude Code 起動 … 中継と同じ選び方（指名を含む）で選ばれた実体と版・ログイン済みか
+ *   ③ 管制との通信     … 緊急停止の読み取りが通るか・ai-kana の MCP が「接続済み」か「要認証」か
+ *   ④ 囲い             … bwrap・socat が在るか・囲いの中の書き込みが作業場所の外で止まるか
+ *   ⑤ GitHub・npm      … 外側から gh・npm、囲いの内側から両方へ1回ずつ
+ *   ⑥ 小さな headless 試験 … 小さい型（haiku）・許可は中継と同じ（番人がそのまま効く）。
+ *                         合否は職人の言葉でなく、tool の結果と終了コードで機械判定する
+ *   ＋番人             … 入っている番人に、止めるべき物と通すべき物を1つずつ判定させる
+ *
+ * 【★副作用なし】commit・push・PR・合流・配備・npm 公開をしない。作業場所は一時フォルダ
+ *   （~/.local/state/conductor/selfcheck/run-<時刻>・git の中ではない）で、終わったら消す。
+ *
+ * 【結果】手元の控え（~/.local/state/conductor/selfcheck/last.json と history/）に必ず残す。
+ *   管制の口が在れば送る（★口が無い・届かないときも落ちない＝送れなかったことを控えに書くだけ）。
+ *   送る中身は buildSelfcheckPayload の1か所（口の形は ai-kana の便 2f5eb92c が決める）。
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from 'node:fs';
+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 { fetchControl } from './relay.js';
+import { readDrain } from './autoupdate-flags.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// 形
+// ─────────────────────────────────────────────────────────────────────────────
+export const SELFCHECK_TRIGGERS = ['daily', 'after-conductor', 'after-claude', 'after-rollback', 'manual'];
+export const defaultExec = (cmd, args, opts = {}) => {
+    const r = spawnSync(cmd, args, {
+        cwd: opts.cwd,
+        env: opts.env,
+        input: opts.input,
+        timeout: opts.timeoutMs ?? 30_000,
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+    });
+    return {
+        status: r.status,
+        stdout: r.stdout ?? '',
+        stderr: r.stderr ?? '',
+        ...(r.error ? { error: r.error.message } : {}),
+    };
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// 置き場
+// ─────────────────────────────────────────────────────────────────────────────
+/** 自己診断の控えと一時の作業場所の置き場。 */
+export function selfcheckDir(home) {
+    return path.join(home, '.local', 'state', 'conductor', 'selfcheck');
+}
+/** 管制の受け口（★1か所。口の形は ai-kana の便 2f5eb92c に合わせてここだけ直す）。 */
+export const SELFCHECK_ENDPOINT = '/api/conductor/selfcheck';
+/** 控えの数の上限（古い物から消す）。 */
+export const SELFCHECK_HISTORY_MAX = 30;
+/** 小さな試験の上限時間。 */
+export const SELFCHECK_HEADLESS_TIMEOUT_MS = 180_000;
+/** 小さな試験で使う型（設計 3ed9e2b2 の要判断6・推奨 haiku）。 */
+export const SELFCHECK_MODEL = 'haiku';
+/** 小さな試験の最後の答えを示す目印（★職人の言葉ではなく、tool の結果の中で探す）。 */
+export const PROBE_OK_MARK = 'SELFCHECK_PROBE_OK';
+// ─────────────────────────────────────────────────────────────────────────────
+// 小さな試験（⑥）の中身と読み方
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * 囲いの中で流す台本。1回の Bash で ④（外への書き込み）と ⑤（内側の通信）までまとめて見る。
+ *   ★書き込み先は作業場所の【外】の使い捨ての場所（自己診断の一時フォルダの中）。
+ *   ★秘密の置き場は1つも触らない。
+ */
+export function probeScript(outsideFile) {
+    return [
+        '#!/usr/bin/env bash',
+        `OUT='${outsideFile.replace(/'/g, "'\\''")}'`,
+        `echo "${PROBE_OK_MARK}"`,
+        'if ( printf x > "$OUT" ) 2>/dev/null; then echo "OUTSIDE_WRITE=open"; else echo "OUTSIDE_WRITE=blocked"; fi',
+        'for u in https://registry.npmjs.org/ https://github.com/; do',
+        '  if command -v curl >/dev/null 2>&1; then',
+        '    c="$(curl -sS -o /dev/null -I -m 20 -w "%{http_code}" "$u" 2>/dev/null)"',
+        '  else c="no-curl"; fi',
+        '  echo "NET $u ${c:-000}"',
+        'done',
+        '',
+    ].join('\n');
+}
+export const PROBE_PROMPT = '作業場所の probe.sh を Bash で1回だけ実行してください（コマンドは `bash probe.sh` だけ）。' +
+    'ほかの道具は使わず、ファイルも作らないでください。出力をそのまま返して終えてください。';
+/** stream-json の出力を読む（★知らない行は読み飛ばす）。 */
+export function summarizeStream(stdout) {
+    const out = { mcp: null, toolResults: [], result: null };
+    for (const line of stdout.split('\n')) {
+        const t = line.trim();
+        if (!t.startsWith('{'))
+            continue;
+        let ev;
+        try {
+            ev = JSON.parse(t);
+        }
+        catch {
+            continue;
+        }
+        if (ev.type === 'system' && ev.subtype === 'init' && Array.isArray(ev.mcp_servers)) {
+            out.mcp = ev.mcp_servers
+                .map((s) => s)
+                .filter((s) => typeof s.name === 'string')
+                .map((s) => ({ name: String(s.name), status: typeof s.status === 'string' ? s.status : 'unknown' }));
+        }
+        if (ev.type === 'user') {
+            const content = ev.message?.content;
+            if (Array.isArray(content)) {
+                for (const c of content) {
+                    if (c?.type !== 'tool_result')
+                        continue;
+                    const body = c.content;
+                    if (typeof body === 'string')
+                        out.toolResults.push(body);
+                    else if (Array.isArray(body)) {
+                        out.toolResults.push(body.map((b) => (typeof b?.text === 'string' ? b.text : '')).join('\n'));
+                    }
+                }
+            }
+        }
+        if (ev.type === 'result') {
+            const usage = (ev.usage ?? {});
+            const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+            out.result = {
+                subtype: typeof ev.subtype === 'string' ? ev.subtype : null,
+                isError: ev.is_error === true,
+                costUsd: num(ev.total_cost_usd),
+                inputTokens: num(usage.input_tokens) === null
+                    ? null
+                    : (num(usage.input_tokens) ?? 0) +
+                        (num(usage.cache_read_input_tokens) ?? 0) +
+                        (num(usage.cache_creation_input_tokens) ?? 0),
+                outputTokens: num(usage.output_tokens),
+                durationMs: num(ev.duration_ms),
+            };
+        }
+    }
+    return out;
+}
+/**
+ * ai-kana の MCP の状態を1つに決める（★実機 2026-10-02・このPCの init 行で確かめた形）。
+ *   init 行には `mcp_servers: [{ name, status }]` が載る。status は connected / pending /
+ *   needs-auth / failed など。このPCでは「claude.ai ai-kana」（アカウントのコネクタ）と、
+ *   使っていない手元の登録「ai-kana」（いつも needs-auth）の2つが並ぶ。
+ *   ★1つでも connected なら接続済み。pending（つなぎかけで始まった）が在れば確定できない
+ *     （＝要認証とは言わない）。connected も pending も無く needs-auth が在るときだけ要認証。
+ */
+export function aiKanaMcpState(mcp) {
+    if (mcp === null)
+        return 'unknown';
+    const mine = mcp.filter((s) => /ai-kana/i.test(s.name));
+    if (mine.length === 0)
+        return 'missing';
+    if (mine.some((s) => s.status === 'connected'))
+        return 'connected';
+    if (mine.some((s) => s.status === 'pending'))
+        return 'pending';
+    if (mine.some((s) => /auth/i.test(s.status)))
+        return 'needs-auth';
+    return 'failed';
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// 本体
+// ─────────────────────────────────────────────────────────────────────────────
+function readJsonVersion(file) {
+    try {
+        const v = JSON.parse(readFileSync(file, 'utf8')).version;
+        return typeof v === 'string' ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 控えの1行（`<時刻> key=value …`）を読む。 */
+function readKvLine(file) {
+    try {
+        const line = (readFileSync(file, 'utf8').split('\n')[0] ?? '').trim();
+        const out = {};
+        for (const p of line.split(' ').slice(1)) {
+            const i = p.indexOf('=');
+            if (i > 0)
+                out[p.slice(0, i)] = p.slice(i + 1);
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+const fail = (item, kind, msg, human) => {
+    item.ok = false;
+    item.detail.push(`✗ ${msg}`);
+    if (kind === 'fault' || item.failKind === 'fault')
+        item.failKind = 'fault';
+    else
+        item.failKind = 'human';
+    if (human)
+        (item.human ??= []).push(human);
+};
+const pass = (item, msg) => {
+    if (item.ok === null)
+        item.ok = true;
+    item.detail.push(`✓ ${msg}`);
+};
+const note = (item, msg) => {
+    item.detail.push(`・${msg}`);
+};
+/** ① conductor 起動 */
+function checkConductor(d, version) {
+    const item = { key: 'conductor', label: 'conductor 起動', ok: null, detail: [] };
+    if (version)
+        pass(item, `この道具の版 ${version}`);
+    else
+        fail(item, 'fault', '配布物の版を読めません');
+    if (d.platform !== 'linux') {
+        note(item, 'systemd の無い機なので常駐は見ていません');
+        return item;
+    }
+    const r = d.exec('systemctl', ['--user', 'list-units', 'conductor@*.service', 'conductor-ear.service', '--all', '--no-legend', '--plain'], {
+        timeoutMs: 15_000,
+    });
+    if (r.status !== 0 && !r.stdout.trim()) {
+        note(item, `常駐の一覧を読めません（${(r.error ?? r.stderr).trim().slice(0, 120) || `終了 ${r.status}`}）`);
+    }
+    else {
+        const units = r.stdout
+            .split('\n')
+            .map((l) => l.trim().split(/\s+/))
+            .filter((f) => f[0]?.endsWith('.service'));
+        const relays = units.filter((f) => f[0].startsWith('conductor@'));
+        const down = units.filter((f) => f[2] !== 'active');
+        if (relays.length === 0)
+            note(item, '常駐（conductor@*）がこの機にありません');
+        else if (down.length === 0)
+            pass(item, `常駐 ${units.length} 本すべて動いています`);
+        else
+            fail(item, 'fault', `動いていない常駐: ${down.map((f) => `${f[0]}(${f[2]}/${f[3] ?? ''})`).join(' ')}`);
+    }
+    // 常駐が最後に動かせた配布物の版（conductor-run の控え・★~/.tyhld/hooks の下＝職人は書けない）。
+    const rt = readKvLine(path.join(d.home, '.tyhld', 'hooks', 'runtime-source.last'));
+    if (rt.status === 'ok' && rt.version) {
+        if (version && rt.version !== version) {
+            fail(item, 'fault', `常駐が動かしている版 ${rt.version} が、この道具の版 ${version} と違います（起こし直しが済んでいない）`);
+        }
+        else
+            pass(item, `常駐が動かしている版 ${rt.version}`);
+    }
+    else if (rt.status) {
+        fail(item, 'fault', `常駐の起動の控えが失敗です（${rt.reason ?? '理由不明'}）`);
+    }
+    else
+        note(item, '常駐の起動の控え（runtime-source.last）がありません');
+    return item;
+}
+/** ② Claude Code 起動 */
+function checkClaude(d) {
+    const item = { key: 'claude', label: 'Claude Code 起動', ok: null, detail: [] };
+    const got = d.resolveClaude();
+    const pin = lastClaudePinStatus();
+    if (pin.state === 'used')
+        note(item, `指名どおりの実体を選びました（${pin.pinned}）`);
+    if (pin.state === 'fallback')
+        fail(item, 'fault', `Claude Code の指名を使えません: ${pin.reason}`);
+    if (!got) {
+        fail(item, 'human', 'claude が見つかりません', {
+            machine: d.machine,
+            what: 'Ubuntu で Claude Code を入れる',
+            command: 'curl -fsSL https://claude.ai/install.sh | bash',
+        });
+        return { item, bin: null, version: null, loggedIn: null };
+    }
+    if (!got.version)
+        fail(item, 'fault', `claude の版を読めません（${got.bin}）`);
+    else if (compareVersions(got.version, CLAUDE_MIN_VERSION) < 0) {
+        const hint = claudeUpdateHint(got.bin);
+        fail(item, 'human', `Claude Code が最低版 ${CLAUDE_MIN_VERSION} より古い（${got.bin} = ${got.version}）`, {
+            machine: d.machine,
+            what: 'Ubuntu で Claude Code を上げる',
+            command: hint.replace(/^[^:]+:\s*/, ''),
+        });
+    }
+    else
+        pass(item, `${got.bin} = ${got.version}`);
+    let loggedIn = null;
+    const a = d.exec(got.bin, ['auth', 'status', '--json'], { timeoutMs: 20_000, env: d.env });
+    try {
+        const j = JSON.parse(a.stdout);
+        if (typeof j.loggedIn === 'boolean')
+            loggedIn = j.loggedIn;
+    }
+    catch {
+        // 読めない形（古い版など）は下で扱う
+    }
+    if (loggedIn === true)
+        pass(item, 'ログイン済み');
+    else if (loggedIn === false) {
+        fail(item, 'human', 'Claude Code がログインしていません', {
+            machine: d.machine,
+            what: 'Ubuntu で Claude Code にログインし直す',
+            command: `"${got.bin}" auth login`,
+        });
+    }
+    else
+        note(item, `ログインの状態を読めません（auth status の終了 ${a.status}）。小さな試験の結果で判断します`);
+    return { item, bin: got.bin, version: got.version, loggedIn };
+}
+/** ③ 管制との通信（MCP の状態は小さな試験の後で足す） */
+async function checkCentral(d) {
+    const item = { key: 'central', label: '管制との通信', ok: null, detail: [] };
+    const url = d.env.CONDUCTOR_URL;
+    const token = d.env.CONDUCTOR_TOKEN;
+    if (!url || !token) {
+        fail(item, 'fault', '接続設定（CONDUCTOR_URL・CONDUCTOR_TOKEN）がありません');
+        return item;
+    }
+    const site = d.env.CONDUCTOR_SITE || 'selfcheck';
+    const ctl = await withFetch(d, () => fetchControl({ url, token, machine: d.machine, site }));
+    if (ctl.ok)
+        pass(item, `緊急停止の読み取りが通りました（停止中=${ctl.relayHalted ? 'はい' : 'いいえ'}）`);
+    else
+        fail(item, 'fault', `緊急停止の読み取りが通りません（${ctl.detail}）`);
+    return item;
+}
+/** relay.ts の fetch を試験で差し替えるための包み（globalThis.fetch を一時的に置き換える）。 */
+async function withFetch(d, fn) {
+    if (d.fetchImpl === globalThis.fetch)
+        return fn();
+    const orig = globalThis.fetch;
+    globalThis.fetch = d.fetchImpl;
+    try {
+        return await fn();
+    }
+    finally {
+        globalThis.fetch = orig;
+    }
+}
+/** ④ 囲い（部品の有無。書き込みの止まり方は小さな試験の後で足す） */
+function checkSandboxParts(d) {
+    const item = { key: 'sandbox', label: '囲い（sandbox）', ok: null, detail: [] };
+    if (d.platform !== 'linux') {
+        note(item, 'Linux 以外の機なので部品（bwrap・socat）は求めません');
+        return item;
+    }
+    const missing = ['bwrap', 'socat'].filter((b) => d.exec('bash', ['-c', `command -v ${b}`], { env: d.env }).status !== 0);
+    if (missing.length === 0)
+        pass(item, 'bwrap・socat が在ります');
+    else {
+        fail(item, 'human', `囲いの部品がありません: ${missing.join('・')}`, {
+            machine: d.machine,
+            what: 'Ubuntu で囲いの部品を入れる（sudo のパスワードが分からないときは Windows の PowerShell で wsl.exe -u root apt-get install -y bubblewrap socat）',
+            command: 'sudo apt-get install -y bubblewrap socat',
+        });
+    }
+    return item;
+}
+/** 配布物の node の隣の npm（★毎時同期と同じ考え方＝PATH の裸の npm に頼らない）。 */
+export function npmBesideNode(execPath = process.execPath) {
+    const beside = path.join(path.dirname(execPath), 'npm');
+    return existsSync(beside) ? beside : null;
+}
+/** ⑤ GitHub・npm（外側。内側は小さな試験の後で足す） */
+function checkNetworkOutside(d, version) {
+    const item = { key: 'network', label: 'GitHub・npm への通信', ok: null, detail: [] };
+    const npm = d.findNpm();
+    if (!npm)
+        fail(item, 'fault', `配布物の node の隣に npm がありません（${path.dirname(process.execPath)}）`);
+    else {
+        const env = { ...d.env, PATH: `${path.dirname(npm)}:${d.env.PATH ?? ''}` };
+        const r = d.exec(npm, ['view', '@tyhld/conductor', 'version', '--@tyhld:registry=https://registry.npmjs.org'], { env, timeoutMs: 60_000 });
+        const v = r.stdout.trim().match(/^\d+\.\d+\.\d+\S*/)?.[0];
+        if (r.status === 0 && v)
+            pass(item, `公開 npm の @tyhld/conductor = ${v}${version && v !== version ? `（この機は ${version}）` : ''}`);
+        else
+            fail(item, 'fault', `公開 npm に問い合わせられません（${npm}・終了 ${r.status}）`);
+    }
+    const gh = d.exec('gh', ['auth', 'status'], { env: d.env, timeoutMs: 30_000 });
+    if (gh.error && /ENOENT/.test(gh.error)) {
+        fail(item, 'human', 'gh が入っていません', { machine: d.machine, what: 'Ubuntu で GitHub の道具を入れる', command: 'sudo apt-get install -y gh' });
+    }
+    else if (gh.status !== 0) {
+        fail(item, 'human', 'GitHub にログインしていません（gh auth status が失敗）', {
+            machine: d.machine,
+            what: 'Ubuntu で GitHub にログインし直す',
+            command: 'gh auth login',
+        });
+    }
+    else {
+        const api = d.exec('gh', ['api', 'rate_limit', '--jq', '.rate.limit'], { env: d.env, timeoutMs: 30_000 });
+        if (api.status === 0)
+            pass(item, 'GitHub にログイン済み・API へ届きます');
+        else
+            fail(item, 'fault', `GitHub の API へ届きません（終了 ${api.status}）`);
+    }
+    return item;
+}
+/** 囲いの設定だけを配布物の雛形から取り出す（★作業場所が現場と同じ囲いになるように）。 */
+function siteSettingsFor(distRoot) {
+    try {
+        const t = JSON.parse(readFileSync(path.join(distRoot, 'sales-template', 'settings.json'), 'utf8'));
+        return `${JSON.stringify({ permissions: t.permissions, sandbox: t.sandbox }, null, 2)}\n`;
+    }
+    catch {
+        return null;
+    }
+}
+/** ⑥ 小さな headless 試験を1回流す。 */
+function runHeadlessProbe(d, claudeBin, runDir) {
+    const res = { summary: null, exitCode: null, outsideWrite: 'unknown', net: {}, probeRan: false, error: null };
+    if (!claudeBin) {
+        res.error = 'claude が無いので流していません';
+        return res;
+    }
+    const work = path.join(runDir, 'work');
+    const outside = path.join(runDir, 'outside');
+    const outsideFile = path.join(outside, 'probe.txt');
+    mkdirSync(path.join(work, '.claude'), { recursive: true });
+    mkdirSync(outside, { recursive: true });
+    const settings = siteSettingsFor(d.distRoot);
+    if (!settings) {
+        res.error = '配布物の囲いの雛形（sales-template/settings.json）を読めません';
+        return res;
+    }
+    writeFileSync(path.join(work, '.claude', 'settings.json'), settings);
+    writeFileSync(path.join(work, 'probe.sh'), probeScript(outsideFile), { mode: 0o755 });
+    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;
+    const r = d.exec(claudeBin, [
+        '-p', PROBE_PROMPT,
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--max-turns', '3',
+        '--model', SELFCHECK_MODEL,
+        // ★中継と同じ許可（src/headless.ts の既定）＝番人がそのまま効く。迂回の旗は付けない。
+        '--permission-mode', 'acceptEdits',
+    ], { cwd: work, env, timeoutMs: SELFCHECK_HEADLESS_TIMEOUT_MS });
+    res.exitCode = r.status;
+    if (r.error)
+        res.error = r.error;
+    res.summary = summarizeStream(r.stdout);
+    const tool = res.summary.toolResults.join('\n');
+    res.probeRan = tool.includes(PROBE_OK_MARK);
+    // ★外に書けたかは【実物】で決める（ファイルが在るか）。台本の言葉は補助。
+    if (existsSync(outsideFile))
+        res.outsideWrite = 'open';
+    else if (/OUTSIDE_WRITE=blocked/.test(tool))
+        res.outsideWrite = 'blocked';
+    for (const m of tool.matchAll(/^NET (\S+) (\S+)$/gm))
+        res.net[m[1]] = m[2];
+    return res;
+}
+/** ＋番人：入っている番人に、止めるべき物と通すべき物を1つずつ判定させる。 */
+function checkGuard(d, work) {
+    const item = { key: 'guard', label: '番人', ok: null, detail: [] };
+    const guard = path.join(d.home, '.tyhld', 'hooks', 'cc2_guard.py');
+    const resync = 'APPLY=1 bash "$(npm root -g)/@tyhld/conductor/scripts/update-guard.sh"';
+    if (!existsSync(guard)) {
+        fail(item, 'human', `番人が入っていません（${guard}）`, { machine: d.machine, what: 'Ubuntu で番人を配り直す', command: resync });
+        return item;
+    }
+    const cases = [
+        { label: '番人の置き場を消す', command: 'rm -rf ~/.tyhld/hooks', want: 'deny' },
+        { label: '鍵を読み出す', command: 'cat ~/.ssh/id_rsa', want: 'deny' },
+        { label: 'ふつうの一覧', command: 'ls', want: 'allow' },
+    ];
+    for (const c of cases) {
+        const input = JSON.stringify({
+            hook_event_name: 'PreToolUse',
+            tool_name: 'Bash',
+            tool_input: { command: c.command },
+            cwd: work,
+            session_id: 'selfcheck',
+        });
+        const r = d.exec('python3', [guard], { input, env: { ...d.env, PYTHONDONTWRITEBYTECODE: '1' }, timeoutMs: 30_000 });
+        let got = 'none';
+        try {
+            got = JSON.parse(r.stdout).hookSpecificOutput?.permissionDecision ?? 'none';
+        }
+        catch {
+            // 何も返さない＝委譲（allow ではない）
+        }
+        const ok = c.want === 'deny' ? got === 'deny' : got === 'allow' || got === 'none';
+        if (ok)
+            pass(item, `${c.label} → ${got}`);
+        else
+            fail(item, 'fault', `${c.label} → ${got}（期待 ${c.want}）`);
+    }
+    return item;
+}
+/** 管制へ送る中身（★1か所）。口の形が決まったらここだけ合わせる。 */
+export function buildSelfcheckPayload(r) {
+    return {
+        schema: r.schema,
+        machine: r.machine,
+        trigger: r.trigger,
+        result: r.result,
+        startedAt: r.startedAt,
+        finishedAt: r.finishedAt,
+        conductorVersion: r.conductorVersion,
+        claudeVersion: r.claude.version,
+        claudeBin: r.claude.bin,
+        claudePin: r.claude.pin.state === 'none' ? null : r.claude.pin,
+        drain: r.drain,
+        mcp: r.mcp,
+        items: r.items.map((i) => ({ key: i.key, label: i.label, ok: i.ok, failKind: i.failKind ?? null, detail: i.detail })),
+        humanActions: r.humanActions,
+        usage: r.usage,
+    };
+}
+/** 手元の控えに書く（last.json と history/）。★失敗しても落ちない。 */
+export function saveSelfcheck(home, r, sent) {
+    try {
+        const dir = selfcheckDir(home);
+        const hist = path.join(dir, 'history');
+        mkdirSync(hist, { recursive: true });
+        const body = `${JSON.stringify({ ...r, sent }, null, 2)}\n`;
+        const stamp = r.startedAt.replace(/[:.]/g, '-');
+        writeFileSync(path.join(hist, `${stamp}-${r.trigger}.json`), body);
+        writeFileSync(path.join(dir, 'last.json'), body);
+        const files = readdirSync(hist).filter((f) => f.endsWith('.json')).sort();
+        for (const f of files.slice(0, Math.max(0, files.length - SELFCHECK_HISTORY_MAX))) {
+            rmSync(path.join(hist, f), { force: true });
+        }
+        return path.join(dir, 'last.json');
+    }
+    catch {
+        return null;
+    }
+}
+/** 管制へ送る。★口が無い・届かないときも落ちない（結果を返すだけ）。 */
+export async function sendSelfcheck(d, r) {
+    const url = d.env.CONDUCTOR_URL;
+    const token = d.env.CONDUCTOR_TOKEN;
+    if (!url || !token)
+        return { sent: false, detail: '接続設定が無いので送っていません' };
+    try {
+        const res = await d.fetchImpl(`${url}${SELFCHECK_ENDPOINT}`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify(buildSelfcheckPayload(r)),
+            // ★口が無いと、管制の入口がログイン画面へ回して 200 を返す（実機 2026-10-02）。
+            //   回り道を辿らず、JSON で答えたときだけ「受け取られた」と数える。
+            redirect: 'manual',
+            signal: AbortSignal.timeout(20_000),
+        });
+        const json = (res.headers.get('content-type') ?? '').includes('application/json');
+        if (res.ok && json)
+            return { sent: true, detail: `HTTP ${res.status}` };
+        if (res.ok || (res.status >= 300 && res.status < 400)) {
+            return { sent: false, detail: `HTTP ${res.status}（JSON の答えではない＝管制にまだ受け口がありません）` };
+        }
+        return { sent: false, detail: res.status === 404 ? 'HTTP 404（管制にまだ受け口がありません）' : `HTTP ${res.status}` };
+    }
+    catch (err) {
+        return { sent: false, detail: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** 自己診断を1回流す（送る・控えるは呼び出し側）。 */
+export async function runSelfcheck(d, trigger) {
+    const startedAt = d.now().toISOString();
+    const version = readJsonVersion(path.join(d.distRoot, 'package.json'));
+    const runDir = path.join(selfcheckDir(d.home), `run-${startedAt.replace(/[:.]/g, '-')}`);
+    mkdirSync(runDir, { recursive: true });
+    try {
+        const conductor = checkConductor(d, version);
+        const claude = checkClaude(d);
+        const central = await checkCentral(d);
+        const sandbox = checkSandboxParts(d);
+        const network = checkNetworkOutside(d, version);
+        const guard = checkGuard(d, path.join(runDir, 'work'));
+        // ⑥ 小さな試験（③の MCP・④の書き込み・⑤の内側の通信もここで見る）
+        const headless = { key: 'headless', label: '小さな headless 試験', ok: null, detail: [] };
+        const h = runHeadlessProbe(d, claude.bin, runDir);
+        const sum = h.summary;
+        if (h.error)
+            note(headless, h.error);
+        if (!sum || !sum.result)
+            fail(headless, 'fault', `結果の行がありません（終了 ${h.exitCode}）`);
+        else {
+            if (h.exitCode === 0)
+                pass(headless, '終了コード 0');
+            else
+                fail(headless, 'fault', `終了コード ${h.exitCode}`);
+            if (sum.result.subtype === 'success' && !sum.result.isError)
+                pass(headless, '結果の行が success');
+            else
+                fail(headless, 'fault', `結果の行が ${sum.result.subtype ?? '不明'}（is_error=${sum.result.isError}）`);
+            if (h.probeRan)
+                pass(headless, '囲いの中で Bash の台本が動きました（tool の結果で確認）');
+            else
+                fail(headless, 'fault', 'tool の結果に台本の目印がありません（Bash が動いていない）');
+        }
+        // ③ MCP
+        const mcpState = aiKanaMcpState(sum?.mcp ?? null);
+        if (mcpState === 'connected')
+            pass(central, 'ai-kana の MCP が接続済み');
+        else if (mcpState === 'needs-auth') {
+            fail(central, 'human', 'ai-kana の MCP が要認証です（完了の知らせを出せません）', {
+                machine: d.machine,
+                what: 'Ubuntu で claude を開き、/mcp → ai-kana → Authenticate を選んでブラウザでログインする',
+                command: 'claude',
+            });
+        }
+        else if (mcpState === 'pending')
+            note(central, 'ai-kana の MCP は つなぎかけのまま試験が始まりました（接続済みか要認証かは確定できません）');
+        else if (mcpState === 'missing')
+            fail(central, 'fault', 'ai-kana の MCP が一覧にありません');
+        else if (mcpState === 'failed')
+            fail(central, 'fault', 'ai-kana の MCP につながりません（failed）');
+        else
+            note(central, 'MCP の状態を読めませんでした（小さな試験の最初の行が無い）');
+        // ④ 書き込み
+        if (h.outsideWrite === 'blocked')
+            pass(sandbox, '囲いの中から作業場所の外への書き込みが止まりました');
+        else if (h.outsideWrite === 'open')
+            fail(sandbox, 'fault', '★囲いの中から作業場所の外へ書けました（囲いが効いていない）');
+        else
+            fail(sandbox, 'fault', '囲いの中の書き込みを確かめられませんでした');
+        // ⑤ 内側の通信
+        const codes = Object.entries(h.net);
+        if (codes.length === 0)
+            fail(network, 'fault', '囲いの内側からの通信を確かめられませんでした');
+        for (const [u, c] of codes) {
+            if (/^[23]\d\d$/.test(c))
+                pass(network, `囲いの内側から ${u} → ${c}`);
+            else
+                fail(network, 'fault', `囲いの内側から ${u} → ${c}`);
+        }
+        const items = [conductor, claude.item, central, sandbox, network, headless, guard];
+        const humanActions = items.flatMap((i) => i.human ?? []);
+        return {
+            schema: 'conductor-selfcheck/1',
+            machine: d.machine,
+            trigger,
+            startedAt,
+            finishedAt: d.now().toISOString(),
+            result: items.some((i) => i.ok === false) ? 'FAIL' : 'PASS',
+            conductorVersion: version,
+            claude: { bin: claude.bin, version: claude.version, loggedIn: claude.loggedIn, pin: lastClaudePinStatus() },
+            mcp: sum?.mcp ?? null,
+            drain: readDrain().active,
+            items,
+            humanActions,
+            usage: sum?.result
+                ? {
+                    costUsd: sum.result.costUsd,
+                    inputTokens: sum.result.inputTokens,
+                    outputTokens: sum.result.outputTokens,
+                    durationMs: sum.result.durationMs,
+                }
+                : null,
+        };
+    }
+    finally {
+        // ★一時の作業場所は必ず消す（外に書けてしまった物も含めて）。
+        rmSync(runDir, { recursive: true, force: true });
+    }
+}
+/** 画面に出す形（人が読む）。 */
+export function formatSelfcheck(r) {
+    const lines = [
+        `自己診断 ${r.result}（${r.machine}・きっかけ ${r.trigger}・${r.startedAt}）`,
+        `  conductor ${r.conductorVersion ?? '不明'} ／ Claude Code ${r.claude.version ?? '不明'}（${r.claude.bin ?? '無し'}）`,
+    ];
+    for (const i of r.items) {
+        const mark = i.ok === true ? 'PASS' : i.ok === false ? `FAIL${i.failKind === 'human' ? '（人の操作）' : ''}` : '----';
+        lines.push(`[${mark}] ${i.label}`);
+        for (const dl of i.detail)
+            lines.push(`    ${dl}`);
+    }
+    if (r.humanActions.length > 0) {
+        lines.push('', '人にしかできない操作:');
+        for (const h of r.humanActions)
+            lines.push(`  🔵 ${h.machine}: ${h.what}`, `     ${h.command}`);
+    }
+    if (r.usage) {
+        lines.push('', `小さな試験の使用量: 入力 ${r.usage.inputTokens ?? '?'} トークン・出力 ${r.usage.outputTokens ?? '?'} トークン・` +
+            `${r.usage.costUsd ?? '?'} ドル相当・${r.usage.durationMs ?? '?'} ms`);
+    }
+    return lines.join('\n');
+}
+/** `conductor selfcheck` の入口。返り値は終了コード（0=PASS / 1=FAIL / 2=使い方の誤り）。 */
+export async function runSelfcheckCommand(argv) {
+    let trigger = 'manual';
+    let json = false;
+    let send = true;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--trigger') {
+            const v = argv[++i];
+            if (!SELFCHECK_TRIGGERS.includes(v)) {
+                console.error(`[selfcheck] きっかけの名前が違います: ${v ?? '(なし)'}（${SELFCHECK_TRIGGERS.join(' / ')}）`);
+                return 2;
+            }
+            trigger = v;
+        }
+        else if (a === '--json')
+            json = true;
+        else if (a === '--no-send')
+            send = false;
+        else if (a === '--now')
+            trigger = 'manual';
+        else {
+            console.error(`[selfcheck] 知らない引数: ${a}`);
+            return 2;
+        }
+    }
+    const d = {
+        exec: defaultExec,
+        fetchImpl: globalThis.fetch,
+        env: process.env,
+        home: os.homedir(),
+        machine: process.env.CONDUCTOR_MACHINE || os.hostname(),
+        now: () => new Date(),
+        distRoot: path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'),
+        resolveClaude: resolveClaudeBin,
+        platform: process.platform,
+        findNpm: () => npmBesideNode(),
+    };
+    const r = await runSelfcheck(d, trigger);
+    const sent = send ? await sendSelfcheck(d, r) : { sent: false, detail: '--no-send' };
+    const saved = saveSelfcheck(d.home, r, sent);
+    if (json)
+        console.log(JSON.stringify({ ...r, sent, saved }, null, 2));
+    else {
+        console.log(formatSelfcheck(r));
+        console.log(`\n管制へ: ${sent.sent ? '送りました' : '送れませんでした'}（${sent.detail}）`);
+        console.log(`控え: ${saved ?? '書けませんでした'}`);
+    }
+    return r.result === 'PASS' ? 0 : 1;
+}