throughline 0.10.0 → 0.10.2

package/src/hosts/codex.mjs

@@ -0,0 +1,28 @@
+/**
+ * hosts/codex.mjs — Codex host adapter
+ *
+ * Codex session (`codex:<thread_id>`) は Claude-facing hook (SessionStart /
+ * UserPromptSubmit / Stop) を通らず、専用入口 `throughline codex-hook`
+ * ([src/cli/codex-hook.mjs](../cli/codex-hook.mjs)) で capture される。
+ * この adapter は共有コードが Codex session を Claude と取り違えないための
+ * 識別と、Claude-facing hook に Codex session が流入した場合の既存挙動
+ * (Claude と同じ経路で処理する) を明文化する。
+ */
+import { CODEX_HOST, isCodexSessionId } from './identity.mjs';
+
+export const codexHostAdapter = Object.freeze({
+  host: CODEX_HOST,
+  matchesSessionId: isCodexSessionId,
+  // 既存挙動: Claude Stop hook の flush barrier は grok 以外 (codex: 含む) に適用される。
+  waitsForStopTranscriptFlush: true,
+  deliverHandoffInjection({ text, stdout = process.stdout }) {
+    stdout.write(text + '\n');
+    return { delivered: true };
+  },
+  resolveCommandPrompt({ prompt }) {
+    return prompt;
+  },
+  afterBatonWrite() {
+    return { launched: false };
+  },
+});

package/src/hosts/grok.mjs

