@cocorograph/hub-agent 0.8.76 → 0.8.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.76",
+  "version": "0.8.77",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",

package/src/async-ttl-cache.mjs

@@ -19,26 +19,40 @@ export class AsyncTtlCache {
 
   async get(build) {
     if (this.hasValue && this.now() < this.expiresAt) return this.value
+    // 合流者はここで inFlight をそのまま受け取る。⚠️ したがって「世代が変わっていないか」の
+    // 確認は inFlight **そのものの中**で済ませておく必要がある（下の _buildOnce）。
     if (this.inFlight) return this.inFlight
 
-    const generation = this.generation
-    const pending = Promise.resolve().then(build)
+    const pending = this._buildOnce(build)
     this.inFlight = pending
     try {
-      const value = await pending
-      // build 中に mutation / state push が走った場合、旧値を最初の caller にも返さない。
-      // clear() が inFlight を外しているため、新世代の build を開始するか既存の新 build に
-      // 合流する。read-only snapshot 専用なので再実行は安全。
-      if (this.generation !== generation) return this.get(build)
-      this.value = value
-      this.hasValue = true
-      this.expiresAt = this.now() + this.ttlMs
-      return value
+      return await pending
     } finally {
       if (this.inFlight === pending) this.inFlight = null
     }
   }
 
+  /**
+   * build を 1 回走らせ、その間に `clear()` が入っていなければ確定して返す。
+   *
+   * ⚠️ 世代確認をこの promise の **中**に置くのが要点。`get()` 側の await の後に置くと、
+   * 確認を通るのは build を開始した最初の caller だけで、`this.inFlight` をそのまま
+   * 受け取った合流者は無効化済みの結果を受け取れてしまう（それが元の実装の穴）。
+   *
+   * 世代が進んでいたら旧結果を捨てて引き直す。`clear()` は generation を進めると同時に
+   * `inFlight` を外すので、ここから `get()` を呼び直しても自分自身へ合流することはない。
+   * read-only snapshot 専用なので再実行は安全。
+   */
+  async _buildOnce(build) {
+    const generation = this.generation
+    const value = await Promise.resolve().then(build)
+    if (this.generation !== generation) return await this.get(build)
+    this.value = value
+    this.hasValue = true
+    this.expiresAt = this.now() + this.ttlMs
+    return value
+  }
+
   clear() {
     this.generation += 1
     this.hasValue = false

package/src/chat-removal-guard.mjs

@@ -0,0 +1,62 @@
+/**
+ * worktree を削除している最中の「新規 attach」を止めるためのガード。
+ *
+ * ⚠️ 削除前に会話を止めるだけでは足りない。停止してから dir を消すまでの間に attach が来ると、
+ * **消える直前の dir を cwd とする会話**が新しく生まれ、削除後には cwd が存在しない会話として
+ * 残る（「送ったら起きる」方式にしたので、この窓は利用者の送信 1 回で簡単に開く）。
+ *
+ * ⚠️ 検査は **attach の定義側 2 箇所**（claude-stream-bridge / codex-stream-bridge）に置く。
+ * 呼び出し元は現時点で 4 箇所あるが、経路ごとに掛けると経路が増えたときに片方だけ守られる。
+ * 会話が生まれる場所は attach だけなので、そこで 1 回見れば足りる。
+ *
+ * ⚠️ 依存を持たないこと。両 bridge から import されるため、bridge や live-sessions を
+ * 参照すると循環する。ここが持つのは「削除中のパス」という事実だけで、
+ * 「どの会話が生きているか」は live-sessions.mjs 側の責務。
+ */
+import path from "node:path"
+
+/** 削除中の worktree パス → 進行中の削除の本数。 */
+const removals = new Map()
+
+/**
+ * 削除の開始を記録し、**解除関数**を返す。
+ *
+ * ⚠️ 単純な Set ではなく参照カウントにしてある。同じ worktree に対する削除要求が重なったとき、
+ * 先に終わった方が解除すると、まだ削除中の側のガードまで外れてしまうため。
+ * 返す解除関数は冪等（2 回以上呼ばれても 1 回ぶんしか減らさない）。呼び出し側は finally で
+ * 呼ぶので、成功・失敗のどちらの経路からも二重に到達しうる。
+ *
+ * @param {string} dir 削除対象の worktree パス
+ * @returns {() => void} 解除関数
+ */
+export function beginRemoval(dir) {
+  const base = path.resolve(dir)
+  removals.set(base, (removals.get(base) || 0) + 1)
+  let released = false
+  return () => {
+    if (released) return
+    released = true
+    const remaining = removals.get(base) - 1
+    if (remaining === 0) removals.delete(base)
+    else removals.set(base, remaining)
+  }
+}
+
+/**
+ * cwd が削除中の worktree そのもの、またはその配下かどうか。
+ *
+ * ⚠️ 比較は必ずパス境界で行う。素の `startsWith(base)` にすると `<wt>` と `<wt>-backup` を
+ * 取り違えて、削除していない worktree への attach まで拒否する（ガードは弾きすぎる方向にも
+ * 壊れるので、両方向の検査がテストにある）。
+ *
+ * @param {unknown} cwd
+ * @returns {boolean}
+ */
+export function isUnderRemoval(cwd) {
+  if (typeof cwd !== "string" || !cwd) return false
+  const resolved = path.resolve(cwd)
+  for (const base of removals.keys()) {
+    if (resolved === base || resolved.startsWith(base + path.sep)) return true
+  }
+  return false
+}

package/src/chat-session-starter.mjs

@@ -0,0 +1,90 @@
+import { randomUUID } from "node:crypto"
+import fs from "node:fs/promises"
+import { expandTilde, prepareChatWorkspace } from "./chat-workspace.mjs"
+import { describeLiveSessionsUnion } from "./live-sessions.mjs"
+
+export const CHAT_START_SYNC_WAIT_MS = 8000
+
+const starts = new Map()
+
+/** 同じ cwd・CLI の起動を直列化し、既存のライブ会話を再利用する。 */
+export async function ensureChatSession({ cwd, cliKind, bridges, logger, resolveClaudeOptions }) {
+  cwd = expandTilde(cwd)
+  const key = JSON.stringify([cwd, cliKind])
+  const previous = starts.get(key) || Promise.resolve()
+  const pending = previous.then(async () => {
+    try {
+      const existing = describeLiveSessionsUnion(bridges, { cwd, cliKind })[0]
+      if (existing) return { ok: true, session: existing, cwd }
+      const bridge = cliKind === "claude" ? bridges?.claudeBridge
+        : cliKind === "codex" ? bridges?.codexBridge : null
+      if (!bridge?.attach) throw new Error(`chat bridge unavailable: ${cliKind}`)
+      const prepared = await prepareChatWorkspace({ cwd, cliKind, waitForSync: false, logger })
+      cwd = prepared.cwd
+      let timer
+      let completed
+      try {
+        completed = await Promise.race([
+          // sync は「指示書が使えるか」に解決する。⚠️ ここを `.then(() => true)` にしない。
+          // 同期は書込に失敗しても warn だけで **正常終了**するため、完了＝準備成功ではない。
+          prepared.sync.then((ready) => ({ ready })),
+          new Promise((resolve) => { timer = setTimeout(() => resolve(null), CHAT_START_SYNC_WAIT_MS) }),
+        ])
+      } finally {
+        clearTimeout(timer)
+      }
+      // ⚠️ 待機の打ち切りも、同期の正常終了も、それだけでは起動の許可にならない。指示書が無い
+      // cwd で会話を開くと、CLAUDE.md / AGENTS.md が無い状態がその会話の前提として固定され、
+      // あとから同期しても開き直すまで直らない。両方まとめて再試行可能な失敗として返す
+      // (呼び出し側は「準備中」と「恒久的な不在」を区別できる)。
+      if (!completed) {
+        logger?.warn?.({ cwd, cliKind }, "chat workspace sync wait timed out; start aborted")
+        return { ok: false, error: "workspace_not_ready", retryable: true }
+      }
+      if (!completed.ready) {
+        logger?.warn?.({ cwd, cliKind }, "chat workspace instructions unavailable; start aborted")
+        return { ok: false, error: "workspace_not_ready", retryable: true }
+      }
+      // ⚠️ prepareChatWorkspace が入口で実在を確かめているが (chat-workspace.mjs の
+      // `fs.stat(resolvedCwd)`)、そこから上の sync 待ち (最大 CHAT_START_SYNC_WAIT_MS) を挟むので、
+      // 待っている間に worktree ごと消えていることがある。**削除中**なら bridge の attach が
+      // chat-removal-guard で弾くが、待機中に削除が **完了** するとガードは解除済みなので、
+      // そちらでは捕まらない。sync 待ちを抜けた直後に実在を取り直すのが、両方をまとめて塞ぐ
+      // 一番小さい形。
+      // ⚠️ ガードを削除後も保持し続ける形にはしない。同じパスへ worktree を作り直したときに
+      // 起動できなくなる。実在確認なら、消えていれば弾き、作り直されていれば通る。
+      // ⚠️ `existsSync` など `node:fs` の同期 API に置き換えないこと。検査が `node:fs/promises`
+      // の `stat` をモックしているため、別 API にするとモックを素通りして実ファイルを見に行く。
+      // ⚠️ この検査を下の live 再確認より **後ろ**へ動かさないこと (理由は下のコメント)。
+      try {
+        if (!(await fs.stat(cwd)).isDirectory()) return { ok: false, error: "workspace_missing" }
+      } catch {
+        return { ok: false, error: "workspace_missing" }
+      }
+      // ⚠️ 同期の待機中に別経路 (画面からの attach 等) が同じ cwd の会話を開いていることがある。
+      // starts の直列化が畳むのは同じ key の起動だけなので、ここで live を取り直さないと
+      // 同じ cwd に会話を二重に起こす。
+      // ⚠️ **この再確認から attach までの間に await を 1 つも置かない。** 通常 attach (main.mjs の
+      // claude.attach / codex.attach) は starts の直列化対象外なので、間に待ちがあるとその隙に
+      // 同じ cwd の会話が開き、再確認をすり抜けて二重に作る。実在確認の await をここへ置いて
+      // 実際に踏んだ (2026-09-16)。
+      const concurrent = describeLiveSessionsUnion(bridges, { cwd, cliKind })[0]
+      if (concurrent) return { ok: true, session: concurrent, cwd }
+      const stream_id = `auto-${randomUUID()}`
+      if (cliKind === "codex") await bridge.attach({ stream_id, cwd })
+      else bridge.attach({ ...resolveClaudeOptions?.(), stream_id, cwd })
+      const session = describeLiveSessionsUnion(bridges, { cwd, cliKind })[0]
+      return { ok: true, session, cwd }
+    } catch (err) {
+      const error = err?.message || String(err)
+      logger?.warn?.({ cwd, cliKind, error }, "chat session start failed")
+      return { ok: false, error }
+    }
+  })
+  starts.set(key, pending)
+  try {
+    return await pending
+  } finally {
+    if (starts.get(key) === pending) starts.delete(key)
+  }
+}

package/src/chat-sessions-snapshot.mjs

@@ -0,0 +1,9 @@
+import { listChatTargets } from "./chat-targets.mjs"
+import { describeLiveSessionsUnion } from "./live-sessions.mjs"
+
+/** ローカル検出した宛先と、毎回取得するライブ会話を返す。 */
+export async function buildChatSessionsSnapshot({ bridges, logger }) {
+  const live = describeLiveSessionsUnion(bridges)
+  const { targets, errors } = await listChatTargets({ logger })
+  return { targets, live, errors }
+}

package/src/chat-targets.mjs

@@ -0,0 +1,60 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+import { hubProjectsBase } from "./chat-workspace.mjs"
+import { listWorktreeEntries } from "./tmux.mjs"
+import { AsyncTtlCache } from "./async-ttl-cache.mjs"
+
+export const chatTargetsCache = new AsyncTtlCache({ ttlMs: 3000 })
+
+/**
+ * これはローカルのディレクトリ検出であって Hub の登録一覧ではない。
+ *
+ * ⚠️ **走査が 1 つでも失敗した結果はキャッシュしない**。この一覧は送信の宛先候補そのもので、
+ * 権限エラー等で一部が欠けたまま TTL のあいだ配ると、実在する宛先が「無い」と判定される
+ * (`no_live_session_for_cwd` に化ける)。AsyncTtlCache は **例外**を投げた build をキャッシュ
+ * しない設計だが、失敗を戻り値へ包むとその保護が外れるため、ここで明示的に捨てる。
+ */
+export async function listChatTargets({ logger } = {}) {
+  const result = await chatTargetsCache.get(async () => {
+    const base = hubProjectsBase()
+    const errors = []
+    let workspaces = []
+    let worktrees = []
+    try {
+      workspaces = (await fs.readdir(base, { withFileTypes: true }))
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+        .map((entry) => ({ kind: "workspace", name: entry.name, cwd: path.join(base, entry.name) }))
+    } catch (err) {
+      // ⚠️ ENOENT は「base がまだ作られていない」であって走査の失敗ではない。worktree 側
+      // (tmux.mjs の listWorktreeEntries) と扱いを揃える。ここで errors に入れると、正常な
+      // 新規環境が常時エラー扱いになり、さらに下の失敗時破棄でキャッシュも毎回捨てられる。
+      // EACCES / ENOTDIR / I-O エラーは本物の失敗なので従来どおり errors に残す。
+      if (err?.code !== "ENOENT") {
+        errors.push({ scope: "projects-base", path: base, code: err?.code ?? null, message: err?.message || String(err) })
+        logger?.warn?.({ err: err?.message || String(err) }, "chat.sessions: workspace scan failed")
+      }
+    }
+    try {
+      const scan = await listWorktreeEntries()
+      errors.push(...scan.errors)
+      worktrees = scan.entries.map((entry) => ({
+        kind: "worktree", name: entry.name, cwd: entry.cwd,
+        parent_name: entry.parent_session_name, branch: entry.branch,
+      }))
+    } catch (err) {
+      errors.push({ scope: "projects-base", path: base, code: err?.code ?? null, message: err?.message || String(err) })
+      logger?.warn?.({ err: err?.message || String(err) }, "chat.sessions: worktree scan failed")
+    }
+    const byName = (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+    const seen = new Set()
+    const targets = [...workspaces.sort(byName), ...worktrees.sort(byName)].filter(({ cwd }) => {
+      if (seen.has(cwd)) return false
+      seen.add(cwd)
+      return true
+    })
+    return { targets, errors }
+  })
+  // 失敗を含む結果は次の呼び出しで再走査させる (TTL のあいだ欠けた宛先一覧を配らない)。
+  if (result.errors.length > 0) chatTargetsCache.clear()
+  return result
+}

package/src/chat-workspace.mjs

@@ -0,0 +1,279 @@
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { ensureClaudeMd } from "./claude-md.mjs"
+import { syncClaudeMdWithHub } from "./claude-md-sync.mjs"
+import { createSessionBudget } from "./hub-request-deadline.mjs"
+
+// HUB_PROJECTS_BASE は実行時に解決する。テストや起動環境で
+// `process.env.HUB_PROJECTS_BASE` を上書きできるよう、import 時に
+// const として固定しない (tests/tmux.test.mjs が動的に差し替えるため)。
+export function hubProjectsBase() {
+  return process.env.HUB_PROJECTS_BASE || path.join(os.homedir(), "hub", "projects")
+}
+
+/**
+ * 先頭の `~` / `~/` を `os.homedir()` に展開する。
+ *
+ * tmux は `-c` に渡された cwd をシェル展開しないため、フロントから
+ * 受け取った `~/hub/projects/...` を絶対パスに変換する必要がある。
+ * 既に絶対パス / 相対パスなら noop。
+ */
+export function expandTilde(p) {
+  if (typeof p !== "string" || p.length === 0) return p
+  if (p === "~") return os.homedir()
+  if (p.startsWith("~/")) return path.join(os.homedir(), p.slice(2))
+  return p
+}
+
+/**
+ * 絶対パス `p` が HUB_PROJECTS_BASE 配下かを判定する。
+ *
+ * `createSession` の cwd 自動作成判定で使う。base そのもの (`~/hub/projects`)
+ * は対象外とし、配下のサブディレクトリのみ true を返す。`path.relative` で
+ * `..` を含まないかチェックすることで `/Users/.../hub/projects-backup` のような
+ * 接頭辞一致のみの誤検知を排除する。
+ */
+export function isUnderHubProjectsBase(p) {
+  if (typeof p !== "string" || p.length === 0) return false
+  const abs = path.resolve(p)
+  const base = path.resolve(hubProjectsBase())
+  if (abs === base) return false
+  const rel = path.relative(base, abs)
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return false
+  return true
+}
+
+/**
+ * Hub workspace またはその worktree から、案件指示ファイルを置く親 workspace を返す。
+ * worktree 内の AGENTS.md / CLAUDE.md を別管理すると Hub 正本が分岐するため、
+ * `<workspace>/.claude/worktrees/<name>` で起動しても常に `<workspace>` を対象にする。
+ */
+export function projectInstructionDir(p) {
+  if (!isUnderHubProjectsBase(p)) return path.resolve(p)
+  const base = path.resolve(hubProjectsBase())
+  const [workspace] = path.relative(base, path.resolve(p)).split(path.sep)
+  return path.join(base, workspace)
+}
+
+// 親 workspace を共有する worktree も含め、同じ指示書への更新を直列化する。
+const preparations = new Map()
+
+/**
+ * 指示書が実際に使える状態かを **ディスクの実体**で判定する。
+ *
+ * ⚠️ 同期処理の戻り値や「例外が出なかったこと」で判定しない。`ensureClaudeMd` /
+ * `syncClaudeMdWithHub` は失敗を warn に潰して **正常終了**するため、EACCES 等で 1 行も
+ * 書けていなくても呼び出し側からは成功に見える（それが「未準備のまま会話を開く」の原因）。
+ * ⚠️ HUB_PROJECTS_BASE の外は同期の対象外なので常に利用可能として扱う。同期しない cwd を
+ * 「未準備」と判定すると、通常の作業ディレクトリで会話を開けなくなる。
+ * ⚠️ 見るのは「通常ファイルとして実在し、実行ユーザーが読めること」だけで、Hub との内容一致は
+ * 条件にしない。Hub が落ちていても、既にローカルにある指示書が読めるならその会話は開いてよい。
+ * ⚠️ 実在だけでは足りない。読めない指示書 (mode 000 等) は stat を通るうえ、`ensureClaudeMd` の
+ * 存在確認 (claude-md.mjs:300 の `fs.access`) も既定では存在しか見ないため「既存」と扱われる。
+ * 結果として CLI 側は 1 行も読めないのに準備成功になる。
+ */
+async function instructionsAvailable(resolvedCwd, opts) {
+  if (!isUnderHubProjectsBase(resolvedCwd)) return true
+  const configFilename = opts.cliKind === "codex" ? "AGENTS.md" : "CLAUDE.md"
+  const file = path.join(projectInstructionDir(resolvedCwd), configFilename)
+  try {
+    // ディレクトリや symlink 先の欠落を「使える」と読まないため、通常ファイルであることを先に見る。
+    if (!(await fs.stat(file)).isFile()) return false
+    // ⚠️ ここで open せず access を使う。実際に読むのは別プロセス (CLI) なので、こちらが
+    // ハンドルを持つ理由がなく、持てば閉じ忘れの経路が増えるだけになる。
+    await fs.access(file, fs.constants.R_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * ローカル準備後、既定では Hub 同期も待つ。
+ * `sync` は **指示書が使えるか (boolean)** に解決し、同期自体の失敗では reject しない。
+ *
+ * @param {number} [budgetMs] Hub 同期に使ってよい wall-clock (既定 `SESSION_BUDGET_MS`)。
+ *   ⚠️ **同じ親 workspace の先行要求を待つ時間も含めて**数える（下の予算生成位置を参照）。
+ */
+export async function prepareChatWorkspace({ cwd, session: name, waitForSync = true, budgetMs, ...opts }) {
+  const resolvedCwd = expandTilde(cwd)
+  await prepareLocalWorkspace(resolvedCwd, name, opts)
+  const key = projectInstructionDir(resolvedCwd)
+  const previous = preparations.get(key) || Promise.resolve()
+  // ⚠️ 予算は **キューに並ぶ前**に作る。同じ親 workspace の同期は直列化されるので、予算を
+  // syncWorkspace の中で作ると先行要求を待った時間が予算の外に出て、待ち行列の長さぶん
+  // 起動の停止時間が伸びる（tmux 側は sync 全体を待つ）。予算は生成時からの wall-clock
+  // なので、ここで作れば待機もそのまま期限に含まれる。切れたら Hub 往復を行わず次回へ持ち越す。
+  const budget = isUnderHubProjectsBase(resolvedCwd) ? createSessionBudget(budgetMs) : null
+  const sync = previous.catch(() => {})
+    .then(() => syncWorkspace(resolvedCwd, name, { ...opts, budget }))
+    .catch((err) => {
+      opts.logger?.warn?.(
+        { session: name, cwd: resolvedCwd, err: err?.message || String(err) },
+        "workspace sync failed (session starts anyway)",
+      )
+    })
+    // ⚠️ 同期の「正常終了」を準備成功と読み替えない。上の catch は syncWorkspace が
+    // 例外を投げたときしか通らず、内部で warn に潰された書込失敗はここまで来ない。
+    .then(() => instructionsAvailable(resolvedCwd, opts))
+    .finally(() => {
+      budget?.clear()
+      if (preparations.get(key) === sync) preparations.delete(key)
+    })
+  preparations.set(key, sync)
+  if (waitForSync) await sync
+  return { cwd: resolvedCwd, sync }
+}
+
+function isWorktreePath(resolvedCwd) {
+  const relative = path.relative(path.resolve(hubProjectsBase()), path.resolve(resolvedCwd))
+  const segments = relative.split(path.sep)
+  if (path.isAbsolute(relative) || segments.includes("..")) return false
+  return segments.some((segment, i) =>
+    segment === ".claude" && segments[i + 1] === "worktrees" && i + 2 < segments.length)
+}
+
+export function isCwdUnavailableError(err) {
+  return err?.code === "CWD_UNAVAILABLE"
+}
+
+function cwdUnavailableError(message) {
+  return Object.assign(new Error(message), { code: "CWD_UNAVAILABLE" })
+}
+
+async function prepareLocalWorkspace(resolvedCwd, name, opts) {
+  // cwd 存在チェック (旧 Cockpit 単体実装と同等の防御)
+  // 無いまま tmux に渡すと pane の current_path が HOME など別ディレクトリに
+  // fallback して、SessionStart hook が project を解決できなくなる。
+  //
+  // 例外: 解決後のパスが HUB_PROJECTS_BASE 配下 (= 案件 workspace ディレクトリ)
+  // なら、未 clone のメンバー Mac でも cockpit から起動できるよう mkdir -p で
+  // 自動生成する。任意の絶対パス (leader cwd 等) や HUB_PROJECTS_BASE 外は
+  // 引き続き `cwd not found` を返し、誤った workspace 起動を防ぐ。
+  try {
+    const st = await fs.stat(resolvedCwd)
+    if (!st.isDirectory()) throw cwdUnavailableError("cwd not a directory")
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      // worktree は git が作るもの。mkdir では .git の無い偽物ができるだけである。
+      // 2026-09-16 の実測でも、消えた worktree の準備が成功し .git の無いディレクトリができた。
+      // 削除と起動が並行すると、この mkdir が削除直後に復活させ、git worktree remove が
+      // 成功しても残骸を残す。自動生成の目的は未 clone のメンバー Mac で案件 workspace を
+      // 開けるようにすることであり、git が管理する worktree を作る理由はない。
+      if (isUnderHubProjectsBase(resolvedCwd) && !isWorktreePath(resolvedCwd)) {
+        try {
+          await fs.mkdir(resolvedCwd, { recursive: true })
+          opts.logger?.info?.(
+            { session: name, cwd: resolvedCwd },
+            "auto-created workspace dir before tmux new-session",
+          )
+        } catch (mkdirErr) {
+          // 原因が一時的でも、いま cwd が無ければ会話は登録できない。
+          // 登録すると live・配送対象に載り、送信が delivered を返してしまう。
+          // ただし並行する別経路の生成を無条件で弾かないよう、現在の状態を再確認する。
+          const st = await fs.stat(resolvedCwd).catch(() => null)
+          if (st?.isDirectory()) {
+            opts.logger?.warn?.(
+              { session: name, cwd: resolvedCwd, err: mkdirErr?.message || String(mkdirErr) },
+              "workspace mkdir failed, but directory already exists",
+            )
+            return
+          }
+          throw cwdUnavailableError(
+            `cwd mkdir failed: ${mkdirErr?.message || String(mkdirErr)}`,
+          )
+        }
+      } else {
+        throw cwdUnavailableError(`cwd not found: ${resolvedCwd}`)
+      }
+    } else if (err?.code === "ENOTDIR") {
+      throw cwdUnavailableError("cwd not a directory")
+    } else if (isCwdUnavailableError(err)) {
+      throw err
+    } else {
+      // stat の失敗だけでは cwd が使えないと確定できないため、印を付けない。
+      throw new Error(`cwd stat failed: ${err?.message || String(err)}`)
+    }
+  }
+}
+
+async function syncWorkspace(resolvedCwd, name, opts) {
+  // HUB_PROJECTS_BASE 配下の workspace の場合は CLAUDE.md を必要なら生成し、
+  // Hub の正本（Project.claude_md）から受け取る。
+  // - ensureClaudeMd: 既存 CLAUDE.md は触らない。無ければ director frontmatter
+  //   または placeholder を生成する。
+  // - syncClaudeMdWithHub: **受け取り専用**。Hub 側更新はローカルへ pull（.bak 退避
+  //   してから上書き）、端末側で編集されていても Hub へは送り返さない（正本は
+  //   プレースホルダ入りで、端末にあるのはそのレンダリング結果のため）。乖離は
+  //   warn ＋ `config-md-receive-only-drift` で見える形に残す。唯一の例外が
+  //   **初回登録**（Hub の正本が空 + そのファイルが元からあった場合に 1 度だけ push）。
+  //   Hub が一度も保存されていないプロジェクトでは何もしない（テナント標準
+  //   CLAUDE.md の運用を尊重する）。
+  // どちらも失敗しても session 起動自体は止めない (warn のみ)。
+  // ⚠️ 2 つの呼び出しで **1 本の budget を共有**する。1 往復ごとの期限だけでは
+  //   往復の本数ぶん足し算されてセッション起動が長時間止まりうるため、Hub 処理に
+  //   割り当てた wall-clock 予算（予算の生成時からの経過時間で、通信の待ち時間の
+  //   累積ではない）で全体を打ち切る。予算切れなら「何も書かずに次回へ持ち越す」。
+  if (isUnderHubProjectsBase(resolvedCwd)) {
+    const instructionDir = projectInstructionDir(resolvedCwd)
+    const dirName = path.basename(instructionDir)
+    const configFilename = opts.cliKind === "codex" ? "AGENTS.md" : "CLAUDE.md"
+    // ⚠️ 予算は呼び出し側 (prepareChatWorkspace) が **キューに並ぶ前**に作って所有する。
+    // ここで作ると先行要求を待った時間が予算の外に出る。後片付けも所有者側で行うので、
+    // 受け取った予算は clear しない（自前で作った場合だけ後始末する）。
+    const budget = opts.budget || createSessionBudget()
+    const ownsBudget = !opts.budget
+    // ⚠️ `ensureClaudeMd` の戻り値を捨てない。`source === 'existing'` は
+    // 「このセッションより前からローカルにファイルがあった」＝ **初回登録**
+    // （Hub に無くローカルにあるものを 1 度だけ Hub へ取り込む）の唯一の根拠で、
+    // ディスクに残さずここから同期へ手渡す。例外時は **undefined のまま渡さない**
+    // （＝登録しない。何が起きたか分からない回に Hub を触らせない安全側）。
+    let localFilePreexisted
+    try {
+      try {
+        const ensure = await ensureClaudeMd({
+          targetDir: instructionDir,
+          dirName,
+          hubUrl: opts.hubUrl,
+          accessToken: opts.hubAccessToken,
+          logger: opts.logger,
+          fetchImpl: opts.fetchImpl,
+          configFilename,
+          budget,
+        })
+        localFilePreexisted = ensure?.source === "existing"
+      } catch (err) {
+        opts.logger?.warn?.(
+          { session: name, cwd: resolvedCwd, err: err?.message || String(err) },
+          "ensureClaudeMd failed (workspace dir is usable, but no CLAUDE.md)",
+        )
+      }
+      try {
+        const syncResult = await syncClaudeMdWithHub({
+          targetDir: instructionDir,
+          dirName,
+          hubUrl: opts.hubUrl,
+          accessToken: opts.hubAccessToken,
+          logger: opts.logger,
+          fetchImpl: opts.fetchImpl,
+          configFilename,
+          budget,
+          // undefined のときはキーごと渡さない（呼び出し側の意図を明示する）。
+          ...(localFilePreexisted === undefined ? {} : { localFilePreexisted }),
+        })
+        opts.logger?.debug?.(
+          { session: name, dirName, sync: syncResult },
+          "syncClaudeMdWithHub completed",
+        )
+      } catch (err) {
+        opts.logger?.warn?.(
+          { session: name, cwd: resolvedCwd, err: err?.message || String(err) },
+          "syncClaudeMdWithHub failed (session starts anyway)",
+        )
+      }
+    } finally {
+      if (ownsBudget) budget.clear()
+    }
+  }
+}

package/src/claude-stream-bridge.mjs

@@ -22,6 +22,7 @@ import { randomUUID } from "node:crypto"
 import { readFileSync } from "node:fs"
 import os from "node:os"
 import path from "node:path"
+import { isUnderRemoval } from "./chat-removal-guard.mjs"
 
 import { jsonlPath } from "./claude-history.mjs"
 import { watchSessionFile } from "./claude-history-watch.mjs"
@@ -2710,10 +2711,14 @@ export class ClaudeStreamBridge extends EventEmitter {
    * SDK セッションを生かしたままだと同一 cwd の jsonl を二重ホストして競合する
    * (DESIGN.md C7)。soft-detach (7 日 resident) では止まらないので、ここで明示 close する。
    *
-   * @param {{cwd?: string, session_id?: string}} sel
+   * ⚠️ `reason` は exit イベントにそのまま載る。既定の `tui-bind-stop` は上記 TUI bind 用の
+   * 名前なので、**TUI 以外の理由で止めるときは必ず渡す**こと (既定のままだと、存在しない
+   * tmux 連携のせいで会話が消えたように見え、原因追跡が別経路へ逸れる)。
+   *
+   * @param {{cwd?: string, session_id?: string, reason?: string}} sel
    * @returns {number} 停止したセッション数
    */
-  stopSessionsFor({ cwd, session_id } = {}) {
+  stopSessionsFor({ cwd, session_id, reason = "tui-bind-stop" } = {}) {
     const victims = new Set()
     if (session_id) {
       // 複合キー化 (T06271) で session_id 単独では引けないため values を走査して拾う。
@@ -2757,7 +2762,7 @@ export class ClaudeStreamBridge extends EventEmitter {
       this.emit("exit", {
         stream_id: s.stream_id,
         code: 0,
-        reason: "tui-bind-stop",
+        reason,
         session_id: s.sessionId,
       })
       stopped++
@@ -2767,7 +2772,7 @@ export class ClaudeStreamBridge extends EventEmitter {
 
   /** cwd と session_id が完全一致する live セッションだけを停止し、CLI 終了まで待つ。
    *  戻り値は今回新たに停止した数 (tombstone の待ち直しは数えない)。timeout は throw。 */
-  async stopSessionForDeletion({ cwd, session_id }) {
+  async stopSessionForDeletion({ cwd, session_id, reason = "session-deleted" }) {
     const key = this._liveKeyFor(cwd, session_id)
     const newVictims = new Set()
     for (const s of [...this._liveBySession.values(), ...this.sessions.values()]) {
@@ -2802,7 +2807,7 @@ export class ClaudeStreamBridge extends EventEmitter {
         this.emit("exit", {
           stream_id: s.stream_id,
           code: 0,
-          reason: "session-deleted",
+          reason,
           session_id: s.sessionId,
         })
       }
@@ -2860,6 +2865,7 @@ export class ClaudeStreamBridge extends EventEmitter {
     // cwd を 1 回だけ解決し、reattach lookup / session 生成 / 索引登録で同じ値を使う
     // (複合キーの整合性を保つため)。
     const scwd = cwd || process.env.HOME || process.cwd()
+    if (isUnderRemoval(scwd)) throw new Error(`worktree removal in progress: ${scwd}`)
     // 常駐化: resume_session_id が示すセッションが (走行中 / idle 問わず) まだ生存していれば、
     // 新規 query を起動せずそのセッションへ再アタッチする。これにより端末スリープ/再接続でも
     // ターンは落ちず、以降のイベントは新しい stream_id 経由でライブに流れる