thinkpool-pair 0.7.363 → 0.7.365

package/flow-worktree.mjs

@@ -1,71 +1 @@
-// Thinkpool Flow — per-lane git worktree isolation.
-//
-// A Flow task-lane builds its slice in its OWN worktree. A branch is NOT isolation
-// when ≥2 lanes share one working tree (M57) — two lanes editing files in the shared
-// checkout collide. A worktree gives each lane a disjoint tree + its own branch, and
-// that branch is the atomic-revert target (commit_sha on flow_tasks, Step 4).
-//
-// Pure over injected git/fs so it's unit-testable against a temp repo.
-// Spec: docs/specs/2026-06-29-thinkpool-flow.md (Step 2).
-
-import { execFileSync } from 'node:child_process'
-import path from 'node:path'
-import fs from 'node:fs'
-import { linkLocalEnvIntoWorktree } from './lane-worktree.mjs'
-
-const ROOT = process.cwd()   // the bridge's checkout (the shared main repo root)
-
-// The lane's branch + directory for a (flowId, taskKey). Deterministic so a
-// re-dispatch of the same task reuses the same worktree.
-export function worktreeSpec ({ flowId, taskKey, root = ROOT }) {
-  const wtRoot = path.join(root, '.claude', 'worktrees')
-  const short = String(flowId).replace(/-/g, '').slice(0, 8)
-  const safeKey = String(taskKey).toLowerCase().replace(/[^a-z0-9-]/g, '-').slice(0, 40).replace(/^-+|-+$/g, '') || 'task'
-  const branch = `flow/${short}/${safeKey}`
-  const dir = path.join(wtRoot, `flow-${short}-${safeKey}`)
-  return { branch, dir, wtRoot }
-}
-
-// Create a worktree for a task-lane off `base`. Idempotent: if the dir already holds a
-// worktree, reuse it. Returns { dir, branch, created }.
-//
-// FL-M6/dispatch — the base must RESOLVE in this repo. The old hard default `origin/main`
-// threw on any repo without an `origin` remote or a non-`main` default branch (e.g. a
-// fresh `git init` checkout), and the dispatch loop swallowed the throw → NO lane ever
-// spawned. Resolve the first ref that actually exists: caller's base → origin/main →
-// origin/HEAD → main → master → HEAD.
-export function createFlowWorktree ({ flowId, taskKey, base = null, root = ROOT, git = runGit, fsImpl = fs }) {
-  const { branch, dir, wtRoot } = worktreeSpec({ flowId, taskKey, root })
-  if (fsImpl.existsSync(path.join(dir, '.git'))) {
-    linkLocalEnvIntoWorktree({ root, dir, fsImpl })
-    return { dir, branch, created: false }
-  }
-  fsImpl.mkdirSync(wtRoot, { recursive: true })
-  let ref = base
-  if (!ref) {
-    for (const cand of ['origin/main', 'origin/HEAD', 'main', 'master', 'HEAD']) {
-      try { git(['rev-parse', '--verify', '--quiet', cand], root); ref = cand; break } catch { /* try next candidate */ }
-    }
-    ref = ref || 'HEAD'
-  }
-  try {
-    git(['worktree', 'add', '-b', branch, dir, ref], root)
-  } catch {
-    // Branch already exists (a prior dispatch of this task) — check it out instead.
-    git(['worktree', 'add', dir, branch], root)
-  }
-  linkLocalEnvIntoWorktree({ root, dir, fsImpl })
-  return { dir, branch, created: true }
-}
-
-// Remove a lane's worktree + delete its branch (on revert / cancel / flow cancel).
-// Best-effort: missing worktree/branch is not an error.
-export function removeFlowWorktree ({ flowId, taskKey, root = ROOT, git = runGit }) {
-  const { branch, dir } = worktreeSpec({ flowId, taskKey, root })
-  try { git(['worktree', 'remove', dir, '--force'], root) } catch { /* already gone */ }
-  try { git(['branch', '-D', branch], root) } catch { /* already gone */ }
-}
-
-function runGit (args, cwd) {
-  return execFileSync('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' })
-}
+import{execFileSync as r}from"node:child_process";import e from"node:path";import o from"node:fs";import{linkLocalEnvIntoWorktree as t}from"./lane-worktree.mjs";const c=process.cwd();export function worktreeSpec({flowId:r,taskKey:o,root:t=c}){const i=e.join(t,".claude","worktrees"),n=String(r).replace(/-/g,"").slice(0,8),a=String(o).toLowerCase().replace(/[^a-z0-9-]/g,"-").slice(0,40).replace(/^-+|-+$/g,"")||"task";return{branch:`flow/${n}/${a}`,dir:e.join(i,`flow-${n}-${a}`),wtRoot:i}}export function createFlowWorktree({flowId:r,taskKey:n,base:a=null,root:s=c,git:d=i,fsImpl:f=o}){const{branch:p,dir:l,wtRoot:w}=worktreeSpec({flowId:r,taskKey:n,root:s});if(f.existsSync(e.join(l,".git")))return t({root:s,dir:l,fsImpl:f}),{dir:l,branch:p,created:!1};f.mkdirSync(w,{recursive:!0});let k=a;if(!k){for(const r of["origin/main","origin/HEAD","main","master","HEAD"])try{d(["rev-parse","--verify","--quiet",r],s),k=r;break}catch{}k=k||"HEAD"}try{d(["worktree","add","-b",p,l,k],s)}catch{d(["worktree","add",l,p],s)}return t({root:s,dir:l,fsImpl:f}),{dir:l,branch:p,created:!0}}export function removeFlowWorktree({flowId:r,taskKey:e,root:o=c,git:t=i}){const{branch:n,dir:a}=worktreeSpec({flowId:r,taskKey:e,root:o});try{t(["worktree","remove",a,"--force"],o)}catch{}try{t(["branch","-D",n],o)}catch{}}function i(e,o){return r("git",e,{cwd:o,stdio:["ignore","pipe","pipe"],encoding:"utf8"})}

