@hongmaple0820/med-scale-research-os 0.43.0

package/examples/demo-projects/agent-governance-demo/src/oauth-state.ts

@@ -0,0 +1,39 @@
+export type OAuthStateFailure = 'missing-record' | 'state-mismatch' | 'state-expired' | 'state-consumed'
+
+export interface OAuthStateRecord {
+  state: string
+  userId: string
+  expiresAt: number
+  consumedAt?: number
+}
+
+export interface OAuthStateVerification {
+  ok: boolean
+  userId?: string
+  reason?: OAuthStateFailure
+}
+
+export function verifyOAuthState(
+  record: OAuthStateRecord | undefined,
+  providedState: string,
+  now: number = Date.now()
+): OAuthStateVerification {
+  if (!record) {
+    return { ok: false, reason: 'missing-record' }
+  }
+
+  if (record.state !== providedState) {
+    return { ok: false, reason: 'state-mismatch' }
+  }
+
+  if (record.expiresAt <= now) {
+    return { ok: false, reason: 'state-expired' }
+  }
+
+  if (record.consumedAt !== undefined) {
+    return { ok: false, reason: 'state-consumed' }
+  }
+
+  return { ok: true, userId: record.userId }
+}
+

package/examples/demo-projects/agent-governance-demo/tests/oauth-state.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import { verifyOAuthState, type OAuthStateRecord } from '../src/oauth-state.js'
+
+const future = 2_000
+const now = 1_000
+
+function record(overrides: Partial<OAuthStateRecord> = {}): OAuthStateRecord {
+  return {
+    state: 'state-123',
+    userId: 'user-1',
+    expiresAt: future,
+    ...overrides
+  }
+}
+
+describe('verifyOAuthState', () => {
+  it('accepts a valid unexpired state', () => {
+    expect(verifyOAuthState(record(), 'state-123', now)).toEqual({
+      ok: true,
+      userId: 'user-1'
+    })
+  })
+
+  it('rejects a missing record', () => {
+    expect(verifyOAuthState(undefined, 'state-123', now)).toEqual({
+      ok: false,
+      reason: 'missing-record'
+    })
+  })
+
+  it('rejects a mismatched state', () => {
+    expect(verifyOAuthState(record(), 'other-state', now)).toEqual({
+      ok: false,
+      reason: 'state-mismatch'
+    })
+  })
+
+  it('rejects an expired state', () => {
+    expect(verifyOAuthState(record({ expiresAt: now }), 'state-123', now)).toEqual({
+      ok: false,
+      reason: 'state-expired'
+    })
+  })
+
+  it('rejects a consumed state', () => {
+    expect(verifyOAuthState(record({ consumedAt: 900 }), 'state-123', now)).toEqual({
+      ok: false,
+      reason: 'state-consumed'
+    })
+  })
+})
+

package/mcp-configs/_INDEX.md

