thinkpool-pair 0.7.352 → 0.7.354

package/bridge.mjs

@@ -59,6 +59,7 @@ import { cleanTerminalName, modelTerminalNameInput } from './terminal-name.mjs'
 import { defaultStructuredMode, normalizeStructuredEffort, shouldDeferStructuredRuntime, structuredModeForSlice, structuredModeLocked, structuredModesForLane, structuredRuntimeForCommand, structuredRuntimeMetadata, structuredRuntimeSupportsMode } from './runtime-registry.mjs'
 import { commandCatalogForRuntime, commandHelpLine, reconcileCommandCatalog } from './command-catalog.mjs'
 import { gitDiffReport } from './git-diff-report.mjs'
+import { repoSearch } from './repo-search.mjs'
 import { probeHermesRuntime } from './hermes-probe.mjs'
 import { hermesRequiredMcpTools, hermesRoleFor } from './hermes-policy.mjs'
 import { canonicalRoomFilePath, waitForNativeImages } from './codex-images.mjs'
@@ -4539,7 +4540,7 @@ channel
       // Display the clean body (web sends `body` when the agent `text` carries host
       // file paths) + the uploaded attachments, so the partner shows the image — not
       // a raw /var path. The agent already got the full `text` via sendTurn above.
-      const evt = { kind: 'you', text: payload.body != null ? String(payload.body) : text, cid: payload.cid, by: payload.by, ...(payload.authorId ? { authorId: payload.authorId } : {}), ...(Array.isArray(payload.files) && payload.files.length ? { files: payload.files } : {}), ...(Array.isArray(payload.pastes) && payload.pastes.length ? { pastes: payload.pastes } : {}) }
+      const evt = { kind: 'you', text: payload.body != null ? String(payload.body) : text, cid: payload.cid, by: payload.by, ...(payload.authorId ? { authorId: payload.authorId } : {}), ...(payload.steered ? { steered: true } : {}), ...(Array.isArray(payload.files) && payload.files.length ? { files: payload.files } : {}), ...(Array.isArray(payload.pastes) && payload.pastes.length ? { pastes: payload.pastes } : {}) }
       pushLog(s, evt)
       bcast('code-event', { term: payload.term, evt })
     }
@@ -4577,6 +4578,19 @@ channel
       } catch { ctlLine('Working-tree diff unavailable outside a readable Git checkout') }
       return
     }
+    const findMatch = text.match(/^\/find(?:\s+([\s\S]+))?$/i)
+    if (findMatch) {
+      const search = repoSearch({ cwd: s.cwd || process.cwd(), query: findMatch[1] || '' })
+      const evt = {
+        kind: 'repo-search',
+        ...search,
+        by: payload.by,
+        cid: payload.cid,
+      }
+      pushLog(s, evt)
+      bcast('code-event', { term: payload.term, evt })
+      return
+    }
     if (/^\/credits\s*$/.test(text) && s.runtime !== 'hermes') {
       if (s.runtime !== 'codex' || typeof s.session?.accountUsage !== 'function') {
         ctlLine('Credit balance is unavailable for this runtime; use /usage for provider limits')

package/code-event-contract.mjs

@@ -47,6 +47,7 @@ export const CODE_EVENT_REGISTRY = Object.freeze({
   'side-handback': P,
   answer: C,
   control: C,
+  'repo-search': C,
   clear: C,
   'queue-add': C,
   'queue-cancel': C,

package/codex-event-mapper.mjs

@@ -30,9 +30,11 @@
 // path routes command/file approval requests through the shared room cards.
 import fs from 'node:fs'
 import { CODEX_COMMAND_CATALOG } from './codex-commands.mjs'
+import { normalizeEditKind, summarizeTextDiff } from './edit-diff.mjs'
 
 const safeMcpPart = (value) => String(value || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_')
 const mcpToolName = (item) => `mcp__${safeMcpPart(item?.server)}__${safeMcpPart(item?.tool)}`
+const webSearchQuery = (item) => item?.query || item?.action?.query || item?.action?.url || ''
 const resultText = (value) => {
   if (typeof value === 'string') return value
   if (value == null) return ''
@@ -99,15 +101,16 @@ export class CodexEventMapper {
           this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: 'Bash', input: { command: it.command || '' } }], parentToolUseId: null })
         } else if (it.type === 'file_change') {
           const before = (it.changes || []).map((c) => {
+            const kind = normalizeEditKind(c.kind)
             let content = ''
-            if (c.kind !== 'add' && c.path) {
+            if (kind !== 'add' && c.path) {
               try { content = this._fs.readFileSync(c.path, 'utf8') } catch { /* missing/unreadable → empty */ }
             }
-            return { path: c.path || '', kind: c.kind || 'update', content }
+            return { path: c.path || '', kind, content }
           })
           this._fileBefore.set(it.id, before)
         } else if (it.type === 'web_search') {
-          this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: 'WebSearch', input: { query: it.query || '' } }], parentToolUseId: null })
+          this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: 'WebSearch', input: { query: webSearchQuery(it) } }], parentToolUseId: null })
         } else if (it.type === 'mcp_tool_call') {
           this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name: mcpToolName(it), input: it.arguments || {} }], parentToolUseId: null })
         }
