throughline 0.15.0 → 0.15.2

package/CHANGELOG.md

@@ -10,6 +10,42 @@ shipped to npm but were not individually tagged on GitHub.
 
 ## [Unreleased]
 
+## [0.15.2] — 2026-10-06
+
+### 修正
+
+- Claude Desktopで「フォルダなし」で始めて、後から作業フォルダへ移した会話では、自動継続（`auto-handoff enable --host claude`）を有効にしていても引き継ぎが始まらない不具合を直す。Desktopは会話を移した後も、hookへ渡す`CLAUDE_PROJECT_DIR`を移る前の場所のままにする。Throughlineはその値で対象のprojectかどうかを決めていたので、自動圧縮の前のhookが`auto_handoff_disabled`で見送り、圧縮がそのまま走っていた。
+- 会話が移った先は、Claude Codeがtranscriptへ書く`relocated`の行（`relocatedCwd`）から読む。移っている会話では、自動継続の有効判定と印（baton）のprojectを、移った先にする。
+- 同じ会話のターン終了では、完了ターンの控えを移った先のprojectへ書き、`sessions.project_path`を移った先へ付け替える。これまでは移る前の場所のまま残り、移った先のprojectの過去の会話（`handoff-context`、`throughline detail`）にも`observer-read`にも、その会話が出なかった。
+- 移っていない会話の扱いは変わらない。`relocated`の行が無ければ、これまでどおり`CLAUDE_PROJECT_DIR`、無ければhookの`cwd`を使う。
+
+### 確認した範囲
+
+- macOS（Claude Desktop同梱の2.1.286が書いた本物のtranscriptの写し、移った後に自動圧縮が2回走った会話）。切り離したHOMEでhookを手で呼び、0.14.2は`pre-compact`が終了コード0・`auto_handoff_disabled`、`sessions.project_path`と控えは移る前の場所。この版は`pre-compact`が終了コード2（圧縮を止める）・`requested`、`sessions.project_path`と控えは移った先、`observer-read`は移った先のprojectで`snapshot`を返す。
+- macOS、端末から始めた移っていない会話（Claude Code 2.1.289、Haiku 4.5）。この版で4回連続で引き継ぎ、14個を番号順に読み切って完了。自動圧縮は0回。
+
+### 確認していない範囲
+
+- Claude Desktopの画面で、この版が通しで引き継ぐこと（旧い会話を止める所と、後継を立てる所）。Desktopの画面からの送信が要るため、hookを手で呼ぶ確認までにとどまる。
+- Windows・Linuxで移した会話。`relocated`の行の読み取りは、Windowsの書き方の場所を単体の試験で確かめただけ。
+
+## [0.15.1] — 2026-10-05
+
+### 修正
+
+- Claudeの席で、完了ターンの控えが256件に達した後、`observer-read`・`observer-wait`へ前に受け取った位置（`--after-cursor`）を渡すと、1ターン増えるたびに`resync_required`が返る不具合を直す（[ADR 0035](docs/adr/0035-observer-cursor-prefix-only.md)）。位置の検証が、位置に入っている控えの下限の番号と今の下限の番号を比べていた。上限に達すると1ターンごとに古い1件が落ちて下限が1上がるので、追いついている位置も必ず無効になった。下限はproject全体で1つなので、落ちた控えが別の古い会話のものでも同じだった。
+- 位置の検証は、位置が指す会話の先頭から読んだ分が今も同じかどうか（`prefix_sha256`の照合）だけで行う。別の古い会話の控えが落ちても、今の会話の位置は有効なままで、`append`・`delta`が返る。
+- 位置の形、snapshotの返し方、`resync_required`を終了コード0で返すことは変わらない。0.15.0以前が出した位置は、そのまま使える。
+
+### 残る制限
+
+- 1つの会話だけで控えが256件を超えると、その会話の先頭が落ちるので、その会話の位置は今までどおり1ターンごとに`resync_required`になる。
+
+### 確認した範囲
+
+- 古い会話の控えで上限まで埋まったprojectで、新しい会話のターンを1つずつ足す再現。0.15.0は2ターン目から毎回`resync_required`、0.15.1は毎回`append`と、足したターンだけの`delta`を返す。
+- BellTeamのコンテナで、控えが上限に達している席（連番は329まで進み、保持は256件、会話は27本、最新の会話の控えは14件）の控えを一時ファイルへ写し、最新の会話へ3ターン足した。読み終えた位置を毎回取り直しても、0.15.0は3回とも`resync_required`、0.15.1は3回とも`append`を返す。控えはhashとsession idだけで、本文は含まない。
+
 ## [0.15.0] — 2026-10-05
 
 ### 追加
