throughline 0.3.25 → 0.4.0

package/src/resume-context.mjs

@@ -1,33 +1,32 @@
 /**
- * resume-context.mjs — 中断地点からの再開注入テキストを組み立てる共有モジュール
+ * resume-context.mjs — 引継ぎ注入テキストを組み立てる共有モジュール
  *
  * 呼び出し元:
- *   - session-start.mjs (isInheritance=true, 引き継ぎヘッダ)
+ *   - session-start.mjs (auto path / baton path どちらでも同じ注入)
  *
- * 設計（schema v7 対応）:
- *   - 注入順: ヘッダ → [in-flight メモ] → [中断直前の思考] → L1 要約 → L2 本文 → フッタ
- *   - in-flight メモ: /tl 発動時に現行 Claude が書いた「次の一手 / 方針 / 未解決 / TODO」
- *   - 中断直前の思考: 最終ターンの assistant extended thinking (details kind='thinking')
+ * 設計 (docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md):
+ *   - 注入順: ヘッダ + Reading Contract → L1 要約 → L2 本文 → L3 refs 一覧 → Continuation Instruction
  *   - 直近 N=20 ターンは bodies から L2 全文を注入
  *   - それ以前は skeletons から L1 要約のみ注入
+ *   - L3 references は具体的な `throughline detail <時刻>` コマンドの一覧として注入
+ *     (本文は埋め込まず、参照のみ)
+ *   - memo / thinking は注入しない (= L2 全文があれば最後の assistant turn 自体に
+ *     「次に何をしようとしていたか」が含まれる)
  *   - 各行頭に [HH:MM:SS] 時刻プレフィックス（created_at ベース、DB 永続）
- *   - 末尾に /sc-detail <時刻> ガイドを追記
  *   - 現セッションのターンは注入しない（Claude Code 本体のコンテキストに既にあるため）
- *   - フレーミングを「過去の記憶」から「中断した作業の再開」に変更する。
- *     冒頭と末尾の両方に current-work instruction を置き、長文 context 内でも
- *     L1/L2 を現在タスク用の作業文脈として読むよう誘導する。
+ *   - フレーミング: 「過去の記憶」ではなく「現在進行中の作業」として読ませる
+ *     (Codex 側 renderCodexRolloutMemoryPreview の写像)
  */
 
-import { buildHandoffRecord, N_RECENT_L2 } from './handoff-record.mjs';
+import { buildHandoffRecord, formatTime, N_RECENT_L2 } from './handoff-record.mjs';
 
 const RESUME_HEADER_TEMPLATE = (turnCount) =>
   `## Throughline: 中断した作業の再開（${turnCount} ターン分の文脈を保持）\n` +
   `\n` +
   `**前セッションで進行中だった作業を、この新セッションで引き継いでいます。以下が中断時点の状態です:**\n` +
-  `- 中断直前の in-flight メモ（前セッション末尾で Claude 自身が書いた「次の一手・方針・未解決・TODO」）\n` +
-  `- 中断直前の思考 (最終ターンの extended thinking)\n` +
   `- 直近 ${N_RECENT_L2} ターンの会話本文 (L2)\n` +
   `- それ以前の要約 (L1)\n` +
+  `- L3 (ツール入出力・思考) の参照一覧 (本文は別途取り出す)\n` +
   `\n` +
   `応答の冒頭でユーザーに「前の作業を ${turnCount} ターン分引き継ぎました」と報告してください。` +
   `作業方針は前セッションのものを踏襲し、中断地点から自然に続行してください。`;
@@ -37,48 +36,38 @@ const ACTIVE_WORK_READING_CONTRACT =
   `**読み方の契約:**\n` +
   `- これは単なる過去ログではなく、現在進行中の作業を再開するための active work context です。\n` +
   `- L2 は古い順に並んだ作業履歴です。後の発言・判断・TODO は前の仮説や作業方針を上書きし得ます。\n` +
