throughline 0.10.12 → 0.10.14

package/CHANGELOG.md

@@ -10,6 +10,24 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.10.14] — 2026-09-02
+
+### Added
+
+- `handoff-context --project <path> --json`で、指定project内の会話本文を持つ最新sessionを
+  read-onlyで選び、本文がなければ`empty`を返せるようにした。
+- `--disclosure silent`を補足ファイルなしで指定できるようにし、埋込製品が短期記憶だけを
+  基盤案内なしで受け取れるようにした。
+
+## [0.10.13] — 2026-09-02
+
+### Fixed
+
+- 通常の引き継ぎ案内を最初の応答だけに限定し、project束縛済み補足から
+  `handoffDisclosure: "silent"`を指定したlauncherは案内を非表示にできるようにした。
+- Throughline旧版がassistant本文へ付けた固定宣言行だけを次回引き継ぎ時に除外し、
+  ユーザーの引用と宣言後の会話本文は保持する。
+
 ## [0.10.12] — 2026-09-01
 
 ### Changed
@@ -1421,7 +1439,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.10.12...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.10.14...HEAD
+[0.10.14]: https://github.com/kitepon/Throughline/compare/v0.10.13...v0.10.14
+[0.10.13]: https://github.com/kitepon/Throughline/compare/v0.10.12...v0.10.13
 [0.10.12]: https://github.com/kitepon/Throughline/compare/v0.10.11...v0.10.12
 [0.10.11]: https://github.com/kitepon/Throughline/compare/v0.10.10...v0.10.11
 [0.10.10]: https://github.com/kitepon/Throughline/compare/v0.10.9...v0.10.10

package/README.ja.md

@@ -74,6 +74,12 @@ cwd は源セッションの `project_path` であり、呼び出し元 cwd は
 `/clear` では起動しない。aiterm / `--rules` / `--from` は使わない。
 macOS Terminal のみ。
 
+通常のhandoff-contextは、引き継いだことを最初の応答で一度だけ案内し、後続応答では
+繰り返させない。埋込製品は`handoff-context --disclosure silent`で案内を消せる。
+project束縛済み補足の`handoffDisclosure: "silent"`も同じ扱いになる。旧版がassistant本文へ
+付けた固定宣言は次回引き継ぎから除外し、ユーザーの
+引用と実際の応答本文は保持する。
+
 新席は `~/.grok/sessions/<encodeURIComponent(cwd)>/` のトップレベル
 ディレクトリ。Desktop の Inactive 畳みは成功条件にしない。L2 が無い源
 （`merged_into` チェーンの空席など）では起動しない。新しい chat で 1〜2
@@ -390,7 +396,7 @@ v0.10.4以前には `self-update` が存在しない。該当版からの初回
 | `throughline runtime-errors snapshot --json` | boundedなlocal aggregateを読み取る（network I/Oなし） |
 | `throughline runtime-errors diagnostics --json` | collection/store状態をpathやraw errorなしで診断 |
 | `throughline handoff-preview --session <id>` | Codex 向け `throughline_handoff` JSON projection を表示 |
-| `throughline handoff-context --session <id> --json [--supplement-file <path>]` | SessionStartと同じ引き継ぎ文脈を取得。任意のproject束縛済み補足を、長期記憶・知識として同じ9,500字枠へ合成できる |
+| `throughline handoff-context (--session <id> \| --project <path>) --json` | SessionStartと同じ引き継ぎ文脈を取得。project指定時は会話本文を持つ最新sessionを選び、`--disclosure silent`に対応し、本文がなければ`empty`を返す。session指定時はproject束縛済み補足を同じ9,500字枠へ合成できる |
 | `throughline latest-session --project <absolute-path> --json` | 指定した1プロジェクトだけを対象に直近セッションIDを読み取る。既存DBをread-onlyで開き、記録がなければ`empty`を返す |
 | `throughline grok-continue --session <id>` | handoff-context を初手 user 文にした対話 Grok 席を立てる。cwd は源の `project_path`。ready でなければ spawn しない。`--rules` なし。macOS Terminal のみ |
 | `throughline codex-sidecar-diagnostics` | この project の `codex-sidecar` diagnostics status を確認 |
@@ -423,14 +429,18 @@ throughline runtime-errors diagnostics --json
 
 ```bash
 throughline handoff-context --session codex:<thread-id> --json
+throughline handoff-context --project /absolute/bot/project --json --disclosure silent
 ```
 
-成功時の`throughline.handoff_context.v1`は`schema`、`status`、`sessionId`、`context`だけを返す。
-`context`はSessionStartと同じ予算付き継承文脈である。任意の`--supplement-file <path>`には
+`throughline.handoff_context.v1`は`schema`、`status`、`sessionId`、`context`だけを返す。
+`--project`ではそのproject内で会話本文を持つ最新sessionを選び、存在しなければ`empty`を返す。
+`--disclosure silent`は長期記憶を追加せずThroughlineの案内を消す。`context`はSessionStartと
+同じ予算付き継承文脈である。`--session`で使える任意の`--supplement-file <path>`には
 `throughline.handoff_supplement.v1`、源sessionと同じ`projectPath`、`title`と`content`からなる
-`sections`を指定する。補足は会話記憶と同じ9,500字枠へ入り、別projectの補足は拒否する。
+`sections`を指定する。任意の`handoffDisclosure`は`visible`（既定）または`silent`を受け取る。
+補足は会話記憶と同じ9,500字枠へ入り、別projectの補足は拒否する。
 DB作成・migration・baton消費・session merge・
