@swarmclawai/swarmclaw 1.6.0 → 1.6.1

package/README.md

@@ -399,6 +399,17 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.6.1 Highlights
+
+Follow-up release for v1.6 with workflow starts, safer metadata handling, A2A discovery polish, and [#61](https://github.com/swarmclawai/swarmclaw/pull/61) by [@latentwill](https://github.com/latentwill). Thanks latentwill!
+
+- **Mission and protocol templates for real work.** New starter paths cover codebase review sprints, research bureau scans, content studio cycles, release readiness panels, synthesis panels, and builder review loops.
+- **Home launchpad paths.** First-run users can choose a self-hosted assistant, visual workflow, or autonomous mission path, with quality actions still one click away.
+- **A2A discovery is easier to integrate.** The canonical `/.well-known/agent-card.json` endpoint now works alongside the legacy API route and hides disabled or trashed agents from public discovery.
+- **Internal metadata stripping is safer.** Side-channel JSON is removed with balanced-object parsing and zod validation so nested payloads are scrubbed without deleting ordinary user JSON.
+- **Browser smoke gate restored.** `npm run test:e2e` now runs a Playwright smoke against health, A2A discovery, `/home`, and `/quality`, either against a live URL or a temporary local dev server.
+- **OpenCode CLI hang fixed.** OpenCode CLI delegation no longer keeps an inherited stdin pipe open, preventing hangs in non-interactive runs.
+
 ### v1.6.0 Highlights
 
 Operator Quality Center release for builders running autonomous agents in production-like workflows.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",
@@ -87,9 +87,9 @@
     "test:cli": "node --test src/cli/*.test.js bin/*.test.js scripts/postinstall.test.mjs scripts/run-next-build.test.mjs scripts/run-next-typegen.test.mjs",
     "test:setup": "tsx --test src/app/api/setup/check-provider/route.test.ts src/lib/server/provider-model-discovery.test.ts src/components/auth/setup-wizard/utils.test.ts src/components/auth/setup-wizard/types.test.ts src/hooks/setup-done-detection.test.ts src/lib/setup-defaults.test.ts src/lib/server/storage-auth.test.ts src/lib/server/storage-auth-docker.test.ts",
     "test:openclaw": "tsx --test src/lib/openclaw/openclaw-agent-id.test.ts src/lib/openclaw/openclaw-endpoint.test.ts src/lib/server/agents/agent-runtime-config.test.ts src/lib/server/build-llm.test.ts src/lib/server/connectors/connector-routing.test.ts src/lib/server/connectors/openclaw.test.ts src/lib/server/connectors/swarmdock.test.ts src/lib/server/gateway/protocol.test.ts src/lib/server/llm-response-cache.test.ts src/lib/server/mcp-conformance.test.ts src/lib/server/openclaw/agent-resolver.test.ts src/lib/server/openclaw/deploy.test.ts src/lib/server/openclaw/skills-normalize.test.ts src/lib/server/session-tools/openclaw-nodes.test.ts src/lib/server/session-tools/swarmdock.test.ts src/lib/server/tasks/task-quality-gate.test.ts src/lib/server/tasks/task-validation.test.ts src/lib/server/tool-capability-policy.test.ts src/lib/providers/openai.test.ts src/lib/providers/openclaw-exports.test.ts src/app/api/openclaw/dashboard-url/route.test.ts",
-    "test:runtime": "tsx --test src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/tts/route.test.ts",
+    "test:runtime": "tsx --test src/lib/a2a/agent-card.test.ts src/lib/strip-internal-metadata.test.ts src/lib/providers/opencode-cli.test.ts src/lib/server/mcp-gateway-runtime.test.ts src/lib/server/mcp-connection-pool.test.ts src/lib/server/knowledge-sources.test.ts src/lib/server/chat-execution/chat-execution-grounding.test.ts src/lib/server/chat-execution/chat-turn-preparation.test.ts src/lib/server/chat-execution/iteration-timers.test.ts src/lib/server/chat-execution/post-stream-finalization.test.ts src/lib/server/chats/clear-undo-snapshots.test.ts src/lib/server/connectors/email.test.ts src/lib/server/protocols/protocol-service.test.ts src/lib/server/runtime/run-ledger.test.ts src/lib/server/observability/otel-config.test.ts src/lib/server/safe-parse-body.test.ts src/lib/server/missions/mission-templates.test.ts src/lib/app/view-constants.test.ts src/lib/quality/quality-summary.test.ts src/app/api/approvals/route.test.ts src/app/api/agents/agents-route.test.ts src/app/api/tasks/tasks-route.test.ts src/app/api/chats/chat-route.test.ts src/app/api/chats/clear-route.test.ts src/app/api/chats/compact-route.test.ts src/app/api/chats/context-status-route.test.ts src/app/api/connectors/connector-doctor-route.test.ts src/app/api/healthz/route.test.ts src/app/api/logs/route.test.ts src/app/api/providers/[id]/route.test.ts src/app/api/tts/route.test.ts",
     "test:builder": "tsx --test src/features/protocols/builder/utils/nodes-to-template.test.ts src/features/protocols/builder/utils/template-to-nodes.test.ts src/features/protocols/builder/validators/dag-validator.test.ts",
-    "test:e2e": "tsx .workbench/browser-e2e/run.ts",
+    "test:e2e": "node --import tsx scripts/browser-e2e-smoke.ts",
     "test:mcp:conformance": "node --import tsx ./scripts/mcp-conformance-check.ts",
     "electron:compile": "tsc -p electron/tsconfig.json",
     "electron:dev": "npm run electron:compile && electron electron-dist/main.js",

package/src/app/.well-known/agent-card.json/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from 'next/server'
+import { buildAgentCardDiscoveryPayload } from '@/lib/a2a/agent-card'
+
+export const dynamic = 'force-dynamic'
+
+/**
+ * GET /.well-known/agent-card.json?agentId=xxx
+ *
+ * Canonical public A2A Agent Card discovery endpoint. If agentId is omitted,
+ * returns a directory of discoverable local SwarmClaw agents.
+ */
+export async function GET(req: Request) {
+  const { body, status } = buildAgentCardDiscoveryPayload(req)
+  return NextResponse.json(body, { status })
+}

package/src/app/api/.well-known/agent-card/route.ts

@@ -1,46 +1,15 @@
 import { NextResponse } from 'next/server'
-import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
-import { generateAgentCard } from '@/lib/a2a/agent-card'
+import { buildAgentCardDiscoveryPayload } from '@/lib/a2a/agent-card'
 
 export const dynamic = 'force-dynamic'
 
 /**
- * GET /.well-known/agent-card.json?agentId=xxx
+ * GET /api/.well-known/agent-card?agentId=xxx
  *
- * A2A Agent Card discovery endpoint.
- * If agentId is provided, returns the full card for that agent.
- * Otherwise, returns a directory of all non-disabled agents.
- *
- * Publicly accessible per A2A spec — no auth required for discovery.
+ * Back-compatible A2A Agent Card discovery endpoint. The canonical public
+ * well-known URL is implemented at /.well-known/agent-card.json.
  */
 export async function GET(req: Request) {
-  const { searchParams } = new URL(req.url)
-  const agentId = searchParams.get('agentId')
-  const baseUrl = `${new URL(req.url).origin}`
-
-  if (agentId) {
-    const agent = getAgent(agentId)
-    if (!agent) {
-      return NextResponse.json({ error: 'Agent not found' }, { status: 404 })
-    }
-    if (agent.disabled) {
-      return NextResponse.json({ error: 'Agent is disabled' }, { status: 404 })
-    }
-    const card = generateAgentCard(agent, baseUrl)
-    return NextResponse.json(card)
-  }
-
-  // Return directory of all active agents
-  const agents = listAgents()
-  const directory = Object.values(agents)
-    .filter(a => !a.disabled)
-    .map(a => ({
-      name: a.name,
-      description: a.description || `SwarmClaw agent: ${a.name}`,
-      agentId: a.id,
-      apiEndpoint: `${baseUrl}/api/a2a`,
-      cardUrl: `${baseUrl}/api/.well-known/agent-card?agentId=${a.id}`,
-    }))
-
-  return NextResponse.json({ agents: directory, protocolVersion: '0.3.0' })
+  const { body, status } = buildAgentCardDiscoveryPayload(req)
+  return NextResponse.json(body, { status })
 }

package/src/components/home/home-launchpad.tsx

@@ -14,6 +14,48 @@ function SnapshotItem({ label, value, hint }: { label: string; value: string; hi
   )
 }
 
+function PathCard({
+  kicker,
+  title,
+  description,
+  primaryLabel,
+  secondaryLabel,
+  onPrimary,
+  onSecondary,
+}: {
+  kicker: string
+  title: string
+  description: string
+  primaryLabel: string
+  secondaryLabel: string
+  onPrimary: () => void
+  onSecondary: () => void
+}) {
+  return (
+    <div className="flex min-h-[220px] flex-col rounded-[18px] border border-white/[0.07] bg-white/[0.03] p-5">
+      <div className="text-[11px] font-700 uppercase tracking-[0.12em] text-text-3/55">{kicker}</div>
+      <div className="mt-3 text-[18px] font-display font-700 tracking-normal text-text">{title}</div>
+      <p className="mt-2 flex-1 text-[13px] leading-relaxed text-text-3/72">{description}</p>
+      <div className="mt-5 flex flex-wrap gap-2">
+        <button
+          type="button"
+          onClick={onPrimary}
+          className="rounded-[10px] bg-accent-bright px-3.5 py-2 text-[12px] font-display font-700 text-black transition-opacity hover:opacity-90"
+        >
+          {primaryLabel}
+        </button>
+        <button
+          type="button"
+          onClick={onSecondary}
+          className="rounded-[10px] border border-white/[0.08] bg-white/[0.04] px-3.5 py-2 text-[12px] font-display font-700 text-text-2 transition-colors hover:bg-white/[0.08]"
+        >
+          {secondaryLabel}
+        </button>
+      </div>
+    </div>
+  )
+}
+
 type Props = {
   firstAgent: Agent | null
   agentCount: number
@@ -53,17 +95,17 @@ export function HomeLaunchpad({
 }: Props) {
   return (
     <div className="max-w-[980px] mx-auto px-6 py-10">
-      <div className="rounded-[24px] border border-white/[0.06] bg-gradient-to-br from-white/[0.05] via-white/[0.02] to-transparent p-6">
+      <div className="rounded-[20px] border border-white/[0.06] bg-white/[0.025] p-6">
         <div className="inline-flex rounded-full border border-white/[0.08] bg-white/[0.03] px-3 py-1 text-[11px] font-700 uppercase tracking-[0.16em] text-text-3/70">
-          Launchpad
+          v1.6 Launchpad
         </div>
         <div className="mt-4 flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between">
           <div className="max-w-[620px]">
-            <h1 className="font-display text-[34px] font-700 tracking-[-0.03em] text-text">
-              Start with the result you want, not the control plane.
+            <h1 className="font-display text-[34px] font-700 tracking-normal text-text">
+              Pick a path and watch the workspace move.
             </h1>
             <p className="mt-3 text-[15px] leading-relaxed text-text-3/72">
-              SwarmClaw already has the building blocks. Use this workspace to start a live agent chat, launch a bounded session, wire a connector, or move straight into reusable workflows.
+              Start with a local assistant, a reusable workflow, or a budgeted autonomous mission. The rest of the control plane stays one click away.
             </p>
           </div>
           <div className="rounded-[18px] border border-white/[0.06] bg-white/[0.03] p-4 min-w-[240px]">
@@ -94,6 +136,36 @@ export function HomeLaunchpad({
         </div>
       </div>
 
+      <div className="mt-6 grid gap-3 lg:grid-cols-3">
+        <PathCard
+          kicker="Self-hosted assistant"
+          title={firstAgent ? `Work with ${firstAgent.name}` : 'Create the first agent'}
+          description="Open a live agent chat, then add memory, local tools, provider routing, or connector access as the work demands."
+          primaryLabel={firstAgent ? 'Open Chat' : 'Open Agents'}
+          secondaryLabel="Connect Platform"
+          onPrimary={onOpenFirstAgent}
+          onSecondary={onOpenConnectors}
+        />
+        <PathCard
+          kicker="Visual workflow"
+          title="Shape a reusable run"
+          description="Use protocol templates and the builder to turn review, research, planning, or release checks into durable workflows."
+          primaryLabel="Open Builder"
+          secondaryLabel="Use Templates"
+          onPrimary={onOpenBuilder}
+          onSecondary={onOpenProtocols}
+        />
+        <PathCard
+          kicker="Autonomous mission"
+          title="Run with budgets"
+          description="Start a mission template for release QA, research, support triage, cost audit, or failed-run review with reports and caps."
+          primaryLabel="Open Missions"
+          secondaryLabel="Quality Center"
+          onPrimary={onStartReleaseQaMission}
+          onSecondary={onRunEvalSuite}
+        />
+      </div>
+
       <div className="mt-6 grid gap-3 md:grid-cols-2 xl:grid-cols-3">
         <LaunchActionCard
           title={firstAgent ? 'Open First Agent Chat' : 'Open Agents'}

package/src/lib/a2a/agent-card.test.ts

@@ -0,0 +1,94 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let storage: typeof import('@/lib/server/storage')
+let canonicalRoute: typeof import('@/app/.well-known/agent-card.json/route')
+let legacyRoute: typeof import('@/app/api/.well-known/agent-card/route')
+
+function testAgent(id: string, overrides: Record<string, unknown> = {}) {
+  const now = Date.now()
+  return {
+    id,
+    name: id === 'agent-active' ? 'Active Agent' : 'Hidden Agent',
+    description: 'A2A route test agent',
+    systemPrompt: '',
+    provider: 'ollama',
+    model: 'qwen3.5',
+    credentialId: null,
+    fallbackCredentialIds: [],
+    apiEndpoint: null,
+    gatewayProfileId: null,
+    extensions: [],
+    capabilities: ['research'],
+    createdAt: now,
+    updatedAt: now,
+    ...overrides,
+  }
+}
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-a2a-card-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  storage = await import('@/lib/server/storage')
+  canonicalRoute = await import('@/app/.well-known/agent-card.json/route')
+  legacyRoute = await import('@/app/api/.well-known/agent-card/route')
+  storage.saveAgents({
+    'agent-active': testAgent('agent-active'),
+    'agent-disabled': testAgent('agent-disabled', { disabled: true }),
+    'agent-trashed': testAgent('agent-trashed', { trashedAt: Date.now() }),
+  })
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('A2A agent card discovery', () => {
+  it('serves the canonical well-known directory and hides disabled agents', async () => {
+    const response = await canonicalRoute.GET(new Request('http://local.test/.well-known/agent-card.json'))
+    assert.equal(response.status, 200)
+    const body = await response.json()
+
+    assert.equal(body.protocolVersion, '0.3.0')
+    assert.equal(body.kind, 'directory')
+    assert.deepEqual(body.agents.map((agent: { agentId: string }) => agent.agentId), ['agent-active'])
+    assert.equal(body.agents[0].apiEndpoint, 'http://local.test/api/a2a')
+    assert.equal(body.agents[0].cardUrl, 'http://local.test/.well-known/agent-card.json?agentId=agent-active')
+  })
+
+  it('returns a full card from both canonical and legacy routes', async () => {
+    const canonical = await canonicalRoute.GET(new Request('http://local.test/.well-known/agent-card.json?agentId=agent-active'))
+    const legacy = await legacyRoute.GET(new Request('http://local.test/api/.well-known/agent-card?agentId=agent-active'))
+
+    assert.equal(canonical.status, 200)
+    assert.equal(legacy.status, 200)
+    assert.equal((await canonical.json()).name, 'Active Agent')
+    assert.equal((await legacy.json()).apiEndpoint, 'http://local.test/api/a2a')
+  })
+
+  it('returns 404 for disabled or missing agent cards', async () => {
+    const disabled = await canonicalRoute.GET(new Request('http://local.test/.well-known/agent-card.json?agentId=agent-disabled'))
+    const missing = await canonicalRoute.GET(new Request('http://local.test/.well-known/agent-card.json?agentId=nope'))
+
+    assert.equal(disabled.status, 404)
+    assert.equal(missing.status, 404)
+  })
+})

package/src/lib/a2a/agent-card.ts

@@ -1,7 +1,8 @@
 import type { Agent } from '@/types/agent'
 import type { AgentCard } from './types'
+import { getAgent, listAgents } from '@/lib/server/agents/agent-repository'
 
-const A2A_PROTOCOL_VERSION = '0.3.0'
+export const A2A_PROTOCOL_VERSION = '0.3.0'
 const SWARMCLAW_VERSION = '1.0.0'
 
 /**
@@ -59,3 +60,42 @@ export function generateAgentCard(agent: Agent, baseUrl: string): AgentCard {
     ],
   }
 }
+
+function isPubliclyDiscoverableAgent(agent: Agent): boolean {
+  return agent.disabled !== true && !agent.trashedAt
+}
+
+export function buildAgentCardDiscoveryPayload(req: Request): {
+  body: unknown
+  status?: number
+} {
+  const url = new URL(req.url)
+  const agentId = url.searchParams.get('agentId')
+  const baseUrl = url.origin
+
+  if (agentId) {
+    const agent = getAgent(agentId)
+    if (!agent || !isPubliclyDiscoverableAgent(agent)) {
+      return { body: { error: 'Agent not found' }, status: 404 }
+    }
+    return { body: generateAgentCard(agent, baseUrl) }
+  }
+
+  const directory = Object.values(listAgents())
+    .filter(isPubliclyDiscoverableAgent)
+    .map((agent) => ({
+      name: agent.name,
+      description: agent.description || `SwarmClaw agent: ${agent.name}`,
+      agentId: agent.id,
+      apiEndpoint: `${baseUrl}/api/a2a`,
+      cardUrl: `${baseUrl}/.well-known/agent-card.json?agentId=${encodeURIComponent(agent.id)}`,
+    }))
+
+  return {
+    body: {
+      agents: directory,
+      kind: 'directory',
+      protocolVersion: A2A_PROTOCOL_VERSION,
+    },
+  }
+}

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)

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

@@ -9,27 +9,156 @@
  *
  * Importable from both client and server code.
  */
+import { z } from 'zod'
 
 // ---------------------------------------------------------------------------
 // Classification JSON
 // ---------------------------------------------------------------------------
 
 const INTERNAL_JSON_KEYS = [
-  'isDeliverableTask', 'quality_score', 'isBroadGoal',
-  'hasHumanSignals', 'explicitToolRequests', 'isResearchSynthesis', 'confidence',
+  'factsUpsert', 'artifactsUpsert', 'planSteps', 'decisionsAppend',
+  'blockersUpsert', 'questionsUpsert', 'hypothesesUpsert', 'supersedeIds',
+  'taskIntent', 'isLightweightDirectChat', 'isDeliverableTask', 'quality_score',
+  'isBroadGoal', 'hasHumanSignals', 'explicitToolRequests', 'isResearchSynthesis',
+  'confidence', 'isIncomplete',
 ]
 
 export const INTERNAL_KEY_RE = new RegExp(`"(?:${INTERNAL_JSON_KEYS.join('|')})"`)
 
+const WorkingStatePatchLikeSchema = z.object({
+  factsUpsert: z.array(z.unknown()).optional(),
+  artifactsUpsert: z.array(z.unknown()).optional(),
+  planSteps: z.array(z.unknown()).optional(),
+  decisionsAppend: z.array(z.unknown()).optional(),
+  blockersUpsert: z.array(z.unknown()).optional(),
+  questionsUpsert: z.array(z.unknown()).optional(),
+  hypothesesUpsert: z.array(z.unknown()).optional(),
+  supersedeIds: z.array(z.unknown()).optional(),
+}).passthrough()
+
+const MessageClassificationLikeSchema = z.object({
+  taskIntent: z.string().optional(),
+  isLightweightDirectChat: z.boolean().optional(),
+  isDeliverableTask: z.boolean().optional(),
+  isBroadGoal: z.boolean().optional(),
+  hasHumanSignals: z.boolean().optional(),
+  explicitToolRequests: z.array(z.unknown()).optional(),
+  isResearchSynthesis: z.boolean().optional(),
+  confidence: z.number().optional(),
+}).passthrough()
+
+const ResponseCompletenessLikeSchema = z.object({
+  isIncomplete: z.boolean(),
+}).passthrough()
+
+const QualityScoreLikeSchema = z.object({
+  quality_score: z.number(),
+  quality_reasoning: z.string().optional(),
+}).passthrough()
+
+interface InternalPayloadRule {
+  schema: z.ZodType<unknown>
+  distinctiveKeys: string[]
+}
+
+const INTERNAL_PAYLOAD_RULES: InternalPayloadRule[] = [
+  {
+    schema: WorkingStatePatchLikeSchema,
+    distinctiveKeys: [
+      'factsUpsert',
+      'artifactsUpsert',
+      'planSteps',
+      'decisionsAppend',
+      'blockersUpsert',
+      'questionsUpsert',
+      'hypothesesUpsert',
+      'supersedeIds',
+    ],
+  },
+  {
+    schema: MessageClassificationLikeSchema,
+    distinctiveKeys: [
+      'isLightweightDirectChat',
+      'isDeliverableTask',
+      'isBroadGoal',
+      'hasHumanSignals',
+      'explicitToolRequests',
+      'isResearchSynthesis',
+    ],
+  },
+  {
+    schema: ResponseCompletenessLikeSchema,
+    distinctiveKeys: ['isIncomplete'],
+  },
+  {
+    schema: QualityScoreLikeSchema,
+    distinctiveKeys: ['quality_score'],
+  },
+]
+
+function objectIsInternalMetadata(obj: Record<string, unknown>): boolean {
+  for (const { schema, distinctiveKeys } of INTERNAL_PAYLOAD_RULES) {
+    if (!distinctiveKeys.some((key) => key in obj)) continue
+    if (schema.safeParse(obj).success) return true
+  }
+  return false
+}
+
+function findBalancedJsonObjectEnd(text: string, start: number): number {
+  if (text.charAt(start) !== '{') return -1
+  let depth = 0
+  let inString = false
+  let escaped = false
+  for (let i = start; i < text.length; i += 1) {
+    const c = text.charAt(i)
+    if (inString) {
+      if (escaped) escaped = false
+      else if (c === '\\') escaped = true
+      else if (c === '"') inString = false
+      continue
+    }
+    if (c === '"') {
+      inString = true
+      continue
+    }
+    if (c === '{') depth += 1
+    else if (c === '}') {
+      depth -= 1
+      if (depth === 0) return i + 1
+    }
+  }
+  return -1
+}
+
 /**
  * Remove top-level `{ ... }` blocks that contain known internal classification keys.
- * Handles multi-line JSON. Only strips blocks where at least one internal key is present.
+ * Handles nested and multi-line JSON. Only strips blocks where at least one
+ * distinctive internal key is present and the payload passes schema validation.
  */
 export function stripInternalJson(text: string): string {
-  return text.replace(
-    /\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/g,
-    (match) => INTERNAL_KEY_RE.test(match) ? '' : match,
-  )
+  let out = text || ''
+  for (let guard = 0; guard < 32; guard += 1) {
+    let removed = false
+    for (let i = 0; i < out.length; i += 1) {
+      if (out.charAt(i) !== '{') continue
+      const end = findBalancedJsonObjectEnd(out, i)
+      if (end <= i) continue
+      const candidate = out.slice(i, end)
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(candidate)
+      } catch {
+        continue
+      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) continue
+      if (!objectIsInternalMetadata(parsed as Record<string, unknown>)) continue
+      out = (out.slice(0, i).replace(/\s+$/, '') + ' ' + out.slice(end).replace(/^\s+/, '')).trim()
+      removed = true
+      break
+    }
+    if (!removed) break
+  }
+  return out
 }
 
 // ---------------------------------------------------------------------------