throughline 0.6.3 → 0.8.0

package/src/turn-backfill.mjs

@@ -59,12 +59,12 @@ export function deriveTranscriptPath(projectPath, sessionId) {
  * @param {string} opts.originSessionId transcript を所有する origin session_id
  * @param {string|null|undefined} opts.transcriptPath
  * @param {number} opts.now timestamp 欠損時の fallback epoch ms
- * @returns {{groups: number, insertedTurns: number, skippedExisting: number, lastTurnNumber: number|null}}
+ * @returns {{groups: number, insertedTurns: number, skippedExisting: number, lastTurnNumber: number|null, turnNumbers: number[]}}
  */
 export function backfillBodies(db, { targetSessionId, originSessionId, transcriptPath, now }) {
   const groups = getLogicalTurnGroups(transcriptPath);
   if (groups.length === 0) {
-    return { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null };
+    return { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null, turnNumbers: [] };
   }
 
   const existing = new Set(
@@ -127,5 +127,6 @@ export function backfillBodies(db, { targetSessionId, originSessionId, transcrip
     insertedTurns,
     skippedExisting,
     lastTurnNumber: groups[groups.length - 1].representative.index,
+    turnNumbers: groups.map((group) => group.representative.index),
   };
 }

package/src/turn-backfill.test.mjs

@@ -58,7 +58,13 @@ test('backfillBodies: multi-fragment group uses last fragment index for both bod
       const result = backfillBodies(db, {
         targetSessionId: 'target', originSessionId: 'origin', transcriptPath: path, now: 999,
       });
-      assert.deepEqual(result, { groups: 2, insertedTurns: 2, skippedExisting: 0, lastTurnNumber: 4 });
+      assert.deepEqual(result, {
+        groups: 2,
+        insertedTurns: 2,
+        skippedExisting: 0,
+        lastTurnNumber: 4,
+        turnNumbers: [2, 4],
+      });
       assert.deepEqual(
         db.prepare('SELECT turn_number, role, text FROM bodies ORDER BY turn_number, role').all().map((row) => ({ ...row })),
         [
@@ -103,7 +109,7 @@ test('backfillBodies: user-only group is dropped', () => {
       backfillBodies(db, {
         targetSessionId: 'target', originSessionId: 'origin', transcriptPath: path, now: 999,
       }),
-      { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null },
+      { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null, turnNumbers: [] },
     );
   });
 });
@@ -193,13 +199,13 @@ test('backfillBodies: sidechain entries and missing or empty paths produce no gr
         backfillBodies(db, {
           targetSessionId: 'target', originSessionId: 'origin', transcriptPath: null, now: 999,
         }),
-        { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null },
+        { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null, turnNumbers: [] },
       );
       assert.deepEqual(
         backfillBodies(db, {
           targetSessionId: 'target', originSessionId: 'origin', transcriptPath: '', now: 999,
         }),
-        { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null },
+        { groups: 0, insertedTurns: 0, skippedExisting: 0, lastTurnNumber: null, turnNumbers: [] },
       );
     },
   );

package/src/turn-processor.mjs

@@ -33,6 +33,7 @@
 import { getDb } from './db.mjs';
 import {
   readRawEntries,
+  readLatestLogicalTurnCompletion,
   sliceCurrentTurnEntries,
   extractDetailBlocks,
 } from './transcript-reader.mjs';
@@ -44,9 +45,48 @@ import { ensureMonitorTaskFile } from './vscode-task.mjs';
 import { readLatestUsage } from './transcript-usage.mjs';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
+import { writeCompletedTurnReceipt } from './completed-turn-receipts.mjs';
 
 /** 直近 N ターンは bodies を生で残し、それより古いものだけ L1 要約する。 */
 export const L2_WINDOW = 20;
+export const CLAUDE_STOP_TRANSCRIPT_FLUSH_TIMEOUT_MS = 2_000;
+export const CLAUDE_STOP_TRANSCRIPT_FLUSH_INTERVAL_MS = 25;
+
+const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+/**
+ * Claude Stop payloadのassistant identityがlatest user groupへ永続化されるまで待つ。
+ * markerは本文ソースにせず、transcript可視化のbarrierにだけ使う。
+ */
+export async function waitForClaudeStopTranscriptFlush({
+  transcriptPath,
+  lastAssistantMessage,
+  timeoutMs = CLAUDE_STOP_TRANSCRIPT_FLUSH_TIMEOUT_MS,
+  intervalMs = CLAUDE_STOP_TRANSCRIPT_FLUSH_INTERVAL_MS,
+  readCompletion = readLatestLogicalTurnCompletion,
+  now = Date.now,
+  wait = delay,
+}) {
+  if (typeof lastAssistantMessage !== 'string' || lastAssistantMessage.length === 0) {
+    return { status: 'marker_unavailable' };
+  }
+  const deadline = now() + timeoutMs;
+  for (;;) {
+    const completion = readCompletion(transcriptPath);
+    if (completion?.assistantContent === lastAssistantMessage) {
+      return {
+        status: 'ready',
+        userTurnNumber: completion.userTurnNumber,
+        assistantTurnNumber: completion.assistantTurnNumber,
+      };
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) {
+      throw new Error('Claude Stop transcript completion was not visible before deadline');
+    }
+    await wait(Math.min(intervalMs, remaining));
+  }
+}
 
 /**
  * target 配下の distinct (origin_session_id, turn_number) ターン数を返す。
@@ -93,6 +133,36 @@ export function pickOldestUnsummarizedTurn(db, target) {
   return row ?? null;
 }
 
+/**
+ * L2 commit 済みの completed pair だけを Claude receipt store へ publish する。
+ * L1/L3 より前に呼び、receipt の失敗は呼び出し元へそのまま伝える。
+ */
+export function publishCapturedClaudeCompletionReceipt(db, {
+  target,
+  origin,
+  turnNumber,
+  projectPath,
+  receiptOptions,
+}) {
+  const completedPair = db.prepare(
+    `SELECT role, text, created_at FROM bodies
+     WHERE session_id = ? AND origin_session_id = ? AND turn_number = ? AND role IN ('user', 'assistant')`,
+  ).all(target, origin, turnNumber);
+  const completedUser = completedPair.find((row) => row.role === 'user');
+  const completedAssistant = completedPair.find((row) => row.role === 'assistant');
+  if (!completedUser || !completedAssistant) {
+    throw new Error('completed pair was not captured before receipt publication');
+  }
+  return writeCompletedTurnReceipt({
+    projectPath,
+    targetSessionId: target,
+    originSessionId: origin,
+    userBody: completedUser.text,
+    assistantBody: completedAssistant.text,
+    completedAt: completedAssistant.created_at,
+  }, receiptOptions);
+}
+
 /**
  * user と assistant のペアを結合して L2 要約用テキストを作る。
  * @param {{content: string} | null} userTurn
@@ -121,7 +191,7 @@ export async function run() {
   });
 
   const payload = JSON.parse(raw || '{}');
-  const { session_id, transcript_path, cwd } = payload;
+  const { session_id, transcript_path, cwd, last_assistant_message } = payload;
   if (!session_id) throw new Error('Missing session_id in Stop payload');
 
   // VSCode で開かれたプロジェクトに .vscode/tasks.json を自動プロビジョニングする。
@@ -134,6 +204,11 @@ export async function run() {
     process.stderr.write(`[vscode-task] ${msg}\n`);
   }
 
+  await waitForClaudeStopTranscriptFlush({
+    transcriptPath: transcript_path,
+    lastAssistantMessage: last_assistant_message,
+  });
+
   // Stop hook 時点で state ファイルを更新 → token-monitor の「アクティブ行」判定が
   // アシスタント応答終了時刻まで追従する
   writeSessionState({
@@ -190,6 +265,20 @@ export async function run() {
 
   const turnNumber = backfill.lastTurnNumber;
 
+  // Claude Stop hook が completion boundary であることを受け、L2 の user/assistant
+  // pair が DB に commit 済みであることを確認してから全logical turnのreceiptを時系列publishする。
+  // 過去のStopでDBだけ回収済みだったpairもreceipt storeの冪等性で穴埋めする。
+  // receipt failure は Stop hook の failure として上位へ伝播させる。L1/L3/usage は
+  // receipt 後の派生処理なので、そこで失敗しても completed pair を取り消さない。
+  for (const completedTurnNumber of backfill.turnNumbers) {
+    publishCapturedClaudeCompletionReceipt(db, {
+      target,
+      origin,
+      turnNumber: completedTurnNumber,
+      projectPath: cwd ?? process.cwd(),
+    });
+  }
+
   // L1 = 遅延要約。target 配下の bodies ターン数 (distinct origin×turn) が
   // WINDOW を超えていたら、最古の未要約ターンを 1 件だけ要約する。
   // 20 ターン以内で終わる作業では Haiku コストゼロ。

package/src/turn-processor.test.mjs

@@ -1,10 +1,17 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { DatabaseSync } from 'node:sqlite';
+import { appendFileSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import {
   L2_WINDOW,
+  CLAUDE_STOP_TRANSCRIPT_FLUSH_INTERVAL_MS,
+  CLAUDE_STOP_TRANSCRIPT_FLUSH_TIMEOUT_MS,
   countDistinctBodyTurns,
   pickOldestUnsummarizedTurn,
+  publishCapturedClaudeCompletionReceipt,
+  waitForClaudeStopTranscriptFlush,
 } from './turn-processor.mjs';
 
 function makeDb() {
@@ -54,6 +61,141 @@ test('L2_WINDOW is 20', () => {
   assert.equal(L2_WINDOW, 20);
 });
 
+test('Claude Stop flush barrierはlatest userの遅延assistantを待ち、過去の同文answerを採用しない', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'throughline-stop-flush-'));
+  const transcriptPath = join(root, 'transcript.jsonl');
+  const answer = 'same answer';
+  let elapsed = 0;
+  let waits = 0;
+  try {
+    writeFileSync(
+      transcriptPath,
+      [
+        { type: 'user', message: { role: 'user', content: 'old question' } },
+        { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: answer }] } },
+        { type: 'user', message: { role: 'user', content: 'current question' } },
+      ].map((entry) => JSON.stringify(entry)).join('\n'),
+      'utf8',
+    );
+    const result = await waitForClaudeStopTranscriptFlush({
+      transcriptPath,
+      lastAssistantMessage: answer,
+      timeoutMs: 100,
+      intervalMs: 10,
+      now: () => elapsed,
+      wait: async (milliseconds) => {
+        elapsed += milliseconds;
+        waits++;
+        if (waits === 1) {
+          appendFileSync(
+            transcriptPath,
+            `\n${JSON.stringify({
+              type: 'assistant',
+              message: { role: 'assistant', content: [{ type: 'text', text: answer }] },
+            })}`,
+            'utf8',
+          );
+        }
+      },
+    });
+    assert.deepEqual(result, { status: 'ready', userTurnNumber: 2, assistantTurnNumber: 3 });
+    assert.equal(waits, 1, 'past identical answer must not satisfy the current user group');
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('Claude Stop flush barrierはmarker不一致をdeadlineで明示失敗する', async () => {
+  let elapsed = 0;
+  await assert.rejects(
+    waitForClaudeStopTranscriptFlush({
+      transcriptPath: '/missing',
+      lastAssistantMessage: 'expected',
+      timeoutMs: 30,
+      intervalMs: 10,
+      readCompletion: () => ({ userTurnNumber: 4, assistantTurnNumber: null, assistantContent: null }),
+      now: () => elapsed,
+      wait: async (milliseconds) => { elapsed += milliseconds; },
+    }),
+    /not visible before deadline/,
+  );
+  assert.equal(elapsed, 30);
+});
+
+test('Claude Stop flush barrierはmarkerなし旧payloadをone-shot互換へ残す', async () => {
+  let reads = 0;
+  const result = await waitForClaudeStopTranscriptFlush({
+    transcriptPath: '/unused',
+    lastAssistantMessage: undefined,
+    readCompletion: () => { reads++; return null; },
+  });
+  assert.deepEqual(result, { status: 'marker_unavailable' });
+  assert.equal(reads, 0);
+  assert.equal(CLAUDE_STOP_TRANSCRIPT_FLUSH_TIMEOUT_MS, 2_000);
+  assert.equal(CLAUDE_STOP_TRANSCRIPT_FLUSH_INTERVAL_MS, 25);
+});
+
+test('publishCapturedClaudeCompletionReceipt: L2 capture済みpairをL1/L3より先にprivate receiptへ固定する', () => {
+  const db = makeDb();
+  const root = mkdtempSync(join(tmpdir(), 'throughline-turn-receipt-'));
+  const storePath = join(root, 'state', 'completed-turn-receipts.json');
+  try {
+    insertTurn(db, { session: 'target', origin: 'origin', turn: 7, createdAt: 1234 });
+    db.prepare(
+      `UPDATE bodies SET text = CASE role WHEN 'user' THEN ' request\r\n' ELSE 'answer' END
+       WHERE session_id = 'target' AND origin_session_id = 'origin' AND turn_number = 7`,
+    ).run();
+    const first = publishCapturedClaudeCompletionReceipt(db, {
+      target: 'target', origin: 'origin', turnNumber: 7, projectPath: '/repo',
+      receiptOptions: { storePath },
+    });
+    const second = publishCapturedClaudeCompletionReceipt(db, {
+      target: 'target', origin: 'origin', turnNumber: 7, projectPath: '/repo',
+      receiptOptions: { storePath },
+    });
+    assert.equal(first.sequence, 1);
+    assert.deepEqual(second, first, 'Stop retry must return the original receipt');
+    assert.equal(first.completed_at, 1234);
+    if (process.platform !== 'win32') {
+      // POSIX permission 契約 (0700/0600) の表現形式検査。Windows の秘匿は stat mode
+      // ではなく owner-only ACL で担保され、writeCompletedTurnReceipt 内部の
+      // applyAndVerifyWindowsAcl が書き込みのたびに apply + verify して失敗を throw
+      // するため、win32 ではこのテストが receipt を作れた時点で ACL 検証済み。
+      assert.equal(statSync(join(root, 'state')).mode & 0o777, 0o700);
+      assert.equal(statSync(storePath).mode & 0o777, 0o600);
+    }
+    const bytes = readFileSync(storePath, 'utf8');
+    assert.doesNotMatch(bytes, /request|answer|\/repo/);
+    assert.match(bytes, /"host":"claude"/);
+  } finally {
+    db.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('publishCapturedClaudeCompletionReceipt: incomplete DB pairはreceiptを作らず失敗する', () => {
+  const db = makeDb();
+  const root = mkdtempSync(join(tmpdir(), 'throughline-turn-receipt-'));
+  const storePath = join(root, 'state', 'completed-turn-receipts.json');
+  try {
+    db.prepare(
+      `INSERT INTO bodies (session_id, origin_session_id, turn_number, role, text, token_count, created_at)
+       VALUES ('target', 'origin', 8, 'user', 'only user', 1, 1)`,
+    ).run();
+    assert.throws(
+      () => publishCapturedClaudeCompletionReceipt(db, {
+        target: 'target', origin: 'origin', turnNumber: 8, projectPath: '/repo',
+        receiptOptions: { storePath },
+      }),
+      /completed pair was not captured/,
+    );
+    assert.throws(() => statSync(storePath), { code: 'ENOENT' });
+  } finally {
+    db.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('countDistinctBodyTurns: 2 ロール行 = 1 ターンとして数える', () => {
   const db = makeDb();
   insertTurn(db, { session: 'S', origin: 'S', turn: 1, createdAt: 100 });

package/src/windows-acl-test-helper.mjs

@@ -17,7 +17,7 @@ if($isDir){[System.IO.Directory]::SetAccessControl($target,$acl)}else{[System.IO
     '-NoProfile', '-NonInteractive', '-Command', script,
   ], {
     encoding: 'utf8',
-    timeout: 3_000,
+    timeout: 15_000,
     windowsHide: true,
     env: {
       ...process.env,
@@ -46,7 +46,7 @@ if($rule.IdentityReference.Value -ne $sid -or $rule.AccessControlType -ne 'Allow
     '-NoProfile', '-NonInteractive', '-Command', script,
   ], {
     encoding: 'utf8',
-    timeout: 3_000,
+    timeout: 15_000,
     windowsHide: true,
     env: {
       ...process.env,