crawd 0.8.7 → 0.9.0

package/src/backend/server.ts

@@ -1,46 +1,32 @@
 /**
- * CrawdBackend — encapsulates the Fastify+Socket.IO server, TTS, coordinator,
+ * CrawdBackend — encapsulates the Fastify+Socket.IO server, coordinator,
  * and chat system. Used by both standalone mode (backend/index.ts) and the
  * OpenClaw plugin (plugin.ts).
+ *
+ * TTS generation has been moved to the overlay (Next.js server actions).
+ * This backend now sends text-only events.
  */
 import { randomUUID } from 'crypto'
-import { writeFile, mkdir } from 'fs/promises'
-import { join } from 'path'
 import Fastify, { type FastifyInstance } from 'fastify'
-import fastifyStatic from '@fastify/static'
 import cors from '@fastify/cors'
 import { Server } from 'socket.io'
-import OpenAI from 'openai'
 import { pumpfun } from '../lib/pumpfun/v2/index.js'
 import { ChatManager } from '../lib/chat/manager.js'
 import { PumpFunChatClient } from '../lib/chat/pumpfun/client.js'
 import { YouTubeChatClient } from '../lib/chat/youtube/client.js'
-import { Coordinator, OneShotGateway, type CoordinatorConfig, type CoordinatorEvent } from './coordinator.js'
+import { Coordinator, OneShotGateway, type CoordinatorConfig, type CoordinatorEvent, type Plan, type AutonomyMode } from './coordinator.js'
 import { generateShortId } from '../lib/chat/types.js'
-import { configureTikTokTTS, generateTikTokTTS } from '../lib/tts/tiktok.js'
 import type { ChatMessage } from '../lib/chat/types.js'
 
 // ---------------------------------------------------------------------------
 // Config types
 // ---------------------------------------------------------------------------
 
