throughline 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -10,6 +10,42 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.8.0] — 2026-07-18
+
+### Changed (breaking behavior)
+
+- **Injection is now push/pull, and L1 is no longer injected (ADR 0016).** The
+  budgeted resume context (9,500 chars) is rebuilt as: header +
+  current-position anchor + an always-shown retrieval-guide section as the
+  fixed part, then the **entire remaining budget is filled with L2 turns in
+  full**, newest-first, turn-atomically (a user+assistant pair goes in whole
+  or not at all — no fixed N, no fragment packing). L1 summaries are no longer
+  injected; older memory is pulled on demand instead. The guide section bakes
+  in the exact session id, ISO-millisecond boundary (strict less-than) and
+  turn counts at injection time, so the pull side never recomputes the window.
+
+### Added
+
+- **`throughline recall --l2|--l1` (ADR 0016).** Read-only pull commands the
+  injected guide section points at. `recall --l2 --session <id> --before
+  <ISO ms> --last <N>` returns the N turns of full L2 bodies older than the
+  boundary, in the same line grammar as the injection (including L3 inline
+  suffixes). `recall --l1 ... --skip <N>` lists every turn older than the
+  `--l2` range with its L1 summary, honestly marking unsummarized turns
+  ("全 M ターン / 要約済み K") and always pointing at `throughline detail
+  <time>` for full text. The DB is opened read-only; a missing DB is an
+  explicit error and is never created or migrated.
+
+### Fixed
+
+- **Windows ACL scripts get a 15s timeout (was 3s).** On windows-latest CI
+  runners a cold PowerShell start was measured at 3.0–3.2s, so the 3s
+  `spawnSync` cap killed the ACL apply/verify scripts of the completed-turn
+  receipt store and the runtime error store and surfaced as a flaky
+  "Windows owner-only ACL verification failed" (2 consecutive runs, including
+  a docs-only commit). The explicit hard-failure contract is unchanged; only
+  the cap was raised.
+
 ## [0.7.0] — 2026-07-17
 
 ### Changed (breaking behavior)
@@ -1063,7 +1099,10 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon-rgb/Throughline/compare/v0.6.2...HEAD
+[Unreleased]: https://github.com/kitepon-rgb/Throughline/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/kitepon-rgb/Throughline/compare/v0.7.0...v0.8.0
+[0.7.0]: https://github.com/kitepon-rgb/Throughline/compare/v0.6.3...v0.7.0
+[0.6.3]: https://github.com/kitepon-rgb/Throughline/compare/v0.6.2...v0.6.3
 [0.6.2]: https://github.com/kitepon-rgb/Throughline/compare/v0.6.1...v0.6.2
 [0.3.22]: https://github.com/kitepon-rgb/Throughline/releases/tag/v0.3.22
 [0.3.21]: https://github.com/kitepon-rgb/Throughline/compare/v0.3.19...v0.3.21

package/README.md

@@ -245,15 +245,23 @@ this fallback. **The env var only affects the fallback**; typed `/clear` and
 
 ### What gets injected
 
-Both paths inject the **same** curated memory:
+Both paths inject the **same** curated memory (push/pull design, ADR 0016):
 
 - A **"現在地 (latest exchange)"** anchor (added in v0.4.12) re-surfaces the
   most recent user directive and the most recent assistant turn directly under
   the header, each truncated to 600 characters
-- L1 summaries (older turns, one-line)
-- L2 verbatim (most recent 20 turns, full text)
+- A **pull guidance section** (always present) with ready-to-run
+  `throughline recall` commands — session id, an ISO-ms boundary, and turn
+  counts are baked in at injection time
+- L2 verbatim: as many of the most recent turns as fit the ~9,500-char
+  injection budget, packed whole-turn (typically 7–8 turns; more for light
+  conversations). **L1 summaries are not injected** — the rest of the
+  20-turn window is retrieved verbatim via `throughline recall --l2`, and
+  everything older via `throughline recall --l1` (summarized turns show
+  their L1 line; unsummarized ones are listed explicitly with a
+  `throughline detail` pointer)
 - L3 references (`throughline detail <time>` retrieval commands, attached
-  inline to each L1/L2 row; bodies stay in SQLite)
+  inline to each L2 row; bodies stay in SQLite)
 
 The injection is reframed as **"resuming an interrupted task"** rather than
 "reading past logs". The L2 verbatim already contains the last assistant