@@ -137,7 +140,17 @@ export class CodexEventMapper {
             if (c.kind !== 'delete' && c.path) {
               try { next = this._fs.readFileSync(c.path, 'utf8') } catch { /* deleted/unreadable → empty */ }
             }
-            return { file_path: c.path, path: c.path, old_string: c.content, new_string: next, kind: c.kind }
+            const summary = summarizeTextDiff(c.content, next, { context: 2, maxLines: 60 })
+            return {
+              file_path: c.path,
+              path: c.path,
+              kind: c.kind,
+              added: summary.added,
+              removed: summary.removed,
+              diff_preview: summary.preview,
+              old_string: c.content,
+              new_string: next,
+            }
           })
           const first = edits[0] || { file_path: '', path: '', old_string: '', new_string: '', kind: 'update' }
           const name = edits.length > 1 ? 'MultiEdit' : first.kind === 'add' ? 'Write' : 'Edit'
@@ -149,7 +162,8 @@ export class CodexEventMapper {
           this._emit({ kind: 'assistant', blocks: [{ type: 'tool_use', id: it.id, name, input }], parentToolUseId: null })
           this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: `${name === 'Write' ? 'wrote' : 'edited'} ${first.path}` }], isError: false, durationMs, parentToolUseId: null })
         } else if (it.type === 'web_search') {
-          this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: it.query || 'search completed' }], isError: false, durationMs, parentToolUseId: null })
+          const query = webSearchQuery(it)
+          this._emit({ kind: 'tool_result', toolUseId: it.id, toolInput: { query }, content: [{ type: 'text', text: query || 'search completed' }], isError: false, durationMs, parentToolUseId: null })
         } else if (it.type === 'mcp_tool_call') {
           this._emit({ kind: 'tool_result', toolUseId: it.id, content: [{ type: 'text', text: it.error?.message || resultText(it.result) }], isError: it.status === 'failed' || !!it.error, durationMs, parentToolUseId: null })
         }

package/command-catalog.mjs

