lonny-agent 0.2.6 → 0.2.7

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
+  }
+}

package/src/agent/compaction.ts

@@ -186,12 +186,19 @@ function buildSummary(messages: LLMMessage[]): string {
 
 function extractEditPaths(input: Record<string, unknown>): string[] {
   const paths: string[] = []
+  // Accumulate paths from legacy input format: { edits: [{ file_path: '...' }, ...] }
   if (Array.isArray(input.edits)) {
     for (const e of input.edits) {
       if (typeof e === 'object' && e && 'file_path' in e) {
-        paths.push(e.file_path as string)
+        paths.push((e as Record<string, unknown>).file_path as string)
       }
     }
   }
-  return paths
+  // Also support direct input format used by tests: { file_path: '...' }
+  const direct = input as Record<string, unknown>
+  if (typeof direct.file_path === 'string') {
+    paths.push(direct.file_path)
+  }
+  // Deduplicate to avoid reporting duplicates
+  return Array.from(new Set(paths))
 }

package/src/agent/index.ts

@@ -1,25 +1,30 @@
-import * as readline from 'node:readline'
-import type { Config } from '../config/index.js'
-import { Session, type SessionOutput } from './session.js'
-
-export async function runAgent(prompt: string, config: Config): Promise<void> {
-  const output: SessionOutput = {
-    write: text => process.stdout.write(text),
-    confirmTool: async toolCalls => {
-      console.log('\nAllow these tool calls?')
-      for (const tc of toolCalls) {
-        const input = JSON.stringify(tc.input)
-        console.log(`  \u2022 ${tc.name}: ${input.slice(0, 120)}`)
-      }
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-      return new Promise(resolve => {
-        rl.question('  (y/N) ', answer => {
-          rl.close()
-          resolve(answer.trim().toLowerCase() === 'y')
-        })
-      })
-    },
-  }
-  const session = (await Session.load(config, output)) || new Session(config, output)
-  await session.chat(prompt)
-}
+import * as readline from 'node:readline'
+import type { Config } from '../config/index.js'
+import { Session, type SessionOutput } from './session.js'
+
+export async function runAgent(
+  prompt: string,
+  config: Config,
+  preloadedSession?: Session,
+): Promise<void> {
+  const output: SessionOutput = {
+    write: text => process.stdout.write(text),
+    confirmTool: async toolCalls => {
+      console.log('\nAllow these tool calls?')
+      for (const tc of toolCalls) {
+        const input = JSON.stringify(tc.input)
+        console.log(`  \u2022 ${tc.name}: ${input.slice(0, 120)}`)
+      }
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+      return new Promise(resolve => {
+        rl.question('  (y/N) ', answer => {
+          rl.close()
+          resolve(answer.trim().toLowerCase() === 'y')
+        })
+      })
+    },
+  }
+  const session =
+    preloadedSession ?? (await Session.load(config, output)) ?? new Session(config, output)
+  await session.chat(prompt)
+}

package/src/agent/memory.ts

@@ -0,0 +1,60 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+export interface MemoryEntry {
+  id: string
+  createdAt: string
+  content: string
+  tags?: string[]
+}
+
+const MEM_DIR = '.lonny/memory'
+
+export function getMemoryDir(cwd: string): string {
+  return path.resolve(cwd, MEM_DIR)
+}
+
+export function ensureMemoryDir(cwd: string): void {
+  const d = getMemoryDir(cwd)
+  if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true })
+}
+
+export function loadMemory(cwd: string): MemoryEntry[] {
+  const d = getMemoryDir(cwd)
+  try {
+    if (!fs.existsSync(d)) return []
+    const files = fs.readdirSync(d).filter(f => f.endsWith('.json'))
+    const out: MemoryEntry[] = []
+    for (const f of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(d, f), 'utf-8'))
+        out.push(data as MemoryEntry)
+      } catch (e) {
+        // ignore corrupted file
+      }
+    }
+    // sort by createdAt
+    out.sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+    return out
+  } catch (e) {
+    return []
+  }
+}
+
+export function saveMemory(cwd: string, entry: MemoryEntry): void {
+  ensureMemoryDir(cwd)
+  const id = entry.id || String(Date.now())
+  const file = path.join(getMemoryDir(cwd), `${id}.json`)
+  fs.writeFileSync(file, JSON.stringify(entry, null, 2), 'utf-8')
+}
+
+export function formatMemoryForPrompt(memories: MemoryEntry[]): string {
+  if (!memories || memories.length === 0) return ''
+  const parts: string[] = []
+  for (const m of memories) {
+    parts.push(
+      `- [${m.createdAt}] ${m.content.slice(0, 400).replace(/\n/g, ' ')}${m.content.length > 400 ? '…' : ''}`,
+    )
+  }
+  return parts.join('\n')
+}

