@swarmclawai/swarmclaw 1.6.0 → 1.7.0

package/src/lib/providers/generic-cli.test.ts

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { GENERIC_CLI_BINARIES, streamGenericCliChat } from './generic-cli'
+
+describe('GENERIC_CLI_BINARIES', () => {
+  it('maps every generic CLI provider id to a non-empty binary name', () => {
+    for (const [providerId, binaryName] of Object.entries(GENERIC_CLI_BINARIES)) {
+      assert.equal(typeof binaryName, 'string', `${providerId} binary must be a string`)
+      assert.ok(binaryName.length > 0, `${providerId} binary must not be empty`)
+      assert.ok(providerId.endsWith('-cli'), `${providerId} should end with -cli for the registry pattern`)
+    }
+  })
+
+  it('does not collide with bespoke CLI provider ids', () => {
+    const bespoke = new Set([
+      'claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli',
+      'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose',
+    ])
+    for (const id of Object.keys(GENERIC_CLI_BINARIES)) {
+      assert.equal(bespoke.has(id), false, `${id} must not collide with a bespoke CLI provider`)
+    }
+  })
+})
+
+describe('streamGenericCliChat', () => {
+  it('streams stdout lines as deltas via the SSE write callback when the binary exists', async () => {
+    // Use `echo` as a stand-in binary. Every POSIX system has it on PATH.
+    // Note: `echo "<prompt>"` will print the prompt itself, which exercises
+    // the line-buffered pipe.
+    const writes: string[] = []
+    const active = new Map<string, unknown>()
+
+    const result = await streamGenericCliChat({
+      session: { id: 'test-session', cwd: process.cwd() },
+      message: 'hello world',
+      write: (data) => writes.push(data),
+      active,
+      loadHistory: () => [],
+      binaryName: 'echo',
+      displayName: 'Echo',
+    })
+
+    assert.ok(result.includes('hello world'), `expected response to include the prompt, got: ${JSON.stringify(result)}`)
+    assert.ok(writes.length > 0, 'should have emitted at least one SSE event')
+    const allText = writes.join('')
+    assert.ok(allText.includes('hello world'), 'SSE stream should include the echoed prompt')
+    assert.ok(!allText.includes('"t":"err"'), 'should not emit an error event on a successful run')
+    assert.equal(active.size, 0, 'session should be removed from active map after close')
+  })
+
+  it('emits an error event when the binary cannot be found on PATH', async () => {
+    const writes: string[] = []
+    const active = new Map<string, unknown>()
+
+    const result = await streamGenericCliChat({
+      session: { id: 'missing-bin-session', cwd: process.cwd() },
+      message: 'test',
+      write: (data) => writes.push(data),
+      active,
+      loadHistory: () => [],
+      binaryName: 'definitely-not-a-real-binary-zzz-' + Date.now(),
+      displayName: 'Nonexistent CLI',
+    })
+
+    assert.equal(result, '', 'missing binary should produce empty response')
+    assert.equal(writes.length, 1, 'should emit exactly one error event')
+    assert.ok(writes[0].includes('"t":"err"'), 'event should carry the err type')
+    assert.ok(writes[0].includes('Nonexistent CLI not found'), 'error message should mention the display name')
+  })
+})

package/src/lib/providers/generic-cli.ts