@@ -0,0 +1,96 @@
+/**
+ * hosts/grok.mjs — Grok host 境界 (envelope 正規化 + hook adapter)
+ *
+ * Grok sends Claude-compatible hook commands with a camelCase wire
+ * (sessionId, hookEventName) and no session_id. Throughline treats that
+ * envelope as host=grok: normalize to the Claude snake_case contract and
+ * prefix session ids so they never mix with Claude predecessor search.
+ *
+ * Grok 固有の挙動 (v0.10.0 / ADR 0021):
+ *   - UserPromptSubmit stdout はモデルへ渡らないため、引き継ぎ注入は
+ *     chat_history.jsonl への直接書き込みで行う
+ *   - hook prompt は `<user_query>` 包装のため、裸の slash command 判定には
+ *     chat_history の最新 user 発話を使う
+ *   - `/tl` 成功後だけ grok-continue で後継の対話 grok を立てる
+ *   - Stop hook の transcript flush barrier は Claude transcript 専用のため使わない
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { GROK_HOST, GROK_SESSION_PREFIX, grokBareSessionId, isGrokSessionId } from './identity.mjs';
+import { injectGrokHandoffContext } from '../grok-history-inject.mjs';
+import { readTranscript } from '../transcript-reader.mjs';
+import { run as runGrokContinue } from '../cli/grok-continue.mjs';
+
+export { GROK_SESSION_PREFIX, grokBareSessionId };
+
+export function isGrokEnvelope(payload) {
+  return payload !== null
+    && typeof payload === 'object'
+    && typeof payload.sessionId === 'string'
+    && payload.sessionId.length > 0
+    && typeof payload.hookEventName === 'string'
+    && payload.hookEventName.length > 0
+    && !Object.hasOwn(payload, 'session_id');
+}
+
+export function deriveGrokChatHistoryPath(projectPath, sessionId, { home = homedir() } = {}) {
+  const bare = grokBareSessionId(sessionId);
+  if (!projectPath || !bare) return null;
+  return join(home, '.grok', 'sessions', encodeURIComponent(projectPath), bare, 'chat_history.jsonl');
+}
+
+export function normalizeGrokHookPayload(payload, { home = homedir() } = {}) {
+  if (!isGrokEnvelope(payload)) return payload;
+  const cwd = typeof payload.cwd === 'string' && payload.cwd.length > 0
+    ? payload.cwd
+    : (typeof payload.workspaceRoot === 'string' ? payload.workspaceRoot : undefined);
+  // Live Grok Stop sets transcriptPath to updates.jsonl (sessionUpdate frames,
+  // no user/assistant rows). L2 lives in chat_history.jsonl only.
+  const transcriptPath = deriveGrokChatHistoryPath(cwd, payload.sessionId, { home });
+  return {
+    ...payload,
+    session_id: `${GROK_SESSION_PREFIX}${payload.sessionId}`,
+    cwd,
+    source: payload.source,
+    prompt: payload.prompt,
+    hook_event_name: payload.hookEventName,
+    transcript_path: transcriptPath,
+    last_assistant_message: payload.lastAssistantMessage,
+  };
+}
+
+function lastUserPromptText(transcriptPath) {
+  const turns = readTranscript(transcriptPath);
+  for (let i = turns.length - 1; i >= 0; i--) {
+    if (turns[i].role === 'user') return turns[i].content;
+  }
+  return '';
+}
+
+export const grokHostAdapter = Object.freeze({
+  host: GROK_HOST,
+  matchesSessionId: isGrokSessionId,
+  // Claude Stop transcript flush barrier は Claude transcript の完了行を待つ機構。
+  // Grok の chat_history には適用しない (既存挙動)。
+  waitsForStopTranscriptFlush: false,
+  // Grok は UserPromptSubmit stdout をモデルへ渡さないため chat_history に直接注入する。
+  deliverHandoffInjection({ payload, text }) {
+    const injected = injectGrokHandoffContext(payload.transcript_path, text);
+    return injected.injected
+      ? { delivered: true }
+      : { delivered: false, reason: `grok chat_history inject skipped: ${injected.reason}` };
+  },
+  // Grok の hook prompt は `<user_query>` 包装 + skill 本文のため、裸の /tl 判定は
+  // chat_history の最新 user 発話へ fallback する。
+  resolveCommandPrompt({ prompt, payload, isCommandPrompt }) {
+    if (isCommandPrompt(prompt)) return prompt;
+    return lastUserPromptText(payload.transcript_path);
+  },
+  // Grok `/tl` 成功後だけ、源セッションの project_path で後継の対話 grok を立てる。
+  afterBatonWrite({ trigger, sessionId, cwd, continueRun = runGrokContinue }) {
+    if (trigger !== 'tl') return { launched: false };
+    const code = continueRun(['--session', sessionId], { cwd });
+    return { launched: true, exitCode: code };
+  },
+});

package/src/{hook-envelope.test.mjs → hosts/grok.test.mjs}

@@ -6,7 +6,7 @@ import {
   deriveGrokChatHistoryPath,
   isGrokEnvelope,
   normalizeHookPayload,
-} from './hook-envelope.mjs';
+} from './index.mjs';
 
 test('isGrokEnvelope detects camelCase wire without session_id', () => {
   assert.equal(

package/src/hosts/identity.mjs

@@ -0,0 +1,71 @@
+/**
+ * hosts/identity.mjs — harness (hook host) 識別の唯一の正本
+ *
+ * Throughline は Claude / Codex / Grok の 3 hook host を同じ SQLite に保存する。
+ * host の見分け方は session_id prefix だけであり、その prefix 定義と判定関数を
+ * このファイルに一元化する。共有コード (hook 入口・monitor・state-file・
+ * predecessor 検索) は文字列リテラルを直接持たず、必ずここを参照する。
+ *
+ * 新しい host を足す場合はここへ prefix / host 名を追加し、
+ * `src/hosts/<host>.mjs` に adapter を実装する。
+ */
+
+export const CLAUDE_HOST = 'claude';
+export const CODEX_HOST = 'codex';
+export const GROK_HOST = 'grok';
+
+export const CODEX_SESSION_PREFIX = 'codex:';
+export const GROK_SESSION_PREFIX = 'grok:';
+
+/**
+ * Claude session は prefix を持たない。auto handoff の前任検索 (Claude 専用) は
+ * この一覧の prefix を持つ session を除外する。
+ */
+export const NON_CLAUDE_SESSION_PREFIXES = Object.freeze([
+  CODEX_SESSION_PREFIX,
+  GROK_SESSION_PREFIX,
+]);
+
+/**
+ * state ファイルに保存できる host 値。Grok session は Claude 互換 hook 経路で
+ * 保存されるため state 上は 'claude' として扱う (既存挙動)。
+ */
+export const KNOWN_STATE_HOSTS = Object.freeze([CLAUDE_HOST, CODEX_HOST]);
+
+export function isCodexSessionId(sessionId) {
+  return typeof sessionId === 'string' && sessionId.startsWith(CODEX_SESSION_PREFIX);
+}
+
+export function isGrokSessionId(sessionId) {
+  return typeof sessionId === 'string' && sessionId.startsWith(GROK_SESSION_PREFIX);
+}
+
+/**
+ * session_id から hook host を返す。prefix なしは Claude。
+ * @param {string} sessionId
+ * @returns {'claude'|'codex'|'grok'}
+ */
+export function hostOfSessionId(sessionId) {
+  if (isCodexSessionId(sessionId)) return CODEX_HOST;
+  if (isGrokSessionId(sessionId)) return GROK_HOST;
+  return CLAUDE_HOST;
+}
+
+export function buildCodexThroughlineSessionId(threadId) {
+  if (typeof threadId !== 'string' || threadId.trim().length === 0) {
+    throw new Error('threadId is required');
+  }
+  return `${CODEX_SESSION_PREFIX}${threadId.trim()}`;
+}
+
+export function codexSessionIdToThreadId(sessionId) {
+  if (!isCodexSessionId(sessionId)) return null;
+  return sessionId.slice(CODEX_SESSION_PREFIX.length) || null;
+}
+
+export function grokBareSessionId(sessionId) {
+  if (typeof sessionId !== 'string' || sessionId.length === 0) return null;
+  return sessionId.startsWith(GROK_SESSION_PREFIX)
+    ? sessionId.slice(GROK_SESSION_PREFIX.length)
+    : sessionId;
+}

