savant-code 0.0.19 → 0.0.21

package/common/src/browser-actions.ts

@@ -1,414 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any -- browser action types: dynamic attribute parsing */
-import { z } from 'zod/v4'
-
-// Default values for browser actions
-export const BROWSER_DEFAULTS = {
-  // Common defaults
-  headless: true,
-  debug: false,
-  timeout: 15000, // 15 seconds
-  userDataDir: '_browser_profile', // Will be relative to project data dir
-  retryOptions: {
-    maxRetries: 3,
-    retryDelay: 1000, // 1 second
-    retryOnErrors: ['TimeoutError', 'TargetClosedError', 'DetachedFrameError'],
-  },
-
-  // Viewport defaults
-  viewportWidth: 1280,
-  viewportHeight: 720,
-
-  // Navigation defaults
-  waitUntil: 'networkidle0' as const,
-
-  // Click defaults
-  waitForNavigation: false,
-  button: 'left' as const,
-
-  // Type defaults
-  delay: 100, // 100ms between keystrokes
-
-  // Screenshot defaults
-  fullPage: false,
-  screenshotCompression: 'jpeg' as const,
-  screenshotCompressionQuality: 25,
-  compressScreenshotData: true,
-
-  // Advanced configuration defaults
-  maxConsecutiveErrors: 3,
-  totalErrorThreshold: 10,
-} as const
-
-/**
- * Response schema for browser action results
- */
-export const LogSchema = z.object({
-  type: z.enum(['error', 'warning', 'info', 'debug', 'verbose']),
-  message: z.string(),
-  timestamp: z.number(),
-  location: z.string().optional(),
-  stack: z.string().optional(),
-  category: z.string().optional(),
-  level: z.number().optional(),
-  source: z.enum(['browser', 'tool']).default('tool'),
-})
-
-export type Log = z.infer<typeof LogSchema>
-
-export const MetricsSchema = z.object({
-  loadTime: z.number(),
-  memoryUsage: z.number(),
-  jsErrors: z.number(),
-  networkErrors: z.number(),
-  ttfb: z.number().optional(),
-  lcp: z.number().optional(),
-  fcp: z.number().optional(),
-  domContentLoaded: z.number().optional(),
-  sessionDuration: z.number().optional(),
-})
-
-export const NetworkEventSchema = z.object({
-  url: z.string(),
-  method: z.string(),
-  status: z.number().optional(),
-  errorText: z.string().optional(),
-  timestamp: z.number(),
-})
-
-export const LogFilterSchema = z.object({
-  types: z
-    .array(z.enum(['error', 'warning', 'info', 'debug', 'verbose']))
-    .optional(),
-  minLevel: z.number().optional(),
-  categories: z.array(z.string()).optional(),
-})
-
-// Required options for each action type
-export const RequiredRetryOptionsSchema = z.object({
-  maxRetries: z.number(),
-  retryDelay: z.number(),
-  retryOnErrors: z.array(z.string()),
-})
-
-// Optional configurations that can be added to any action
-export const OptionalBrowserConfigSchema = z.object({
-  timeout: z.number().optional(),
-  retryOptions: z
-    .object({
-      maxRetries: z.number().optional(),
-      retryDelay: z.number().optional(),
-      retryOnErrors: z.array(z.string()).optional(),
-    })
-    .optional(),
-  logFilter: LogFilterSchema.optional(),
-  debug: z.boolean().optional(),
-})
-
-// Advanced optional configurations specific to start action
-export const OptionalStartConfigSchema = z.object({
-  maxConsecutiveErrors: z.number().optional(),
-  totalErrorThreshold: z.number().optional(),
-})
-
-export type BrowserConfig = z.infer<typeof OptionalBrowserConfigSchema> &
-  z.infer<typeof OptionalStartConfigSchema>
-
-// Optional configurations specific to each action type
-export const OptionalNavigateConfigSchema = z.object({
-  waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle0']).optional(),
-})
-
-export const OptionalClickConfigSchema = z.object({
-  waitForNavigation: z.boolean().optional(),
-  button: z.enum(['left', 'right', 'middle']).optional(),
-  // New optional fields for visual verification
-  visualVerify: z.boolean().optional(),
-  visualThreshold: z.number().min(0).max(1).optional(), // fraction from 0..1
-})
-
-export const OptionalTypeConfigSchema = z.object({
-  delay: z.number().optional(),
-})
-
-export const OptionalScreenshotConfigSchema = z.object({
-  fullPage: z.boolean().optional(),
-  screenshotCompression: z.enum(['jpeg', 'png']).optional(),
-  screenshotCompressionQuality: z.number().optional(),
-  compressScreenshotData: z.boolean().optional(),
-})
-
-// Maximum size for a single WebSocket message (10MB)
-export const MAX_MESSAGE_SIZE = 10 * 1024 * 1024
-
-export const BrowserResponseChunkSchema = z.object({
-  id: z.string(),
-  total: z.number(),
-  index: z.number(),
-  data: z.string(), // Base64 encoded chunk
-})
-
-export const ImageContentSchema = z.object({
-  type: z.literal('image'),
-  source: z.object({
-    type: z.literal('base64'),
-    media_type: z.literal('image/jpeg'),
-    data: z.string(),
-  }),
-})
-export type ImageContent = z.infer<typeof ImageContentSchema>
-
-export const BrowserResponseSchema = z.object({
-  success: z.boolean(),
-  error: z.string().optional(),
-  logs: z.array(LogSchema),
-  logFilter: LogFilterSchema.optional(),
-  networkEvents: z.array(NetworkEventSchema).optional(),
-  metrics: MetricsSchema.optional(),
-  screenshots: z
-    .object({
-      pre: ImageContentSchema.optional(),
-      post: ImageContentSchema,
-    })
-    .optional(),
-})
-
-// Update action schemas to include retry options
-// Required base schemas
-export const RequiredBrowserStartActionSchema = z.object({
-  type: z.literal('start'),
-  url: z.string().url(),
-})
-
-// Combined schema
-export const BrowserStartActionSchema = RequiredBrowserStartActionSchema.merge(
-  OptionalBrowserConfigSchema,
-).merge(OptionalStartConfigSchema)
-
-export const RequiredBrowserNavigateActionSchema = z.object({
-  type: z.literal('navigate'),
-  url: z.string().url(),
-})
-
-export const BrowserNavigateActionSchema =
-  RequiredBrowserNavigateActionSchema.merge(OptionalBrowserConfigSchema).merge(
-    OptionalNavigateConfigSchema,
-  )
-
-const _RangeSchema = z.object({
-  min: z.number(),
-  max: z.number(),
-})
-
-export const RequiredBrowserClickActionSchema = z.object({
-  type: z.literal('click'),
-  // xRange: RangeSchema,
-  // yRange: RangeSchema,
-})
-
-export const BrowserClickActionSchema = RequiredBrowserClickActionSchema.merge(
-  OptionalBrowserConfigSchema,
-).merge(OptionalClickConfigSchema)
-
-export const RequiredBrowserTypeActionSchema = z.object({
-  type: z.literal('type'),
-  selector: z.string(),
-  text: z.string(),
-})
-
-export const BrowserTypeActionSchema = RequiredBrowserTypeActionSchema.merge(
-  OptionalBrowserConfigSchema,
-).merge(OptionalTypeConfigSchema)
-
-export const RequiredBrowserScrollActionSchema = z.object({
-  type: z.literal('scroll'),
-})
-
-export const OptionalScrollConfigSchema = z.object({
-  direction: z.enum(['up', 'down']).optional(),
-})
-
-export const BrowserScrollActionSchema =
-  RequiredBrowserScrollActionSchema.merge(OptionalBrowserConfigSchema).merge(
-    OptionalScrollConfigSchema,
-  )
-
-export const RequiredBrowserScreenshotActionSchema = z.object({
-  type: z.literal('screenshot'),
-})
-
-export const BrowserScreenshotActionSchema =
-  RequiredBrowserScreenshotActionSchema.merge(
-    OptionalBrowserConfigSchema,
-  ).merge(OptionalScreenshotConfigSchema)
-
-export const RequiredBrowserStopActionSchema = z.object({
-  type: z.literal('stop'),
-})
-export const BrowserStopActionSchema = RequiredBrowserStopActionSchema.merge(
-  OptionalBrowserConfigSchema,
-)
-
-// First define the base action schemas without the diagnostic step
-const BaseBrowserActionSchema = z.discriminatedUnion('type', [
-  BrowserStartActionSchema,
-  BrowserNavigateActionSchema,
-  BrowserClickActionSchema,
-  BrowserTypeActionSchema,
-  BrowserScrollActionSchema,
-  BrowserScreenshotActionSchema,
-  BrowserStopActionSchema,
-])
-
-// Now we can define the diagnostic step schema that references the base actions
-export const DiagnosticStepSchema = z.object({
-  label: z.string().optional(),
-  // The actual browser action to run
-  action: BaseBrowserActionSchema,
-  // Success conditions to verify after step
-  expectedLogs: z.array(z.string()).optional(),
-  noJsErrors: z.boolean().optional(),
-  noNetworkErrors: z.boolean().optional(),
-  customCondition: z.string().optional(),
-})
-
-// The 'diagnose' action for multi-step debugging
-export const BrowserDiagnoseActionSchema = z.object({
-  type: z.literal('diagnose'),
-  // Array of steps to run
-  steps: z.array(DiagnosticStepSchema),
-  // Toggle whether to run all steps automatically or step-by-step
-  automated: z.boolean().optional(),
-  // Optional maximum steps/time to run
-  maxSteps: z.number().optional(),
-  sessionTimeoutMs: z.number().optional(),
-  // Include optional browser config
-  ...OptionalBrowserConfigSchema.shape,
-})
-
-// Finally, export the complete schema that includes diagnostic actions
-export const BrowserActionSchema = z.discriminatedUnion('type', [
-  BrowserStartActionSchema,
-  BrowserNavigateActionSchema,
-  BrowserClickActionSchema,
-  BrowserTypeActionSchema,
-  BrowserScrollActionSchema,
-  BrowserScreenshotActionSchema,
-  BrowserStopActionSchema,
-  BrowserDiagnoseActionSchema,
-])
-
-/**
- * Creates an XML string from a BrowserAction object
- */
-export function createBrowserActionXML(action: BrowserAction): string {
-  const { type, ...attributes } = action
-  const attrsString = Object.entries(attributes)
-    .filter(([_, v]) => v !== undefined && v !== null)
-    .map(([k, v]) => {
-      // Handle different value types
-      const val = typeof v === 'object' ? JSON.stringify(v) : String(v)
-      // Escape special characters in XML attributes
-      const escaped = val.replace(/[<>&'"]/g, (char) => {
-        switch (char) {
-          case '<':
-            return '&lt;'
-          case '>':
-            return '&gt;'
-          case '&':
-            return '&amp;'
-          case '"':
-            return '&quot;'
-          case "'":
-            return '&apos;'
-          default:
-            return char
-        }
-      })
-      return `${k}="${escaped}"`
-    })
-    .join(' ')
-  return `<browser_logs action="${type}" ${attrsString} />`
-}
-
-/**
- * Parses XML attributes into a BrowserAction object
- */
-export function parseBrowserActionXML(xmlString: string): BrowserAction {
-  // Basic XML validation
-  if (!xmlString.includes('<browser_logs') || !xmlString.includes('/>')) {
-    throw new Error('Invalid browser action XML: missing browser_logs tag')
-  }
-
-  // Extract attributes using regex
-  const attrs: Record<string, string> = {}
-  const attrPattern = /(\w+)="([^"]*)"/g
-  let match
-
-  while ((match = attrPattern.exec(xmlString)) !== null) {
-    const [_, key, value] = match
-    attrs[key] = value
-  }
-
-  if (!attrs.action) {
-    throw new Error('Invalid browser action XML: missing action attribute')
-  }
-
-  // Convert action attribute to type
-  const type = attrs.action
-  delete attrs.action
-
-  // Parse special values (booleans, numbers, objects)
-  const parsedAttrs = Object.entries(attrs).reduce(
-    (acc, [key, value]) => {
-      try {
-        // Try to parse as JSON for objects
-        if (value.startsWith('{') || value.startsWith('[')) {
-          acc[key] = JSON.parse(value)
-        }
-        // Parse booleans
-        else if (value === 'true' || value === 'false') {
-          acc[key] = value === 'true'
-        }
-        // Parse numbers
-        else if (!isNaN(Number(value))) {
-          acc[key] = Number(value)
-        }
-        // Keep as string
-        else {
-          acc[key] = value
-        }
-      } catch {
-        // If parsing fails, keep as string
-        acc[key] = value
-      }
-      return acc
-    },
-    {} as Record<string, any>,
-  )
-
-  // Construct and validate the BrowserAction
-  const action = { type, ...parsedAttrs } as BrowserAction
-  return BrowserActionSchema.parse(action)
-}
-
-export type BrowserResponse = z.infer<typeof BrowserResponseSchema>
-export type BrowserAction = z.infer<typeof BrowserActionSchema>
-
-/**
- * Parse browser action XML attributes into a typed BrowserAction object
- */
-export function parseBrowserActionAttributes(
-  attributes: Record<string, string>,
-): BrowserAction {
-  const { action, ...rest } = attributes
-  return {
-    type: action,
-    ...Object.entries(rest).reduce((acc, [key, value]) => {
-      // Convert string values to appropriate types
-      if (value === 'true') return { ...acc, [key]: true }
-      if (value === 'false') return { ...acc, [key]: false }
-      if (!isNaN(Number(value))) return { ...acc, [key]: Number(value) }
-      return { ...acc, [key]: value }
-    }, {}),
-  } as BrowserAction
-}