package/git-diff-report.mjs

@@ -1,121 +1 @@
-import { execFileSync } from 'node:child_process'
-
-const DEFAULT_MAX_FILES = 24
-const DEFAULT_MAX_COMMITS = 5
-const DEFAULT_MAX_CHARS = 1800
-
-const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`
-
-function defaultRunGit(args, cwd) {
-  return execFileSync('git', args, {
-    cwd,
-    encoding: 'utf8',
-    timeout: 3000,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-}
-
-function cleanLine(value, max = 240) {
-  return Array.from(String(value || ''), (character) => {
-    const code = character.charCodeAt(0)
-    const removableControl = (code <= 0x1f && code !== 0x09 && code !== 0x0a && code !== 0x0d) || code === 0x7f
-    return removableControl ? '' : character
-  }).join('')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, max)
-}
-
-function gitText(runGit, cwd, args) {
-  return String(runGit(args, cwd) || '').trim()
-}
-
-function tryGit(runGit, cwd, args) {
-  try { return gitText(runGit, cwd, args) } catch { return '' }
-}
-
-function resolveComparisonRef(runGit, cwd) {
-  const remoteHead = tryGit(runGit, cwd, ['symbolic-ref', '--quiet', '--short', 'refs/remotes/origin/HEAD'])
-  if (remoteHead && tryGit(runGit, cwd, ['rev-parse', '--verify', '--quiet', remoteHead])) return remoteHead
-  for (const candidate of ['origin/main', 'origin/master', 'main', 'master']) {
-    if (tryGit(runGit, cwd, ['rev-parse', '--verify', '--quiet', candidate])) return candidate
-  }
-  return ''
-}
-
-function boundedReport(lines, maxChars) {
-  const kept = []
-  let length = 0
-  for (const raw of lines) {
-    const line = cleanLine(raw)
-    if (!line) continue
-    const nextLength = length + (kept.length ? 1 : 0) + line.length
-    if (nextLength > maxChars) {
-      const suffix = '… output shortened'
-      if (length + (kept.length ? 1 : 0) + suffix.length <= maxChars) kept.push(suffix)
-      break
-    }
-    kept.push(line)
-    length = nextLength
-  }
-  return kept.join('\n')
-}
-
-export function gitDiffReport({
-  cwd = process.cwd(),
-  runGit = defaultRunGit,
-  maxFiles = DEFAULT_MAX_FILES,
-  maxCommits = DEFAULT_MAX_COMMITS,
-  maxChars = DEFAULT_MAX_CHARS,
-} = {}) {
-  gitText(runGit, cwd, ['rev-parse', '--show-toplevel'])
-
-  const status = tryGit(runGit, cwd, ['status', '--porcelain=v1', '--untracked-files=normal'])
-  const statusLines = status ? status.split(/\r?\n/).filter(Boolean) : []
-  const branch = tryGit(runGit, cwd, ['symbolic-ref', '--quiet', '--short', 'HEAD']) || 'detached HEAD'
-  const head = tryGit(runGit, cwd, ['rev-parse', '--short=8', 'HEAD']) || 'unknown'
-  const subject = cleanLine(tryGit(runGit, cwd, ['log', '-1', '--pretty=%s']), 160)
-  const comparisonRef = resolveComparisonRef(runGit, cwd)
-  const lines = []
-
-  if (statusLines.length) {
-    lines.push(`${plural(statusLines.length, 'uncommitted file')}`)
-    for (const line of statusLines.slice(0, Math.max(0, maxFiles))) lines.push(line)
-    if (statusLines.length > maxFiles) lines.push(`… ${plural(statusLines.length - maxFiles, 'more file')}`)
-  } else {
-    lines.push('No uncommitted changes')
-  }
-
-  lines.push(`Branch · ${branch} · ${head}`)
-
-  if (!comparisonRef) {
-    if (subject) lines.push(`Latest commit · ${head} — ${subject}`)
-    return boundedReport(lines, maxChars)
-  }
-
-  const counts = tryGit(runGit, cwd, ['rev-list', '--left-right', '--count', `${comparisonRef}...HEAD`])
-    .split(/\s+/)
-    .map((value) => Number(value))
-  const behind = Number.isFinite(counts[0]) ? counts[0] : 0
-  const ahead = Number.isFinite(counts[1]) ? counts[1] : 0
-
-  if (ahead > 0) {
-    lines.push(`${plural(ahead, 'commit')} ahead of ${comparisonRef}${behind ? ` · ${plural(behind, 'commit')} behind` : ''}`)
-    const commitLines = tryGit(runGit, cwd, ['log', `--max-count=${Math.max(0, maxCommits)}`, '--pretty=%h %s', `${comparisonRef}..HEAD`])
-      .split(/\r?\n/)
-      .filter(Boolean)
-    if (commitLines.length) {
-      lines.push(`Commits not in ${comparisonRef}`)
-      lines.push(...commitLines)
-      if (ahead > commitLines.length) lines.push(`… ${plural(ahead - commitLines.length, 'more commit')}`)
-    }
-  } else if (behind > 0) {
-    if (subject) lines.push(`Latest commit · ${head} — ${subject} · already in ${comparisonRef}`)
-    lines.push(`${plural(behind, 'commit')} behind ${comparisonRef}`)
-  } else {
-    if (subject) lines.push(`Latest commit · ${head} — ${subject}`)
-    lines.push(`Up to date with ${comparisonRef}`)
-  }
-
-  return boundedReport(lines, maxChars)
-}
+import{execFileSync as t}from"node:child_process";const e=(t,e)=>`${t} ${e}${1===t?"":"s"}`;function n(e,n){return t("git",e,{cwd:n,encoding:"utf8",timeout:3e3,stdio:["ignore","pipe","pipe"]})}function r(t,e=240){return Array.from(String(t||""),t=>{const e=t.charCodeAt(0);return e<=31&&9!==e&&10!==e&&13!==e||127===e?"":t}).join("").replace(/\s+/g," ").trim().slice(0,e)}function i(t,e,n){return String(t(n,e)||"").trim()}function o(t,e,n){try{return i(t,e,n)}catch{return""}}function s(t,e){const n=[];let i=0;for(const o of t){const t=r(o);if(!t)continue;const s=i+(n.length?1:0)+t.length;if(s>e){const t="… output shortened";i+(n.length?1:0)+t.length<=e&&n.push(t);break}n.push(t),i=s}return n.join("\n")}export function gitDiffReport({cwd:t=process.cwd(),runGit:u=n,maxFiles:c=24,maxCommits:m=5,maxChars:h=1800}={}){i(u,t,["rev-parse","--show-toplevel"]);const a=o(u,t,["status","--porcelain=v1","--untracked-files=normal"]),l=a?a.split(/\r?\n/).filter(Boolean):[],p=o(u,t,["symbolic-ref","--quiet","--short","HEAD"])||"detached HEAD",f=o(u,t,["rev-parse","--short=8","HEAD"])||"unknown",$=r(o(u,t,["log","-1","--pretty=%s"]),160),g=function(t,e){const n=o(t,e,["symbolic-ref","--quiet","--short","refs/remotes/origin/HEAD"]);if(n&&o(t,e,["rev-parse","--verify","--quiet",n]))return n;for(const n of["origin/main","origin/master","main","master"])if(o(t,e,["rev-parse","--verify","--quiet",n]))return n;return""}(u,t),d=[];if(l.length){d.push(`${e(l.length,"uncommitted file")}`);for(const t of l.slice(0,Math.max(0,c)))d.push(t);l.length>c&&d.push(`… ${e(l.length-c,"more file")}`)}else d.push("No uncommitted changes");if(d.push(`Branch · ${p} · ${f}`),!g)return $&&d.push(`Latest commit · ${f} — ${$}`),s(d,h);const v=o(u,t,["rev-list","--left-right","--count",`${g}...HEAD`]).split(/\s+/).map(t=>Number(t)),y=Number.isFinite(v[0])?v[0]:0,b=Number.isFinite(v[1])?v[1]:0;if(b>0){d.push(`${e(b,"commit")} ahead of ${g}${y?` · ${e(y,"commit")} behind`:""}`);const n=o(u,t,["log",`--max-count=${Math.max(0,m)}`,"--pretty=%h %s",`${g}..HEAD`]).split(/\r?\n/).filter(Boolean);n.length&&(d.push(`Commits not in ${g}`),d.push(...n),b>n.length&&d.push(`… ${e(b-n.length,"more commit")}`))}else y>0?($&&d.push(`Latest commit · ${f} — ${$} · already in ${g}`),d.push(`${e(y,"commit")} behind ${g}`)):($&&d.push(`Latest commit · ${f} — ${$}`),d.push(`Up to date with ${g}`));return s(d,h)}

package/hermes-delegation-guard.mjs

@@ -1,15 +1,2 @@
 #!/usr/bin/env node
-// Hermes shell hook: the ACP toolset currently includes delegate_task and ACP
-// has no per-session tool exclusion. Block it before execution so all delegated
-// work remains a visible ThinkPool lane.
-let input = ''
-process.stdin.setEncoding('utf8')
-process.stdin.on('data', (chunk) => { input += chunk })
-process.stdin.on('end', () => {
-  let payload = null
-  try { payload = JSON.parse(input) } catch { /* malformed hook input fails closed below */ }
-  const blocking = !payload || payload.tool_name === 'delegate_task'
-  process.stdout.write(JSON.stringify(blocking
-    ? { action: 'block', message: 'ThinkPool blocks hidden Hermes delegation. Open visible ThinkPool lanes instead.' }
-    : {}) + '\n')
-})
+let e="";process.stdin.setEncoding("utf8"),process.stdin.on("data",s=>{e+=s}),process.stdin.on("end",()=>{let s=null;try{s=JSON.parse(e)}catch{}const n=!s||"delegate_task"===s.tool_name;process.stdout.write(JSON.stringify(n?{action:"block",message:"ThinkPool blocks hidden Hermes delegation. Open visible ThinkPool lanes instead."}:{})+"\n")});

package/hermes-event-mapper.mjs

@@ -1,194 +1 @@
-import { evidenceForToolResult } from './evidence-citations.mjs'
-
-const textOf = (content) => {
-  if (typeof content === 'string') return content
-  if (content?.type === 'text') return String(content.text || '')
-  if (content?.type === 'content') return textOf(content.content)
-  return ''
-}
-const outputText = (update) => {
-  if (typeof update?.rawOutput === 'string') return update.rawOutput
-  const text = (update?.content || []).map(textOf).filter(Boolean).join('\n')
-  if (text) return text
-  if (update?.rawOutput != null) {
-    try { return JSON.stringify(update.rawOutput) } catch { return String(update.rawOutput) }
-  }
-  return ''
-}
-
-const diffInput = (content) => {
-  const diffs = (Array.isArray(content) ? content : []).filter((part) => part?.type === 'diff')
-  if (!diffs.length) return null
-  if (diffs.length === 1) return {
-    file_path: diffs[0].path || '', path: diffs[0].path || '',
-    old_string: diffs[0].oldText || '', new_string: diffs[0].newText || '',
-  }
-  return {
-    file_path: diffs[0].path || '', path: diffs[0].path || '',
-    edits: diffs.map((diff) => ({ file_path: diff.path || '', old_string: diff.oldText || '', new_string: diff.newText || '' })),
-  }
-}
-
-export function hermesToolFor(update = {}) {
-  const kind = String(update.kind || '').toLowerCase()
-  const title = String(update.title || '')
-  const raw = update.rawInput && typeof update.rawInput === 'object' ? update.rawInput : {}
-  const server = String(update.server || raw.server || '')
-  const tool = String(update.tool || raw.tool || raw.name || '')
-  if (server === 'project-context' && tool === 'search_context_evidence') return { name: 'mcp__project-context__search_context_evidence', input: raw }
-  const terminal = (update.content || []).find((part) => part?.type === 'terminal')
-  const shellText = (update.content || []).map(textOf).find((text) => text.trim().startsWith('$ '))
-  const location = update.locations?.[0]?.path
-  if (kind === 'execute' || terminal || shellText) return { name: 'Bash', input: { ...raw, command: raw.command || shellText?.trim().slice(2) || title } }
-  if (kind === 'edit') {
-    const diff = diffInput(update.content)
-    const name = diff?.edits ? 'MultiEdit' : title.toLowerCase().includes('write') ? 'Write' : 'Edit'
-    return { name, input: { ...raw, ...(diff || {}), file_path: diff?.file_path || raw.path || location || '', path: diff?.path || raw.path || location || '' } }
-  }
-  if (kind === 'read') return { name: 'Read', input: { ...raw, file_path: raw.path || location || '', path: raw.path || location || '' } }
-  if (kind === 'search') return { name: 'Grep', input: raw }
-  if (kind === 'fetch') return { name: 'WebFetch', input: raw }
-  return { name: title || 'HermesTool', input: raw }
-}
-
-export class HermesEventMapper {
-  constructor({ onEvent, sessionId = null, model = null } = {}) {
-    this.onEvent = onEvent
-    this.sessionId = sessionId
-    this.model = model
-    this.tools = new Map()
-    this.text = ''
-    this.thought = ''
-    this.textCid = null
-  }
-
-  _emit(event) { try { this.onEvent?.(event) } catch { /* consumer isolation */ } }
-
-  startSession({ sessionId, models, modes, commands = [] } = {}) {
-    this.sessionId = sessionId || this.sessionId
-    this.model = models?.currentModelId || this.model
-    const list = (models?.availableModels || []).map((item) => ({ value: item.modelId, displayName: item.name || item.modelId, description: item.description || '' }))
-    this._emit({ kind: 'system', sessionId: this.sessionId, model: this.model, commands, models: list, modes })
-    if (list.length) this._emit({ kind: 'models', models: list, model: this.model })
-  }
-
-  push(params = {}) {
-    if (params.sessionId && this.sessionId && params.sessionId !== this.sessionId) return
-    const update = params.update || params
-    switch (update.sessionUpdate) {
-      case 'agent_message_chunk': {
-        const chunk = textOf(update.content)
-        if (!chunk) return
-        this.text += chunk
-        this.textCid ||= `hermes-stream:${this.sessionId || 'session'}:${Date.now()}`
-        this._emit({ kind: 'assistant_stream', cid: this.textCid, text: this.text, streaming: true })
-        return
-      }
-      case 'agent_thought_chunk':
-        this.thought += textOf(update.content)
-        return
-      case 'tool_call': {
-        const tool = hermesToolFor(update)
-        this.tools.set(update.toolCallId, { ...update, ...tool, startedAt: Date.now() })
-        this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: update.toolCallId, name: tool.name, input: tool.input }], parentToolUseId: null })
-        return
-      }
-      case 'tool_call_update': {
-        const prior = this.tools.get(update.toolCallId) || {}
-        const merged = { ...prior, ...update }
-        this.tools.set(update.toolCallId, merged)
-        if (!['completed', 'failed'].includes(update.status)) return
-        const completedTool = hermesToolFor(merged)
-        const content = [{ type: 'text', text: outputText(merged) }]
-        const evidence = evidenceForToolResult(completedTool.name, content)
-        this._emit({
-          kind: 'tool_result', toolUseId: update.toolCallId,
-          content, ...(evidence ? { evidence } : {}),
-          toolInput: { ...(prior.input || {}), ...(completedTool.input || {}) },
-          isError: update.status === 'failed',
-          durationMs: prior.startedAt ? Date.now() - prior.startedAt : undefined,
-          parentToolUseId: null,
-        })
-        this.tools.delete(update.toolCallId)
-        return
-      }
-      case 'usage_update': {
-        const used = Number(update.used) || 0
-        const max = Number(update.size) || 0
-        this._emit({ kind: 'usage', ctx: { used, max, pct: max ? Math.min(100, Math.round((used / max) * 100)) : 0, over: max > 0 && used > max, model: this.model } })
-        return
-      }
-      case 'available_commands_update':
-        // ACP commands carry useful UI metadata.  Keep strings accepted for
-        // older runtimes, but never flatten a native catalog on the way out.
-        this._emit({ kind: 'system', sessionId: this.sessionId, model: this.model, commands: (update.availableCommands || []).map((command) => {
-          if (typeof command === 'string') return command.startsWith('/') ? command : `/${command}`
-          const name = String(command?.name || '').replace(/^\/+/, '')
-          const hint = command?.input?.hint || command?.inputHint || command?.input_hint || ''
-          return {
-            name: `/${name}`,
-            description: String(command?.description || ''),
-            ...(hint ? { inputHint: String(hint) } : {}),
-          }
-        }).filter((command) => typeof command === 'string' ? command !== '/' : command.name !== '/') })
-        return
-      case 'current_mode_update':
-        this._emit({ kind: 'mode', mode: update.currentModeId })
-        return
-      case 'plan': {
-        const todos = (update.entries || []).map((entry) => ({ content: entry.content || '', activeForm: entry.content || '', status: entry.status === 'in_progress' ? 'in_progress' : entry.status === 'completed' ? 'completed' : 'pending' }))
-        this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: `hermes-plan:${this.sessionId}`, name: 'TodoWrite', input: { todos } }], parentToolUseId: null })
-        return
-      }
-      default:
-        return
-    }
-  }
-
-  finishTurn({ stopReason = 'end_turn', usage = null } = {}) {
-    for (const [toolCallId, tool] of this.tools) {
-      const cancelled = stopReason === 'cancelled'
-      this._emit({
-        kind: 'tool_result', toolUseId: toolCallId,
-        content: [{ type: 'text', text: cancelled ? '[cancelled]' : 'Hermes ended the turn without reporting this tool result.' }],
-        toolInput: tool.input || undefined,
-        isError: !cancelled && stopReason !== 'end_turn',
-        missing: !cancelled,
-        durationMs: tool.startedAt ? Date.now() - tool.startedAt : undefined,
-        parentToolUseId: null,
-      })
-    }
-    this.tools.clear()
-    const blocks = []
-    if (this.thought) blocks.push({ type: 'thinking', text: this.thought, reasoningKind: 'thought' })
-    if (this.text) blocks.push({ type: 'text', text: this.text })
-    if (blocks.length) this._emit({ kind: 'assistant', blocks, parentToolUseId: null, ...(this.textCid ? { replacesCid: this.textCid } : {}) })
-    this._emit({
-      kind: 'result', subtype: stopReason === 'cancelled' ? 'aborted' : stopReason === 'end_turn' ? 'success' : 'error_during_execution',
-      sessionId: this.sessionId, model: this.model, costUsd: null,
-      usage: usage ? {
-        input_tokens: Number(usage.inputTokens) || 0,
-        cache_read_input_tokens: Number(usage.cachedReadTokens) || 0,
-        cache_creation_input_tokens: 0,
-        output_tokens: (Number(usage.outputTokens) || 0) + (Number(usage.thoughtTokens) || 0),
-      } : null,
-      numTurns: 1, durationMs: undefined, denials: 0, resultText: this.text || null,
-    })
-    this.text = ''
-    this.thought = ''
-    this.textCid = null
-  }
-
-  compactOutcome() {
-    // /compact is handled locally by Hermes and its response is the only
-    // authoritative success signal.  Do not infer a reset from a successful
-    // ACP envelope: no-op and failure also return end_turn.
-    const text = String(this.text || '')
-    const hit = text.match(/Context compressed:\s*(\d+)\s*->\s*(\d+)\s*messages[\s\S]*?~?([\d,]+)\s*->\s*~?([\d,]+)\s*tokens/i)
-    if (!hit) return null
-    return {
-      preMessages: Number(hit[1]), postMessages: Number(hit[2]),
-      preTokens: Number(hit[3].replace(/,/g, '')), postTokens: Number(hit[4].replace(/,/g, '')),
-    }
-  }
-}
+import{evidenceForToolResult as t}from"./evidence-citations.mjs";const e=t=>"string"==typeof t?t:"text"===t?.type?String(t.text||""):"content"===t?.type?e(t.content):"",s=t=>{if("string"==typeof t?.rawOutput)return t.rawOutput;const s=(t?.content||[]).map(e).filter(Boolean).join("\n");if(s)return s;if(null!=t?.rawOutput)try{return JSON.stringify(t.rawOutput)}catch{return String(t.rawOutput)}return""};export function hermesToolFor(t={}){const s=String(t.kind||"").toLowerCase(),n=String(t.title||""),o=t.rawInput&&"object"==typeof t.rawInput?t.rawInput:{},i=String(t.server||o.server||""),r=String(t.tool||o.tool||o.name||"");if("project-context"===i&&"search_context_evidence"===r)return{name:"mcp__project-context__search_context_evidence",input:o};const a=(t.content||[]).find(t=>"terminal"===t?.type),d=(t.content||[]).map(e).find(t=>t.trim().startsWith("$ ")),l=t.locations?.[0]?.path;if("execute"===s||a||d)return{name:"Bash",input:{...o,command:o.command||d?.trim().slice(2)||n}};if("edit"===s){const e=(t=>{const e=(Array.isArray(t)?t:[]).filter(t=>"diff"===t?.type);return e.length?1===e.length?{file_path:e[0].path||"",path:e[0].path||"",old_string:e[0].oldText||"",new_string:e[0].newText||""}:{file_path:e[0].path||"",path:e[0].path||"",edits:e.map(t=>({file_path:t.path||"",old_string:t.oldText||"",new_string:t.newText||""}))}:null})(t.content);return{name:e?.edits?"MultiEdit":n.toLowerCase().includes("write")?"Write":"Edit",input:{...o,...e||{},file_path:e?.file_path||o.path||l||"",path:e?.path||o.path||l||""}}}return"read"===s?{name:"Read",input:{...o,file_path:o.path||l||"",path:o.path||l||""}}:"search"===s?{name:"Grep",input:o}:"fetch"===s?{name:"WebFetch",input:o}:{name:n||"HermesTool",input:o}}export class HermesEventMapper{constructor({onEvent:t,sessionId:e=null,model:s=null}={}){this.onEvent=t,this.sessionId=e,this.model=s,this.tools=new Map,this.text="",this.thought="",this.textCid=null}_emit(t){try{this.onEvent?.(t)}catch{}}startSession({sessionId:t,models:e,modes:s,commands:n=[]}={}){this.sessionId=t||this.sessionId,this.model=e?.currentModelId||this.model;const o=(e?.availableModels||[]).map(t=>({value:t.modelId,displayName:t.name||t.modelId,description:t.description||""}));this._emit({kind:"system",sessionId:this.sessionId,model:this.model,commands:n,models:o,modes:s}),o.length&&this._emit({kind:"models",models:o,model:this.model})}push(n={}){if(n.sessionId&&this.sessionId&&n.sessionId!==this.sessionId)return;const o=n.update||n;switch(o.sessionUpdate){case"agent_message_chunk":{const t=e(o.content);if(!t)return;return this.text+=t,this.textCid||=`hermes-stream:${this.sessionId||"session"}:${Date.now()}`,void this._emit({kind:"assistant_stream",cid:this.textCid,text:this.text,streaming:!0})}case"agent_thought_chunk":return void(this.thought+=e(o.content));case"tool_call":{const t=hermesToolFor(o);return this.tools.set(o.toolCallId,{...o,...t,startedAt:Date.now()}),void this._emit({kind:"assistant",blocks:[{type:"tool_use",id:o.toolCallId,name:t.name,input:t.input}],parentToolUseId:null})}case"tool_call_update":{const e=this.tools.get(o.toolCallId)||{},n={...e,...o};if(this.tools.set(o.toolCallId,n),!["completed","failed"].includes(o.status))return;const i=hermesToolFor(n),r=[{type:"text",text:s(n)}],a=t(i.name,r);return this._emit({kind:"tool_result",toolUseId:o.toolCallId,content:r,...a?{evidence:a}:{},toolInput:{...e.input||{},...i.input||{}},isError:"failed"===o.status,durationMs:e.startedAt?Date.now()-e.startedAt:void 0,parentToolUseId:null}),void this.tools.delete(o.toolCallId)}case"usage_update":{const t=Number(o.used)||0,e=Number(o.size)||0;return void this._emit({kind:"usage",ctx:{used:t,max:e,pct:e?Math.min(100,Math.round(t/e*100)):0,over:e>0&&t>e,model:this.model}})}case"available_commands_update":return void this._emit({kind:"system",sessionId:this.sessionId,model:this.model,commands:(o.availableCommands||[]).map(t=>{if("string"==typeof t)return t.startsWith("/")?t:`/${t}`;const e=String(t?.name||"").replace(/^\/+/,""),s=t?.input?.hint||t?.inputHint||t?.input_hint||"";return{name:`/${e}`,description:String(t?.description||""),...s?{inputHint:String(s)}:{}}}).filter(t=>"string"==typeof t?"/"!==t:"/"!==t.name)});case"current_mode_update":return void this._emit({kind:"mode",mode:o.currentModeId});case"plan":{const t=(o.entries||[]).map(t=>({content:t.content||"",activeForm:t.content||"",status:"in_progress"===t.status?"in_progress":"completed"===t.status?"completed":"pending"}));return void this._emit({kind:"assistant",blocks:[{type:"tool_use",id:`hermes-plan:${this.sessionId}`,name:"TodoWrite",input:{todos:t}}],parentToolUseId:null})}default:return}}finishTurn({stopReason:t="end_turn",usage:e=null}={}){for(const[e,s]of this.tools){const n="cancelled"===t;this._emit({kind:"tool_result",toolUseId:e,content:[{type:"text",text:n?"[cancelled]":"Hermes ended the turn without reporting this tool result."}],toolInput:s.input||void 0,isError:!n&&"end_turn"!==t,missing:!n,durationMs:s.startedAt?Date.now()-s.startedAt:void 0,parentToolUseId:null})}this.tools.clear();const s=[];this.thought&&s.push({type:"thinking",text:this.thought,reasoningKind:"thought"}),this.text&&s.push({type:"text",text:this.text}),s.length&&this._emit({kind:"assistant",blocks:s,parentToolUseId:null,...this.textCid?{replacesCid:this.textCid}:{}}),this._emit({kind:"result",subtype:"cancelled"===t?"aborted":"end_turn"===t?"success":"error_during_execution",sessionId:this.sessionId,model:this.model,costUsd:null,usage:e?{input_tokens:Number(e.inputTokens)||0,cache_read_input_tokens:Number(e.cachedReadTokens)||0,cache_creation_input_tokens:0,output_tokens:(Number(e.outputTokens)||0)+(Number(e.thoughtTokens)||0)}:null,numTurns:1,durationMs:void 0,denials:0,resultText:this.text||null}),this.text="",this.thought="",this.textCid=null}compactOutcome(){const t=String(this.text||"").match(/Context compressed:\s*(\d+)\s*->\s*(\d+)\s*messages[\s\S]*?~?([\d,]+)\s*->\s*~?([\d,]+)\s*tokens/i);return t?{preMessages:Number(t[1]),postMessages:Number(t[2]),preTokens:Number(t[3].replace(/,/g,"")),postTokens:Number(t[4].replace(/,/g,""))}:null}}

package/hermes-isolation.mjs

@@ -1,61 +1 @@
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { randomUUID } from 'node:crypto'
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
-import { startHermesSession } from './hermes-session.mjs'
-import { withMcpSessionFactory } from './codex-mcp-http.mjs'
-
-const waitFor = (predicate, timeoutMs = 25_000) => new Promise((resolve, reject) => {
-  const started = Date.now()
-  const timer = setInterval(() => {
-    if (predicate()) { clearInterval(timer); resolve() }
-    else if (Date.now() - started > timeoutMs) { clearInterval(timer); reject(new Error('Hermes MCP isolation probe timed out')) }
-  }, 50)
-})
-
-export function assertHermesIsolation(outputs, markers) {
-  if (!Array.isArray(outputs) || outputs.length !== 2 || !Array.isArray(markers) || markers.length !== 2) {
-    throw new TypeError('Hermes MCP isolation requires exactly two session outputs and markers')
-  }
-  for (let i = 0; i < 2; i++) {
-    if (!outputs[i].includes(`mcp__thinkpool__${markers[i]}`)) throw new Error(`Hermes lane ${i + 1} did not advertise its own MCP marker`)
-    if (outputs[i].includes(`mcp__thinkpool__${markers[1 - i]}`)) throw new Error(`Hermes lane ${i + 1} advertised the other lane's MCP marker`)
-  }
-  return true
-}
-
-export async function verifyHermesMcpIsolation({ rounds = 2, sessionFactory = startHermesSession } = {}) {
-  const evidence = []
-  for (let round = 0; round < rounds; round++) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'tp-hermes-mcp-isolation-'))
-    const suffix = randomUUID().replaceAll('-', '').slice(0, 10)
-    const markers = [`lane_alpha_${suffix}`, `lane_beta_${suffix}`]
-    const events = [[], []]
-    const sessions = []
-    try {
-      for (let i = 0; i < 2; i++) {
-        const cwd = path.join(root, i === 0 ? 'alpha' : 'beta')
-        fs.mkdirSync(cwd)
-        const createMarkerServer = () => createSdkMcpServer({
-          name: 'thinkpool', version: '1.0.0',
-          tools: [tool(markers[i], 'Synthetic ThinkPool lane-isolation marker.', {}, async () => ({ content: [{ type: 'text', text: markers[i] }] }))],
-        })
-        const sdkServer = withMcpSessionFactory(createMarkerServer)
-        sessions.push(sessionFactory({ cwd, lazy: true, mcpServers: { thinkpool: sdkServer }, onEvent: (event) => events[i].push(event) }))
-      }
-      sessions.forEach((session) => session.sendTurn('/tools'))
-      await waitFor(() => events.every((list) => list.some((event) => event.kind === 'result') || list.some((event) => event.kind === 'error')))
-      const errors = events.flatMap((list) => list.filter((event) => event.kind === 'error'))
-      if (errors.length) throw new Error(`Hermes MCP isolation probe failed: ${errors.map((event) => event.message).join('; ')}`)
-      const outputs = events.map((list) => list.filter((event) => event.kind === 'assistant_stream').map((event) => event.text).join(''))
-      assertHermesIsolation(outputs, markers)
-      evidence.push({ round: round + 1, markers, sessionIds: sessions.map((session) => session.sessionId) })
-    } finally {
-      sessions.forEach((session) => session.end())
-      await new Promise((resolve) => setTimeout(resolve, 250))
-      fs.rmSync(root, { recursive: true, force: true })
-    }
-  }
-  return evidence
-}
+import e from"node:fs";import r from"node:os";import o from"node:path";import{randomUUID as t}from"node:crypto";import{createSdkMcpServer as n,tool as s}from"@anthropic-ai/claude-agent-sdk";import{startHermesSession as i}from"./hermes-session.mjs";import{withMcpSessionFactory as a}from"./codex-mcp-http.mjs";const m=(e,r=25e3)=>new Promise((o,t)=>{const n=Date.now(),s=setInterval(()=>{e()?(clearInterval(s),o()):Date.now()-n>r&&(clearInterval(s),t(new Error("Hermes MCP isolation probe timed out")))},50)});export function assertHermesIsolation(e,r){if(!Array.isArray(e)||2!==e.length||!Array.isArray(r)||2!==r.length)throw new TypeError("Hermes MCP isolation requires exactly two session outputs and markers");for(let o=0;o<2;o++){if(!e[o].includes(`mcp__thinkpool__${r[o]}`))throw new Error(`Hermes lane ${o+1} did not advertise its own MCP marker`);if(e[o].includes(`mcp__thinkpool__${r[1-o]}`))throw new Error(`Hermes lane ${o+1} advertised the other lane's MCP marker`)}return!0}export async function verifyHermesMcpIsolation({rounds:l=2,sessionFactory:p=i}={}){const c=[];for(let i=0;i<l;i++){const l=e.mkdtempSync(o.join(r.tmpdir(),"tp-hermes-mcp-isolation-")),d=t().replaceAll("-","").slice(0,10),h=[`lane_alpha_${d}`,`lane_beta_${d}`],f=[[],[]],u=[];try{for(let r=0;r<2;r++){const t=o.join(l,0===r?"alpha":"beta");e.mkdirSync(t);const i=a(()=>n({name:"thinkpool",version:"1.0.0",tools:[s(h[r],"Synthetic ThinkPool lane-isolation marker.",{},async()=>({content:[{type:"text",text:h[r]}]}))]}));u.push(p({cwd:t,lazy:!0,mcpServers:{thinkpool:i},onEvent:e=>f[r].push(e)}))}u.forEach(e=>e.sendTurn("/tools")),await m(()=>f.every(e=>e.some(e=>"result"===e.kind)||e.some(e=>"error"===e.kind)));const r=f.flatMap(e=>e.filter(e=>"error"===e.kind));if(r.length)throw new Error(`Hermes MCP isolation probe failed: ${r.map(e=>e.message).join("; ")}`);assertHermesIsolation(f.map(e=>e.filter(e=>"assistant_stream"===e.kind).map(e=>e.text).join("")),h),c.push({round:i+1,markers:h,sessionIds:u.map(e=>e.sessionId)})}finally{u.forEach(e=>e.end()),await new Promise(e=>setTimeout(e,250)),e.rmSync(l,{recursive:!0,force:!0})}}return c}

