throughline 0.4.12 → 0.6.0

package/rag/02-messages-api/raw/messages-api-extract.md

@@ -0,0 +1,126 @@
+# Anthropic Messages API — Extract
+
+Source: <https://platform.claude.com/docs/en/api/messages> (fetched 2026-05-24)
+
+## Messages array structure
+
+### Role values
+
+Only `"user"` and `"assistant"`. No `"system"` role in messages[].
+
+> "Our models are trained to operate on alternating `user` and `assistant` conversational turns."
+
+> "Consecutive `user` or `assistant` turns in your request will be combined into a single turn."
+
+### Content block types
+
+Each message's `content` is either a string (shorthand for `[{"type": "text", "text": "..."}]`) or an array of `ContentBlockParam`.
+
+| Type | Schema | Purpose |
+|---|---|---|
+| `text` | `{type: "text", text, cache_control?, citations?}` | Plain text |
+| `image` | `{type: "image", source, cache_control?}` | Images |
+| `document` | `{type: "document", source, title?, context?, citations?, cache_control?}` | PDF / plain text |
+| `tool_use` | `{type: "tool_use", id, name, input, caller?, cache_control?}` | Model's tool invocation |
+| `tool_result` | `{type: "tool_result", tool_use_id, content?, is_error?, cache_control?}` | Tool execution result |
+| `thinking` | `{type: "thinking", thinking, signature}` | Extended thinking (input only) |
+| `redacted_thinking` | `{type: "redacted_thinking", data}` | Redacted thinking |
+| `search_result` | `{type: "search_result", title, source, content, cache_control?, citations?}` | Web search results |
+| `server_tool_use` | `{type: "server_tool_use", id, name, input, caller?, cache_control?}` | Server-side tool execution |
+
+---
+
+## System field (top-level)
+
+```json
+{
+  "system": "You are a helpful assistant.",
+  "messages": [{"role": "user", "content": "Hello"}]
+}
+```
+
+> "Note that if you want to include a system prompt, you can use the top-level `system` parameter — there is no `system` role for input messages in the Messages API."
+
+`system` accepts string OR `TextBlockParam[]`:
+
+```json
+{
+  "system": [
+    {"type": "text", "text": "Today's date is 2024-06-01.",
+     "cache_control": {"type": "ephemeral", "ttl": "5m"}}
+  ]
+}
+```
+
+---
+
+## Conversation continuation & synthetic messages (CRITICAL FOR THROUGHLINE)
+
+### Synthetic assistant prefill
+
+> "If the final message uses the `assistant` role, the response content will continue immediately from the content in that message. This can be used to constrain part of the model's response."
+
+Example:
+
+```json
+{
+  "messages": [
+    {"role": "user", "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"},
+    {"role": "assistant", "content": "The best answer is ("}
+  ]
+}
+```
+
+Response: model continues from `"The best answer is ("` and outputs `"B)"`.
+
+### No differentiation between real & synthetic messages (KEY)
+
+> "When creating a new `Message`, you specify the prior conversational turns with the `messages` parameter, and the model then generates the next `Message` in the conversation."
+
+**The documentation does not distinguish between:**
+
+- Historically real messages from past API calls
+- Newly constructed/injected synthetic messages in the current request
+
+→ Models treat all messages equally regardless of source. **No metadata field indicates whether a message was real or synthetic.**
+
+This validates the D-route theory: IF we could inject prior turns into messages[], the model would treat them as continuation. The question is purely about **how to control messages[] from within Claude Code**.
+
+### Turn combining
+
+> "Consecutive `user` or `assistant` turns in your request will be combined into a single turn."
+
+This applies uniformly regardless of source.
+
+---
+
+## Fields outside messages[]
+
+Top-level request parameters (relevant for context):
+
+| Parameter | Type | Purpose |
+|---|---|---|
+| `system` | `string \| TextBlockParam[]` | System prompt |
+| `model` | `string` | Required |
+| `max_tokens` | `number` | Required |
+| `temperature`, `top_p`, `top_k`, `stop_sequences` | — | sampling |
+| `tools`, `tool_choice` | — | Tool definitions |
+| `thinking` | `ThinkingConfig` | Extended thinking budget |
+| `stream` | `boolean` | Streaming |
+| `metadata` | `{user_id?}` | Request tracking |
+| `cache_control` | `CacheControlEphemeral` | Top-level cache marker |
+| `service_tier` | `"auto" \| "standard_only"` | Capacity tier |
+| `output_config` | `{format?, effort?}` | Output formatting |
+
+No "transcript" or "session_history" field — all conversation context goes through `messages[]` or `system`.
+
+---
+
+## Implications for Throughline
+
+1. **Only `messages[]` carries "real" conversation history**. `system` is briefing material.
+2. **The model treats all `messages[]` entries equally** — synthetic past turns are indistinguishable from real ones.
+3. **For "本人体感" (the assistant feeling like it was the one talking), the past turns MUST be in `messages[]`, not in `system`.**
+4. **Synthetic assistant prefill is officially supported** — we could end messages[] with an assistant turn to constrain continuation.
+
+→ Claude Code's challenge: how does CC build the API request's `messages[]`? If we can influence that (via `initialUserMessage` or another mechanism), we can solve the "本人体感" problem.

