lonny-agent 0.2.4 → 0.2.7

package/scripts/check-line-count.mjs

@@ -0,0 +1,53 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const MAX_LINES = 500
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ROOT = join(__dirname, '..')
+const SRC = join(ROOT, 'src')
+
+/** Recursively collect .ts files in a directory (skip node_modules, dist, __tests__). */
+function walk(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true })
+  const files = []
+  for (const entry of entries) {
+    const full = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      if (
+        entry.name === 'node_modules' ||
+        entry.name === 'dist' ||
+        entry.name === '__tests__' ||
+        entry.name === 'pi-tui' ||
+        entry.name.startsWith('.')
+      )
+        continue
+      files.push(...walk(full))
+    } else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+      files.push(full)
+    }
+  }
+  return files
+}
+
+let exitCode = 0
+const files = walk(SRC)
+
+for (const file of files) {
+  try {
+    const content = readFileSync(file, 'utf-8')
+    const lines = content.split('\n').length
+    if (lines > MAX_LINES) {
+      const rel = relative(ROOT, file).replace(/\\/g, '/')
+      console.log(`⚠  ${rel} (${lines} lines) exceeds ${MAX_LINES}-line limit`)
+      exitCode = 1
+    }
+  } catch {
+    // skip unreadable files
+  }
+}
+
+if (exitCode === 0) {
+  console.log(`✓ All ${files.length} source files are under ${MAX_LINES} lines`)
+}
+process.exit(exitCode)

package/scripts/copy-ast-wasm.mjs