-  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2、in-flight メモ、最終ターン thinking を優先して現在状態を推定してください。\n` +
-  `- 不足している tool output / 詳細根拠が必要なときだけ、末尾の \`throughline detail <時刻>\` を使って L3 を取得してください。`;
+  `- すべての L2 行を現在も正しい事実として扱わず、最新の L2 を優先して現在状態を推定してください。\n` +
+  `- 不足している tool output / 詳細根拠が必要なときだけ、L3 references の \`throughline detail <時刻>\` を使って取得してください。`;
 
 const CONTINUATION_REMINDER =
-  '**再開指示:** 上記の L1 / L2 / thinking / in-flight メモを、現在タスクに使う作業コンテキストとして扱ってください。' +
-  '最新の L2、in-flight メモ、最終ターン thinking から次の一手を決め、中断地点から続行してください。' +
+  '**再開指示:** 上記の L1 / L2 を、現在タスクに使う作業コンテキストとして扱ってください。' +
+  '最新の L2 から次の一手を決め、中断地点から続行してください。' +
   '古い仮説や未完了 TODO は、後続の判断で上書きされ得ます。';
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
-const FOOTER_GUIDE =
-  '---\n' +
-  '**[Claude 向け — 記憶の使い方]**\n' +
-  '上の L1 要約や L2 本文を読んで「具体的なコマンドやツール出力、ファイル内容を確認したい」と感じたら、' +
-  '推測せずに **Bash ツールで `throughline detail <時刻>` を実行** して L3（ツール入出力・hook 出力・thinking）を取得してください。\n' +
-  '- 単一時刻: `throughline detail 14:23:05`\n' +
-  '- 時刻範囲: `throughline detail 14:23-14:30`\n' +
-  '\n' +
-  '返る内容: 指定ターンの L2 会話本文 + L3（tool_input / tool_output / system / thinking 別にグループ化）。\n' +
-  'ユーザーに「詳細を見せて」と言われた時だけでなく、**ユーザー発言の文脈が過去ターンに依存しているのに L1/L2 だけでは情報不足だと判断した時**に、Claude 自身の判断で呼び出して構いません。';
-
 /**
- * L1+L2 注入テキストを組み立てる。
+ * L1 + L2 + L3 references 注入テキストを組み立てる。
  *
  * @param {import('node:sqlite').DatabaseSync} db
  * @param {{
  *   sessionId: string,
  *   isInheritance: boolean,
  *   excludeOriginId?: string | null,
- *   inflightMemo?: string | null,
+ *   inflightMemo?: string | null,  // 互換のため受け取るが新仕様では使用しない
  * }} params
  * @returns {string | null}
  */
 export function buildResumeContext(
   db,
-  { sessionId, isInheritance, excludeOriginId = null, inflightMemo = null },
+  { sessionId, isInheritance, excludeOriginId = null, inflightMemo: _ignoredMemo = null },
 ) {
+  // handoff-record は Codex 側でも使うので signature 維持。inflightMemo / latestThinking は
+  // 新仕様の注入テキストには使わない (L2 全文で十分という判断)。
   const record = buildHandoffRecord(db, {
     sessionId,
     isInheritance,
     excludeOriginId,
-    inflightMemo,
   });
   if (!record) return null;
 
@@ -88,20 +77,6 @@ export function buildResumeContext(
     : NORMAL_HEADER;
   const lines = [header];
 
-  if (record.memory.inflightMemo) {
-    lines.push('');
-    lines.push('### 中断直前の in-flight メモ（前セッションの Claude 自身による要約）');
-    lines.push(record.memory.inflightMemo);
-  }
-
-  if (record.memory.latestThinking.length > 0) {
-    lines.push('');
-    lines.push('### 中断直前の思考 (最終ターンの extended thinking)');
-    for (const r of record.memory.latestThinking) {
-      lines.push(`[${r.time}] ${r.text}`);
-    }
-  }
-
   if (record.memory.l1Summaries.length > 0) {
     lines.push('');
     lines.push('### それ以前の要約 (L1)');
@@ -121,8 +96,16 @@ export function buildResumeContext(
     }
   }
 
-  lines.push('');
-  lines.push(FOOTER_GUIDE);
+  if (record.references.l3.length > 0) {
+    lines.push('');
+    lines.push('### L3 詳細参照 (本文は注入されていません)');
+    lines.push('必要なときだけ以下のコマンドで取得してください:');
+    for (const ref of record.references.l3) {
+      const time = formatTime(ref.createdAt);
+      lines.push(`- [${time}] ${ref.kind}: \`throughline detail ${time}\``);
+    }
+  }
+
   lines.push('');
   lines.push(CONTINUATION_REMINDER);
 

package/src/resume-context.test.mjs

@@ -65,7 +65,7 @@ function insertThinking(db, row) {
   ).run(row.session, row.origin, row.turn, row.text, row.createdAt, row.sourceId);
 }
 
-test('buildResumeContext: inheritance output order is memo -> thinking -> L1 -> L2 -> footer', () => {
+test('buildResumeContext: inheritance output order is L1 -> L2 -> L3 refs -> reminder (no memo / no thinking)', () => {
   const db = makeDb();
 
   insertSkeleton(db, {
@@ -92,6 +92,7 @@ test('buildResumeContext: inheritance output order is memo -> thinking -> L1 ->
     text: 'recent assistant body',
     createdAt: 2100,
   });
+  // thinking は DB に書かれても、新仕様では注入テキストに出ない
   insertThinking(db, {
     session: 'new',
     origin: 'old',
@@ -104,32 +105,36 @@ test('buildResumeContext: inheritance output order is memo -> thinking -> L1 ->
   const text = buildResumeContext(db, {
     sessionId: 'new',
     isInheritance: true,
-    inflightMemo: '**Next**: keep going',
+    // inflightMemo は互換のため受け取れるが、新仕様では注入テキストに使わない
+    inflightMemo: '**Next**: keep going (should NOT appear)',
   });
 
   assert.ok(text);
   assert.match(text, /^## Throughline: 中断した作業の再開/);
 
-  const memoIdx = text.indexOf('### 中断直前の in-flight メモ');
-  const thinkingIdx = text.indexOf('### 中断直前の思考');
+  // 新仕様: memo / thinking セクションは注入されない
+  assert.ok(text.indexOf('### 中断直前の in-flight メモ') < 0, 'memo section should not be injected');
+  assert.ok(text.indexOf('### 中断直前の思考') < 0, 'thinking section should not be injected');
+  assert.ok(!text.includes('**Next**: keep going'), 'inflightMemo content should be ignored');
+  assert.ok(!text.includes('latest thinking block'), 'thinking text should not appear');
+
+  // 注入される順序: L1 → L2 → L3 refs → 再開指示
   const l1Idx = text.indexOf('### それ以前の要約 (L1)');
   const l2Idx = text.indexOf('### 現在進行中の作業履歴 (L2 / active work thread)');
-  const footerIdx = text.indexOf('**[Claude 向け — 記憶の使い方]**');
+  const l3Idx = text.indexOf('### L3 詳細参照');
+  const reminderIdx = text.indexOf('**再開指示:**');
 
-  assert.ok(memoIdx > 0, 'in-flight memo section should be present');
-  assert.ok(thinkingIdx > memoIdx, 'thinking should follow in-flight memo');
-  assert.ok(l1Idx > thinkingIdx, 'L1 should follow thinking');
+  assert.ok(l1Idx > 0, 'L1 section should be present');
   assert.ok(l2Idx > l1Idx, 'L2 should follow L1');
-  assert.ok(footerIdx > l2Idx, 'footer should follow L2');
+  assert.ok(l3Idx > l2Idx, 'L3 references should follow L2');
+  assert.ok(reminderIdx > l3Idx, 'continuation reminder should follow L3 refs');
 
-  assert.ok(text.includes('**Next**: keep going'));
-  assert.ok(text.includes('latest thinking block'));
   assert.ok(text.includes('older L1 summary'));
   assert.ok(text.includes('[user]: recent user body'));
   assert.ok(text.includes('[assistant]: recent assistant body'));
+  // L3 refs は detail コマンドのみ (本文は注入しない)
+  assert.match(text, /throughline detail \d{2}:\d{2}:\d{2}/);
   assert.match(text, /単なる過去ログではなく、現在進行中の作業/);
-  assert.match(text, /後の行ほど現在状態に近く/);
-  assert.match(text, /上記の L1 \/ L2 \/ thinking \/ in-flight メモを、現在タスクに使う作業コンテキスト/);
 });
 
 test('buildResumeContext: returns null when no memory rows or inflight memo exist', () => {

package/src/session-start.mjs

@@ -1,20 +1,28 @@
 #!/usr/bin/env node
 /**
- * SessionStart hook — セッション登録 + バトン消費 + 引き継ぎ注入
+ * SessionStart hook — セッション登録 + 引き継ぎ判定 + 注入
  *
  * stdin: { session_id, source, cwd, transcript_path, hook_event_name }
  *
- * 【引き継ぎ条件 (バトン方式)】
- *   ユーザーが旧セッションで /tl スラッシュコマンドを打つと UserPromptSubmit hook が
- *   baton テーブルに session_id を書き込む。本 SessionStart hook はそれを TTL 1 時間以内
- *   なら消費して merge + 引き継ぎヘッダ付き L1+L2 を stdout 注入する。
- *   バトンが無ければ / 期限切れなら何も引き継がない（docs/INHERITANCE_ON_CLEAR_ONLY.md 参照）。
+ * 【引き継ぎ条件 (2 経路)】 docs/THROUGHLINE_CLEAR_AUTO_HANDOFF_PLAN.md
+ *
+ *   1. baton path: ユーザーが旧セッションで `/tl` を打つと UserPromptSubmit hook が
+ *      handoff_batons に session_id を書く。本 hook が TTL 1 時間以内に消費して
+ *      前任を merge + 引継ぎ stdout 注入。`source` 値関係なく発火。
+ *   2. auto path: `source='clear'` かつ env `THROUGHLINE_DISABLE_AUTO_HANDOFF` が
+ *      `'1'` でない場合、同 project_path の最新 Claude unmerged session を
+ *      自動 merge して注入。
+ *
+ *   両方同時成立はしない (consumeBaton が先発、baton ありなら baton path、
+ *   なければ source 判定)。env で OFF にしたユーザーは `/tl` を打ってから
+ *   新セッションスタートで baton path を使う。
  *
  * 役割:
  *   1. sessions テーブルに新セッションを INSERT OR IGNORE
- *   2. バトン消費 + 指名された前任を merge (session-merger.mjs)
- *   3. 合流成立なら L1+L2 を「引き継ぎヘッダ」付きで stdout 注入
- *   4. 判定結果を ~/.throughline/logs/inheritance-decision.log に記録
+ *   2. baton path 判定 (consumeBaton + mergeSpecificPredecessor)
+ *   3. baton 無し かつ source='clear' かつ env disable 無し → auto path 判定
+ *   4. 合流成立なら curated memory (L1+L2+L3 refs) を「引き継ぎヘッダ」付きで stdout 注入
+ *   5. 判定結果を ~/.throughline/logs/inheritance-decision.log に記録
  */
 
 import { getDb } from './db.mjs';
@@ -27,6 +35,37 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 
+const ENV_DISABLE_AUTO_HANDOFF = 'THROUGHLINE_DISABLE_AUTO_HANDOFF';
+
+function isAutoHandoffDisabled(env) {
+  return env[ENV_DISABLE_AUTO_HANDOFF] === '1';
+}
+
+/**
+ * 同 project_path の最新 Claude unmerged session を返す (auto path 用 predecessor)。
+ * Codex session (`codex:*`) と現セッション自身は除外。
+ *
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {string} projectPath
+ * @param {string} currentSessionId
+ * @returns {{ session_id: string } | null}
+ */
+function findLatestClaudePredecessor(db, projectPath, currentSessionId) {
+  return (
+    db
+      .prepare(
+        `SELECT session_id FROM sessions
+         WHERE lower(project_path) = lower(?)
+           AND merged_into IS NULL
+           AND session_id != ?
+           AND session_id NOT LIKE 'codex:%'
+         ORDER BY updated_at DESC
+         LIMIT 1`,
+      )
+      .get(projectPath, currentSessionId) ?? null
+  );
+}
+
 function logDecision(entry) {
   const path = join(homedir(), '.throughline', 'logs', 'inheritance-decision.log');
   try {
@@ -57,11 +96,7 @@ export async function run() {
   const db = getDb();
   const now = Date.now();
 
-  // 0. VSCode で開かれた新規プロジェクトに .vscode/tasks.json を自動プロビジョニング。
-  //    Stop hook 側にも同じ呼び出しがあるが、Stop が発火しない環境（応答中断・IDE 挙動差）
-  //    でも SessionStart は必ず走るので、新規プロジェクトでの自動起動を確実化する保険。
-  //    冪等性は ensureMonitorTaskFile 側で保証されており、Stop/UserPromptSubmit と重複呼び
-  //    出しされても安全。
+  // 0. VSCode 用 tasks.json 自動プロビジョニング (冪等)
   try {
     ensureMonitorTaskFile({ cwd: projectPath, env: process.env });
   } catch (err) {
@@ -75,18 +110,40 @@ export async function run() {
      VALUES (?, ?, 'active', ?, ?)`,
   ).run(session_id, projectPath, now, now);
 
-  // 2. バトン消費
+  // 2. baton 消費
   const baton = consumeBaton(db, { projectPath, now });
 
-  let mergeResult = { merged: false, skipReason: 'no_baton' };
+  // 3. 引継ぎ判定
+  let mergeResult = { merged: false, skipReason: 'no_trigger' };
+  let triggeredPath = null;
+  const autoDisabled = isAutoHandoffDisabled(process.env);
+
   if (baton.sessionId) {
-    // バトンが指す session が既に他と merge 済みなら、その合流先末端を前任とする
+    // baton path
+    triggeredPath = 'baton';
     const { target: predecessorId } = resolveMergeTarget(db, baton.sessionId);
     mergeResult = mergeSpecificPredecessor(db, {
       newSessionId: session_id,
       predecessorId,
       now,
     });
+  } else if (source === 'clear' && !autoDisabled) {
+    // auto path: 同 project の最新 Claude unmerged session を自動 predecessor にする
+    triggeredPath = 'auto';
+    const predRow = findLatestClaudePredecessor(db, projectPath, session_id);
+    if (predRow?.session_id) {
+      const { target: predecessorId } = resolveMergeTarget(db, predRow.session_id);
+      mergeResult = mergeSpecificPredecessor(db, {
+        newSessionId: session_id,
+        predecessorId,
+        now,
+      });
+    } else {
+      mergeResult = { merged: false, skipReason: 'no_predecessor' };
+    }
+  } else if (source === 'clear' && autoDisabled) {
+    triggeredPath = 'auto-disabled';
+    mergeResult = { merged: false, skipReason: 'auto_handoff_disabled' };
   }
 
   logDecision({
@@ -94,22 +151,21 @@ export async function run() {
     source: source ?? null,
     session_id,
     project_path: projectPath,
+    triggered_path: triggeredPath,
+    auto_handoff_disabled: autoDisabled,
     baton_session_id: baton.sessionId ?? null,
     baton_age_ms: baton.ageMs ?? null,
     baton_skip_reason: baton.skipReason ?? null,
-    baton_has_memo: Boolean(baton.memoText),
     merged: mergeResult.merged,
     merge_skip_reason: mergeResult.skipReason ?? null,
     predecessor_id: mergeResult.predecessorId ?? null,
   });
 
-  // 3. 合流成立なら引き継ぎヘッダ付きで注入
-  //    バトンに付いていた in-flight メモも併せて先頭セクションに注入する
+  // 4. 合流成立なら curated memory を stdout 注入 (L1 + L2 + L3 refs)
   if (mergeResult.merged) {
     const text = buildResumeContext(db, {
       sessionId: session_id,
       isInheritance: true,
-      inflightMemo: baton.memoText ?? null,
     });
     if (text) {
       process.stdout.write(text + '\n');

package/.claude/commands/tl-trim.md

@@ -1,42 +0,0 @@
----
-description: 現セッションの context trim 計画を dry-run する (Throughline)
----
-
-Throughline の context trim は、現時点では dry-run のみ有効です。自動 `/rewind` や自動 rollback / inject は、host primitive の検証が完了するまで実行してはいけません。
-
-まず、今この時点の「現在作業」を自分の文脈から思い出し、以下 4 項目を Markdown で整理してください。
-
-- **次の一手**: 今まさに何をやろうとしていたか（1-3 文、具体的に）
-- **現在の方針 / 仮説**: 追っているバグの原因、設計の方向性、調査中の観点など
-- **未解決の疑問**: 判断保留中の論点
-- **進行中 TODO**: 完了済みを除いた現行 TODO
-
-その Markdown を stdin として、次のコマンドを Bash ツールで実行し、結果をユーザーにそのまま要約してください。
-
-```bash
-throughline trim --dry-run --host claude --memo-stdin $ARGUMENTS <<'EOF'
-**次の一手**: ...
-**現在の方針 / 仮説**: ...
-**未解決の疑問**: ...
-**進行中 TODO**:
-- ...
-EOF
-```
-
-出力には以下が含まれます。
-
-- 現セッションで Throughline が捕捉している turn 数
-- keep-recent 設定
-- rollback 候補 turn 数
-- host が自動 rollback / inject 対応かどうか
-- rollback 後に戻す curated memory preview
-- rollback 後に「今やっている作業」として戻す current-work memo
-
-`$ARGUMENTS` には `--keep-recent 20`、`--all`、`--session <id>` を渡せます。
-
-重要:
-
-- dry-run の結果だけで自動 rollback しないでください。
-- Claude の既存 `/tl` baton handoff は変更しません。
-- L1/L2 だけでは「今やっている作業」として認識されにくいので、current-work memo を省略しないでください。
-- `Throughline Trim Dry-run` の `Automatic execution allowed` が `no` の場合は、実行手順ではなく「現状は dry-run / 手動案内まで」と説明してください。

package/src/cli/save-inflight.mjs

@@ -1,81 +0,0 @@
-/**
- * throughline save-inflight — /tl 発動後、現行 Claude が中断地点の in-flight メモを
- * stdin 経由で書き込む CLI。
- *
- * 使い方 (Claude Code の Bash ツールから):
- *   throughline save-inflight <<'EOF'
- *   **次の一手**: ...
- *   **現在の方針**: ...
- *   **未解決の疑問**: ...
- *   **進行中 TODO**: ...
- *   EOF
- *
- * 動作:
- *   1. stdin を UTF-8 で全部読む
- *   2. 空なら exit 1 (§0 フォールバック禁止 — サイレント成功しない)
- *   3. cwd に対応する handoff_batons 行の memo_text を UPDATE
- *   4. バトン未登録なら updated=false で警告して exit 1
- *
- * 呼び出し元: [.claude/commands/tl.md] が Claude に実行させる
- */
-
-import { getDb } from '../db.mjs';
-import { updateBatonMemo } from '../baton.mjs';
-import { readFileSync, appendFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
-
-function logInflight(entry) {
-  const path = join(homedir(), '.throughline', 'logs', 'inflight-memo.log');
-  try {
-    mkdirSync(dirname(path), { recursive: true });
-    appendFileSync(path, JSON.stringify(entry) + '\n', 'utf8');
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : 'unknown';
-    process.stderr.write(`[save-inflight:log] ${msg}\n`);
-  }
-}
-
-export async function run() {
-  let memoText;
-  try {
-    memoText = readFileSync(0, 'utf8').trim();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : 'unknown';
-    process.stderr.write(`[save-inflight] failed to read stdin: ${msg}\n`);
-    process.exit(1);
-    return;
-  }
-
-  if (!memoText) {
-    process.stderr.write(
-      '[save-inflight] stdin was empty. Provide the in-flight memo via stdin (here-doc or pipe).\n',
-    );
-    process.exit(1);
-    return;
-  }
-
-  const projectPath = process.cwd();
-  const db = getDb();
-  const { updated } = updateBatonMemo(db, { projectPath, memoText });
-
-  logInflight({
-    ts: new Date().toISOString(),
-    project_path: projectPath,
-    memo_length: memoText.length,
-    baton_updated: updated,
-  });
-
-  if (!updated) {
-    process.stderr.write(
-      `[save-inflight] no baton found for ${projectPath}. ` +
-        `Run /tl first so the baton exists, then save-inflight can attach the memo.\n`,
-    );
-    process.exit(1);
-    return;
-  }
-
-  process.stdout.write(
-    `[throughline] in-flight memo saved (${memoText.length} chars) for next session\n`,
-  );
-}