Apollo 自体の改修（止まっていた計画が、自分で回り出すまでの5日間）（会話ログ）

#!/usr/bin/env bash
# セッション終了チェック（GH-1）: Claude Code の SessionEnd フック / 手動実行の両方で使う。
#
# やること（止めない・全部やって最後に要約を出す）:
#   1. 内部文書の自動 commit+push を auto-push.sh に任せる（対象外の dirty があれば auto-push 側が exit 2 で保留にする）
#   2. push 後の git 同期状態（ahead/behind/dirty）を doctor --check から取る
#   3. FB台帳漏れチェック（fb_ledger_gap_check.py --summary）。python3 不在・失敗・台帳0本は警告に載せる
#   4. 実行記録を vault/.agents/runs/YYYY-MM/YYYY-MM-DD-<host>.md に1ブロック追記（機械が分かる事実だけ。
#      「やったこと・成果物・学び」の3行はセッション側が .claude/routines/session-end.md に従って同じファイルに書く）
#
# 使い方:
#   bash scripts/session-end-check.sh              # 通常（push あり）
#   bash scripts/session-end-check.sh --no-push    # push しない（検証・他人のマシン）
#   bash scripts/session-end-check.sh --quiet      # 要約だけ
#
# 設計上の約束:
#   - このスクリプト自身は git の破壊操作（reset/checkout --/stash/force）を一切しない
#   - 書込先は vault/.agents/runs/ 配下の自分が作るファイルだけ
#   - フックから呼ばれるため常に exit 0（失敗は要約に「⚠️」で残す。実行できなかったチェックも⚠️に載せる）
set -uo pipefail

NO_PUSH=0; QUIET=0
for arg in "$@"; do
  case "$arg" in
    --no-push) NO_PUSH=1 ;;
    --quiet) QUIET=1 ;;
    -h|--help) sed -n '2,20p' "$0"; exit 0 ;;
    *) echo "⚠️ 未知のオプション: $arg（無視して続行）" >&2 ;;
  esac
done

REPO=$(git rev-parse --show-toplevel 2>/dev/null) || { echo "⚠️ git リポジトリ外のため何もしません"; exit 0; }
cd "$REPO" || exit 0

HOST=$(hostname -s 2>/dev/null || hostname 2>/dev/null || echo unknown)
HOST=$(printf '%s' "$HOST" | tr -c 'A-Za-z0-9._-' '_' | cut -c1-64); [ -z "$HOST" ] && HOST=unknown
NOW=$(date '+%Y-%m-%d %H:%M:%S')
TODAY=$(date '+%Y-%m-%d')
MONTH=$(date '+%Y-%m')
RUN_DIR="vault/.agents/runs/$MONTH"
RUN_FILE="$RUN_DIR/$TODAY-$HOST.md"
BRANCH=$(git branch --show-current 2>/dev/null || echo "?")
WARN=()
CHECKS_RUN=0

# 1. 内部文書の自動 push（先にやる。2の同期状態は push 後の値を記録する） -----------
PUSH_LINE="skip（--no-push）"
if [ "$NO_PUSH" -eq 0 ]; then
  if [ -f scripts/auto-push.sh ]; then
    AP_OUT=$(bash scripts/auto-push.sh --no-notify 2>&1); AP_RC=$?
    CHECKS_RUN=$((CHECKS_RUN+1))
    case "$AP_RC" in
      0) PUSH_LINE="auto-push OK" ;;
      2) PUSH_LINE="auto-push 保留（対象外のdirtyあり・内部文書は次回）"; WARN+=("内部文書のpushが保留（auto-push exit 2）") ;;
      *) PUSH_LINE="auto-push 失敗 rc=$AP_RC"; WARN+=("auto-push が失敗（rc=$AP_RC）: $(printf '%s' "$AP_OUT" | tail -1)") ;;
    esac
  else
    PUSH_LINE="auto-push.sh 不在"; WARN+=("scripts/auto-push.sh が無く内部文書のpushを確認できない")
  fi
fi

# 2. 同期状態（push 後） -------------------------------------------------------
SYNC_LINE="(doctor 不在)"
if [ -f scripts/git-sync-doctor.sh ]; then
  DOCTOR_OUT=$(bash scripts/git-sync-doctor.sh --check 2>&1); DOCTOR_RC=$?
  CHECKS_RUN=$((CHECKS_RUN+1))
  AHEAD=$(printf '%s\n' "$DOCTOR_OUT" | awk '/^ahead:/{print $2; exit}')
  BEHIND=$(printf '%s\n' "$DOCTOR_OUT" | awk '/^behind:/{print $2; exit}')
  SYNC_LINE="ahead=${AHEAD:-?} behind=${BEHIND:-?}"
  printf '%s\n' "$DOCTOR_OUT" | grep -q 'OK: clean and synced' && SYNC_LINE="$SYNC_LINE clean"
  case "${AHEAD:-?}" in ''|0|\?) ;; *) WARN+=("未pushのcommitが ${AHEAD} 件（統合botかpushで解消）") ;; esac
  case "${BEHIND:-?}" in ''|0|\?) ;; *) WARN+=("originより ${BEHIND} 件遅れ（次回 doctor --start --pull）") ;; esac
  [ -z "${AHEAD:-}" ] && [ "$DOCTOR_RC" -ge 4 ] && WARN+=("doctor が fetch/pull に失敗（rc=$DOCTOR_RC）。同期状態は未確認")
else
  WARN+=("scripts/git-sync-doctor.sh が無く同期状態を確認できない")
fi
if STATUS_OUT=$(git status --porcelain 2>/dev/null); then
  DIRTY_TOTAL=$(printf '%s\n' "$STATUS_OUT" | awk 'NF{n++} END{print n+0}')
  DIRTY_TRACKED=$(printf '%s\n' "$STATUS_OUT" | awk 'NF && substr($0,1,2)!="??" {n++} END{print n+0}')
else
  DIRTY_TOTAL="?"; DIRTY_TRACKED="?"; WARN+=("git status が失敗し dirty を数えられない")
fi

# 3. FB台帳漏れ（JSON で読む。失敗は未完了として警告） ----------------------------
FB_LINE="FB台帳漏れチェック: 未実行"
FB_LEAK=""
if ! command -v python3 >/dev/null 2>&1; then
  WARN+=("python3 が無くFB台帳漏れチェックを実行できない")
elif [ ! -f scripts/fb_ledger_gap_check.py ]; then
  WARN+=("scripts/fb_ledger_gap_check.py が無くFB台帳漏れチェックを実行できない")
else
  FB_SUMMARY=$(python3 scripts/fb_ledger_gap_check.py --summary 2>/dev/null); FB_RC=$?
  CHECKS_RUN=$((CHECKS_RUN+1))
  FB_LEAK=${FB_SUMMARY%%$'\t'*}
  FB_DETAIL=${FB_SUMMARY#*$'\t'}
  if [ "$FB_RC" -ne 0 ] || [ -z "$FB_SUMMARY" ] || [[ "$FB_SUMMARY" != *$'\t'* ]] || ! [[ "$FB_LEAK" =~ ^[0-9]+$ ]]; then
    FB_LINE="FB台帳漏れチェック: 失敗（rc=$FB_RC）"; WARN+=("FB台帳漏れチェックが未完了（rc=$FB_RC）。python3 scripts/fb_ledger_gap_check.py で確認")
  else
    FB_LINE="FB台帳漏れチェック: $FB_DETAIL"
    [ "$FB_LEAK" != "0" ] && WARN+=("FB台帳の要対応 ${FB_LEAK} 件（python3 scripts/fb_ledger_gap_check.py で一覧）")
    case "$FB_DETAIL" in *台帳0本*) WARN+=("修正台帳が1本も見つからない（検索範囲か環境を確認）") ;; esac
  fi
fi

# 4. 実行記録（機械が分かる事実だけ） -----------------------------------------
COMMITS_24H=$(git log --since='24 hours ago' --oneline 2>/dev/null | wc -l | tr -d ' ')
FILES_24H=$(git log --since='24 hours ago' --name-only --pretty=format: 2>/dev/null | grep -c . || true)
REPO_REAL=$(pwd -P)
WRITE_OK=1
# 書込先の安全確認（mkdir の前）: vault → vault/.agents → runs の各段が symlink なら作らない・書かない
for pfx in vault vault/.agents vault/.agents/runs; do
  if [ -L "$pfx" ]; then WARN+=("$pfx が symlink のため実行記録を書かない"); WRITE_OK=0; break; fi
done
if [ "$WRITE_OK" -eq 1 ]; then
  mkdir -p "$RUN_DIR" 2>/dev/null || { WARN+=("実行記録ディレクトリを作れない: $RUN_DIR"); WRITE_OK=0; }
fi
# 書込直前の再確認（ヘッダ作成・追記の両方で呼ぶ）
write_guard() {
  local pfx
  for pfx in vault vault/.agents vault/.agents/runs; do [ -L "$pfx" ] && return 1; done
  [ -L "$RUN_DIR" ] && return 1
  [ -L "$RUN_FILE" ] && return 1
  [ -e "$RUN_FILE" ] && [ ! -f "$RUN_FILE" ] && return 1   # FIFO・デバイス・ディレクトリには書かない
  [ "$(cd "$RUN_DIR" 2>/dev/null && pwd -P)" = "$REPO_REAL/vault/.agents/runs/$MONTH" ] || return 1
  return 0
}
if [ "$WRITE_OK" -eq 1 ] && ! write_guard; then
  WARN+=("実行記録の書込先が repo 内 runs/ 配下の通常ファイルと確認できないため書かない: $RUN_FILE"); WRITE_OK=0
fi
if [ "$WRITE_OK" -eq 1 ] && [ ! -e "$RUN_FILE" ] && write_guard; then
  if ! {
    echo "# 実行記録 $TODAY ($HOST)"
    echo
    echo "> 機械が書く行（時刻・git・台帳漏れ）と、セッションが書く3行（やったこと・成果物・学び）を同じ日のファイルに積む。週次ダイジェスト（GH-2）が集計する。"
    echo
  } > "$RUN_FILE"; then
    WARN+=("実行記録のヘッダを書けなかった: $RUN_FILE"); WRITE_OK=0
  fi
