@cocorograph/hub-agent 0.8.56 → 0.8.57

package/package.json

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

package/src/chat-signals.mjs

@@ -70,6 +70,11 @@ const STREAM_TICK_THROTTLE_MS = 3 * 1000
 // key → 最後に stream tick を記録した時刻 (スロットル判定用)。
 const _lastStreamTickAt = new Map()
 
+// `${cliKind}\u0000${cwd}` → チャット入力を最後に受け付けた時刻。handler が dispatch 前に同期で記録する
+// (bridge の応答を待つ間に turn/started 等で state loop が processing を観測しても、観測時刻ではなく
+// この受付時刻で prompt_submit を書けるように)。tmux 走査より先に記録するので走査失敗にも影響されない。
+const _promptAcceptedAtByKey = new Map()
+
 const VALID_STATUS = new Set(["processing", "waiting", "idle"])
 
 function _now() {
@@ -88,6 +93,19 @@ function _key(cwd, cliKind) {
   return `${normalizeCliKind(cliKind)}\u0000${cwd}`
 }
 
+/** (cwd, cliKind) の最新 prompt 受付時刻を単調に記録する。 */
+export function recordPromptAccepted(cwd, cliKind, at) {
+  const key = _key(cwd, cliKind)
+  if (!key) return
+  _promptAcceptedAtByKey.set(key, Math.max(_promptAcceptedAtByKey.get(key) ?? 0, at))
+}
+
+/** (cwd, cliKind) の最新 prompt 受付時刻を返す (無ければ undefined)。 */
+export function getPromptAcceptedAt(cwd, cliKind) {
+  const key = _key(cwd, cliKind)
+  return key ? _promptAcceptedAtByKey.get(key) : undefined
+}
+
 /**
  * チャットのアクティビティを記録する。status / context_pct は与えられた分だけ更新し、
  * turnAt (= 最終アクティビティ時刻 / ソート用) は呼ばれるたびに前進させる。
@@ -239,12 +257,14 @@ export function clearChatSignal(cwd, cliKind) {
   if (!key) return
   _byKey.delete(key)
   _lastStreamTickAt.delete(key)
+  _promptAcceptedAtByKey.delete(key)
 }
 
 /** テスト用: ストアを空にする。 */
 export function _resetChatSignals() {
   _byKey.clear()
   _lastStreamTickAt.clear()
+  _promptAcceptedAtByKey.clear()
 }
 
 export { CHAT_SIGNAL_STALE_MS, STREAM_TICK_THROTTLE_MS }

package/src/claude-stream-bridge.mjs

@@ -3890,4 +3890,8 @@ export class ClaudeStreamBridge extends EventEmitter {
     const s = this.sessions.get(stream_id)
     return s ? s.sessionId : null
   }
+
+  getCwd(stream_id) {
+    return this.sessions.get(stream_id)?.cwd ?? null
+  }
 }

package/src/codex-stream-bridge.mjs

@@ -4760,4 +4760,10 @@ export class CodexStreamBridge extends EventEmitter {
     }
     this.sessions.clear()
   }
+
+  getCwd(stream_id) {
+    const session = this.sessions.get(stream_id)
+    if (!session || session.dead) return null
+    return session.cwd ?? null
+  }
 }

package/src/main.mjs