@@ -1754,7 +1790,9 @@ two attempts, instrument first instead of patching again.
 
 ---
 
-[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.0...HEAD
+[Unreleased]: https://github.com/kitepon/Throughline/compare/v0.15.2...HEAD
+[0.15.2]: https://github.com/kitepon/Throughline/compare/v0.15.1...v0.15.2
+[0.15.1]: https://github.com/kitepon/Throughline/compare/v0.15.0...v0.15.1
 [0.15.0]: https://github.com/kitepon/Throughline/compare/v0.14.3...v0.15.0
 [0.14.3]: https://github.com/kitepon/Throughline/compare/v0.14.2...v0.14.3
 [0.14.2]: https://github.com/kitepon/Throughline/compare/v0.14.1...v0.14.2

package/docs/adr/0033-claude-auto-handoff-new-session.md

@@ -31,6 +31,8 @@ Claude Desktop の新しい会話は、画面を開いただけでは process
 1. **圧縮を止める**: `PreCompact` hook（`throughline pre-compact`、matcher 無し）が、`trigger: "auto"` で自動継続が
    有効な project の時だけ、`/tl` と同じ印（baton）と引き継ぎの記録を残し、exit code 2 で圧縮を止める。
    印の project は、会話を起動した場所（`CLAUDE_PROJECT_DIR`）を、その OS の書き方にそろえたもの（0.14.2）。
+   Claude Desktop で会話を別の project へ移している時は、transcript の `relocated` の行（`relocatedCwd`）が示す移った先を使う。
+   `CLAUDE_PROJECT_DIR` は移る前の場所のまま届くため（0.15.2）。
    hook の cwd は Bash の `cd` に追従するので使わない。後継は起動した場所で立ち、その cwd で印を探す。
    手動の `/compact`、無効な project、subagent の中の圧縮（payload に `agent_id`）、script から起動した会話
    （`CLAUDE_CODE_ENTRYPOINT` が `sdk-` で始まる）では止めない。

package/docs/adr/0035-observer-cursor-prefix-only.md

@@ -0,0 +1,49 @@
+# ADR 0035: Observer の位置は、下限の番号を比べず、先頭からの照合だけで検証する
+
+日付: 2026-10-05
+
+## Context
+
+ADR 0003 は、Claude の完了ターンの控え（project ごとに 256 件まで、`COMPLETED_TURN_RECEIPT_LIMIT`）から
+作る chain に位置（cursor）を結び、「保持の下限より古い位置は resync を求める」と決めた。位置には、
+発行した時点の控えの下限の番号（`history_floor`）、会話の chain の長さ（`length`）、先頭から `length` 件の
+digest（`prefix_sha256`）が入る。
+
+実装は「位置の `history_floor` < 今の `history_floor`」なら `resync_required` にしていた。控えが 256 件に
+達すると、1 ターン増えるたびに古い 1 件が落ちて下限の番号が 1 上がる。そのため、追いついている位置も、
+次の 1 ターンで必ず無効になった。下限は project 全体で 1 つなので、落ちた控えが別の古い会話のものでも、
+今の会話の位置が無効になった。
+
+BellTeam（0.14.3、2026-10-05）で、控えが 323 件ある席の読み出しが、ターン 10 回すべてで `resync_required` に
+なった。BellTeam は `resync_required` のたびに今の位置から読み直していたので、その間に終わったターンの
+回答が画面に出なかった（同じ日に 2 回）。BellTeam のビスケットとトロニーが見つけた。
+
+`history_floor` の比較が無くても、位置が指す会話の先頭の控えが落ちたことは分かる。先頭が k 件落ちると、
+今の chain の先頭から `length` 件は、発行した時の先頭から `length` 件と違う控えになり、`prefix_sha256` が
+合わない（各項目は控えの連番から作る `source_sha256` を含む）。chain が `length` より短くなった時も無効になる。
+
+## Decision
+
+1. 位置の検証から `history_floor` の比較を外す。位置が有効なのは、その会話の chain が `length` 件以上あり、
+   先頭から `length` 件の digest が `prefix_sha256` と一致する時だけとする。`resolveObserverTurnFeed` と
+   `readObserverTurnPage`（`validateCursorCandidate`）の両方。
+2. 位置の形は変えない。`history_floor` は今までどおり入れる（発行した時点の控えの下限の番号）。
+   検証には使わない。0.15.0 以前が出した位置は、そのまま使える。
+3. snapshot の返し方、`resync_required` を終了コード 0 で返すこと、page token の作りは変えない。
+
+## Consequences
+
+- 別の古い会話の控えが落ちても、今の会話の位置は有効なままで、`append`・`delta` が返る。
+- 位置が指す会話そのものの先頭が落ちた時は、今までどおり `resync_required` になる。1 つの会話だけで
+  控えが 256 件を超えると、その会話の位置は 1 ターンごとに無効になる。これを無くすには、位置を
+  先頭からの digest ではなく控えの連番に結ぶ必要があり、位置の作りが変わるので、別に決める。
+- `history_floor` だけを書き換えた位置は、先頭からの照合が合えば受け入れる。位置は認可の鍵ではなく
+  （ADR 0003）、控えそのものと照合するので、読める範囲は変わらない。
+- ADR 0003 の「cursor below `history_floor` … returns `resync_required`」は、この ADR で置き換える。
+  「保持で失われたことを黙って隠さない」は、先頭からの照合で保つ。
+
+## 確認した範囲
+
+- `src/observer-turn-feed.test.mjs`: 古い会話の控えで上限まで埋まった project で、新しい会話のターンを
+  1 つずつ足し、毎回 `append` と、足したターンだけの `delta` が返ること。同じ会話の先頭が落ちた時は
+  `resync_required` になること。修理前のコードでは 2 件とも失敗する。

package/package.json

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

package/src/claude-auto-handoff.mjs

@@ -197,8 +197,10 @@ export function requestClaudeAutoHandoff({
   const path = recordPath(sessionId, dir);
   const existing = readClaudeAutoHandoff(sessionId, dir);
   // 有効判定は会話を起動した project で行う。hook の cwd は Bash の cd に追従する。
+  // 会話が別の project へ移っている時（Claude Desktop）は、移った先で行う。
   const projectPath = nativeProjectPath(
-    claudeHostAdapter.completionProjectPath({ cwd: payload.cwd ?? process.cwd(), env }), platform);
+    claudeHostAdapter.completionProjectPath({
+      cwd: payload.cwd ?? process.cwd(), env, transcriptPath: payload.transcript_path }), platform);
 
   if (payload.trigger !== 'auto') {
     // 人が /compact を選んだ。まだ止めていない記録は取り下げる。

package/src/claude-auto-handoff.test.mjs

@@ -63,6 +63,33 @@ function request(dir, overrides = {}) {
   return { result, db };
 }
 
+test('PreCompact: 会話が別の project へ移っている時は、移った先で有効かどうかを決める（Claude Desktop）', () => withDir(dir => {
+  // Desktop は「フォルダなし」で始めた会話を後から project へ移す。CLAUDE_PROJECT_DIR は移る前のまま届く。
+  const scratch = '/Users/kite/Library/Application Support/Claude/scratch-workspaces/a/b/scratch-2026-10-05-ac3fa8';
+  const moved = '/Users/kite/tl-claude-probe';
+  const transcriptPath = join(dir, 'moved.jsonl');
+  writeFileSync(transcriptPath, jsonl([user('読んで', '2026-10-05T22:38:17.050Z'), assistant('読みました', '2026-10-05T22:39:18.926Z'),
+    { type: 'relocated', sessionId: SESSION, relocatedCwd: moved }]));
+  const onlyMoved = { enabled: true, projects: [moved] };
+
+  const { result, db } = request(dir, { config: onlyMoved, transcriptPath, env: { CLAUDE_PROJECT_DIR: scratch }, payload: { cwd: moved } });
+  assert.equal(result.status, 'requested');
+  assert.equal(result.block, true);
+  assert.equal(result.projectPath, moved);
+  assert.equal(readClaudeAutoHandoff(SESSION, dir).project_path, moved);
+  assert.equal(db.prepare('SELECT session_id FROM handoff_batons WHERE project_path = ?').get(moved).session_id, SESSION);
+}));
+
+test('PreCompact: 移っていない会話は、これまでどおり起動した project で決める', () => withDir(dir => {
+  const transcriptPath = join(dir, 'plain.jsonl');
+  writeFileSync(transcriptPath, jsonl([user('読んで', '2026-10-05T22:38:17.050Z'), assistant('読みました', '2026-10-05T22:39:18.926Z')]));
+  const { result } = request(dir, { config: { enabled: true, projects: ['/work/app/sub'] }, transcriptPath,
+    env: { CLAUDE_PROJECT_DIR: '/work/app' }, payload: { cwd: '/work/app/sub' } });
+  assert.equal(result.status, 'skipped');
+  assert.equal(result.reason, 'auto_handoff_disabled');
+  assert.equal(result.projectPath, '/work/app');
+}));
+
 test('PreCompact: 自動圧縮で有効な時だけ、印と記録を残して圧縮を止める', () => withDir(dir => {
   const { result, db } = request(dir);
   assert.equal(result.status, 'requested');

package/src/hook-entrypoints.test.mjs

@@ -863,6 +863,57 @@ test('process-turn subprocess backfills all completed logical turns from a multi
   }
 });
 
+test('process-turn subprocess files a relocated Claude Desktop conversation under the project it moved to', () => {
+  // Desktop は「フォルダなし」で始めた会話を後から project へ移す。hook の CLAUDE_PROJECT_DIR は移る前のまま届く。
+  const home = makeTempHome();
+  const scratch = makeTempProject();
+  const moved = makeTempProject();
+  const transcriptPath = join(moved, 'transcript.jsonl');
+  const sessionId = '04bf5ab3-4b29-4b35-9b85-02a48eec51a1';
+  const entries = [
+    { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'first request' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'first answer' }] } },
+  ];
+  const stop = (lastAssistantMessage) => runNode([join(REPO_ROOT, 'src/turn-processor.mjs')], {
+    home,
+    cwd: moved,
+    env: { CLAUDE_PROJECT_DIR: scratch },
+    input: JSON.stringify({ session_id: sessionId, cwd: moved, transcript_path: transcriptPath, last_assistant_message: lastAssistantMessage }),
+  });
+  try {
+    // 移る前: SessionStart が移る前の場所で行を作り、最初の Stop も移る前の場所へ受領を書く。
+    const started = runNode([join(REPO_ROOT, 'src/session-start.mjs')], {
+      home, cwd: scratch, input: JSON.stringify({ session_id: sessionId, cwd: scratch, source: 'startup', transcript_path: transcriptPath }),
+    });
+    assert.equal(started.status, 0, started.stderr);
+    writeFileSync(transcriptPath, entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n', 'utf8');
+    assert.equal(stop('first answer').status, 0);
+    let db = openDb(home);
+    assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(sessionId).project_path, scratch);
+    db.close();
+    assert.equal(readCompletedTurnReceiptSnapshot({ projectPath: scratch, env: childEnv(home) }).receipts.length, 1);
+
+    // 移った後の Stop: sessions の project を付け替え、全ターンの受領を移った先へ出す。
+    appendFileSync(transcriptPath, [
+      { type: 'relocated', sessionId, relocatedCwd: moved },
+      { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'second request' }] } },
+      { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'second answer' }] } },
+    ].map((entry) => JSON.stringify(entry)).join('\n') + '\n', 'utf8');
+    const second = stop('second answer');
+    assert.equal(second.status, 0, second.stderr);
+    db = openDb(home);
+    assert.equal(db.prepare('SELECT project_path FROM sessions WHERE session_id = ?').get(sessionId).project_path, moved);
+    assert.equal(db.prepare('SELECT COUNT(*) AS n FROM bodies').get().n, 4);
+    db.close();
+    const receipts = readCompletedTurnReceiptSnapshot({ projectPath: moved, env: childEnv(home) });
+    assert.deepEqual(receipts.receipts.map((entry) => entry.sequence), [1, 2]);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+    rmSync(moved, { recursive: true, force: true });
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
 test('process-turn subprocess captures the completed turn when the next user entry lands right after Stop', () => {
   const home = makeTempHome();
   const project = makeTempProject();

package/src/hosts/claude.mjs

@@ -4,7 +4,8 @@
  * Claude は Throughline の基準 host。hook payload は snake_case のまま届き、
  * 引き継ぎ注入は UserPromptSubmit hook の stdout でモデルへ渡る。
  */
-import { isAbsolute } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { isAbsolute, posix, win32 } from 'node:path';
 import { CLAUDE_HOST, hostOfSessionId } from './identity.mjs';
 
 // Claude Code の背景 task 通知は user 発言として transcript に入る。識別子・出力 path・
@@ -36,6 +37,40 @@ export function compactClaudePeerMessage(text) {
   return note < 0 ? text : text.slice(0, note);
 }
 
+// Claude Desktop は「フォルダなし」で始めた会話を、後から実在の project へ移せる。移すと transcript に
+// `{"type":"relocated","relocatedCwd":"<移った先>"}` の行が入り、transcript 自体も移った先の project の
+// 置き場へ移る。hook へ渡る CLAUDE_PROJECT_DIR は、移る前の場所のまま残る（2.1.286 で実測）。
+const RELOCATED_MARKER = '"relocated"';
+
+/**
+ * 会話が最後に移った先。移っていない会話、transcript が読めない時は null。
+ * @param {string | null | undefined} transcriptPath
+ * @returns {string | null}
+ */
+export function readClaudeRelocatedCwd(transcriptPath) {
+  if (typeof transcriptPath !== 'string' || !transcriptPath) return null;
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); }
+  catch { return null; }
+  // 道具の出力が同じ文字列を含むことがある。行を JSON として読み、行そのものの type で確かめる。
+  for (let end = raw.length; end > 0;) {
+    const marker = raw.lastIndexOf(RELOCATED_MARKER, end - 1);
+    if (marker < 0) return null;
+    const lineStart = raw.lastIndexOf('\n', marker) + 1;
+    const newline = raw.indexOf('\n', marker);
+    const line = raw.slice(lineStart, newline < 0 ? raw.length : newline);
+    try {
+      const entry = JSON.parse(line);
+      const moved = entry?.type === 'relocated' ? entry.relocatedCwd : null;
+      if (typeof moved === 'string' && (posix.isAbsolute(moved) || win32.isAbsolute(moved))) return moved;
+    } catch {
+      // 書きかけの行。前の行を探す。
+    }
+    end = lineStart;
+  }
+  return null;
+}
+
 export const claudeHostAdapter = Object.freeze({
   host: CLAUDE_HOST,
   matchesSessionId: (sessionId) => hostOfSessionId(sessionId) === CLAUDE_HOST,
@@ -45,7 +80,10 @@ export const claudeHostAdapter = Object.freeze({
   // 完了受領はセッションを起動した project に書く。hook payload の cwd は Bash の cd に
   // 追従するため、作業中に下位ディレクトリへ移ると起動 project の feed から漏れる。
   // Claude Code は hook の環境変数 CLAUDE_PROJECT_DIR に起動 project を渡す。
-  completionProjectPath({ cwd, env }) {
+  // 会話が別の project へ移っている時は、移った先を使う（CLAUDE_PROJECT_DIR は移る前のまま）。
+  completionProjectPath({ cwd, env, transcriptPath }) {
+    const relocated = readClaudeRelocatedCwd(transcriptPath);
+    if (relocated) return relocated;
     const projectDir = env?.CLAUDE_PROJECT_DIR;
     return typeof projectDir === 'string' && isAbsolute(projectDir) ? projectDir : cwd;
   },

package/src/hosts/claude.test.mjs

@@ -1,6 +1,9 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { claudeHostAdapter } from './claude.mjs';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { claudeHostAdapter, readClaudeRelocatedCwd } from './claude.mjs';
 import { codexHostAdapter } from './codex.mjs';
 import { cursorHostAdapter } from './cursor.mjs';
 import { grokHostAdapter } from './grok.mjs';
@@ -18,3 +21,57 @@ test('Codex, Grok, and Cursor completion receipts keep the hook cwd', () => {
     assert.equal(adapter.completionProjectPath({ cwd: '/work/bot', env: { CLAUDE_PROJECT_DIR: '/elsewhere' } }), '/work/bot');
   }
 });
+
+function withTranscript(lines, fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-claude-host-'));
+  const transcriptPath = join(dir, 'transcript.jsonl');
+  try {
+    writeFileSync(transcriptPath, lines.join('\n'), 'utf8');
+    return fn(transcriptPath);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// Claude Desktop 2.1.286 が書く行の形（Mac で実測）。順序は2通りある。
+const relocatedLine = (cwd) => JSON.stringify({ type: 'relocated', sessionId: '04bf5ab3-4b29-4b35-9b85-02a48eec51a1', relocatedCwd: cwd });
+const userLine = (text) => JSON.stringify({ type: 'user', message: { role: 'user', content: text } });
+
+test('readClaudeRelocatedCwd: 移っていない会話と読めない transcript は null', () => {
+  assert.equal(readClaudeRelocatedCwd(null), null);
+  assert.equal(readClaudeRelocatedCwd(join(tmpdir(), 'tl-claude-host-missing', 'none.jsonl')), null);
+  withTranscript([userLine('hello'), ''], (path) => assert.equal(readClaudeRelocatedCwd(path), null));
+});
+
+test('readClaudeRelocatedCwd: 最後に移った先を返す', () => {
+  withTranscript([userLine('a'), relocatedLine('/Users/kite/first'), userLine('b'), relocatedLine('/Users/kite/tl-claude-probe'),
+    JSON.stringify({ type: 'agent-name', agentName: 'x' }), ''], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), '/Users/kite/tl-claude-probe');
+  });
+  withTranscript([relocatedLine('C:\\Users\\kite_\\proj')], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), 'C:\\Users\\kite_\\proj');
+  });
+});
+
+test('readClaudeRelocatedCwd: 道具の出力に同じ文字列があっても、行そのものの type だけを見る', () => {
+  const quoted = JSON.stringify({ type: 'user', message: { role: 'user', content: [
+    { type: 'tool_result', tool_use_id: 't1', content: relocatedLine('/quoted/in/output') }] } });
+  withTranscript([relocatedLine('/Users/kite/real'), quoted, '{"type":"relocated","relocatedCwd":"/partial'], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), '/Users/kite/real');
+  });
+  withTranscript([quoted, relocatedLine('relative/path'), JSON.stringify({ type: 'relocated' })], (path) => {
+    assert.equal(readClaudeRelocatedCwd(path), null);
+  });
+});
+
+test('Claude completion receipts follow the project the conversation moved to (Claude Desktop)', () => {
+  const scratch = '/Users/kite/Library/Application Support/Claude/scratch-workspaces/a/b/scratch-2026-10-05-ac3fa8';
+  withTranscript([userLine('a'), relocatedLine('/Users/kite/tl-claude-probe'), ''], (transcriptPath) => {
+    assert.equal(claudeHostAdapter.completionProjectPath({
+      cwd: '/Users/kite/tl-claude-probe/sub', env: { CLAUDE_PROJECT_DIR: scratch }, transcriptPath,
+    }), '/Users/kite/tl-claude-probe');
+  });
+  withTranscript([userLine('a'), ''], (transcriptPath) => {
+    assert.equal(claudeHostAdapter.completionProjectPath({ cwd: '/work/bot/sub', env: { CLAUDE_PROJECT_DIR: '/work/bot' }, transcriptPath }), '/work/bot');
+  });
+});