@@ -754,6 +762,7 @@ aggregate は collection が既定OFFで、canonical dotagents config の
 | `throughline monitor [--all] [--session <id>]` | Run the multi-session token monitor                          |
 | `throughline monitor --diag`                   | Dump TTY/columns/env diagnostics (for debugging monitor render bugs) |
 | `throughline detail <time>`                    | Retrieve L2 body text and L3 tool I/O for a turn (see below) |
+| `throughline recall --l2\|--l1 --session <id> --before <ISO> ...` | Pull older memory referenced by the injection's guidance section (read-only; the exact command is baked into each injection) |
 | `throughline observer-read --project <absolute-directory> --json` | Read one completed-turn Observer page through the JSON-only public boundary |
 | `throughline observer-wait --project <absolute-directory> --after-cursor <opaque> [--timeout-seconds 3600] --json` | Wait up to 3600 seconds for a completed-turn Observer cursor change |
 | `throughline doctor`                           | Check Node version, hook registration, DB writability, PATH  |

package/bin/throughline.mjs

@@ -9,6 +9,7 @@
  *   throughline process-turn  # Stop hook (Claude Code から呼ばれる)
  *   throughline session-start # SessionStart hook (Claude Code から呼ばれる)
  *   throughline detail <時刻> # L2+L3 詳細取得 (Claude が Bash 経由で呼ぶ想定)
+ *   throughline recall --l2|--l1 # 注入案内から辿る pull 用 read-only 記憶取得
  *   throughline handoff-preview # Codex-facing throughline_handoff JSON preview
  *   throughline auditor-context --json # Read-only bounded auditor context JSON
  *   throughline factory-diagnostics --json # Native factory read-only readiness JSON