@@ -139,8 +139,10 @@ import {
 import {
   clearChatSignal,
   getChatSignal,
+  getPromptAcceptedAt,
   recordChatActivity,
   recordChatStreamTick,
+  recordPromptAccepted,
 } from "./chat-signals.mjs"
 import { cliKindForSessionName, sessionNameFor } from "./session-names.mjs"
 import {
@@ -1686,18 +1688,31 @@ export function updateSawUserTurn(name, event) {
  * @param {number} at epoch ms
  * @returns {{ sortAffecting: boolean, sortAffectingAt: number|undefined, stale: boolean }}
  */
-export function ingestSessionEventForSort(name, event, at) {
+export function ingestSessionEventForSort(name, event, at, { fresh = false } = {}) {
   const prevAt = lastEventAtByName.get(name) ?? 0
   // stale (この session で処理済みの at より古い) read は状態を汚さない。arm や status は
   // 呼び出し側で従来通り処理してよいが、sort へは一切効かせない。
-  if (typeof at === "number" && at < prevAt) {
+  // `fresh`: in-process の直接 publish (チャット入力の受付) は out-of-order な file read ではなく
+  // 「いま起きた」event なので、この stale 判定を通さない (受付〜tmux 走査の ms 窓に state loop の
+  // stop が先に取り込まれても、人間の送信を落とさない)。sort 時刻の単調性は下の比較で保つ。
+  if (!fresh && typeof at === "number" && at < prevAt) {
     return {
       sortAffecting: false,
       sortAffectingAt: lastSortAffectingAtByName.get(name),
       stale: true,
     }
   }
-  if (typeof at === "number") lastEventAtByName.set(name, at)
+  // fresh な prompt_submit でも sort 時刻を前進させないもの (同一行への 2 送信の tmux 走査が逆順に
+  // 完了した後着の古い方、同値の再通知) は、frontend へ sort_affecting=true で流さない。frontend は
+  // 単調マージで弾くが、契約として「sort_affecting=true は sort 時刻が前進した event」に揃える。
+  if (fresh && typeof at === "number" && at <= (lastSortAffectingAtByName.get(name) ?? 0)) {
+    return {
+      sortAffecting: false,
+      sortAffectingAt: lastSortAffectingAtByName.get(name),
+      stale: true,
+    }
+  }
+  if (typeof at === "number") lastEventAtByName.set(name, Math.max(prevAt, at))
   updateSawUserTurn(name, event)
   const sortAffecting = computeSortAffecting(event, sawUserTurnByName.get(name) === true)
   // sort_affecting=true で前進したときだけ sort 時刻を更新し、sidecar に永続化する (major#1)。
@@ -1937,50 +1952,8 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
       const text = await readFile(full, "utf-8")
       const data = JSON.parse(text)
       if (!data || typeof data.event !== "string") return
-      // ターン境界 (prompt_submit / stop) で readiness tracker を arm し、子プロセスが
-      // baseline へ復帰したら 'ready' を出す土台にする。'ready' 自身では arm しない
-      // (readiness loop の書込み → 再 arm の無限ループを避ける)。prompt_submit は次ターンの
-      // ready を解禁するため emitted をリセットする。
-      if (readinessTracker) {
-        if (data.event === "prompt_submit") {
-          readinessTracker.arm(sessionName, { newTurn: true })
-        } else if (data.event === "stop" || data.event === "idle_hint") {
-          // stop: ターン論理終了。idle_hint: Notification(idle_prompt) フックの裏取り。
-          // どちらも arm するだけで、実際の 'ready' は proc 内省 (子プロセス baseline 復帰)
-          // が確定させる。これにより Notification が Stop フック完了前に発火しても、
-          // proc が clear するまで誤フラッシュしない (idle_hint→即 ready にはしない)。
-          readinessTracker.arm(sessionName)
-        }
-      }
-      // sort_affecting 判定を状態機械へ委譲する: at 単調ガードで out-of-order な stale read を
-      // 弾き (major#2)、prompt_submit/session_start で状態遷移し、sort_affecting=true なら
-      // sort 時刻を更新する (major#1)。arm や status push は従来通り (stale でも status は最新化)。
       const at = typeof data.at === "number" ? data.at : Date.now()
-      const { sortAffecting } = ingestSessionEventForSort(sessionName, data.event, at)
-      // 計装 (2026-06-19, 既定 OFF=2026-06-20): ターン境界イベントと arm を記録する。常時 info は
-      // ログ肥大の主因のため HUB_AGENT_STATE_TRACE=1 のときだけ出す(障害解析時に有効化)。
-      if (STATE_TRACE) {
-        logger?.info(
-          {
-            session_name: sessionName,
-            event: data.event,
-            armed: readinessTracker ? readinessTracker.isArmed(sessionName) : undefined,
-            sort_affecting: sortAffecting,
-          },
-          "session.event push",
-        )
-      }
-      // 直前に作った一覧 snapshot がこの event より古い場合、次の poll で last_event を
-      // 逆戻りさせない。build 中なら AsyncTtlCache が新世代へ合流し直す。
-      tmuxSessionsSnapshotCache.clear()
-      client.send({
-        type: "session.event",
-        session_name: sessionName,
-        event: data.event,
-        at,
-        // false=ライフサイクル/resume 落ち着き由来 → frontend は status のみ更新し並び順は動かさない。
-        sort_affecting: sortAffecting,
-      })
+      await publishSessionEvent({ client, readinessTracker, logger }, sessionName, data.event, at)
     } catch {
       // 一時欠如 / parse 失敗等は無視 (次の変更で読み直す)
     }
@@ -2021,6 +1994,46 @@ async function startSessionEventWatcher({ client, logger, readinessTracker }) {
   }
 }
 
+/** session-event をプロセス内で取り込み、並び順を更新して WS push する。 */
+export async function publishSessionEvent(
+  { client, readinessTracker, logger },
+  sessionName,
+  event,
+  at,
+  { fresh = false, arm = !fresh } = {},
+) {
+  // readiness (proc 内省の ready 判定) を動かすのはファイル監視経路だけ。直接 publish (fresh) は
+  // 「人間が送った」事実を並び順へ流すだけで、ターンの開始を意味しない (bridge が拒否すれば
+  // ターンは始まらないし、走査が逆順に完了した後着の古い方は既に終わったターン)。ここで arm すると
+  // 次の stop が来ない限り busy が残る。ターン境界の arm は従来どおり state loop / bundle hook が
+  // 書く event ファイル経由で行う。
+  const { sortAffecting } = ingestSessionEventForSort(sessionName, event, at, { fresh })
+  if (arm) {
+    if (event === "prompt_submit") {
+      readinessTracker?.arm(sessionName, { newTurn: true })
+    } else if (event === "stop" || event === "idle_hint") {
+      readinessTracker?.arm(sessionName)
+    }
+  }
+  if (STATE_TRACE) {
+    logger?.info?.({
+      session_name: sessionName,
+      event,
+      armed: readinessTracker ? readinessTracker.isArmed(sessionName) : undefined,
+      sort_affecting: sortAffecting,
+    }, "session.event push")
+  }
+  tmuxSessionsSnapshotCache.clear()
+  client.send({
+    type: "session.event",
+    session_name: sessionName,
+    event,
+    at,
+    sort_affecting: sortAffecting,
+  })
+  return { sortAffecting }
+}
+
 
 /**
  * arm 済みセッション (prompt_submit / stop を受けた or busy 観測中) の claude プロセスを
@@ -2414,6 +2427,71 @@ export async function pushImmediateChatState({
   }
 }
 
+/**
+ * チャット入力の受付時刻を、対応する tmux 行の prompt_submit として **in-process で** publish する。
+ *
+ * state loop の 5 秒 tick だけでは、5 秒未満で完了するターンや、終了と次の開始の間に tick が
+ * 入らない連続ターンを取りこぼし、観測できても送信時刻ではなく assistant event の時刻になる。
+ * そこで handler が入力を受け付けた瞬間 (dispatch 前) に、cwd と CLI 種別が一致する tmux 行へ
+ * publishSessionEvent(prompt_submit, 受付時刻, fresh) を流す。
+ *
+ * ファイルは書かない。並び順の正本は ingestSessionEventForSort の sidecar (poll の
+ * sort_affecting_at で復元される) で、event ファイルは status 復元用に state loop が従来どおり
+ * 書く (その prompt_submit の at は chatSessionEventForTick が受付時刻へ揃える)。直接経路が
+ * ファイルを書かないので、fs.watch の読み落とし・並行 rename・kill 中の保留書き込みといった
+ * ファイル由来の競合そのものが無い。
+ *
+ * bridge が入力を拒否した場合 (empty / queue dead 等) も publish 済みのまま取り消さない:
+ * 並び順の定義は「最後に人間が送った順」で、送信操作自体は起きているため (仕様)。
+ */
+export async function notifyChatPromptSubmit({
+  cwd,
+  cliKind,
+  at,
+  client,
+  readinessTracker,
+  plugins,
+  logger,
+  listSessionStatesFn = listSessionStates,
+  publishFn = publishSessionEvent,
+}) {
+  if (!cwd || !client) return
+  try {
+    const states = await listSessionStatesFn({ plugins, logger })
+    for (const s of states) {
+      if (s.cwd !== cwd || cliKindForSessionName(s.session_name) !== cliKind) continue
+      try {
+        await publishFn({ client, readinessTracker, logger }, s.session_name, "prompt_submit", at, { fresh: true })
+      } catch (err) {
+        logger?.warn?.({ err: err?.message, cwd, cliKind, session_name: s.session_name }, "notifyChatPromptSubmit publish failed")
+      }
+    }
+  } catch (err) {
+    logger?.warn?.({ err: err?.message, cwd, cliKind }, "notifyChatPromptSubmit failed")
+  }
+}
+
+/**
+ * chat signal から、この tick で書く session-event を導出する。
+ * FIFO で前ターンの stop 後に次ターンの processing を観測しても、prompt_submit の at は
+ * 最後に人間が送った時刻を超えない。直接 publish が失敗 (tmux 走査不能等) しても edge を抑止しないため、
+ * processing 観測時に同じ at で回復できる。同値 at の重複は ingest の単調ガードで無害。
+ *
+ * @returns {{ev: string, at: number}|null}
+ */
+export function chatSessionEventForTick({ chat, prevEv, prevTurnAt, directAt }) {
+  const ev = chat.inputPending
+    ? "input_required"
+    : chat.status === "processing"
+      ? "prompt_submit"
+      : "stop"
+  if (!(chat.turnAt > prevTurnAt && ev !== prevEv)) return null
+  const at = ev === "prompt_submit" && typeof directAt === "number" && directAt > 0
+    ? directAt
+    : chat.turnAt
+  return { ev, at }
+}
+
 /**
  * turnActiveForCwd / jsonlContextForCwd に渡す bound session_id を解決する純関数。
  *
@@ -2588,17 +2666,19 @@ export function startStateLoop({ client, plugins, logger, intervalMs, claudeBrid
           //
           // 確認待ち (inputPending) は専用 event "input_required"、生成中は "prompt_submit"、
           // それ以外は "stop"。並び順に効くのは computeSortAffecting により prompt_submit だけ。
-          const ev = chat.inputPending
-            ? "input_required"
-            : chat.status === "processing"
-              ? "prompt_submit"
-              : "stop"
           const prevTurnAt = lastTurnAtByName.get(s.session_name) || 0
           const prevEv = lastChatEventByName.get(s.session_name)
-          if (chat.turnAt > prevTurnAt && ev !== prevEv) {
+          const eventForTick = chatSessionEventForTick({
+            chat,
+            prevEv,
+            prevTurnAt,
+            directAt: s.cwd ? getPromptAcceptedAt(s.cwd, sessionCliKind) : undefined,
+          })
+          if (eventForTick) {
+            const { ev, at } = eventForTick
             lastTurnAtByName.set(s.session_name, chat.turnAt)
             lastChatEventByName.set(s.session_name, ev)
-            writeSessionEventFile(s.session_name, ev, chat.turnAt).catch(() => {})
+            writeSessionEventFile(s.session_name, ev, at).catch(() => {})
           }
         }
         // 内容安定で「確実に停止」と判定できたか (frontend が 2 サンプル消灯確認を省いて
@@ -3126,6 +3206,7 @@ function inputLifecycleRejection(ctx) {
  * テストから直接呼べるよう dispatch から切り出して export する。
  */
 export function handleClaudeChatInput(msg, ctx) {
+  const acceptedAt = Date.now()
   const stream_id = msg.stream_id
   const input_id = typeof msg.input_id === "string" && msg.input_id ? msg.input_id : null
   if (!ctx.claudeBridge) {
@@ -3174,6 +3255,26 @@ export function handleClaudeChatInput(msg, ctx) {
     }
     return undefined
   }
+  // cwd は dispatch 前に確定する (Promise 解決後に引くと、その間に stream が別 cwd へ再 attach
+  // された場合に別行へ記録する)。受付時刻の記録と並び順の publish も dispatch **前** に行う:
+  // Claude の resident reconcile / Codex の turn/start RPC が未解決の間に assistant / turn/started
+  // が先に届いて state loop が processing を観測しても、記録済みなら観測時刻ではなく受付時刻で
+  // 書かれる。bridge が拒否しても取り消さない (仕様。notifyChatPromptSubmit の JSDoc)。
+  const cwdSnapshot = ctx.claudeBridge.getCwd?.(stream_id) ?? null
+  if (cwdSnapshot) {
+    recordPromptAccepted(cwdSnapshot, "claude", acceptedAt)
+    notifyChatPromptSubmit({
+      cwd: cwdSnapshot,
+      cliKind: "claude",
+      at: acceptedAt,
+      plugins: ctx.plugins,
+      logger: ctx.logger,
+      client: ctx.client,
+      readinessTracker: ctx.readinessTracker,
+      listSessionStatesFn: ctx._listSessionStates || listSessionStates,
+      publishFn: ctx._publishSessionEvent || publishSessionEvent,
+    }).catch(() => {})
+  }
   const p = ctx.claudeBridge
     .input({
       stream_id,
@@ -3398,6 +3499,7 @@ export function buildAttachHistoryPromise({
  * テストから直接呼べるよう dispatch から切り出して export する。
  */
 export function handleCodexChatInput(msg, ctx) {
+  const acceptedAt = Date.now()
   const stream_id = msg.stream_id
   const input_id = typeof msg.input_id === "string" && msg.input_id ? msg.input_id : null
   if (!ctx.codexBridge) {
@@ -3438,6 +3540,23 @@ export function handleCodexChatInput(msg, ctx) {
     })
     return undefined
   }
+  // claude 側と同じ理由で dispatch 前に cwd を確定し、受付時刻の記録と publish を行う
+  // (handleClaudeChatInput のコメント参照)。
+  const cwdSnapshot = ctx.codexBridge.getCwd?.(stream_id) ?? null
+  if (cwdSnapshot) {
+    recordPromptAccepted(cwdSnapshot, "codex", acceptedAt)
+    notifyChatPromptSubmit({
+      cwd: cwdSnapshot,
+      cliKind: "codex",
+      at: acceptedAt,
+      plugins: ctx.plugins,
+      logger: ctx.logger,
+      client: ctx.client,
+      readinessTracker: ctx.readinessTracker,
+      listSessionStatesFn: ctx._listSessionStates || listSessionStates,
+      publishFn: ctx._publishSessionEvent || publishSessionEvent,
+    }).catch(() => {})
+  }
   const p = ctx.codexBridge
     .input({
       stream_id,