-latest session推測・`sessions.merged_into`変更・L1/L2/L3 rowの所属変更は行わない。AItermは任意の
+`sessions.merged_into`変更・L1/L2/L3 rowの所属変更は行わない。AItermは任意の
 別harness portable forkでこの境界を使う。Observer feedはcompleted-turn projectionであり代替ではない。
 
 スラッシュコマンド (Claude Code 内でユーザーが叩く):

package/README.md

@@ -817,13 +817,21 @@ entry to the `tasks` array yourself:
 
 ## Commands
 
-**The current release is v0.10.12.** Throughline supports Claude Code, Codex,
+**The current release is v0.10.14.** Throughline supports Claude Code, Codex,
 Grok, and Cursor as documented host adapters. The versioned, read-only
 `handoff-context` boundary opens only an existing database and leaves baton
 state, session ownership, and memory rows unchanged. Factory diagnostics,
 Observer, runtime-error, capture, and normal handoff behavior remain available
 under the same explicit-failure and local-only contracts.
 
+Normal handoffs announce inherited continuity once in the first response and
+explicitly forbid repeating that line in later responses. A project-bound
+launcher may pass `--disclosure silent` for an embedded product that keeps
+continuity metadata out of its chat. A supplement may also set
+`handoffDisclosure` to `silent`. Legacy Throughline disclosure lines
+in assistant memory are omitted from the next handoff; user quotations and the
+actual reply body remain intact.
+
 | Command                                        | What it does                                                 |
 | ---------------------------------------------- | ------------------------------------------------------------ |
 | `throughline install`                          | Register Claude user hooks/slash commands, the global Codex UserPromptSubmit/PostToolUse/Stop hooks, the global `$throughline` Codex skill, `~/.grok/hooks/throughline.json`, and the current VS Code monitor task when applicable |
@@ -855,7 +863,7 @@ once with `npm install --global throughline@latest`, then run
 | `throughline runtime-errors reopen <fingerprint> --json` | Explicitly reopen a resolved aggregate without fabricating a new occurrence |
 | `throughline runtime-errors compact --json`    | Remove only acknowledged, resolved aggregates after retention; open or unacknowledged records remain |
 | `throughline handoff-preview --session <id>`   | Print a Codex-facing `throughline_handoff` JSON projection    |
-| `throughline handoff-context --session <id> --json [--supplement-file <path>]` | Print the SessionStart inheritance context without moving memory rows; an optional project-bound supplement adds long-term memory and knowledge inside the same 9,500-character budget |
+| `throughline handoff-context (--session <id> \| --project <path>) --json` | Print the SessionStart inheritance context without moving memory rows. Project mode selects the newest captured session with dialogue, supports `--disclosure silent`, and returns `empty` when no dialogue exists. Session mode may add a project-bound supplement inside the same 9,500-character budget |
 | `throughline latest-session --project <absolute-path> --json` | Read the latest session id strictly scoped to one project; opens the existing database read-only and returns `empty` when the project has no captured session |
 | `throughline grok-continue --session <id>` | Spawn a person-facing Grok seat whose first user text is the handoff-context body. cwd is the source session `project_path`. Does not spawn without ready context. No `--rules`. macOS Terminal only |
 | `throughline codex-capture --codex-thread-id <id>` | Capture active Codex rollout turns into a `codex:<thread_id>` DB session |
@@ -905,17 +913,22 @@ performing a normal handoff:
 
 ```bash
 throughline handoff-context --session codex:<thread-id> --json
+throughline handoff-context --project /absolute/bot/project --json --disclosure silent
 ```
 
-The successful `throughline.handoff_context.v1` object contains only `schema`,
-`status`, `sessionId`, and `context`. The context is the same budgeted
-inheritance text used by SessionStart. A launcher may append
+The `throughline.handoff_context.v1` object contains only `schema`, `status`,
+`sessionId`, and `context`. With `--project`, Throughline selects the newest
+session in that project that has dialogue context; it returns `status: "empty"`
+when none exists. `--disclosure silent` removes the Throughline announcement
+without adding long-term memory. The context uses the same budget as
+SessionStart. With `--session`, a launcher may append
 `--supplement-file <path>` with a `throughline.handoff_supplement.v1` JSON object:
 
 ```json
 {
   "schema": "throughline.handoff_supplement.v1",
   "projectPath": "/absolute/bot/project",
+  "handoffDisclosure": "silent",
   "sections": [
     { "title": "Long-term memory", "content": "..." },
     { "title": "Relevant knowledge", "content": "..." }
@@ -923,11 +936,12 @@ inheritance text used by SessionStart. A launcher may append
 }
 ```
 
+`handoffDisclosure` is optional and accepts `visible` (the default) or `silent`.
 The supplement is included only when `projectPath` matches the source session
 and shares the 9,500-character budget with conversation memory. If the captured
 session has no dialogue context yet, a valid project-bound supplement is returned
 by itself. The command does not create or migrate a
-database, consume a baton, merge sessions, infer a latest session, change
+database, consume a baton, merge sessions, change
 `sessions.merged_into`, or reassign L1/L2/L3 rows. AIterm uses this boundary for
 its optional cross-harness portable fork; the Observer feed is a separate
 completed-turn projection and is not a substitute.