package/src/hosts/identity.test.mjs

@@ -0,0 +1,65 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  CODEX_SESSION_PREFIX,
+  GROK_SESSION_PREFIX,
+  NON_CLAUDE_SESSION_PREFIXES,
+  buildCodexThroughlineSessionId,
+  codexSessionIdToThreadId,
+  grokBareSessionId,
+  hostOfSessionId,
+  isCodexSessionId,
+  isGrokSessionId,
+} from './identity.mjs';
+import { hostAdapterForSessionId } from './index.mjs';
+
+test('session prefixes are the canonical wire values', () => {
+  assert.equal(CODEX_SESSION_PREFIX, 'codex:');
+  assert.equal(GROK_SESSION_PREFIX, 'grok:');
+  assert.deepEqual([...NON_CLAUDE_SESSION_PREFIXES], ['codex:', 'grok:']);
+});
+
+test('hostOfSessionId maps prefixes to hosts and defaults to claude', () => {
+  assert.equal(hostOfSessionId('codex:0199aa'), 'codex');
+  assert.equal(hostOfSessionId('grok:0199aa'), 'grok');
+  assert.equal(hostOfSessionId('0199aa-claude'), 'claude');
+  assert.equal(hostOfSessionId(undefined), 'claude');
+});
+
+test('codex session id round-trips thread id', () => {
+  assert.equal(buildCodexThroughlineSessionId(' t1 '), 'codex:t1');
+  assert.equal(codexSessionIdToThreadId('codex:t1'), 't1');
+  assert.equal(codexSessionIdToThreadId('t1'), null);
+  assert.equal(codexSessionIdToThreadId('codex:'), null);
+  assert.throws(() => buildCodexThroughlineSessionId('  '));
+});
+
+test('grokBareSessionId strips only the grok prefix', () => {
+  assert.equal(grokBareSessionId('grok:abc'), 'abc');
+  assert.equal(grokBareSessionId('abc'), 'abc');
+  assert.equal(grokBareSessionId(''), null);
+});
+
+test('isCodexSessionId / isGrokSessionId reject non-strings', () => {
+  assert.equal(isCodexSessionId(null), false);
+  assert.equal(isGrokSessionId(undefined), false);
+});
+
+test('every host adapter satisfies the shared hook contract', () => {
+  for (const sessionId of ['claude-session', 'codex:t1', 'grok:t1']) {
+    const adapter = hostAdapterForSessionId(sessionId);
+    assert.equal(typeof adapter.host, 'string');
+    assert.equal(adapter.matchesSessionId(sessionId), true);
+    assert.equal(typeof adapter.waitsForStopTranscriptFlush, 'boolean');
+    assert.equal(typeof adapter.deliverHandoffInjection, 'function');
+    assert.equal(typeof adapter.resolveCommandPrompt, 'function');
+    assert.equal(typeof adapter.afterBatonWrite, 'function');
+  }
+});
+
+test('flush barrier applies to claude and codex sessions, not grok', () => {
+  assert.equal(hostAdapterForSessionId('claude-session').waitsForStopTranscriptFlush, true);
+  assert.equal(hostAdapterForSessionId('codex:t1').waitsForStopTranscriptFlush, true);
+  assert.equal(hostAdapterForSessionId('grok:t1').waitsForStopTranscriptFlush, false);
+});