@@ -0,0 +1,138 @@
+import { spawn } from 'child_process'
+import type { StreamChatOptions } from './index'
+import { log } from '../server/logger'
+import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
+import { resolveCliBinary, buildCliEnv, attachAbortHandler, isStderrNoise } from './cli-utils'
+
+/**
+ * Map of swarmclaw provider id to the binary name we look up on PATH.
+ * Used by the generic CLI streamer for tools without a bespoke handler.
+ */
+export const GENERIC_CLI_BINARIES: Record<string, string> = {
+  'aider-cli': 'aider',
+  'amp-cli': 'amp',
+  'augment-cli': 'augment',
+  'adal-cli': 'adal',
+  'bob-cli': 'bob',
+  'cline-cli': 'cline',
+  'codebuddy-cli': 'codebuddy',
+  'command-code-cli': 'commandcode',
+  'continue-cli': 'continue',
+  'cortex-cli': 'cortex',
+  'crush-cli': 'crush',
+  'deepagents-cli': 'deepagents',
+  'firebender-cli': 'firebender',
+  'iflow-cli': 'iflow',
+  'junie-cli': 'junie',
+  'kilo-code-cli': 'kilocode',
+  'kimi-cli': 'kimi',
+  'kode-cli': 'kode',
+  'mcpjam-cli': 'mcpjam',
+  'mistral-vibe-cli': 'vibe',
+  'mux-cli': 'mux',
+  'neovate-cli': 'neovate',
+  'openhands-cli': 'openhands',
+  'pochi-cli': 'pochi',
+  'qoder-cli': 'qoder',
+  'replit-cli': 'replit',
+  'roo-code-cli': 'roo',
+  'trae-cn-cli': 'trae-cn',
+  'warp-cli': 'warp',
+  'windsurf-cli': 'windsurf',
+  'zencoder-cli': 'zencoder',
+}
+
+interface GenericCliOptions extends StreamChatOptions {
+  binaryName: string
+  displayName: string
+}
+
+/**
+ * Generic streamer for CLI providers without a bespoke stream parser.
+ *
+ * Spawns the configured binary with the prompt as the final argv, captures
+ * stdout/stderr line-by-line, and emits each line as a delta. No JSON event
+ * parsing — callers that need structured event streams should use a tool-
+ * specific provider instead.
+ */
+export function streamGenericCliChat(opts: GenericCliOptions): Promise<string> {
+  const { session, message, systemPrompt, write, active, signal, binaryName, displayName } = opts
+  const processTimeoutMs = loadRuntimeSettings().cliProcessTimeoutMs
+  const binary = resolveCliBinary(binaryName)
+  if (!binary) {
+    const msg = `${displayName} not found. Install \`${binaryName}\` and ensure it is on your PATH, or remove this provider.`
+    write(`data: ${JSON.stringify({ t: 'err', text: msg })}\n\n`)
+    return Promise.resolve('')
+  }
+
+  const env = buildCliEnv()
+  const prompt = systemPrompt ? `[System instructions]\n${systemPrompt}\n\n${message}` : message
+
+  log.info('generic-cli', `Spawning: ${binary}`, {
+    binaryName,
+    cwd: session.cwd,
+    hasSystemPrompt: Boolean(systemPrompt),
+    promptLength: prompt.length,
+  })
+
+  const proc = spawn(binary, [prompt], {
+    cwd: session.cwd,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: processTimeoutMs,
+  })
+
+  active.set(session.id, proc)
+  attachAbortHandler(proc, signal)
+
+  let fullResponse = ''
+  let buf = ''
+  let stderrText = ''
+
+  proc.stdout?.on('data', (chunk: Buffer) => {
+    buf += chunk.toString()
+    const lines = buf.split('\n')
+    buf = lines.pop() || ''
+    for (const line of lines) {
+      if (!line) continue
+      fullResponse += `${line}\n`
+      write(`data: ${JSON.stringify({ t: 'd', text: `${line}\n` })}\n\n`)
+    }
+  })
+
+  proc.stderr?.on('data', (chunk: Buffer) => {
+    const text = chunk.toString()
+    stderrText += text
+    if (stderrText.length > 16_000) stderrText = stderrText.slice(-16_000)
+    if (isStderrNoise(text)) {
+      log.debug('generic-cli', `stderr noise [${binaryName}/${session.id}]`, text.slice(0, 400))
+    } else {
+      log.warn('generic-cli', `stderr [${binaryName}/${session.id}]`, text.slice(0, 400))
+    }
+  })
+
+  return new Promise((resolve) => {
+    proc.on('close', (code, sig) => {
+      active.delete(session.id)
+      if (buf) {
+        fullResponse += buf
+        write(`data: ${JSON.stringify({ t: 'd', text: buf })}\n\n`)
+        buf = ''
+      }
+      if ((code ?? 0) !== 0 && !fullResponse.trim()) {
+        const msg = stderrText.trim()
+          ? `${displayName} exited with code ${code ?? 'unknown'}${sig ? ` (${sig})` : ''}: ${stderrText.trim().slice(0, 1200)}`
+          : `${displayName} exited with code ${code ?? 'unknown'}${sig ? ` (${sig})` : ''} and returned no output.`
+        write(`data: ${JSON.stringify({ t: 'err', text: msg })}\n\n`)
+      }
+      log.info('generic-cli', `Process closed [${binaryName}]: code=${code} signal=${sig} response=${fullResponse.length}chars`)
+      resolve(fullResponse.trim())
+    })
+
+    proc.on('error', (err) => {
+      active.delete(session.id)
+      write(`data: ${JSON.stringify({ t: 'err', text: err.message })}\n\n`)
+      resolve(fullResponse.trim())
+    })
+  })
+}

