録音文字起こしシステムの初期版（ローカル版・Windows対応）

spinthoughts.zip の Mac 向けコードを Windows で動くよう調整し、
テスト音声で文字起こしからCSV/Excel出力まで通ることを確認した状態。

- ffmpeg/ffprobe を PATH 外（winget の置き場）からも探す
- 文字起こしは faster-whisper、GPUがあれば自動でCUDAを使う
- CPU機では既定モデルを large-v3-turbo にする
- HuggingFaceキャッシュのシンボリックリンクを無効化（WinError 1314 回避）
- 話者分離オフのとき全行に要確認が付く不具合を修正

.claude/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "spinthoughts",
+      "runtimeExecutable": ".venv\Scripts\python.exe",
+      "runtimeArgs": ["app.py"],
+      "port": 8000
+    }
+  ]
+}

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+出力/

README.md

@@ -0,0 +1,204 @@
+# 録音文字起こし（Windows・ローカル完結）
+
+録音ZIPを投げると、指定秒数以上のファイルだけを文字起こしし、話者ごとに分けてCSVにするローカルWebアプリ。
+音声・文字起こし結果ともに外部へ送信しない（モデルの初回ダウンロードのみ通信あり）。
+
+- 文字起こし: Whisper large-v3 系（Windows は faster-whisper、Mac の Apple Silicon は MLX）
+- 話者分離: pyannote.audio 3.1
+- 費用: 0円。すべてオープンソース＋ローカル実行
+
+---
+
+## 1. セットアップ
+
+### ffmpeg
+
+PowerShell で:
+
+```powershell
+winget install Gyan.FFmpeg
+```
+
+インストール直後は PATH に載っていないことがあるが、このアプリは winget の置き場も自分で探すのでそのまま動く。
+
+### Python環境
+
+Python 3.12 を使う。フォルダの中で PowerShell を開き:
+
+```powershell
+.\setup.ps1
+```
+
+仮想環境 `.venv` を作り、torch（CPU版）と残りのライブラリを入れる。数分かかる。
+`python` ではなく `.venv\Scripts\python.exe` を使う点に注意（PATH 上の python.exe は Store のスタブ）。
+
+### HuggingFaceトークン（話者分離に必要）
+
+1. https://huggingface.co/join でアカウント作成（無料）
+2. 次の2つのページを開き、それぞれ利用条件に同意する
+   - https://huggingface.co/pyannote/speaker-diarization-3.1
+   - https://huggingface.co/pyannote/segmentation-3.0
+3. https://huggingface.co/settings/tokens で read 権限のトークンを作成
+
+トークンは環境変数に入れておくと毎回の入力が不要になる。PowerShell で一度だけ:
+
+```powershell
+setx HF_TOKEN "hf_xxxxxxxxxxxx"
+```
+
+設定後は PowerShell を開き直す。
+
+**両方のページで同意しないと動かない。** ここを飛ばすとモデル読み込みで失敗する。
+話者分離をオフにすれば、トークン無しでも文字起こしだけは使える。その場合は話者列が空になる
+（区間が無いことを誤認識と数えて全行に「要確認」が付かないようにしてある）。
+
+---
+
+## 2. 起動
+
+エクスプローラーで `start.cmd` をダブルクリックする。ブラウザが開く。
+
+コマンドから起動する場合:
+
+```powershell
+.\.venv\Scripts\python.exe app.py
+```
+
+`127.0.0.1:8000` にのみ待ち受けるので、同じPC以外からはアクセスできない。
+別のポートを使いたいときは `$env:PORT=8030` のように指定する。
+
+初回はWhisperと話者分離のモデルを取得するため数分かかる。2回目以降はキャッシュから読む
+（`C:\Users\<ユーザー名>\.cache\huggingface`）。
+
+---
+
+## 3. 使い方
+
+1. ZIPを選ぶ（ドラッグでも可）
+2. しきい値（既定30秒）と話者人数を設定
+3. 「文字起こしを始める」
+
+処理が終わると、ファイルごとの書き起こしが画面に出て、CSVを保存できる。
+
+### 出力
+
+**録音1本ごとに分ける**のを基本にしている。「一式をZIPで保存」を押すと次の構成で落ちてくる。
+
+```
+文字起こし_<ID>/
+├── 書き起こし/
+│   ├── 001_訪問_田中様.txt      ← 人が読む用。そのまま記録に貼れる
+│   └── 002_訪問_佐藤様.txt
+├── データ/
+│   ├── 001_訪問_田中様.csv      ← システム取り込み用
+│   └── 002_訪問_佐藤様.csv
+├── 録音ごと.xlsx                 ← 1録音＝1シート＋先頭に一覧シート
+├── 処理結果一覧.csv              ← 何が処理され何が除外されたかの記録
+└── 全発話.csv                    ← 横断で検索・集計したいとき用
+```
+
+画面上でも録音ごとの折りたたみカードになっていて、1本だけコピーしたり、
+その録音のテキスト／CSVだけを個別に落とすこともできる。
+
+**書き起こしテキスト（.txt）の形**
+
+```
+────────────────────────────────────────
+訪問_田中様.m4a
+────────────────────────────────────────
+録音日時   2026-08-12 10:32:04
+録音長     00:06:52（412秒）
+話者       SPEAKER_00、SPEAKER_01
+状態       書き起こし済み
+
+00:00:03  SPEAKER_00
+    今日の体温は36度4分でした
+
+00:00:12  SPEAKER_01
+    ありがとう、変わりないね
+
+00:04:41  SPEAKER_00  ※要確認（Whisperの定型幻聴に一致）
+    ご視聴ありがとうございました
+
+────────────────────────────────────────
+全 3 発話 / 要確認 1 件
+```
+
+**CSVの列**（録音ごとのCSV）
+
+| 列 | 内容 |
+|---|---|
+| 開始 / 終了 | 発話のタイムコード |
+| 話者 | SPEAKER_00, SPEAKER_01 … |
+| 発話内容 | 書き起こし |
+| 要確認 | 誤認識の疑いがある行に印 |
+| 備考 | 疑わしいと判定した理由 |
+
+`全発話.csv` はこれの先頭に「ファイル名・録音日時・録音長(秒)」が付く。
+Excelで文字化けしないようBOM付きUTF-8で出力している。
+
+30秒未満で除外したファイルは発話CSVには出ないが、`処理結果一覧.csv` と
+`書き起こし/` のテキストには理由付きで残る。何が処理されなかったかを黙って消さないため。
+
+---
+
+## 4. 知っておくべき制約
+
+**話者の名前は自動では分からない。** `SPEAKER_00` のような番号が振られるだけで、
+どれが職員でどれが利用者かは人が対応付ける必要がある。
+話者人数を事前に指定すると精度が目に見えて上がるので、1対1の訪問なら「2」を入れる。
+
+**精度は録音環境に強く依存する。** レコーダーを机に置いた1対1の会話なら実用的だが、
+複数人が同時に話す、テレビや生活音が大きい環境では話者の切り替わりを取りこぼす。
+「完成品」ではなく「人が直す前提の下書き」として設計してある。
+
+**Whisperは無音区間で幻の文を作る。** 「ご視聴ありがとうございました」のような定型句が典型。
+検出した行は削除せず「要確認」を立てるようにした。勝手に消すと、
+本当の発話まで消えたときに気づけないため。
+
+**このPCはCPU処理になる。** NVIDIAのGPUが無いため、文字起こしも話者分離もCPUで回る。
+精度の既定を `large-v3` ではなく `large-v3-turbo` にしてあるのはそのため。
+GPU搭載機で動かせば自動で `large-v3` が既定になり、速度も数倍になる。
+
+**処理時間の目安（このPC / Ryzen 5 7530U・CPU処理）**
+実測: `large-v3-turbo`・話者分離オフで、合計91秒の録音3本がモデル読み込み込み102秒。
+モデル読み込み（起動後の最初の1回だけ40秒前後）を除くと、録音1秒あたり0.6〜0.7秒。
+つまり1時間の録音で文字起こし35〜45分程度。話者分離を入れると同程度の時間が上乗せされる。
+`large-v3` を選ぶとさらに数倍かかる。長時間の録音は夜間にまとめて流すのが現実的。
+
+**要配慮個人情報の扱い。** 介護の録音は個人情報保護法の要配慮個人情報にあたる可能性が高い。
+ローカル完結にしてあるのはそのためだが、出力CSVの保存場所、保持期間、
+アクセス権限は運用側で決める必要がある。作業用の一時ファイルは処理後に削除している。
+
+---
+
+## 5. ファイル構成
+
+```
+koe-okoshi/
+├── app.py            Webサーバー（アップロード・進捗・CSV出力）
+├── pipeline.py       ZIP展開 → 長さフィルタ → 文字起こし → 話者分離 → 統合
+├── index.html        画面
+├── setup.ps1         初回セットアップ
+├── start.cmd         起動
+├── requirements.txt
+└── README.md
+```
+
+処理の中身を変えたいときは `pipeline.py` を見る。
+たとえば `HALLUCINATION_PATTERNS` に自分の環境で出やすい誤認識を足せる。
+`DEFAULT_PROMPT` に事業所名や利用者様の呼称を足すと固有名詞の精度が上がる。
+
+---
+
+## 6. うまくいかないとき
+
+| 症状 | 対処 |
+|---|---|
+| ffmpeg が見つからない | `winget install Gyan.FFmpeg` を実行し、PowerShellを開き直す |
+| 話者分離モデルが読めない | HuggingFaceの2ページ両方で条件に同意したか、トークンが read 権限か確認 |
+| 日本語ファイル名が化ける | Windows製ZIPのCP932は自動判別済み。それでも化けるなら元のZIPの作り方を確認 |
+| 極端に遅い | 精度を `turbo` に落とす、または話者分離をオフにする |
+| 発話が検出されない | 録音の音量が小さい可能性。`ffmpeg -i 元ファイル -af loudnorm 正規化後.wav` で正規化してから再投入 |
+| ポート8000が使用中 | `$env:PORT=8030; .\.venv\Scripts\python.exe app.py` |
+| モデル取得で WinError 1314 | HuggingFaceキャッシュのシンボリックリンクに管理者権限が要るのが原因。`pipeline.py` で実体コピーに切り替え済み。それでも出るなら `C:\Users\<ユーザー名>\.cache\huggingface` の該当モデルフォルダを消して再実行 |

