throughline 0.10.11 → 0.10.13

package/CHANGELOG.md

@@ -10,6 +10,22 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.10.13] — 2026-09-02
+
+### Fixed
+
+- 通常の引き継ぎ案内を最初の応答だけに限定し、project束縛済み補足から
+  `handoffDisclosure: "silent"`を指定したlauncherは案内を非表示にできるようにした。
+- Throughline旧版がassistant本文へ付けた固定宣言行だけを次回引き継ぎ時に除外し、
+  ユーザーの引用と宣言後の会話本文は保持する。
+
+## [0.10.12] — 2026-09-01
+
+### Changed
+
+- 変更した実装の依存関係から必要なテストと工場環境を選び、依存を確定できない変更だけ全件へ広げ、選択jobのskip・cancel・failureを最終gateで拒否する製品所有CIへ更新した。
+- 文書だけの変更はLinuxの文書検査だけを実行し、共通・未分類の製品変更は従来どおり3環境で検証する。
+
 ## [0.10.11] — 2026-09-01
 
 ### Fixed
@@ -1414,7 +1430,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.10.11...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.10.13...HEAD
+[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
 [0.10.9]: https://github.com/kitepon/Throughline/compare/v0.10.8...v0.10.9

package/README.ja.md

@@ -74,6 +74,11 @@ cwd は源セッションの `project_path` であり、呼び出し元 cwd は
 `/clear` では起動しない。aiterm / `--rules` / `--from` は使わない。
 macOS Terminal のみ。
 
+通常のhandoff-contextは、引き継いだことを最初の応答で一度だけ案内し、後続応答では
+繰り返させない。project束縛済み補足へ`handoffDisclosure: "silent"`を指定した埋込製品だけは
+案内を出さない。旧版がassistant本文へ付けた固定宣言は次回引き継ぎから除外し、ユーザーの
+引用と実際の応答本文は保持する。
+
 新席は `~/.grok/sessions/<encodeURIComponent(cwd)>/` のトップレベル
 ディレクトリ。Desktop の Inactive 畳みは成功条件にしない。L2 が無い源
 （`merged_into` チェーンの空席など）では起動しない。新しい chat で 1〜2
@@ -428,7 +433,8 @@ throughline handoff-context --session codex:<thread-id> --json
 成功時の`throughline.handoff_context.v1`は`schema`、`status`、`sessionId`、`context`だけを返す。
 `context`はSessionStartと同じ予算付き継承文脈である。任意の`--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は任意の
 別harness portable forkでこの境界を使う。Observer feedはcompleted-turn projectionであり代替ではない。

package/README.md

@@ -817,13 +817,20 @@ entry to the `tasks` array yourself:
 
 ## Commands
 
-**The current release is v0.10.11.** Throughline supports Claude Code, Codex,
+**The current release is v0.10.13.** 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
+supplement may set `handoffDisclosure` to `silent` for an embedded product that
+keeps continuity metadata out of its chat. 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 |
@@ -916,6 +923,7 @@ inheritance text used by SessionStart. A launcher may append
 {
   "schema": "throughline.handoff_supplement.v1",
   "projectPath": "/absolute/bot/project",
+  "handoffDisclosure": "silent",
   "sections": [
     { "title": "Long-term memory", "content": "..." },
     { "title": "Relevant knowledge", "content": "..." }
@@ -923,6 +931,7 @@ 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

package/docs/04_public_release_plan.md

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

package/package.json

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

package/src/cli/handoff-context.mjs

@@ -38,6 +38,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
   ) {
@@ -65,21 +67,22 @@ export function readHandoffContext(sessionId, {
   const db = openReadOnlyDb(dbPath);
   try {
     let supplementContext = null;
+    let handoffDisclosure = 'visible';
     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);
+      handoffDisclosure = supplement.handoffDisclosure ?? 'visible';
     }
 
     const separator = supplementContext ? '\n\n' : '';
     const context = buildBudgetedResumeContext(db, {
       sessionId,
       isInheritance: true,
+      handoffDisclosure,
       maxChars: INJECTION_BUDGET_CHARS - (supplementContext?.length ?? 0) - separator.length,
     })?.text ?? null;
     if (!context && !supplementContext) return null;

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

@@ -169,6 +169,38 @@ 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 returns a project-bound supplement when the captured session has no dialogue yet', () => {
   const home = mkdtempSync(join(tmpdir(), 'tl-handoff-supplement-only-'));
   try {

package/src/docs-contract.test.mjs

@@ -24,16 +24,19 @@ test('Markdown-only CI runs the product-owned documentation contract', () => {
   );
   assert.match(
     workflow,
-    /documentation-command:\s+npm install --ignore-scripts --no-package-lock --no-audit --no-fund && npm run verify:docs/,
+    /documentation-command:\s+npm run verify:docs/,
   );
   assert.doesNotMatch(workflow, /documentation-command:\s*(?:["']{2})?\s*$/m);
 
   const reusable = readFileSync(new URL('../.github/workflows/product-full-ci.yml', import.meta.url), 'utf8');
-  assert.match(reusable, /setup documentation Node[\s\S]*actions\/setup-node@[0-9a-f]{40}[\s\S]*node-version:\s*22/);
+  const runner = readFileSync(new URL('../scripts/run-product-ci-tests.mjs', import.meta.url), 'utf8');
+  assert.match(reusable, /name: documentation dependency install/);
+  assert.match(reusable, /scripts\/product-ci-plan\.mjs verify/);
   assert.ok(
-    reusable.indexOf('setup documentation Node') < reusable.indexOf('- name: documentation check'),
-    'documentation Node must be configured before dependency installation and verification',
+    reusable.indexOf('documentation dependency install') < reusable.indexOf('- name: documentation check'),
+    'documentation dependencies must be installed before verification',
   );
+  assert.doesNotMatch(runner, /npm\.cmd|cmd\.exe/);
 
   const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
   const result = spawnPortableSync(npmCommand, ['run', 'verify:docs', '--silent'], {

package/src/product-ci-plan.test.mjs

@@ -0,0 +1,150 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import test from 'node:test';
+
+import {
+  ALL_ENVIRONMENTS,
+  classifyPaths,
+  selectTestFiles,
+  verifyResults,
+} from '../scripts/product-ci-plan.mjs';
+
+const SCRIPT = resolve(import.meta.dirname, '..', 'scripts', 'product-ci-plan.mjs');
+
+function git(root, ...args) {
+  const result = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  return result.stdout.trim();
+}
+
+async function repository(t) {
+  const root = await mkdtemp(join(tmpdir(), 'throughline-ci-plan-'));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  git(root, 'init');
+  git(root, 'config', 'user.name', 'CI test');
+  git(root, 'config', 'user.email', 'ci@example.invalid');
+  await writeFile(join(root, 'README.md'), '# fixture\n', 'utf8');
+  git(root, 'add', 'README.md');
+  git(root, 'commit', '-m', 'initial');
+  const base = git(root, 'rev-parse', 'HEAD');
+  await mkdir(join(root, 'src', 'os'), { recursive: true });
+  await writeFile(join(root, 'src', 'os', 'windows-acl.mjs'), '// fixture\n', 'utf8');
+  git(root, 'add', 'src/os/windows-acl.mjs');
+  git(root, 'commit', '-m', 'windows');
+  return { root, base, head: git(root, 'rev-parse', 'HEAD') };
+}
+
+test('文書だけの変更はLinuxの文書検査へ分類する', () => {
+  const plan = classifyPaths(['README.md', 'docs/04_public_release_plan.md']);
+  assert.equal(plan.productChange, false);
+  assert.deepEqual(plan.environments, ['linux-workstation']);
+});
+
+test('macOS固有変更はmacOSとLinuxへ分類する', () => {
+  const plan = classifyPaths(['src/os/macos-terminal.mjs']);
+  assert.equal(plan.productChange, true);
+  assert.deepEqual(plan.environments, ['macos-native', 'linux-workstation']);
+});
+
+test('Windows固有変更はLinuxとWindowsへ分類する', () => {
+  const plan = classifyPaths(['src/os/windows-acl.mjs']);
+  assert.equal(plan.productChange, true);
+  assert.deepEqual(plan.environments, ['linux-workstation', 'windows-native']);
+});
+
+test('共通変更と未分類変更は全環境へ広げる', () => {
+  for (const paths of [['src/db.mjs'], ['new-product/file.txt'], ['.github/workflows/test.yml'], []]) {
+    const plan = classifyPaths(paths);
+    assert.equal(plan.productChange, true);
+    assert.deepEqual(plan.environments, ALL_ENVIRONMENTS);
+  }
+});
+
+test('実装変更は依存するテストだけを選ぶ', () => {
+  const plan = selectTestFiles(['src/terminal-size.mjs'], resolve(import.meta.dirname, '..'));
+  assert.equal(plan.testScope, 'selected');
+  assert.ok(plan.testFiles.includes('src/terminal-size.test.mjs'));
+  assert.ok(plan.testFiles.length < 82);
+});
+
+test('依存を確定できない変更は全テストへ広げる', () => {
+  assert.deepEqual(selectTestFiles(['package.json'], resolve(import.meta.dirname, '..')), {
+    testScope: 'all',
+    testFiles: [],
+  });
+});
+
+test('結果判定は選択されたfullの成功と文書時の明示skipだけを受け入れる', () => {
+  assert.doesNotThrow(() => verifyResults({
+    classifyResult: 'success',
+    fullResult: 'success',
+    productChange: 'true',
+  }));
+  assert.doesNotThrow(() => verifyResults({
+    classifyResult: 'success',
+    fullResult: 'skipped',
+    productChange: 'false',
+  }));
+});
+
+test('結果判定は分類失敗と理由不明skipを拒否する', () => {
+  assert.throws(() => verifyResults({
+    classifyResult: 'failure',
+    fullResult: 'skipped',
+    productChange: '',
+  }), /変更分類jobが成功していません/u);
+  assert.throws(() => verifyResults({
+    classifyResult: 'success',
+    fullResult: 'skipped',
+    productChange: 'true',
+  }), /選択計画と実行結果が一致しません/u);
+});
+
+test('plan入口はGit履歴から変更を分類してGitHub outputへ書く', async (t) => {
+  const repo = await repository(t);
+  const output = join(repo.root, 'github-output.txt');
+  const result = spawnSync(process.execPath, [SCRIPT, 'plan'], {
+    cwd: repo.root,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      EVENT_NAME: 'push',
+      BEFORE_SHA: repo.base,
+      BASE_SHA: '',
+      DISPATCH_BASE: '',
+      GITHUB_REF: 'refs/heads/main',
+      GITHUB_SHA: repo.head,
+      GITHUB_OUTPUT: output,
+      REQUESTED_ENVIRONMENT: 'all',
+    },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  const outputs = Object.fromEntries((await readFile(output, 'utf8')).trim().split('\n')
+    .map((line) => line.split(/=(.*)/su).slice(0, 2)));
+  assert.equal(outputs.product_change, 'true');
+  assert.deepEqual(JSON.parse(outputs.environments), ['linux-workstation', 'windows-native']);
+  assert.equal(outputs.test_scope, 'all');
+  assert.equal(outputs.comparison_base, repo.base);
+});
+
+test('plan入口はzero SHAを明示失敗にする', async (t) => {
+  const repo = await repository(t);
+  const result = spawnSync(process.execPath, [SCRIPT, 'plan'], {
+    cwd: repo.root,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      EVENT_NAME: 'push',
+      BEFORE_SHA: '0'.repeat(40),
+      GITHUB_REF: 'refs/heads/main',
+      GITHUB_SHA: repo.head,
+      GITHUB_OUTPUT: join(repo.root, 'github-output.txt'),
+      REQUESTED_ENVIRONMENT: 'all',
+    },
+  });
+  assert.equal(result.status, 2);
+  assert.match(result.stderr, /CI comparison baseが必要です/u);
+});

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.