package/src/observer-turn-feed.mjs

@@ -47,7 +47,7 @@ export function resolveObserverTurnFeed({ projectPath, cursor = null, codexHome,
     ? emptyCandidate()
     : candidates.find((item) => item.host === prior.host && item.threadHash === prior.thread_sha256);
   if (!priorCandidate || prior.host !== null &&
-    (prior.history_floor < priorCandidate.historyFloor || prior.length > priorCandidate.chain.length ||
+    (prior.length > priorCandidate.chain.length ||
       prefixDigest(priorCandidate.chain.slice(0, prior.length)) !== prior.prefix_sha256)) {
     return { schema: OBSERVER_CURSOR_SCHEMA, status: 'resync_required', afterCursor: cursor, throughCursor: null };
   }
@@ -254,7 +254,7 @@ function decodeCursorForRead(token, projectSha256) {
 function validateCursorCandidate(cursor, candidates) {
   if (cursor.host === null) return emptyCandidate();
   const current = candidates.find((item) => item.host === cursor.host && item.threadHash === cursor.thread_sha256);
-  if (!current || cursor.history_floor < current.historyFloor || cursor.length > current.chain.length ||
+  if (!current || cursor.length > current.chain.length ||
     prefixDigest(current.chain.slice(0, cursor.length)) !== cursor.prefix_sha256) return null;
   return current;
 }

package/src/observer-turn-feed.test.mjs

@@ -126,11 +126,16 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
   try {
     const options = box.receiptOptions;
     seedCompletedTurnReceiptStore({ projectPath: box.project, receiptOptions: options, targetSessionId: 'claude-session' });
+    const full = resolveObserverTurnFeed({ projectPath: box.project, receiptOptions: options, codexHome: box.home });
     writeCompletedTurnReceipt({ projectPath: box.project, targetSessionId: 'claude-session', originSessionId: 'o257', userBody: 'user-body-257', assistantBody: 'assistant-body-257', completedAt: 257 }, options);
+    // 同じ会話の先頭の控えが落ちた時は、先頭からの照合が合わなくなるので resync（ADR 0035）
+    assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: full.throughCursor, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
     const latest = resolveObserverTurnFeed({ projectPath: box.project, receiptOptions: options, codexHome: box.home });
     const decoded = decodeObserverCursor(latest.throughCursor);
-    const beforeFloor = encodeObserverCursor({ ...decoded, history_floor: 1 });
-    assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: beforeFloor, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
+    assert.equal(decoded.history_floor, 2);
+    // 下限の番号は位置に入れたままだが、検証には使わない。先頭からの照合が合えば有効
+    const olderFloor = encodeObserverCursor({ ...decoded, history_floor: 1 });
+    assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: olderFloor, receiptOptions: options, codexHome: box.home }).status, 'unchanged');
     assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: `${latest.throughCursor}x`, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
     const oldVersion = `tlc1.${Buffer.from(JSON.stringify({ ...decoded, schema: 'throughline.observer_cursor.v0' })).toString('base64url')}`;
     assert.equal(resolveObserverTurnFeed({ projectPath: box.project, cursor: oldVersion, receiptOptions: options, codexHome: box.home }).status, 'resync_required');
@@ -157,6 +162,51 @@ test('observer feed: Claude history floor, host/thread switch, cross-host tie, a
   } finally { rmSync(box.root, { recursive: true, force: true }); }
 });
 
+test('observer feed: 控えが上限に達して別の古い会話の控えが落ちても、今の会話の位置は有効なまま', () => {
+  const box = fixture();
+  const dbPath = join(box.root, 'throughline.db');
+  let db;
+  try {
+    // 古い会話の控えで上限まで埋まっている席で、新しい会話が始まる
+    seedCompletedTurnReceiptStore({ projectPath: box.project, receiptOptions: box.receiptOptions, targetSessionId: 'old-session' });
+    db = createProjectionDb(dbPath, box.project, 'live-session');
+    const read = (afterCursor) => readObserverTurnPage({
+      projectPath: box.project, afterCursor, codexHome: box.home, receiptOptions: box.receiptOptions, dbPath,
+    });
+    const floorOf = (cursor) => decodeObserverCursor(cursor).history_floor;
+
+    addClaudeTurn(box, db, { sessionId: 'live-session', origin: 'live-1', turn: 1, user: 'user-1', assistant: 'assistant-1', at: 1001 });
+    let cursor = read(null).throughCursor;
+    assert.equal(floorOf(cursor), 2);
+    for (let turn = 2; turn <= 5; turn++) {
+      // 1 ターンごとに古い会話の控えが1件落ち、控え全体の下限が1上がる
+      addClaudeTurn(box, db, { sessionId: 'live-session', origin: `live-${turn}`, turn, user: `user-${turn}`, assistant: `assistant-${turn}`, at: 1000 + turn });
+      assert.equal(resolveObserverTurnFeed({
+        projectPath: box.project, cursor, codexHome: box.home, receiptOptions: box.receiptOptions,
+      }).status, 'append');
+      const page = read(cursor);
+      assert.equal(page.status, 'delta');
+      assert.deepEqual(page.turns.map((item) => item.user), [`user-${turn}`]);
+      assert.equal(page.page.complete, true);
+      assert.equal(floorOf(page.throughCursor), turn + 1);
+      cursor = page.throughCursor;
+    }
+    // 追いついた位置は、次のターンが来るまで unchanged
+    assert.equal(resolveObserverTurnFeed({
+      projectPath: box.project, cursor, codexHome: box.home, receiptOptions: box.receiptOptions,
+    }).status, 'unchanged');
+    // 読み遅れた位置（2 ターン前）からも、残りを続きとして読める
+    addClaudeTurn(box, db, { sessionId: 'live-session', origin: 'live-6', turn: 6, user: 'user-6', assistant: 'assistant-6', at: 1006 });
+    addClaudeTurn(box, db, { sessionId: 'live-session', origin: 'live-7', turn: 7, user: 'user-7', assistant: 'assistant-7', at: 1007 });
+    const late = read(cursor);
+    assert.equal(late.status, 'delta');
+    assert.deepEqual(late.turns.map((item) => item.user), ['user-6', 'user-7']);
+  } finally {
+    db?.close();
+    rmSync(box.root, { recursive: true, force: true });
+  }
+});
+
 test('observer feed: Codex pair hashes reuse DB capture role aggregation', () => {
   const box = fixture();
   try {

package/src/turn-processor.mjs

@@ -49,6 +49,8 @@ import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
 import { logHookFailure } from './hook-failure-log.mjs';
 import { writeCompletedTurnReceipt } from './completed-turn-receipts.mjs';
 import { hostAdapterForSessionId, parseHookPayload } from './hosts/index.mjs';
+import { readClaudeRelocatedCwd } from './hosts/claude.mjs';
+import { CLAUDE_HOST } from './hosts/identity.mjs';
 import { completeClaudeTurnWithoutHandoff } from './claude-auto-handoff.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
@@ -316,6 +318,20 @@ async function processStop() {
     db.prepare('UPDATE sessions SET updated_at = ? WHERE session_id = ?').run(now, target);
   }
 
+  // 完了受領と sessions の project は、会話を起動した project に合わせる。会話が別の project へ
+  // 移っている時（Claude Desktop）は、移った先へ付け替える。付け替えないと、移った先の project の
+  // 過去の会話にも Observer feed にも、この会話が出ない。
+  const hostAdapter = hostAdapterForSessionId(session_id);
+  const relocatedProjectPath = hostAdapter.host === CLAUDE_HOST ? readClaudeRelocatedCwd(transcript_path) : null;
+  const completionProjectPath = relocatedProjectPath ?? hostAdapter.completionProjectPath({
+    cwd: cwd ?? process.cwd(),
+    env: process.env,
+  });
+  if (relocatedProjectPath) {
+    db.prepare('UPDATE sessions SET project_path = ? WHERE session_id IN (?, ?) AND project_path <> ?')
+      .run(relocatedProjectPath, session_id, target, relocatedProjectPath);
+  }
+
   // L2 = transcript 全体を論理ターン群で走査し、未捕捉の完了ターンを一括回収する。
   // 従来の「最後の 1 ペアのみ保存」は Stop の空振り・不発が永久穴になった (docs/12 B-1)。
   // user / assistant は「1 往復 = 1 ターン」として同じ turn_number（= 代表 assistant
@@ -349,10 +365,6 @@ async function processStop() {
   // 過去のStopでDBだけ回収済みだったpairもreceipt storeの冪等性で穴埋めする。
   // receipt failure は Stop hook の failure として上位へ伝播させる。L1/L3/usage は
   // receipt 後の派生処理なので、そこで失敗しても completed pair を取り消さない。
-  const completionProjectPath = hostAdapterForSessionId(session_id).completionProjectPath({
-    cwd: cwd ?? process.cwd(),
-    env: process.env,
-  });
   for (const completedTurnNumber of backfill.turnNumbers) {
     publishCapturedClaudeCompletionReceipt(db, {
       target,