@@ -66,6 +67,11 @@ switch (cmd) {
   case 'detail':
     (await import('../src/sc-detail.mjs')).run(rest);
     break;
+  case 'recall': {
+    const exitCode = (await import('../src/cli/recall.mjs')).run(rest);
+    process.exitCode = exitCode;
+    break;
+  }
   case 'handoff-preview':
     await (await import('../src/cli/handoff-preview.mjs')).run(rest);
     break;

package/docs/02_clear_auto_handoff_plan.md

@@ -17,6 +17,14 @@ A 案 (= /clear で自動引継ぎ + /tl は逃げ道として残す + /tl-trim
 > `THROUGHLINE_DISABLE_AUTO_HANDOFF=1` は **fallback path のみに作用** する
 > ようになった (typed `/clear` / `/tl` には効かない)。
 
+> **2026-07-18 (ADR 0016) update**: 注入の中身を push/pull 二段に再設計した。
+> push (9,500 字) はヘッダ + 現在地アンカー + 案内セクション + **L2 をターン原子で
+> 入るだけ全文**（L1 は注入しない）。窓 20 ターンの残りは `throughline recall --l2`、
+> それより古い全ターンは `recall --l1`（要約 or 未要約明示）で pull する。範囲・境界
+> (ISO ms)・件数・session は注入時に案内コマンドへ焼き込み、recall 側は窓を再計算
+> しない。正典は [ADR 0016](adr/0016-push-pull-recall-injection.md)。本書内の
+> 「L1 + L2 を注入する」旧記述はこの update で読み替えること。
+
 ---
 
 ## 1. 確定した事実 (実機検証済み)

package/docs/adr/0016-push-pull-recall-injection.md

@@ -0,0 +1,93 @@
+# ADR 0016: 注入の push/pull 再設計 — 現在地 + 入るだけ L2 の push と recall CLI による pull
+
+- Status: accepted (2026-07-18 オーナー裁定)
+- 関連: [ADR 0014](0014-two-phase-handoff-ghost-baton.md)（9,500 字注入予算）、
+  [ADR 0015](0015-l1-summarizer-model-effort-ratio.md)（L1 要約体制）
+
+## 問題
+
+9,500 字の注入予算（hook stdout ~10k で `<persisted-output>` file 化、ADR 0014）の中で、
+旧 `buildBudgetedResumeContext` は **L1 を先に詰めてから L2 を詰めて**いた。実測
+（このMacのDB、L2 1 ターン中央値 ~800 字・平均 ~2,750 字）では L2 は 5〜10 ターンしか
+入らず、しかも L1 生成は `L2_WINDOW = 20` より古いターンにしか走らない（Stop 毎 1 件の
+遅延生成）ため、「予算落ちした 5〜20 ターン前」が **L2 も注入されず L1 も未生成**の
+記憶空白帯になっていた。省略告知は時刻列挙のみで、取り出しは 1 ターンずつ
+`throughline detail` を叩くしかなかった。
+
+## 検討して不採用にした案
+
+1. **固定 N ターン + per-role 切り詰めで L2 を保証し、残りに L1 充填**:
+   L1 生成閾値を N に連動させる案。pull 設計に移った時点で、注入 L1 が pull の L2×残り
+   と同じターンを二重に運ぶ矛盾が出て破棄（会話での敵対的整理）。固定 N 自体も
+   「軽い会話で予算を設計的に遊ばせる」ため破棄。
+2. **multi-hook による 10k 突破**: 実測で**可能**と確認した（下記「実測」）が、hook の
+   構造的想定（1 本 = 1 context string）に無い使い方であり、attachment 順序も非決定の
+   ため不採用。
+3. **全文ログのファイル書き出し + Read 誘導**: DB が正本なのに派生ファイルの寿命管理が
+   発生する。過去ターンのレコードは不変なので、スナップショット性は DB 直参照でも
+   担保できる。CLI 経由の DB 直参照に統一して不採用。
+4. **生 SQL をモデルに案内**: schema 講義で注入が太り、origin フィルタ等の誤クエリ事故面
+   が開く。`detail` と同じ「DB 直参照だがモデルにはコマンド 1 発」の流儀で不採用。
+
+## 決定
+
+push は「現在地」に徹し、過去は pull に出す。
+
+- **push（注入、9,500 字内）**: ヘッダ + 現在地アンカー + 案内セクション
+  （固定部として最優先予約・無条件表示）+ 残り全予算に **L2 を新しい順で
+  丸ごと入るターンだけ全文**（ターン単位の原子。固定 N なし・断片詰めなし・
+  ターン境界の自然な端数は許容）。**L1 は注入しない**。
+  最新ターンが単体で予算超過する場合だけ切り詰めて入れる（従来規則の維持）。
+- **pull（新 CLI `throughline recall` = read-only DB 直参照）**:
+  - `recall --l2 --session <id> --before <ISO8601 ms> --last <N>` —
+    境界より古いターンを新しい側から N 件、L2 全文（注入と同じ行文法 + L3 suffix）
+  - `recall --l1 --session <id> --before <ISO8601 ms> --skip <N>` —
+    --l2 の担当分を飛ばした先の全ターン一覧。**L1 要約があれば要約、無ければ
+    「未要約」と明示**して detail 誘導。冒頭に「全 M ターン / 要約済み K」を正直に表示
+  - 一点掘りは従来どおり `throughline detail <時刻>`（L2+L3）
+- **`L2_WINDOW = 20` は据え置き**。20 の意味が「push（入るだけ）+ pull（残り）」の
+  合計窓に再定義されるだけで、L1 要約ペース・Codex 側・schema への変更なし。
+
+### 間抜け防止 — 機械用境界の完全焼き込み（refuter 敵対的検証 2026-07-18）
+
+実装前に refuter による敵対的検証を通し、real 指摘 6 件を全て設計へ反映した:
+
+| 指摘 | 対処 |
+|---|---|
+| HH:MM:SS 境界は「当日」解決（sc-detail の `timeToUnixRange`）で深夜跨ぎに壊れる | `--before` は ISO 8601 完全日時（ms 精度）。表示用 HH:MM:SS と機械用境界を分離 |
+| 秒切り捨てで同秒行の境界包含が未定義 | 境界は strict less-than の ms 比較で規定 |
+| 20 ターン窓はクエリ時再計算のため、新セッションのターン追記で窓がスライドし古い側が黙って欠落 | `--last <残り件数>` も注入時に焼き込み、recall 側の窓再計算を全廃 |
+| L1 は遅延生成でバックログがあり「全 N ターンの要約」が虚偽になる。未要約ターンがどの取っ手からも見えない | `--l1` は全ターン一覧（要約 or 未要約明示）。件数は「全 M / 要約済み K」形式 |
+| 既定 session 解決（cwd 系）は Codex 併走・複数ウィンドウで非決定 | `--session` も焼き込み。recall は既定解決を持たない |
+| `getDb()` は mkdir + read-write open + migration を行い read-only 契約に反する | recall は `DatabaseSync(path, { readOnly: true })` + 存在チェック。DB を作成しない |
+
+併せて、予算詰めを行（role）単位からターン単位の原子に変更した（行単位だと同一ターンの
+assistant 行だけ入り user 行が pull 側に半身で現れ、境界の算術が濁るため）。
+
+## 実測
+
+### 新設計のレンダリング（2026-07-18、実 DB 191 ターンセッション）
+
+- totalChars 9,158 / 9,500、L2 9 ターン注入、残り 11 ターン、窓外 171 ターン
+  （要約済み 124 / 未要約 47）
+- 焼き込まれた案内コマンドをそのまま実行して、`--l2` が境界ぴったりから 11 ターン
+  （33k 字）、`--l1` が全 171 ターン一覧（118k 字、`--last` で部分取得可）を返すことを確認
+
+### multi-hook 10k 突破の実測（2026-07-18、Claude Code 2.1.211 / 不採用）
+
+- 同一 UserPromptSubmit に hook を 3 本登録 → それぞれ独立の `hook_success` attachment
+  になり 9,000 字 × 3 = 27,000 字が全部モデル可視 inline
+- 1 本だけ 12k にすると**その 1 本だけ**が `<persisted-output>` 化（隣の 9k は無傷）
+  = 10k 判定は per context string
+- 5 本 × 9k = 45,000 字でも全部可視。合算上限は 45k まで観測されず
+- **attachment の並び順は登録順と一致しない**（並列実行のため非決定）
+- 詳細は [rag/01-hooks/hook-stdout-10k-persisted-output.md](../../rag/01-hooks/hook-stdout-10k-persisted-output.md)
+
+## 帰結
+
+- 「5〜20 ターン前の空白帯」は消滅: 窓内の非注入分は `recall --l2` が verbatim で、
+  窓外は `recall --l1` が全ターン（未要約含む）で必ず到達可能
+- push は会話密度に自動適応（中央値 7〜8 ターン、軽い会話なら 10 ターン超、重くて 2〜3）
+- コンテキスト衛生は維持: pull はモデルが必要と判断した時だけ発生する
+- `handoff-executor` の injection stats は
+  `injected_l2_turns / remaining_l2_turns / older_turns / older_summarized` に更新

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "Claude Code hooks plugin for structured context compression (/clear-safe persistent memory)",
   "keywords": [

package/rag/01-hooks/hook-stdout-10k-persisted-output.md

@@ -40,6 +40,23 @@ v2.1.195 より前に 10k 超を emit した実績が手元に無いため、「
 ヘッダ + アンカー常時全文、L1 → L2 を新しい側から詰め、省略は注入文へ明示）。
 詳細は [ADR 0014](../../docs/adr/0014-two-phase-handoff-ghost-baton.md)。
 
+## 追記: 10k 判定は per context string — multi-hook で突破可能（2026-07-18 実測、不採用）
+
+同一イベントに複数 hook を登録した場合の挙動を実測した（Claude Code 2.1.211、
+一時 project + 3〜5 本の UserPromptSubmit tracer hook + `claude -p` Haiku）:
+
+- 各 hook stdout は**独立の `hook_success` attachment** になり、10k 判定も per string。
+  3 本 × 9,000 字 = 27,000 字、5 本 × 9,000 字 = 45,000 字が全部モデル可視 inline
+- 1 本だけ 12k にすると**その 1 本だけ**が `<persisted-output>` 化し、隣の 9k は無傷
+- hooks reference の「10,000 characters per context string」「複数 hook の
+  additionalContext は all of the values が届く」の文言と整合
+- **罠**: attachment の並び順は登録順と一致しない（hook 並列実行のため非決定）。
+  multi-part 注入に使うなら各 part に自己記述ヘッダが必須
+
+Throughline では「hook の構造的想定（1 本 = 1 context string）に無い使い方」として
+**不採用**（オーナー裁定 2026-07-18）。注入は 9,500 字 push + `throughline recall` pull の
+二段構成にした（[ADR 0016](../../docs/adr/0016-push-pull-recall-injection.md)）。
+
 ## 検証手順（再現用）
 
 1. 一時 project に `.claude/settings.json` で UserPromptSubmit hook を登録し、

package/src/cli/recall.mjs

@@ -0,0 +1,279 @@
+/**
+ * `throughline recall` — 注入案内から辿る pull 用の DB 直参照 CLI (read-only)
+ *
+ * 注入（push）は「現在地 + 入るだけの L2」だけを運び、残りの記憶は本コマンドで
+ * 必要な時だけ取得する（オーナー裁定 2026-07-18、ADR 0016）:
+ *   - `recall --l2 --session <id> --before <ISO日時> --last <N>`
+ *       境界（strict less-than, ms 比較）より古いターンを新しい側から N 件、
+ *       L2 全文（注入と同じ行文法 + L3 参照 suffix）で出す。
+ *   - `recall --l1 --session <id> --before <ISO日時> --skip <N>`
+ *       境界から N 件（--l2 の担当分）を飛ばした先の全ターン一覧。
+ *       L1 要約があれば要約、無ければ「未要約」と明示して detail 誘導を出す。
+ *
+ * 契約:
+ *   - 範囲・境界・session は注入時に案内コマンドへ焼き込まれた値だけで決まる。
+ *     recall 側で「現在の 20 ターン窓」を再計算しない（新セッションのターン追記で
+ *     窓がスライドし、古い側が黙って欠落するため）。
+ *   - DB は read-only で開く（create / migrate / write なし）。DB が無ければ
+ *     explicit error で終了する。
+ *   - 既定 session 解決は持たない。案内コマンドが常に `--session` を運ぶ。
+ */
+
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { formatTime } from '../handoff-record.mjs';
+import { groupL3ByTurn, buildPartsSummary } from '../l3-summary.mjs';
+
+export function defaultRecallDbPath() {
+  return join(homedir(), '.throughline', 'throughline.db');
+}
+
+const USAGE =
+  'usage: throughline recall (--l2 --last <N> | --l1 [--skip <N>] [--last <N>]) ' +
+  '--session <id> --before <ISO8601> [--db <path>]';
+
+export function parseRecallArgs(argv) {
+  const opts = {
+    mode: null,
+    sessionId: null,
+    beforeMs: null,
+    last: null,
+    skip: 0,
+    dbPath: null,
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--l2' || a === '--l1') {
+      if (opts.mode) throw new Error('recall: --l2 と --l1 は同時に指定できません');
+      opts.mode = a.slice(2);
+    } else if (a === '--session') {
+      opts.sessionId = argv[++i];
+    } else if (a === '--before') {
+      const raw = argv[++i];
+      const ms = Date.parse(raw ?? '');
+      if (!Number.isFinite(ms)) {
+        throw new Error(`recall: --before の日時を解釈できません: ${raw}（ISO 8601 を指定）`);
+      }
+      opts.beforeMs = ms;
+    } else if (a === '--last') {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 0) throw new Error('recall: --last は 0 以上の整数');
+      opts.last = n;
+    } else if (a === '--skip') {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 0) throw new Error('recall: --skip は 0 以上の整数');
+      opts.skip = n;
+    } else if (a === '--db') {
+      opts.dbPath = argv[++i];
+    } else {
+      throw new Error(`recall: 未知の引数: ${a}\n${USAGE}`);
+    }
+  }
+  if (!opts.mode) throw new Error(`recall: --l2 または --l1 を指定してください\n${USAGE}`);
+  if (!opts.sessionId) throw new Error(`recall: --session は必須です\n${USAGE}`);
+  if (opts.beforeMs == null) throw new Error(`recall: --before は必須です\n${USAGE}`);
+  if (opts.mode === 'l2' && opts.last == null) {
+    throw new Error(`recall: --l2 には --last <N> が必須です\n${USAGE}`);
+  }
+  return opts;
+}
+
+/**
+ * 境界より古い側の distinct ターンを新しい順に列挙する。
+ * 各要素: { originSessionId, turnNumber, turnKey, minCreatedAt }
+ */
+function listTurnsBefore(db, { sessionId, beforeMs }) {
+  const rows = db
+    .prepare(
+      `SELECT origin_session_id, turn_number, MIN(created_at) AS min_ca, MAX(created_at) AS max_ca
+       FROM bodies
+       WHERE session_id = ? AND created_at < ?
+       GROUP BY origin_session_id, turn_number
+       ORDER BY min_ca DESC`,
+    )
+    .all(sessionId, beforeMs);
+  return rows.map((r) => ({
+    originSessionId: r.origin_session_id,
+    turnNumber: r.turn_number,
+    turnKey: `${r.origin_session_id}\x00${r.turn_number}`,
+    minCreatedAt: r.min_ca,
+    maxCreatedAt: r.max_ca,
+  }));
+}
+
+function loadL3ForTurns(db, sessionId, turns) {
+  if (turns.length === 0) return [];
+  const placeholders = turns.map(() => '(?, ?, ?)').join(', ');
+  const params = turns.flatMap((t) => [sessionId, t.originSessionId, Number(t.turnNumber)]);
+  return db
+    .prepare(
+      `SELECT kind, tool_name, origin_session_id, turn_number, created_at
+       FROM details
+       WHERE (session_id, origin_session_id, turn_number) IN (VALUES ${placeholders})
+       ORDER BY created_at ASC, id ASC`,
+    )
+    .all(...params)
+    .map((r) => ({
+      kind: r.kind,
+      toolName: r.tool_name,
+      originSessionId: r.origin_session_id,
+      turnNumber: r.turn_number,
+      createdAt: r.created_at,
+    }));
+}
+
+/**
+ * --l2: 境界より古いターンを新しい側から last 件、古い順の L2 全文で描画する。
+ */
+export function renderRecallL2(db, { sessionId, beforeMs, last }) {
+  const turnsDesc = listTurnsBefore(db, { sessionId, beforeMs });
+  const selected = turnsDesc.slice(0, last).reverse(); // 古い順に戻す
+  const lines = [];
+
+  if (selected.length === 0) {
+    lines.push(`## Throughline recall (L2): 該当ターンなし（--before ${new Date(beforeMs).toISOString()} より古い L2 が DB にありません）`);
+    return { text: lines.join('\n'), turnCount: 0 };
+  }
+
+  const range = `${formatTime(selected[0].minCreatedAt)}〜${formatTime(selected[selected.length - 1].maxCreatedAt)}`;
+  lines.push(`## Throughline recall (L2): ${selected.length}ターン (${range}, 古い順)`);
+  if (selected.length < last) {
+    lines.push(`（--last ${last} のうち DB に存在するのは ${selected.length} ターンのみ）`);
+  }
+  lines.push('');
+
+  const l3ByTurn = groupL3ByTurn(loadL3ForTurns(db, sessionId, selected));
+
+  const bodyStmt = db.prepare(
+    `SELECT role, text, created_at
+     FROM bodies
+     WHERE session_id = ? AND origin_session_id = ? AND turn_number = ? AND created_at < ?
+     ORDER BY created_at ASC`,
+  );
+  for (const turn of selected) {
+    const rows = bodyStmt
+      .all(sessionId, turn.originSessionId, Number(turn.turnNumber), beforeMs)
+      .filter((r) => r.text);
+    for (let i = 0; i < rows.length; i += 1) {
+      const r = rows[i];
+      const isLast = i === rows.length - 1;
+      const partCounts = isLast ? (l3ByTurn.get(turn.turnKey)?.partCounts ?? new Map()) : new Map();
+      const suffix = buildPartsSummary(partCounts);
+      lines.push(`[${formatTime(r.created_at)}] [${r.role}]: ${r.text}${suffix}`);
+    }
+  }
+  return { text: lines.join('\n'), turnCount: selected.length };
+}
+
+/**
+ * --l1: 境界から skip 件を飛ばした先の全ターン一覧（古い順）。
+ * L1 要約があれば要約行、無ければ「未要約」と明示して detail 誘導を出す。
+ */
+export function renderRecallL1(db, { sessionId, beforeMs, skip, last = null }) {
+  const turnsDesc = listTurnsBefore(db, { sessionId, beforeMs });
+  let olderDesc = turnsDesc.slice(skip);
+  if (last != null) olderDesc = olderDesc.slice(0, last);
+  const selected = [...olderDesc].reverse(); // 古い順
+  const lines = [];
+
+  if (selected.length === 0) {
+    lines.push('## Throughline recall (L1): 該当ターンなし');
+    return { text: lines.join('\n'), turnCount: 0, summarizedCount: 0 };
+  }
+
+  const skelRows = db
+    .prepare(
+      `SELECT origin_session_id, turn_number, summary, created_at
+       FROM skeletons
+       WHERE session_id = ?
+       ORDER BY created_at ASC`,
+    )
+    .all(sessionId);
+  const skelByTurn = new Map();
+  for (const r of skelRows) {
+    const key = `${r.origin_session_id}\x00${r.turn_number}`;
+    if (!skelByTurn.has(key)) skelByTurn.set(key, []);
+    skelByTurn.get(key).push(r);
+  }
+
+  let summarizedCount = 0;
+  const bodyLines = [];
+  for (const turn of selected) {
+    const time = formatTime(turn.minCreatedAt);
+    const skels = skelByTurn.get(turn.turnKey);
+    if (skels && skels.length > 0) {
+      summarizedCount += 1;
+      for (const s of skels) {
+        if (!s.summary || s.summary === '(no content)') continue;
+        const summary = s.summary.replace(/\n+/g, ' ').trim();
+        bodyLines.push(`[${time}] ${summary}`);
+      }
+    } else {
+      bodyLines.push(`[${time}] (未要約) 全文: throughline detail ${time}`);
+    }
+  }
+
+  const range = `${formatTime(selected[0].minCreatedAt)}〜${formatTime(selected[selected.length - 1].minCreatedAt)}`;
+  lines.push(
+    `## Throughline recall (L1): 全${selected.length}ターン / 要約済み ${summarizedCount} (${range}, 古い順)`,
+  );
+  lines.push('各ターンの全文・ツール入出力: `throughline detail <時刻>` で取得可');
+  lines.push('');
+  lines.push(...bodyLines);
+  return { text: lines.join('\n'), turnCount: selected.length, summarizedCount };
+}
+
+export function runRecall(db, opts) {
+  if (opts.mode === 'l2') {
+    return renderRecallL2(db, {
+      sessionId: opts.sessionId,
+      beforeMs: opts.beforeMs,
+      last: opts.last,
+    });
+  }
+  return renderRecallL1(db, {
+    sessionId: opts.sessionId,
+    beforeMs: opts.beforeMs,
+    skip: opts.skip,
+    last: opts.last,
+  });
+}
+
+export function run(argv) {
+  let opts;
+  try {
+    opts = parseRecallArgs(argv);
+  } catch (err) {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    return 1;
+  }
+
+  const dbPath = opts.dbPath ?? defaultRecallDbPath();
+  if (!existsSync(dbPath)) {
+    process.stderr.write(`recall: DB がありません: ${dbPath}（recall は DB を作成しません）\n`);
+    return 1;
+  }
+
+  let db;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+  } catch (err) {
+    process.stderr.write(
+      `recall: DB を read-only で開けませんでした: ${err instanceof Error ? err.message : String(err)}\n`,
+    );
+    return 1;
+  }
+
+  try {
+    const result = runRecall(db, opts);
+    process.stdout.write(`${result.text}\n`);
+    return 0;
+  } catch (err) {
+    process.stderr.write(`recall: ${err instanceof Error ? err.message : String(err)}\n`);
+    return 1;
+  } finally {
+    db.close();
+  }
+}