throughline 0.4.8 → 0.4.10

package/src/cli/doctor.mjs

@@ -397,6 +397,89 @@ function countCapturedCodexSessions(db, projectPath) {
   }
 }
 
+function parseCodexTrustedHookState(configText) {
+  const trustedKeys = new Set();
+  let currentKey = null;
+  let currentTrusted = false;
+
+  function flush() {
+    if (currentKey && currentTrusted) trustedKeys.add(currentKey);
+  }
+
+  for (const line of configText.split(/\r?\n/)) {
+    const section = line.match(/^\s*\[hooks\.state\."([^"]+)"\]\s*$/);
+    if (section) {
+      flush();
+      currentKey = section[1];
+      currentTrusted = false;
+      continue;
+    }
+    if (!currentKey) continue;
+    if (/^\s*\[/.test(line)) {
+      flush();
+      currentKey = null;
+      currentTrusted = false;
+      continue;
+    }
+    if (/^\s*trusted_hash\s*=\s*"sha256:[^"]+"\s*$/.test(line)) {
+      currentTrusted = true;
+    }
+  }
+  flush();
+  return trustedKeys;
+}
+
+function listHooksWithTrust(parsed, eventName, eventKey, hooksPath, trustedStateKeys) {
+  const groups = parsed.hooks?.[eventName] ?? [];
+  return groups.flatMap((group, groupIndex) =>
+    (group.hooks ?? []).map((hook, hookIndex) => {
+      const trustKey = `${hooksPath}:${eventKey}:${groupIndex}:${hookIndex}`;
+      return {
+        ...hook,
+        throughlineDoctorTrustKey: trustKey,
+        throughlineDoctorTrusted: trustedStateKeys.has(trustKey),
+      };
+    }),
+  );
+}
+
+function summarizeHookTrust(hooks, { hooksFeatureEnabled, codexHooksFeatureEnabled } = {}) {
+  if (hooks.length === 0) {
+    return {
+      status: 'no managed hooks',
+      trustedCount: 0,
+      totalCount: 0,
+    };
+  }
+  const trustedCount = hooks.filter(h => h.throughlineDoctorTrusted).length;
+  if (trustedCount === hooks.length) {
+    return {
+      status: 'trusted',
+      trustedCount,
+      totalCount: hooks.length,
+    };
+  }
+  if (hooksFeatureEnabled) {
+    return {
+      status: `${trustedCount}/${hooks.length} trusted - accept hooks in Codex menu`,
+      trustedCount,
+      totalCount: hooks.length,
+    };
+  }
+  if (codexHooksFeatureEnabled) {
+    return {
+      status: 'not recorded (legacy codex_hooks)',
+      trustedCount,
+      totalCount: hooks.length,
+    };
+  }
+  return {
+    status: 'not trusted',
+    trustedCount,
+    totalCount: hooks.length,
+  };
+}
+
 function readCodexHookDiagnosis(codexHome) {
   const hooksPath = join(codexHome, 'hooks.json');
   const configPath = join(codexHome, 'config.toml');
@@ -413,6 +496,12 @@ function readCodexHookDiagnosis(codexHome) {
     featureEnabled: false,
     codexHooksFeatureEnabled: false,
     hooksFeatureEnabled: false,
+    trustedStateKeys: new Set(),
+    managedHookTrust: {
+      status: 'no managed hooks',
+      trustedCount: 0,
+      totalCount: 0,
+    },
     managedPromptHooks: [],
     legacyManagedPromptHooks: [],
     managedPostToolUseHooks: [],
@@ -427,6 +516,7 @@ function readCodexHookDiagnosis(codexHome) {
       out.codexHooksFeatureEnabled = /^\s*codex_hooks\s*=\s*true\s*$/m.test(config);
       out.hooksFeatureEnabled = /^\s*hooks\s*=\s*true\s*$/m.test(config);
       out.featureEnabled = out.codexHooksFeatureEnabled || out.hooksFeatureEnabled;
+      out.trustedStateKeys = parseCodexTrustedHookState(config);
     } catch {
       out.featureEnabled = false;
     }
@@ -441,9 +531,21 @@ function readCodexHookDiagnosis(codexHome) {
   }
 
   out.hooksReadable = true;
-  const promptHooks = (parsed.hooks?.UserPromptSubmit ?? []).flatMap(group => group.hooks ?? []);
-  const postToolUseHooks = (parsed.hooks?.PostToolUse ?? []).flatMap(group => group.hooks ?? []);
-  const stopHooks = (parsed.hooks?.Stop ?? []).flatMap(group => group.hooks ?? []);
+  const promptHooks = listHooksWithTrust(
+    parsed,
+    'UserPromptSubmit',
+    'user_prompt_submit',
+    hooksPath,
+    out.trustedStateKeys,
+  );
+  const postToolUseHooks = listHooksWithTrust(
+    parsed,
+    'PostToolUse',
+    'post_tool_use',
+    hooksPath,
+    out.trustedStateKeys,
+  );
+  const stopHooks = listHooksWithTrust(parsed, 'Stop', 'stop', hooksPath, out.trustedStateKeys);
   out.managedPromptHooks = promptHooks.filter(h => isThroughlineCodexHookCommand(h.command));
   out.legacyManagedPromptHooks = out.managedPromptHooks.filter(h => h.command !== expectedPromptCommand);
   out.managedPostToolUseHooks = postToolUseHooks.filter(h => isThroughlineCodexPostToolUseCommand(h.command));
@@ -452,6 +554,14 @@ function readCodexHookDiagnosis(codexHome) {
   );
   out.managedStopHooks = stopHooks.filter(h => isThroughlineCodexStopCommand(h.command));
   out.legacyManagedStopHooks = out.managedStopHooks.filter(h => h.command !== expectedStopCommand);
+  out.managedHookTrust = summarizeHookTrust(
+    [
+      ...out.managedPromptHooks,
+      ...out.managedPostToolUseHooks,
+      ...out.managedStopHooks,
+    ],
+    out,
+  );
   return out;
 }
 
@@ -484,6 +594,7 @@ function runCodexDiagnosis({
   console.log(`  project:               ${cwd}`);
   console.log(`  CODEX_HOME:            ${codexHome}`);
   console.log(`  Codex hooks feature:   ${hookDiagnosis.featureEnabled ? 'enabled' : 'not enabled'}`);
+  console.log(`  Codex hook trust:      ${hookDiagnosis.managedHookTrust.status}`);
   console.log(`  Codex UserPrompt hook: ${
     hookDiagnosis.managedPromptHooks.length === 0
       ? 'not registered'
@@ -496,6 +607,7 @@ function runCodexDiagnosis({
     console.log(`    command:             ${h.command}`);
     console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
     console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
   }
   console.log(`  Codex PostTool hook:   ${
     hookDiagnosis.managedPostToolUseHooks.length === 0
@@ -509,6 +621,7 @@ function runCodexDiagnosis({
     console.log(`    command:             ${h.command}`);
     console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
     console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
   }
   console.log(`  Codex Stop hook:       ${
     hookDiagnosis.managedStopHooks.length === 0
@@ -522,6 +635,7 @@ function runCodexDiagnosis({
     console.log(`    command:             ${h.command}`);
     console.log(`    async:               ${h.async === false ? 'false' : String(h.async)}`);
     console.log(`    timeoutSec:          ${h.timeoutSec ?? '(default)'}`);
+    console.log(`    trusted:             ${h.throughlineDoctorTrusted ? 'yes' : 'no'}`);
   }
   console.log(`  VSCode monitor task:   ${monitorTaskDiagnosis.status}`);
   if (monitorTaskDiagnosis.path) {

package/src/cli/doctor.test.mjs

@@ -381,17 +381,41 @@ test('readCodexHookDiagnosis detects Codex prompt and Stop hooks', () => {
         2,
       ) + '\n',
     );
-    writeFileSync(join(codexHome, 'config.toml'), '[features]\ncodex_hooks = true\nhooks = true\n');
+    const hooksPath = join(codexHome, 'hooks.json');
+    writeFileSync(
+      join(codexHome, 'config.toml'),
+      [
+        '[features]',
+        'codex_hooks = true',
+        'hooks = true',
+        '',
+        `[hooks.state."${hooksPath}:user_prompt_submit:0:0"]`,
+        'trusted_hash = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"',
+        '',
+        `[hooks.state."${hooksPath}:post_tool_use:0:0"]`,
+        'trusted_hash = "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"',
+        '',
+        `[hooks.state."${hooksPath}:stop:0:0"]`,
+        'trusted_hash = "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"',
+        '',
+      ].join('\n'),
+    );
 
     const diagnosis = readCodexHookDiagnosis(codexHome);
     assert.equal(diagnosis.featureEnabled, true);
     assert.equal(diagnosis.codexHooksFeatureEnabled, true);
     assert.equal(diagnosis.hooksFeatureEnabled, true);
+    assert.equal(diagnosis.managedHookTrust.status, 'trusted');
+    assert.equal(diagnosis.managedHookTrust.trustedCount, 3);
+    assert.equal(diagnosis.managedHookTrust.totalCount, 3);
     assert.equal(diagnosis.managedPromptHooks.length, 1);
+    assert.equal(diagnosis.managedPromptHooks[0].throughlineDoctorTrusted, true);
     assert.equal(diagnosis.legacyManagedPromptHooks.length, 1);
     assert.equal(diagnosis.managedPostToolUseHooks.length, 1);
+    assert.equal(diagnosis.managedPostToolUseHooks[0].throughlineDoctorTrusted, true);
     assert.equal(diagnosis.legacyManagedPostToolUseHooks.length, 1);
     assert.equal(diagnosis.managedStopHooks.length, 1);
+    assert.equal(diagnosis.managedStopHooks[0].throughlineDoctorTrusted, true);
     assert.equal(diagnosis.legacyManagedStopHooks.length, 1);
   } finally {
     rmSync(codexHome, { recursive: true, force: true });

package/src/cli/install.mjs

@@ -490,8 +490,8 @@ export async function run(args = []) {
   console.log('  Stop             → throughline process-turn   (L1 要約 + L2 本文保存 + L3 詳細保存)');
   console.log('  UserPromptSubmit → throughline prompt-submit  (/tl & /clear バトン書き込み)');
   if (codex) {
-    console.log(`  Codex UserPromptSubmit → ${buildCodexUserPromptSubmitHookCommand()} (80% 到達時に current session へ $throughline 指示を注入)`);
-    console.log(`  Codex PostToolUse      → ${buildCodexPostToolUseHookCommand()} (tool loop 中も 80% 到達時に $throughline 指示を注入)`);
+    console.log(`  Codex UserPromptSubmit → ${buildCodexUserPromptSubmitHookCommand()} (75% 到達時に current session へ $throughline 指示を注入)`);
+    console.log(`  Codex PostToolUse      → ${buildCodexPostToolUseHookCommand()} (tool loop 中も 75% 到達時に $throughline 指示を注入)`);
     console.log(`  Codex Stop             → ${buildCodexStopHookCommand()} (Codex rollout capture + L1 要約)`);
   }
   console.log('');

package/src/cli/trim.mjs

@@ -366,15 +366,6 @@ async function runPreflight(parsed, plan) {
     expectedTurns: expectedCodexAppServerTurns(plan),
     command,
   });
-  const turnCountStatus = preflight.turnCountCheck?.status;
-  if (turnCountStatus === 'mismatch' || turnCountStatus === 'unknown') {
-    return {
-      status: 'preflight-refused',
-      reason: preflight.turnCountCheck.reason,
-      plan,
-      preflight,
-    };
-  }
 
   return {
     status: 'preflight-ready',

package/src/codex-app-server.mjs

@@ -209,6 +209,48 @@ export function buildThreadRollbackRequest({ id, threadId, numTurns }) {
   };
 }
 
+export function resolveRollbackTurnsForAppServer({
+  plannedRollbackTurns,
+  expectedTurns = null,
+  readTurns = null,
+  resumedTurns = null,
+} = {}) {
+  if (!Number.isInteger(plannedRollbackTurns) || plannedRollbackTurns < 1) {
+    throw new Error('resolveRollbackTurnsForAppServer: plannedRollbackTurns must be an integer >= 1');
+  }
+  assertOptionalTurnCount(expectedTurns, 'resolveRollbackTurnsForAppServer: expectedTurns');
+
+  const result = {
+    plannedRollbackTurns,
+    requestedRollbackTurns: plannedRollbackTurns,
+    adjustment: 0,
+    basis: 'planned',
+    reason: 'using_planned_rollback_turns',
+  };
+
+  if (
+    Number.isInteger(expectedTurns) &&
+    Number.isInteger(readTurns) &&
+    Number.isInteger(resumedTurns) &&
+    readTurns === resumedTurns &&
+    readTurns !== expectedTurns
+  ) {
+    const adjustment = readTurns - expectedTurns;
+    const adjustedTurns = plannedRollbackTurns + adjustment;
+    if (adjustedTurns >= 1) {
+      return {
+        plannedRollbackTurns,
+        requestedRollbackTurns: Math.min(adjustedTurns, readTurns),
+        adjustment,
+        basis: 'app_server_turn_count',
+        reason: 'adjusted_by_app_server_turn_delta',
+      };
+    }
+  }
+
+  return result;
+}
+
 export function buildThreadInjectItemsRequest({ id, threadId, items }) {
   assertRequestId(id, 'buildThreadInjectItemsRequest');
   assertNonEmptyString(threadId, 'buildThreadInjectItemsRequest: threadId');
@@ -313,6 +355,12 @@ export async function runCodexTrimPreflight({
     );
     const readTurns = countTurns(beforeRead);
     const resumedTurns = countTurns(resumed);
+    const rollbackResolution = resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: rollbackTurns,
+      expectedTurns,
+      readTurns,
+      resumedTurns,
+    });
 
     return {
       status: 'preflight-ready',
@@ -321,6 +369,8 @@ export async function runCodexTrimPreflight({
       injectSent: false,
       readTurns,
       resumedTurns,
+      rollbackRequestedTurns: rollbackResolution.requestedRollbackTurns,
+      rollbackResolution,
       turnCountCheck: compareTurnCounts({
         expectedTurns,
         readTurns,
@@ -329,7 +379,7 @@ export async function runCodexTrimPreflight({
       rollbackRequestPreview: buildThreadRollbackRequest({
         id: 'rollback-preview',
         threadId,
-        numTurns: rollbackTurns,
+        numTurns: rollbackResolution.requestedRollbackTurns,
       }),
       notifications: [...new Set(client.notifications)],
       stderr: client.stderr,
@@ -964,27 +1014,17 @@ export async function runCodexTrimExecution({
       readTurns,
       resumedTurns,
     });
-    if (turnCountCheck.status === 'mismatch' || turnCountCheck.status === 'unknown') {
-      return {
-        status: 'refused',
-        reason: 'codex_rollout_app_server_turn_mismatch',
-        threadId,
-        rollbackSent: false,
-        injectSent: false,
-        injectedItems: 0,
-        readTurns,
-        resumedTurns,
-        rollbackRequestedTurns: rollbackTurns,
-        turnCountCheck,
-        notifications: [...new Set(client.notifications)],
-        stderr: client.stderr,
-      };
-    }
+    const rollbackResolution = resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: rollbackTurns,
+      expectedTurns,
+      readTurns,
+      resumedTurns,
+    });
     const rollback = await client.request(
       buildThreadRollbackRequest({
         id: randomUUID(),
         threadId,
-        numTurns: rollbackTurns,
+        numTurns: rollbackResolution.requestedRollbackTurns,
       }),
     );
     const inject = await client.request(
@@ -1016,7 +1056,8 @@ export async function runCodexTrimExecution({
       injectedItems: 1,
       readTurns,
       resumedTurns,
-      rollbackRequestedTurns: rollbackTurns,
+      rollbackRequestedTurns: rollbackResolution.requestedRollbackTurns,
+      rollbackResolution,
       rollbackResultTurns,
       injectResultTurns,
       afterTurns: postInjectRead.turns,

package/src/codex-app-server.test.mjs

@@ -19,6 +19,7 @@ import {
   compareTurnCounts,
   encodeAppServerMessage,
   parseAppServerLine,
+  resolveRollbackTurnsForAppServer,
   runCodexModelVisibilitySmoke,
   runCodexRollbackModelVisiblePrepare,
   runCodexRollbackModelVisibleVerify,
@@ -203,6 +204,50 @@ test('compareTurnCounts: rejects invalid expected turn count', () => {
   );
 });
 
+test('resolveRollbackTurnsForAppServer adjusts planned rollback by app-server turn delta', () => {
+  assert.deepEqual(
+    resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: 6,
+      expectedTurns: 6,
+      readTurns: 7,
+      resumedTurns: 7,
+    }),
+    {
+      plannedRollbackTurns: 6,
+      requestedRollbackTurns: 7,
+      adjustment: 1,
+      basis: 'app_server_turn_count',
+      reason: 'adjusted_by_app_server_turn_delta',
+    },
+  );
+
+  assert.deepEqual(
+    resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: 2,
+      expectedTurns: 22,
+      readTurns: 21,
+      resumedTurns: 21,
+    }),
+    {
+      plannedRollbackTurns: 2,
+      requestedRollbackTurns: 1,
+      adjustment: -1,
+      basis: 'app_server_turn_count',
+      reason: 'adjusted_by_app_server_turn_delta',
+    },
+  );
+
+  assert.equal(
+    resolveRollbackTurnsForAppServer({
+      plannedRollbackTurns: 6,
+      expectedTurns: 6,
+      readTurns: 7,
+      resumedTurns: 8,
+    }).requestedRollbackTurns,
+    6,
+  );
+});
+
 test('summarizeAppServerStderr: compacts repeated unknown-turn item warnings', () => {
   const stderr = [
     '2026-05-06T00:00:00Z  WARN codex_app_server_protocol::protocol::thread_history: dropping turn-scoped item for unknown turn id `turn-a` item_id="call_1"',

package/src/codex-auto-refresh.mjs

@@ -2,7 +2,7 @@ import { runCodexTrimExecution } from './codex-app-server.mjs';
 import { buildCodexRolloutTrimSource } from './codex-rollout-memory.mjs';
 import { buildTrimPlan } from './trim-model.mjs';
 
-export const CODEX_AUTO_REFRESH_THRESHOLD = 0.8;
+export const CODEX_AUTO_REFRESH_THRESHOLD = 0.75;
 
 export function evaluateCodexAutoRefreshUsage(usage, { threshold = CODEX_AUTO_REFRESH_THRESHOLD } = {}) {
   if (!usage) {

package/src/codex-auto-refresh.test.mjs

@@ -7,10 +7,10 @@ import {
   runCodexAutoRefresh,
 } from './codex-auto-refresh.mjs';
 
-test('evaluateCodexAutoRefreshUsage: default threshold is 80%', () => {
-  assert.equal(CODEX_AUTO_REFRESH_THRESHOLD, 0.8);
+test('evaluateCodexAutoRefreshUsage: default threshold is 75%', () => {
+  assert.equal(CODEX_AUTO_REFRESH_THRESHOLD, 0.75);
   const below = evaluateCodexAutoRefreshUsage({
-    tokens: 206_719,
+    tokens: 193_799,
     contextWindowSize: 258_400,
     estimated: false,
     contextWindowEstimated: false,
@@ -19,7 +19,7 @@ test('evaluateCodexAutoRefreshUsage: default threshold is 80%', () => {
   assert.equal(below.reason, 'below_threshold');
 
   const atThreshold = evaluateCodexAutoRefreshUsage({
-    tokens: 206_720,
+    tokens: 193_800,
     contextWindowSize: 258_400,
     estimated: false,
     contextWindowEstimated: false,

package/src/codex-handoff-smoke.mjs

@@ -13,9 +13,12 @@ function addCheck(checks, { id, status, reason }) {
   checks.push({ id, status, reason });
 }
 
-function findDetailCommands(text) {
-  const matches = text.match(/throughline detail \d\d:\d\d:\d\d/g) ?? [];
-  return matches;
+/**
+ * 新仕様: 各 L1/L2 行末尾の `(詳細：…)` suffix を抽出する。
+ * 旧版の `throughline detail HH:MM:SS` 列挙は廃止 (groupL3ByTurn が turn 単位で集約)。
+ */
+function findDetailSuffixes(text) {
+  return text.match(/\(詳細：[^)]+\)/g) ?? [];
 }
 
 export function buildCodexHandoffSmoke(
@@ -39,8 +42,7 @@ export function buildCodexHandoffSmoke(
     maxBodyChars,
   });
   const checks = [];
-  const detailCommands = findDetailCommands(prompt);
-  const uniqueDetailCommands = new Set(detailCommands);
+  const detailSuffixes = findDetailSuffixes(prompt);
 
   addCheck(checks, {
     id: 'new_thread_handoff_header',
@@ -85,11 +87,11 @@ export function buildCodexHandoffSmoke(
     status: prompt.includes('## Throughline: Active Work Context') ? 'fail' : 'pass',
     reason: 'fresh-thread smoke must not accidentally use the full active-work renderer',
   });
-  addCheck(checks, {
-    id: 'detail_commands_deduplicated',
-    status: detailCommands.length === uniqueDetailCommands.size ? 'pass' : 'fail',
-    reason: 'handoff prompt should not repeat the same detail command',
-  });
+  // 旧 `detail_commands_deduplicated` check は L3 の literal command 列挙を
+  // dedup するためのもの。新版は groupL3ByTurn が構造的に turn 単位に集約するため
+  // 不要。「L3 が存在すれば suffix も存在する」は localizeL3Part の挙動次第で
+  // 偽陽性 (例: tool_output だけの turn は label が null で suffix 空) になるので
+  // smoke check には入れない。
   addCheck(checks, {
     id: 'prompt_size_within_limit',
     status: prompt.length <= maxPromptChars ? 'pass' : 'fail',
@@ -111,8 +113,9 @@ export function buildCodexHandoffSmoke(
     l1Summaries: record.memory.l1Summaries.length,
     recentBodies: record.memory.recentBodies.length,
     l3References: record.references.l3.length,
-    renderedDetailCommands: detailCommands.length,
-    uniqueRenderedDetailCommands: uniqueDetailCommands.size,
+    // 新仕様: per-line `(詳細：…)` suffix の出現回数 (turn 単位に集約済み)。
+    // 旧 renderedDetailCommands / uniqueRenderedDetailCommands は廃止。
+    renderedDetailSuffixes: detailSuffixes.length,
     checks,
   };
 

package/src/codex-handoff-smoke.test.mjs

@@ -68,7 +68,11 @@ test('buildCodexHandoffSmoke: fails when prompt exceeds max size', () => {
   );
 });
 
-test('buildCodexHandoffSmoke: reports rendered detail command deduplication', () => {
+test('buildCodexHandoffSmoke: aggregates same-turn L3 into a single inline (詳細：…) suffix', () => {
+  // 旧版は L3 を独立 `### Detail References` セクションで列挙し、同一 detail command
+  // を dedup していた。新版は groupL3ByTurn が turn 単位に集約して L2 ターンの
+  // 最終 role 行に inline suffix を 1 つ貼る。結果として「同 turn の tool_input +
+  // tool_output」は (詳細：exec_command) 1 件になる。
   const detailRefs = [
     {
       kind: 'tool_input',
@@ -90,14 +94,29 @@ test('buildCodexHandoffSmoke: reports rendered detail command deduplication', ()
     },
   ];
 
-  const result = buildCodexHandoffSmoke(makeRecord({ detailRefs }), { includePrompt: true });
+  const record = makeRecord({ detailRefs });
+  // L3 と turn key が一致する L2 行に上書き (smoke の makeRecord 既定では
+  // recentBodies が originSessionId/turnNumber を持たない)
+  record.memory.recentBodies = [
+    {
+      time: '12:00:02',
+      role: 'assistant',
+      text: 'body of turn 1',
+      originSessionId: 'codex:thread-smoke',
+      turnNumber: 1,
+    },
+  ];
+
+  const result = buildCodexHandoffSmoke(record, { includePrompt: true });
 
   assert.equal(result.status, 'ready');
   assert.equal(result.l3References, 2);
-  assert.equal(result.renderedDetailCommands, 1);
-  assert.equal(result.uniqueRenderedDetailCommands, 1);
+  // 2 件の L3 (tool_input + tool_output) は同一 turn なので 1 件の suffix にまとまる
+  assert.equal(result.renderedDetailSuffixes, 1);
+  assert.match(result.prompt, /\(詳細：exec_command\)/);
+  // 旧 detail_commands_deduplicated check は廃止 (構造的に重複しない)
   assert.equal(
-    result.checks.find((check) => check.id === 'detail_commands_deduplicated')?.status,
-    'pass',
+    result.checks.find((check) => check.id === 'detail_commands_deduplicated'),
+    undefined,
   );
 });