package/src/hosts/index.mjs

@@ -0,0 +1,37 @@
+/**
+ * hosts/index.mjs — host 境界の入口
+ *
+ * 共有 hook 入口 (session-start / prompt-submit / turn-processor) はここから
+ * `normalizeHookPayload` と `hostAdapterForSessionId` だけを使い、
+ * ベンダー分岐を直接書かない。
+ */
+import { hostOfSessionId, CLAUDE_HOST, CODEX_HOST, GROK_HOST } from './identity.mjs';
+import { claudeHostAdapter } from './claude.mjs';
+import { codexHostAdapter } from './codex.mjs';
+import { grokHostAdapter, isGrokEnvelope, normalizeGrokHookPayload } from './grok.mjs';
+
+export * from './identity.mjs';
+export { isGrokEnvelope, deriveGrokChatHistoryPath, normalizeGrokHookPayload } from './grok.mjs';
+
+const ADAPTERS = Object.freeze({
+  [CLAUDE_HOST]: claudeHostAdapter,
+  [CODEX_HOST]: codexHostAdapter,
+  [GROK_HOST]: grokHostAdapter,
+});
+
+/**
+ * hook stdin payload を Claude snake_case 契約へ正規化する。
+ * 現状 camelCase envelope を送るのは Grok だけ (v0.10.0 / ADR 0021)。
+ */
+export function normalizeHookPayload(payload, options = {}) {
+  if (isGrokEnvelope(payload)) return normalizeGrokHookPayload(payload, options);
+  return payload;
+}
+
+/**
+ * @param {string} sessionId
+ * @returns {typeof claudeHostAdapter}
+ */
+export function hostAdapterForSessionId(sessionId) {
+  return ADAPTERS[hostOfSessionId(sessionId)];
+}

package/src/os/app-dirs.mjs