package/rag/03-settings/raw/sessions-extract.md

@@ -0,0 +1,64 @@
+# Claude Code Sessions — Extract
+
+Source: <https://code.claude.com/docs/en/sessions> (fetched 2026-05-24)
+
+## Session storage
+
+- JSONL at `~/.claude/projects/<project>/<session-id>.jsonl`
+- `<project>` derived from working directory path
+- Each line is a JSON object (message / tool use / metadata)
+- Override storage location: `CLAUDE_CONFIG_DIR` env var
+- Default retention: 30 days, configurable via `cleanupPeriodDays`
+- Disable transcript writes: `CLAUDE_CODE_SKIP_PROMPT_HISTORY` (env), or `--no-session-persistence` (CLI flag)
+
+## Resume / continue
+
+| Command | Behavior |
+|---|---|
+| `claude --continue` | Resumes most recent session in current directory |
+| `claude --resume` | Opens session picker |
+| `claude --resume <name>` | Resumes named session directly |
+| `claude --from-pr <number>` | Resumes session linked to PR |
+| `/resume` (inside session) | Switches to a different conversation |
+
+## /clear behavior (KEY)
+
+> `/clear`: start fresh with an empty context. **The previous conversation is saved and resumable**.
+
+- /clear empties CC's in-memory context buffer
+- Previous conversation remains in JSONL, retrievable via `--continue` / `--resume`
+- This implies CC has BOTH an in-memory state AND the persisted JSONL — and after /clear, the in-memory state is reset but the file is preserved
+
+## /compact behavior
+
+> `/compact [instructions]`: replace history with a summary, optionally focused on what you specify
+
+- Summarizes existing context in-place
+- Optionally focused via instructions
+- Triggers `PreCompact` / `PostCompact` hooks (mid-session events)
+
+## /context
+
+> `/context`: show what is currently consuming context
+
+## Branch / fork
+
+> `/branch [name]` or `--fork-session` with `--continue` / `--resume`:
+> Creates a copy of the conversation so far and switches into it, leaving the original intact.
+
+- Permission grants don't carry over to new branch
+- Resuming the same session in two terminals interleaves messages into one transcript
+
+## Naming
+
+- `claude -n <name>` (at startup)
+- `/rename <name>` (mid-session)
+- `Ctrl+R` in session picker
+- Auto-naming on plan accept
+
+## Implications for Throughline
+
+1. **/clear preserves JSONL**. CC's in-memory state is the canonical source for the new session's messages[], NOT the JSONL.
+2. **/compact preserves session continuity** — same session_id, just summarized. This is the documented "memory preservation" path.
+3. **`--continue` / `--resume` are the official "restore from JSONL" mechanisms** but they pull the WHOLE prior conversation (no Throughline-style L1/L2/L3 selective compression).
+4. **There's no documented hook to influence in-memory state after /clear**, only context attachments (system reminders).

package/rag/04-skills/raw/initialUserMessage-investigation.md