@@ -0,0 +1,55 @@
+# MCP Configurations Catalog
+
+10 ready-to-use MCP server configurations.
+
+## Data & Storage
+
+| MCP | Description | Tools |
+|-----|-------------|-------|
+| [memory](memory/config.json) | Knowledge graph | add_entities, search_nodes |
+| [filesystem](filesystem/config.json) | File operations | read_file, write_file |
+| [postgres](postgres/config.json) | PostgreSQL | query, execute |
+| [neon](neon/config.json) | Neon DB | create_branch, run_query |
+
+## Development
+
+| MCP | Description | Tools |
+|-----|-------------|-------|
+| [github](github/config.json) | GitHub API | create_pr, search_repos |
+| [context7](context7/config.json) | Docs lookup | resolve-library-id, query-docs |
+
+## Testing & Browser
+
+| MCP | Description | Tools |
+|-----|-------------|-------|
+| [playwright](playwright/config.json) | Browser E2E | navigate, screenshot |
+| [puppeteer](puppeteer/config.json) | Browser alt | navigate, screenshot |
+
+## Utilities
+
+| MCP | Description | Tools |
+|-----|-------------|-------|
+| [fetch](fetch/config.json) | Web fetching | fetch, fetch_multiple |
+| [sequential-thinking](sequential-thinking/config.json) | Deep reasoning | think, branch |
+
+## Installation
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "memory": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"]
+    }
+  }
+}
+```
+
+## Environment Variables
+
+Some MCPs require environment variables:
+- `github`: `GITHUB_TOKEN`
+- `postgres`: `POSTGRES_URL`
+- `neon`: `NEON_API_KEY`

package/mcp-configs/context7/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "context7",
+  "description": "Documentation lookup for libraries",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-context7"],
+  "env": {},
+  "tools": ["resolve-library-id", "query-docs"],
+  "whenToUse": "User asks about library/framework usage"
+}

package/mcp-configs/fetch/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "fetch",
+  "description": "Web content fetching",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-fetch"],
+  "env": {},
+  "tools": ["fetch", "fetch_multiple"],
+  "whenToUse": "Fetching web content and APIs"
+}

package/mcp-configs/filesystem/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "filesystem",
+  "description": "File system operations with sandboxing",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-filesystem", "/path/to/project"],
+  "env": {},
+  "tools": ["read_file", "write_file", "list_directory", "search_files"],
+  "whenToUse": "Safe file operations with path restrictions"
+}

package/mcp-configs/github/config.json

@@ -0,0 +1,11 @@
+{
+  "name": "github",
+  "description": "GitHub API operations",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-github"],
+  "env": {
+    "GITHUB_TOKEN": "${GITHUB_TOKEN}"
+  },
+  "tools": ["create_issue", "create_pr", "search_repos", "get_file_contents"],
+  "whenToUse": "GitHub workflows, PRs, issues"
+}

package/mcp-configs/memory/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "memory",
+  "description": "Knowledge graph for persistent memory",
+  "command": "npx",
+  "args": ["-y", "@modelcontextprotocol/server-memory"],
+  "env": {},
+  "tools": ["add_entities", "add_relations", "read_graph", "search_nodes"],
+  "whenToUse": "Remembering context across sessions"
+}

package/mcp-configs/neon/config.json

@@ -0,0 +1,11 @@
+{
+  "name": "neon",
+  "description": "Neon PostgreSQL database",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-neon"],
+  "env": {
+    "NEON_API_KEY": "${NEON_API_KEY}"
+  },
+  "tools": ["create_branch", "run_query", "describe_table"],
+  "whenToUse": "Branching database workflows"
+}

package/mcp-configs/playwright/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "playwright",
+  "description": "Browser automation for E2E testing",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-playwright"],
+  "env": {},
+  "tools": ["navigate", "click", "fill", "screenshot", "evaluate"],
+  "whenToUse": "E2E testing, browser automation"
+}

package/mcp-configs/postgres/config.json

@@ -0,0 +1,11 @@
+{
+  "name": "postgres",
+  "description": "PostgreSQL database operations",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-postgres"],
+  "env": {
+    "POSTGRES_URL": "${POSTGRES_URL}"
+  },
+  "tools": ["query", "execute", "describe_table"],
+  "whenToUse": "Database queries and schema operations"
+}

package/mcp-configs/puppeteer/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "puppeteer",
+  "description": "Browser automation alternative",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-puppeteer"],
+  "env": {},
+  "tools": ["navigate", "click", "screenshot", "evaluate"],
+  "whenToUse": "Browser automation with headless Chrome"
+}

package/mcp-configs/sequential-thinking/config.json

@@ -0,0 +1,9 @@
+{
+  "name": "sequential-thinking",
+  "description": "Deep reasoning with structured thoughts",
+  "command": "npx",
+  "args": ["-y", "@anthropic/mcp-sequential-thinking"],
+  "env": {},
+  "tools": ["think", "branch", "conclude"],
+  "whenToUse": "Complex problems requiring step-by-step reasoning"
+}

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@hongmaple0820/med-scale-research-os",
+  "version": "0.43.0",
+  "description": "MedSCALE Research OS: evidence-driven medical research workflow with literature review, fact checks, package audit, memory review, and a researcher dashboard",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hongmaple0820/med-scale-research-os.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hongmaple0820/med-scale-research-os/issues"
+  },
+  "homepage": "https://github.com/hongmaple0820/med-scale-research-os#readme",
+  "type": "module",
+  "bin": {
+    "medscale": "dist/api/medscale.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "target-research-platform/main.py",
+    "target-research-platform/bridge_runner.py",
+    "target-research-platform/run_dashboard.py",
+    "target-research-platform/run_real_medical_workflow.py",
+    "target-research-platform/config.yaml",
+    "target-research-platform/requirements.txt",
+    "target-research-platform/pyproject.toml",
+    "target-research-platform/src",
+    "target-research-platform/scripts",
+    "target-research-platform/docs",
+    "target-research-platform/data",
+    ".scale/skills.json",
+    ".scale/mcp-servers.yaml",
+    ".scale/verification.json",
+    "mcp-configs",
+    "docs/README.md",
+    "docs/zh",
+    "docs/guides",
+    "docs/start",
+    "docs/workflow",
+    "docs/reference",
+    "examples/demo-projects/agent-governance-demo",
+    "scripts/workflow/lib",
+    "scripts/workflow/medscale-release-smoke.mjs",
+    "scripts/workflow/setup-smoke.mjs",
+    "scripts/workflow/provider-rehearsal.mjs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "bun --watch src/api/cli.ts",
+    "medscale": "tsx src/api/medscale.ts",
+    "test": "vitest run --reporter dot --pool=forks --maxWorkers=4 --minWorkers=1",
+    "test:serial": "vitest run --reporter dot --pool=forks --poolOptions.forks.maxForks=1 --poolOptions.forks.minForks=1",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/**/*.ts",
+    "docs:cli": "npm run build && node scripts/generate-cli-reference.mjs",
+    "smoke:setup": "node scripts/workflow/setup-smoke.mjs",
+    "smoke:medscale-release": "npm run build && node scripts/workflow/medscale-release-smoke.mjs",
+    "smoke:providers": "node scripts/workflow/provider-rehearsal.mjs",
+    "smoke:gbrain": "node scripts/workflow/provider-rehearsal.mjs --skip-graphify --require-gbrain",
+    "smoke:graphify": "node scripts/workflow/provider-rehearsal.mjs --skip-gbrain --require-graphify",
+    "release:check": "npm run typecheck && npm run lint && npm test && npm run smoke:setup && npm run smoke:providers -- --write-report && npm run smoke:medscale-release && npm audit --omit=dev && git diff --check && npm pack --dry-run",
+    "release:medscale": "npm run typecheck && npm test -- tests/cli/targetCommands.test.ts tests/cli/medscaleCli.test.ts tests/memory/MemoryReview.test.ts && npm run smoke:medscale-release",
+    "mcp": "node dist/api/mcp.js",
+    "serve": "node dist/api/http.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "better-sqlite3": "^11.10.0",
+    "chokidar": "^3.6.0",
+    "citty": "^0.1.6",
+    "content-type": "1.0.5",
+    "element-plus": "^2.8.8",
+    "execa": "^9.3.0",
+    "hono": "^4.5.0",
+    "js-yaml": "^4.1.0",
+    "pino": "^9.3.0",
+    "pino-pretty": "^11.2.0",
+    "type-is": "2.0.1",
+    "vue": "^3.5.17",
+    "zod": "^3.23.0"
+  },
+  "overrides": {
+    "content-type": "1.0.5",
+    "type-is": "2.0.1",
+    "qs": "6.15.2"
+  },
+  "optionalDependencies": {
+    "playwright": "^1.50.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.14.0",
+    "@typescript-eslint/parser": "^8.59.3",
+    "eslint": "^9.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/scripts/workflow/lib/gbrain-runtime.mjs

@@ -0,0 +1,185 @@
+import { createHash } from 'node:crypto'
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+
+const MIRROR_META_FILE = '.scale-gbrain-runtime.json'
+const GBRAIN_TIMEOUT_RECOVERY_COMMANDS = new Set(['--version', 'version', 'doctor', 'list', 'get', 'query', 'search'])
+
+export function resolveDirectWindowsGbrainInvocation(command, args, resolveCommandPath) {
+  if (process.platform !== 'win32' || command !== 'gbrain') return null
+  const gbrainShim = resolveCommandPath('gbrain')
+  if (!gbrainShim || !/\.cmd$/i.test(gbrainShim) || !existsSync(gbrainShim)) return null
+  try {
+    const content = readFileSync(gbrainShim, 'utf8')
+    const match = content.match(/call\s+"([^"]*bun\.cmd)"\s+"([^"]*src[\\/]cli\.ts)"/i)
+    const cliPath = match?.[2]
+    const bunShim = match?.[1] ?? resolveCommandPath('bun')
+    const bunExe = bunShim ? join(dirname(bunShim), 'node_modules', 'bun', 'bin', 'bun.exe') : ''
+    if (cliPath && bunExe && existsSync(bunExe)) {
+      return {
+        command: bunExe,
+        args: [cliPath, ...args],
+        cwd: dirname(dirname(cliPath)),
+        cliPath,
+      }
+    }
+  } catch {
+    return null
+  }
+  return null
+}
+
+export function shouldRetryWithMirroredGbrain(invocation, result) {
+  if (!invocation?.cliPath) return false
+  if (result.status === 0) return false
+  const output = `${String(result.stdout ?? '')}\n${String(result.stderr ?? '')}\n${String(result.error?.message ?? '')}`
+  if (!/EPERM reading/i.test(output)) return false
+  return normalizeForCompare(output).includes(normalizeForCompare(invocation.cliPath))
+}
+
+export function ensureMirroredGbrainInvocation(invocation) {
+  const packageRoot = invocation.cwd
+  const cliMtimeMs = statSync(invocation.cliPath).mtimeMs
+  const version = readPackageVersion(packageRoot)
+  const mirrorKey = `${resolve(packageRoot)}|${version ?? ''}|${cliMtimeMs}`
+  const mirrorRoot = join(
+    tmpdir(),
+    'scale-engine',
+    'gbrain-runtime',
+    createHash('sha1').update(mirrorKey).digest('hex').slice(0, 16),
+  )
+  const cliRelativePath = invocation.cliPath.slice(packageRoot.length + 1)
+  const mirrorCliPath = join(mirrorRoot, cliRelativePath)
+  let selectedRoot = mirrorRoot
+  if (!isMirrorFresh(mirrorRoot, packageRoot, version, cliMtimeMs, mirrorCliPath)) {
+    const stagedRoot = `${mirrorRoot}-staging-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`
+    rmSync(stagedRoot, { recursive: true, force: true })
+    mkdirSync(dirname(mirrorRoot), { recursive: true })
+    cpSync(packageRoot, stagedRoot, { recursive: true, force: true })
+    writeFileSync(join(stagedRoot, MIRROR_META_FILE), JSON.stringify({
+      sourceRoot: packageRoot,
+      version,
+      cliMtimeMs,
+    }, null, 2), 'utf8')
+    const stagedCliPath = join(stagedRoot, cliRelativePath)
+    if (!isMirrorFresh(mirrorRoot, packageRoot, version, cliMtimeMs, mirrorCliPath)) {
+      try {
+        renameSync(stagedRoot, mirrorRoot)
+      } catch {
+        if (isMirrorFresh(mirrorRoot, packageRoot, version, cliMtimeMs, mirrorCliPath)) {
+          rmSync(stagedRoot, { recursive: true, force: true })
+        } else {
+          selectedRoot = stagedRoot
+        }
+      }
+    } else {
+      rmSync(stagedRoot, { recursive: true, force: true })
+    }
+    if (selectedRoot === mirrorRoot && !existsSync(mirrorCliPath) && existsSync(stagedCliPath)) selectedRoot = stagedRoot
+  }
+  return {
+    ...invocation,
+    args: [join(selectedRoot, cliRelativePath), ...invocation.args.slice(1)],
+    cwd: selectedRoot,
+    cliPath: join(selectedRoot, cliRelativePath),
+  }
+}
+
+export function normalizeGbrainSpawnResult(args, result) {
+  const stdout = String(result.stdout ?? '')
+  const stderr = `${String(result.stderr ?? '')}${result.error ? `\n${result.error.message}` : ''}`.trim()
+  const exitCode = typeof result.status === 'number' ? result.status : 1
+  const timedOut = /ETIMEDOUT/i.test(String(result.error?.message ?? ''))
+  const recoveredTimeout = shouldRecoverGbrainTimeout(args, stdout, stderr, exitCode, timedOut)
+  return {
+    stdout,
+    stderr: recoveredTimeout ? stripRecoverableTimeoutNoise(stderr) : stderr,
+    exitCode: recoveredTimeout ? 0 : exitCode,
+    timedOut: recoveredTimeout ? false : timedOut,
+    recoveredTimeout,
+  }
+}
+
+function isMirrorFresh(mirrorRoot, sourceRoot, version, cliMtimeMs, mirrorCliPath) {
+  if (!existsSync(mirrorCliPath)) return false
+  const metadataPath = join(mirrorRoot, MIRROR_META_FILE)
+  if (!existsSync(metadataPath)) return false
+  try {
+    const parsed = JSON.parse(readFileSync(metadataPath, 'utf8'))
+    return parsed.sourceRoot === sourceRoot
+      && parsed.version === version
+      && parsed.cliMtimeMs === cliMtimeMs
+  } catch {
+    return false
+  }
+}
+
+function readPackageVersion(packageRoot) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'))
+    return typeof parsed.version === 'string' ? parsed.version : undefined
+  } catch {
+    return undefined
+  }
+}
+
+function normalizeForCompare(value) {
+  return String(value).replace(/\//g, '\\').toLowerCase()
+}
+
+function shouldRecoverGbrainTimeout(args, stdout, stderr, exitCode, timedOut) {
+  if (!timedOut || exitCode === 0) return false
+  const command = String(args?.[0] ?? '').trim().toLowerCase()
+  if (!command || !GBRAIN_TIMEOUT_RECOVERY_COMMANDS.has(command)) return false
+  const cleanedStderr = stripRecoverableTimeoutNoise(stderr)
+  if (cleanedStderr) return false
+  return hasRecoverableGbrainOutput(command, stdout.trim())
+}
+
+function hasRecoverableGbrainOutput(command, stdout) {
+  if (!stdout) return false
+  switch (command) {
+    case '--version':
+    case 'version':
+      return /\bgbrain\b/i.test(stdout) || /\d+\.\d+\.\d+/.test(stdout)
+    case 'doctor':
+      return looksLikeJsonOutput(stdout)
+    case 'list':
+      return /no pages found/i.test(stdout)
+        || /^\d+\.\s+\S+/m.test(stdout)
+        || /^\[\d+(?:\.\d+)?\]\s+/m.test(stdout)
+    case 'get':
+      return /^---$/m.test(stdout)
+        || /^#\s+\S+/m.test(stdout)
+        || looksLikeJsonOutput(stdout)
+    case 'query':
+    case 'search':
+      return looksLikeJsonOutput(stdout)
+        || /no (pages|results) found/i.test(stdout)
+        || /^\[\d+(?:\.\d+)?\]\s+/m.test(stdout)
+        || /^\d+\.\s+\S+/m.test(stdout)
+    default:
+      return false
+  }
+}
+
+function looksLikeJsonOutput(stdout) {
+  const trimmed = String(stdout ?? '').trim()
+  if (!trimmed || (!trimmed.startsWith('{') && !trimmed.startsWith('['))) return false
+  try {
+    JSON.parse(trimmed)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function stripRecoverableTimeoutNoise(stderr) {
+  return String(stderr ?? '')
+    .replace(/\n?spawnSync .*?\bETIMEDOUT\b\s*/gim, '\n')
+    .replace(/\n?Command failed: .*?\bETIMEDOUT\b\s*/gim, '\n')
+    .replace(/\n?timed out after .*$/gim, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}

package/scripts/workflow/lib/report-output.mjs

@@ -0,0 +1,107 @@
+function stripAnsi(value) {
+  return String(value ?? '').replace(/\u001B\[[0-9;]*m/g, '')
+}
+
+export function summarizeCommandOutput(name, stream, value, max = 1600) {
+  const sanitized = sanitizeCommandOutput(name, stream, stripAnsi(value))
+  if (!sanitized.trim()) return ''
+  const summary = commandSpecificSummary(name, stream, sanitized)
+  return compactText(summary ?? sanitized, max)
+}
+
+export function summarizeCommandRecord(record) {
+  if (!record) return record
+  const {
+    stdout,
+    stderr,
+    ...rest
+  } = record
+  return {
+    ...rest,
+    stdoutTail: summarizeCommandOutput(record.name, 'stdout', stdout ?? record.stdoutTail ?? ''),
+    stderrTail: summarizeCommandOutput(record.name, 'stderr', stderr ?? record.stderrTail ?? ''),
+  }
+}
+
+function sanitizeCommandOutput(name, stream, value) {
+  let text = String(value ?? '').replace(/\r\n/g, '\n').replace(/[�]+/g, '')
+  if (isGbrainCommand(name)) {
+    if (stream === 'stderr') {
+      text = text
+        .replace(/^\s*The system cannot find the path specified\.\s*$/gim, '')
+        .replace(/\n?={20,}\n[\s\S]*?The user owns this decision\.\n={20,}\n?/g, '\n')
+    }
+    if (stream === 'stdout' && /init/i.test(name)) {
+      text = text
+        .replace(/\n?═{10,}\n\[gbrain\] search mode tentatively set[\s\S]*?To see what is running: gbrain search modes\n*/g, '\n')
+        .replace(/\n--- GBrain Mod Status ---[\s\S]*$/g, '')
+    }
+  }
+  return normalizeMultiline(text)
+}
+
+function commandSpecificSummary(name, stream, value) {
+  if (stream !== 'stdout') return undefined
+  if (name === 'gbrain-init' || name === 'gbrain-init-isolated-home') {
+    return collectMatchingLines(value, [
+      /migration\(s\) applied/i,
+      /^Brain ready at /i,
+      /^0 pages\./i,
+      /^Next: /i,
+      /^When you outgrow local:/i,
+    ])
+  }
+  if (name === 'graphify-update' || name === 'graphify-extract') {
+    return collectMatchingLines(value, [
+      /Rebuilt/i,
+      /graph\.json updated/i,
+      /^Code graph updated\./i,
+      /^Tip:/i,
+    ])
+  }
+  if (name === 'graphify-benchmark') {
+    return collectMatchingLines(value, [
+      /^graphify token reduction benchmark$/i,
+      /^\s*Corpus:/i,
+      /^\s*Graph:/i,
+      /^\s*Avg query cost:/i,
+      /^\s*Reduction:/i,
+    ])
+  }
+  if (name === 'graphify-query') {
+    return firstInterestingLines(value, 12)
+  }
+  return undefined
+}
+
+function collectMatchingLines(value, patterns) {
+  const lines = normalizeMultiline(value).split('\n').map(line => line.trim()).filter(Boolean)
+  const selected = lines.filter(line => patterns.some(pattern => pattern.test(line)))
+  return selected.length > 0 ? selected.join('\n') : undefined
+}
+
+function firstInterestingLines(value, maxLines) {
+  const lines = normalizeMultiline(value)
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .filter(line => !/^[=._-]{6,}$/.test(line))
+  return lines.slice(0, maxLines).join('\n')
+}
+
+function compactText(value, max) {
+  const normalized = normalizeMultiline(value)
+  if (normalized.length <= max) return normalized
+  return `${normalized.slice(0, max - 1)}…`
+}
+
+function normalizeMultiline(value) {
+  return String(value ?? '')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}
+
+function isGbrainCommand(name) {
+  return /^gbrain-/i.test(String(name ?? ''))
+}