@@ -0,0 +1,25 @@
+/**
+ * os/app-dirs.mjs — OS別のユーザー設定/状態ベースディレクトリ解決
+ *
+ * LOCALAPPDATA（Windows）と XDG_CONFIG_HOME / XDG_STATE_HOME（POSIX）の
+ * フォールバック組み立てが runtime-error-store と completed-turn-receipts に
+ * 別々に書かれていたため、ここへ集約する。最終的なアプリ別 join は呼び出し側が持つ。
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function homeOf(env) {
+  return env.HOME || env.USERPROFILE || homedir();
+}
+
+export function windowsLocalAppData(env = process.env) {
+  return env.LOCALAPPDATA || join(homeOf(env), 'AppData', 'Local');
+}
+
+export function xdgConfigHome(env = process.env) {
+  return env.XDG_CONFIG_HOME || join(homeOf(env), '.config');
+}
+
+export function xdgStateHome(env = process.env) {
+  return env.XDG_STATE_HOME || join(homeOf(env), '.local', 'state');
+}

package/src/os/macos-terminal.mjs

@@ -0,0 +1,44 @@
+/**
+ * os/macos-terminal.mjs — macOS Terminal.app で対話 process を立てる
+ *
+ * 2 つの起動形を提供する (どちらも osascript 経由):
+ *   - runTerminalScriptDetached: launch script の path を quoted form で exec
+ *     (grok-continue が使う detached 起動)
+ *   - runTerminalDoScript: shell command 1 行を do script で実行 (codex resume 用)
+ *
+ * macOS 以外では呼ばないこと。platform gate は呼び出し元の責務
+ * (explicit error にするため、ここで silent no-op にしない)。
+ */
+import { spawn, spawnSync } from 'node:child_process';
+
+import { appleString } from './shell.mjs';
+
+export function appleScriptForTerminalExec(launchScriptPath) {
+  return [
+    'tell application "Terminal"',
+    '  activate',
+    `  do script "exec " & quoted form of ${JSON.stringify(launchScriptPath)}`,
+    'end tell',
+    '',
+  ].join('\n');
+}
+
+export function runTerminalScriptDetached({ launchFile, spawnImpl = spawn }) {
+  const child = spawnImpl('osascript', ['-e', appleScriptForTerminalExec(launchFile)], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref?.();
+  return child;
+}
+
+export function runTerminalDoScript(shellCommand, { spawnImpl = spawnSync } = {}) {
+  return spawnImpl('osascript', [], {
+    input: `tell application "Terminal"
+  activate
+  do script ${appleString(shellCommand)}
+end tell
+`,
+    encoding: 'utf8',
+  });
+}

package/src/os/open-url.mjs

@@ -0,0 +1,16 @@
+/**
+ * os/open-url.mjs — deep link / URL を OS 既定の handler で開く
+ *
+ * darwin: `open` / win32: `cmd /c start` / その他: `xdg-open`。
+ * 呼び出し元は result.status !== 0 を explicit failure として扱う。
+ */
+import { spawnSync } from 'node:child_process';
+
+export function openUrlWithOsHandler(url, {
+  platform = process.platform,
+  spawnImpl = spawnSync,
+} = {}) {
+  if (platform === 'darwin') return spawnImpl('open', [url], { encoding: 'utf8' });
+  if (platform === 'win32') return spawnImpl('cmd.exe', ['/c', 'start', '', url], { encoding: 'utf8' });
+  return spawnImpl('xdg-open', [url], { encoding: 'utf8' });
+}

package/src/os/paths.mjs

@@ -0,0 +1,16 @@
+/**
+ * os/paths.mjs — path 正規化の OS 依存部分
+ *
+ * Windows の filesystem は case-insensitive のため、比較・保存用の
+ * 正規化 path は win32 でだけ小文字へ畳む。この判断が state-file と
+ * project-path に別々に書かれていたため、ここへ集約する。
+ */
+import { platform } from 'node:os';
+
+export function foldPathCaseForPlatform(path, { hostPlatform = platform() } = {}) {
+  return hostPlatform === 'win32' ? path.toLowerCase() : path;
+}
+
+export function isWin32Platform(hostPlatform = platform()) {
+  return hostPlatform === 'win32';
+}

package/src/os/shell.mjs

@@ -0,0 +1,16 @@
+/**
+ * os/shell.mjs — shell / AppleScript 文字列 quoting の唯一の正本
+ *
+ * grok-continue と codex-handoff-start がそれぞれ同じ POSIX single-quote
+ * escape を別実装していたため集約する。
+ */
+
+/** POSIX shell single-quote escape */
+export function shQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+/** AppleScript の string literal escape */
+export function appleString(value) {
+  return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}

package/src/os/windows-acl.mjs

@@ -0,0 +1,57 @@
+/**
+ * os/windows-acl.mjs — Windows owner-only ACL の適用と検証 (唯一の正本)
+ *
+ * runtime-error-store と completed-turn-receipts が同一の PowerShell ACL
+ * 実装を別々に持っていたため (env 変数名だけ違う事故フォーク)、ここへ集約する。
+ *
+ * apply script は適用直後に同一 process 内で read-back 検証まで行う。
+ * 検証内容: owner = current SID、explicit rule が current SID の
+ * FullControl Allow 1 本だけ、継承 rule なし。
+ *
+ * CI 実測で PowerShell コールドスタートが 3.0〜3.2 秒に達し 3 秒 cap と衝突して
+ * flake したため timeout は 15 秒 (run 29586852389 / 29628634501)。
+ * explicit failure 契約は不変: 非 0 exit は例外にする。
+ *
+ * 注意: テストは `childProcess.spawnSync` を node:child_process の default
+ * export 経由で mock するため、named import に変えないこと。
+ */
+import childProcess from 'node:child_process';
+import { platform as hostPlatform } from 'node:os';
+
+export const WINDOWS_ACL_TIMEOUT_MS = 15_000;
+
+export function isWindows(env = process.env) {
+  return env.OS === 'Windows_NT' || hostPlatform() === 'win32';
+}
+
+export function applyAndVerifyWindowsAcl(path, directory) {
+  runWindowsAclScript(path, directory, WINDOWS_ACL_APPLY_SCRIPT);
+}
+
+export function verifyWindowsAcl(path, directory) {
+  runWindowsAclScript(path, directory, WINDOWS_ACL_VERIFY_SCRIPT);
+}
+
+function runWindowsAclScript(path, directory, script) {
+  const result = childProcess.spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], {
+    env: { ...process.env, THROUGHLINE_ACL_PATH: path, THROUGHLINE_ACL_DIRECTORY: directory ? '1' : '0' },
+    stdio: 'ignore', timeout: WINDOWS_ACL_TIMEOUT_MS, windowsHide: true,
+  });
+  if (result.status !== 0) throw new Error('Windows owner-only ACL verification failed');
+}
+
+const WINDOWS_ACL_VERIFY_SCRIPT = String.raw`
+$p=$env:THROUGHLINE_ACL_PATH; $isDir=$env:THROUGHLINE_ACL_DIRECTORY -eq '1'; $sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value
+$acl=if($isDir){[System.IO.Directory]::GetAccessControl($p)}else{[System.IO.File]::GetAccessControl($p)}
+$owner=$acl.GetOwner([System.Security.Principal.SecurityIdentifier]).Value
+if($owner -ne $sid){exit 41}; $rules=@($acl.GetAccessRules($true,$true,[System.Security.Principal.SecurityIdentifier])); if($rules.Count -ne 1){exit 42}
+$r=$rules[0]; if($r.IdentityReference.Value -ne $sid -or $r.AccessControlType -ne 'Allow' -or $r.IsInherited -or ($r.FileSystemRights -band [System.Security.AccessControl.FileSystemRights]::FullControl) -ne [System.Security.AccessControl.FileSystemRights]::FullControl){exit 43}
+`;
+
+const WINDOWS_ACL_APPLY_SCRIPT = String.raw`
+$p=$env:THROUGHLINE_ACL_PATH; $sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User
+$isDir=$env:THROUGHLINE_ACL_DIRECTORY -eq '1'; $acl=if($isDir){New-Object System.Security.AccessControl.DirectorySecurity}else{New-Object System.Security.AccessControl.FileSecurity}; $acl.SetAccessRuleProtection($true,$false)
+$flags=if($isDir){[System.Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit'}else{[System.Security.AccessControl.InheritanceFlags]::None}
+$rule=New-Object System.Security.AccessControl.FileSystemAccessRule($sid,'FullControl',$flags,[System.Security.AccessControl.PropagationFlags]::None,[System.Security.AccessControl.AccessControlType]::Allow)
+$acl.SetOwner($sid); $acl.AddAccessRule($rule); if($isDir){[System.IO.Directory]::SetAccessControl($p,$acl)}else{[System.IO.File]::SetAccessControl($p,$acl)}
+` + WINDOWS_ACL_VERIFY_SCRIPT;