package/bin/throughline.mjs

@@ -11,7 +11,7 @@
  *   throughline detail <時刻> # L2+L3 詳細取得 (Claude が Bash 経由で呼ぶ想定)
  *   throughline recall --l2|--l1 # 注入案内から辿る pull 用 read-only 記憶取得
  *   throughline handoff-preview # Codex-facing throughline_handoff JSON preview
- *   throughline handoff-context --session <id> --json [--supplement-file <path>] # Read-only inheritance context JSON
+ *   throughline handoff-context (--session <id> | --project <path>) --json # Read-only inheritance context JSON
  *   throughline latest-session --project <path> --json # Latest session strictly scoped to one project
  *   throughline grok-continue --session <id> # Spawn a Grok seat whose first user text is handoff-context
  *   throughline auditor-context --json # Read-only bounded auditor context JSON
@@ -236,10 +236,12 @@ Usage:
   throughline monitor           Multi-session token monitor (use --all, --session <id>)
   throughline detail <time>     Retrieve L2+L3 detail for a turn (e.g. 14:23:05 or 14:23-14:30)
   throughline handoff-preview   Print Codex-facing throughline_handoff JSON
-  throughline handoff-context --session <id> --json [--supplement-file <path>]
+  throughline handoff-context (--session <id> | --project <path>) --json
                               Print the exact inheritance context without
-                              changing database ownership; optionally include
-                              project-bound long-term memory and knowledge
+                              changing database ownership. Project mode selects
+                              the newest session with dialogue and may use
+                              --disclosure silent. Session mode may use a
+                              project-bound --supplement-file
   throughline latest-session --project <absolute-path> --json
                               Read the latest session id for exactly one project
   throughline grok-continue --session <id>

package/docs/04_public_release_plan.md

@@ -6,7 +6,7 @@
 
 ## 現行状態
 
-- release candidateのpackage版は `0.10.12`。tagとnpmの公開確認はpublish後に行う。
+- release candidateのpackage版は `0.10.14`。tagとnpmの公開確認はpublish後に行う。
 - Claude Code、Codex、Grok、Cursorをfirst-class hostとして扱う。
 - 現行DB schemaはv9。schemaの正本は [src/db.mjs](../src/db.mjs) の
   `CURRENT_VERSION`、二相handoffの判断は

package/docs/adr/0021-grok-host-capture.md