fi
BLOCK=$({
  echo "## $NOW"
  echo "- git（push後）: branch=$BRANCH $SYNC_LINE / dirty=${DIRTY_TOTAL}（追跡変更 ${DIRTY_TRACKED}） / 直近24hのcommit=${COMMITS_24H}・変更ファイル=${FILES_24H}"
  echo "- 内部文書push: $PUSH_LINE"
  echo "- $FB_LINE"
  if [ ${#WARN[@]} -gt 0 ]; then
    for w in "${WARN[@]}"; do echo "- ⚠️ $w"; done
  fi
  echo "- やったこと: （セッションが追記）"
  echo "- 成果物: （セッションが追記）"
  echo "- 学び: （セッションが追記。learned-corrections へ反映したら出典を書く）"
  echo
})
if [ "$WRITE_OK" -eq 1 ]; then
  # 書込直前にもう一度確認（チェックと書込の間の差し替え対策）
  if write_guard; then
    printf '%s\n' "$BLOCK" >> "$RUN_FILE" || { WARN+=("実行記録を書けなかった: $RUN_FILE"); WRITE_OK=0; }
  else
    WARN+=("実行記録の書込先が直前に変わったため書かない"); WRITE_OK=0
  fi
fi

# 5. 要約 --------------------------------------------------------------------
if [ "$QUIET" -eq 0 ]; then
  echo "== session-end-check ($NOW @ $HOST) =="
  echo "git: $SYNC_LINE / dirty=$DIRTY_TOTAL"
  echo "push: $PUSH_LINE"
  echo "$FB_LINE"
  if [ "$WRITE_OK" -eq 1 ]; then echo "記録: $RUN_FILE"; else echo "記録: 未書込（理由は⚠️を参照）"; fi
fi
if [ ${#WARN[@]} -gt 0 ]; then
  for w in "${WARN[@]}"; do echo "⚠️ $w"; done
else
  echo "✅ 実行できたチェック（${CHECKS_RUN}本）では問題なし"
fi
exit 0

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""修正台帳（review-ledger）の「採用」指摘が、汎化先（ルール/チェックリスト）に転記されたかを機械判定する。

背景（松下 2026-09-15 実測）: 外部レビューで採用した指摘83件のうち80件がFB台帳に入っておらず、
台帳に無い指摘は提出前チェックに出ないため、W大阪で受けた指摘が翌日そのまま茗荷谷で再発した。
本スクリプトは GH-1（セッション終了フック）から毎回呼ばれ、漏れ件数を実行記録に残す。止めない。

判定の考え方（日付は見ない・内容で見る）:
  - 台帳の各行で 採否=採用 のものが対象
  - 汎化列が「-」= 汎化不要と明示判断 → 対象外（件数だけ出す）
  - 汎化列が空欄 = 判断漏れ → 漏れに数える
  - 汎化列に転記先がある → 転記先ファイルを repo 内で解決し（パス末尾一致→basename一意の順）、本文に指摘の
    特徴語が2語以上あれば「転記済み」、無ければ「転記漏れ」。解決できなければ「転記先不明」、同名ファイルが
    複数あれば「曖昧」。表の列数が8でない行は「列数不正」。要対応件数はこれら全部の合計（見逃しより誤警告を選ぶ）

使い方:
  python3 scripts/fb_ledger_gap_check.py               # 全台帳・人間向け表
  python3 scripts/fb_ledger_gap_check.py --brief       # 1〜3行（フック用）
  python3 scripts/fb_ledger_gap_check.py --since-days 7
  python3 scripts/fb_ledger_gap_check.py --json
  python3 scripts/fb_ledger_gap_check.py --strict      # 漏れがあれば exit 1

exit code: 0=正常（--strict で漏れなし） / 1=--strict で漏れあり / 2=repo解決不能
依存: Python 標準ライブラリのみ。書込は一切しない。
"""
from __future__ import annotations

import argparse
import json
import os
import re
import subprocess
import sys
import time
from pathlib import Path

COLUMNS = ["ID", "指摘", "採否", "修正箇所", "残存チェック語", "検証方法", "検証結果", "汎化"]
LEDGER_ROOTS = ("clients", "vault/.agents/reviews")
TARGET_ROOTS = (".claude", "docs", "article-pipeline/rules", "templates", "memory-topics", "vault/wiki", "vault/.agents/proposals", "knowledge")
TEXT_EXT = {".md", ".txt", ".yaml", ".yml", ".json"}
# 特徴語抽出: 4文字以上の連続する漢字・かな・英数（記号で区切る）
TOKEN_RE = re.compile(r"[一-龥ぁ-んァ-ヶーA-Za-z0-9_]{4,}")
ADOPTED_RE = re.compile(r"^採用(?:[（(].*)?$")
STOP_TOKENS = {"codex", "巡目", "1巡目", "2巡目", "3巡目", "採用", "不採用", "指摘", "修正", "出典", "レビュー", "レビュー元", "外部AI", "松下FB", "宮田FB", "wireframe", "html"}
STOP_TOKEN_CF = {t.casefold() for t in STOP_TOKENS}


def _inside(p: Path, root: Path) -> bool:
    """symlink を解決した実体が repo 内にあるか（repo 外へ抜ける symlink は読まない）。"""
    try:
        p.resolve().relative_to(root.resolve())
        return True
    except (OSError, ValueError):
        return False


def repo_root() -> Path:
    try:
        out = subprocess.run(["git", "rev-parse", "--show-toplevel"], capture_output=True, text=True, check=True)
        return Path(out.stdout.strip())
    except Exception:
        return Path(__file__).resolve().parents[1]


def parse_ledger(path: Path) -> list[dict]:
    """台帳md → 行dictのlist。verify_review_ledger.py と同じ表形式を前提にする。不正行は skipped に数える。"""
    rows: list[dict] = []
    try:
        lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
    except OSError:
        return rows
    for lineno, line in enumerate(lines, 1):
        s = line.strip()
        if not s.startswith("|"):
            continue
        cells = [c.replace("\x00", "|").strip() for c in s.replace("\\|", "\x00").strip("|").split("|")]
        if not cells:
            continue
        if cells[0] == "ID":  # ヘッダ行。見出し文言は台帳ごとに補足があり得るので列数だけ検証する
            if len(cells) != len(COLUMNS):
                rows.append({"_malformed": True, "_line": lineno, "_ncells": len(cells)})
            continue
        if all(set(c) <= set("-: ") and c != "" for c in cells):  # 区切り行 |---|---|
            continue
        if len(cells) != len(COLUMNS) or cells[0] == "":
            rows.append({"_malformed": True, "_line": lineno, "_ncells": len(cells)})
            continue
        rows.append({col: cells[i] for i, col in enumerate(COLUMNS)} | {"_line": lineno})
    return rows


def find_ledgers(root: Path, since_days: int | None) -> list[Path]:
    found: list[Path] = []
    cutoff = time.time() - since_days * 86400 if since_days is not None else None
    for base in LEDGER_ROOTS:
        d = root / base
        if not d.is_dir():
            continue
        for p in d.rglob("review-ledger*.md"):
            if any(part.startswith(".") for part in p.relative_to(d).parts[:-1]):
                continue
            if not _inside(p, root):
                continue
            try:
                if cutoff and p.stat().st_mtime < cutoff:
                    continue
            except OSError:
                print(f"⚠️ 読めない台帳候補を除外: {p}", file=sys.stderr)
                continue
            found.append(p)
    return sorted(found)


def build_target_index(root: Path) -> dict[str, list[Path]]:
    """basename（小文字・拡張子なし）→ 候補パス。汎化列の表記ゆれ（拡張子省略・§付き）に耐える。"""
    idx: dict[str, list[Path]] = {}
    for base in TARGET_ROOTS:
        d = root / base
        if not d.is_dir():
            continue
        for p in d.rglob("*"):
            if not p.is_file() or p.suffix.lower() not in TEXT_EXT or not _inside(p, root):
                continue
            key = p.stem.casefold()
            idx.setdefault(key, []).append(p)
    return idx


PATH_FRAG_RE = re.compile(r"[A-Za-z0-9_\-./]+\.(?:md|yaml|yml|json|txt)", re.IGNORECASE)
# 拡張子なしのASCIIパス（例 .claude/knowledge/lp/learned-corrections）。"/" を1つ以上含むもの
BARE_PATH_RE = re.compile(r"(?:\.claude|docs|templates|memory-topics|vault|article-pipeline|knowledge)/(?:[A-Za-z0-9_\-.]+/)*[A-Za-z0-9_\-.]+")
SPEC_SPLIT_RE = re.compile(r"[、,;・＋+→/&]|\s*(?:と|および|ならびに|及び)\s*(?=[A-Za-z.\u3040-\u30ff\u4e00-\u9fff])")
NOTE_RE = re.compile(r"「[^」]*」|（[^）]*）|\([^)]*\)")  # 引用・注記は転記先の指定ではない


def _resolve_path_frag(frag: str, idx: dict[str, list[Path]], root: Path) -> dict:
    """ASCIIパス断片（拡張子あり/なし）を解決。パスに"/"を含むなら末尾一致を必須にする（別ディレクトリの同名へ流さない）。"""
    fcf = frag.casefold().lstrip("./")
    cands = idx.get(Path(frag).stem.casefold(), [])
    exact = [c for c in cands if str(c.relative_to(root)).casefold().endswith(fcf)
             or str(c.with_suffix("").relative_to(root)).casefold().endswith(fcf)]
    exact = _dedup(exact)
    if exact:
        return {"frag": frag, "paths": exact, "ambiguous": len(exact) > 1}
    if "/" in frag:  # 明示パスなのに末尾一致しない → 不明（近い同名ファイルへ解決しない）
        return {"frag": frag, "paths": [], "ambiguous": False}
    if len(cands) == 1:  # 素のファイル名で一意
        return {"frag": frag, "paths": cands[:], "ambiguous": False}
    return {"frag": frag, "paths": cands[:], "ambiguous": len(cands) > 1}


def _resolve_words(segment: str, idx: dict[str, list[Path]], root: Path) -> dict:
    """語だけの指定を1件として解決。basename一意→同じ区画内の他の語でパスを絞る→複数なら曖昧。"""
    words = [f.strip() for f in re.split(r"[/、,・→\s§()（）「」]+", segment) if len(f.strip()) >= 2]
    hint_words = {w.casefold() for w in words}
    found: list[Path] = []
    ambiguous = False
    for w in words:
        stem = w.casefold()
        cands = idx.get(stem, [])
        if not cands:
            continue
        if len(cands) == 1:
            found.extend(cands)
            continue
        narrowed = [c for c in cands if any(h in str(c.relative_to(root)).casefold() for h in hint_words if h != stem)]
        if len(narrowed) == 1:
            found.extend(narrowed)
        else:
            ambiguous = True
            found.extend(narrowed or cands)
    found = _dedup(found)
    if len(found) > 1:  # 1区画=1転記先に正規化。複数実体に解けたら曖昧として漏れ側に倒す（any判定にしない）
        ambiguous = True
    return {"frag": segment, "paths": found, "ambiguous": ambiguous}


def resolve_specs(generalize_cell: str, idx: dict[str, list[Path]], root: Path) -> list[dict]:
    """汎化列を「指定単位」に分解して、それぞれ転記先候補を引く。
    戻り値: [{"frag": 指定文字列, "paths": [Path...], "ambiguous": bool}, ...]。paths が空なら未解決。
    手順: 1) 「」（）内は注記として除く 2) 拡張子ありASCIIパス→指定単位 3) 既知ルート接頭辞つきの拡張子なしパス→指定単位
    4) 残った文字列を区切り（、,・＋→/ と）で区画に分け、区画ごとに語で解決。**残りの区画も全部 specs に入れる**
    （明示パスの後ろに書かれた追加の転記先を捨てない＝all判定の対象にする）。"""
    body = NOTE_RE.sub(" ", generalize_cell)
    specs: list[dict] = []
    consumed = body
    for frag in PATH_FRAG_RE.findall(body):
        specs.append(_resolve_path_frag(frag, idx, root))
        consumed = consumed.replace(frag, " ", 1)
    for frag in BARE_PATH_RE.findall(consumed):
        specs.append(_resolve_path_frag(frag, idx, root))
        consumed = consumed.replace(frag, " ", 1)
    segments = [seg.strip() for seg in SPEC_SPLIT_RE.split(consumed) if seg.strip()]
    # 「に追記」「へ転記」のような接続語だけの区画は指定ではない
    filler = re.compile(r"^(?:(?:に|へ|を|の|で|と|も|にも|へも|側|末尾|冒頭|該当節|同上)?(?:追記|転記|反映|新設|移設|追加|昇格|更新|統合|記載|明記|する|した|済み?|予定|要)*|§\s*[\dA-Za-z.\-]+|#\S*|L\d+(?:-\d+)?|\d+行目?|\d+)$")
    for seg in segments:
        if filler.match(seg):
            continue
        specs.append(_resolve_words(seg, idx, root))
    if not specs:
        if not body.strip():  # 注記だけのセル → 転記先の指定が無い
            return [{"frag": generalize_cell, "paths": [], "ambiguous": False}]
        return [_resolve_words(body, idx, root)]
    return specs


def _dedup(paths: list[Path]) -> list[Path]:
    """実体（symlink解決後）で重複排除。同じ実体を指す symlink と実ファイルを別候補にしない。"""
    seen, out = set(), []
    for p in paths:
        try:
            key = p.resolve()
        except OSError:
            key = p
        if key not in seen:
            seen.add(key)
            out.append(p)
    return out


def feature_terms(text: str, max_terms: int = 5) -> list[str]:
    """指摘文から特徴語を最大N語。長い語を優先し、汎用語は除く。"""
    cands = [t for t in TOKEN_RE.findall(text) if t.casefold() not in STOP_TOKEN_CF]
    cands = sorted(set(cands), key=lambda t: (-len(t), t))
    return cands[:max_terms]


def is_transcribed(terms: list[str], targets: list[Path], cache: dict[Path, str]) -> bool:
    if len(terms) < 2:
        return False  # 特徴語が2語未満なら判定不能 → 漏れ側に倒す（見逃しより誤警告を選ぶ）
    for p in targets:
        body = cache.get(p)
        if body is None:
            try:
                body = p.read_text(encoding="utf-8", errors="replace").casefold()
            except OSError:
                body = ""
            cache[p] = body
        hits = sum(1 for t in terms if t.casefold() in body)
        if hits >= 2:
            return True
    return False


def analyze(root: Path, since_days: int | None) -> dict:
    ledgers = find_ledgers(root, since_days)
    idx = build_target_index(root)
    cache: dict[Path, str] = {}
    per_ledger, gaps = [], []
    keys = ("adopted", "no_generalize", "transcribed", "missing", "undecided", "unresolved", "ambiguous", "malformed")
    tot = {k: 0 for k in keys}
    for lp in ledgers:
        rows = parse_ledger(lp)
        c = {k: 0 for k in keys}
        for r in rows:
            if r.get("_malformed"):
                c["malformed"] += 1
                gaps.append({"ledger": str(lp.relative_to(root)), "id": "?", "line": r["_line"], "kind": f"表の列数不正（{r['_ncells']}列）", "generalize": "", "summary": "台帳の行を読めない。verify_review_ledger.py で台帳を直す"})
                continue
            if not ADOPTED_RE.match(r["採否"]):
                continue
            c["adopted"] += 1
            g = r["汎化"].strip()
            if g == "-":
                c["no_generalize"] += 1
                continue
            if g == "":
                c["undecided"] += 1
                gaps.append(_gap(lp, root, r, "汎化判断漏れ"))
                continue
            specs = resolve_specs(g, idx, root)
            if any(not sp["paths"] for sp in specs):
                c["unresolved"] += 1
                gaps.append(_gap(lp, root, r, "転記先不明"))
                continue
            if any(sp["ambiguous"] for sp in specs):
                c["ambiguous"] += 1
                gaps.append(_gap(lp, root, r, "転記先が曖昧（同名ファイル複数・パスで指定する）"))
                continue
            terms = feature_terms(r["指摘"])
            # 複数の転記先が指定されていたら、全部に転記されて初めて転記済み（any判定は見逃しになる）
            if all(is_transcribed(terms, sp["paths"], cache) for sp in specs):
                c["transcribed"] += 1
            else:
                c["missing"] += 1
                gaps.append(_gap(lp, root, r, "転記漏れ"))
        for k in tot:
            tot[k] += c[k]
        per_ledger.append({"ledger": str(lp.relative_to(root)), **c})
    denom = tot["adopted"] - tot["no_generalize"] + tot["malformed"]
    # 要対応=転記漏れ＋判断漏れ＋転記先不明＋曖昧＋列数不正（見逃しより誤警告を選ぶ）
    leak = tot["missing"] + tot["undecided"] + tot["unresolved"] + tot["ambiguous"] + tot["malformed"]
    return {
        "ledgers": len(ledgers),
        "totals": tot,
        "leak_count": leak,
        "leak_rate": (leak / denom) if denom else 0.0,
        "per_ledger": per_ledger,
        "gaps": gaps,
        "since_days": since_days,
    }


def _gap(lp: Path, root: Path, r: dict, kind: str) -> dict:
    return {
        "ledger": str(lp.relative_to(root)),
        "id": r["ID"],
        "line": r["_line"],
        "kind": kind,
        "generalize": r["汎化"],
        "summary": r["指摘"][:60],
    }


def render(res: dict, brief: bool) -> str:
    t = res["totals"]
    head = (f"FB台帳漏れチェック: 台帳{res['ledgers']}本 / 採用{t['adopted']} / 汎化不要{t['no_generalize']} / "
            f"転記済{t['transcribed']} / 転記漏れ{t['missing']} / 判断漏れ{t['undecided']} / 転記先不明{t['unresolved']} / "
            f"曖昧{t['ambiguous']} / 列数不正{t['malformed']} → 要対応 {res['leak_count']}件（要対応率 {res['leak_rate']:.0%}）")
    if brief:
        lines = [head]
        for g in res["gaps"][:3]:
            lines.append(f"  - {g['kind']} {g['ledger']}:{g['id']} 「{g['summary'][:30]}」→ {g['generalize'] or '（空欄）'}")
        if len(res["gaps"]) > 3:
            lines.append(f"  - …他{len(res['gaps']) - 3}件（--brief なしで全件）")
        return "\n".join(lines)
    lines = [head, "", "| 台帳 | 採用 | 汎化不要 | 転記済 | 転記漏れ | 判断漏れ | 転記先不明 | 曖昧 | 列数不正 |", "|---|---|---|---|---|---|---|---|---|"]
    for pl in res["per_ledger"]:
        lines.append(f"| {pl['ledger']} | {pl['adopted']} | {pl['no_generalize']} | {pl['transcribed']} | {pl['missing']} | {pl['undecided']} | {pl['unresolved']} | {pl['ambiguous']} | {pl['malformed']} |")
    if res["gaps"]:
        lines += ["", "漏れ一覧（種別 / 台帳:ID / 指摘 / 汎化先）:"]
        for g in res["gaps"]:
            lines.append(f"- {g['kind']} / {g['ledger']}:{g['id']}（L{g['line']}） / {g['summary']} / {g['generalize'] or '（空欄）'}")
    return "\n".join(lines)


def main(argv: list[str]) -> int:
    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
    ap.add_argument("--brief", action="store_true", help="フック用の短い出力")
    ap.add_argument("--summary", action="store_true", help="フック用: 要対応件数<TAB>要約1行 だけを出す")
    ap.add_argument("--json", action="store_true", help="JSONで出力")
    ap.add_argument("--strict", action="store_true", help="漏れがあれば exit 1")
    ap.add_argument("--since-days", type=int, default=None, help="更新日がN日以内の台帳だけ対象")
    a = ap.parse_args(argv)
    if a.since_days is not None and a.since_days < 0:
        print("❌ --since-days は0以上", file=sys.stderr)
        return 2
    root = repo_root()
    if not (root / ".git").exists():
        print("❌ git リポジトリが解決できません", file=sys.stderr)
        return 2
    res = analyze(root, a.since_days)
    if a.summary:
        t = res["totals"]
        zero = "⚠️台帳0本（検索範囲か環境を確認） " if res["ledgers"] == 0 else ""
        print(f"{res['leak_count']}\t{zero}台帳{res['ledgers']}本 / 採用{t['adopted']} / 汎化不要{t['no_generalize']} / 転記済{t['transcribed']} / "
              f"転記漏れ{t['missing']} / 判断漏れ{t['undecided']} / 転記先不明{t['unresolved']} / 曖昧{t['ambiguous']} / 列数不正{t['malformed']} / "
              f"要対応{res['leak_count']}件（{res['leak_rate']:.0%}）")
    else:
        print(json.dumps(res, ensure_ascii=False, indent=2) if a.json else render(res, a.brief))
    if a.strict and res["ledgers"] == 0:
        print("⚠️ 台帳が1本も見つからない（検索範囲か環境を確認）", file=sys.stderr)
        return 1
    if a.strict and res["leak_count"] > 0:
        return 1
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))

#!/bin/bash
# Apollo git-integrator — m/<id>（マシン別ブランチ）を origin main に自動統合する bot（G1-b I4）
#
# 設計根拠:
# - vault/.agents/proposals/2026-09-22-g1b-i4-git-integrator.md
#   （§1〜§6 ＋ 末尾「設計レビュー（codex・実装前1巡）と確定仕様」D1〜D10 が §1〜§6 を上書き）
# - scripts/lib/machine-branch.sh（APOLLO_MACHINE_IDS = 対象 m/* の allowlist・D2）
# - scripts/lib/codex-trailer-check.sh（D1 事前検査・merge commit の自己検査）
# - codex 実装 R1 反映: D1 は rev-list＋diff-tree -m で merge も検査 / セキュリティ系パスは --security /
#   raced 通知は raced_notified で送信成功まで再試行 / ロック解放は所有者（$$）確認つき
# - codex 実装 R2 反映: stale ロック回収は mv で原子化 / conflict・trailer・selfcheck 通知は push 結果まで保留
# - codex 実装 R3 反映: lib 呼び出しは全て TRAILER_NO_WORKTREE=1（作業ツリーの proposal を信用しない）/
#   テスト用の差し込み口は持たない（raced の再現はテスト側の偽 git ラッパ、通知の計数は --repo の
#   一時 clone に置く偽 scripts/discord-notify.py で行う）。外部から渡された文字列をシェルとして評価・実行しない
#
# 1周の動き:
#   ロック → fetch（refs/integrator/* 名前空間のみ・D3）→ allowlist の m/* を名前順に
#   trailer 事前検査（D1）→ merge-tree で合成（D4: attr.tree=第1親）→ commit-tree で merge commit
#   → lib で自己検査 → 1回だけ push（main の fast-forward のみ）→ 1周1行ログ
#
# 絶対条件:
# - force push をしない（+refspec・--force・--force-with-lease いずれも使わない）
# - stash / reset / checkout / merge（porcelain）/ update-ref を使わない
# - 作業ツリー・index・ローカル refs/heads/main・refs/remotes/*・FETCH_HEAD を一切触らない
#   （書くのは object DB・refs/integrator/*・logs/integrator/ のみ）
#
# Exit codes:
#   0 = ok / noop / raced / locked / dry_run
#   1 = 引数エラー / fetch_error / push_error

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
LIB="$SCRIPT_DIR/lib"
# shellcheck source=scripts/lib/machine-branch.sh
source "$LIB/machine-branch.sh"

REPO="$(cd "$SCRIPT_DIR/.." && pwd)"
# 触ったら codex-trailer-check.sh --security で検査する（Codex-Skip-Rationale 不可）パス（codex 実装 R1 High）
# 拡張子の無い hook 本体（scripts/git-hooks/commit-msg 等）も検査対象に含める
SECURITY_PATHSPECS="scripts/lib/codex-trailer-check.sh scripts/git-hooks/ scripts/git-integrator.sh scripts/lib/machine-branch.sh"
REMOTE="origin"
DRY_RUN=0
NO_NOTIFY=0

usage() {
  cat <<EOF
Usage: bash scripts/git-integrator.sh [OPTIONS]

allowlist（${APOLLO_MACHINE_IDS}）の m/<id> を origin main へ merge commit で統合します。
作業ツリー・index・ローカル main は触りません。

Options:
  --dry-run       合成まで実行し、push・通知・state/keys 書込はしない（通知予定は stdout）
  --repo DIR      対象 repo（既定: このスクリプトの親ディレクトリ）
  --remote NAME   remote 名（既定: origin）
  --no-notify     Discord 通知を送らない
  -h, --help      このメッセージを表示
EOF
}

while [ $# -gt 0 ]; do
  case "$1" in
    --dry-run)   DRY_RUN=1 ;;
    --repo)      [ $# -ge 2 ] || { usage >&2; exit 1; }; REPO="$2"; shift ;;
    --remote)    [ $# -ge 2 ] || { usage >&2; exit 1; }; REMOTE="$2"; shift ;;
    --no-notify) NO_NOTIFY=1 ;;
    -h|--help)   usage; exit 0 ;;
    *) echo "❌ Unknown option: $1" >&2; usage >&2; exit 1 ;;
  esac
  shift
done

REPO="$(cd "$REPO" && pwd)"
cd "$REPO"

STATE_DIR="$REPO/logs/integrator"
mkdir -p "$STATE_DIR"
LOCK_DIR="$STATE_DIR/.lock"
STATE_FILE="$STATE_DIR/state"
KEYS_FILE="$STATE_DIR/notified.keys"
LOG_FILE="$STATE_DIR/$(date +'%Y-%m-%d').log"

now_iso() { date +'%Y-%m-%dT%H:%M:%S%z'; }
log_line() { printf '%s %s\n' "$(now_iso)" "$1" >>"$LOG_FILE"; }

# ─────────────────────────────────────────────
# ロック（mkdir 原子取得 + pid・D8）
# ─────────────────────────────────────────────
LOCK_HELD=0
release_lock() {
  # 所有者確認: lock 内の pid が自分（$$）のときだけ消す（stale 回収で他者に取られた lock は残す）
  if [ "$LOCK_HELD" = "1" ]; then
    LOCK_HELD=0
    if [ "$(cat "$LOCK_DIR/pid" 2>/dev/null || true)" = "$$" ]; then
      rm -rf "$LOCK_DIR" 2>/dev/null || true
    fi
  fi
}
trap release_lock EXIT

take_lock() {
  if mkdir "$LOCK_DIR" 2>/dev/null; then
    printf '%s\n' "$$" >"$LOCK_DIR/pid"
    LOCK_HELD=1
    return 0
  fi
  return 1
}

lock_is_stale() {
  local pid cmd
  pid=$(cat "$LOCK_DIR/pid" 2>/dev/null || true)
  if [ -z "$pid" ]; then
    # mkdir 直後で pid 未記入の可能性 → 10分以上経っていれば stale
    [ -n "$(find "$LOCK_DIR" -maxdepth 0 -mmin +10 2>/dev/null)" ]
    return
  fi
  case "$pid" in *[!0-9]*) return 0 ;; esac
  kill -0 "$pid" 2>/dev/null || return 0
  cmd=$(ps -o command= -p "$pid" 2>/dev/null || true)
  case "$cmd" in *git-integrator*) return 1 ;; esac
  return 0  # PID 再利用（別プロセス）
}

# stale 回収は mv（rename は原子的＝同時に stale を見た複数プロセスのうち1つだけが成功）。
# mv に成功した側だけが退避先を消して mkdir で再取得し、失敗した側は locked で終わる（codex 実装 R2）。
if ! take_lock; then
  got=0
  if lock_is_stale; then
    STALE_DIR="$LOCK_DIR.stale.$$"
    if mv "$LOCK_DIR" "$STALE_DIR" 2>/dev/null; then
      rm -rf "$STALE_DIR" 2>/dev/null || true
      log_line "stale lock を回収"
      take_lock && got=1
    fi
  fi
  if [ "$got" != "1" ]; then
    log_line "status=locked pid=$(cat "$LOCK_DIR/pid" 2>/dev/null || echo '?')"
    exit 0
  fi
fi

# ─────────────────────────────────────────────
# 通知（Discord #エラー・重複防止キー・D7 マスク）
# ─────────────────────────────────────────────
mask_paths() {
  # clients/ の直後の1セグメントを <*> に（article-pipeline/clients/<x>/ も対象）
  sed -E 's#(^|[^[:alnum:]_.-])clients/[^/[:space:]]+#\1clients/<*>#g'
}

# notify <kind> <branch> <tip> <targets(改行区切り)> <body> [nodedupe]
notify() {
  local kind="$1" branch="$2" tip="$3" targets="$4" body="$5" nodedupe="${6:-}"
  local sorted key
  sorted=$(printf '%s\n' "$targets" | awk 'NF' | LC_ALL=C sort -u | paste -sd, -)
  key=$(printf '%s|%s|%s|%s' "$kind" "$branch" "$tip" "$sorted" | shasum -a 256 | awk '{print $1}')
  body=$(printf '%s\n' "$body" | mask_paths)

  if [ -z "$nodedupe" ] && [ -f "$KEYS_FILE" ] && grep -qxF "$key" "$KEYS_FILE"; then
    log_line "notify skip (既出キー) kind=$kind branch=$branch"
    return 0
  fi
  if [ "$DRY_RUN" = "1" ]; then
    printf '[dry-run] 通知予定 kind=%s branch=%s\n%s\n' "$kind" "$branch" "$body"
    return 0
  fi
  if [ "$NO_NOTIFY" = "1" ]; then
    log_line "notify suppressed (--no-notify) kind=$kind branch=$branch"
    return 0
  fi

  # 送信経路はこの1本だけ（環境変数でコマンドを差し替える口は持たない・codex R3 同型）。本文は位置引数
  local rc
  /usr/bin/env python3 "$REPO/scripts/discord-notify.py" --channel "エラー" "$body" >>"$LOG_FILE" 2>&1 && rc=0 || rc=$?
  if [ "$rc" -eq 0 ]; then
    [ -n "$nodedupe" ] || printf '%s\n' "$key" >>"$KEYS_FILE"
    NOTIFY_SENT=1
    log_line "notify sent kind=$kind branch=$branch"
  else
    log_line "notify failed rc=$rc kind=$kind branch=${branch}（次周で再送を試みる）"
  fi
  return 0
}

# ─────────────────────────────────────────────
# 1周分の記録
# ─────────────────────────────────────────────
BASE0=""
BASE=""
INTEGRATED=()
SKIPPED=()
PUSHED="-"
NOTIFY_SENT=0

# 保留通知（codex 実装 R2）: conflict / trailer / selfcheck の通知と notified.keys 書込は push の結果が
# 出るまで保留する。push 成功・push 不要（noop）の周だけ送る。raced / push_error なら捨てる
# （次周で最新 main から判定し直す＝仮 base に対する判定を通知・キー化しない）。
PEND_KIND=(); PEND_BRANCH=(); PEND_TIP=(); PEND_TARGETS=(); PEND_BODY=()
queue_notify() { # queue_notify <kind> <branch> <tip> <targets> <body>
  PEND_KIND+=("$1"); PEND_BRANCH+=("$2"); PEND_TIP+=("$3"); PEND_TARGETS+=("$4"); PEND_BODY+=("$5")
}
flush_pending() {
  local i=0
  while [ "$i" -lt "${#PEND_KIND[@]}" ]; do
    notify "${PEND_KIND[$i]}" "${PEND_BRANCH[$i]}" "${PEND_TIP[$i]}" "${PEND_TARGETS[$i]}" "${PEND_BODY[$i]}"
    i=$((i + 1))
  done
}
discard_pending() {
  if [ "${#PEND_KIND[@]}" -gt 0 ]; then
    log_line "保留通知 ${#PEND_KIND[@]} 件を破棄（push 未成功のため次周で再判定）"
  fi
}

join_or_dash() {
  if [ $# -eq 0 ]; then printf -- '-'; else local IFS=,; printf '%s' "$*"; fi
}

finish() {
  local status="$1"
  log_line "status=$status base=${BASE0:0:9} head=${BASE:0:9} integrated=$(join_or_dash ${INTEGRATED[@]+"${INTEGRATED[@]}"}) skipped=$(join_or_dash ${SKIPPED[@]+"${SKIPPED[@]}"}) pushed=$PUSHED"
}

# D5 state（codex 実装 R1 Medium 反映）: consecutive_raced=N / raced_notified=0|1
#   raced 通知は「consecutive_raced>=3 かつ未通知」で送り、送信成功時だけ raced_notified=1
#   （3周目の送信失敗で通知が永久に落ちるのを防ぐ）。ok / noop で両方 0 に戻す。
read_state() { # read_state <key>
  local n
  n=$(sed -n "s/^$1=\\([0-9][0-9]*\\)\$/\\1/p" "$STATE_FILE" 2>/dev/null | head -1)
  printf '%s' "${n:-0}"
}
write_state() { # write_state <consecutive_raced> <raced_notified>
  [ "$DRY_RUN" = "1" ] && return 0
  printf 'consecutive_raced=%s\nraced_notified=%s\n' "$1" "$2" >"$STATE_FILE"
}

# ─────────────────────────────────────────────
# fetch（D3: refs/integrator/* のみ。refs/remotes/* と FETCH_HEAD は触らない）
# ─────────────────────────────────────────────
fetch_err=$(git fetch --prune --no-write-fetch-head "$REMOTE" \
  '+refs/heads/main:refs/integrator/main' \
  '+refs/heads/m/*:refs/integrator/m/*' 2>&1 >/dev/null) && rc=0 || rc=$?
if [ "$rc" -ne 0 ]; then
  log_line "fetch 失敗 rc=$rc: $(printf '%s' "$fetch_err" | tr '\n' ' ' | cut -c1-300)"
  finish "fetch_error"
  exit 1
fi

BASE0=$(git rev-parse --verify -q 'refs/integrator/main^{commit}') && rc=0 || rc=$?
if [ "$rc" -ne 0 ] || [ -z "$BASE0" ]; then
  log_line "refs/integrator/main 解決失敗"
  finish "fetch_error"
  exit 1
fi
BASE="$BASE0"

IDS=$(printf '%s\n' $APOLLO_MACHINE_IDS | LC_ALL=C sort)

for id in $IDS; do
  branch="m/$id"
  tip=$(git rev-parse --verify -q "refs/integrator/$branch^{commit}") && rc=0 || rc=$?
  [ "$rc" -eq 0 ] && [ -n "$tip" ] || continue   # ブランチ無し → 無視
  tip9="${tip:0:9}"

  # 取り込み済み
  if git merge-base --is-ancestor "$tip" "$BASE"; then
    continue
  fi

  # D1: trailer 事前検査（codex 実装 R1 Critical 反映）
  #   `git log <range> -- <pathspec>` は履歴簡略化で merge を落とす（第1親と TREESAME な evil merge が
  #   素通りする）。そこで範囲内の全 commit を列挙し、diff-tree -m（merge は各親との差分）で
  #   scripts/*.py・scripts/*.sh（CI と同じ pathspec）かセキュリティ系パスを触るものを lib に掛ける。
  #   セキュリティ系（検査・統合・hook そのもの）を触る commit は --security（Skip-Rationale 不可）。
  commits=$(git rev-list "$BASE..$tip") && rc=0 || rc=$?
  if [ "$rc" -ne 0 ]; then
    SKIPPED+=("$id:error"); log_line "detail $branch($tip9) rev-list 失敗 rc=$rc"; continue
  fi
  bad=()
  scan_err=0
  for h in $commits; do
    touched=$(git diff-tree -m -r --root --name-only --no-commit-id "$h" -- 'scripts/*.py' 'scripts/*.sh') && rc=0 || rc=$?
    [ "$rc" -eq 0 ] || { scan_err=1; break; }
    sec=$(git diff-tree -m -r --root --name-only --no-commit-id "$h" -- $SECURITY_PATHSPECS) && rc=0 || rc=$?
    [ "$rc" -eq 0 ] || { scan_err=1; break; }
    [ -n "$touched" ] || [ -n "$sec" ] || continue
    if [ -n "$sec" ]; then
      out=$(TRAILER_NO_WORKTREE=1 TRAILER_TREE_REF="$tip" bash "$LIB/codex-trailer-check.sh" "$h" --security 2>&1) && rc=0 || rc=$?
    else
      out=$(TRAILER_NO_WORKTREE=1 TRAILER_TREE_REF="$tip" bash "$LIB/codex-trailer-check.sh" "$h" 2>&1) && rc=0 || rc=$?
    fi
    if [ "$rc" -ne 0 ]; then
      bad+=("$h")
      log_line "detail $branch($tip9) trailer NG commit=$h rc=$rc security=$([ -n "$sec" ] && echo 1 || echo 0): $(printf '%s' "$out" | tr '\n' ' ' | cut -c1-200)"
    fi
  done
  if [ "$scan_err" = "1" ]; then
    SKIPPED+=("$id:error"); log_line "detail $branch($tip9) diff-tree 失敗"; continue
  fi
  if [ "${#bad[@]}" -gt 0 ]; then
    SKIPPED+=("$id:trailer")
    first="${bad[0]}"
    queue_notify "trailer" "$branch" "$tip" "$(printf '%s\n' "${bad[@]}")" \
      "🚨 git-integrator: $branch ($tip9) に Codex trailer の無い scripts 変更 commit ${first:0:9}$([ "${#bad[@]}" -gt 1 ] && printf ' ほか%s件' "$(( ${#bad[@]} - 1 ))") があるため統合を保留（main は未変更）。該当 commit に Codex レビュー＋trailer を付け直して $branch へ push"
    continue
  fi

  # 合成（D4: 属性は第1親の tree から）
  mt=$(git -c core.quotepath=false -c attr.tree="$BASE" merge-tree --write-tree --name-only "$BASE" "$tip" 2>&1) && rc=0 || rc=$?
  if [ "$rc" -eq 1 ]; then
    files=$(printf '%s\n' "$mt" | awk 'NR==1{next} /^$/{exit} {print}' | LC_ALL=C sort -u)
    SKIPPED+=("$id:conflict")
    log_line "detail $branch($tip9) conflict files=$(printf '%s\n' "$files" | paste -sd, -)"
    queue_notify "conflict" "$branch" "$tip" "$files" \
      "🚨 git-integrator: $branch ($tip9) が main と衝突したため統合を保留（main は未変更）
衝突ファイル:
$(printf '%s\n' "$files" | sed 's/^/- /')
解決手順: 該当機で \`git fetch origin && git merge origin/main\` → 衝突を解決して commit → \`scripts/git-sync-doctor.sh --end\`（$branch へ push）→ 次の統合周回（5分毎）で自動取り込み。main は未変更"
    continue
  elif [ "$rc" -ne 0 ]; then
    SKIPPED+=("$id:error")
    log_line "detail $branch($tip9) merge-tree rc=$rc: $(printf '%s' "$mt" | tr '\n' ' ' | cut -c1-200)"
    continue
  fi
  tree=$(printf '%s\n' "$mt" | head -1)

  new=$(GIT_AUTHOR_NAME="Apollo Integrator (2gouki)" GIT_COMMITTER_NAME="Apollo Integrator (2gouki)" \
        GIT_AUTHOR_EMAIL="［伏せ字］" GIT_COMMITTER_EMAIL="［伏せ字］" \
        git commit-tree "$tree" -p "$BASE" -p "$tip" -m "Integrate $branch ($tip9) by git-integrator" 2>&1) && rc=0 || rc=$?
  if [ "$rc" -ne 0 ]; then
    SKIPPED+=("$id:error")
    log_line "detail $branch($tip9) commit-tree rc=$rc: $(printf '%s' "$new" | tr '\n' ' ' | cut -c1-200)"
    continue
  fi

  # 自己検査（自動 merge 免除で通るはず。通らなければこの m/* を捨てる）
  out=$(TRAILER_NO_WORKTREE=1 bash "$LIB/codex-trailer-check.sh" "$new" 2>&1) && rc=0 || rc=$?
  if [ "$rc" -ne 0 ]; then
    SKIPPED+=("$id:selfcheck")
    log_line "detail $branch($tip9) selfcheck NG rc=$rc merge=${new:0:9}: $(printf '%s' "$out" | tr '\n' ' ' | cut -c1-200)"
    # 重複防止キーは kind|branch|tip|"selfcheck"（merge commit の hash は commit-tree の時刻で毎周変わり連投になるため
    # 含めない）。tip が変わるまで再通知しない。
    queue_notify "selfcheck" "$branch" "$tip" "selfcheck" \
      "🚨 git-integrator: $branch ($tip9) を合成した merge commit が trailer 自己検査（codex-trailer-check.sh）を通らないため統合を保留（main は未変更）。integrator か共通 lib の不整合の可能性。ローカルログ logs/integrator/ を確認"
    continue
  fi

  BASE="$new"
  INTEGRATED+=("$id")
done

# ─────────────────────────────────────────────
# push（fast-forward のみ・force なし）
# ─────────────────────────────────────────────
if [ "$BASE" = "$BASE0" ]; then
  # push 不要の周: 保留通知を送る（dry-run は stdout に予定を出すだけ）
  flush_pending
  if [ "$DRY_RUN" = "1" ]; then
    finish "dry_run"
  else
    write_state 0 0
    finish "noop"
  fi
  exit 0
fi

if [ "$DRY_RUN" = "1" ]; then
  printf '[dry-run] push 予定: %s -> %s main (integrated=%s)\n' "${BASE:0:9}" "$REMOTE" "$(join_or_dash "${INTEGRATED[@]}")"
  flush_pending   # 実走では push 成功時にだけ送る通知
  finish "dry_run"
  exit 0
fi

push_err=$(git push "$REMOTE" "$BASE:refs/heads/main" 2>&1 >/dev/null) && rc=0 || rc=$?
if [ "$rc" -eq 0 ]; then
  PUSHED="${BASE:0:9}"
  write_state 0 0
  flush_pending
  finish "ok"
  exit 0
fi

if printf '%s' "$push_err" | grep -qE 'rejected|non-fast-forward|fetch first'; then
  n=$(( $(read_state consecutive_raced) + 1 ))
  notified=$(read_state raced_notified)
  discard_pending
  finish "raced"
  if [ "$n" -ge 3 ] && [ "$notified" != "1" ]; then
    NOTIFY_SENT=0
    notify "raced" "main" "$BASE0" "consecutive_raced=$n" \
      "⚠️ git-integrator: ${n}周連続で main への push が競合（raced）。I5 未展開の機がまだ main に直 push している可能性。main は未変更（統合は次周で再試行）" \
      nodedupe
    if [ "$NOTIFY_SENT" = "1" ]; then notified=1; fi
  fi
  write_state "$n" "$notified"
  exit 0
fi

log_line "push 失敗 rc=$rc: $(printf '%s' "$push_err" | tr '\n' ' ' | cut -c1-300)"
discard_pending
finish "push_error"
exit 1

#!/bin/bash
# Apollo ロードマップ運転機（roadmap runner）— 人が書いたキューの順に、前のタスクの完了条件（dod）が
# 機械で確認できたら、次のタスクの Claude を非対話（claude -p）で自動起動する。2号機 cron 専用。
#
# 設計根拠（仕様の正）:
# - vault/.agents/proposals/2026-09-22-roadmap-runner-impl.md 末尾「宮田回答（2026-09-22）と確定仕様」
#   （本文・表を上書きする最終仕様: ファイル・キュー yaml の形式・1周の手順1〜9・state.json のスキーマ・DoD）
# - 背景: vault/.agents/proposals/2026-09-22-roadmap-runner-devspec.md
# - 流儀の手本: scripts/git-integrator.sh（ロック・通知の成功判定・state の原子書込・clients マスク）
#
# 構成: この bash は引数の解釈と Python の確認だけを行い、判定・状態・起動は同じファイルに埋め込んだ Python で行う。
#   - yaml は Homebrew の Python（/opt/homebrew/bin/python3・PyYAML あり）で読む。無ければ fail-closed（起動しない）
#   - キューの値はシェルに渡さない。git・tmux・通知は全て引数リスト（subprocess の list 形式）で呼ぶ＝シェル評価なし
#   - 起動文はファイルに書き、tmux → scripts/lib/runner-launch.sh → `claude -p ... -- "<起動文>"` の順に
#     「1個の引数」として渡すだけ（eval・sh -c なし）
#
# 1周（10分ごと・cron 4-59/10）:
#   1 ロック（logs/runner/.lock に fcntl.flock の非ブロッキング排他。プロセスが死ねば OS が解放＝stale 判定なし。
#     取れなければ「別の運転機が実行中」で exit 0）
#   2 state.json を読む（壊れていたら安全停止＋#エラー に1通。以後は人が直すまで何もしない）
#   3 busy: claude プロセスがある、または tmux `runner` がある → 何もしない。runner 所有（tmux runner の pane の実 PID が
#     state の running タスクの pid と一致し生存）でない busy が6時間 → stalled を1通
#   終了判定: runner-launch.sh が claude 終了後に <ログ>.done（rc・終了時刻）を書く。.done 無しの終了は異常終了として扱う
#   🛑 宮田判断待ち（<タスク id>-<数字>）: 形式外・他タスクの ID・止まった時点で台帳に既にある ID は blocked
#   起動方式: LAUNCH_POLICY="no-sandbox" で起動（宮田判断 RUNNER-C1＝(a)）。"pending" は緊急停止用の値（下の定数の説明を参照）
#   起動前: 作業ツリーが dirty なら起動保留（#エラー に1通）／claude 不在・tmux 起動失敗は #エラー に1通・3回で blocked
#   3b 復旧記録（FIX1 §1-5）: scripts/queue/recovery_apply.py があれば --check で呼び、exit 0 以外（applied のまま残った
#     項目がある・実行できない）なら何も起動しない（status=recovery_pending・#エラー に1通・同じ内容は再送しない）。無ければ何もしない
#   4 統合 bot の state で consecutive_fail >= 3 → 新規起動しない
#   5 キューの先頭から最初の未完了タスクを処理（needs_decision / 終了判定 / dod / 起動）
#   6〜7 起動（起動文＝prompt＋共通の約束）／8 通知（成功判定は統合 bot と同じ）／9 state の原子書込
#   統合の判定（FIX1）: dod の integrated を見る直前に origin の main を自分で fetch する（refs/runner/origin-main へ・
#     refs/remotes/* と FETCH_HEAD は触らない）。rc=0 で終わったセッションの完了見出しが 2号機の HEAD には在るが main に
#     まだ無い・2号機の commit が main に無い・fetch に失敗した → integrating（統合待ち・通知なし）で次の周に再判定。
#     INTEGRATING_MAX_SEC（60分）続いたら blocked（理由に main・HEAD の sha・fetch の成否・FETCH_HEAD の時刻・統合 bot の最後のログ行）
#
# 人の操作:
#   - blocked からの再開: logs/runner/state.json の該当タスクの "state" を "todo"（必要なら "quick_fail" を 0）に戻す
#   - キューの追加・変更: scripts/runner/roadmap-queue.yaml を Codex-Review trailer 付き commit で
#
# 絶対条件: rm / mv / git の設定コマンド / git の統合コマンドを使わない。外部送信は discord-notify.py の
#   チャンネル「エラー」「宮田-作業」だけ（本文は clients/<*> マスク）。
#
# Options:
#   --dry-run       判定と予定を表示するだけ（起動・通知・state 書込・ロック取得をしない）
#   --queue FILE    キュー yaml（既定: <repo>/scripts/runner/roadmap-queue.yaml）
#   --state FILE    state.json（既定: <repo>/logs/runner/state.json）
#   --repo DIR      対象 repo（既定: このスクリプトの親ディレクトリ）
#   --no-notify     Discord 通知を送らない（通知済みフラグも立てない）
#
# Exit codes: 0 = 通常（noop・busy・locked・起動・待機を含む）/ 1 = 引数エラー・Python 不在・state 破損・キュー破損

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
REPO="$(cd "$SCRIPT_DIR/.." && pwd)"
QUEUE=""
STATE=""
DRY_RUN=0
NO_NOTIFY=0

usage() {
  cat <<'EOF'
Usage: bash scripts/roadmap-runner.sh [--dry-run] [--queue FILE] [--state FILE] [--repo DIR] [--no-notify]
EOF
}

while [ $# -gt 0 ]; do
  case "$1" in
    --dry-run)   DRY_RUN=1 ;;
    --queue)     [ $# -ge 2 ] || { usage >&2; exit 1; }; QUEUE="$2"; shift ;;
    --state)     [ $# -ge 2 ] || { usage >&2; exit 1; }; STATE="$2"; shift ;;
    --repo)      [ $# -ge 2 ] || { usage >&2; exit 1; }; REPO="$2"; shift ;;
    --no-notify) NO_NOTIFY=1 ;;
    -h|--help)   usage; exit 0 ;;
    *) echo "❌ Unknown option: $1" >&2; usage >&2; exit 1 ;;
  esac
  shift
done

REPO="$(cd "$REPO" && pwd)"
[ -n "$QUEUE" ] || QUEUE="$REPO/scripts/runner/roadmap-queue.yaml"
[ -n "$STATE" ] || STATE="$REPO/logs/runner/state.json"

# 入れ子の禁止（codex R3 High）: 運転機が起動した Claude（runner-launch.sh が APOLLO_RUNNER_CHILD=1 を渡す）の中からは動かない
if [ "${APOLLO_RUNNER_CHILD:-}" = "1" ]; then
  echo "$(date +'%Y-%m-%dT%H:%M:%S%z') status=child 運転機が起動した Claude の中からは動かない（何もしない）"
  exit 0
fi
# 2号機専用（codex R3 Critical）: crontab-apollo.txt は全機共通で installer がパスを置き換えるため、他の機でも cron に入り得る。
#   machine id（git の apollo.machineId、無ければ hostname）が 2gouki でなければ何もしない。未解決も何もしない（fail-closed）
# shellcheck source=scripts/lib/machine-branch.sh
source "$SCRIPT_DIR/lib/machine-branch.sh"
MID="$(cd "$REPO" && apollo_machine_id 2>/dev/null || true)"
if [ "$MID" != "2gouki" ]; then
  echo "$(date +'%Y-%m-%dT%H:%M:%S%z') status=not_2gouki machine=${MID:-未解決} 運転機は2号機専用（何もしない）"
  exit 0
fi

PY=/opt/homebrew/bin/python3
if [ ! -x "$PY" ] || ! "$PY" -c 'import yaml' >/dev/null 2>&1; then
  echo "$(date +'%Y-%m-%dT%H:%M:%S%z') status=no_python ${PY} が無いか PyYAML が無い（fail-closed・起動しない）"
  exit 1
fi

ENGINE=""
IFS= read -r -d '' ENGINE <<'PYEOF' || true
import collections, datetime, fcntl, hashlib, json, os, re, shutil, subprocess, sys
import yaml

_, MARK, SCRIPT_DIR, REPO, QUEUE, STATE, DRY_S, NO_NOTIFY_S = sys.argv
DRY = DRY_S == "1"
NO_NOTIFY = NO_NOTIFY_S == "1"
QUEUE = os.path.abspath(QUEUE)
STATE = os.path.abspath(STATE)
REPO = os.path.realpath(REPO)
os.chdir(REPO)

STATE_DIR = os.path.dirname(STATE)
LOG_DIR = STATE_DIR                      # セッションログと起動文もここ（既定 logs/runner/）
LOCK_FILE = os.path.join(STATE_DIR, ".lock")
BROKEN_MARK = STATE + ".broken-notified"
LEDGER = "vault/.agents/handover/chats/README.md"
INTEGRATOR_STATE = os.path.join(REPO, "logs", "integrator", "state")
INTEGRATOR_LOG_DIR = os.path.join(REPO, "logs", "integrator")
ORIGIN_MAIN = "refs/remotes/origin/main"
FETCH_HOLD = "判定保留: "              # fetch 失敗時、古い origin/main では充足していても done にしない理由の接頭辞（FIX1 codex R1）
FRESH_MAIN = "refs/runner/origin-main"      # 判定用に自分で fetch した origin の main（FIX1。統合 bot の refs/integrator/* と同じ流儀）
MY_BRANCH = "refs/remotes/origin/m/2gouki"
RECOVERY = os.path.join("scripts", "queue", "recovery_apply.py")
TMUX_SESSION = "runner"

QUICK_SEC = 5 * 60            # 起動からこの秒数以内に終了し新 commit なし＝起動直後の失敗
RETRY_SEC = 60 * 60           # 起動直後の失敗からの再起動待ち
QUICK_MAX = 3                 # 起動直後の失敗がこの回数で blocked
STALL_SEC = 6 * 60 * 60       # runner 所有でない busy がこの時間続いたら stalled 通知
KEEP_SEC = 30 * 24 * 60 * 60  # セッションログ・起動文の保持
TEST_TIMEOUT = 3600
LAUNCH_FAIL_MAX = 3            # claude 不在・tmux 起動失敗がこの回数続いたら blocked
FETCH_TIMEOUT = 60             # dod 判定前の fetch（FIX1）
INTEGRATING_MAX_SEC = 60 * 60  # 統合待ちがこの時間続いたら blocked（FIX1・6周）
RECOVERY_TIMEOUT = 120

# ───────────── 起動方式（宮田判断 RUNNER-C1＝(a)・2026-09-22）─────────────
# 起動した Claude の外部送信を OS レベルで止めるサンドボックス（strictAllowlist）は、その中で git の SSH push と codex が
# 動かないことを実機で確認済み。宮田判断 (a) により、サンドボックスなしで起動する。外部送信の禁止は
# --disallowedTools（外部送信系）・--strict-mcp-config・起動文の約束・project の settings deny の多重で担保し、
# codex R1 の C1 は「既知の残存リスク」（impl.md に記録）。値:
#   "no-sandbox" … 起動する（本番の値。--disallowedTools・--strict-mcp-config まで・OS レベルの強制なし）
#   "pending"    … どのタスクも Claude を起動しない（起動すべき場面では state を変えず・通知もせず、ログに1行だけ）。
#                  緊急停止用。scripts/test_roadmap_runner.sh は一時コピーのこの行を書き換えて止めの動作を確かめる
#   それ以外      … 起動しない（fail-closed）。将来の "sandbox"（運転機が codex を代行する設計・据置）は判断後に実装する
# 外から切り替える口（環境変数・オプション）は持たない。この値の変更は scripts 変更＝Codex 審査を経て main に入る。
LAUNCH_POLICY = "no-sandbox"

TASK_STATES = ("todo", "running", "integrating", "done", "waiting_decision", "blocked")
TASK_KEYS = {"id", "title", "kickoff", "prompt", "dod", "needs_decision", "note"}
REQUIRED_KEYS = ("id", "title", "kickoff", "prompt")
ID_RE = re.compile(r"^[A-Za-z0-9_-]+$")
PATH_RE = re.compile(r"^[A-Za-z0-9_.][A-Za-z0-9_./+@-]*$")
TEST_RE = re.compile(r"^scripts/test_[A-Za-z0-9_.-]+\.(sh|py)$")
# reflog の件名のうち「この repo で commit を作った」記録（rebase の start/finish は既存 commit を指すので除く）
LOCAL_RE = re.compile(r"^(commit|cherry-pick|revert)\b|^rebase( -i)? \((pick|continue|reword|edit|squash|fixup)\)")
STOP_RE = re.compile(r"🛑\s*宮田判断待ち")
STOP_ID_RE = re.compile(r"🛑\s*宮田判断待ち（([^）]*)）")   # ID の形式は <タスク id>-<数字> だけ有効（stop_id_ok）

PLAN = []          # dry-run・busy 時に表示する「次にすること」


def now():
    return datetime.datetime.now().astimezone()


def iso(dt):
    return dt.isoformat(timespec="seconds")


def parse_iso(s):
    try:
        return datetime.datetime.fromisoformat(s) if s else None
    except (TypeError, ValueError):
        return None


def out(msg):
    print("%s %s%s" % (iso(now()), "[dry-run] " if DRY else "", msg), flush=True)


def plan(msg):
    PLAN.append(msg)
    out(msg)


def mask(s):
    return re.sub(r"(^|[^0-9A-Za-z_.-])clients/[^/\s]+", r"\1clients/<*>", s)


def run(cmd, timeout=120, **kw):
    try:
        p = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout, **kw)
        return p.returncode, p.stdout, p.stderr
    except (OSError, subprocess.SubprocessError) as e:
        return 127, "", str(e)


def git(*args):
    rc, o, _ = run(["git", "-C", REPO] + list(args))
    return rc, o


# ───────────── ロック（fcntl.flock・codex R1 Critical）─────────────
# logs/runner/.lock に非ブロッキングの排他 flock を掛ける。プロセスが死ねば OS が解放するので stale 判定は不要
# （旧方式の「pid＋ps のコマンド表示」は表示の切れで生死を誤判定し、二重起動の経路になった）。
# fd は Python の既定で close-on-exec（PEP 446）なので、起動した tmux や claude にロックは引き継がれない。
LOCK_FD = None


def take_lock():
    global LOCK_FD
    fd = os.open(LOCK_FILE, os.O_RDWR | os.O_CREAT, 0o600)
    try:
        fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
    except OSError:
        os.close(fd)
        return False
    LOCK_FD = fd
    return True


def release_lock():
    global LOCK_FD
    if LOCK_FD is not None:
        try:
            fcntl.flock(LOCK_FD, fcntl.LOCK_UN)
        finally:
            os.close(LOCK_FD)
            LOCK_FD = None


# ───────────── 通知（統合 bot と同じ成功判定・clients マスク）─────────────
def notify(channel, body):
    assert channel in ("エラー", "宮田-作業")
    body = mask(body)
    if DRY:
        out("通知予定 #%s: %s" % (channel, body.replace("\n", " ")))
        return False
    if NO_NOTIFY:
        out("notify suppressed (--no-notify) #%s" % channel)
        return False
    rc, o, e = run(["/usr/bin/env", "python3", os.path.join(REPO, "scripts", "discord-notify.py"),
                    "--channel", channel, body], timeout=120)
    text = (o or "") + (e or "")
    if text.strip():
        out("notify output: " + mask(text.strip()).replace("\n", " ")[:300])
    # 成否は discord-notify.py の最後の結果行で判定する（DoD② 実測で判明: #宮田-作業 は webhook が無く、[WARN] のあと
    # Bot Token のフォールバックで送信に成功する。[WARN] の有無で判定すると成功を失敗とみなし、毎周再送していた）。
    # 成功＝exit 0・[ERROR] なし・「Discord通知送信完了」あり・「Discord通知送信失敗」なし
    if rc == 0 and ("[ERROR]" in text or "Discord通知送信完了" not in text or "Discord通知送信失敗" in text):
        rc = 99
    if rc == 0:
        out("notify sent #%s" % channel)
        return True
    out("notify failed rc=%s #%s（次周で再送を試みる）" % (rc, channel))
    return False


# ───────────── state.json（スキーマ検証・原子書込）─────────────
def empty_state():
    return {"version": 1, "tasks": {}, "stalled_since": None, "stalled_notified": False,
            "last_run": None, "last_action": None, "dirty_notified": False}


def new_rec():
    return {"state": "todo", "attempts": 0, "quick_fail": 0, "started_at": None, "finished_at": None,
            "decision_id": None, "notified": {"waiting": False, "blocked": False}, "tmux": None, "pid": None,
            "head_at_start": None, "state_changed_at": None, "stops_at_start": [], "log": None, "reason": None,
            "launch_fail": 0, "launch_fail_notified": False, "integrating_since": None}


def _is_int(v):
    return isinstance(v, int) and not isinstance(v, bool) and v >= 0


def _opt_str(v):
    return v is None or isinstance(v, str)


def state_valid(d):
    if not isinstance(d, dict) or d.get("version") != 1 or not isinstance(d.get("tasks"), dict):
        return False
    for k in ("stalled_since", "last_run", "last_action", "queue_error_key", "recovery_key"):
        if not _opt_str(d.get(k)):
            return False
    if not isinstance(d.get("stalled_notified", False), bool):
        return False
    if not isinstance(d.get("dirty_notified", False), bool):
        return False
    for tid, r in d["tasks"].items():
        if not ID_RE.match(tid) or not isinstance(r, dict):
            return False
        if r.get("state") not in TASK_STATES:
            return False
        if not all(_is_int(r.get(k, 0)) for k in ("attempts", "quick_fail", "launch_fail")):
            return False
        n = r.get("notified", {"waiting": False, "blocked": False})
        if not isinstance(n, dict) or not all(isinstance(n.get(k, False), bool) for k in ("waiting", "blocked")):
            return False
        for k in ("started_at", "finished_at", "decision_id", "tmux", "head_at_start", "state_changed_at",
                  "log", "reason", "integrating_since"):
            if not _opt_str(r.get(k)):
                return False
        if not isinstance(r.get("launch_fail_notified", False), bool):
            return False
        if r.get("pid") is not None and not _is_int(r.get("pid")):
            return False
        s = r.get("stops_at_start", [])
        if not isinstance(s, list) or not all(isinstance(x, str) for x in s):
            return False
    return True


def load_state():
    """(state, broken_text)。無ければ空の state。壊れていれば (None, 中身)。"""
    try:
        with open(STATE, "rb") as f:
            raw = f.read()
    except FileNotFoundError:
        return empty_state(), None
    try:
        d = json.loads(raw.decode("utf-8"))
    except (UnicodeDecodeError, ValueError):
        return None, raw
    if not state_valid(d):
        return None, raw
    base = empty_state()
    base.update(d)
    for tid, r in list(base["tasks"].items()):
        full = new_rec()
        full.update(r)
        full["notified"] = dict(new_rec()["notified"], **(r.get("notified") or {}))
        base["tasks"][tid] = full
    return base, None


def ensure_dir():
    os.makedirs(STATE_DIR, mode=0o700, exist_ok=True)


def write_private(path, text):
    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
    with os.fdopen(fd, "w", encoding="utf-8") as f:
        f.write(text)
        f.flush()
        os.fsync(f.fileno())


def save_state(st):
    if DRY:
        return
    ensure_dir()
    tmp = "%s.tmp.%d" % (STATE, os.getpid())
    write_private(tmp, json.dumps(st, ensure_ascii=False, indent=2, sort_keys=True) + "\n")
    os.replace(tmp, STATE)


def set_state(rec, s):
    if rec["state"] != s:
        rec["state"] = s
        rec["state_changed_at"] = iso(now())
        if s == "waiting_decision":
            rec["notified"]["waiting"] = False
        if s == "blocked":
            rec["notified"]["blocked"] = False
        rec["integrating_since"] = iso(now()) if s == "integrating" else None


# ───────────── キュー yaml（静的定義・形式外は blocked）─────────────
def valid_rel(p):
    if not isinstance(p, str) or not p or "\x00" in p or not PATH_RE.match(p):
        return False
    parts = p.split("/")
    if any(x in ("", ".", "..") for x in parts):
        return False
    real = os.path.realpath(os.path.join(REPO, p))
    return real.startswith(REPO + os.sep)


def one_line(s):
    return isinstance(s, str) and s != "" and "\n" not in s and "\r" not in s and "\x00" not in s


def check_dod_item(c):
    if not isinstance(c, dict):
        return "dod の要素が mapping でない"
    keys = set(c.keys())
    if keys in ({"heading", "text"}, {"contains", "text"}):
        kind = "heading" if "heading" in keys else "contains"
        if not valid_rel(c[kind]):
            return "dod %s のパスが不正（相対パスのみ・.. 不可）: %r" % (kind, c[kind])
        if not one_line(c["text"]):
            return "dod %s の text が1行の文字列でない" % kind
        return None
    if keys == {"integrated"}:
        return None if c["integrated"] is True else "dod integrated は true のみ"
    if keys == {"test"}:
        t = c["test"]
        if not isinstance(t, str) or not TEST_RE.match(t) or not valid_rel(t):
            return "dod test は scripts/test_*.sh|*.py のみ: %r" % (t,)
        return None
    return "未知の dod 種別: %s" % ",".join(sorted(map(str, keys)))


def load_queue():
    """(tasks, errors{index: [msg]}, top_error, raw_bytes)"""
    try:
        with open(QUEUE, "rb") as f:
            raw = f.read()
    except OSError as e:
        return [], {}, "キューを読めない: %s" % e, b""
    try:
        d = yaml.safe_load(raw.decode("utf-8"))
    except (UnicodeDecodeError, yaml.YAMLError) as e:
        return [], {}, "キュー yaml の構文エラー: %s" % str(e).replace("\n", " ")[:200], raw
    if not isinstance(d, dict) or set(d.keys()) - {"version", "tasks"}:
        return [], {}, "キューの最上位は version と tasks だけ", raw
    if d.get("version") != 1 or not isinstance(d.get("tasks"), list):
        return [], {}, "キューの version が 1 でない、または tasks が配列でない", raw
    tasks = d["tasks"]
    errors = collections.defaultdict(list)
    seen = collections.defaultdict(list)
    for i, t in enumerate(tasks):
        if not isinstance(t, dict) or not isinstance(t.get("id"), str) or not ID_RE.match(t["id"]):
            return [], {}, "tasks[%d] の id が無いか形式外（[A-Za-z0-9_-]+）" % i, raw
        seen[t["id"]].append(i)
        unknown = set(t.keys()) - TASK_KEYS
        if unknown:
            errors[i].append("未知キー: " + ",".join(sorted(map(str, unknown))))
        for k in REQUIRED_KEYS:
            if k not in t:
                errors[i].append("必須キーが無い: " + k)
        if "title" in t and not one_line(t["title"]):
            errors[i].append("title が1行の文字列でない")
        if "kickoff" in t:
            if not valid_rel(t["kickoff"]):
                errors[i].append("kickoff のパスが不正（相対パスのみ・.. 不可）: %r" % (t["kickoff"],))
            elif not os.path.isfile(os.path.join(REPO, t["kickoff"])):
                errors[i].append("kickoff が存在しない: %s" % t["kickoff"])
        if "prompt" in t:
            p = t["prompt"]
            if not isinstance(p, str) or not p.strip() or "\x00" in p:
                errors[i].append("prompt が空か文字列でない")
            elif p.lstrip().startswith("-"):
                errors[i].append("prompt の先頭が '-'")
        if "dod" in t:
            if not isinstance(t["dod"], list) or not t["dod"]:
                errors[i].append("dod が空でない配列でない")
            else:
                for c in t["dod"]:
                    m = check_dod_item(c)
                    if m:
                        errors[i].append(m)
        if "needs_decision" in t and (not isinstance(t["needs_decision"], str) or not ID_RE.match(t["needs_decision"])):
            errors[i].append("needs_decision が ID 形式でない")
        if "note" in t and not isinstance(t["note"], str):
            errors[i].append("note が文字列でない")
    for tid, idx in seen.items():
        if len(idx) > 1:
            for i in idx:
                errors[i].append("id 重複: " + tid)
    return tasks, dict(errors), None, raw


def dod_of(t):
    if "dod" in t:
        return t["dod"]
    return [{"heading": t["kickoff"], "text": "## 完了報告（%s）" % t["id"]}, {"integrated": True}]


# ───────────── git の読み取り ─────────────
_LOCAL = None


def local_commits():
    """2号機（この repo）で作られた commit = reflog に commit 系の記録がある commit。"""
    global _LOCAL
    if _LOCAL is None:
        _LOCAL = set()
        rc, o = git("log", "-g", "--all", "--format=%H%x09%gs")
        if rc == 0:
            for line in o.splitlines():
                h, _, gs = line.partition("\t")
                if LOCAL_RE.match(gs) or "Merge made by" in gs:
                    _LOCAL.add(h)
    return _LOCAL


def head_sha():
    rc, o = git("rev-parse", "--verify", "-q", "HEAD^{commit}")
    return o.strip() if rc == 0 else None


def origin_sha():
    rc, o = git("rev-parse", "--verify", "-q", ORIGIN_MAIN + "^{commit}")
    return o.strip() if rc == 0 else None


_FRESH = None


def fresh_main():
    """(sha, fetch 成功か, 説明)。dod の integrated を見る直前に origin の main を自分で fetch する（周に1回・FIX1）。
    auto-pull が10分ごとに更新する refs/remotes/origin/main は統合直後だと古く、正常完了を誤って blocked にしていた。
    書くのは refs/runner/origin-main だけ（--refmap= で refs/remotes/* を、--no-tags で refs/tags/* を、--no-write-fetch-head で FETCH_HEAD を触らない＝
    auto-pull とロックを取り合わず、sync_lag の fetch 鮮度も偽らない）。失敗時は