package/hermes-model-cache.mjs

@@ -1,54 +1 @@
-// Hermes exposes its model catalog only after `session/new`, which may take up
-// to 30 seconds while the ACP process boots. The catalog is public metadata and
-// identical for every room served by this Hermes profile, so keep the last
-// validated copy at the host level. A live Hermes session always replaces it.
-
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-const MAX_MODELS = 1000
-const MAX_BYTES = 512 * 1024
-const MAX_FIELD = 512
-
-const cachePath = () => process.env.TP_HERMES_MODEL_CACHE
-  || path.join(process.env.TP_PAIR_ROOT || path.join(os.homedir(), '.thinkpool-pair'), 'hermes-models.json')
-
-export function normalizeHermesModelCache(models) {
-  if (!Array.isArray(models)) return []
-  const seen = new Set()
-  const normalized = []
-  for (const raw of models.slice(0, MAX_MODELS)) {
-    const value = String(raw?.value || '').trim().slice(0, MAX_FIELD)
-    if (!value || seen.has(value)) continue
-    seen.add(value)
-    normalized.push({
-      value,
-      displayName: String(raw?.displayName || value).trim().slice(0, MAX_FIELD) || value,
-      description: String(raw?.description || '').trim().slice(0, MAX_FIELD),
-    })
-  }
-  return normalized
-}
-
-export function loadHermesModelCache() {
-  try {
-    const file = cachePath()
-    if ((Number(fs.statSync(file).size) || 0) > MAX_BYTES) return []
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
-    return normalizeHermesModelCache(parsed?.models)
-  } catch { return [] }
-}
-
-export function saveHermesModelCache(models) {
-  const normalized = normalizeHermesModelCache(models)
-  if (!normalized.length) return []
-  try {
-    const file = cachePath()
-    fs.mkdirSync(path.dirname(file), { recursive: true })
-    const temp = `${file}.${process.pid}.${Date.now()}.tmp`
-    fs.writeFileSync(temp, JSON.stringify({ savedAt: Date.now(), models: normalized }), { mode: 0o600 })
-    fs.renameSync(temp, file)
-  } catch { /* cache is opportunistic; live discovery remains the fallback */ }
-  return normalized
-}
+import e from"node:fs";import r from"node:os";import o from"node:path";const n=()=>process.env.TP_HERMES_MODEL_CACHE||o.join(process.env.TP_PAIR_ROOT||o.join(r.homedir(),".thinkpool-pair"),"hermes-models.json");export function normalizeHermesModelCache(e){if(!Array.isArray(e))return[];const r=new Set,o=[];for(const n of e.slice(0,1e3)){const e=String(n?.value||"").trim().slice(0,512);e&&!r.has(e)&&(r.add(e),o.push({value:e,displayName:String(n?.displayName||e).trim().slice(0,512)||e,description:String(n?.description||"").trim().slice(0,512)}))}return o}export function loadHermesModelCache(){try{const r=n();if((Number(e.statSync(r).size)||0)>524288)return[];const o=JSON.parse(e.readFileSync(r,"utf8"));return normalizeHermesModelCache(o?.models)}catch{return[]}}export function saveHermesModelCache(r){const t=normalizeHermesModelCache(r);if(!t.length)return[];try{const r=n();e.mkdirSync(o.dirname(r),{recursive:!0});const s=`${r}.${process.pid}.${Date.now()}.tmp`;e.writeFileSync(s,JSON.stringify({savedAt:Date.now(),models:t}),{mode:384}),e.renameSync(s,r)}catch{}return t}