package/src/lib/providers/index.ts

@@ -8,6 +8,7 @@ import { streamDroidCliChat } from './droid-cli'
 import { streamCursorCliChat } from './cursor-cli'
 import { streamQwenCodeCliChat } from './qwen-code-cli'
 import { streamGooseChat } from './goose'
+import { streamGenericCliChat, GENERIC_CLI_BINARIES } from './generic-cli'
 import { streamOpenAiChat } from './openai'
 import { streamOllamaChat } from './ollama'
 import { streamAnthropicChat } from './anthropic'
@@ -51,6 +52,59 @@ interface BuiltinProviderConfig extends ProviderInfo {
   handler: ProviderHandler
 }
 
+const GENERIC_CLI_DISPLAY_NAMES: Record<string, string> = {
+  'aider-cli': 'Aider CLI',
+  'amp-cli': 'Amp CLI',
+  'augment-cli': 'Augment CLI',
+  'adal-cli': 'AdaL CLI',
+  'bob-cli': 'IBM Bob CLI',
+  'cline-cli': 'Cline CLI',
+  'codebuddy-cli': 'CodeBuddy CLI',
+  'command-code-cli': 'Command Code CLI',
+  'continue-cli': 'Continue CLI',
+  'cortex-cli': 'Cortex Code CLI',
+  'crush-cli': 'Crush CLI',
+  'deepagents-cli': 'Deep Agents CLI',
+  'firebender-cli': 'Firebender CLI',
+  'iflow-cli': 'iFlow CLI',
+  'junie-cli': 'Junie CLI',
+  'kilo-code-cli': 'Kilo Code CLI',
+  'kimi-cli': 'Kimi Code CLI',
+  'kode-cli': 'Kode CLI',
+  'mcpjam-cli': 'MCPJam CLI',
+  'mistral-vibe-cli': 'Mistral Vibe CLI',
+  'mux-cli': 'Mux CLI',
+  'neovate-cli': 'Neovate CLI',
+  'openhands-cli': 'OpenHands CLI',
+  'pochi-cli': 'Pochi CLI',
+  'qoder-cli': 'Qoder CLI',
+  'replit-cli': 'Replit Agent CLI',
+  'roo-code-cli': 'Roo Code CLI',
+  'trae-cn-cli': 'TRAE CN CLI',
+  'warp-cli': 'Warp Agent CLI',
+  'windsurf-cli': 'Windsurf CLI',
+  'zencoder-cli': 'Zencoder CLI',
+}
+
+function buildGenericCliEntries(): Record<string, BuiltinProviderConfig> {
+  const entries: Record<string, BuiltinProviderConfig> = {}
+  for (const [providerId, binaryName] of Object.entries(GENERIC_CLI_BINARIES)) {
+    const displayName = GENERIC_CLI_DISPLAY_NAMES[providerId] ?? providerId
+    entries[providerId] = {
+      id: providerId,
+      name: displayName,
+      models: ['default'],
+      requiresApiKey: false,
+      optionalApiKey: true,
+      requiresEndpoint: false,
+      handler: {
+        streamChat: (opts) => streamGenericCliChat({ ...opts, binaryName, displayName }),
+      },
+    }
+  }
+  return entries
+}
+
 export const PROVIDERS: Record<string, BuiltinProviderConfig> = {
   'claude-cli': {
     id: 'claude-cli',
@@ -223,6 +277,7 @@ export const PROVIDERS: Record<string, BuiltinProviderConfig> = {
     requiresEndpoint: false,
     handler: { streamChat: streamGooseChat },
   },
+  ...buildGenericCliEntries(),
   google: {
     id: 'google',
     name: 'Google Gemini',
@@ -475,7 +530,7 @@ export function getProviderList(): ProviderInfo[] {
         ...info,
         models: overrides[info.id] || info.models,
         defaultModels: info.models,
-        supportsModelDiscovery: !['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose', 'fireworks'].includes(info.id),
+        supportsModelDiscovery: !['claude-cli', 'codex-cli', 'opencode-cli', 'gemini-cli', 'copilot-cli', 'droid-cli', 'cursor-cli', 'qwen-code-cli', 'goose', 'fireworks', ...Object.keys(GENERIC_CLI_BINARIES)].includes(info.id),
       }
     })
   

package/src/lib/providers/opencode-cli.test.ts

@@ -0,0 +1,9 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { OPENCODE_CLI_STDIO } from './opencode-cli'
+
+describe('opencode-cli provider', () => {
+  it('closes child stdin so argv-prompt runs do not hang waiting for input', () => {
+    assert.deepEqual(OPENCODE_CLI_STDIO, ['ignore', 'pipe', 'pipe'])
+  })
+})

package/src/lib/providers/opencode-cli.ts

@@ -4,6 +4,8 @@ import { log } from '../server/logger'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
 import { resolveCliBinary, buildCliEnv, probeCliAuth, attachAbortHandler, isStderrNoise } from './cli-utils'
 
+export const OPENCODE_CLI_STDIO: ['ignore', 'pipe', 'pipe'] = ['ignore', 'pipe', 'pipe']
+
 /**
  * OpenCode CLI provider — spawns `opencode run <message> --format json` for non-interactive usage.
  * Tracks `session.opencodeSessionId` from streamed JSON events to support multi-turn continuity.
@@ -60,7 +62,9 @@ export function streamOpenCodeCliChat({ session, message, imagePath, systemPromp
   const proc = spawn(binary, args, {
     cwd,
     env,
-    stdio: ['pipe', 'pipe', 'pipe'],
+    // stdin must be closed: OpenCode CLI can wait forever on a connected pipe
+    // even when the prompt is passed via argv.
+    stdio: OPENCODE_CLI_STDIO,
     timeout: processTimeoutMs,
   })
 

package/src/lib/server/missions/mission-templates.test.ts

@@ -96,6 +96,23 @@ describe('mission-templates: registry', () => {
     assert.equal(templates.getMissionTemplate('weekly-agent-quality-report')?.category, 'monitoring')
   })
 
+  it('includes v1.6 love-path templates for review, research, and content', () => {
+    const expected = [
+      ['codebase-review-sprint', 'productivity'],
+      ['research-bureau-scan', 'research'],
+      ['content-studio-cycle', 'communication'],
+    ] as const
+
+    for (const [id, category] of expected) {
+      const template = templates.getMissionTemplate(id)
+      assert.ok(template, `expected ${id} template`)
+      assert.equal(template.category, category)
+      assert.ok(template.defaults.goal.length > 120, `${id} should have a concrete goal`)
+      assert.ok(template.defaults.successCriteria.length >= 3, `${id} should have acceptance criteria`)
+      assert.ok(template.defaults.budget.maxTurns, `${id} should have a turn budget`)
+    }
+  })
+
   it('getMissionTemplate resolves known ids', () => {
     const list = templates.listMissionTemplates()
     const first = list[0]

package/src/lib/server/missions/mission-templates.ts

@@ -303,6 +303,75 @@ export const BUILT_IN_MISSION_TEMPLATES: MissionTemplate[] = [
       reportSchedule: report(DAY),
     },
   },
+  {
+    id: 'codebase-review-sprint',
+    name: 'Codebase Review Sprint',
+    description:
+      'Inspect a repository for user-facing bugs, fragile flows, missing tests, and release-readiness risks.',
+    icon: '🧪',
+    category: 'productivity',
+    tags: ['codebase', 'review', 'release', 'quality'],
+    setupNote:
+      'Set the repository path and risk areas in the goal. Keep code edits disabled unless the mission is explicitly converted into implementation work.',
+    defaults: {
+      title: 'Codebase Review Sprint',
+      goal:
+        'Review the current codebase for release-readiness. Inspect tests, build scripts, recent failure-prone flows, user-facing onboarding, desktop/package notes, and high-risk runtime paths. Produce a prioritized markdown report with bugs, missing tests, quick wins, and deferred risks. Do not edit files unless explicitly approved.',
+      successCriteria: [
+        'At least 5 concrete risks or no-finding checks are documented with file or workflow evidence',
+        'Recommended fixes are prioritized by user impact and implementation effort',
+        'The report separates release blockers from follow-up improvements',
+      ],
+      budget: budget({ maxUsd: 2, maxTokens: 140_000, maxTurns: 140, maxWallclockSec: DAY }),
+      reportSchedule: report(6 * HOUR),
+    },
+  },
+  {
+    id: 'research-bureau-scan',
+    name: 'Research Bureau Scan',
+    description:
+      'Fan out a topic across multiple research angles, then synthesize evidence into a concise decision brief.',
+    icon: '🔎',
+    category: 'research',
+    tags: ['research', 'synthesis', 'competitive', 'decision'],
+    setupNote:
+      'Name the topic, sources, and decision the research should support before starting.',
+    defaults: {
+      title: 'Research Bureau Scan',
+      goal:
+        'Research the target topic from at least three angles: current market signals, technical feasibility, and user impact. Gather source-backed notes, compare conflicting evidence, and produce a concise decision brief with recommendation, confidence, and open questions.',
+      successCriteria: [
+        'At least 6 source-backed findings are captured',
+        'The final brief compares evidence across at least 3 research angles',
+        'Recommendation includes confidence level and open questions',
+      ],
+      budget: budget({ maxUsd: 3, maxTokens: 180_000, maxTurns: 180, maxWallclockSec: 2 * DAY }),
+      reportSchedule: report(12 * HOUR),
+    },
+  },
+  {
+    id: 'content-studio-cycle',
+    name: 'Content Studio Cycle',
+    description:
+      'Turn a brief into draft, edit pass, publish checklist, and repurposed snippets for multiple channels.',
+    icon: '✍️',
+    category: 'communication',
+    tags: ['content', 'writing', 'editorial', 'launch'],
+    setupNote:
+      'Provide the audience, voice, channels, and any approval boundary. Public posting stays manual by default.',
+    defaults: {
+      title: 'Content Studio Cycle',
+      goal:
+        'Convert the supplied brief into a polished content package. Produce an outline, long-form draft, editor notes, publish checklist, and short repurposed snippets for the requested channels. Do not publish or post externally without approval.',
+      successCriteria: [
+        'Package includes outline, draft, editor notes, checklist, and channel snippets',
+        'Copy follows the requested audience and voice constraints',
+        'Any claims that need evidence are marked before publication',
+      ],
+      budget: budget({ maxUsd: 2, maxTokens: 120_000, maxTurns: 120, maxWallclockSec: DAY }),
+      reportSchedule: report(6 * HOUR),
+    },
+  },
   {
     id: 'hello-world-demo',
     name: 'Hello World Demo',

package/src/lib/server/protocols/protocol-service.test.ts

@@ -2,6 +2,31 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
 
+test('protocol-service exposes v1.6 built-in templates for release, research, and builder flows', () => {
+  const output = runWithTempDataDir<{
+    ids: string[]
+    releaseOutputs: string[]
+    builderKinds: string[]
+  }>(`
+    const protocolsMod = await import('./src/lib/server/protocols/protocol-templates')
+    const protocols = protocolsMod.default || protocolsMod
+    const templates = protocols.listAllTemplates()
+    const release = templates.find((template) => template.id === 'release_readiness_panel')
+    const builder = templates.find((template) => template.id === 'builder_review_loop')
+    console.log(JSON.stringify({
+      ids: templates.map((template) => template.id),
+      releaseOutputs: release?.recommendedOutputs || [],
+      builderKinds: builder?.defaultPhases?.map((phase) => phase.kind) || [],
+    }))
+  `, { prefix: 'swarmclaw-protocol-templates-' })
+
+  assert.ok(output.ids.includes('release_readiness_panel'))
+  assert.ok(output.ids.includes('research_bureau_synthesis'))
+  assert.ok(output.ids.includes('builder_review_loop'))
+  assert.ok(output.releaseOutputs.includes('go/no-go decision'))
+  assert.deepEqual(output.builderKinds, ['present', 'collect_independent_inputs', 'compare', 'emit_tasks', 'summarize'])
+})
+
 test('protocol-service creates a hidden transcript run and completes a structured session', () => {
   const output = runWithTempDataDir<{
     status: string | null

package/src/lib/server/protocols/protocol-templates.ts

@@ -77,6 +77,54 @@ export const BUILT_IN_PROTOCOL_TEMPLATES: ProtocolTemplate[] = [
       { id: 'summarize', kind: 'summarize', label: 'Summarize the outcome' },
     ],
   },
+  {
+    id: 'release_readiness_panel',
+    name: 'Release Readiness Panel',
+    description: 'Review a candidate release, compare risks, and produce a go/no-go summary.',
+    builtIn: true,
+    singleAgentAllowed: true,
+    tags: ['release', 'quality', 'review'],
+    recommendedOutputs: ['blockers', 'risk summary', 'go/no-go decision'],
+    defaultPhases: [
+      { id: 'present', kind: 'present', label: 'Set the release context' },
+      { id: 'collect', kind: 'collect_independent_inputs', label: 'Collect release risks' },
+      { id: 'compare', kind: 'compare', label: 'Compare blockers and evidence' },
+      { id: 'decide', kind: 'decide', label: 'Make a go/no-go recommendation' },
+      { id: 'summarize', kind: 'summarize', label: 'Summarize release readiness' },
+    ],
+  },
+  {
+    id: 'research_bureau_synthesis',
+    name: 'Research Bureau Synthesis',
+    description: 'Collect multiple research angles and turn them into one source-backed brief.',
+    builtIn: true,
+    singleAgentAllowed: true,
+    tags: ['research', 'synthesis', 'decision'],
+    recommendedOutputs: ['findings', 'recommendation', 'open questions'],
+    defaultPhases: [
+      { id: 'present', kind: 'present', label: 'Frame the research question' },
+      { id: 'collect', kind: 'collect_independent_inputs', label: 'Collect research angles' },
+      { id: 'compare', kind: 'compare', label: 'Compare source-backed findings' },
+      { id: 'decide', kind: 'decide', label: 'Recommend the current direction' },
+      { id: 'summarize', kind: 'summarize', label: 'Write the decision brief' },
+    ],
+  },
+  {
+    id: 'builder_review_loop',
+    name: 'Builder Review Loop',
+    description: 'Move an implementation plan through builder, reviewer, decision, and follow-up summary.',
+    builtIn: true,
+    singleAgentAllowed: true,
+    tags: ['builder', 'review', 'implementation'],
+    recommendedOutputs: ['implementation notes', 'review risks', 'follow-up tasks'],
+    defaultPhases: [
+      { id: 'present', kind: 'present', label: 'Present the work item' },
+      { id: 'collect', kind: 'collect_independent_inputs', label: 'Collect builder and reviewer notes' },
+      { id: 'compare', kind: 'compare', label: 'Compare implementation and review signals' },
+      { id: 'emit_tasks', kind: 'emit_tasks', label: 'Emit follow-up tasks' },
+      { id: 'summarize', kind: 'summarize', label: 'Summarize the delivery path' },
+    ],
+  },
   {
     id: 'decision_round',
     name: 'Decision Round',

package/src/lib/strip-internal-metadata.test.ts

@@ -35,6 +35,29 @@ describe('stripInternalJson', () => {
     assert.equal(stripInternalJson(input).trim(), '')
   })
 
+  it('removes multi-line working-state JSON with nested strings and arrays', () => {
+    const input = [
+      'Answer first.',
+      '{',
+      '  "factsUpsert": [{ "title": "Nested", "value": "brace } inside a string" }],',
+      '  "questionsUpsert": []',
+      '}',
+      'Answer second.',
+    ].join('\n')
+    const result = stripInternalJson(input)
+    assert.equal(result, 'Answer first. Answer second.')
+  })
+
+  it('preserves objects with internal-looking keys when schema validation fails', () => {
+    const input = 'The score object is { "quality_score": "high", "quality_reasoning": 42 }'
+    assert.equal(stripInternalJson(input), input)
+  })
+
+  it('preserves taskIntent-only user JSON without classifier fields', () => {
+    const input = 'Example payload: { "taskIntent": "book a flight" }'
+    assert.equal(stripInternalJson(input), input)
+  })
+
   it('handles multiple JSON blocks, only removing internal ones', () => {
     const input = '{ "isDeliverableTask": true } some text { "foo": "bar" }'
     const result = stripInternalJson(input)