@@ -0,0 +1,101 @@
+# `initialUserMessage` Field — Investigation Results
+
+## Sources
+
+- Official hooks reference: <https://code.claude.com/docs/en/hooks> (mentions field in SessionStart hookSpecificOutput shape)
+- First-party hook-dev SKILL: <https://github.com/anthropics/claude-code/blob/main/plugins/plugin-dev/skills/hook-development/SKILL.md> (does NOT mention)
+- Open-source CC implementation `Gitlawb/openclaude`:
+  - `src/utils/hooks.ts` — schema definition
+  - `src/utils/sessionStart.ts` — storage + retrieval mechanism
+  - `src/cli/print.ts` — consumer (the critical one)
+  - `src/main.tsx` — initialMessages array construction
+
+## The schema (confirmed)
+
+```typescript
+// From openclaude src/utils/hooks.ts and src/types/hooks.ts
+interface HookResult {
+  additionalContext?: string
+  initialUserMessage?: string
+  watchPaths?: string[]
+  updatedInput?: Record<string, unknown>
+  // ...
+}
+
+// SessionStart hook output processing
+case 'SessionStart':
+  result.additionalContext = json.hookSpecificOutput.additionalContext
+  result.initialUserMessage = json.hookSpecificOutput.initialUserMessage
+  if ('watchPaths' in json.hookSpecificOutput && json.hookSpecificOutput.watchPaths) {
+    result.watchPaths = json.hookSpecificOutput.watchPaths
+  }
+  break
+```
+
+## The CRITICAL constraint (from openclaude source comment)
+
+```typescript
+// src/cli/print.ts:
+// SessionStart hooks can emit initialUserMessage — the first user turn for
+// headless orchestrator sessions where stdin is empty.
+takeInitialUserMessage,
+```
+
+**`initialUserMessage` is for HEADLESS MODE ONLY.** It's invoked when `claude -p` is launched and stdin doesn't provide a prompt — the hook can supply the "first user turn" as a substitute.
+
+## Storage / consumption mechanism
+
+```typescript
+// src/utils/sessionStart.ts
+// Set by processSessionStartHooks when a hook emits initialUserMessage;
+// consumed once by takeInitialUserMessage. This side channel avoids changing
+// the return type of processSessionStartHooks.
+let pendingInitialUserMessage: string | undefined = undefined
+
+if (hookResult.initialUserMessage) {
+  pendingInitialUserMessage = hookResult.initialUserMessage
+}
+
+export function takeInitialUserMessage(): string | undefined {
+  const v = pendingInitialUserMessage
+  pendingInitialUserMessage = undefined
+  return v
+}
+```
+
+```typescript
+// src/cli/print.ts
+const hookInitialUserMessage = takeInitialUserMessage()
+if (hookInitialUserMessage) {
+  structuredIO.prependUserMessage(hookInitialUserMessage)
+}
+// then runHeadlessStreaming() processes the queue
+```
+
+## What this means for Throughline
+
+`initialUserMessage` does NOT solve the `/clear` continuation problem because:
+
+1. `/clear` is an INTERACTIVE mode operation
+2. Interactive mode always has a user typing the next prompt — there's no "missing first user message" slot to fill
+3. `initialUserMessage` is consumed by `print.ts` (print mode = `claude -p`), not by the interactive REPL
+
+**Conclusion**: `initialUserMessage` is the wrong tool for our problem. It can't be used to make `/clear` continuation feel native.
+
+## What IS the right tool? (As of this research)
+
+For interactive `/clear`-then-prompt continuity, the available hook surfaces are:
+
+- `additionalContext` → system reminder ("briefing" framing, what we have now)
+- `stdout` (SessionStart/UserPromptSubmit/UserPromptExpansion) → system reminder (same as above)
+- `PreCompact`/`PostCompact` hooks → fire on /compact, not /clear (different code path)
+- `decision: block` for UserPromptSubmit → can block prompts, doesn't help inject memory
+- Modifying transcript JSONL externally → ignored by CC's in-memory parent chain (proven dead via Phase 0 experiments)
+
+**The current Claude Code hook system does NOT provide a documented mechanism to inject true conversation history (messages[]) into an interactive session after /clear.**
+
+The only paths that would solve this are:
+
+1. **Use /compact instead of /clear** — preserves session continuity in-place; PreCompact hook can influence the summary
+2. **Agent SDK rewrite (E)** — bypass Claude Code's REPL, build a custom runtime that controls messages[] directly
+3. **API-level proxy** — intercept the Claude Code → Anthropic API call and rewrite messages[]