app.py

@@ -0,0 +1,248 @@
+"""
+ローカルで動く文字起こしWebアプリ。
+
+起動:
+    python app.py
+ブラウザ:
+    http://127.0.0.1:8000
+
+127.0.0.1 にのみ待ち受けるため、このPC以外からはアクセスできない。
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import threading
+import traceback
+import uuid
+from pathlib import Path
+
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+
+import pipeline as pl
+
+APP_DIR = Path(__file__).parent
+WORK_ROOT = Path(tempfile.gettempdir()) / "koe-okoshi"
+WORK_ROOT.mkdir(parents=True, exist_ok=True)
+
+app = FastAPI(title="録音文字起こし")
+JOBS: dict[str, dict] = {}
+LOCK = threading.Lock()
+
+
+def update(job_id: str, **fields) -> None:
+    with LOCK:
+        if job_id in JOBS:
+            JOBS[job_id].update(fields)
+
+
+def serialize(results: list[pl.FileResult]) -> list[dict]:
+    return [
+        {
+            "index": i,
+            "shortName": os.path.basename(r.original_name),
+            "name": r.original_name,
+            "duration": round(r.duration, 1),
+            "durationLabel": pl.hhmmss(r.duration),
+            "recordedAt": r.recorded_at,
+            "status": r.status,
+            "reason": r.reason,
+            "speakers": r.speakers,
+            "utterances": [
+                {
+                    "start": pl.hhmmss(u.start),
+                    "end": pl.hhmmss(u.end),
+                    "speaker": u.speaker,
+                    "text": u.text,
+                    "needsReview": u.needs_review,
+                    "reviewNote": u.review_note,
+                }
+                for u in r.utterances
+            ],
+        }
+        for i, r in enumerate(results, 1)
+    ]
+
+
+def worker(job_id: str, zip_path: Path, options: dict) -> None:
+    workdir = WORK_ROOT / job_id
+    try:
+        def progress(message: str, done: int, total: int) -> None:
+            update(job_id, message=message, done=done, total=total)
+
+        results = pl.run(zip_path=zip_path, workdir=workdir, progress=progress, **options)
+
+        update(job_id, message="ファイルを書き出しています")
+        outputs = pl.build_outputs(results, workdir / "出力", job_id)
+
+        transcribed = sum(1 for r in results if r.status == "transcribed")
+        skipped = sum(1 for r in results if r.status == "skipped")
+        failed = sum(1 for r in results if r.status == "error")
+
+        update(
+            job_id,
+            state="done",
+            message="完了",
+            results=serialize(results),
+            summary={
+                "total": len(results),
+                "transcribed": transcribed,
+                "skipped": skipped,
+                "failed": failed,
+                "flagged": sum(
+                    1 for r in results for u in r.utterances if u.needs_review
+                ),
+            },
+            outputs=outputs,
+            hasXlsx=outputs.get("xlsx") is not None,
+        )
+    except Exception as exc:
+        traceback.print_exc()
+        update(job_id, state="error", message=str(exc))
+    finally:
+        shutil.rmtree(workdir / "audio", ignore_errors=True)
+        shutil.rmtree(workdir / "wav", ignore_errors=True)
+        zip_path.unlink(missing_ok=True)
+
+
+@app.get("/", response_class=HTMLResponse)
+def index() -> str:
+    return (APP_DIR / "index.html").read_text(encoding="utf-8")
+
+
+@app.get("/environment")
+def environment() -> JSONResponse:
+    return JSONResponse({
+        "appleSilicon": pl.is_apple_silicon(),
+        "ffmpeg": pl.tool_path("ffmpeg") is not None and pl.tool_path("ffprobe") is not None,
+        "ffmpegHint": "winget install Gyan.FFmpeg" if pl.IS_WINDOWS else "brew install ffmpeg",
+        "gpu": pl.gpu_label(),
+        "defaultModel": pl.default_model_size(),
+        "tokenFromEnv": bool(os.environ.get("HF_TOKEN")),
+        "defaultPrompt": pl.DEFAULT_PROMPT,
+    })
+
+
+@app.post("/jobs")
+async def create_job(
+    file: UploadFile = File(...),
+    minSeconds: float = Form(30.0),
+    modelSize: str = Form(""),
+    numSpeakers: int = Form(0),
+    diarization: bool = Form(True),
+    prompt: str = Form(pl.DEFAULT_PROMPT),
+    hfToken: str = Form(""),
+) -> JSONResponse:
+    if not file.filename.lower().endswith(".zip"):
+        raise HTTPException(400, "ZIPファイルを選んでください。")
+
+    token = hfToken.strip() or os.environ.get("HF_TOKEN", "")
+    if diarization and not token:
+        raise HTTPException(
+            400,
+            "話者分離にはHuggingFaceのアクセストークンが必要です。"
+            "トークンを入力するか、話者分離をオフにしてください。",
+        )
+
+    job_id = uuid.uuid4().hex[:12]
+    workdir = WORK_ROOT / job_id
+    workdir.mkdir(parents=True, exist_ok=True)
+
+    zip_path = workdir / "upload.zip"
+    with open(zip_path, "wb") as out:
+        shutil.copyfileobj(file.file, out)
+
+    with LOCK:
+        JOBS[job_id] = {
+            "state": "running",
+            "message": "準備しています",
+            "done": 0,
+            "total": 0,
+            "results": [],
+            "summary": None,
+            "csv": None,
+        }
+
+    options = {
+        "min_seconds": max(0.0, minSeconds),
+        "model_size": modelSize or pl.default_model_size(),
+        "num_speakers": numSpeakers if numSpeakers > 0 else None,
+        "diarization_enabled": diarization,
+        "prompt": prompt,
+        "hf_token": token,
+    }
+
+    threading.Thread(target=worker, args=(job_id, zip_path, options), daemon=True).start()
+    return JSONResponse({"jobId": job_id})
+
+
+@app.get("/jobs/{job_id}")
+def job_status(job_id: str) -> JSONResponse:
+    with LOCK:
+        job = JOBS.get(job_id)
+    if not job:
+        raise HTTPException(404, "処理が見つかりません。")
+    return JSONResponse({k: v for k, v in job.items() if k != "outputs"})
+
+
+def _outputs(job_id: str) -> dict:
+    with LOCK:
+        job = JOBS.get(job_id)
+    if not job or not job.get("outputs"):
+        raise HTTPException(404, "出力がまだありません。")
+    return job["outputs"]
+
+
+@app.get("/jobs/{job_id}/bundle")
+def download_bundle(job_id: str) -> FileResponse:
+    out = _outputs(job_id)
+    return FileResponse(
+        out["bundle"], media_type="application/zip", filename=f"文字起こし_{job_id}.zip"
+    )
+
+
+@app.get("/jobs/{job_id}/xlsx")
+def download_xlsx(job_id: str) -> FileResponse:
+    out = _outputs(job_id)
+    if not out.get("xlsx"):
+        raise HTTPException(404, "Excelを作成できませんでした。openpyxl を導入してください。")
+    return FileResponse(
+        out["xlsx"],
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename=f"録音ごと_{job_id}.xlsx",
+    )
+
+
+@app.get("/jobs/{job_id}/all-csv")
+def download_all_csv(job_id: str) -> FileResponse:
+    out = _outputs(job_id)
+    return FileResponse(
+        out["all_csv"], media_type="text/csv", filename=f"全発話_{job_id}.csv"
+    )
+
+
+@app.get("/jobs/{job_id}/files/{index}.{kind}")
+def download_one(job_id: str, index: int, kind: str) -> FileResponse:
+    out = _outputs(job_id)
+    record = next((r for r in out["per_file"] if r["index"] == index), None)
+    if not record:
+        raise HTTPException(404, "その録音が見つかりません。")
+    if kind == "txt":
+        return FileResponse(
+            record["txt"], media_type="text/plain; charset=utf-8",
+            filename=f"{record['stem']}.txt",
+        )
+    if kind == "csv" and record.get("csv"):
+        return FileResponse(
+            record["csv"], media_type="text/csv", filename=f"{record['stem']}.csv"
+        )
+    raise HTTPException(404, "その形式は用意されていません。")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="127.0.0.1", port=int(os.environ.get("PORT", "8000")))

index.html

@@ -0,0 +1,575 @@
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>録音文字起こし</title>
+<style>
+  :root {
+    --paper: #e7eaec;
+    --card: #fbfbfc;
+    --ink: #171b20;
+    --ink-soft: #5a636b;
+    --ink-faint: #8b939a;
+    --rule: #ccd3d8;
+    --accent: #1f5f5b;
+    --accent-soft: #d9e5e3;
+    --warn: #8a5512;
+    --warn-soft: #f2e6d2;
+    --sp-0: #1f5f5b;
+    --sp-1: #9a4f22;
+    --sp-2: #4b4a86;
+    --sp-3: #8c2f4d;
+    --sp-4: #40682a;
+    --mono: ui-monospace, "SF Mono", Menlo, Consolas, monospace;
+    --sans: -apple-system, BlinkMacSystemFont, "Hiragino Sans", "Yu Gothic Medium",
+            "Noto Sans JP", sans-serif;
+  }
+
+  * { box-sizing: border-box; }
+
+  body {
+    margin: 0;
+    background: var(--paper);
+    color: var(--ink);
+    font-family: var(--sans);
+    font-size: 15px;
+    line-height: 1.7;
+    -webkit-font-smoothing: antialiased;
+  }
+
+  .wrap { max-width: 940px; margin: 0 auto; padding: 40px 20px 96px; }
+
+  /* ---------- header ---------- */
+  .masthead { border-bottom: 2px solid var(--ink); padding-bottom: 16px; margin-bottom: 32px; }
+  .masthead h1 {
+    margin: 0;
+    font-size: 27px;
+    font-weight: 700;
+    letter-spacing: 0.06em;
+  }
+  .masthead p { margin: 6px 0 0; color: var(--ink-soft); font-size: 13.5px; }
+
+  .chips { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 14px; }
+  .chip {
+    font-family: var(--mono);
+    font-size: 11px;
+    letter-spacing: 0.04em;
+    padding: 3px 9px;
+    border: 1px solid var(--rule);
+    border-radius: 2px;
+    background: var(--card);
+    color: var(--ink-soft);
+  }
+  .chip.ok { border-color: var(--accent); color: var(--accent); background: var(--accent-soft); }
+  .chip.bad { border-color: var(--warn); color: var(--warn); background: var(--warn-soft); }
+
+  /* ---------- panels ---------- */
+  .panel {
+    background: var(--card);
+    border: 1px solid var(--rule);
+    border-radius: 3px;
+    padding: 22px;
+    margin-bottom: 20px;
+  }
+  .panel h2 {
+    margin: 0 0 18px;
+    font-size: 12px;
+    font-family: var(--mono);
+    letter-spacing: 0.14em;
+    text-transform: uppercase;
+    color: var(--ink-faint);
+    font-weight: 600;
+  }
+
+  /* ---------- drop zone ---------- */
+  .drop {
+    border: 1.5px dashed var(--rule);
+    border-radius: 3px;
+    padding: 30px 20px;
+    text-align: center;
+    cursor: pointer;
+    background: transparent;
+    transition: border-color .15s, background .15s;
+    display: block;
+    width: 100%;
+    font: inherit;
+    color: inherit;
+  }
+  .drop:hover, .drop.hot { border-color: var(--accent); background: var(--accent-soft); }
+  .drop:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }
+  .drop strong { display: block; font-size: 16px; }
+  .drop span { color: var(--ink-soft); font-size: 13px; }
+  .drop .picked { font-family: var(--mono); font-size: 13px; color: var(--accent); word-break: break-all; }
+
+  /* ---------- form ---------- */
+  .grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 16px; margin-top: 22px; }
+  .field { display: flex; flex-direction: column; gap: 5px; }
+  .field label { font-size: 12.5px; font-weight: 600; letter-spacing: .02em; }
+  .field .hint { font-size: 11.5px; color: var(--ink-faint); line-height: 1.5; }
+  .field input, .field select, .field textarea {
+    font: inherit;
+    font-size: 14px;
+    padding: 8px 10px;
+    border: 1px solid var(--rule);
+    border-radius: 2px;
+    background: #fff;
+    color: var(--ink);
+    width: 100%;
+  }
+  .field textarea { resize: vertical; min-height: 66px; line-height: 1.6; }
+  .field input:focus, .field select:focus, .field textarea:focus {
+    outline: 2px solid var(--accent); outline-offset: -1px; border-color: var(--accent);
+  }
+  .field.span2 { grid-column: 1 / -1; }
+  .check { display: flex; align-items: center; gap: 8px; }
+  .check input { width: auto; }
+
+  .actions { display: flex; align-items: center; gap: 14px; margin-top: 22px; flex-wrap: wrap; }
+  button.go {
+    font: inherit; font-weight: 600; font-size: 14.5px;
+    background: var(--accent); color: #fff;
+    border: none; border-radius: 2px; padding: 11px 26px; cursor: pointer;
+    letter-spacing: .04em;
+  }
+  button.go:hover { background: #174a47; }
+  button.go:disabled { background: var(--ink-faint); cursor: not-allowed; }
+  button.go:focus-visible { outline: 2px solid var(--ink); outline-offset: 2px; }
+
+  a.dl {
+    font-family: var(--mono); font-size: 13px; letter-spacing: .03em;
+    color: var(--accent); border: 1px solid var(--accent);
+    padding: 9px 18px; border-radius: 2px; text-decoration: none;
+  }
+  a.dl:hover { background: var(--accent-soft); }
+
+  .error { color: var(--warn); font-size: 13px; }
+
+  /* ---------- progress ---------- */
+  .bar { height: 5px; background: var(--rule); border-radius: 3px; overflow: hidden; }
+  .bar i { display: block; height: 100%; width: 0; background: var(--accent); transition: width .3s ease; }
+  .track { display: flex; justify-content: space-between; gap: 12px; margin-bottom: 9px; font-size: 13px; }
+  .track .now { color: var(--ink-soft); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .track .count { font-family: var(--mono); color: var(--ink-faint); flex: none; }
+
+  /* ---------- summary ---------- */
+  .tally { display: flex; gap: 28px; flex-wrap: wrap; }
+  .tally div { display: flex; flex-direction: column; }
+  .tally b { font-family: var(--mono); font-size: 26px; font-weight: 600; line-height: 1.2; }
+  .tally span { font-size: 11.5px; color: var(--ink-faint); letter-spacing: .04em; }
+
+  /* ---------- per-recording cards ---------- */
+  .file {
+    border: 1px solid var(--rule);
+    border-radius: 3px;
+    margin-bottom: 12px;
+    background: #fff;
+    overflow: hidden;
+  }
+  .file[open] { border-color: var(--accent); }
+  .file > summary {
+    padding: 14px 16px;
+    cursor: pointer;
+    list-style: none;
+    display: block;
+  }
+  .file > summary::-webkit-details-marker { display: none; }
+  .file > summary:hover { background: var(--accent-soft); }
+  .file > summary:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
+  .file[open] > summary { border-bottom: 1px solid var(--rule); background: var(--card); }
+  .file-body { padding: 4px 16px 16px; }
+
+  .no {
+    font-family: var(--mono); font-size: 11px; color: var(--ink-faint);
+    flex: none; padding-top: 2px;
+  }
+  .file-head { display: flex; align-items: baseline; gap: 10px; flex-wrap: wrap; }
+  .file-name { font-size: 14.5px; font-weight: 600; word-break: break-all; flex: 1 1 200px; }
+  .file-meta { font-family: var(--mono); font-size: 11.5px; color: var(--ink-faint); flex: none; }
+  .preview {
+    margin: 6px 0 0; font-size: 13px; color: var(--ink-soft);
+    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  }
+  .file-tools { display: flex; gap: 8px; flex-wrap: wrap; margin: 12px 0 4px; }
+  .file-tools a, .file-tools button {
+    font-family: var(--mono); font-size: 11.5px; letter-spacing: .03em;
+    color: var(--ink-soft); background: transparent;
+    border: 1px solid var(--rule); border-radius: 2px;
+    padding: 5px 11px; text-decoration: none; cursor: pointer;
+  }
+  .file-tools a:hover, .file-tools button:hover { border-color: var(--accent); color: var(--accent); }
+  .len { position: relative; height: 6px; background: var(--rule); border-radius: 2px; margin-top: 9px; }
+  .len i { display: block; height: 100%; border-radius: 2px; background: var(--accent); }
+  .len.cut i { background: var(--ink-faint); opacity: .5; }
+  .len .gate { position: absolute; top: -3px; bottom: -3px; width: 1px; background: var(--warn); }
+  .tag {
+    font-family: var(--mono); font-size: 10.5px; letter-spacing: .05em;
+    padding: 2px 7px; border-radius: 2px; flex: none;
+  }
+  .tag.cut { background: var(--rule); color: var(--ink-soft); }
+  .tag.err { background: var(--warn-soft); color: var(--warn); }
+
+  /* ---------- transcript score ---------- */
+  .score { margin-top: 14px; }
+  .line { display: flex; gap: 12px; padding: 7px 0; border-top: 1px dotted var(--rule); }
+  .line:first-child { border-top: none; }
+  .time { font-family: var(--mono); font-size: 11.5px; color: var(--ink-faint); flex: none; width: 60px; padding-top: 3px; }
+  .spine { width: 3px; border-radius: 2px; flex: none; background: var(--ink-faint); }
+  .said { flex: 1; min-width: 0; }
+  .who {
+    font-family: var(--mono); font-size: 10.5px; letter-spacing: .08em;
+    text-transform: uppercase; color: var(--ink-soft); display: block;
+  }
+  .what { font-size: 14.5px; line-height: 1.75; word-break: break-word; }
+  .flag {
+    display: inline-block; font-family: var(--mono); font-size: 10px;
+    color: var(--warn); background: var(--warn-soft);
+    padding: 1px 6px; border-radius: 2px; margin-left: 6px; vertical-align: 1px;
+  }
+  .sp0 { background: var(--sp-0); } .sp1 { background: var(--sp-1); }
+  .sp2 { background: var(--sp-2); } .sp3 { background: var(--sp-3); }
+  .sp4 { background: var(--sp-4); }
+
+  .empty { color: var(--ink-faint); font-size: 13px; }
+  [hidden] { display: none !important; }
+
+  @media (max-width: 620px) {
+    .wrap { padding: 24px 14px 60px; }
+    .grid { grid-template-columns: 1fr; }
+    .time { width: 52px; }
+  }
+  @media (prefers-reduced-motion: reduce) {
+    * { transition: none !important; }
+  }
+</style>
+</head>
+<body>
+<div class="wrap">
+
+  <header class="masthead">
+    <h1>録音文字起こし</h1>
+    <p>ZIPの中から一定の長さ以上の録音だけを選び、話者ごとに書き起こしてCSVにします。音声はこのPCの外に出ません。</p>
+    <div class="chips" id="chips"></div>
+  </header>
+
+  <section class="panel" id="setup">
+    <h2>音声を読み込む</h2>
+
+    <input type="file" id="picker" accept=".zip" hidden>
+    <button type="button" class="drop" id="drop">
+      <strong id="dropTitle">ZIPファイルを選ぶ</strong>
+      <span id="dropHint">ここにドラッグし��も読み込めます</span>
+    </button>
+
+    <div class="grid">
+      <div class="field">
+        <label for="minSeconds">この長さ以上だけ処理する</label>
+        <input type="number" id="minSeconds" value="30" min="0" step="1">
+        <span class="hint">秒。短い録音は文字起こしせずに一覧だけ残します。</span>
+      </div>
+
+      <div class="field">
+        <label for="modelSize">精度</label>
+        <select id="modelSize">
+          <option value="large-v3-turbo">標準（turbo・速くて実用精度）</option>
+          <option value="large-v3">最優先（large-v3・いちばん正確／数倍遅い）</option>
+          <option value="medium">軽量（medium）</option>
+        </select>
+        <span class="hint" id="modelHint">初回だけモデルの取得に数分かかります。</span>
+      </div>
+
+      <div class="field">
+        <label for="numSpeakers">話者の人数</label>
+        <input type="number" id="numSpeakers" value="2" min="0" max="10" step="1">
+        <span class="hint">分かっているなら指定するほど正確になります。0で自動判定。</span>
+      </div>
+
+      <div class="field">
+        <label for="hfToken">HuggingFaceトークン</label>
+        <input type="password" id="hfToken" placeholder="hf_..." autocomplete="off">
+        <span class="hint">話者分離に必要です。環境変数 HF_TOKEN があれば空欄で構いません。</span>
+      </div>
+
+      <div class="field span2 check">
+        <input type="checkbox" id="diarization" checked>
+        <label for="diarization">話者を分けて記録する</label>
+      </div>
+
+      <div class="field span2">
+        <label for="prompt">よく出る言葉</label>
+        <textarea id="prompt"></textarea>
+        <span class="hint">業務でよく使う語を書いておくと、固有名詞や専門用語の変換精度が上がります。</span>
+      </div>
+    </div>
+
+    <div class="actions">
+      <button type="button" class="go" id="start" disabled>文字起こしを始める</button>
+      <span class="error" id="formError"></span>
+    </div>
+  </section>
+
+  <section class="panel" id="progress" hidden>
+    <h2>処理中</h2>
+    <div class="track">
+      <span class="now" id="progressNow">準備しています</span>
+      <span class="count" id="progressCount"></span>
+    </div>
+    <div class="bar"><i id="progressBar"></i></div>
+  </section>
+
+  <section class="panel" id="summary" hidden>
+    <h2>結果</h2>
+    <div class="tally" id="tally"></div>
+    <div class="actions" id="downloads"></div>
+    <p class="hint" id="bundleNote"></p>
+  </section>
+
+  <section class="panel" id="output" hidden>
+    <h2>書き起こし</h2>
+    <div id="files"></div>
+  </section>
+
+</div>
+
+<script>
+const $ = (id) => document.getElementById(id);
+let chosenFile = null;
+let poller = null;
+
+/* ---------- environment ---------- */
+fetch("/environment").then(r => r.json()).then(env => {
+  $("prompt").value = env.defaultPrompt || "";
+  if (env.defaultModel) $("modelSize").value = env.defaultModel;
+  if (!env.gpu) {
+    $("modelHint").textContent =
+      "初回だけモデルの取得に数分かかります。CPU処理なので、録音1時間あたり数十分かかります。";
+  }
+  const chips = [
+    env.ffmpeg
+      ? { text: "ffmpeg 利用可", cls: "ok" }
+      : { text: `ffmpeg 未検出 — ${env.ffmpegHint || ""}`, cls: "bad" },
+    env.gpu
+      ? { text: `${env.gpu} で高速処理`, cls: "ok" }
+      : { text: "CPU処理（時間がかかります）", cls: "" },
+    env.tokenFromEnv
+      ? { text: "HF_TOKEN 設定済み", cls: "ok" }
+      : { text: "HF_TOKEN 未設定", cls: "" },
+  ];
+  $("chips").innerHTML = chips
+    .map(c => `<span class="chip ${c.cls}">${c.text}</span>`)
+    .join("");
+}).catch(() => {});
+
+/* ---------- file selection ---------- */
+const drop = $("drop");
+drop.addEventListener("click", () => $("picker").click());
+$("picker").addEventListener("change", (e) => setFile(e.target.files[0]));
+
+["dragenter", "dragover"].forEach(ev =>
+  drop.addEventListener(ev, (e) => { e.preventDefault(); drop.classList.add("hot"); }));
+["dragleave", "drop"].forEach(ev =>
+  drop.addEventListener(ev, (e) => { e.preventDefault(); drop.classList.remove("hot"); }));
+drop.addEventListener("drop", (e) => setFile(e.dataTransfer.files[0]));
+
+function setFile(file) {
+  if (!file) return;
+  if (!file.name.toLowerCase().endsWith(".zip")) {
+    $("formError").textContent = "ZIPファイルを選んでください。";
+    return;
+  }
+  chosenFile = file;
+  $("formError").textContent = "";
+  $("dropTitle").textContent = file.name;
+  $("dropHint").className = "picked";
+  $("dropHint").textContent = (file.size / 1048576).toFixed(1) + " MB — 別のファイルに変えるにはもう一度クリック";
+  $("start").disabled = false;
+}
+
+/* ---------- start ---------- */
+$("start").addEventListener("click", async () => {
+  if (!chosenFile) return;
+  $("formError").textContent = "";
+  $("start").disabled = true;
+  $("start").textContent = "アップロード中";
+
+  const body = new FormData();
+  body.append("file", chosenFile);
+  body.append("minSeconds", $("minSeconds").value || "30");
+  body.append("modelSize", $("modelSize").value);
+  body.append("numSpeakers", $("numSpeakers").value || "0");
+  body.append("diarization", $("diarization").checked ? "true" : "false");
+  body.append("prompt", $("prompt").value);
+  body.append("hfToken", $("hfToken").value);
+
+  try {
+    const res = await fetch("/jobs", { method: "POST", body });
+    const data = await res.json();
+    if (!res.ok) throw new Error(data.detail || "処理を開始できませんでした。");
+
+    $("progress").hidden = false;
+    $("summary").hidden = true;
+    $("output").hidden = true;
+    $("start").textContent = "処理中";
+    poller = setInterval(() => check(data.jobId), 1200);
+    check(data.jobId);
+  } catch (err) {
+    $("formError").textContent = err.message;
+    $("start").disabled = false;
+    $("start").textContent = "文字起こしを始める";
+  }
+});
+
+/* ---------- polling ---------- */
+async function check(jobId) {
+  const res = await fetch("/jobs/" + jobId);
+  if (!res.ok) return;
+  const job = await res.json();
+
+  $("progressNow").textContent = job.message || "";
+  $("progressCount").textContent = job.total ? `${job.done} / ${job.total}` : "";
+  $("progressBar").style.width = job.total ? (job.done / job.total * 100) + "%" : "4%";
+
+  if (job.state === "running") return;
+  clearInterval(poller);
+  $("start").disabled = false;
+  $("start").textContent = "文字起こしを始める";
+
+  if (job.state === "error") {
+    $("progressNow").textContent = job.message;
+    $("progressBar").style.background = "var(--warn)";
+    return;
+  }
+
+  $("progress").hidden = true;
+  render(job, jobId);
+}
+
+/* ---------- render ---------- */
+let currentJob = null;
+
+function render(job, jobId) {
+  currentJob = job;
+  const s = job.summary || {};
+  $("tally").innerHTML = [
+    ["書き起こし", s.transcribed || 0],
+    ["長さ不足で除外", s.skipped || 0],
+    ["失敗", s.failed || 0],
+    ["要確認", s.flagged || 0],
+  ].map(([label, n]) => `<div><b>${n}</b><span>${label}</span></div>`).join("");
+
+  const links = [
+    [`/jobs/${jobId}/bundle`, "一式をZIPで保存"],
+    job.hasXlsx ? [`/jobs/${jobId}/xlsx`, "Excel（1録音＝1シート）"] : null,
+    [`/jobs/${jobId}/all-csv`, "全発話をまとめたCSV"],
+  ].filter(Boolean);
+  $("downloads").innerHTML = links
+    .map(([href, label]) => `<a class="dl" href="${href}" download>${label}</a>`)
+    .join("");
+  $("bundleNote").textContent =
+    "ZIPの中身：書き起こし／（録音ごとのテキスト）、データ／（録音ごとのCSV）、"
+    + "処理結果一覧.csv、全発話.csv、録音ごと.xlsx";
+  $("summary").hidden = false;
+
+  const gate = parseFloat($("minSeconds").value || "30");
+  const longest = Math.max(1, ...job.results.map(r => r.duration));
+  const openByDefault = job.results.filter(r => r.status === "transcribed").length <= 3;
+
+  $("files").innerHTML = job.results
+    .map(r => card(r, jobId, gate, longest, openByDefault))
+    .join("");
+  $("output").hidden = false;
+}
+
+function card(r, jobId, gate, longest, openByDefault) {
+  const width = Math.min(100, r.duration / longest * 100);
+  const gatePos = Math.min(100, gate / longest * 100);
+  const done = r.status === "transcribed";
+
+  let tag = "";
+  if (r.status === "skipped") tag = `<span class="tag cut">${esc(r.reason)}</span>`;
+  if (r.status === "error") tag = `<span class="tag err">失敗</span>`;
+
+  const flagged = r.utterances.filter(u => u.needsReview).length;
+  const meta = [
+    r.durationLabel,
+    r.recordedAt,
+    done ? `${r.utterances.length}発話` : null,
+    done && r.speakers.length ? `話者${r.speakers.length}人` : null,
+    flagged ? `要確認${flagged}` : null,
+  ].filter(Boolean).join(" · ");
+
+  const preview = done && r.utterances.length
+    ? `<p class="preview">${esc(r.utterances[0].text)}</p>`
+    : "";
+
+  /* 話者の色は録音ごとに割り当てる。別の録音の SPEAKER_00 は別人なので、
+     色を共有すると同一人物に見えてしまう。 */
+  const palette = {};
+  let next = 0;
+  let score = "";
+
+  if (done) {
+    score = r.utterances.length
+      ? `<div class="score">${r.utterances.map(u => {
+          if (!(u.speaker in palette)) palette[u.speaker] = next++ % 5;
+          const flag = u.needsReview
+            ? `<span class="flag" title="${esc(u.reviewNote)}">要確認</span>` : "";
+          return `<div class="line">
+            <span class="time">${u.start}</span>
+            <span class="spine sp${palette[u.speaker]}"></span>
+            <span class="said">
+              <span class="who">${esc(u.speaker)}</span>
+              <span class="what">${esc(u.text)}${flag}</span>
+            </span>
+          </div>`;
+        }).join("")}</div>`
+      : `<p class="empty">��話を検出できませんでした。</p>`;
+  } else {
+    score = `<p class="empty">${esc(r.reason || "書き起こしはありません。")}</p>`;
+  }
+
+  const tools = `<div class="file-tools">
+    <button type="button" onclick="copyOne(${r.index}, this)">本文をコピー</button>
+    <a href="/jobs/${jobId}/files/${r.index}.txt" download>テキスト</a>
+    ${done && r.utterances.length ? `<a href="/jobs/${jobId}/files/${r.index}.csv" download>CSV</a>` : ""}
+  </div>`;
+
+  return `<details class="file" ${done && openByDefault ? "open" : ""}>
+    <summary>
+      <div class="file-head">
+        <span class="no">${String(r.index).padStart(3, "0")}</span>
+        <span class="file-name">${esc(r.shortName)}</span>
+        ${tag}
+        <span class="file-meta">${esc(meta)}</span>
+      </div>
+      <div class="len ${done ? "" : "cut"}">
+        <i style="width:${width}%"></i>
+        <span class="gate" style="left:${gatePos}%" title="${gate}秒"></span>
+      </div>
+      ${preview}
+    </summary>
+    <div class="file-body">${tools}${score}</div>
+  </details>`;
+}
+
+function copyOne(index, btn) {
+  const r = (currentJob?.results || []).find(x => x.index === index);
+  if (!r) return;
+  const head = `${r.shortName}\n録音日時 ${r.recordedAt || "不明"} ／ 録音長 ${r.durationLabel}\n\n`;
+  const body = r.utterances
+    .map(u => `${u.start}${u.speaker ? "  " + u.speaker : ""}${u.needsReview ? "  ※要確認" : ""}\n    ${u.text}`)
+    .join("\n\n");
+  navigator.clipboard.writeText(head + body).then(() => {
+    const original = btn.textContent;
+    btn.textContent = "コピーしました";
+    setTimeout(() => { btn.textContent = original; }, 1600);
+  });
+}
+
+function esc(str) {
+  return String(str ?? "").replace(/[&<>"']/g, c =>
+    ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
+}
+</script>
+</body>
+</html>

pipeline.py

@@ -0,0 +1,747 @@
+"""
+録音ZIP → 30秒以上のファイルだけ文字起こし＋話者分離 → CSV
+
+すべてローカルで完結する。音声も文字起こし結果も外部に送信しない。
+"""
+
+from __future__ import annotations
+
+import csv
+import os
+import platform
+import re
+import shutil
+import subprocess
+import zipfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Iterable
+
+# HuggingFace のキャッシュは既定でシンボリックリンクを張るが、Windows では
+# 管理者権限か開発者モードが無いと WinError 1314 で落ちる。実体コピーに切り替える。
+# （torch / faster_whisper より先に効かせる必要があるので、ここで設定する）
+if platform.system() == "Windows":
+    os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS", "1")
+    os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")
+
+
+AUDIO_EXT = {
+    ".wav", ".mp3", ".m4a", ".mp4", ".aac", ".flac",
+    ".ogg", ".opus", ".wma", ".amr", ".3gp", ".mov", ".aif", ".aiff",
+}
+
+# Whisperが無音区間で作り出しやすい定型句。削除はせず「要確認」フラグを立てる。
+HALLUCINATION_PATTERNS = [
+    "ご視聴ありがとうございました",
+    "ご覧いただきありがとうございます",
+    "最後までご視聴",
+    "チャンネル登録",
+    "高評価",
+    "字幕",
+    "Thank you for watching",
+    "Thanks for watching",
+    "Subscribe",
+]
+
+MLX_MODELS = {
+    "large-v3": "mlx-community/whisper-large-v3-mlx",
+    "large-v3-turbo": "mlx-community/whisper-large-v3-turbo",
+    "medium": "mlx-community/whisper-medium-mlx",
+}
+
+DEFAULT_PROMPT = (
+    "訪問介護の記録です。バイタル、血圧、体温、脈拍、服薬、排泄、入浴介助、"
+    "デイサービス、ケアマネ、居宅介護支援、モニタリング、ADL、清拭、"
+    "利用者様、ご家族、といった言葉が出てきます。"
+)
+
+
+# ---------------------------------------------------------------- utilities
+
+
+IS_WINDOWS = platform.system() == "Windows"
+
+# 変換のたびに黒いコンソール窓が開かないようにする（Windowsのみ）
+_NO_WINDOW = {"creationflags": subprocess.CREATE_NO_WINDOW} if IS_WINDOWS else {}
+
+_tool_cache: dict[str, str] = {}
+
+
+def is_apple_silicon() -> bool:
+    return platform.system() == "Darwin" and platform.machine() == "arm64"
+
+
+def _ffmpeg_candidates(name: str) -> Iterable[Path]:
+    """PATH に無いときに ffmpeg / ffprobe を探す場所。"""
+    exe = f"{name}.exe" if IS_WINDOWS else name
+
+    yield Path(__file__).parent / "tools" / "ffmpeg" / "bin" / exe
+
+    local = os.environ.get("LOCALAPPDATA")
+    if local:
+        # winget で入れた直後は PATH に載っていないことがあるので実体も見に行く
+        yield Path(local) / "Microsoft" / "WinGet" / "Links" / exe
+        packages = Path(local) / "Microsoft" / "WinGet" / "Packages"
+        if packages.is_dir():
+            yield from packages.glob(f"*FFmpeg*/**/bin/{exe}")
+
+
+def tool_path(name: str) -> str | None:
+    if name in _tool_cache:
+        return _tool_cache[name]
+    found = shutil.which(name)
+    if not found:
+        for candidate in _ffmpeg_candidates(name):
+            if candidate.is_file():
+                found = str(candidate)
+                break
+    if found:
+        _tool_cache[name] = found
+    return found
+
+
+def ffmpeg_bin() -> str:
+    return tool_path("ffmpeg") or "ffmpeg"
+
+
+def ffprobe_bin() -> str:
+    return tool_path("ffprobe") or "ffprobe"
+
+
+def ensure_ffmpeg() -> None:
+    if tool_path("ffmpeg") and tool_path("ffprobe"):
+        return
+    how = (
+        "PowerShell で `winget install Gyan.FFmpeg` を実行し、開き直してください。"
+        if IS_WINDOWS
+        else "ターミナルで `brew install ffmpeg` を実行してください。"
+    )
+    raise RuntimeError(f"ffmpeg が見つかりません。{how}")
+
+
+def gpu_label() -> str:
+    """使える計算資源の名前。画面表示と既定モデルの判断に使う。"""
+    if is_apple_silicon():
+        return "Apple Silicon"
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            return torch.cuda.get_device_name(0)
+    except Exception:
+        pass
+    return ""
+
+
+def default_model_size() -> str:
+    """CPUだけの機械で large-v3 を既定にすると実用にならないので turbo を既定にする。"""
+    return "large-v3" if gpu_label() else "large-v3-turbo"
+
+
+def hhmmss(seconds: float) -> str:
+    seconds = max(0.0, float(seconds))
+    h, rem = divmod(int(seconds), 3600)
+    m, s = divmod(rem, 60)
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+
+def decode_zip_name(info: zipfile.ZipInfo) -> str:
+    """Windows製ZIPの日本語ファイル名（CP932）を復元する。
+
+    zipfile は UTF-8 フラグが立っていない名前を CP437 として読むため、
+    そのままだと日本語ファイル名が��字化けする。
+    """
+    if info.flag_bits & 0x800:
+        return info.filename
+    for enc in ("cp932", "utf-8"):
+        try:
+            return info.filename.encode("cp437").decode(enc)
+        except (UnicodeEncodeError, UnicodeDecodeError):
+            continue
+    return info.filename
+
+
+# ---------------------------------------------------------------- data model
+
+
+@dataclass
+class Utterance:
+    start: float
+    end: float
+    speaker: str
+    text: str
+    needs_review: bool = False
+    review_note: str = ""
+
+
+@dataclass
+class FileResult:
+    original_name: str
+    duration: float
+    recorded_at: str = ""
+    status: str = "pending"  # transcribed / skipped / error
+    reason: str = ""
+    utterances: list[Utterance] = field(default_factory=list)
+    speakers: list[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------- extraction
+
+
+def extract_audio(zip_path: Path, dest: Path) -> list[tuple[str, Path, str]]:
+    """ZIPを展開し (元のパス, 展開先, 録音日時) を返す。"""
+    dest.mkdir(parents=True, exist_ok=True)
+    found: list[tuple[str, Path, str]] = []
+
+    with zipfile.ZipFile(zip_path) as zf:
+        for info in zf.infolist():
+            if info.is_dir():
+                continue
+            name = decode_zip_name(info)
+            base = os.path.basename(name)
+            if not base or base.startswith("._") or "__MACOSX" in name:
+                continue
+            if Path(base).suffix.lower() not in AUDIO_EXT:
+                continue
+
+            target = dest / base
+            counter = 1
+            while target.exists():
+                target = dest / f"{Path(base).stem}__{counter}{Path(base).suffix}"
+                counter += 1
+
+            with zf.open(info) as src, open(target, "wb") as out:
+                shutil.copyfileobj(src, out)
+
+            y, mo, d, h, mi, s = info.date_time
+            recorded_at = f"{y:04d}-{mo:02d}-{d:02d} {h:02d}:{mi:02d}:{s:02d}"
+            found.append((name, target, recorded_at))
+
+    found.sort(key=lambda item: item[0])
+    return found
+
+
+def probe_duration(path: Path) -> float:
+    result = subprocess.run(
+        [
+            ffprobe_bin(), "-v", "error",
+            "-show_entries", "format=duration",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            str(path),
+        ],
+        capture_output=True,
+        text=True,
+        **_NO_WINDOW,
+    )
+    try:
+        return float(result.stdout.strip())
+    except ValueError:
+        return 0.0
+
+
+def to_wav16k(src: Path, dst: Path) -> None:
+    """Whisperとpyannoteの両方が扱いやすい 16kHz モノラル WAV に変換する。"""
+    result = subprocess.run(
+        [ffmpeg_bin(), "-y", "-i", str(src), "-ac", "1", "-ar", "16000",
+         "-c:a", "pcm_s16le", str(dst)],
+        capture_output=True,
+        **_NO_WINDOW,
+    )
+    if result.returncode != 0:
+        tail = result.stderr.decode("utf-8", "replace").strip().splitlines()[-3:]
+        raise RuntimeError("音声を変換できませんでした: " + " / ".join(tail))
+
+
+# ---------------------------------------------------------------- models
+
+
+_whisper_cache: dict = {}
+_diarizer_cache: dict = {}
+
+
+def load_whisper(backend: str, model_size: str):
+    key = (backend, model_size)
+    if key in _whisper_cache:
+        return _whisper_cache[key]
+
+    if backend == "mlx":
+        import mlx_whisper  # noqa: F401  読み込み確認のみ
+        obj = MLX_MODELS.get(model_size, MLX_MODELS["large-v3"])
+    else:
+        from faster_whisper import WhisperModel
+
+        device, compute_type = "cpu", "int8"
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                device, compute_type = "cuda", "float16"
+        except Exception:
+            pass
+        obj = WhisperModel(model_size, device=device, compute_type=compute_type)
+
+    _whisper_cache[key] = obj
+    return obj
+
+
+def load_diarizer(hf_token: str):
+    if "pipeline" in _diarizer_cache:
+        return _diarizer_cache["pipeline"]
+
+    from pyannote.audio import Pipeline
+
+    pipe = Pipeline.from_pretrained(
+        "pyannote/speaker-diarization-3.1", use_auth_token=hf_token
+    )
+    if pipe is None:
+        raise RuntimeError(
+            "話者分離モデルを読み込めません。HuggingFaceで "
+            "pyannote/speaker-diarization-3.1 と pyannote/segmentation-3.0 の "
+            "利用条件に同意し、有効なトークンを設定してください。"
+        )
+
+    try:  # GPU が使えれば使う（未対応の演算はCPUに落ちる）
+        import torch
+
+        if torch.cuda.is_available():
+            pipe.to(torch.device("cuda"))
+        elif getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+            pipe.to(torch.device("mps"))
+    except Exception:
+        pass
+
+    _diarizer_cache["pipeline"] = pipe
+    return pipe
+
+
+# ---------------------------------------------------------------- core steps
+
+
+def transcribe(wav: Path, backend: str, model, prompt: str) -> list[dict]:
+    if backend == "mlx":
+        import mlx_whisper
+
+        result = mlx_whisper.transcribe(
+            str(wav),
+            path_or_hf_repo=model,
+            language="ja",
+            initial_prompt=prompt or None,
+            condition_on_previous_text=False,
+            no_speech_threshold=0.6,
+            compression_ratio_threshold=2.4,
+            verbose=None,
+        )
+        segments = result.get("segments", [])
+        return [
+            {"start": float(s["start"]), "end": float(s["end"]), "text": s["text"].strip()}
+            for s in segments
+            if s.get("text", "").strip()
+        ]
+
+    segments, _ = model.transcribe(
+        str(wav),
+        language="ja",
+        initial_prompt=prompt or None,
+        vad_filter=True,
+        condition_on_previous_text=False,
+    )
+    return [
+        {"start": float(s.start), "end": float(s.end), "text": s.text.strip()}
+        for s in segments
+        if s.text.strip()
+    ]
+
+
+def diarize(wav: Path, hf_token: str, num_speakers: int | None) -> list[tuple[float, float, str]]:
+    pipe = load_diarizer(hf_token)
+    kwargs = {}
+    if num_speakers and num_speakers > 0:
+        kwargs["num_speakers"] = num_speakers
+    annotation = pipe(str(wav), **kwargs)
+    return [
+        (float(turn.start), float(turn.end), str(label))
+        for turn, _, label in annotation.itertracks(yield_label=True)
+    ]
+
+
+def looks_like_hallucination(text: str) -> bool:
+    return any(p in text for p in HALLUCINATION_PATTERNS)
+
+
+def merge(
+    segments: list[dict],
+    turns: list[tuple[float, float, str]],
+    speaker_names: dict[str, str] | None = None,
+    diarized: bool = True,
+) -> list[Utterance]:
+    """文字起こしの各セグメントに、最も重なりの長い話者を割り当てる。
+
+    話者分離をオフにしたときは話者列を空にする。区間が無いことを
+    「無音部の誤認識」と数えると全行に要確認が付き、印の意味が無くなるため。
+    """
+    speaker_names = speaker_names or {}
+    utterances: list[Utterance] = []
+
+    for seg in segments:
+        best_label, best_overlap = "", 0.0
+        for start, end, label in turns:
+            overlap = min(seg["end"], end) - max(seg["start"], start)
+            if overlap > best_overlap:
+                best_overlap, best_label = overlap, label
+
+        seg_len = max(0.01, seg["end"] - seg["start"])
+        coverage = best_overlap / seg_len
+
+        note = []
+        if diarized:
+            if not best_label:
+                note.append("発話区間と重ならない（無音部の誤認識の可能性）")
+            elif coverage < 0.35:
+                note.append("話者の重なりが少なく判定が不確実")
+        if looks_like_hallucination(seg["text"]):
+            note.append("Whisperの定型幻聴に一致")
+
+        display = speaker_names.get(best_label, best_label or "不明") if diarized else ""
+        utterances.append(
+            Utterance(
+                start=seg["start"],
+                end=seg["end"],
+                speaker=display,
+                text=seg["text"],
+                needs_review=bool(note),
+                review_note=" / ".join(note),
+            )
+        )
+
+    return utterances
+
+
+# ---------------------------------------------------------------- orchestrator
+
+
+def run(
+    zip_path: Path,
+    workdir: Path,
+    min_seconds: float = 30.0,
+    backend: str = "auto",
+    model_size: str = "",
+    hf_token: str = "",
+    num_speakers: int | None = None,
+    prompt: str = DEFAULT_PROMPT,
+    diarization_enabled: bool = True,
+    progress: Callable[[str, int, int], None] | None = None,
+) -> list[FileResult]:
+    ensure_ffmpeg()
+
+    if backend == "auto":
+        backend = "mlx" if is_apple_silicon() else "faster"
+    model_size = model_size or default_model_size()
+
+    audio_dir = workdir / "audio"
+    wav_dir = workdir / "wav"
+    wav_dir.mkdir(parents=True, exist_ok=True)
+
+    def notify(message: str, done: int, total: int) -> None:
+        if progress:
+            progress(message, done, total)
+
+    notify("ZIPを展開しています", 0, 1)
+    files = extract_audio(zip_path, audio_dir)
+    if not files:
+        raise RuntimeError("ZIPの中に音声ファイルが見つかりませんでした。")
+
+    # 長さで先に絞る。ffprobe はデコードしないので大量ファイルでも一瞬で終わる。
+    results: list[FileResult] = []
+    targets: list[tuple[FileResult, Path]] = []
+    for original, path, recorded_at in files:
+        duration = probe_duration(path)
+        entry = FileResult(original_name=original, duration=duration, recorded_at=recorded_at)
+        if duration < min_seconds:
+            entry.status = "skipped"
+            entry.reason = f"{min_seconds:.0f}秒未満"
+        else:
+            targets.append((entry, path))
+        results.append(entry)
+
+    total = len(targets)
+    if total == 0:
+        notify("条件に合う録音がありませんでした", 0, 0)
+        return results
+
+    notify("文字起こしモデルを読み込んでいます", 0, total)
+    model = load_whisper(backend, model_size)
+    if diarization_enabled:
+        notify("話者分離モデルを読み込んでいます", 0, total)
+        load_diarizer(hf_token)
+
+    for index, (entry, path) in enumerate(targets):
+        label = os.path.basename(entry.original_name)
+        try:
+            notify(f"変換中: {label}", index, total)
+            wav = wav_dir / f"{path.stem}.wav"
+            to_wav16k(path, wav)
+
+            notify(f"文字起こし中: {label}", index, total)
+            segments = transcribe(wav, backend, model, prompt)
+
+            turns: list[tuple[float, float, str]] = []
+            if diarization_enabled:
+                notify(f"話者を判定中: {label}", index, total)
+                turns = diarize(wav, hf_token, num_speakers)
+
+            entry.utterances = merge(segments, turns, diarized=diarization_enabled)
+            entry.speakers = sorted({u.speaker for u in entry.utterances if u.speaker})
+            entry.status = "transcribed"
+            wav.unlink(missing_ok=True)
+        except Exception as exc:  # 1ファイルの失敗で全体を止めない
+            entry.status = "error"
+            entry.reason = str(exc)
+
+        notify(f"完了: {label}", index + 1, total)
+
+    return results
+
+
+# ---------------------------------------------------------------- output
+#
+# 出力は「録音1本＝1まとまり」を基本にする。
+#   書き起こし/  … 人が読む用のテキスト（録音ごと）
+#   データ/      … システムに取り込む用のCSV（録音ごと）
+#   処理結果一覧.csv … 何が処理され何が除外されたかの記録
+#   全発話.csv       … 横断で検索・集計したいとき用
+#   録音ごと.xlsx    … Excelで1録音＝1シート
+
+STATUS_LABEL = {"transcribed": "書き起こし済み", "skipped": "除外", "error": "失敗"}
+UTTERANCE_HEADER = ["開始", "終了", "話者", "発話内容", "要確認", "備考"]
+_INVALID_SHEET = re.compile(r"[\[\]:*?/\\]")
+_INVALID_FILE = re.compile(r'[<>:"/\\|?*\x00-\x1f]')
+
+
+def safe_stem(name: str, index: int) -> str:
+    base = _INVALID_FILE.sub("_", os.path.basename(name))
+    return f"{index:03d}_{Path(base).stem}"[:80]
+
+
+def sheet_name(name: str, index: int, used: set[str]) -> str:
+    base = _INVALID_SHEET.sub("_", Path(os.path.basename(name)).stem) or "録音"
+    candidate = f"{index:02d}_{base}"[:31]
+    suffix = 1
+    while candidate in used:
+        candidate = f"{candidate[:28]}_{suffix}"
+        suffix += 1
+    used.add(candidate)
+    return candidate
+
+
+def transcript_text(entry: FileResult) -> str:
+    """1録音分の、人がそのまま読める書き起こし。"""
+    rule = "─" * 52
+    flagged = sum(1 for u in entry.utterances if u.needs_review)
+
+    lines = [
+        rule,
+        os.path.basename(entry.original_name),
+        rule,
+        f"録音日時   {entry.recorded_at or '不明'}",
+        f"録音長     {hhmmss(entry.duration)}（{entry.duration:.0f}秒）",
+        f"話者       {'、'.join(entry.speakers) if entry.speakers else '判定なし'}",
+        f"状態       {STATUS_LABEL.get(entry.status, entry.status)}"
+        + (f" — {entry.reason}" if entry.reason else ""),
+        "",
+    ]
+
+    if entry.status != "transcribed":
+        lines.append(entry.reason or "書き起こしはありません。")
+        return "\n".join(lines) + "\n"
+
+    if not entry.utterances:
+        lines.append("発話を検出できませんでした。")
+        return "\n".join(lines) + "\n"
+
+    for u in entry.utterances:
+        mark = f"  ※要確認（{u.review_note}）" if u.needs_review else ""
+        who = f"  {u.speaker}" if u.speaker else ""
+        lines.append(f"{hhmmss(u.start)}{who}{mark}")
+        lines.append(f"    {u.text}")
+        lines.append("")
+
+    lines.append(rule)
+    lines.append(f"全 {len(entry.utterances)} 発話 / 要確認 {flagged} 件")
+    lines.append("※ 話者名は自動判定の仮ラベルです。担当者名への置き換えと内容の確認をしてください。")
+    return "\n".join(lines) + "\n"
+
+
+def _write_rows(path: Path, header: list[str], rows: list[list]) -> Path:
+    # Excel（Mac版含む）で文字化けしないよう BOM 付き UTF-8 で書く
+    with open(path, "w", encoding="utf-8-sig", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(header)
+        writer.writerows(rows)
+    return path
+
+
+def write_file_csv(entry: FileResult, path: Path) -> Path:
+    rows = [
+        [
+            hhmmss(u.start), hhmmss(u.end), u.speaker, u.text,
+            "要確認" if u.needs_review else "", u.review_note,
+        ]
+        for u in entry.utterances
+    ]
+    return _write_rows(path, UTTERANCE_HEADER, rows)
+
+
+def write_index_csv(results: Iterable[FileResult], path: Path) -> Path:
+    rows = []
+    for i, entry in enumerate(results, 1):
+        rows.append([
+            i,
+            entry.original_name,
+            entry.recorded_at,
+            hhmmss(entry.duration),
+            f"{entry.duration:.1f}",
+            STATUS_LABEL.get(entry.status, entry.status),
+            entry.reason,
+            len(entry.utterances),
+            sum(1 for u in entry.utterances if u.needs_review),
+            "、".join(entry.speakers),
+        ])
+    header = [
+        "No", "ファイル名", "録音日時", "録音長", "録音長(秒)",
+        "状態", "備考", "発話数", "要確認数", "話者",
+    ]
+    return _write_rows(path, header, rows)
+
+
+def write_all_csv(results: Iterable[FileResult], path: Path) -> Path:
+    rows = []
+    for entry in results:
+        if entry.status != "transcribed":
+            continue
+        for u in entry.utterances:
+            rows.append([
+                entry.original_name, entry.recorded_at, f"{entry.duration:.1f}",
+                hhmmss(u.start), hhmmss(u.end), u.speaker, u.text,
+                "要確認" if u.needs_review else "", u.review_note,
+            ])
+    header = ["ファイル名", "録音日時", "録音長(秒)"] + UTTERANCE_HEADER
+    return _write_rows(path, header, rows)
+
+
+def write_xlsx(results: list[FileResult], path: Path) -> Path | None:
+    """1録音＝1シート。先頭に一覧シートを置く。openpyxl が無ければ何もしない。"""
+    try:
+        from openpyxl import Workbook
+        from openpyxl.styles import Alignment, Font, PatternFill
+        from openpyxl.utils import get_column_letter
+    except ImportError:
+        return None
+
+    head_font = Font(name="Arial", bold=True, color="FFFFFF")
+    head_fill = PatternFill("solid", fgColor="1F5F5B")
+    body_font = Font(name="Arial")
+    warn_font = Font(name="Arial", color="8A5512")
+    wrap = Alignment(vertical="top", wrap_text=True)
+    top = Alignment(vertical="top")
+
+    wb = Workbook()
+    overview = wb.active
+    overview.title = "一覧"
+
+    ov_header = ["No", "ファイル名", "録音日時", "録音長", "状態", "備考", "発話数", "要確認数", "話者"]
+    overview.append(ov_header)
+    for i, entry in enumerate(results, 1):
+        overview.append([
+            i, entry.original_name, entry.recorded_at, hhmmss(entry.duration),
+            STATUS_LABEL.get(entry.status, entry.status), entry.reason,
+            len(entry.utterances),
+            sum(1 for u in entry.utterances if u.needs_review),
+            "、".join(entry.speakers),
+        ])
+    for width, col in zip([5, 38, 20, 11, 15, 26, 9, 10, 22], range(1, 10)):
+        overview.column_dimensions[get_column_letter(col)].width = width
+    overview.freeze_panes = "A2"
+
+    used: set[str] = set()
+    for i, entry in enumerate(results, 1):
+        if entry.status != "transcribed":
+            continue
+        ws = wb.create_sheet(sheet_name(entry.original_name, i, used))
+
+        ws["A1"] = os.path.basename(entry.original_name)
+        ws["A1"].font = Font(name="Arial", bold=True, size=13)
+        ws["A2"] = f"録音日時 {entry.recorded_at or '不明'} ／ 録音長 {hhmmss(entry.duration)}"
+        ws["A3"] = f"話者 {'、'.join(entry.speakers) or '判定なし'}"
+        ws["A4"] = "※ 話者名は自動判定の仮ラベルです。要確認の行は内容を確認してください。"
+        for row in ("A2", "A3", "A4"):
+            ws[row].font = Font(name="Arial", size=10, color="5A636B")
+
+        ws.append([])
+        ws.append(UTTERANCE_HEADER)
+        for cell in ws[6]:
+            cell.font, cell.fill = head_font, head_fill
+
+        for u in entry.utterances:
+            ws.append([
+                hhmmss(u.start), hhmmss(u.end), u.speaker, u.text,
+                "要確認" if u.needs_review else "", u.review_note,
+            ])
+
+        for row in ws.iter_rows(min_row=7):
+            flagged = row[4].value == "要確認"
+            for cell in row:
+                cell.font = warn_font if flagged else body_font
+                cell.alignment = wrap if cell.column == 4 else top
+
+        for width, col in zip([10, 10, 15, 76, 10, 30], range(1, 7)):
+            ws.column_dimensions[get_column_letter(col)].width = width
+        ws.freeze_panes = "A7"
+
+    for cell in overview[1]:
+        cell.font, cell.fill = head_font, head_fill
+
+    wb.save(path)
+    return path
+
+
+def build_outputs(results: list[FileResult], outdir: Path, job_id: str) -> dict[str, Path]:
+    """録音ごとのファイル群を作り、まとめてZIPにする。"""
+    outdir.mkdir(parents=True, exist_ok=True)
+    text_dir = outdir / "書き起こし"
+    data_dir = outdir / "データ"
+    text_dir.mkdir(exist_ok=True)
+    data_dir.mkdir(exist_ok=True)
+
+    per_file: list[dict] = []
+    for i, entry in enumerate(results, 1):
+        stem = safe_stem(entry.original_name, i)
+        txt = text_dir / f"{stem}.txt"
+        txt.write_text(transcript_text(entry), encoding="utf-8")
+        record = {"index": i, "stem": stem, "txt": txt, "csv": None}
+        if entry.status == "transcribed" and entry.utterances:
+            record["csv"] = write_file_csv(entry, data_dir / f"{stem}.csv")
+        per_file.append(record)
+
+    index_csv = write_index_csv(results, outdir / "処理結果一覧.csv")
+    all_csv = write_all_csv(results, outdir / "全発話.csv")
+    xlsx = write_xlsx(results, outdir / "録音ごと.xlsx")
+
+    bundle = outdir.parent / f"文字起こし_{job_id}.zip"
+    with zipfile.ZipFile(bundle, "w", zipfile.ZIP_DEFLATED) as zf:
+        root = f"文字起こし_{job_id}"
+        zf.write(index_csv, f"{root}/処理結果一覧.csv")
+        zf.write(all_csv, f"{root}/全発話.csv")
+        if xlsx:
+            zf.write(xlsx, f"{root}/録音ごと.xlsx")
+        for record in per_file:
+            zf.write(record["txt"], f"{root}/書き起こし/{record['stem']}.txt")
+            if record["csv"]:
+                zf.write(record["csv"], f"{root}/データ/{record['stem']}.csv")
+
+    return {
+        "bundle": bundle,
+        "index_csv": index_csv,
+        "all_csv": all_csv,
+        "xlsx": xlsx,
+        "per_file": per_file,
+    }

requirements.txt

@@ -0,0 +1,12 @@
+fastapi>=0.110
+uvicorn[standard]>=0.27
+python-multipart>=0.0.9
+
+# 文字起こし（Windows は CPU で faster-whisper を使う）
+faster-whisper>=1.1
+
+# 話者分離。torch / torchaudio も一緒に入る。
+# torch は setup.ps1 が先に CPU 版を入れておくので、ここでは CUDA 版を引かない。
+pyannote.audio>=3.1
+
+openpyxl>=3.1

setup.ps1

@@ -0,0 +1,23 @@
+# 録音文字起こし（Windows）セットアップ
+# 使い方: PowerShell で  .\setup.ps1
+$ErrorActionPreference = "Stop"
+Set-Location $PSScriptRoot
+
+if (-not (Test-Path ".venv")) {
+    Write-Host "[1/4] Python 仮想環境を作ります"
+    & "$env:LOCALAPPDATA\Programs\Python\Python312\python.exe" -m venv .venv
+}
+
+$py = ".\.venv\Scripts\python.exe"
+
+Write-Host "[2/4] pip を更新します"
+& $py -m pip install --upgrade pip --quiet
+
+Write-Host "[3/4] torch(CPU版) を入れます。数分かかります"
+& $py -m pip install torch torchaudio --index-url https://download.pytorch.org/whl/cpu
+
+Write-Host "[4/4] 残りのライブラリを入れます。数分かかります"
+& $py -m pip install -r requirements.txt
+
+Write-Host ""
+Write-Host "完了。起動は  .\start.cmd" -ForegroundColor Green

start.cmd

@@ -0,0 +1,12 @@
+@echo off
+chcp 65001 > nul
+cd /d "%~dp0"
+
+if not exist ".venv\Scripts\python.exe" (
+  echo セットアップがまだです。PowerShell で setup.ps1 を実行してください。
+  pause
+  exit /b 1
+)
+
+start "" http://127.0.0.1:8000
+".venv\Scripts\python.exe" app.py