package/common/src/constants/agents.ts

@@ -1,250 +0,0 @@
-import type { AgentTemplateTypes } from '../types/session-state'
-
-// Define agent personas with their shared characteristics
-export const AGENT_PERSONAS = {
-  // ECHO agents
-  thinker: {
-    displayName: 'Savant the Thinker',
-    purpose:
-      'Does deep thinking given the current messages and a specific prompt to focus on. Use this to help you solve a specific problem.',
-  } as const,
-  scout: {
-    displayName: 'Savant the Scout',
-    purpose: 'Expert at exploring a codebase and finding relevant files.',
-  } as const,
-  verifier: {
-    displayName: 'Savant the Verifier',
-    purpose:
-      'Reviews file changes and responds with critical feedback. Use this after making any significant change to the codebase; otherwise, no need to use this agent for minor changes since it takes a second.',
-  } as const,
-  researcher: {
-    displayName: 'Savant the Researcher',
-    purpose: 'Expert at researching topics using web search and documentation.',
-  } as const,
-
-  // Personas
-  ask: {
-    displayName: 'Ask Mode Agent',
-    purpose: 'Base ask-mode agent that orchestrates the full response.',
-  } as const,
-  planner: {
-    displayName: 'Peter Plan',
-    purpose: 'Agent that formulates a comprehensive plan to a prompt.',
-    hidden: true,
-  } as const,
-
-  // Infrastructure
-  'file-explorer': {
-    displayName: 'Dora The File Explorer',
-    purpose: 'Expert at exploring a codebase and finding relevant files.',
-  } as const,
-} as const satisfies Partial<
-  Record<
-    (typeof AgentTemplateTypes)[keyof typeof AgentTemplateTypes],
-    { displayName: string; purpose: string; hidden?: boolean }
-  >
->
-
-// Agent IDs list from AGENT_PERSONAS keys
-export const AGENT_IDS = Object.keys(
-  AGENT_PERSONAS,
-) as (keyof typeof AGENT_PERSONAS)[]
-
-// Agent ID prefix constant
-export const AGENT_ID_PREFIX = 'SavantCode/'
-
-// Agent names for client-side reference
-export const AGENT_NAMES = Object.fromEntries(
-  Object.entries(AGENT_PERSONAS).map(([agentType, persona]) => [
-    agentType,
-    persona.displayName,
-  ]),
-) as Record<keyof typeof AGENT_PERSONAS, string>
-
-export type AgentName =
-  (typeof AGENT_PERSONAS)[keyof typeof AGENT_PERSONAS]['displayName']
-
-// Get unique agent names for UI display
-export const UNIQUE_AGENT_NAMES = Array.from(
-  new Set(
-    Object.values(AGENT_PERSONAS)
-      .filter((persona) => !('hidden' in persona) || !persona.hidden)
-      .map((persona) => persona.displayName),
-  ),
-)
-
-// Map from display name back to agent types (for parsing user input)
-export const AGENT_NAME_TO_TYPES = Object.entries(AGENT_NAMES).reduce(
-  (acc, [type, name]) => {
-    if (!acc[name]) acc[name] = []
-    acc[name].push(type)
-    return acc
-  },
-  {} as Record<string, string[]>,
-)
-
-export const MAX_AGENT_STEPS_DEFAULT = 200
-
-/**
- * Base agents that may spawn ANY agent by raw ID, bypassing the
- * spawnableAgents allowlist. Single source of truth (FID-2026-0802-005 L6) —
- * previously duplicated in tool-executor.ts and spawn-agent-utils.ts.
- */
-export const BASE_AGENTS: readonly string[] = [
-  'base',
-  'base-free',
-  'base-max',
-  'base-experimental',
-]
-
-export const ECHO_PROTOCOL_INSTRUCTIONS = [
-  '# ECHO Protocol (v0.2.0) \u2014 Engineering Governance',
-  '',
-  'You are bound by the ECHO Protocol. The following rules and processes are non-negotiable.',
-  '',
-  '## The 15 Laws',
-  '',
-  '### Laws 1-4: Immutable Process Laws (Always Enforced)',
-  '1. **Read 0-EOF Before Touch** \u2014 Every file read completely before any edit. No exceptions.',
-  '2. **Present Before Act** \u2014 Every change presented with full impact analysis BEFORE implementation.',
-  '3. **Verify Before Proceed** \u2014 Every change verified with build/test commands before moving on. No broken builds.',
-  '4. **Verify Call-Graph Reachability** \u2014 After wiring any feature, grep production entry points to confirm it is actually called. Compilation is NOT verification.',
-  '',
-  '### Laws 5-15: Extended Code Laws (Enforced when strict_mode: true)',
-  '5. No pseudo-code, TODOs, or placeholders',
-  '6. No type safety shortcuts (no any, no @ts-ignore, no bare except:)',
-  '7. Search for existing code BEFORE creating new',
-  '8. Log intent before coding \u2014 document intended change in the session summary before implementation',
-  '9. Generate production-grade documentation',
-  '10. Update tracking after every feature',
-  '11. Follow discovered patterns EXACTLY',
-  '12. Never expose sensitive data in logs/errors',
-  '13. Utility-first, universal logic \u2014 one function, one truth',
-  '14. All error paths handled',
-  '15. Build stays clean \u2014 zero errors, zero warnings',
-  '',
-  '## Perfection Loop FSM',
-  '',
-  'Every code change follows this Finite State Machine:',
-  '',
-  '```',
-  'idle \u2192 red \u2192 green \u2192 audit \u2192 complete',
-  '                \u2193         \u2191',
-  '                self_correct',
-  '```',
-  '',
-  'Optimization shortcuts:',
-  '- **GREEN \u2192 inline verification**: Run typecheck/lint via run_terminal_command without transitioning to audit.',
-  '- **SELF_CORRECT \u2192 complete**: After fixing audit findings, verify inline and go directly to complete.',
-  '',
-  '- **RED**: Identify ALL failures and issues. Catalog with evidence.',
-  '- **GREEN**: Fix issues with MINIMAL changes. May run inline verification.',
-  '- **AUDIT**: Independent verification via Verifier agent. Self-reporting is prohibited \u2014 audit must use a separate agent or tool-mediated verification.',
-  '- **SELF-CORRECT**: Address audit findings. Write tools available. May verify inline via run_terminal_command (tool-mediated, not self-reporting).',
-  '- **COMPLETE**: Document results. Loop ends.',
-  '',
-  '## Circuit Breaker Rules',
-  '1. Max 10% character change per pass',
-  '2. After each change, verify a random 500-char sample for unintended side effects',
-  '3. Stop if change delta < 2% for 2 consecutive passes',
-  '4. If same issue reappears 3 times, escalate',
-  '5. Hard stop at 10 iterations per loop',
-  '',
-  '## The Five Questions',
-  'When evaluating any approach, ask:',
-  '1. Will this work for ALL cases, not just the common case?',
-  '2. Will this scale to 1000 agents, not just 10?',
-  '3. Will this survive a hostile attacker, not just an honest user?',
-  '4. Will this be maintainable in 2 years, not just today?',
-  '5. Does this set the standard for the industry, not just meet it?',
-  'If any answer is no \u2014 redesign until all answers are yes.',
-  '',
-  '## FID Authoring Rules',
-  "Only the Recorder agent may create, update, or archive FID files. Agents without write tools (Thinker, Scout, Researcher) must route FID content through the Recorder. Parent agents with write tools must not write FID files directly from a sub-agent's output.",
-  '',
-  'FIDs are Markdown files that live ONLY in `dev/fids/`. NEVER create top-level directories such as `fids/`, `archive/`, or any path that shadows canonical ECHO paths.',
-  '',
-  'Filename format: `FID-YYYY-MMDD-NNN-{kebab-case-title}.md`. Scan the existing FIDs in `dev/fids/` and `dev/fids/archive/` first to allocate the next available number on the date, and never reuse a number on the same date.',
-  '',
-  'Use `templates/FID-TEMPLATE.md` as the exact template. Required metadata fields: **Filename**, **ID**, **Severity**, **Status**, **Created**, **Author**.',
-  '',
-  'Allowed status values: `created | analyzed | fixed | verified | closed`.',
-  '',
-  'Non-FID design documents go to `docs/design/`, never at the repo root, and never with a `FID-` prefix.',
-  '',
-  '## Anti-Patterns (Never Do These)',
-  '- "The simplest approach" \u2014 enterprise-grade implementations, not simple ones',
-  '- "Let me just quickly fix this" \u2014 every change is surgical',
-  '- Reading only the affected line \u2014 MUST read full file 0-EOF',
-  '- Making changes without presenting \u2014 partner, not rubber stamp',
-  '- Skipping verification \u2014 broken builds cascade',
-  '- Choosing speed over quality \u2014 never in a rush',
-  '- "Good enough" \u2014 good enough is never good enough',
-  '- Writing pseudo-code or placeholders \u2014 every line must be production-ready',
-  '',
-  '## FSM Phase Gating',
-  '',
-  'The Perfection Loop is enforced through phase-gated tool access. You start in the `idle` phase. The following rules apply:',
-  '',
-  '### Phases and Tool Access',
-  '',
-  '| Phase | Allowed Tools | Purpose |',
-  '|-------|---------------|--------|',
-  '| **idle** | read_files, glob, list_directory, spawn_agents (no tools blocked) | Planning and analysis only |',
-  '| **red** | read_files, glob, list_directory, spawn_agents, code_search (no tools blocked) | Issue discovery with evidence |',
-  '| **green** | write_file, str_replace, apply_patch, run_terminal_command (phase-gated); spawn_agents, read_files, glob (always available) | Implementation + inline verification |',
-  '| **audit** | run_terminal_command (phase-gated); spawn_agents, read_files, glob (always available) | Independent verification |',
-  '| **self_correct** | write_file, str_replace, apply_patch, run_terminal_command (phase-gated); spawn_agents, read_files, glob (always available) | Fix audit findings |',
-  '| **complete** | (none \u2014 task done) | Document results |',
-  '',
-  '**Note:** Only 5 tools are FSM phase-gated in the runtime: write_file, str_replace, apply_patch (green/self_correct only), run_terminal_command (green/audit only), and sequentialthinking (Thinker agents only). All other tools including spawn_agents, read_files, glob, list_directory, skill, ask_user, etc. are available in ALL phases.',
-  '',
-  '**Note:** `basher` is a spawnable agent (via `spawn_agents`), not a phase-gated tool. The agent itself can be spawned in any phase, but the terminal commands it executes require GREEN or AUDIT phase. Transition to GREEN before spawning basher for commands that need `run_terminal_command`.',
-  '',
-  '### Transition Rules',
-  '',
-  'The FSM supports two optimization shortcuts beyond the basic loop:',
-  '',
-  '1. **Inline verification** (GREEN phase): Run typecheck/lint via `run_terminal_command` or `basher` without transitioning to audit.',
-  '2. **Self-correct shortcut** (SELF_CORRECT \u2192 COMPLETE): After fixing audit findings, verify inline and go directly to complete \u2014 no need to re-enter green.',
-  '',
-  'Full transition map:',
-  '- **idle \u2192 red**: Start Perfection Loop for complex tasks.',
-  '- **red \u2192 green**: After cataloging all issues, transition to green to fix them.',
-  '- **green**: Write code. You may also run typecheck/lint inline via `run_terminal_command` or `basher` without transitioning to audit.',
-  '- **green \u2192 audit**: After writing, if you need independent verification (Verifier agent), transition to audit.',
-  '- **audit**: Run verification. If issues found \u2192 self_correct. If clean \u2192 complete.',
-  '- **audit \u2192 self_correct**: Found issues. Fix them directly (write tools are available).',
-  '- **self_correct \u2192 complete**: After fixing, verify inline (typecheck/lint). If clean, go directly to complete. No need to re-enter green.',
-  '- **self_correct \u2192 green**: If fixes are complex or need another audit cycle, loop back to green.',
-  '- **audit \u2192 complete**: Verification passes. Document and finish.',
-  '',
-  '### When to Skip RED',
-  '',
-  "RED is for finding EXISTING bugs in code you're about to modify. It is NOT required for:",
-  '- Creating new files (nothing to analyze)',
-  "- Tasks where the user gave you a clear spec and you're implementing from scratch",
-  '- Small changes (< 75 lines) with no existing code to audit',
-  '',
-  'Law 2 (Present Before Act) still applies: present your plan before writing. But presenting a plan \u2260 running RED phase.',
-  '',
-  'When skipping RED: `transition_phase(green)` \u2192 write \u2192 `transition_phase(audit)` \u2192 verify \u2192 `transition_phase(complete)`.',
-  '',
-  '### Self-Correct Optimization',
-  '',
-  'When audit finds issues, you have two paths:',
-  '',
-  '**Path A \u2014 Quick fix (preferred for obvious issues like typos, missing imports, obvious logic errors):**',
-  '1. `transition_phase(self_correct)` \u2014 write tools available',
-  '2. Fix the issues',
-  '3. Run inline verification via run_terminal_command (typecheck/lint) \u2014 this is tool-mediated verification, not self-reporting',
-  '4. `transition_phase(complete)` \u2014 done',
-  '',
-  '**Path B \u2014 Complex fix (needs re-audit for non-obvious changes):**',
-  '1. `transition_phase(self_correct)`',
-  '2. Fix the issues',
-  '3. `transition_phase(green)` \u2014 re-enter green (increments iteration counter)',
-  '4. `transition_phase(audit)` \u2014 re-verify with Verifier agent',
-  '',
-  'Always use `transition_phase` to move between phases. Never attempt `write_file` or `str_replace` outside of `green` or `self_correct`.',
-].join('\n')