@@ -0,0 +1,32 @@
+import { copyFileSync, mkdirSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+const targets = [
+  join(__dirname, '..', 'src', 'tools', 'codebase', 'ast', 'wasm'),
+  join(__dirname, '..', 'dist', 'tools', 'codebase', 'ast', 'wasm'),
+]
+
+const wasmMap = [
+  { id: 'web-tree-sitter/web-tree-sitter.wasm', out: 'web-tree-sitter.wasm' },
+  { id: 'tree-sitter-typescript/tree-sitter-typescript.wasm', out: 'tree-sitter-typescript.wasm' },
+  { id: 'tree-sitter-typescript/tree-sitter-tsx.wasm', out: 'tree-sitter-tsx.wasm' },
+  { id: 'tree-sitter-python/tree-sitter-python.wasm', out: 'tree-sitter-python.wasm' },
+]
+
+for (const dest of targets) {
+  mkdirSync(dest, { recursive: true })
+  for (const { id, out } of wasmMap) {
+    try {
+      const src = require.resolve(id)
+      copyFileSync(src, join(dest, out))
+      console.log(`  ✓ ${dest.endsWith('wasm') ? out : out} → ${dest.slice(dest.indexOf('tools'))}`)
+    } catch (err) {
+      console.warn(`  ⚠ Failed to copy ${out}: ${err.message}`)
+    }
+  }
+}

package/scripts/copy-native.mjs

@@ -0,0 +1,24 @@
+// copy:native — recursively copies src/pi-tui/native/ to dist/pi-tui/native/
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'fs'
+import { join } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = fileURLToPath(new URL('..', import.meta.url))
+
+function cpDir(s, d) {
+  mkdirSync(d, { recursive: true })
+  for (const e of readdirSync(s)) {
+    const sp = join(s, e)
+    const dp = join(d, e)
+    if (statSync(sp).isDirectory()) {
+      cpDir(sp, dp)
+    } else {
+      copyFileSync(sp, dp)
+    }
+  }
+}
+
+const src = join(__dirname, 'src', 'pi-tui', 'native')
+const dst = join(__dirname, 'dist', 'pi-tui', 'native')
+
+if (existsSync(src)) cpDir(src, dst)

package/scripts/copy-web.mjs

@@ -0,0 +1,15 @@
+// copy:web — copies src/web/public/ to dist/web/public/
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'fs'
+import { join } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = fileURLToPath(new URL('..', import.meta.url))
+const src = join(__dirname, 'src', 'web', 'public')
+const dst = join(__dirname, 'dist', 'web', 'public')
+
+if (existsSync(src)) {
+  if (!existsSync(dst)) mkdirSync(dst, { recursive: true })
+  for (const f of readdirSync(src)) {
+    copyFileSync(join(src, f), join(dst, f))
+  }
+}

package/src/agent/__tests__/session-restore.test.ts

@@ -0,0 +1,284 @@
+import * as crypto from 'node:crypto'
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import type { Config } from '../../config/index.js'
+import type { LLMMessage } from '../llm.js'
+import { Session } from '../session.js'
+
+/**
+ * Helper: build a minimal Config with a project-subdir cwd for test session files.
+ * Using the project directory ensures detectPackageManager etc. find a valid cwd.
+ * Each test gets a fresh subdirectory that gets cleaned up after.
+ */
+function testConfig(): Config {
+  const testDir = path.join(process.cwd(), '.test-sessions', crypto.randomUUID().slice(0, 8))
+  fs.mkdirSync(testDir, { recursive: true })
+  // Create a package.json so detectPackageManager doesn't fail async
+  fs.writeFileSync(path.join(testDir, 'package.json'), JSON.stringify({ name: 'test' }), 'utf-8')
+  return {
+    mode: 'code',
+    model: 'test-model',
+    provider: 'openai',
+    apiKey: 'test-key',
+    baseUrl: 'http://test',
+    cwd: testDir,
+    autoApprove: true,
+    thinking: false,
+    reasoningEffort: 'medium',
+    enableCache: false,
+    strictTools: false,
+    contextWindow: 128_000,
+  }
+}
+
+/**
+ * Build the session file path matching what save() would write.
+ */
+function sessionFilePath(cwd: string, sessionId: string): string {
+  const { createHash } = require('node:crypto')
+  const absPath = path.resolve(cwd)
+  const hash = createHash('sha256').update(absPath, 'utf-8').digest('hex').slice(0, 12)
+  const dirName = path.basename(absPath)
+  const safeName = dirName.replace(/[<>:"/\\|?*]/g, '_')
+  const base = `${safeName}-${hash}`
+  const sessionDir = path.join(os.homedir(), '.lonny', 'sessions')
+  return path.join(sessionDir, `${base}-${sessionId}.json`)
+}
+
+describe('Session save/load cycle', () => {
+  let config: Config
+  let sessionId: string
+  let filePath: string
+
+  beforeEach(() => {
+    config = testConfig()
+    const { randomUUID } = require('node:crypto')
+    sessionId = randomUUID().slice(0, 8)
+    filePath = sessionFilePath(config.cwd, sessionId)
+    // Ensure session directory exists
+    const dir = path.dirname(filePath)
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  })
+
+  afterEach(() => {
+    try {
+      if (fs.existsSync(filePath)) fs.unlinkSync(filePath)
+    } catch {
+      /* ignore */
+    }
+    // Don't clean up .test-sessions dir — buildSystemPrompt fires async and may
+    // still be reading the cwd. The dir is gitignored and cleaned on restart.
+  })
+
+  test('restores assistant message with text + tool_calls + tool results', async () => {
+    const messages: LLMMessage[] = [
+      { role: 'system', content: 'You are a helpful assistant.' },
+      { role: 'user', content: 'Fix the bug in the code.' },
+      {
+        role: 'assistant',
+        content: 'I see the root cause. Three fixes needed:\n\n1. Remove X\n2. Add Y',
+        tool_calls: [
+          { id: 'call_abc', name: 'edit', input: { file: 'test.ts', old: 'a', new: 'b' } },
+          { id: 'call_def', name: 'read', input: { file: 'test.ts' } },
+        ],
+      },
+      { role: 'tool', content: 'Edited test.ts', tool_call_id: 'call_abc', name: 'edit' },
+      { role: 'tool', content: 'File contents...', tool_call_id: 'call_def', name: 'read' },
+      { role: 'assistant', content: 'Done with fixes.' },
+      { role: 'user', content: 'Great, thanks!' },
+    ]
+
+    // Write session file (simulating what save() would produce)
+    const data = {
+      id: sessionId,
+      cwd: path.resolve(config.cwd),
+      messages,
+      totalInputTokens: 100,
+      totalOutputTokens: 50,
+      totalApiCalls: 2,
+      mode: 'code',
+      model: 'test-model',
+      provider: 'test-provider',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
+
+    // Load the session from disk
+    const session = await Session.load(config)
+    expect(session).not.toBeNull()
+
+    // Verify ALL messages are preserved
+    expect(session!.messages.length).toBe(messages.length)
+    for (let i = 0; i < messages.length; i++) {
+      expect(session!.messages[i].role).toBe(messages[i].role)
+    }
+
+    // Verify the critical assistant message (text + tool_calls)
+    const assistantWithTools = session!.messages.find(
+      m => m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0,
+    )
+    expect(assistantWithTools).toBeDefined()
+    expect(assistantWithTools!.content).toContain('I see the root cause')
+    expect(assistantWithTools!.tool_calls).toHaveLength(2)
+
+    // Verify tool results still reference the correct tool_call_ids
+    const toolMsgs = session!.messages.filter(m => m.role === 'tool')
+    expect(toolMsgs).toHaveLength(2)
+    expect(toolMsgs[0].tool_call_id).toBe('call_abc')
+    expect(toolMsgs[1].tool_call_id).toBe('call_def')
+  })
+
+  test('preserves assistant message with text-only (no tool_calls)', async () => {
+    const messages: LLMMessage[] = [
+      { role: 'system', content: 'system prompt' },
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there!' },
+      { role: 'user', content: 'How are you?' },
+      { role: 'assistant', content: "I'm great, thanks!" },
+    ]
+
+    const data = {
+      id: sessionId,
+      cwd: path.resolve(config.cwd),
+      messages,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalApiCalls: 0,
+      mode: 'code',
+      model: 'test-model',
+      provider: 'test-provider',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
+
+    const session = await Session.load(config)
+    expect(session).not.toBeNull()
+    expect(session!.messages.length).toBe(messages.length)
+    expect(session!.messages[2].content).toBe('Hi there!')
+    expect(session!.messages[4].content).toBe("I'm great, thanks!")
+  })
+
+  test('loads session with most messages when multiple session files exist', async () => {
+    // Create a "newer but emptier" session file
+    const newSessionId = 'new_empty_' + require('node:crypto').randomUUID().slice(0, 4)
+    const newFilePath = sessionFilePath(config.cwd, newSessionId)
+    const emptyMessages: LLMMessage[] = [
+      { role: 'system', content: 'system prompt' },
+      { role: 'user', content: 'Hello' },
+    ]
+    const newData = {
+      id: newSessionId,
+      cwd: path.resolve(config.cwd),
+      messages: emptyMessages,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalApiCalls: 0,
+      mode: 'code',
+      model: 'test-model',
+      provider: 'test-provider',
+      createdAt: new Date(Date.now() + 60_000).toISOString(), // 1 minute in the future
+      updatedAt: new Date(Date.now() + 60_000).toISOString(), // 1 minute in the future
+    }
+    fs.writeFileSync(newFilePath, JSON.stringify(newData, null, 2), 'utf-8')
+
+    // Create an "older but fuller" session file
+    const fullMessages: LLMMessage[] = [
+      { role: 'system', content: 'system prompt' },
+      { role: 'user', content: 'Do the first thing.' },
+      {
+        role: 'assistant',
+        content: 'Working on it.',
+        tool_calls: [{ id: 't1', name: 'bash', input: { command: 'echo 1' } }],
+      },
+      { role: 'tool', content: '1', tool_call_id: 't1', name: 'bash' },
+      { role: 'user', content: 'Now the second thing.' },
+      { role: 'assistant', content: 'Doing it.' },
+      { role: 'user', content: 'Great!' },
+    ]
+
+    const data = {
+      id: sessionId,
+      cwd: path.resolve(config.cwd),
+      messages: fullMessages,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalApiCalls: 0,
+      mode: 'code',
+      model: 'test-model',
+      provider: 'test-provider',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(), // OLDER timestamp
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
+
+    // Load — should pick the FULL session (7 messages) over the NEWER but EMPTIER one (2 messages)
+    const session = await Session.load(config)
+    expect(session).not.toBeNull()
+    expect(session!.messages.length).toBe(7)
+    expect(session!.messages[1].content).toBe('Do the first thing.')
+
+    // Clean up the extra file
+    try {
+      fs.unlinkSync(newFilePath)
+    } catch {
+      /* ignore */
+    }
+  })
+
+  test('sanitizeMessages keeps complete assistant+tool sequences', async () => {
+    // Two complete turns, each with tool_calls+results — should all survive
+    const messages: LLMMessage[] = [
+      { role: 'system', content: 'system prompt' },
+      { role: 'user', content: 'Do the first thing.' },
+      {
+        role: 'assistant',
+        content: 'Working on it.',
+        tool_calls: [{ id: 't1', name: 'bash', input: { command: 'echo 1' } }],
+      },
+      { role: 'tool', content: '1', tool_call_id: 't1', name: 'bash' },
+      { role: 'user', content: 'Now the second thing.' },
+      {
+        role: 'assistant',
+        content: 'Doing it.',
+        tool_calls: [
+          { id: 't2', name: 'bash', input: { command: 'echo 2' } },
+          { id: 't3', name: 'edit', input: { file: 'x.ts', old: 'a', new: 'b' } },
+        ],
+      },
+      { role: 'tool', content: '2', tool_call_id: 't2', name: 'bash' },
+      { role: 'tool', content: 'Edited x.ts', tool_call_id: 't3', name: 'edit' },
+      { role: 'assistant', content: 'Done!' },
+    ]
+
+    const data = {
+      id: sessionId,
+      cwd: path.resolve(config.cwd),
+      messages,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalApiCalls: 0,
+      mode: 'code',
+      model: 'test-model',
+      provider: 'test-provider',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
+
+    const session = await Session.load(config)
+    expect(session).not.toBeNull()
+    expect(session!.messages.length).toBe(messages.length)
+
+    // Both assistant messages with tool_calls should be present
+    const assistantWithTools = session!.messages.filter(
+      m => m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0,
+    )
+    expect(assistantWithTools).toHaveLength(2)
+    expect(assistantWithTools[0].content).toBe('Working on it.')
+    expect(assistantWithTools[1].content).toBe('Doing it.')
+  })
+})

package/src/agent/commands.ts

@@ -0,0 +1,274 @@
+import type { Config } from '../config/index.js'
+import { resetTokenUsage } from '../config/tokens.js'
+import { fmtErr } from '../tools/errors.js'
+import { resetGlobalEventBus } from './event-bus.js'
+import type { LLMMessage } from './llm.js'
+import { ensurePromptsDir, loadPromptTemplates } from './prompt-templates.js'
+import { Session } from './session.js'
+import { ensureSkillsDir, loadSkills } from './skills.js'
+
+export interface CommandUI {
+  write(text: string): void
+  replaceContent(text: string): void
+  onStateChange(): void
+  onNewSession(session: Session): void
+}
+
+export interface CommandEnv {
+  session: Session
+  config: Config
+  ui: CommandUI
+  isRunning: boolean
+}
+
+export function handleNew(env: CommandEnv): Session {
+  env.session.stop()
+  Session.clearSavedSession(env.config.cwd)
+  resetTokenUsage(env.config.cwd)
+  resetGlobalEventBus()
+  const newSession = new Session(env.config, env.session.output)
+  newSession.onPlanWritten = env.session.onPlanWritten
+  env.ui.replaceContent('')
+  env.ui.onNewSession(newSession)
+  env.ui.onStateChange()
+  return newSession
+}
+
+export async function handleMode(env: CommandEnv, mode: string): Promise<boolean> {
+  if (mode !== 'code' && mode !== 'plan' && mode !== 'ask' && mode !== 'loop') {
+    env.ui.write(`Usage: /mode code|plan|ask|loop  (current: ${env.session.config.mode})`)
+    return true
+  }
+  await env.session.setMode(mode)
+  env.ui.write(`Switched to ${mode} mode`)
+  env.ui.onStateChange()
+  return true
+}
+
+export function handleModel(env: CommandEnv, model: string): boolean {
+  if (!model) {
+    env.ui.write(`Current model: ${env.session.config.model}`)
+    return true
+  }
+  env.session.config.model = model
+  // Trigger system prompt rebuild by re-setting mode
+  env.session.setMode(env.session.config.mode)
+  env.ui.write(`Model switched to ${model}`)
+  env.ui.onStateChange()
+  return true
+}
+
+export function handlePrompts(env: CommandEnv): boolean {
+  const templates = loadPromptTemplates(env.config.cwd)
+  if (templates.length === 0) {
+    env.ui.write('No prompt templates found. Create .md files in .lonny/prompts/')
+  } else {
+    let msg = `Prompt Templates (${templates.length}):\n`
+    for (const t of templates) {
+      msg += `  \u2022 ${t.name}`
+      if (t.description) msg += ` \u2014 ${t.description}`
+      msg += '\n'
+    }
+    env.ui.write(msg.trimEnd())
+  }
+  return true
+}
+
+export function handleSkills(env: CommandEnv): boolean {
+  const skills = loadSkills(env.config.cwd)
+  if (skills.length === 0) {
+    env.ui.write('No skills loaded. Create .md files in .lonny/skills/')
+  } else {
+    let msg = `Active Skills (${skills.length}):\n`
+    for (const s of skills) {
+      msg += `  \u2022 ${s.name}`
+      if (s.description) msg += ` \u2014 ${s.description}`
+      msg += '\n'
+    }
+    env.ui.write(msg.trimEnd())
+  }
+  return true
+}
+
+export function handleSessions(env: CommandEnv): boolean {
+  const allSessions = Session.listSessions()
+  if (allSessions.length === 0) {
+    env.ui.write('No saved sessions found.')
+    return true
+  }
+  let msg = `Saved Sessions (${allSessions.length}):\n`
+  msg +=
+    '  ID        Title                                       Mode    Messages  Tokens    Updated\n'
+  for (const s of allSessions) {
+    const id = s.id.padEnd(9)
+    const title = (s.title || '(untitled)').slice(0, 42).padEnd(43)
+    const mode = s.mode.padEnd(7)
+    const msgs = String(s.messageCount).padEnd(9)
+    const tokens = String(s.totalInputTokens + s.totalOutputTokens).padEnd(9)
+    const date = s.updatedAt.slice(0, 10)
+    msg += `  ${id} ${title} ${mode} ${msgs} ${tokens} ${date}\n`
+  }
+  msg += '\n  Use /session delete <id> to delete a session'
+  env.ui.write(msg)
+  return true
+}
+
+export async function handleSessionCommand(env: CommandEnv, arg: string): Promise<boolean> {
+  if (arg === 'delete' || arg.startsWith('delete ')) {
+    const id = arg.slice(arg.startsWith('delete ') ? 7 : 6).trim()
+    if (id) {
+      const deleted = Session.deleteSession(id)
+      if (deleted) {
+        env.ui.write(`Deleted session ${id}`)
+      } else {
+        env.ui.write(`Session not found: ${id}`)
+      }
+    } else {
+      env.ui.write('Usage: /session delete <id>')
+    }
+    return true
+  }
+
+  if (arg.startsWith('title ')) {
+    const title = arg.slice(6).trim()
+    if (title) {
+      env.session.sessionTitle = title
+      env.session.save()
+      env.ui.write(`Session titled: ${title}`)
+    } else {
+      env.ui.write('Usage: /session title <name>')
+    }
+    return true
+  }
+
+  if (arg === 'export') {
+    try {
+      const filePath = env.session.exportSession()
+      env.ui.write(`Session exported to ${filePath}`)
+    } catch (err) {
+      env.ui.write(`Export failed: ${fmtErr(err)}`)
+    }
+    return true
+  }
+
+  if (arg === 'switch' || arg.startsWith('switch ')) {
+    const id = arg.startsWith('switch ') ? arg.slice(7).trim() : ''
+    if (!id) {
+      env.ui.write('Usage: /session switch <id>. Use /sessions to list session IDs.')
+      return true
+    }
+    if (env.isRunning) {
+      env.ui.write('Cannot switch session while agent is running. Wait or use /stop first.')
+      return true
+    }
+    const switched = await Session.loadById(id, env.config, env.session.output)
+    if (switched) {
+      switched.onPlanWritten = env.session.onPlanWritten
+      const preview = lastUserQuestion(switched.messages)
+      let msg = `Switched to session ${switched.sessionTitle || switched.sessionId}`
+      if (preview) msg += ` Last question: ${preview}`
+      env.ui.replaceContent(msg + '\n')
+      env.ui.onNewSession(switched)
+      env.ui.onStateChange()
+    } else {
+      env.ui.write(`Session not found: ${id}`)
+    }
+    return true
+  }
+
+  // Default: show current session info
+  const id = env.session.sessionId
+  const title = env.session.sessionTitle || '(untitled)'
+  const mode = env.session.config.mode
+  const model = env.session.config.model
+  const provider = env.session.config.provider
+  const msgs = env.session.messages.length
+  const totalIn = env.session.totalInputTokens
+  const totalOut = env.session.totalOutputTokens
+  const totalApi = env.session.totalApiCalls
+  const created = env.session.sessionCreatedAt.slice(0, 10)
+  const info =
+    '' +
+    `ID:       ${id}\n` +
+    `Title:    ${title}\n` +
+    `Mode:     ${mode}\n` +
+    `Model:    ${model} (${provider})\n` +
+    `Messages: ${msgs}\n` +
+    `Tokens:   ${totalIn + totalOut} (in: ${totalIn}, out: ${totalOut})\n` +
+    `API Calls: ${totalApi}\n` +
+    `Created:  ${created}\n`
+  env.ui.write(info.trimEnd())
+  return true
+}
+
+export async function handleFork(env: CommandEnv): Promise<boolean> {
+  if (env.isRunning) {
+    env.ui.write('Cannot fork while agent is running. Wait or use /stop first.')
+    return true
+  }
+  if (env.session.messages.length <= 1) {
+    env.ui.write('No conversation to fork. Start a conversation first.')
+    return true
+  }
+  const forked = env.session.fork()
+  forked.onPlanWritten = env.session.onPlanWritten
+  const baseTitle = forked.sessionTitle || 'forked session'
+  env.ui.write(`Forked new session: ${baseTitle}`)
+  env.ui.write(`  ID: ${forked.sessionId}`)
+  env.ui.onNewSession(forked)
+  env.ui.onStateChange()
+  return true
+}
+
+export function handleInit(env: CommandEnv): boolean {
+  ensureSkillsDir(env.config.cwd)
+  ensurePromptsDir(env.config.cwd)
+  env.ui.write('Initialized .lonny/skills/ and .lonny/prompts/')
+  return true
+}
+
+export function handleStop(env: CommandEnv): boolean {
+  if (!env.isRunning) {
+    env.ui.write('Agent is not running.')
+    return true
+  }
+  env.session.stop()
+  env.ui.write('Stopping agent...')
+  return true
+}
+
+function lastUserQuestion(messages: LLMMessage[]): string | null {
+  const lastUserMsg = [...messages].reverse().find(m => m.role === 'user')
+  if (!lastUserMsg || typeof lastUserMsg.content !== 'string') return null
+  return lastUserMsg.content.length > 80
+    ? `${lastUserMsg.content.slice(0, 80)}\u2026`
+    : lastUserMsg.content
+}
+
+export async function dispatchCommand(env: CommandEnv, cmd: string, arg: string): Promise<boolean> {
+  switch (cmd) {
+    case 'new':
+      handleNew(env)
+      return true
+    case 'mode':
+      return handleMode(env, arg)
+    case 'model':
+      return handleModel(env, arg)
+    case 'prompts':
+      return handlePrompts(env)
+    case 'skills':
+      return handleSkills(env)
+    case 'sessions':
+      return handleSessions(env)
+    case 'session':
+      return handleSessionCommand(env, arg)
+    case 'fork':
+      return handleFork(env)
+    case 'init':
+      return handleInit(env)
+    case 'stop':
+      return handleStop(env)
+    default:
+      return false
+  }
+}