package/src/project-path.mjs

@@ -1,7 +1,8 @@
 import { existsSync, realpathSync } from 'node:fs';
-import { platform } from 'node:os';
 import { resolve, sep } from 'node:path';
 
+import { foldPathCaseForPlatform } from './os/paths.mjs';
+
 export function normalizeProjectPathForCompare(value) {
   if (!value) return '';
   let resolved = resolve(String(value));
@@ -10,9 +11,8 @@ export function normalizeProjectPathForCompare(value) {
   } catch {
     // Fall back to the lexical path when the filesystem cannot resolve it.
   }
-  let normalized = resolved.split(sep).join('/').replace(/\/+$/, '');
-  if (platform() === 'win32') normalized = normalized.toLowerCase();
-  return normalized;
+  const normalized = resolved.split(sep).join('/').replace(/\/+$/, '');
+  return foldPathCaseForPlatform(normalized);
 }
 
 export function sameProjectPath(a, b) {

package/src/prompt-submit.mjs

@@ -42,10 +42,7 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { recordRuntimeErrorBestEffort } from './runtime-error-store.mjs';
-import { GROK_SESSION_PREFIX, normalizeHookPayload } from './hook-envelope.mjs';
-import { injectGrokHandoffContext } from './grok-history-inject.mjs';
-import { readTranscript } from './transcript-reader.mjs';
-import { run as runGrokContinue } from './cli/grok-continue.mjs';
+import { hostAdapterForSessionId, normalizeHookPayload } from './hosts/index.mjs';
 
 // Phase 0-5 spike marker (SessionStart の spike-inject.flag とは別)
 const PROMPT_SPIKE_MARKER_PATH = join(homedir(), '.throughline', 'spike-prompt.flag');
@@ -131,14 +128,6 @@ function isNamedSlashCommand(prompt, name) {
   return text === name || text.startsWith(`${name} `) || text.startsWith(`${name}\n`);
 }
 
-function lastUserPromptText(transcriptPath) {
-  const turns = readTranscript(transcriptPath);
-  for (let i = turns.length - 1; i >= 0; i--) {
-    if (turns[i].role === 'user') return turns[i].content;
-  }
-  return '';
-}
-
 /**
  * プロンプトが /tl バトン発動コマンドか判定する。
  * 許容: "/tl", "/tl\n", "/tl 何か"。Grok の user_query 包装も見る。
@@ -155,20 +144,6 @@ export function isClearCommand(prompt) {
   return isNamedSlashCommand(prompt, '/clear') || isNamedSlashCommand(prompt, '/new');
 }
 
-export function shouldLaunchGrokContinue({ sessionId, trigger }) {
-  return trigger === 'tl'
-    && typeof sessionId === 'string'
-    && sessionId.startsWith(GROK_SESSION_PREFIX);
-}
-
-export function launchGrokContinueAfterTl({
-  sessionId,
-  cwd,
-  continueRun = runGrokContinue,
-}) {
-  return continueRun(['--session', sessionId], { cwd });
-}
-
 export async function run() {
   let raw = '';
   await new Promise((resolve) => {
@@ -181,6 +156,7 @@ export async function run() {
 
   const payload = normalizeHookPayload(JSON.parse(raw));
   const { session_id, cwd, prompt } = payload;
+  const hostAdapter = hostAdapterForSessionId(session_id);
 
   // VSCode 新規プロジェクトへの tasks.json 自動プロビジョニング。
   // SessionStart/Stop に加えここでも呼ぶことで、どれか 1 つでも発火すれば初回メッセージ送信で
@@ -208,16 +184,13 @@ export async function run() {
     });
     if (handoff.attempted) {
       if (handoff.injectionText) {
-        if (session_id.startsWith(GROK_SESSION_PREFIX)) {
-          const injected = injectGrokHandoffContext(
-            payload.transcript_path,
-            handoff.injectionText,
-          );
-          if (!injected.injected) {
-            process.stderr.write(`[prompt-submit] grok chat_history inject skipped: ${injected.reason}\n`);
-          }
-        } else {
-          process.stdout.write(handoff.injectionText + '\n');
+        // 注入の届け方は host 依存 (Claude: stdout / Grok: chat_history 直書き)。
+        const delivery = hostAdapter.deliverHandoffInjection({
+          payload,
+          text: handoff.injectionText,
+        });
+        if (!delivery.delivered) {
+          process.stderr.write(`[prompt-submit] ${delivery.reason}\n`);
         }
       }
       logDecision({
@@ -238,15 +211,13 @@ export async function run() {
     }
   }
 
-  let commandPrompt = prompt;
-  if (
-    typeof session_id === 'string'
-    && session_id.startsWith(GROK_SESSION_PREFIX)
-    && !isBatonCommand(commandPrompt)
-    && !isClearCommand(commandPrompt)
-  ) {
-    commandPrompt = lastUserPromptText(payload.transcript_path);
-  }
+  // slash command の判定材料は host 依存 (Grok は user_query 包装のため
+  // chat_history の最新 user 発話へ fallback する)。
+  const commandPrompt = hostAdapter.resolveCommandPrompt({
+    prompt,
+    payload,
+    isCommandPrompt: (p) => isBatonCommand(p) || isClearCommand(p),
+  });
   const tlMatch = isBatonCommand(commandPrompt);
   const clearMatch = !tlMatch && isClearCommand(commandPrompt);
 
@@ -281,17 +252,14 @@ export async function run() {
     trigger: tlMatch ? 'tl' : 'clear',
   });
 
-  if (shouldLaunchGrokContinue({
-    sessionId: session_id,
+  // バトン書き込み後の副作用は host 依存 (Grok /tl だけ後継セッションを起動する)。
+  const afterBaton = hostAdapter.afterBatonWrite({
     trigger: tlMatch ? 'tl' : 'clear',
-  })) {
-    const code = launchGrokContinueAfterTl({
-      sessionId: session_id,
-      cwd: projectPath,
-    });
-    if (code !== 0) {
-      process.stderr.write(`[prompt-submit] grok-continue exited ${code}\n`);
-    }
+    sessionId: session_id,
+    cwd: projectPath,
+  });
+  if (afterBaton.launched && afterBaton.exitCode !== 0) {
+    process.stderr.write(`[prompt-submit] grok-continue exited ${afterBaton.exitCode}\n`);
   }
 
   process.exit(0);