@@ -52,6 +52,11 @@ Grok 1.0.4 バイナリの hook 出力型は `GateHookJson`（PreToolUse deny/up
   この後ユーザーが指示を出す。何もせず待機すること。
   ```
 
+- 通常の`{context}`は引き継ぎの事実と保持ターン数を最初の応答で一度だけ案内し、後続応答では
+  繰り返させない。project束縛済み補足が`handoffDisclosure: silent`を指定した時だけ案内しない。
+  Throughline自身が旧版でassistantへ付けた固定宣言は後継へ渡す会話本文から除外し、ユーザーが
+  同じ文を引用した内容は保持する。
+
 - spawn の cwd は源セッションの `project_path`。呼び出し元 cwd は使わない。共有 `GROK_HOME` の対話 `grok`。位置引数 `[PROMPT]` を使う。`--rules` / `--system-prompt-override` / `--agent` / 単発 `-p` は使わない。aiterm は使わない。
 - Claude / Codex の `/tl` 契約は変えない。Grok `/tl` 成功後の副作用起動だけが配線対象。
 - 一覧の正は `~/.grok/sessions/<encodeURIComponent(cwd)>/<id>/`。Desktop Inactive 畳みは成功条件にしない。

package/docs/adr/0023-handoff-disclosure-policy.md

@@ -0,0 +1,37 @@
+# ADR 0023: 引き継ぎ案内を通常は一度だけ表示する
+
+Date: 2026-09-02
+
+## Status
+
+Accepted
+
+## Context
+
+v0.10.12以前の引き継ぎコンテキストは、モデルへ「Throughlineで前のセッションから
+Nターン分の記憶を引き継いだ」と応答冒頭で宣言させていた。この命令は最初の応答と
+ともに同じhost sessionへ残り、再起動が一度しか起きていなくても後続応答で同じ宣言を
+模倣させた。さらに、その応答を次の引き継ぎへ再投入すると宣言が連鎖する。
+
+一方、通常のThroughline利用では、引き継ぎが成立したことを最初の応答で確認できる案内は
+必要である。BellTeamのような埋込製品は会話画面へ基盤のメタ情報を出さない。
+
+## Decision
+
+- 通常の引き継ぎは、引き継ぎの事実と保持ターン数を最初の応答で一度だけ案内する。
+- 同じhost sessionの2回目以降の応答では案内を繰り返させない。
+- `handoff-context`は`--disclosure visible|silent`を受け取り、`silent`を指定した埋込製品では
+  補足ファイルを作らずに案内を消せる。
+- project束縛済み`throughline.handoff_supplement.v1`も任意の`handoffDisclosure`として
+  `visible`（既定）または`silent`を持てる。
+- Throughline自身が旧版でassistantへ付けた固定宣言行は、後継へ渡すassistant本文から除外する。
+- ユーザー発言に含まれる同じ文字列は会話内容として保持する。
+- 引き継ぎの成立はsession対応、生成コンテキスト、継続応答の内容で検証する。宣言の反復を
+  成立判定に使わない。
+
+## Consequences
+
+- 通常のThroughline利用では従来の引き継ぎ案内が残る。
+- 埋込製品はproject分離境界と公開CLI引数を使って案内だけを非表示にできる。
+- 旧宣言が保存済みのsessionも、次回の正規引き継ぎでメタ行を持ち越さない。
+- 保存済みの原会話は監査記録として変更しない。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "throughline",
-    "version": "0.10.12",
+    "version": "0.10.14",
     "type": "module",
     "description": "Persistent memory hooks for Claude Code, Codex, Grok, and Cursor (/clear-safe context compression)",
     "keywords": [

package/src/cli/handoff-context.mjs

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
+import { isAbsolute, join, resolve } from 'node:path';
 
 import { sameProjectPath } from '../project-path.mjs';
 import { openReadOnlyDb } from '../db.mjs';
@@ -13,23 +13,50 @@ export const HANDOFF_CONTEXT_SCHEMA = 'throughline.handoff_context.v1';
 export const HANDOFF_SUPPLEMENT_SCHEMA = 'throughline.handoff_supplement.v1';
 
 export function parseArgs(argv = []) {
-  const baseArgsInvalid =
-    (argv.length !== 3 && argv.length !== 5) ||
-    argv[0] !== '--session' ||
+  if (
+    (argv[0] !== '--session' && argv[0] !== '--project') ||
     typeof argv[1] !== 'string' ||
     argv[1].length === 0 ||
-    argv[2] !== '--json';
-  const supplementArgsValid = argv.length === 3 || (
-    argv[3] === '--supplement-file' &&
-    typeof argv[4] === 'string' &&
-    argv[4].length > 0
-  );
-  if (baseArgsInvalid || !supplementArgsValid) {
+    argv[2] !== '--json' ||
+    argv.length % 2 === 0
+  ) {
     throw new TypeError('usage error');
   }
+
+  let supplementFile = null;
+  let handoffDisclosure = 'visible';
+  const seen = new Set();
+  for (let index = 3; index < argv.length; index += 2) {
+    const option = argv[index];
+    const value = argv[index + 1];
+    if (
+      seen.has(option) ||
+      typeof value !== 'string' ||
+      value.length === 0
+    ) {
+      throw new TypeError('usage error');
+    }
+    seen.add(option);
+    if (option === '--supplement-file') {
+      supplementFile = value;
+    } else if (option === '--disclosure' && ['visible', 'silent'].includes(value)) {
+      handoffDisclosure = value;
+    } else {
+      throw new TypeError('usage error');
+    }
+  }
+  if (
+    (argv[0] === '--project' && supplementFile) ||
+    (supplementFile && seen.has('--disclosure'))
+  ) {
+    throw new TypeError('usage error');
+  }
+
   return {
-    sessionId: argv[1],
-    supplementFile: argv.length === 5 ? argv[4] : null,
+    sessionId: argv[0] === '--session' ? argv[1] : null,
+    projectPath: argv[0] === '--project' ? resolve(argv[1]) : null,
+    supplementFile,
+    handoffDisclosure,
   };
 }
 
@@ -38,6 +65,8 @@ export function renderHandoffSupplement(value, projectPath) {
     value?.schema !== HANDOFF_SUPPLEMENT_SCHEMA ||
     !isAbsolute(value.projectPath) ||
     !sameProjectPath(value.projectPath, projectPath) ||
+    (value.handoffDisclosure !== undefined &&
+      !['visible', 'silent'].includes(value.handoffDisclosure)) ||
     !Array.isArray(value.sections) ||
     value.sections.length === 0
   ) {
@@ -59,27 +88,29 @@ export function renderHandoffSupplement(value, projectPath) {
 export function readHandoffContext(sessionId, {
   dbPath = join(homedir(), '.throughline', 'throughline.db'),
   supplementFile = null,
+  handoffDisclosure = 'visible',
 } = {}) {
   if (!existsSync(dbPath)) return null;
 
   const db = openReadOnlyDb(dbPath);
   try {
     let supplementContext = null;
+    let resolvedHandoffDisclosure = handoffDisclosure;
     if (supplementFile) {
       const row = db.prepare(
         'SELECT project_path FROM sessions WHERE session_id = ?',
       ).get(sessionId);
       if (!row?.project_path) return null;
-      supplementContext = renderHandoffSupplement(
-        JSON.parse(readFileSync(supplementFile, 'utf8')),
-        row.project_path,
-      );
+      const supplement = JSON.parse(readFileSync(supplementFile, 'utf8'));
+      supplementContext = renderHandoffSupplement(supplement, row.project_path);
+      resolvedHandoffDisclosure = supplement.handoffDisclosure ?? handoffDisclosure;
     }
 
     const separator = supplementContext ? '\n\n' : '';
     const context = buildBudgetedResumeContext(db, {
       sessionId,
       isInheritance: true,
+      handoffDisclosure: resolvedHandoffDisclosure,
       maxChars: INJECTION_BUDGET_CHARS - (supplementContext?.length ?? 0) - separator.length,
     })?.text ?? null;
     if (!context && !supplementContext) return null;
@@ -96,6 +127,34 @@ export function readHandoffContext(sessionId, {
   }
 }
 
+export function readLatestProjectHandoffContext(projectPath, {
+  dbPath = join(homedir(), '.throughline', 'throughline.db'),
+  handoffDisclosure = 'visible',
+} = {}) {
+  if (!existsSync(dbPath)) return null;
+
+  const db = openReadOnlyDb(dbPath);
+  try {
+    const sessions = db.prepare(
+      `SELECT session_id, project_path
+       FROM sessions
+       ORDER BY updated_at DESC`,
+    ).all();
+    for (const session of sessions) {
+      if (!sameProjectPath(session.project_path, projectPath)) continue;
+      const context = buildBudgetedResumeContext(db, {
+        sessionId: session.session_id,
+        isInheritance: true,
+        handoffDisclosure,
+      })?.text ?? null;
+      if (context) return { sessionId: session.session_id, context };
+    }
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
 export function readSessionProjectPath(sessionId, {
   dbPath = join(homedir(), '.throughline', 'throughline.db'),
 } = {}) {
@@ -119,26 +178,43 @@ export function run(argv = [], {
   stdout = process.stdout,
   stderr = process.stderr,
   readContext = readHandoffContext,
+  readProjectContext = readLatestProjectHandoffContext,
 } = {}) {
   let sessionId;
+  let projectPath;
   let supplementFile;
+  let handoffDisclosure;
   try {
-    ({ sessionId, supplementFile } = parseArgs(argv));
+    ({ sessionId, projectPath, supplementFile, handoffDisclosure } = parseArgs(argv));
   } catch {
     stderr.write(
-      'Usage: throughline handoff-context --session <id> --json [--supplement-file <path>]\n',
+      'Usage: throughline handoff-context (--session <id> | --project <path>) --json [--disclosure visible|silent | --supplement-file <path>]\n',
     );
     return 2;
   }
 
-  let context;
+  let result;
   try {
-    context = readContext(sessionId, { supplementFile });
+    result = projectPath
+      ? readProjectContext(projectPath, { handoffDisclosure })
+      : {
+          sessionId,
+          context: readContext(sessionId, { supplementFile, handoffDisclosure }),
+        };
   } catch {
     stderr.write('Throughline handoff context could not be read.\n');
     return 1;
   }
-  if (!context) {
+  if (!result?.context && projectPath) {
+    stdout.write(`${JSON.stringify({
+      schema: HANDOFF_CONTEXT_SCHEMA,
+      status: 'empty',
+      sessionId: null,
+      context: '',
+    })}\n`);
+    return 0;
+  }
+  if (!result?.context) {
     stderr.write('Throughline handoff context is not available for that session.\n');
     return 1;
   }
@@ -146,8 +222,8 @@ export function run(argv = [], {
   stdout.write(`${JSON.stringify({
     schema: HANDOFF_CONTEXT_SCHEMA,
     status: 'ready',
-    sessionId,
-    context,
+    sessionId: result.sessionId,
+    context: result.context,
   })}\n`);
   return 0;
 }

package/src/cli/handoff-context.test.mjs

@@ -8,7 +8,11 @@ import { fileURLToPath } from 'node:url';
 import { DatabaseSync } from 'node:sqlite';
 
 import { buildBudgetedResumeContext, INJECTION_BUDGET_CHARS } from '../resume-context.mjs';
-import { parseArgs, readSessionProjectPath } from './handoff-context.mjs';
+import {
+  parseArgs,
+  readLatestProjectHandoffContext,
+  readSessionProjectPath,
+} from './handoff-context.mjs';
 
 const REPO_ROOT = fileURLToPath(new URL('../..', import.meta.url));
 const BIN_PATH = join(REPO_ROOT, 'bin/throughline.mjs');
@@ -169,6 +173,125 @@ test('handoff-context adds a project-bound supplement inside the shared budget',
   }
 });
 
+test('handoff-context supplement can silence disclosure without changing normal default', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-silent-'));
+  try {
+    const { db } = createFixture(home);
+    db.close();
+    const supplementFile = join(home, 'supplement.json');
+    writeFileSync(supplementFile, JSON.stringify({
+      schema: 'throughline.handoff_supplement.v1',
+      projectPath: '/work/project',
+      handoffDisclosure: 'silent',
+      sections: [{ title: 'Botプロフィール', content: 'BellTeamのBot' }],
+    }));
+
+    const normal = runCli(home);
+    assert.equal(normal.status, 0, normal.stderr);
+    assert.match(JSON.parse(normal.stdout).context, /この引き継ぎ直後の最初の応答だけ/);
+
+    const silent = runCli(home, [
+      'handoff-context', '--session', SESSION_ID, '--json',
+      '--supplement-file', supplementFile,
+    ]);
+    assert.equal(silent.status, 0, silent.stderr);
+    const context = JSON.parse(silent.stdout).context;
+    assert.doesNotMatch(context, /この引き継ぎ直後の最初の応答だけ/);
+    assert.doesNotMatch(context, /Throughline で前のセッションから .* ターン分/);
+    assert.match(context, /BellTeamのBot/);
+    assert.match(context, /所有権を変えずに記憶を渡して/);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-context can silence disclosure without a long-term-memory supplement', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-direct-silent-'));
+  try {
+    const { db } = createFixture(home);
+    db.close();
+
+    const result = runCli(home, [
+      'handoff-context', '--session', SESSION_ID, '--json',
+      '--disclosure', 'silent',
+    ]);
+    assert.equal(result.status, 0, result.stderr);
+    const context = JSON.parse(result.stdout).context;
+    assert.doesNotMatch(context, /この引き継ぎ直後の最初の応答だけ/);
+    assert.doesNotMatch(context, /Throughline で前のセッションから .* ターン分/);
+    assert.match(context, /所有権を変えずに記憶を渡して/);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-context project selector skips the newest empty session', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-project-'));
+  try {
+    const { db, dbPath } = createFixture(home);
+    db.prepare(
+      `INSERT INTO sessions
+         (session_id, project_path, status, created_at, updated_at, merged_into)
+       VALUES ('newest-empty', '/work/project', 'active', ?, ?, NULL)`,
+    ).run(1_700_000_005_000, 1_700_000_006_000);
+    db.prepare(
+      `INSERT INTO sessions
+         (session_id, project_path, status, created_at, updated_at, merged_into)
+       VALUES ('other-newest', '/work/other', 'active', ?, ?, NULL)`,
+    ).run(1_700_000_007_000, 1_700_000_008_000);
+    db.prepare(
+      `INSERT INTO bodies
+         (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES ('other-newest', 'other-newest', 1, 'user', 'OTHER_PROJECT_PRIVATE', 4, ?)`,
+    ).run(1_700_000_007_500);
+    db.close();
+
+    const selected = readLatestProjectHandoffContext('/work/project', {
+      dbPath,
+      handoffDisclosure: 'silent',
+    });
+    assert.equal(selected.sessionId, SESSION_ID);
+    assert.match(selected.context, /所有権を変えずに記憶を渡して/);
+
+    const result = runCli(home, [
+      'handoff-context', '--project', '/work/project', '--json',
+      '--disclosure', 'silent',
+    ]);
+    assert.equal(result.status, 0, result.stderr);
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.status, 'ready');
+    assert.equal(payload.sessionId, SESSION_ID);
+    assert.match(payload.context, /所有権を変えずに記憶を渡して/);
+    assert.doesNotMatch(payload.context, /OTHER_PROJECT_PRIVATE/);
+    assert.doesNotMatch(payload.context, /この引き継ぎ直後の最初の応答だけ/);
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('handoff-context project selector returns empty when the project has no dialogue', () => {
+  const home = mkdtempSync(join(tmpdir(), 'tl-handoff-project-empty-'));
+  try {
+    const { db } = createFixture(home);
+    db.exec('DELETE FROM details; DELETE FROM bodies; DELETE FROM skeletons;');
+    db.close();
+
+    const result = runCli(home, [
+      'handoff-context', '--project', '/work/project', '--json',
+      '--disclosure', 'silent',
+    ]);
+    assert.equal(result.status, 0, result.stderr);
+    assert.deepEqual(JSON.parse(result.stdout), {
+      schema: 'throughline.handoff_context.v1',
+      status: 'empty',
+      sessionId: null,
+      context: '',
+    });
+  } finally {
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('handoff-context returns a project-bound supplement when the captured session has no dialogue yet', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-handoff-supplement-only-'));
   try {
@@ -229,15 +352,33 @@ test('handoff-context refuses a supplement from another bot project', () => {
 test('handoff-context accepts only the documented supplement argument shape', () => {
   assert.deepEqual(parseArgs(['--session', 's', '--json']), {
     sessionId: 's',
+    projectPath: null,
     supplementFile: null,
+    handoffDisclosure: 'visible',
   });
   assert.deepEqual(parseArgs([
     '--session', 's', '--json', '--supplement-file', '/tmp/memory.json',
   ]), {
     sessionId: 's',
+    projectPath: null,
     supplementFile: '/tmp/memory.json',
+    handoffDisclosure: 'visible',
+  });
+  assert.deepEqual(parseArgs([
+    '--project', '.', '--json', '--disclosure', 'silent',
+  ]), {
+    sessionId: null,
+    projectPath: process.cwd(),
+    supplementFile: null,
+    handoffDisclosure: 'silent',
   });
   assert.throws(() => parseArgs(['--session', 's', '--supplement-file', '/tmp/memory.json', '--json']));
+  assert.throws(() => parseArgs(['--project', '.', '--json', '--supplement-file', '/tmp/memory.json']));
+  assert.throws(() => parseArgs(['--session', 's', '--json', '--disclosure', 'hidden']));
+  assert.throws(() => parseArgs([
+    '--session', 's', '--json', '--disclosure', 'silent',
+    '--supplement-file', '/tmp/memory.json',
+  ]));
 });
 
 test('readSessionProjectPath returns the source session project', () => {

package/src/cli/help.test.mjs

@@ -51,7 +51,8 @@ test('CLI help exposes guided Codex handoff and guarded execute semantics', () =
   assert.match(result.stdout, /Use --execute to/);
   assert.match(result.stdout, /--open-host auto\|desktop\|vscode\|cli\|none/);
   assert.match(result.stdout, /throughline trim --execute/);
-  assert.match(result.stdout, /throughline handoff-context --session <id> --json/);
+  assert.match(result.stdout, /throughline handoff-context \(--session <id> \| --project <path>\) --json/);
+  assert.match(result.stdout, /--disclosure silent/);
   assert.match(result.stdout, /throughline latest-session --project <absolute-path> --json/);
   assert.match(result.stdout, /without\s+changing database ownership/);
   assert.match(result.stdout, /injectable DB memory/);

package/src/resume-context.mjs

@@ -24,11 +24,14 @@
 import { buildHandoffRecord } from './handoff-record.mjs';
 import { groupL3ByTurn, buildPartsSummary } from './l3-summary.mjs';
 
-const RESUME_HEADER_TEMPLATE = (turnCount) =>
+const RESUME_HEADER_TEMPLATE = (turnCount, handoffDisclosure) =>
   `## Throughline: 直前スレッドの継続応答用コンテキスト（${turnCount} ターン分の文脈を保持）\n` +
-  `\n` +
-  `**応答の冒頭で必ず以下を 1 行宣言してください** (会話の継続性をユーザーに見せるため):\n` +
-  `> 「Throughline で前のセッションから ${turnCount} ターン分の記憶を引き継いだ状態で続けます」\n` +
+  (handoffDisclosure === 'visible'
+    ? `\n` +
+      `**この引き継ぎ直後の最初の応答だけ、冒頭で以下を 1 行宣言してください**:\n` +
+      `> 「Throughline で前のセッションから ${turnCount} ターン分の記憶を引き継いだ状態で続けます」\n` +
+      `**2 回目以降の応答では、この宣言を繰り返さないでください。**\n`
+    : '') +
   `\n` +
   `**読み方 (重要):**\n` +
   `- 下記「現在地」「L1」「L2」は **あなた自身が直前にユーザーと交わした会話** です ` +
@@ -52,6 +55,17 @@ const RESUME_HEADER_TEMPLATE = (turnCount) =>
 
 const NORMAL_HEADER = '## Throughline: セッション記憶';
 
+// v0.10.12以前にThroughline自身がassistantへ付与させていた宣言行。
+// 製品由来のメタ情報だけを引き継ぎ材料から除き、会話本文への模倣連鎖を止める。
+// userが同じ文を引用した場合は会話内容なので保持する。
+const LEGACY_HANDOFF_DISCLOSURE =
+  /^「Throughline で前のセッションから \d+ ターン分の記憶を引き継いだ状態で続けます」[ \t]*(?:\r?\n[ \t]*)*/u;
+
+function textForHandoff(row) {
+  if (row.role !== 'assistant') return row.text;
+  return row.text.replace(LEGACY_HANDOFF_DISCLOSURE, '');
+}
+
 // 現在地アンカーは最新 user / assistant 本文を再掲する。長すぎると注入全体が膨らむので
 // この文字数で打ち切り、全文は L2 セクション側を参照させる。
 const ANCHOR_MAX_CHARS = 600;
@@ -93,7 +107,13 @@ function pickLatestExchange(recentBodies) {
  *   l2Lines: { text: string, time: string }[],
  * } | null}
  */
