@asobacloud/nehanda 0.0.0-stage → 0.3.0

package/lib/transcript.mjs

@@ -0,0 +1,223 @@
+import { randomUUID } from 'node:crypto'
+
+function nextSeq(db, sessionId) {
+  const r = db
+    .prepare(`SELECT COALESCE(MAX(sequence), -1) AS m FROM transcript_entries WHERE session_id = ?`)
+    .get(sessionId)
+  return (r?.m ?? -1) + 1
+}
+
+export function appendEntry(db, sessionId, entryType, payload, toolUseId = null) {
+  const seq = nextSeq(db, sessionId)
+  const payloadJson = JSON.stringify(payload)
+  const info = db
+    .prepare(
+      `INSERT INTO transcript_entries(session_id, sequence, entry_type, payload_json, tool_use_id)
+       VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(sessionId, seq, entryType, payloadJson, toolUseId)
+  return info.lastInsertRowid
+}
+
+/** Build Anthropic Messages API messages array from transcript (§2.5). */
+export function transcriptToAnthropicMessages(db, sessionId) {
+  // Check for collapse_commit — if present, start from there
+  const collapse = db.prepare(
+    `SELECT sequence, payload_json FROM transcript_entries WHERE session_id = ? AND entry_type = 'collapse_commit' ORDER BY sequence DESC LIMIT 1`
+  ).get(sessionId)
+
+  let rows
+  if (collapse) {
+    const summary = JSON.parse(collapse.payload_json).summary || ''
+    rows = [
+      { entry_type: 'user', payload_json: JSON.stringify({ _t: 'user', content: [{ type: 'text', text: `[Previous conversation summary]\n${summary}` }] }) },
+      ...db.prepare(
+        `SELECT entry_type, payload_json FROM transcript_entries WHERE session_id = ? AND sequence > ? AND entry_type != 'collapse_commit' ORDER BY sequence ASC`
+      ).all(sessionId, collapse.sequence),
+    ]
+  } else {
+    rows = db.prepare(
+      `SELECT entry_type, payload_json FROM transcript_entries WHERE session_id = ? ORDER BY sequence ASC`
+    ).all(sessionId)
+  }
+  const messages = []
+  let pendingToolResults = []
+
+  const flushToolResults = () => {
+    if (!pendingToolResults.length) return
+    messages.push({ role: 'user', content: pendingToolResults })
+    pendingToolResults = []
+  }
+
+  for (const row of rows) {
+    let payload
+    try { payload = JSON.parse(row.payload_json) } catch { continue }
+
+    if (row.entry_type === 'user') {
+      flushToolResults()
+      const text = extractTextContent(payload)
+      if (text) messages.push({ role: 'user', content: text })
+    } else if (row.entry_type === 'assistant') {
+      flushToolResults()
+      const content = assistantPayloadToApiContent(payload)
+      if (content.length) messages.push({ role: 'assistant', content })
+    } else if (row.entry_type === 'tool_result') {
+      pendingToolResults.push({
+        type: 'tool_result',
+        tool_use_id: payload.tool_use_id,
+        content: typeof payload.content === 'string' ? payload.content : JSON.stringify(payload.content),
+        is_error: Boolean(payload.is_error),
+      })
+    }
+  }
+  flushToolResults()
+  return messages
+}
+
+/** Build OpenAI /v1/chat/completions messages. */
+export function transcriptToOpenAIMessages(db, sessionId) {
+  const collapse = db.prepare(
+    `SELECT sequence, payload_json FROM transcript_entries WHERE session_id = ? AND entry_type = 'collapse_commit' ORDER BY sequence DESC LIMIT 1`
+  ).get(sessionId)
+
+  let rows
+  if (collapse) {
+    const summary = JSON.parse(collapse.payload_json).summary || ''
+    rows = [
+      { entry_type: 'user', payload_json: JSON.stringify({ _t: 'user', content: [{ type: 'text', text: `[Previous conversation summary]\n${summary}` }] }) },
+      ...db.prepare(
+        `SELECT entry_type, payload_json FROM transcript_entries WHERE session_id = ? AND sequence > ? AND entry_type != 'collapse_commit' ORDER BY sequence ASC`
+      ).all(sessionId, collapse.sequence),
+    ]
+  } else {
+    rows = db.prepare(
+      `SELECT entry_type, payload_json FROM transcript_entries WHERE session_id = ? ORDER BY sequence ASC`
+    ).all(sessionId)
+  }
+  const messages = []
+
+  for (const row of rows) {
+    let payload
+    try { payload = JSON.parse(row.payload_json) } catch { continue }
+
+    if (row.entry_type === 'user') {
+      const text = extractTextContent(payload)
+      if (text) messages.push({ role: 'user', content: text })
+    } else if (row.entry_type === 'assistant') {
+      const blocks = payload.content
+      if (!Array.isArray(blocks)) continue
+      const textParts = []
+      const toolUses = []
+      for (const b of blocks) {
+        if (b?.type === 'text' && typeof b.text === 'string') textParts.push(b.text)
+        else if (b?.type === 'tool_use' && b.id && b.name) {
+          toolUses.push({
+            id: b.id,
+            type: 'function',
+            function: {
+              name: b.name,
+              arguments: JSON.stringify(b.input && typeof b.input === 'object' ? b.input : {}),
+            },
+          })
+        }
+      }
+      if (toolUses.length) {
+        messages.push({
+          role: 'assistant',
+          content: textParts.length ? textParts.join('\n') : null,
+          tool_calls: toolUses,
+        })
+      } else if (textParts.length) {
+        messages.push({ role: 'assistant', content: textParts.join('\n') })
+      }
+    } else if (row.entry_type === 'tool_result') {
+      const id = payload.tool_use_id
+      const s = typeof payload.content === 'string' ? payload.content : JSON.stringify(payload.content ?? '')
+      if (id) messages.push({ role: 'tool', tool_call_id: id, content: s })
+    }
+  }
+  return messages
+}
+
+function extractTextContent(payload) {
+  const blocks = payload.content
+  if (!Array.isArray(blocks)) return ''
+  return blocks.filter(b => b?.type === 'text' && typeof b.text === 'string').map(b => b.text).join('\n')
+}
+
+function assistantPayloadToApiContent(payload) {
+  const blocks = payload.content
+  if (!Array.isArray(blocks)) return []
+  const out = []
+  for (const b of blocks) {
+    if (b?.type === 'text' && typeof b.text === 'string') out.push({ type: 'text', text: b.text })
+    else if (b?.type === 'tool_use') out.push({ type: 'tool_use', id: b.id, name: b.name, input: b.input && typeof b.input === 'object' ? b.input : {} })
+  }
+  return out
+}
+
+export function makeUserPayload(text) {
+  return { _t: 'user', uuid: randomUUID(), content: [{ type: 'text', text }] }
+}
+
+export function makeAssistantPayload(contentBlocks) {
+  return { _t: 'assistant', uuid: randomUUID(), content: contentBlocks }
+}
+
+export function makeToolResultPayload(toolUseId, content, isError) {
+  return { _t: 'tool_result', tool_use_id: toolUseId, content, is_error: isError }
+}
+
+/**
+ * Epistemic isolation filter — §8.5.1.
+ *
+ * Strips SEARCH/REPLACE implementation blocks from assistant messages before
+ * building the context for the TEST phase. This guarantees the test-generation
+ * agent cannot read the implementation it is supposed to independently verify.
+ *
+ * A block is defined as any sequence matching:
+ *   <<<<<<< SEARCH ... ======= ... >>>>>>> REPLACE
+ * or the equivalent file-path-prefixed form used by Nehanda.
+ *
+ * Given: an array of OpenAI-format messages and the active workflow phase
+ * When: phase === 'test'
+ * Then: every assistant message has SEARCH/REPLACE blocks replaced with a
+ *       redaction placeholder; all other messages pass through unchanged.
+ * When: phase !== 'test'
+ * Then: messages are returned unmodified.
+ */
+export function applyEpistemicFilter(messages, phase) {
+  if (phase !== 'test') return messages
+
+  const SEARCH_REPLACE_RE = /<<<<<<< SEARCH[\s\S]*?>>>>>>> REPLACE/g
+  const PLACEHOLDER = '[implementation details redacted for epistemic isolation]'
+
+  return messages.map(msg => {
+    if (msg.role !== 'assistant') return msg
+
+    // String content
+    if (typeof msg.content === 'string') {
+      const filtered = msg.content.replace(SEARCH_REPLACE_RE, PLACEHOLDER)
+      return filtered === msg.content ? msg : { ...msg, content: filtered }
+    }
+
+    // Array content (text blocks + possible tool_calls)
+    if (Array.isArray(msg.content)) {
+      const filtered = msg.content.map(block => {
+        if (typeof block === 'string') {
+          return block.replace(SEARCH_REPLACE_RE, PLACEHOLDER)
+        }
+        if (block?.type === 'text' && typeof block.text === 'string') {
+          const t = block.text.replace(SEARCH_REPLACE_RE, PLACEHOLDER)
+          return t === block.text ? block : { ...block, text: t }
+        }
+        return block
+      })
+      // Only return a new object if something actually changed
+      const changed = filtered.some((b, i) => b !== msg.content[i])
+      return changed ? { ...msg, content: filtered } : msg
+    }
+
+    return msg
+  })
+}

package/lib/ui.mjs

@@ -0,0 +1,286 @@
+// Terminal UI — colors, formatting, spinner, markdown rendering
+// Reference: claude-code components/Spinner.tsx, components/Markdown.tsx, components/PromptInput/
+import chalk from 'chalk'
+import { marked } from 'marked'
+import TerminalRenderer from 'marked-terminal'
+
+// Configure marked for terminal output
+marked.setOptions({
+  renderer: new TerminalRenderer({
+    code: chalk.yellow,
+    codespan: chalk.yellow,
+    strong: chalk.bold,
+    em: chalk.italic,
+    heading: chalk.bold.cyan,
+    hr: () => chalk.dim('─'.repeat(60)),
+    listitem: text => `  ${chalk.dim('•')} ${text}`,
+    paragraph: text => text + '\n',
+    table: chalk.reset,
+    link: (href, title, text) => `${text} ${chalk.dim.underline(href)}`,
+  })
+})
+
+export function renderMarkdown(text) {
+  if (!text) return ''
+  try {
+    return marked(text).replace(/\n{3,}/g, '\n\n').trimEnd()
+  } catch {
+    return text
+  }
+}
+
+// ── Colors ──────────────────────────────────────────────────
+
+export const colors = {
+  banner: chalk.bold.hex('#cc785c'),       // warm bronze for ona branding
+  version: chalk.dim,
+  provider: chalk.cyan,
+  model: chalk.bold.white,
+  endpoint: chalk.dim,
+  prompt: chalk.bold.hex('#cc785c'),       // matches banner
+  promptArrow: chalk.bold.hex('#cc785c'),
+  assistant: chalk.reset,
+  toolName: chalk.bold.yellow,
+  toolLabel: chalk.dim.yellow,
+  toolResult: chalk.dim,
+  toolError: chalk.red,
+  error: chalk.red,
+  success: chalk.green,
+  dim: chalk.dim,
+  info: chalk.blue,
+  warning: chalk.yellow,
+  command: chalk.cyan,
+  key: chalk.dim,
+  value: chalk.white,
+  header: chalk.bold.underline,
+  separator: chalk.dim,
+}
+
+// ── Banner ──────────────────────────────────────────────────
+
+export function printBanner(version, dbPath, bare) {
+  const inner = `   ona v${version}   `
+  const width = inner.length
+  const lines = []
+  lines.push('')
+  lines.push(colors.banner(`  ╭${'─'.repeat(width)}╮`))
+  lines.push(colors.banner(`  │`) + `${inner}` + colors.banner(`│`))
+  lines.push(colors.banner(`  ╰${'─'.repeat(width)}╯`))
+  if (bare) lines.push(colors.dim(`  [bare mode]`))
+  lines.push(colors.dim(`  DB: ${dbPath}`))
+  lines.push('')
+  return lines.join('\n')
+}
+
+export function printProviderBanner(provider, wireModel, endpoint) {
+  const lines = []
+  lines.push(`  ${colors.key('Provider:')} ${colors.provider(provider)}`)
+  lines.push(`  ${colors.key('Model:')}    ${colors.model(wireModel)}`)
+  lines.push(`  ${colors.key('Endpoint:')} ${colors.endpoint(endpoint)}`)
+  lines.push('')
+  return lines.join('\n')
+}
+
+// ── Prompt ──────────────────────────────────────────────────
+
+export function formatPrompt() {
+  return colors.promptArrow('❯ ')
+}
+
+// ── Help ────────────────────────────────────────────────────
+
+export function formatHelp(provider, dbPath) {
+  const cmd = (name, desc) => `  ${colors.command(name.padEnd(18))} ${colors.dim(desc)}`
+  const lines = [
+    '',
+    colors.header('Commands'),
+    cmd('/phase', 'Show current SDLC phase'),
+    cmd('/plan', 'Show plan status'),
+    cmd('/code', 'Implement approved plan'),
+    cmd('/test', 'Generate and run tests'),
+    cmd('/verify', 'Coverage report'),
+    cmd('/done', 'Complete workflow'),
+    '',
+    cmd('/init', 'Create Ona.md'),
+    cmd('/diff', 'Uncommitted changes'),
+    cmd('/cost', 'Token usage and cost'),
+    cmd('/doctor', 'Environment diagnostics'),
+    cmd('/permissions', 'Permission rules'),
+    cmd('/pr-comments', 'PR comments (requires gh)'),
+    cmd('/compact', 'Compact conversation'),
+    cmd('/team', 'Manage teams'),
+    '',
+    cmd('/model [name]', 'Change model'),
+    cmd('/login', 'Store credentials'),
+    cmd('/logout', 'Clear credentials'),
+    cmd('/status', 'Auth status'),
+    cmd('/config', 'Show / set settings'),
+    cmd('/config set <key> <value>', 'Set any config value'),
+    cmd('/mcp', 'MCP server management & guide'),
+    cmd('/mcp list', 'List all discovered tools & descriptions'),
+    cmd('/mcp status', 'Show configured MCP servers'),
+    cmd('/mcp env [server] [KEY] [val]', 'Set MCP env vars (API keys)'),
+    cmd('/clear', 'New conversation'),
+    cmd('/exit', 'Quit (/quit)'),
+    '',
+    `  ${colors.key('Provider:')} ${colors.provider(provider)}`,
+    `  ${colors.key('DB:')}       ${colors.dim(dbPath)}`,
+    '',
+  ]
+  return lines.join('\n')
+}
+
+export function formatMcpHelp() {
+  const cmd = (name, desc) => `  ${colors.command(name.padEnd(28))} ${colors.dim(desc)}`
+  const lines = [
+    '',
+    colors.header('MCP Server & Tool Commands'),
+    cmd('/mcp list', 'Discover and list all available MCP tools'),
+    cmd('/mcp status', 'Show configured servers and command paths'),
+    cmd('/mcp reload [server]', 'Reload mcp.json configs into session'),
+    cmd('/mcp add <name> <cmd> [args]', 'Register a new MCP server'),
+    cmd('/mcp env [server] [KEY] [val]', 'View or set server environment variables'),
+    '',
+    colors.dim('  Tip: Run /mcp list to inspect tools injected into the assistant.'),
+    '',
+  ]
+  return lines.join('\n')
+}
+
+// ── Tool display ────────────────────────────────────────────
+
+export function formatToolStart(toolName) {
+  return colors.toolLabel('  ┌ ') + colors.toolName(toolName)
+}
+
+export function formatToolResult(toolName, content, isError) {
+  const icon = isError ? colors.toolError('✗') : colors.success('✓')
+  const label = colors.toolLabel('  └ ')
+  const preview = (content || '').split('\n')[0].slice(0, 80)
+  return label + icon + ' ' + colors.dim(preview)
+}
+
+// ── Spinner ─────────────────────────────────────────────────
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+
+export class Spinner {
+  constructor(io) {
+    this.io = io
+    this.frame = 0
+    this.interval = null
+    this.active = false
+    this.message = 'Thinking'
+  }
+
+  start(message) {
+    if (this.active) return
+    this.active = true
+    this.message = message || 'Thinking'
+    this.frame = 0
+    this.interval = setInterval(() => {
+      const f = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length]
+      this.io.write(`\r${colors.dim(f + ' ' + this.message + '...')}`)
+      this.frame++
+    }, 80)
+  }
+
+  stop() {
+    if (!this.active) return
+    this.active = false
+    if (this.interval) {
+      clearInterval(this.interval)
+      this.interval = null
+    }
+    this.io.write('\r' + ' '.repeat(this.message.length + 20) + '\r')
+  }
+}
+
+// ── Model change ────────────────────────────────────────────
+
+export function formatModelChange(provider, modelId, wireModel, isCustom = false) {
+  const customSuffix = isCustom ? colors.dim(' (custom)') : ''
+  return `  ${colors.success('✓')} Model: ${colors.provider(provider)} ${colors.dim('/')} ${colors.model(wireModel)}${customSuffix}`
+}
+
+// ── Status ──────────────────────────────────────────────────
+
+export function formatStatus(status) {
+  const lines = ['', colors.header('Auth Status')]
+  for (const [k, v] of Object.entries(status)) {
+    if (k === 'alsoConfigured') {
+      const ac = v || {}
+      if (ac.ignoredHints?.length) {
+        lines.push(`  ${colors.key('Notes:')}`)
+        for (const hint of ac.ignoredHints) lines.push(`    ${colors.dim(hint)}`)
+      }
+      continue
+    }
+    const display = typeof v === 'object' ? JSON.stringify(v) : String(v)
+    lines.push(`  ${colors.key(k + ':')} ${colors.value(display)}`)
+  }
+  lines.push('')
+  return lines.join('\n')
+}
+
+// ── Config ──────────────────────────────────────────────────
+
+export function formatConfig(settings) {
+  const lines = ['', colors.header('Settings')]
+  
+  // Show model config with custom indicator
+  if (settings.model_config) {
+    const { provider, model_id, custom_model_name, base_url } = settings.model_config
+    lines.push(`  ${colors.key('Provider:')} ${colors.provider(provider)}`)
+    
+    if (custom_model_name) {
+      lines.push(`  ${colors.key('Model:')}    ${colors.model(custom_model_name)} ${colors.dim('(custom)')}`)
+    } else {
+      lines.push(`  ${colors.key('Model:')}    ${colors.model(model_id)}`)
+    }
+    
+    if (base_url) {
+      lines.push(`  ${colors.key('Base URL:')} ${colors.dim(base_url)}`)
+    }
+    lines.push('')
+  }
+  
+  // Show full JSON for other settings
+  const json = JSON.stringify(settings, null, 2)
+  for (const line of json.split('\n')) {
+    lines.push('  ' + colors.dim(line))
+  }
+  lines.push('')
+  return lines.join('\n')
+}
+
+// ── Separator ───────────────────────────────────────────────
+
+export function separator() {
+  return colors.separator('─'.repeat(60))
+}
+
+// ── Session summary ──────────────────────────────────────────
+
+export function formatSessionSummary(sessionId, tokens, model, provider) {
+  const { input = 0, output = 0, calls = 0 } = tokens
+  const total = input + output
+  const sep = colors.dim('─'.repeat(48))
+
+  const lines = [
+    '',
+    sep,
+    `  ${colors.header('Session Summary')}`,
+    `  ${colors.key('Session:')}  ${colors.dim(sessionId)}`,
+    `  ${colors.key('Model:')}    ${colors.provider(provider)} ${colors.dim('/')} ${colors.model(model)}`,
+    `  ${colors.key('API calls:')} ${colors.value(String(calls))}`,
+    '',
+    `  ${colors.header('Token Usage')}`,
+    `  ${colors.key('Input:')}    ${colors.value(input.toLocaleString())}`,
+    `  ${colors.key('Output:')}   ${colors.value(output.toLocaleString())}`,
+    `  ${colors.key('Total:')}    ${colors.value(total.toLocaleString())}`,
+    sep,
+    '',
+  ]
+  return lines.join('\n')
+}

package/lib/workflow.mjs

@@ -0,0 +1,91 @@
+import { withTransaction } from './store.mjs'
+
+const MUTATING = new Set(['Write', 'Edit', 'Bash', 'NotebookEdit'])
+const PHASES = new Set(['idle', 'planning', 'implement', 'test', 'verify', 'done'])
+
+/** §8.2 — valid transitions. */
+const TRANSITIONS = {
+  idle: new Set(['planning']),
+  planning: new Set(['planning', 'implement']),
+  implement: new Set(['planning', 'test']),
+  test: new Set(['planning', 'verify']),
+  verify: new Set(['planning', 'done']),
+  done: new Set(['planning']),
+}
+
+/** §8.3 — deny mutating tools ONLY during planning phase without an approved plan. */
+export function planningGateDeniesTool(db, conversationId, toolName) {
+  if (!MUTATING.has(toolName)) return false
+  const conv = db.prepare(`SELECT phase FROM conversations WHERE id = ?`).get(conversationId)
+  const phase = conv?.phase || 'idle'
+  // Only block during planning phase — all other phases allow mutating tools
+  if (phase !== 'planning') return false
+  // In planning phase, block unless there's an approved plan
+  const approved = db.prepare(`SELECT 1 AS ok FROM plans WHERE conversation_id = ? AND status = 'approved' LIMIT 1`).get(conversationId)
+  return !approved
+}
+
+/** Check if a transition is valid per §8.2. */
+export function canTransition(db, conversationId, toPhase) {
+  if (!PHASES.has(toPhase)) return { ok: false, reason: `Invalid phase: ${toPhase}` }
+  const conv = db.prepare(`SELECT phase FROM conversations WHERE id = ?`).get(conversationId)
+  const from = conv?.phase || 'idle'
+  const allowed = TRANSITIONS[from]
+  if (!allowed || !allowed.has(toPhase)) {
+    return { ok: false, reason: `Cannot transition from ${from} to ${toPhase} (§8.2)` }
+  }
+
+  if (from === 'planning' && toPhase === 'implement') {
+    const approved = db.prepare(`SELECT 1 AS ok FROM plans WHERE conversation_id = ? AND status = 'approved' LIMIT 1`).get(conversationId)
+    if (!approved) return { ok: false, reason: 'Cannot enter implement: no approved plan (§8.2)' }
+  }
+
+  if (from === 'implement' && toPhase === 'test') {
+    // Implementation complete — tests must be generated next
+  }
+
+  if (from === 'test' && toPhase === 'verify') {
+    // §8.6.2 Coverage gate: all plan-traced tests must pass
+    const results = db.prepare(`SELECT detail FROM events WHERE conversation_id = ? AND event_type = 'test_result'`).all(conversationId)
+    if (!results.length) return { ok: false, reason: 'Cannot transition to verify: no test results recorded. Run /test first.' }
+    const parsed = results.map(r => { try { return JSON.parse(r.detail) } catch { return null } }).filter(Boolean)
+    const failing = parsed.filter(r => !r.passed)
+    if (failing.length) return { ok: false, reason: `Cannot transition to verify: ${failing.length} test(s) failing.` }
+  }
+
+  if (from === 'verify' && toPhase === 'done') {
+    // Operator approval required — handled by caller
+  }
+
+  return { ok: true }
+}
+
+/**
+ * Set the phase for a conversation.
+ * @param {object} db - Database connection
+ * @param {string} conversationId - Conversation ID
+ * @param {string} phase - Target phase
+ * @param {string} [source] - Source of the phase transition (e.g., 'terminal_tool', 'cli_admin')
+ * 
+ * §2, §3.2: Phase transitions should occur through terminal tools.
+ * Terminal tools (EnterPlanMode, ExitPlanMode, SubmitImplementation, SubmitTest) validate
+ * the current phase before calling setPhase(), ensuring legitimate transitions.
+ * CLI commands provide administrative overrides for debugging/manual control.
+ * 
+ * Enforcement is achieved through:
+ * 1. Terminal tools validate current phase before calling setPhase()
+ * 2. canTransition() validates allowed state transitions (§8.2)
+ * 3. Phase-based capability masking prevents unauthorized tool use
+ * 4. Instruction interceptor catches protocol violations
+ */
+export function setPhase(db, conversationId, phase, source = 'unknown') {
+  withTransaction(db, () => {
+    db.prepare(`UPDATE conversations SET phase = ?, last_active = datetime('now') WHERE id = ?`).run(phase, conversationId)
+    db.prepare(`INSERT INTO events(conversation_id, event_type, detail) VALUES (?, 'phase', ?)`).run(conversationId, phase)
+  })
+}
+
+export function getPhase(db, conversationId) {
+  const r = db.prepare(`SELECT phase FROM conversations WHERE id = ?`).get(conversationId)
+  return r?.phase || 'idle'
+}

package/lib/worktree.mjs

@@ -0,0 +1,56 @@
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+
+let currentWorktree = null // { originalCwd, worktreePath, worktreeBranch, name }
+
+const SLUG_RE = /^[a-zA-Z0-9._-]{1,64}$/
+
+export function getCurrentWorktree() { return currentWorktree }
+
+export function createWorktree(cwd, name) {
+  if (!name || !SLUG_RE.test(name)) {
+    return { ok: false, error: `Invalid worktree name: "${name}". Use alphanumeric, dots, dashes, underscores (max 64 chars).` }
+  }
+  if (currentWorktree) {
+    return { ok: false, error: `Already in worktree: ${currentWorktree.name}. Exit first.` }
+  }
+
+  // Find git root
+  const root = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
+  if (root.status !== 0) return { ok: false, error: 'Not in a git repository.' }
+  const gitRoot = root.stdout.trim()
+
+  // Get current branch
+  const branch = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: gitRoot, encoding: 'utf8' })
+  const baseBranch = branch.stdout?.trim() || 'HEAD'
+
+  // Create worktree
+  const wtPath = path.join(gitRoot, '.ona', 'worktrees', name)
+  const wtBranch = `worktree-${name.replace(/\//g, '+')}`
+  const result = spawnSync('git', ['worktree', 'add', '-B', wtBranch, wtPath, baseBranch], { cwd: gitRoot, encoding: 'utf8' })
+  if (result.status !== 0) {
+    return { ok: false, error: `git worktree add failed: ${(result.stderr || result.stdout || '').trim()}` }
+  }
+
+  currentWorktree = { originalCwd: cwd, worktreePath: wtPath, worktreeBranch: wtBranch, name }
+  return { ok: true, worktreePath: wtPath, worktreeBranch: wtBranch }
+}
+
+export function removeWorktree() {
+  if (!currentWorktree) return { ok: false, error: 'Not in a worktree.' }
+
+  const { worktreePath, worktreeBranch, originalCwd } = currentWorktree
+
+  // Remove worktree
+  const rm = spawnSync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: originalCwd, encoding: 'utf8' })
+  if (rm.status !== 0) {
+    return { ok: false, error: `git worktree remove failed: ${(rm.stderr || '').trim()}` }
+  }
+
+  // Delete branch
+  spawnSync('git', ['branch', '-D', worktreeBranch], { cwd: originalCwd, encoding: 'utf8' })
+
+  const result = { ok: true, originalCwd, removedPath: worktreePath }
+  currentWorktree = null
+  return result
+}