package/src/agent/prompt-builder.ts

@@ -1,13 +1,26 @@
 import * as os from 'node:os'
 import type { Config } from '../config/index.js'
+import { formatToolTreeForPrompt } from '../tools/tree.js'
+import type { ToolDefinition } from '../tools/types.js'
+
+const CORE_TOOL_NAMES = new Set(['read', 'edit', 'bash', 'glob', 'grep'])
+
+import { formatMemoryForPrompt, loadMemory } from './memory.js'
 import { discoverProject, formatProjectContext } from './project.js'
 import { formatSkillsForPrompt, loadSkills } from './skills.js'
 
 /**
  * Build the system prompt for the current configuration.
  * Extracted from session.ts to keep module size manageable (<500 LoC target).
+ *
+ * @param config - Current configuration
+ * @param definitions - Optional tool definitions for dynamic tree generation.
+ *   When provided, replaces the hardcoded tool lists with a hierarchical tree.
  */
-export async function buildSystemPrompt(config: Config): Promise<string> {
+export async function buildSystemPrompt(
+  config: Config,
+  definitions?: ToolDefinition[],
+): Promise<string> {
   const platform = os.platform()
   const release = os.release()
   const shell = process.env.SHELL || process.env.ComSpec || 'unknown'
@@ -19,12 +32,33 @@ export async function buildSystemPrompt(config: Config): Promise<string> {
   const skills = loadSkills(cwd)
   const skillsSection = formatSkillsForPrompt(skills)
 
+  // ── Load long-term memory (persistent) ─────────────────────────────────
+  const memories = loadMemory(cwd)
+  const memorySection = formatMemoryForPrompt(memories)
+
   // ── Load project context ─────────────────────────────────────────────────
   const projectInfo = await discoverProject(cwd)
   const projectSection = formatProjectContext(projectInfo)
 
   // ── Mode-specific tool list ───────────────────────────────────────────
   function getToolListForMode(mode: string): string {
+    // When tool definitions are available, use the dynamic tree
+    if (definitions && definitions.length > 0) {
+      const header =
+        mode === 'plan'
+          ? 'Available tools (read-only investigation + write_plan):'
+          : mode === 'ask'
+            ? 'Available tools:'
+            : 'Available tools:'
+      const tree = formatToolTreeForPrompt(definitions, CORE_TOOL_NAMES)
+      const note =
+        mode !== 'ask'
+          ? '\n  Direct access: read, edit, bash, glob, grep\n  Extended tools: use `tool()` gateway (see tree above)\n'
+          : ''
+      return `${header}\n${tree}${note}\n`
+    }
+
+    // Fallback hardcoded lists (when definitions not available)
     if (mode === 'ask') {
       return `Available tools:
 - \`fetch\`: Fetch content from a URL
@@ -50,11 +84,12 @@ export async function buildSystemPrompt(config: Config): Promise<string> {
 - \`grep\`: Search file content by regex (pattern: string, include?: string, path?: string)
 - \`ls\`: List directory (path?: string)
       - \`bash\`: Execute a shell command — for running commands (NOT for creating or modifying files — use \`edit\` for that)
-- \`edit\`: Replace text in files using markdown code block format. Use: \`edit({ content: "\`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`" })\`
-- \`install_skill\`: Install an npm package as a skill — fetches package info from npm, runs npm install, and creates a .lonny/skills/ file with usage instructions for the AI
-- \`find\`: Find files by name pattern (pattern: string, path?: string, maxResults?: number)
-- \`git\`: Run read-only git commands (command: string)
-- \`search\`: Search the web using Tavily (query: string, search_depth?: string, include_answer?: boolean, max_results?: number, topic?: string, days?: number)
+      - \`edit\`: Replace text in files using markdown code block format. Use: \`edit({ content: "\`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`" })\`. NOTE: There is no "write" tool — always use \`edit\` to modify files.
+  - \`install_skill\`: Install an npm package as a skill — fetches package info from npm, runs npm install, and creates a .lonny/skills/ file with usage instructions for the AI
+  - \`save_memory\`: Save a memory entry to long-term memory (content: string, tags?: string[])
+  - \`find\`: Find files by name pattern (pattern: string, path?: string, maxResults?: number)
+  - \`git\`: Run read-only git commands (command: string)
+  - \`search\`: Search the web using Tavily (query: string, search_depth?: string, include_answer?: boolean, max_results?: number, topic?: string, days?: number)
 `
   }
 
@@ -63,14 +98,49 @@ export async function buildSystemPrompt(config: Config): Promise<string> {
 RULES:
 1. Read first: Use read/grep/glob tools to gather all context you need before making any edits.
 2. Be thorough: Explore the relevant parts of the codebase.
-3. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({ content: "..." })\` with multiple \`\`\`edit blocks to edit multiple files at once.
+ 3. AST tools (\`ast_query\`, \`ast_edit\`) are available via the \`tool()\` gateway. Use \`ast_query\` to inspect code structure (functions, classes, imports) before editing. Use \`ast_edit\` for structure-aware edits that preserve formatting.
+4. **For JavaScript/TypeScript files, prefer AST tools over raw text tools**: Use \`ast_query\` (not \`read\`) to understand file structure — it returns structured function/class/import/export data with exact line numbers. Use \`ast_edit\` (not \`edit\`) to replace entire functions, classes, or variables — it avoids string-matching issues and preserves formatting. Reserve \`edit\` for small surgical changes to function bodies or single-line fixes.
+5. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({ content: "..." })\` with multiple \`\`\`edit blocks to edit multiple files at once.
+6. There is NO "write" tool. To modify files, use the \`edit\` tool (listed above). Calling \`write\` will fail with "Unknown tool".
+
+${getToolListForMode(config.mode)}
+`
+  // ── Memory section (appended to system prompt to provide long-term context) ──
+  const memoryPromptSection = memorySection ? `\n## Long-term Memory\n\n${memorySection}` : ''
 
-${getToolListForMode(config.mode)}`
+  // NOTE: Mention save_memory in loop/code mode tool lists only if the tool exists at runtime.
+  // The tool may be provided via plugin or future implementation.
 
   // ── Mode-specific instructions ───────────────────────────────────────────
   const modeInstructions =
-    config.mode === 'plan'
-      ? `You are a planning agent. Your ONLY job is to investigate the codebase and produce an actionable implementation plan with a todo list.
+    config.mode === 'loop'
+      ? `You are an autonomous coding agent operating in LOOP mode. You will CONTINUE working on the task automatically after each turn — you do NOT need to ask for confirmation between steps.
+
+${getToolListForMode('loop')}
+RULES (loop-specific):
+ 1. Read first: Use read/grep/glob tools to gather all context you need BEFORE making any edits. **For JS/TS files, prefer \`ast_query\` over \`read\`** — it returns structured function/class/import/export data with exact line numbers. Use \`tool({ name: "ast_query", params: { path: "file.ts", query: "structure" }})\` to inspect code structure via AST before editing. **For edits to whole functions/classes/variables in JS/TS, prefer \`ast_edit\` over \`edit\`** — use \`tool({ name: "ast_edit", params: { path: "file.ts", editType: "replace-node", targetLine: 5, newCode: "..." }})\` to avoid string-matching issues. Reserve \`edit\` for small surgical changes inside function bodies or single-line fixes. The \`read\` output prefixes each line with "<lineNumber>: " for easy reference. Do NOT include the "N: " prefix when copying text into \`edit\`.
+2. edit CALL FORMAT — use markdown code block format:
+   \`\`\`edit
+   file: src/file.ts
+   old: |
+     text to replace
+   new: |
+     replacement text
+   \`\`\`
+   Use separate \`\`\`edit blocks for multiple files.
+3. After making edits to a file, if you need to make ANOTHER edit to the SAME file, you MUST re-read it first to get the updated content.
+4. If \`edit\` reports \`old_string not found\`, do NOT retry with the same old_string — re-read the file immediately to see its actual current content, then retry with correctly-copied text.
+5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
+ 6. On Windows, files may use CRLF (\\r\\n) line endings, but the \`edit\` tool normalizes them to LF (\\n). Always use \`\\n\` (not \`\\r\\n\`) in old_string/new_string.
+ 7. CRITICAL: old_string must be CONTIGUOUS — do NOT skip any lines between the old_string start and end. If you need to modify non-adjacent sections, use separate \`\`\`edit blocks.
+ 8. The \`|\` (pipe) after \`old:\` / \`new:\` supports chomping: \`|\` keeps trailing newline, \`|-\` strips it. Use \`|\` (not \`|-\`) when copying old_string — wrong chomping causes "old_string not found".
+ 9. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({ content: "..." })\` with multiple \`\`\`edit blocks to edit multiple files at once.
+10. TODO LIST MAINTENANCE: After completing a task item, update the corresponding plan file in \`.lonny/\` by checking off the TODO item (change \`- [ ]\` to \`- [x]\`). Use \`read\` to find the plan file, then \`edit\` to update the checkbox.
+11. LOOP BEHAVIOR: After this turn ends, you will AUTOMATICALLY receive a continuation prompt to continue working on the same task. You do NOT need to stop and wait for the user — keep going until the task is complete.
+12. If you believe the task is COMPLETE, end your response with a clear summary of what was accomplished. The system will detect this and stop the loop.
+13. You can use /stop at any time to halt execution.`
+      : config.mode === 'plan'
+        ? `You are a planning agent. Your ONLY job is to investigate the codebase and produce an actionable implementation plan with a todo list.
 
 You CANNOT edit files. You do NOT have access to edit, bash (write mode), or install_skill.
 Any attempt to call these tools will FAIL — they are simply unavailable in this mode.
@@ -84,6 +154,7 @@ RULES (plan-specific):
 6. If the plan is very long (or the todo list has many items), split into multiple files with descriptive names like \`backend-api.md\`, \`frontend-ui.md\`, \`database.md\`, etc.
 7. You MUST also include the todo list in your text response to the user (not just in the file).
 7. If the user asks you to modify files, run write commands, or install packages — refuse and explain they need to switch to code mode (\`/mode code\`).
+8. When the task involves writing code, your plan MUST follow Test-Driven Development: write tests first, then implement. Include a \`- [ ] Write tests for ...\` step BEFORE the implementation steps in the todo list.
 
 OUTPUT FORMAT (you MUST include both in write_plan AND in your response text):
 
@@ -99,18 +170,16 @@ A short, ordered description of the approach. Reference concrete files using \`p
 End your response by telling the user where the plan was saved and asking whether they want to switch to \`code\` mode to execute it. Use exactly: "Switch to code mode to implement this plan? (run \`/mode code\`)"
 
 If the user's request is a question rather than a change request, answer it directly and skip the plan/todo sections.`
-      : config.mode === 'ask'
-        ? `You are a Q&A assistant. You can ONLY use the following tools to search for information:
-- \`fetch\`: Fetch content from a URL
-- \`search\`: Search the web using Tavily
-
+        : config.mode === 'ask'
+          ? `You are a Q&A assistant. You can ONLY use the following tools to search for information:
+${getToolListForMode('ask')}
 You CANNOT execute any shell commands (\`bash\`), read local files, or make any changes to the codebase.
 
 RULES (ask-specific):
 1. Use \`fetch\` and \`search\` to find information and answer user questions.
 2. You CANNOT use \`bash\`, \`read\`, \`edit\`, \`write_plan\`, \`glob\`, \`grep\`, \`ls\`, \`find\`, or \`git\`.
 3. If the user wants you to modify code or run commands, explain you are in ask mode and suggest switching to code mode.`
-        : `You are a coding agent optimized for per-call pricing.
+          : `You are a coding agent optimized for per-call pricing.
 
 RULES (code-specific):
 1. Read first: Use read/grep/glob tools to gather all context you need BEFORE making any edits. The \`read\` output prefixes each line with "<lineNumber>: " for easy reference. Do NOT include the "N: " prefix when copying text into \`edit\`.
@@ -125,15 +194,17 @@ RULES (code-specific):
    Use separate \`\`\`edit blocks for multiple files.
 3. After making edits to a file, if you need to make ANOTHER edit to the SAME file, you MUST re-read it first to get the updated content.
 4. If \`edit\` reports \`old_string not found\`, do NOT retry with the same old_string — re-read the file immediately to see its actual current content, then retry with correctly-copied text.
-5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
-6. On Windows, files may use CRLF (\\r\\n) line endings, but the \`edit\` tool normalizes them to LF (\\n). Always use \`\\n\` (not \`\\r\\n\`) in old_string/new_string.
-7. COST OPTIMIZATION (CRITICAL): Each API call costs money. You have a hard limit of ~5 API calls per task.
-8. TODO LIST MAINTENANCE: After completing a task item, update the corresponding plan file in \`.lonny/\` by checking off the TODO item (change \`- [ ]\` to \`- [x]\`). Use \`read\` to find the plan file, then \`edit\` to update the checkbox.`
+ 5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
+ 6. CRITICAL: old_string must be CONTIGUOUS — do NOT skip any lines between the old_string start and end. If you need to modify non-adjacent sections, use separate \`\`\`edit blocks.
+ 7. The \`|\` (pipe) after \`old:\` / \`new:\` supports chomping: \`|\` keeps trailing newline, \`|-\` strips it. Use \`|\` (not \`|-\`) when copying old_string — wrong chomping causes "old_string not found".
+ 8. On Windows, files may use CRLF (\\r\\n) line endings, but the \`edit\` tool normalizes them to LF (\\n). Always use \`\\n\` (not \`\\r\\n\`) in old_string/new_string.
+ 9. COST OPTIMIZATION (CRITICAL): Each API call costs money. You have a hard limit of ~5 API calls per task.
+10. TODO LIST MAINTENANCE: After completing a task item, update the corresponding plan file in \`.lonny/\` by checking off the TODO item (change \`- [ ]\` to \`- [x]\`). Use \`read\` to find the plan file, then \`edit\` to update the checkbox.`
 
   // ── Built-in development methodologies ─────────────────────────────────
   // Embedded directly from Superpowers — no skill files needed.
   const methodologySection =
-    config.mode === 'code'
+    config.mode === 'code' || config.mode === 'loop'
       ? `
 
 ## Development Methodology
@@ -169,17 +240,20 @@ Before writing a plan, explore the user's request thoroughly:
 - Shell: ${shell}
 - Working directory: ${cwd}
 - OS: ${isWindows ? 'Windows' : 'Linux/macOS'}
-- Available shell commands: ${isWindows ? 'PowerShell (cmd is also available but PowerShell is preferred)' : 'bash'}
-${isWindows ? '  - Use PowerShell. Do NOT use Unix commands like `cat`, `ls`, `grep`, `which`, `chmod`, `mv`, `cp`, `rm`, `touch`, `mkdir`, `uname`, etc.' : ''}
-${isWindows ? '  - Use `type` instead of `cat`, `dir` instead of `ls`, `where` instead of `which`' : ''}`
+  - Available shell commands: ${isWindows ? 'PowerShell (cmd is also available but PowerShell is preferred)' : 'bash'}
+${isWindows ? '  ⚠️  THIS IS WINDOWS. Do NOT use Unix/Linux paths like `/workspace/...` or `/home/...`. The working directory is a Windows path (e.g. `C:\\Users\\...`).' : ''}
+${isWindows ? '  ⚠️  Do NOT use Unix commands: `find`, `cat`, `ls -la`, `which`, `cp`, `mv`, `rm`, `touch`, `chmod`, `mkdir`, `grep`, `head`, `tail`. They will ALL fail.' : ''}
+${isWindows ? '  - Use `type` instead of `cat`, `dir` instead of `ls`, `where` instead of `which`, `Select-Object -First N` instead of `head -N`' : ''}
+${isWindows ? '  - Use `;` (semicolon) instead of `&&` to chain commands' : ''}
+${isWindows ? '  - ⚠️  `Select-String` exits with code 1 when no match is found (e.g. `Select-String -Pattern "FAIL"` returns code 1 if no line contains FAIL). This is NORMAL — it does NOT mean the command failed. Append `; $LASTEXITCODE = 0` to suppress this.' : ''}`
 
   // Plan mode uses its own standalone tool list inside modeInstructions — skip sharedRules
   const rulesSection =
-    config.mode === 'plan'
+    config.mode === 'plan' || config.mode === 'loop'
       ? ''
       : `
 ${sharedRules}`
   return `${modeInstructions}
 
-${envSection}${rulesSection}${methodologySection}${projectSection}${skillsSection}`
+${envSection}${rulesSection}${methodologySection}${projectSection}${memoryPromptSection}${skillsSection}`
 }