package/rag/INDEX.md

@@ -0,0 +1,164 @@
+# Throughline RAG Index — Context Spec Knowledge Base
+
+Built: 2026-05-24
+
+This directory accumulates third-party specifications relevant to Throughline's mission ("コンテキスト削減しつつ過去の記憶を一切失わない") so design decisions are grounded in actual Claude Code / Anthropic API constraints rather than guesses.
+
+## Folder layout
+
+```text
+rag/
+├── INDEX.md (this file — synthesized findings, paths forward)
+├── 01-hooks/
+│   ├── raw/hooks-reference-extract.md      ← Claude Code hooks reference
+│   └── raw/session-end-reasons.md          ← SessionEnd reason enum + timeout 1.5s (2026-07-11 fetch)
+├── 02-messages-api/
+│   └── raw/messages-api-extract.md         ← Anthropic Messages API spec
+├── 03-settings/
+│   └── raw/sessions-extract.md             ← /clear, /compact, /resume behavior
+└── 04-skills/
+    └── raw/initialUserMessage-investigation.md ← deep-dive on the killer field
+```
+
+---
+
+## Question this RAG was built to answer
+
+> Throughline は「コンテキスト削減しつつ過去の記憶を一切失わない」と定義されている。記憶を引き継いでいてもモデルがそれを自分の作業履歴として体感していないなら、その記憶は無意味なコンテキストである。
+>
+> Claude Code の hook 系内で **モデルが「これは自分の過去発話である」と認識する形** で記憶を注入する経路は、本当に存在しないのか?
+
+## Hard findings from spec (verified, not guessed)
+
+### Finding 1: `additionalContext` is a system reminder, not a user message
+
+> "Claude Code wraps the string in a system reminder and inserts it into the conversation at the point where the hook fired. Claude reads the reminder on the next model request, but it **does not appear as a chat message** in the interface."
+> — [Hooks reference](01-hooks/raw/hooks-reference-extract.md#what-additionalcontext-actually-does-critical)
+
+→ システムリマインダ = ブリーフィング扱い。モデルが「他人事」と感じる構造的原因。
+
+### Finding 2: stdout from `SessionStart` / `UserPromptSubmit` / `UserPromptExpansion` is also a system reminder
+
+> "any non-JSON text written to stdout is added as context"
+> "Claude Code wraps the string in a system reminder"
+> — [Hooks reference](01-hooks/raw/hooks-reference-extract.md#stdout)
+
+→ 現行 Throughline v0.4.12 の stdout 注入はこの経路。`additionalContext` と同じカテゴリ = 同じ「他人事」問題。
+
+### Finding 3: `initialUserMessage` exists in the schema, but is **HEADLESS-ONLY**
+
+Verified via [openclaude source](04-skills/raw/initialUserMessage-investigation.md#the-critical-constraint-from-openclaude-source-comment):
+
+```text
+// SessionStart hooks can emit initialUserMessage — the first user turn for
+// headless orchestrator sessions where stdin is empty.
+```
+
+→ Interactive mode (`/clear` シナリオ) では発火しない。我々の問題には使えない。
+
+**2026-05-24 実機確認**: real Claude Code (v2.1.145) で `~/.throughline/initial-user-message-test.flag` を立てて SessionStart hook を JSON 出力モードに切り替え、`hookSpecificOutput.initialUserMessage` に 8 hex tracer 入りメッセージを乗せて `/clear` 後の cleared-me に「過去発話の tracer を message history だけ見て返して」と尋ねた。ラン (2) 13:33 tracer `9220a79c` (session `0979ad20-…`) → モデル応答 **「ない」**。openclaude のソースコメントが real CC でも妥当であることを実機で確認。詳細: [docs/10_transcript_injection_plan.md §6 Phase 0-6](../docs/10_transcript_injection_plan.md#phase-0-6--hookspecificoutputinitialusermessage-経路-spike)
+
+### Finding 4: Messages API treats all messages[] entries equally
+
+> "When creating a new Message, you specify the prior conversational turns with the messages parameter, and the model then generates the next Message in the conversation."
+> — [Messages API](02-messages-api/raw/messages-api-extract.md#no-differentiation-between-real--synthetic-messages-key)
+
+→ もし messages[] に synthetic な過去 turn を入れられれば、モデルは「本物」と区別できない。問題は CC が messages[] を hook から制御させていないこと。
+
+### Finding 5: `/clear` preserves the JSONL but resets in-memory state
+
+> "/clear: start fresh with an empty context. The previous conversation is saved and resumable"
+> — [Sessions](03-settings/raw/sessions-extract.md#clear-behavior-key)
+
+→ CC は in-memory state を一次ソースに messages[] を構築。JSONL を外から書き換えても in-memory には反映されない (= Phase 0 / Phase 0-5 で実測確認済み)。
+
+### Finding 6: `/compact` is the documented memory-preservation path
+
+> "/compact [instructions]: replace history with a summary"
+
+→ /compact は同一 session を継続したまま履歴を要約版に置換。**PreCompact / PostCompact hook が発火**。これが Anthropic 公式の「記憶圧縮しつつ継続」経路。
+
+### Finding 7: First-party hook-dev SKILL omits `initialUserMessage`
+
+[anthropics/claude-code/plugins/plugin-dev/skills/hook-development/SKILL.md](https://github.com/anthropics/claude-code/blob/main/plugins/plugin-dev/skills/hook-development/SKILL.md) は SessionStart hook の `hookSpecificOutput` の `additionalContext` も `initialUserMessage` も触れていない。Plugin 開発者向けの公式チュートリアルですら触れない = どちらも primary 経路として推奨されていない可能性。
+
+### Finding 8: SessionEnd has a `clear` reason; built-in `/clear` never reaches UserPromptSubmit (2026-07-11)
+
+SessionEnd reason enum: `clear|resume|logout|prompt_input_exit|bypass_permissions_disabled|other`、default timeout 1.5s（/clear にも適用）— [session-end-reasons.md](01-hooks/raw/session-end-reasons.md)。実測: ビルトイン /clear はどのクライアントでも UserPromptSubmit に届かない（同一セッション /tl 対照実験 ×2 + VSCode 2.1.207）。VSCode は `source:"clear"` を送るが Desktop 2.1.205 は `source:"startup"`（クライアント実装差・バージョン交絡棄却済み）。→ Desktop の /clear 検知は SessionEnd(reason='clear') が唯一の hook 経路候補（実機検証は [docs/12](../docs/12_desktop_clear_handoff_plan.md) A Phase 1）。
+
+---
+
+## Throughline 仮説の見直し
+
+### 当初仮説 (D 経路)
+
+「JSONL に user/assistant 行を append すれば、CC が messages[] 構築時にそれを読む」
+
+**実測 (4 ラン): すべて「ない」 → 反証済み**
+
+JSONL は read 対象ではなく、CC の in-memory state が messages[] のソース。書き込んでも再読込されない。
+
+### 第二仮説 (initialUserMessage)
+
+「`initialUserMessage` で interactive モードでも first user message を注入できる」
+
+**spec 調査 (openclaude source): HEADLESS-ONLY → 反証済み**
+
+### 第三仮説 (PreCompact での再投影)
+
+未検証。`/compact` のタイミングで PreCompact hook が「これを summary に必ず含めろ」と影響を与えられるなら、compaction 後の messages[] は本物の assistant turn として要約を含む可能性。
+
+---
+
+## ここから取れる現実的な道 (3 つ)
+
+### 道 A: スコープを `/compact` に切り替え
+
+- Throughline は `/clear` を諦め、`/compact` への置換を提案
+- PreCompact hook で「直近 N turn を保持し、それ以前を summary に置換」のロジックを差し込む
+- 同一 session 内なので messages[] は real assistant turn として要約を持つ → 本人体感を維持
+- 制約: ユーザーの習慣 ("/clear で切り替える") から外れる; /compact は context full のときに自動発火する別経路でもあるので、頻発させると体感が変わる
+- **`/clear` シナリオには適用できない** (構造的に別物)
+
+### 道 B: Agent SDK / 自前ランタイム (= E)
+
+- Claude Code を捨てて Agent SDK (Python or TypeScript) でラッパーを書く
+- messages[] を完全制御 — synthetic user/assistant turn を自由に prepend
+- /clear に相当する UX は自前で実装、内部的には messages[] を選択的に圧縮
+- 制約: 大改修。Throughline は plugin から product になる
+- これが「本人体感」を達成する唯一の正攻法
+
+### 道 C: 現状受容 + A2.0 文言調整
+
+- 現行 stdout 注入のままで継続
+- 案内文の文言を改善 (現行 A 実装) で「他人事感」を多少緩和
+- 「本人体感」までは届かないが、「『何のこと？』が出ない」レベルは達成済み
+- 制約: Throughline のミッション定義 (「体感」まで含む) を満たさない
+
+---
+
+## 推奨される判断順
+
+1. **Throughline のミッション定義の再確認**:
+   - 「体感まで保証」が必須 → 道 B (E pivot) しかない。CC plugin である限り構造的に不可能。
+   - 「配送までで OK、体感は best-effort」 → 道 C で十分。
+
+2. **`/clear` という UI シグナルへのこだわり**:
+   - 必須 → 道 B または C。/compact は別物。
+   - 妥協可能 → 道 A も視野 (ユーザーに /compact を勧める)
+
+3. **着手コスト**:
+   - 道 C: 小 (文言調整のみ。実装済み)
+   - 道 A: 中 (PreCompact hook + summary 制御)
+   - 道 B: 大 (別プロジェクト相当)
+
+---
+
+## 蓄積予定 (今後 RAG に足すべき調査)
+
+- [ ] PreCompact / PostCompact hook の詳細仕様 (specific output schema)
+- [ ] Agent SDK Python / TypeScript の messages[] 制御 API
+- [ ] `claude --continue` / `--resume` の実 messages[] 構築フロー (JSONL → API call の変換)
+- [ ] CC のバージョンによる hook 挙動差分 (2.1.128 で source='clear' が変わった等)
+- [ ] 他の OSS CC 互換実装 (openclaude 以外) の messages[] 構築コード
+- [ ] Codex の同等問題と解決手法 (Throughline は Claude / Codex 両対応)

package/src/baton.mjs

@@ -1,7 +1,7 @@
 /**
  * baton.mjs — 引き継ぎバトン管理
  *
- * バトン方式の設計 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md):
+ * バトン方式の設計 (docs/02_clear_auto_handoff_plan.md):
  *   - 新仕様では `/clear` 自動引継ぎがデフォルト ON。バトンは「/clear 自動引継ぎを
  *     使わずに明示的に引き継ぎたい」ユーザーのための逃げ道。
  *   - ユーザーが旧セッションで `/tl` スラッシュコマンドを打つ → UserPromptSubmit hook が
@@ -14,7 +14,7 @@
  *       "startup" に潰される問題 (#49937) に対する明示意思マーカーとして導入。
  *       2026-05-08 時点で Claude Code 2.1.128 で source='clear' は reliable に
  *       なったため auto path 中心の設計に変わったが、明示意思の signal として
- *       baton 仕組み自体は残す。詳細は docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md。
+ *       baton 仕組み自体は残す。詳細は docs/02_clear_auto_handoff_plan.md。
  */
 
 /**

package/src/db.mjs

@@ -180,7 +180,7 @@ function initSchema(db) {
   // v5 → v6: handoff_batons テーブル追加（/tl スラッシュコマンドによる明示的引き継ぎ指名用）
   // - project_path ごとに最新 1 件のみ (PRIMARY KEY)
   // - SessionStart で読み出し、TTL 以内なら merge して DELETE
-  // - docs/INHERITANCE_ON_CLEAR_ONLY.md 参照: 案 D (時間差) 撤去、バトン方式へ移行
+  // - docs/03_inheritance_on_clear_only.md 参照: 案 D (時間差) 撤去、バトン方式へ移行
   if (version < 6) {
     db.exec(`
       CREATE TABLE IF NOT EXISTS handoff_batons (
@@ -203,7 +203,7 @@ function initSchema(db) {
   }
 
   // v7 → v8: handoff_batons から memo_text 列を drop。
-  // 新仕様 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md) で memo 廃止:
+  // 新仕様 (docs/02_clear_auto_handoff_plan.md) で memo 廃止:
   //   - /clear 自動引継ぎ (SessionStart source='clear') + /tl baton (memo なし) の 2 経路に
   //   - 注入は L1 + L2 + L3 refs のみ
   //   - save-inflight CLI / updateBatonMemo 関数も併せて削除