-export type TtsVoiceEntry = {
-  provider: 'openai' | 'elevenlabs' | 'tiktok'
-  voice: string
-}
-
 export type CrawdConfig = {
   enabled: boolean
   port: number
   bindHost: string
-  backendUrl?: string
-  tts: {
-    chat: TtsVoiceEntry[]
-    bot: TtsVoiceEntry[]
-    openaiApiKey?: string
-    elevenlabsApiKey?: string
-    tiktokSessionId?: string
-  }
+  autonomyMode?: AutonomyMode
   vibe: {
     enabled: boolean
     intervalMs: number
@@ -86,10 +72,6 @@ export class CrawdBackend {
   private config: CrawdConfig
   private logger: CrawdLogger
 
-  private openai: OpenAI | null = null
-  private elevenlabs: any = null
-  private ttsDir: string
-  private backendUrl: string
   private buildVersion: string
 
   private chatManager: ChatManager | null = null
@@ -105,17 +87,7 @@ export class CrawdBackend {
     this.config = config
     this.logger = logger ?? defaultLogger
     this.fastify = Fastify({ logger: true })
-    this.ttsDir = join(process.cwd(), 'tmp', 'tts')
-    this.backendUrl = config.backendUrl ?? `http://localhost:${config.port}`
     this.buildVersion = randomUUID()
-
-    // Initialize TTS providers based on config
-    if (config.tts.openaiApiKey) {
-      this.openai = new OpenAI({ apiKey: config.tts.openaiApiKey })
-    }
-    if (config.tts.tiktokSessionId) {
-      configureTikTokTTS(config.tts.tiktokSessionId)
-    }
   }
 
   // =========================================================================
@@ -123,23 +95,7 @@ export class CrawdBackend {
   // =========================================================================
 
   async start(): Promise<void> {
-    // Lazy-init ElevenLabs (optional dep)
-    if (this.config.tts.elevenlabsApiKey && !this.elevenlabs) {
-      try {
-        const { ElevenLabsClient } = await import('@elevenlabs/elevenlabs-js')
-        this.elevenlabs = new ElevenLabsClient({ apiKey: this.config.tts.elevenlabsApiKey })
-      } catch {
-        this.logger.warn('ElevenLabs SDK not installed, ElevenLabs TTS disabled')
-      }
-    }
-
     await this.fastify.register(cors, { origin: true })
-    await mkdir(this.ttsDir, { recursive: true })
-    await this.fastify.register(fastifyStatic, {
-      root: this.ttsDir,
-      prefix: '/tts/',
-      decorateReply: false,
-    })
 
     this.io = new Server(this.fastify.server, {
       cors: { origin: '*' },
@@ -174,7 +130,7 @@ export class CrawdBackend {
   // Public API (used by plugin tool handlers)
   // =========================================================================
 
-  /** Speak on the livestream — emits overlay event + TTS. Blocks until overlay finishes playing. */
+  /** Speak on the livestream — emits text-only overlay event. Blocks until overlay finishes. */
   async handleTalk(text: string): Promise<{ spoken: boolean }> {
     if (!text || typeof text !== 'string') {
       return { spoken: false }
@@ -183,23 +139,15 @@ export class CrawdBackend {
     this.coordinator?.notifySpeech()
 
     const id = randomUUID()
-    try {
-      const tts = await this.generateTTSWithFallback(text, this.config.tts.bot)
-      this.logger.info(`TTS generated: ${tts.url}`)
-      this.io.emit('crawd:talk', { id, message: text, ttsUrl: tts.url, ttsProvider: tts.provider })
-    } catch (e) {
-      this.logger.error('Failed to generate TTS, emitting without audio', e)
-      this.io.emit('crawd:talk', { id, message: text, ttsUrl: '' })
-    }
+    this.io.emit('crawd:talk', { id, message: text })
 
     await this.waitForAck(id)
     return { spoken: true }
   }
 
   /**
-   * Reply to a chat message — reads original aloud (chat voice),
-   * then speaks bot reply (bot voice). Emits `crawd:reply-turn`.
-   * Blocks until overlay finishes playing both audios.
+   * Reply to a chat message — emits text-only overlay event with chat + bot message.
+   * Blocks until overlay finishes.
    */
   async handleReply(
     text: string,
@@ -212,34 +160,44 @@ export class CrawdBackend {
     this.coordinator?.notifySpeech()
 
     const id = randomUUID()
-    try {
-      const [chatTts, botTts] = await Promise.all([
-        this.generateTTSWithFallback(`Chat says: ${chat.message}`, this.config.tts.chat),
-        this.generateTTSWithFallback(text, this.config.tts.bot),
-      ])
-      this.io.emit('crawd:reply-turn', {
-        id,
-        chat: { username: chat.username, message: chat.message },
-        botMessage: text,
-        chatTtsUrl: chatTts.url,
-        botTtsUrl: botTts.url,
-        chatTtsProvider: chatTts.provider,
-        botTtsProvider: botTts.provider,
-      })
-    } catch (e) {
-      this.logger.error('Failed to generate reply-turn TTS, falling back to talk', e)
-      try {
-        const tts = await this.generateTTSWithFallback(text, this.config.tts.bot)
-        this.io.emit('crawd:talk', { id, message: text, ttsUrl: tts.url, ttsProvider: tts.provider })
-      } catch {
-        this.io.emit('crawd:talk', { id, message: text, ttsUrl: '' })
-      }
-    }
+    this.io.emit('crawd:reply-turn', {
+      id,
+      chat: { username: chat.username, message: chat.message },
+      botMessage: text,
+    })
 
     await this.waitForAck(id)
     return { spoken: true }
   }
 
+  // =========================================================================
+  // Plan API (used by plugin tool handlers)
+  // =========================================================================
+
+  setPlan(goal: string, steps: string[]): { plan: Plan } | { error: string } {
+    if (!this.coordinator) return { error: 'Coordinator not enabled' }
+    const plan = this.coordinator.setPlan(goal, steps)
+    return { plan }
+  }
+
+  markPlanStepDone(step: number): { plan: Plan } | { error: string } {
+    if (!this.coordinator) return { error: 'Coordinator not enabled' }
+    const plan = this.coordinator.markStepDone(step)
+    if (!plan) return { error: 'No active plan or invalid step index' }
+    return { plan }
+  }
+
+  abandonPlan(): { plan: Plan } | { error: string } {
+    if (!this.coordinator) return { error: 'Coordinator not enabled' }
+    const plan = this.coordinator.abandonPlan()
+    if (!plan) return { error: 'No active plan to abandon' }
+    return { plan }
+  }
+
+  getPlan(): { plan: Plan | null } {
+    return { plan: this.coordinator?.getPlan() ?? null }
+  }
+
   getIO(): Server {
     return this.io
   }
@@ -266,95 +224,6 @@ export class CrawdBackend {
     }
   }
 
-  // =========================================================================
-  // TTS (with ordered fallback chain)
-  // =========================================================================
-
-  async generateTTSWithFallback(text: string, chain: TtsVoiceEntry[]): Promise<{ url: string; provider: TtsVoiceEntry['provider'] }> {
-    let lastError: Error | null = null
-
-    for (const entry of chain) {
-      try {
-        let url: string
-        switch (entry.provider) {
-          case 'elevenlabs':
-            url = await this.generateElevenLabsTTS(text, entry.voice)
-            break
-          case 'openai':
-            url = await this.generateOpenAITTS(text, entry.voice)
-            break
-          case 'tiktok':
-            url = await this.generateTikTokTTSFile(text, entry.voice)
-            break
-        }
-        return { url, provider: entry.provider }
-      } catch (e) {
-        lastError = e instanceof Error ? e : new Error(String(e))
-        this.logger.warn(`TTS ${entry.provider}/${entry.voice} failed: ${lastError.message}, trying next...`)
-      }
-    }
-
-    throw lastError ?? new Error('No TTS providers configured')
-  }
-
-  private async generateOpenAITTS(text: string, voice: string): Promise<string> {
-    if (!this.openai) throw new Error('OpenAI not configured (missing apiKey)')
-
-    const response = await this.openai.audio.speech.create({
-      model: 'gpt-4o-mini-tts',
-      voice: voice as 'onyx',
-      input: text,
-    })
-
-    const buffer = Buffer.from(await response.arrayBuffer())
-    return await this.saveTTSFile(buffer)
-  }
-
-  private async generateElevenLabsTTS(text: string, voiceId: string): Promise<string> {
-    if (!this.elevenlabs) throw new Error('ElevenLabs not configured (missing apiKey)')
-
-    const audio = await this.elevenlabs.textToSpeech.convert(voiceId, {
-      modelId: 'eleven_multilingual_v2',
-      text,
-      outputFormat: 'mp3_44100_128',
-      voiceSettings: {
-        stability: 0,
-        similarityBoost: 1.0,
-        useSpeakerBoost: true,
-        speed: 1.0,
-      },
-    })
-
-    const response = new Response(audio as any)
-    const arrayBuffer = await response.arrayBuffer()
-    const buffer = Buffer.from(arrayBuffer)
-
-    // Check if response is valid MP3
-    const isMP3 =
-      (buffer[0] === 0x49 && buffer[1] === 0x44 && buffer[2] === 0x33) ||
-      (buffer[0] === 0xff && (buffer[1] & 0xe0) === 0xe0)
-
-    if (!isMP3) {
-      const preview = buffer.subarray(0, 200).toString('utf-8')
-      throw new Error(`ElevenLabs returned non-audio response: ${preview.slice(0, 100)}`)
-    }
-
-    return await this.saveTTSFile(buffer)
-  }
-
-  private async generateTikTokTTSFile(text: string, voice?: string): Promise<string> {
-    const buffer = await generateTikTokTTS(text, voice)
-    return await this.saveTTSFile(buffer)
-  }
-
-  private async saveTTSFile(buffer: Buffer): Promise<string> {
-    const filename = `${randomUUID()}.mp3`
-    await mkdir(this.ttsDir, { recursive: true })
-    await writeFile(join(this.ttsDir, filename), buffer)
-    this.logger.info(`TTS file written: ${filename}, size: ${buffer.length} bytes`)
-    return `${this.backendUrl}/tts/${filename}`
-  }
-
   // =========================================================================
   // Chat system + Coordinator
   // =========================================================================
@@ -388,7 +257,7 @@ export class CrawdBackend {
       )
 
       const coordConfig: Partial<CoordinatorConfig> = {
-        vibeEnabled: this.config.vibe.enabled,
+        autonomyMode: this.config.autonomyMode ?? 'vibe',
         vibeIntervalMs: this.config.vibe.intervalMs,
         idleAfterMs: this.config.vibe.idleAfterMs,
         sleepAfterIdleMs: this.config.vibe.sleepAfterIdleMs,
@@ -410,6 +279,14 @@ export class CrawdBackend {
           this.io.emit('crawd:status', { status: 'vibing' })
         } else if (event.type === 'chatProcessed') {
           this.io.emit('crawd:status', { status: 'chatting' })
+        } else if (event.type === 'planNudgeExecuted' && !event.skipped) {
+          this.io.emit('crawd:status', { status: 'planning' })
+        } else if (event.type === 'planCreated') {
+          this.io.emit('crawd:plan', { type: 'created', planId: event.planId, goal: event.goal })
+        } else if (event.type === 'planCompleted') {
+          this.io.emit('crawd:plan', { type: 'completed', planId: event.planId })
+        } else if (event.type === 'planAbandoned') {
+          this.io.emit('crawd:plan', { type: 'abandoned', planId: event.planId })
         }
       })
 
@@ -502,6 +379,10 @@ export class CrawdBackend {
       return { enabled: true, ...this.coordinator.getState() }
     })
 
+    this.fastify.get('/plan', async () => {
+      return this.getPlan()
+    })
+
     this.fastify.post<{ Body: Partial<CoordinatorConfig> }>(
       '/coordinator/config',
       async (request, reply) => {
@@ -544,25 +425,14 @@ export class CrawdBackend {
           return reply.status(400).send({ error: 'username, message, and response are required' })
         }
 
-        try {
-          const [chatTts, botTts] = await Promise.all([
-            this.generateTTSWithFallback(`Chat says: ${message}`, this.config.tts.chat),
-            this.generateTTSWithFallback(response, this.config.tts.bot),
-          ])
-          this.io.emit('crawd:reply-turn', {
-            id: randomUUID(),
-            chat: { username, message },
-            botMessage: response,
-            chatTtsUrl: chatTts.url,
-            botTtsUrl: botTts.url,
-            chatTtsProvider: chatTts.provider,
-            botTtsProvider: botTts.provider,
-          })
-          return { ok: true }
-        } catch (e) {
-          this.fastify.log.error(e, 'failed to generate mock turn TTS')
-          return reply.status(500).send({ error: 'Failed to generate TTS' })
-        }
+        const id = randomUUID()
+        this.io.emit('crawd:reply-turn', {
+          id,
+          chat: { username, message },
+          botMessage: response,
+        })
+
+        return { ok: true, id }
       },
     )
   }
@@ -592,36 +462,14 @@ export class CrawdBackend {
 
 export function configFromEnv(): CrawdConfig {
   const port = Number(process.env.PORT || 4000)
-
-  const botChain: TtsVoiceEntry[] = []
-  const chatChain: TtsVoiceEntry[] = []
-
-  if (process.env.ELEVENLABS_API_KEY) {
-    botChain.push({ provider: 'elevenlabs', voice: process.env.TTS_BOT_VOICE || 'TX3LPaxmHKxFdv7VOQHJ' })
-  }
-  if (process.env.OPENAI_API_KEY) {
-    botChain.push({ provider: 'openai', voice: process.env.TTS_BOT_VOICE || 'onyx' })
-  }
-
-  if (process.env.TIKTOK_SESSION_ID) {
-    chatChain.push({ provider: 'tiktok', voice: process.env.TTS_CHAT_VOICE || 'en_us_002' })
-  }
-  if (process.env.OPENAI_API_KEY) {
-    chatChain.push({ provider: 'openai', voice: process.env.TTS_CHAT_VOICE || 'onyx' })
-  }
+  const rawMode = process.env.AUTONOMY_MODE
+  const autonomyMode = (rawMode === 'vibe' || rawMode === 'plan' || rawMode === 'none') ? rawMode : undefined
 
   return {
     enabled: true,
     port,
     bindHost: process.env.BIND_HOST || '0.0.0.0',
-    backendUrl: process.env.BACKEND_URL || `http://localhost:${port}`,
-    tts: {
-      chat: chatChain,
-      bot: botChain,
-      openaiApiKey: process.env.OPENAI_API_KEY,
-      elevenlabsApiKey: process.env.ELEVENLABS_API_KEY,
-      tiktokSessionId: process.env.TIKTOK_SESSION_ID,
-    },
+    autonomyMode,
     vibe: {
       enabled: process.env.VIBE_ENABLED !== 'false',
       intervalMs: Number(process.env.VIBE_INTERVAL_MS || 30_000),

package/src/plugin.ts

@@ -7,7 +7,7 @@
  * - `crawd` service (Fastify + Socket.IO backend)
  */
 import { Type } from '@sinclair/typebox'
-import { CrawdBackend, type CrawdConfig, type TtsVoiceEntry } from './backend/server.js'
+import { CrawdBackend, type CrawdConfig } from './backend/server.js'
 
 // Minimal plugin types — the real types come from openclaw/plugin-sdk at runtime.
 // Defined inline so this package builds without the openclaw peerDep installed.
@@ -36,18 +36,6 @@ type PluginDefinition = {
 // Config parsing — transform pluginConfig → CrawdConfig
 // ---------------------------------------------------------------------------
 
-function parseTtsChain(raw: unknown): TtsVoiceEntry[] {
-  if (!Array.isArray(raw)) return []
-  return raw
-    .filter((e): e is { provider: string; voice: string } =>
-      e && typeof e === 'object' && typeof e.provider === 'string' && typeof e.voice === 'string',
-    )
-    .map((e) => ({
-      provider: e.provider as TtsVoiceEntry['provider'],
-      voice: e.voice,
-    }))
-}
-
 /** Resolve gateway WebSocket URL from env/defaults (same logic as OpenClaw's callGateway) */
 function resolveGatewayUrl(port?: number): string {
   if (port) return `ws://127.0.0.1:${port}`
@@ -74,7 +62,6 @@ function resolveGatewayFromHost(api: PluginApi): { token?: string; port?: number
 
 function parsePluginConfig(raw: Record<string, unknown> | undefined): CrawdConfig {
   const cfg = raw ?? {}
-  const tts = (cfg.tts ?? {}) as Record<string, unknown>
   const vibe = (cfg.vibe ?? {}) as Record<string, unknown>
   const chat = (cfg.chat ?? {}) as Record<string, unknown>
   const youtube = (chat.youtube ?? {}) as Record<string, unknown>
@@ -86,14 +73,6 @@ function parsePluginConfig(raw: Record<string, unknown> | undefined): CrawdConfi
     enabled: cfg.enabled !== false,
     port,
     bindHost: typeof cfg.bindHost === 'string' ? cfg.bindHost : '0.0.0.0',
-    backendUrl: typeof cfg.backendUrl === 'string' ? cfg.backendUrl : `http://localhost:${port}`,
-    tts: {
-      chat: parseTtsChain(tts.chat),
-      bot: parseTtsChain(tts.bot),
-      openaiApiKey: typeof tts.openaiApiKey === 'string' ? tts.openaiApiKey : undefined,
-      elevenlabsApiKey: typeof tts.elevenlabsApiKey === 'string' ? tts.elevenlabsApiKey : undefined,
-      tiktokSessionId: typeof tts.tiktokSessionId === 'string' ? tts.tiktokSessionId : undefined,
-    },
     vibe: {
       enabled: vibe.enabled !== false,
       intervalMs: typeof vibe.intervalMs === 'number' ? vibe.intervalMs : 10_000,
@@ -113,6 +92,10 @@ function parsePluginConfig(raw: Record<string, unknown> | undefined): CrawdConfi
         authToken: typeof pumpfun.authToken === 'string' ? pumpfun.authToken : undefined,
       },
     },
+    // Autonomy mode: vibe (periodic prompts), plan (goal-driven), none (disabled)
+    autonomyMode: cfg.autonomyMode === 'vibe' || cfg.autonomyMode === 'plan' || cfg.autonomyMode === 'none'
+      ? cfg.autonomyMode
+      : undefined,
     // Gateway: plugin config overrides, then env vars, then OpenClaw defaults
     gatewayUrl: typeof cfg.gatewayUrl === 'string' ? cfg.gatewayUrl
       : process.env.OPENCLAW_GATEWAY_URL ?? resolveGatewayUrl(),
@@ -136,12 +119,7 @@ const crawdConfigSchema = {
     enabled: { label: 'Enabled' },
     port: { label: 'Backend Port', placeholder: '4000' },
     bindHost: { label: 'Bind Host', placeholder: '0.0.0.0', advanced: true },
-    backendUrl: { label: 'Backend URL', advanced: true, help: 'Public URL for TTS file serving' },
-    'tts.chat': { label: 'Chat TTS Voices', help: 'Ordered fallback chain [{provider, voice}]' },
-    'tts.bot': { label: 'Bot TTS Voices', help: 'Ordered fallback chain [{provider, voice}]' },
-    'tts.openaiApiKey': { label: 'OpenAI API Key', sensitive: true },
-    'tts.elevenlabsApiKey': { label: 'ElevenLabs API Key', sensitive: true },
-    'tts.tiktokSessionId': { label: 'TikTok Session ID', sensitive: true },
+    'autonomyMode': { label: 'Autonomy Mode', help: 'vibe = timed prompts, plan = goal-driven loop, none = disabled' },
     'vibe.enabled': { label: 'Vibe Mode' },
     'vibe.intervalMs': { label: 'Vibe Interval (ms)', advanced: true },
     'vibe.idleAfterMs': { label: 'Idle After (ms)', advanced: true },
@@ -153,15 +131,15 @@ const crawdConfigSchema = {
     'chat.pumpfun.enabled': { label: 'PumpFun Chat' },
     'chat.pumpfun.tokenMint': { label: 'PumpFun Token Mint' },
     'chat.pumpfun.authToken': { label: 'PumpFun Auth Token', sensitive: true },
-    gatewayUrl: { label: 'Gateway URL', advanced: true, help: 'Override auto-detected gateway URL (usually not needed)' },
-    gatewayToken: { label: 'Gateway Token', advanced: true, sensitive: true, help: 'Override OPENCLAW_GATEWAY_TOKEN env var' },
+    gatewayUrl: { label: 'Gateway URL', help: 'WebSocket URL for agent triggering', advanced: true },
+    gatewayToken: { label: 'Gateway Token', sensitive: true },
   },
 }
 
 const plugin: PluginDefinition = {
   id: 'crawd',
   name: 'Crawd Livestream',
-  description: 'crawd.bot plugin — AI agent livestreaming with TTS, chat integration, and OBS overlay',
+  description: 'crawd.bot plugin — AI agent livestreaming with chat integration and OBS overlay',
   configSchema: crawdConfigSchema,
 
   register(api: PluginApi) {
@@ -209,7 +187,7 @@ const plugin: PluginDefinition = {
         name: 'livestream_talk',
         label: 'Livestream Talk',
         description:
-          'Speak on the livestream unprompted. Shows a speech bubble on the overlay and generates TTS audio. Use for narration, vibes, and commentary — NOT for replying to chat (use livestream_reply for that).',
+          'Speak on the livestream unprompted. Shows a speech bubble on the overlay. Use for narration, vibes, and commentary — NOT for replying to chat (use livestream_reply for that).',
         parameters: Type.Object({
           text: Type.String({ description: 'Message to speak on stream' }),
         }),
@@ -232,7 +210,7 @@ const plugin: PluginDefinition = {
         name: 'livestream_reply',
         label: 'Livestream Reply',
         description:
-          'Reply to a chat message on the livestream. Reads the original message aloud with the chat voice, then speaks your reply with the bot voice. Use this ONLY when responding to a specific viewer message.',
+          'Reply to a chat message on the livestream. Shows the original message and your reply on the overlay. Use this ONLY when responding to a specific viewer message.',
         parameters: Type.Object({
           text: Type.String({ description: 'Your reply to the chat message' }),
           username: Type.String({ description: 'Username of the person you are replying to' }),
@@ -251,6 +229,117 @@ const plugin: PluginDefinition = {
       { name: 'livestream_reply' },
     )
 
+    // plan_set — create or replace current plan
+    api.registerTool(
+      {
+        name: 'plan_set',
+        label: 'Set Plan',
+        description:
+          'Create or replace the current plan. Provide a goal and ordered steps. Any existing active plan is abandoned.',
+        parameters: Type.Object({
+          goal: Type.String({ description: 'The overall goal of the plan' }),
+          steps: Type.Array(Type.String(), { description: 'Ordered list of steps to accomplish the goal', minItems: 1, maxItems: 20 }),
+        }),
+        async execute(_toolCallId: string, params: unknown) {
+          const b = await ensureBackend()
+          const { goal, steps } = params as { goal: string; steps: string[] }
+          const result = b.setPlan(goal, steps)
+          if ('error' in result) {
+            return { content: [{ type: 'text', text: `Failed: ${result.error}` }] }
+          }
+          const stepList = result.plan.steps.map((s, i) => `  ${i}. ${s.description}`).join('\n')
+          return {
+            content: [{ type: 'text', text: `Plan created: ${goal}\n${stepList}` }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_set' },
+    )
+
+    // plan_step_done — mark a step as complete
+    api.registerTool(
+      {
+        name: 'plan_step_done',
+        label: 'Plan Step Done',
+        description:
+          'Mark a plan step as done by its 0-based index. The coordinator will nudge you for the next step.',
+        parameters: Type.Object({
+          step: Type.Number({ description: 'Zero-based index of the step to mark as done' }),
+        }),
+        async execute(_toolCallId: string, params: unknown) {
+          const b = await ensureBackend()
+          const { step } = params as { step: number }
+          const result = b.markPlanStepDone(step)
+          if ('error' in result) {
+            return { content: [{ type: 'text', text: `Failed: ${result.error}` }] }
+          }
+          const done = result.plan.steps.filter(s => s.status === 'done').length
+          const total = result.plan.steps.length
+          const isComplete = result.plan.status === 'completed'
+          return {
+            content: [{ type: 'text', text: isComplete
+              ? `Plan completed! All ${total} steps done.`
+              : `Step ${step} done (${done}/${total} complete).`
+            }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_step_done' },
+    )
+
+    // plan_abandon — abandon current plan
+    api.registerTool(
+      {
+        name: 'plan_abandon',
+        label: 'Abandon Plan',
+        description:
+          'Abandon the current plan. The coordinator will stop sending plan nudges.',
+        parameters: Type.Object({}),
+        async execute(_toolCallId: string, _params: unknown) {
+          const b = await ensureBackend()
+          const result = b.abandonPlan()
+          if ('error' in result) {
+            return { content: [{ type: 'text', text: `Failed: ${result.error}` }] }
+          }
+          return {
+            content: [{ type: 'text', text: `Plan abandoned: ${result.plan.goal}` }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_abandon' },
+    )
+
+    // plan_get — view current plan state
+    api.registerTool(
+      {
+        name: 'plan_get',
+        label: 'Get Plan',
+        description:
+          'View the current plan state including goal, steps, and progress.',
+        parameters: Type.Object({}),
+        async execute(_toolCallId: string, _params: unknown) {
+          const b = await ensureBackend()
+          const result = b.getPlan()
+          if (!result.plan) {
+            return { content: [{ type: 'text', text: 'No active plan.' }] }
+          }
+          const p = result.plan
+          const stepList = p.steps.map((s, i) => {
+            const marker = s.status === 'done' ? '[x]' : '[ ]'
+            return `  ${marker} ${i}. ${s.description}`
+          }).join('\n')
+          return {
+            content: [{ type: 'text', text: `Plan (${p.status}): ${p.goal}\n${stepList}` }],
+            details: result,
+          }
+        },
+      },
+      { name: 'plan_get' },
+    )
+
     // Service lifecycle
     api.registerService({
       id: 'crawd',

package/src/types.ts

@@ -13,41 +13,22 @@ export type {
   SuperChatInfo,
 } from './lib/chat/types'
 
-/** TTS provider identifier */
-export type TtsProvider = 'openai' | 'elevenlabs' | 'tiktok'
-
 // --- Socket.IO event payloads ---
 
-/** Turn-based reply: chat message + bot response, each with TTS audio */
+/** Turn-based reply: chat message + bot response (text only, TTS handled by overlay) */
 export type ReplyTurnEvent = {
-  /** Correlation ID — overlay sends talk:done with this ID when both audios finish */
+  /** Correlation ID — overlay sends talk:done with this ID when finished */
   id: string
   chat: { username: string; message: string }
   botMessage: string
-  chatTtsUrl: string
-  botTtsUrl: string
-  /** TTS provider used for the chat audio */
-  chatTtsProvider?: TtsProvider
-  /** TTS provider used for the bot audio */
-  botTtsProvider?: TtsProvider
 }
 
-/** Bot speech bubble with pre-generated TTS (atomic event) */
+/** Bot speech bubble (text only, TTS handled by overlay) */
 export type TalkEvent = {
-  /** Correlation ID — overlay sends talk:done with this ID when audio finishes */
+  /** Correlation ID — overlay sends talk:done with this ID when finished */
   id: string
   /** Bot reply text */
   message: string
-  /** Bot TTS audio URL */
-  ttsUrl: string
-  /** TTS provider used for the bot audio */
-  ttsProvider?: TtsProvider
-  /** Optional: chat message being replied to (overlay plays this first) */
-  chat?: {
-    message: string
-    username: string
-    ttsUrl: string
-  }
 }
 
 /** Overlay → backend acknowledgement that a talk finished playing */