-function buildResumeSections(db, { sessionId, isInheritance, excludeOriginId = null }) {
+function buildResumeSections(
+  db,
+  { sessionId, isInheritance, excludeOriginId = null, handoffDisclosure = 'visible' },
+) {
+  if (!['visible', 'silent'].includes(handoffDisclosure)) {
+    throw new TypeError('invalid handoff disclosure');
+  }
   const record = buildHandoffRecord(db, {
     sessionId,
     isInheritance,
@@ -102,15 +122,21 @@ function buildResumeSections(db, { sessionId, isInheritance, excludeOriginId = n
   if (!record) return null;
 
   const turnCount = record.stats.preservedContextRows;
-  const header = isInheritance ? RESUME_HEADER_TEMPLATE(turnCount) : NORMAL_HEADER;
+  const header = isInheritance
+    ? RESUME_HEADER_TEMPLATE(turnCount, handoffDisclosure)
+    : NORMAL_HEADER;
+  const recentBodies = record.memory.recentBodies.map((row) => ({
+    ...row,
+    text: textForHandoff(row),
+  }));
 
   const l3ByTurn = groupL3ByTurn(record.references.l3);
 
   // 現在地アンカー: 引き継ぎ時のみ、最新 user / assistant turn をヘッダ直下に再掲する。
   // L2 末尾アンカーだけだと、長い L2 で注意が前半に固着して話の流れを取り違える事例があった。
   const anchorLines = [];
-  if (isInheritance && record.memory.recentBodies.length > 0) {
-    const { latestUser, latestAssistant } = pickLatestExchange(record.memory.recentBodies);
+  if (isInheritance && recentBodies.length > 0) {
+    const { latestUser, latestAssistant } = pickLatestExchange(recentBodies);
     if (latestUser) {
       anchorLines.push(
         `**最新ユーザー指示** [${latestUser.time}]: ${truncateForAnchor(latestUser.text)}`,
@@ -145,14 +171,14 @@ function buildResumeSections(db, { sessionId, isInheritance, excludeOriginId = n
   // 同じターンの user 行と assistant 行の両方に貼ると同じ内容が二度出て紛らわしい。
   const l2Lines = [];
   const lastIdxPerTurn = new Map();
-  for (let i = 0; i < record.memory.recentBodies.length; i += 1) {
-    const r = record.memory.recentBodies[i];
+  for (let i = 0; i < recentBodies.length; i += 1) {
+    const r = recentBodies[i];
     if (!r.text) continue;
     const key = `${r.originSessionId}\x00${r.turnNumber}`;
     lastIdxPerTurn.set(key, i);
   }
-  for (let i = 0; i < record.memory.recentBodies.length; i += 1) {
-    const r = record.memory.recentBodies[i];
+  for (let i = 0; i < recentBodies.length; i += 1) {
+    const r = recentBodies[i];
     if (!r.text) continue;
     const key = `${r.originSessionId}\x00${r.turnNumber}`;
     const isLastOfTurn = lastIdxPerTurn.get(key) === i;
@@ -207,9 +233,20 @@ function joinSections({ header, anchorLines, l1Lines, l2Lines }, { l1Note = null
  */
 export function buildResumeContext(
   db,
-  { sessionId, isInheritance, excludeOriginId = null, inflightMemo: _ignoredMemo = null },
+  {
+    sessionId,
+    isInheritance,
+    excludeOriginId = null,
+    inflightMemo: _ignoredMemo = null,
+    handoffDisclosure = 'visible',
+  },
 ) {
-  const sections = buildResumeSections(db, { sessionId, isInheritance, excludeOriginId });
+  const sections = buildResumeSections(db, {
+    sessionId,
+    isInheritance,
+    excludeOriginId,
+    handoffDisclosure,
+  });
   if (!sections) return null;
   return joinSections(sections);
 }
@@ -344,9 +381,20 @@ function buildGuidanceLines({ sessionId, boundaryMs, remainingTurns, remainingRa
  */
 export function buildBudgetedResumeContext(
   db,
-  { sessionId, isInheritance, excludeOriginId = null, maxChars = INJECTION_BUDGET_CHARS },
+  {
+    sessionId,
+    isInheritance,
+    excludeOriginId = null,
+    maxChars = INJECTION_BUDGET_CHARS,
+    handoffDisclosure = 'visible',
+  },
 ) {
-  const sections = buildResumeSections(db, { sessionId, isInheritance, excludeOriginId });
+  const sections = buildResumeSections(db, {
+    sessionId,
+    isInheritance,
+    excludeOriginId,
+    handoffDisclosure,
+  });
   if (!sections) return null;
 
   const lineCost = (s) => s.length + 1; // join('\n') 分

package/src/resume-context.test.mjs

@@ -113,10 +113,10 @@ test('buildResumeContext: header is terse and announces the Bash invocation cont
   assert.match(text, /新規依頼ではなく、上記スレッドの \*\*続き\*\*/);
   assert.match(text, /続きよろしく.*OK.*次は？/s);
   assert.match(text, /新規会話ではない/);
-  // β 経路 (early-style explicit report-back instruction): モデルが冒頭で
-  // 「引き継いだ状態で続けます」と明示的に表明することで、user が体感する継続感を強める
-  assert.match(text, /応答の冒頭で必ず以下を 1 行宣言/);
+  // 通常のThroughline引き継ぎは最初の一度だけ可視化し、後続応答では反復させない。
+  assert.match(text, /この引き継ぎ直後の最初の応答だけ/);
   assert.match(text, /Throughline で前のセッションから .* ターン分の記憶を引き継いだ状態で続けます/);
+  assert.match(text, /2 回目以降の応答では、この宣言を繰り返さない/);
   assert.match(
     text,
     /\*\*各ターンの詳細\*\*: \*\*`Bash` ツールで `throughline detail HH:MM:SS` を実行\*\* \(該当ターンの本文＋詳細を stdout に返します\)/,
@@ -130,6 +130,61 @@ test('buildResumeContext: header is terse and announces the Bash invocation cont
   assert.match(text, /最新アシスタント発話の指示が、過去ターンのリストへの参照より上位/);
 });
 
+test('buildResumeContext: silent disclosure keeps inheritance internal', () => {
+  const db = makeDb();
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: '続きの本文',
+    createdAt: 1000,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+    handoffDisclosure: 'silent',
+  });
+
+  assert.ok(text);
+  assert.doesNotMatch(text, /この引き継ぎ直後の最初の応答だけ/);
+  assert.doesNotMatch(text, /Throughline で前のセッションから .* ターン分の記憶を引き継いだ状態で続けます/);
+  assert.match(text, /\[assistant\]: 続きの本文/);
+});
+
+test('buildResumeContext: legacy disclosure is removed only from assistant memory', () => {
+  const db = makeDb();
+  const disclosure = '「Throughline で前のセッションから 20 ターン分の記憶を引き継いだ状態で続けます」';
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'user',
+    text: `この表示は何？ ${disclosure}`,
+    createdAt: 1000,
+  });
+  insertBody(db, {
+    session: 'new',
+    origin: 'old',
+    turn: 1,
+    role: 'assistant',
+    text: `${disclosure}\n\n本題の応答です。`,
+    createdAt: 1001,
+  });
+
+  const text = buildResumeContext(db, {
+    sessionId: 'new',
+    isInheritance: true,
+  });
+
+  assert.ok(text);
+  assert.equal(text.split(disclosure).length - 1, 2, 'user quote remains in anchor and L2 only');
+  assert.doesNotMatch(text, /\[assistant\]: 「Throughline で前のセッションから/);
+  assert.match(text, /\[assistant\]: 本題の応答です。/);
+  assert.match(text, /\*\*直前のアシスタント\*\* \[\d\d:\d\d:\d\d\]: 本題の応答です。/);
+});
+
 test('buildResumeContext: 現在地 anchor surfaces the latest user/assistant exchange above L1/L2', () => {
   const db = makeDb();
   // 25 turns to exercise an L2 window edge and ensure the anchor picks the newest.