@@ -19,6 +19,7 @@ export const CODE_ROOM_COMMANDS = Object.freeze([
   command('/usage', 'session usage and provider limits', 'control'),
   command('/context', 'current context-window usage', 'control'),
   command('/diff', 'Git changes and branch status', 'control'),
+  command('/find', 'find relevant files in this repository', 'control', 'query'),
   command('/compact', 'compact context', 'runtime'),
   command('/clear', 'clear context · confirms', 'clear'),
   command('/model', 'pick model — opens selector', 'model'),

package/edit-diff.mjs

@@ -0,0 +1,136 @@
+// Bridge-local diff primitives. Keep this module self-contained: the npm
+// package cannot import the web app's ../src tree.
+export const normalizeEditKind = (value) => {
+  const kind = typeof value === 'object' ? value?.type : value
+  if (kind === 'add' || kind === 'delete' || kind === 'rename') return kind
+  return 'update'
+}
+
+const splitLines = (value) => {
+  if (!value) return []
+  const lines = String(value).replace(/\r\n?/g, '\n').split('\n')
+  if (lines.at(-1) === '') lines.pop()
+  return lines
+}
+
+const fallbackDiff = (before, after) => {
+  let start = 0
+  while (start < before.length && start < after.length && before[start] === after[start]) start++
+  let oldEnd = before.length
+  let newEnd = after.length
+  while (oldEnd > start && newEnd > start && before[oldEnd - 1] === after[newEnd - 1]) {
+    oldEnd--
+    newEnd--
+  }
+  return [
+    ...before.slice(0, start).map((text) => ({ type: 'context', text })),
+    ...before.slice(start, oldEnd).map((text) => ({ type: 'remove', text })),
+    ...after.slice(start, newEnd).map((text) => ({ type: 'add', text })),
+    ...before.slice(oldEnd).map((text) => ({ type: 'context', text })),
+  ]
+}
+
+function lineDiff(before, after, maxDistance = 600) {
+  if (!before.length) return after.map((text) => ({ type: 'add', text }))
+  if (!after.length) return before.map((text) => ({ type: 'remove', text }))
+  const max = Math.min(before.length + after.length, maxDistance)
+  const frontier = new Map([[1, 0]])
+  const trace = []
+  for (let distance = 0; distance <= max; distance++) {
+    trace.push(new Map(frontier))
+    for (let diagonal = -distance; diagonal <= distance; diagonal += 2) {
+      const down = frontier.get(diagonal + 1) ?? -1
+      const right = frontier.get(diagonal - 1) ?? -1
+      let oldIndex = diagonal === -distance || (diagonal !== distance && right < down)
+        ? Math.max(0, down)
+        : Math.max(0, right + 1)
+      let newIndex = oldIndex - diagonal
+      while (oldIndex < before.length && newIndex < after.length && before[oldIndex] === after[newIndex]) {
+        oldIndex++
+        newIndex++
+      }
+      frontier.set(diagonal, oldIndex)
+      if (oldIndex < before.length || newIndex < after.length) continue
+
+      const operations = []
+      let x = before.length
+      let y = after.length
+      for (let d = distance; d >= 0; d--) {
+        const snapshot = trace[d]
+        const k = x - y
+        const snapshotDown = snapshot.get(k + 1) ?? -1
+        const snapshotRight = snapshot.get(k - 1) ?? -1
+        const previousK = k === -d || (k !== d && snapshotRight < snapshotDown) ? k + 1 : k - 1
+        const previousX = Math.max(0, snapshot.get(previousK) ?? 0)
+        const previousY = previousX - previousK
+        while (x > previousX && y > previousY) {
+          operations.push({ type: 'context', text: before[x - 1] })
+          x--
+          y--
+        }
+        if (d === 0) break
+        if (x === previousX) {
+          operations.push({ type: 'add', text: after[y - 1] })
+          y--
+        } else {
+          operations.push({ type: 'remove', text: before[x - 1] })
+          x--
+        }
+      }
+      return operations.reverse()
+    }
+  }
+  return fallbackDiff(before, after)
+}
+
+const previewLine = (type, text = '') => {
+  if (type === 'add') return `+${text}`
+  if (type === 'remove') return `-${text}`
+  if (type === 'context') return ` ${text}`
+  return `…${text}`
+}
+
+function compactOperations(operations, context = 2, maxLines = 80) {
+  const changed = []
+  operations.forEach((operation, index) => {
+    if (operation.type !== 'context') changed.push(index)
+  })
+  if (!changed.length) return []
+
+  const ranges = []
+  for (const index of changed) {
+    const start = Math.max(0, index - context)
+    const end = Math.min(operations.length, index + context + 1)
+    const previous = ranges.at(-1)
+    if (previous && start <= previous.end) previous.end = Math.max(previous.end, end)
+    else ranges.push({ start, end })
+  }
+
+  const compacted = []
+  ranges.forEach((range, index) => {
+    if (index > 0) compacted.push({ type: 'omit', text: `${range.start - ranges[index - 1].end} unchanged lines` })
+    compacted.push(...operations.slice(range.start, range.end))
+  })
+  if (compacted.length <= maxLines) return compacted
+
+  const head = Math.floor((maxLines - 1) / 2)
+  const tail = maxLines - head - 1
+  return [
+    ...compacted.slice(0, head),
+    { type: 'omit', text: `${compacted.length - head - tail} preview lines hidden` },
+    ...compacted.slice(-tail),
+  ]
+}
+
+export function summarizeTextDiff(oldText, newText, options = {}) {
+  const operations = lineDiff(splitLines(oldText), splitLines(newText), options.maxDistance)
+  const added = operations.reduce((total, operation) => total + (operation.type === 'add' ? 1 : 0), 0)
+  const removed = operations.reduce((total, operation) => total + (operation.type === 'remove' ? 1 : 0), 0)
+  const lines = compactOperations(operations, options.context ?? 2, options.maxLines ?? 80)
+  return {
+    added,
+    removed,
+    lines,
+    preview: lines.map((line) => previewLine(line.type, line.text)).join('\n'),
+  }
+}

package/git-diff-report.mjs

@@ -16,8 +16,11 @@ function defaultRunGit(args, cwd) {
 }
 
 function cleanLine(value, max = 240) {
-  return String(value || '')
-    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+  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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.352",
+  "version": "0.7.354",
   "description": "Connect Claude Code, Codex, or Hermes on your computer to a Thinkpool Code room.",
   "type": "module",
   "bin": {
@@ -34,6 +34,7 @@
     "codex-mcp-http.mjs",
     "lane-worktree.mjs",
     "codex-event-mapper.mjs",
+    "edit-diff.mjs",
     "cumulative-event-relay.mjs",
     "codex-commands.mjs",
     "acp-client.mjs",
@@ -48,6 +49,7 @@
     "hermes-delegation-guard.mjs",
     "runtime-registry.mjs",
     "command-catalog.mjs",
+    "repo-search.mjs",
     "git-diff-report.mjs",
     "runtime-session.mjs",
     "turn-stall.mjs",

package/repo-search.mjs

@@ -0,0 +1,188 @@
+import { execFileSync } from 'node:child_process'
+
+const MAX_QUERY_CHARS = 160
+const DEFAULT_MAX_RESULTS = 8
+const MAX_FILES_BUFFER = 16 * 1024 * 1024
+
+const STOP_WORDS = new Set([
+  'a', 'an', 'and', 'every', 'file', 'files', 'find', 'for', 'from', 'in',
+  'inside', 'is', 'locate', 'me', 'of', 'please', 'show', 'the', 'to', 'under',
+  'where', 'with',
+])
+
+const EXPANSIONS = Object.freeze({
+  api: ['endpoint', 'route', 'server'],
+  auth: ['login', 'session', 'oauth'],
+  component: ['card', 'panel', 'view', 'widget'],
+  config: ['configuration', 'settings'],
+  database: ['db', 'sql', 'schema'],
+  image: ['asset', 'gallery', 'media', 'photo', 'picture', 'thumbnail'],
+  library: ['catalog', 'collection', 'index', 'lib'],
+  login: ['auth', 'oauth', 'session'],
+  session: ['auth', 'login'],
+  style: ['css', 'theme'],
+  styles: ['css', 'theme'],
+  test: ['spec'],
+  tests: ['spec'],
+})
+
+const cleanQuery = (value) => String(value || '')
+  .replace(/[\u0000-\u001f\u007f]/g, ' ')
+  .replace(/\s+/g, ' ')
+  .trim()
+
+const unique = (values) => [...new Set(values.filter(Boolean))]
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+const normalizePath = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '')
+const wordish = (value) => String(value || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim()
+const pathContainsSegment = (path, segment) => `/${normalizePath(path).toLowerCase()}/`.includes(`/${segment.toLowerCase().replace(/^\/+|\/+$/g, '')}/`)
+
+function queryTokens(query) {
+  return unique((query.toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}_-]*/gu) || [])
+    .map((token) => token.replace(/^[-_]+|[-_]+$/g, ''))
+    .filter((token) => token && !STOP_WORDS.has(token)))
+}
+
+function locationHints(query) {
+  return unique([...query.toLowerCase().matchAll(/\b(?:from|in|inside|under)\s+([\p{L}\p{N}_.\/-]+)/gu)]
+    .map((match) => match[1].replace(/^\/+|\/+$/g, ''))
+    .filter(Boolean))
+}
+
+function defaultRun(command, args, cwd) {
+  return execFileSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: command === 'rg' ? 1400 : 3000,
+    maxBuffer: MAX_FILES_BUFFER,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+}
+
+function listedFiles(run, cwd) {
+  const raw = String(run('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard'], cwd) || '')
+  return unique(raw.split('\0').map(normalizePath).filter(Boolean))
+}
+
+function contentMatches(run, cwd, terms, knownFiles) {
+  const matches = new Map()
+  if (!terms.length) return matches
+  const pattern = terms.slice().sort((a, b) => b.length - a.length).map(escapeRegex).join('|')
+  let raw = ''
+  try {
+    raw = String(run('rg', [
+      '--json',
+      '--ignore-case',
+      '--max-count', '4',
+      '--no-messages',
+      '--regexp', pattern,
+      '.',
+    ], cwd) || '')
+  } catch {
+    // `rg` is the fast path. A host without it still gets filename/path search;
+    // repository search must never block the room or fall through to an LLM turn.
+    return matches
+  }
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line) continue
+    let record
+    try { record = JSON.parse(line) } catch { continue }
+    if (record?.type !== 'match') continue
+    const path = normalizePath(record.data?.path?.text)
+    if (!knownFiles.has(path)) continue
+    const lineNumber = Number(record.data?.line_number)
+    const text = String(record.data?.lines?.text || '').toLowerCase()
+    const prior = matches.get(path)
+    if (!prior) matches.set(path, { line: Number.isFinite(lineNumber) ? lineNumber : null, text })
+    else prior.text += ` ${text}`
+  }
+  return matches
+}
+
+function candidateScore(path, original, expanded, content) {
+  const lowerPath = path.toLowerCase()
+  const base = lowerPath.split('/').at(-1) || lowerPath
+  const pathWords = ` ${wordish(lowerPath)} `
+  const contentText = content?.text || ''
+  let score = 0
+
+  const phrase = original.join(' ')
+  if (phrase && pathWords.includes(` ${phrase} `)) score += 100
+  for (const token of original) {
+    if (base.includes(token)) score += 30
+    if (lowerPath.includes(token)) score += 16
+    if (pathWords.includes(` ${token} `)) score += 8
+    if (contentText.includes(token)) score += 8
+  }
+  for (const token of expanded) {
+    if (base.includes(token)) score += 8
+    else if (lowerPath.includes(token)) score += 5
+    if (contentText.includes(token)) score += 2
+  }
+
+  const rootMatches = (haystack) => original.filter((token) =>
+    haystack.includes(token) || (EXPANSIONS[token] || []).some((alias) => haystack.includes(alias)))
+  const pathCoverage = rootMatches(lowerPath).length
+  const coverage = rootMatches(`${lowerPath} ${contentText}`).length
+  score += (coverage ** 2) * 18 + (pathCoverage ** 2) * 22
+
+  const ext = base.includes('.') ? base.slice(base.lastIndexOf('.')) : ''
+  const componentFile = ['.jsx', '.tsx', '.vue', '.svelte'].includes(ext)
+  if (original.includes('component') && componentFile) score += 60
+  if (original.some((token) => token === 'test' || token === 'tests') && /(?:^|\/)(?:test|tests|spec|specs)(?:\/|$)|\.(?:test|spec)\./.test(lowerPath)) score += 10
+  if (original.some((token) => token === 'asset' || token === 'assets') && /(?:^|\/)assets?(?:\/|$)/.test(lowerPath)) score += 10
+  const testPath = /(?:^|\/)(?:test|tests|spec|specs)(?:\/|$)|\.(?:test|spec)\./.test(lowerPath)
+  if (testPath && !original.some((token) => token === 'test' || token === 'tests')) score -= 25
+  if (/^(?:docs|marketing|archive|\.claude)\//.test(lowerPath)) score -= 35
+  if (/^(?:src|app|lib|api|bridge|server|client|components|packages)\//.test(lowerPath)) score += 12
+  return { score, coverage, pathCoverage, componentFile }
+}
+
+export function repoSearch({
+  cwd = process.cwd(),
+  query,
+  maxResults = DEFAULT_MAX_RESULTS,
+  run = defaultRun,
+  now = () => Date.now(),
+} = {}) {
+  const startedAt = now()
+  const cleaned = cleanQuery(query)
+  const finish = (result) => ({ ...result, durationMs: Math.max(0, Math.round(now() - startedAt)) })
+
+  if (!cleaned) return finish({ query: '', results: [], total: 0, truncated: false, error: 'Use /find followed by a filename, symbol, or code concept.' })
+  if (cleaned.length > MAX_QUERY_CHARS) return finish({ query: cleaned.slice(0, MAX_QUERY_CHARS), results: [], total: 0, truncated: false, error: `Keep /find queries under ${MAX_QUERY_CHARS} characters.` })
+
+  const original = queryTokens(cleaned)
+  if (!original.length) return finish({ query: cleaned, results: [], total: 0, truncated: false, error: 'Try a filename, symbol, or code concept.' })
+  const expanded = unique(original.flatMap((token) => EXPANSIONS[token] || []))
+
+  let files
+  try { files = listedFiles(run, cwd) } catch {
+    return finish({ query: cleaned, results: [], total: 0, truncated: false, error: 'Repository search is unavailable outside a readable Git checkout.' })
+  }
+  const activeLocations = locationHints(cleaned).filter((hint) => files.some((path) => pathContainsSegment(path, hint)))
+  const eligibleFiles = activeLocations.length
+    ? files.filter((path) => activeLocations.every((hint) => pathContainsSegment(path, hint)))
+    : files
+  const knownFiles = new Set(eligibleFiles)
+  const matches = contentMatches(run, cwd, unique([...original, ...expanded]), knownFiles)
+  const minimumCoverage = Math.max(1, Math.ceil(original.length * 0.6))
+  const ranked = eligibleFiles
+    .map((path) => {
+      const rank = candidateScore(path, original, expanded, matches.get(path))
+      return { path, line: matches.get(path)?.line || null, ...rank }
+    })
+    .filter((item) => item.score > 0 && (
+      item.coverage >= minimumCoverage
+      || (original.includes('component') && item.componentFile && item.coverage >= 2)
+    ))
+    .sort((a, b) => b.score - a.score || b.pathCoverage - a.pathCoverage || a.path.length - b.path.length || a.path.localeCompare(b.path))
+
+  const limit = Math.max(1, Math.min(20, Number(maxResults) || DEFAULT_MAX_RESULTS))
+  return finish({
+    query: cleaned,
+    results: ranked.slice(0, limit).map(({ path, line }) => ({ path, ...(line ? { line } : {}) })),
+    total: ranked.length,
+    truncated: ranked.length > limit,
+  })
+}

package/terminal-name.mjs

@@ -224,7 +224,7 @@ export function cleanTerminalName(value) {
   const words = name.split(/\s+/).filter(Boolean)
   const compactCjk = words.length === 1
     && /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u.test(name)
-  if ((words.length < 2 && !compactCjk) || words.length > 4) return null
+  if ((words.length < 2 && !compactCjk) || words.length > 3) return null
   return name || null
 }
 
@@ -268,7 +268,7 @@ const taskTitle = (value) => {
   if (!body) return null
   const grammar = analyzeGrammar(body)
   if (grammar.negativePreference) {
-    const subject = contentWords(negativePreferenceSubject(grammar)).slice(0, 3)
+    const subject = contentWords(negativePreferenceSubject(grammar)).slice(0, 2)
     return subject.length ? cleanTerminalName(['Avoid', ...subject.map(titleWord)].join(' ')) : null
   }
   const informationRequest = grammar.informationRequest
@@ -286,11 +286,11 @@ const taskTitle = (value) => {
   if (!verb && /\bopen(?:s|ed|ing)?\b/i.test(body)) verb = 'Open'
 
   if (/\bautomatic(?:ally)?\b[\s\S]{0,24}\bnam(?:e|ing)\b/i.test(signalText) && /\bterminals?\b/i.test(signalText)) {
-    if (/\bcontext\b[\s\S]{0,24}\broom\b|\broom\b[\s\S]{0,24}\bcontext\b/i.test(signalText)) return 'Auto-Name Terminals From Context'
+    if (/\bcontext\b[\s\S]{0,24}\broom\b|\broom\b[\s\S]{0,24}\bcontext\b/i.test(signalText)) return 'Contextual Terminal Names'
     verb = 'Auto-Name'
   }
-  if (verb === 'Snap' && /\bterminal row\b/i.test(signalText) && /\bview\b/i.test(signalText)) return 'Snap Terminal Row View'
-  if (verb === 'Snap' && /\bclicked terminal\b/i.test(signalText) && /\bview\b/i.test(signalText)) return 'Snap Clicked Terminal View'
+  if (verb === 'Snap' && /\bterminal row\b/i.test(signalText) && /\bview\b/i.test(signalText)) return 'Snap Terminal Row'
+  if (verb === 'Snap' && /\bclicked terminal\b/i.test(signalText) && /\bview\b/i.test(signalText)) return 'Snap Clicked Terminal'
 
   let domain = []
   let objectText = body
@@ -311,7 +311,7 @@ const taskTitle = (value) => {
   }
   const picked = [...domain, ...object]
     .filter((word, index, all) => all.findIndex((other) => other.toLowerCase() === word.toLowerCase()) === index)
-    .slice(0, verb ? 3 : 4)
+    .slice(0, verb ? 2 : 3)
   if (!picked.length) return null
   return cleanTerminalName([verb, ...picked.map(titleWord)].filter(Boolean).join(' '))
 }