@swarmclawai/swarmclaw 1.2.4 → 1.2.5

package/src/lib/server/working-state/prompt.ts

@@ -0,0 +1,60 @@
+import { cleanText } from '@/lib/server/text-normalization'
+import type { SessionWorkingState } from '@/types'
+
+// ---------------------------------------------------------------------------
+// buildWorkingStatePromptBlock
+// ---------------------------------------------------------------------------
+
+function buildListSection(title: string, values: string[]): string | null {
+  if (values.length === 0) return null
+  return [title, ...values.map((value) => `- ${value}`)].join('\n')
+}
+
+export function buildWorkingStatePromptBlockFromState(
+  state: SessionWorkingState | null,
+): string {
+  if (!state) return ''
+  const activePlan = state.planSteps
+    .filter((item) => item.status === 'active')
+    .map((item) => item.text)
+    .slice(0, 8)
+  const confirmedFacts = state.confirmedFacts
+    .filter((item) => item.status === 'active')
+    .map((item) => item.statement)
+    .slice(0, 8)
+  const blockers = state.blockers
+    .filter((item) => item.status === 'active')
+    .map((item) => item.nextAction ? `${item.summary} | next: ${item.nextAction}` : item.summary)
+    .slice(0, 6)
+  const questions = state.openQuestions
+    .filter((item) => item.status === 'active')
+    .map((item) => item.question)
+    .slice(0, 6)
+  const hypotheses = state.hypotheses
+    .filter((item) => item.status === 'active')
+    .map((item) => item.confidence ? `${item.statement} (${item.confidence})` : item.statement)
+    .slice(0, 6)
+  const artifacts = state.artifacts
+    .filter((item) => item.status === 'active')
+    .map((item) => cleanText(item.path || item.url || item.label, 220))
+    .slice(0, 6)
+
+  const sections = [
+    '## Active Working State',
+    state.objective ? `Objective: ${state.objective}` : '',
+    state.summary ? `Summary: ${state.summary}` : '',
+    `Status: ${state.status}`,
+    state.nextAction ? `Next action: ${state.nextAction}` : '',
+    state.successCriteria.length > 0 ? `Success criteria: ${state.successCriteria.join(' | ')}` : '',
+    state.constraints.length > 0 ? `Constraints: ${state.constraints.join(' | ')}` : '',
+    buildListSection('Plan', activePlan),
+    buildListSection('Confirmed facts', confirmedFacts),
+    buildListSection('Blockers', blockers),
+    buildListSection('Open questions', questions),
+    buildListSection('Hypotheses', hypotheses),
+    buildListSection('Artifacts', artifacts),
+    'Trust this structured state before reconstructing status from the raw transcript.',
+  ].filter(Boolean)
+
+  return sections.join('\n')
+}

package/src/lib/server/working-state/repository.ts

@@ -0,0 +1,38 @@
+import { perf } from '@/lib/server/runtime/perf'
+import {
+  deletePersistedWorkingState as deleteStoredWorkingState,
+  loadPersistedWorkingState as loadStoredWorkingState,
+  upsertPersistedWorkingState as upsertStoredWorkingState,
+} from '@/lib/server/storage'
+
+export type PersistedWorkingState = Record<string, unknown>
+
+export function loadPersistedWorkingState(sessionId: string): PersistedWorkingState | null {
+  return perf.measureSync(
+    'repository',
+    'working-state.get',
+    () => loadStoredWorkingState(sessionId) as PersistedWorkingState | null,
+    { sessionId },
+  )
+}
+
+export function upsertPersistedWorkingState(
+  sessionId: string,
+  value: PersistedWorkingState,
+): void {
+  perf.measureSync(
+    'repository',
+    'working-state.upsert',
+    () => upsertStoredWorkingState(sessionId, value),
+    { sessionId },
+  )
+}
+
+export function deletePersistedWorkingState(sessionId: string): void {
+  perf.measureSync(
+    'repository',
+    'working-state.delete',
+    () => deleteStoredWorkingState(sessionId),
+    { sessionId },
+  )
+}

package/src/lib/server/working-state/service.test.ts

@@ -0,0 +1,253 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-working-state-'))
+  try {
+    const result = spawnSync(
+      process.execPath,
+      ['--import', 'tsx', '--input-type=module', '--eval', script],
+      {
+        cwd: repoRoot,
+        env: {
+          ...process.env,
+          DATA_DIR: tempDir,
+          WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+          SWARMCLAW_BUILD_MODE: '1',
+        },
+        encoding: 'utf-8',
+        timeout: 20000,
+      },
+    )
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}') as Record<string, unknown>
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('working-state service', () => {
+  it('merges deterministic evidence with structured extraction and renders a prompt block', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('@/lib/server/storage')
+      const storage = storageMod.default || storageMod['module.exports'] || storageMod
+      const serviceMod = await import('@/lib/server/working-state/service')
+      const service = serviceMod.default || serviceMod['module.exports'] || serviceMod
+
+      storage.saveAgents({
+        'agent-a': {
+          id: 'agent-a',
+          name: 'Agent A',
+          provider: 'openai',
+          model: 'gpt-test',
+        },
+      })
+
+      storage.saveSessions({
+        main: {
+          id: 'main',
+          name: 'Main Thread',
+          shortcutForAgentId: 'agent-a',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [
+            { role: 'user', text: 'Please fix the migration and write the summary to docs/migration.md.', time: 1 },
+          ],
+          createdAt: 1,
+          lastActiveAt: 1,
+          sessionType: 'human',
+          agentId: 'agent-a',
+          heartbeatEnabled: true,
+        },
+      })
+
+      const mission = {
+        id: 'mission-1',
+        source: 'chat',
+        objective: 'Ship the migration fix safely.',
+        successCriteria: ['docs written', 'type-check green'],
+        status: 'active',
+        phase: 'executing',
+        currentStep: 'Run deploy after approval',
+        plannerSummary: 'Fix the migration, verify it, then deploy.',
+        verifierSummary: null,
+        blockerSummary: null,
+        createdAt: 1,
+        updatedAt: 2,
+      }
+
+      const state = await service.synchronizeWorkingStateForTurn({
+        sessionId: 'main',
+        agentId: 'agent-a',
+        mission,
+        source: 'chat',
+        runId: 'run-1',
+        message: 'Please fix the migration and write the summary to docs/migration.md.',
+        assistantText: 'I fixed the migration and wrote docs/migration.md.',
+        toolEvents: [
+          {
+            name: 'files',
+            input: JSON.stringify({ action: 'write', files: [{ path: 'docs/migration.md', content: '# migration' }] }),
+            output: JSON.stringify({ ok: true, files: [{ path: 'docs/migration.md' }] }),
+          },
+          {
+            name: 'shell',
+            input: 'npm run type-check',
+            output: 'Type check passed. Evidence file: /api/uploads/typecheck.txt',
+          },
+          {
+            name: 'deploy_release',
+            input: JSON.stringify({ env: 'prod' }),
+            output: JSON.stringify({ requiresApproval: true, approvalId: 'apr-123' }),
+          },
+        ],
+      }, {
+        generateText: async () => JSON.stringify({
+          status: 'blocked',
+          nextAction: 'Wait for approval apr-123, then run the deploy step.',
+          planSteps: [
+            { text: 'Fix the migration build issue', status: 'resolved' },
+            { text: 'Wait for approval apr-123', status: 'active' },
+          ],
+          factsUpsert: [
+            { statement: 'Type check passed after the migration update.', source: 'tool' },
+          ],
+          decisionsAppend: [
+            { summary: 'Capture the migration summary in docs/migration.md.', rationale: 'Keep the fix durable.' },
+          ],
+          blockersUpsert: [
+            { summary: 'Approval apr-123 is pending.', kind: 'approval', nextAction: 'Wait for approval apr-123', status: 'active' },
+          ],
+          hypothesesUpsert: [
+            { statement: 'After approval, deploy should be the only remaining step.', confidence: 'medium', status: 'active' },
+          ],
+        }),
+      })
+
+      const prompt = service.buildWorkingStatePromptBlock('main', { mission })
+      console.log(JSON.stringify({
+        status: state.status,
+        nextAction: state.nextAction,
+        planSteps: state.planSteps.map((step) => ({ text: step.text, status: step.status })),
+        facts: state.confirmedFacts.map((fact) => fact.statement),
+        blockers: state.blockers.map((blocker) => blocker.summary),
+        artifacts: state.artifacts.map((artifact) => artifact.path || artifact.url || artifact.label),
+        prompt,
+      }))
+    `)
+
+    assert.equal(output.status, 'blocked')
+    assert.match(String(output.nextAction), /approval apr-123/i)
+    assert.ok(Array.isArray(output.planSteps) && output.planSteps.some((step) => /wait for approval apr-123/i.test(String((step as Record<string, unknown>).text))))
+    assert.ok(Array.isArray(output.facts) && output.facts.some((fact) => /type check passed/i.test(String(fact))))
+    assert.ok(Array.isArray(output.blockers) && output.blockers.some((blocker) => /approval apr-123 is pending/i.test(String(blocker))))
+    assert.ok(Array.isArray(output.artifacts) && output.artifacts.some((artifact) => /docs\/migration\.md/i.test(String(artifact))))
+    assert.match(String(output.prompt), /Active Working State/)
+    assert.match(String(output.prompt), /docs\/migration\.md/)
+    assert.match(String(output.prompt), /approval apr-123/i)
+  })
+
+  it('keeps the main loop hydrated from working state and mirrors main-loop updates back', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('@/lib/server/storage')
+      const storage = storageMod.default || storageMod['module.exports'] || storageMod
+      const mainLoopMod = await import('@/lib/server/agents/main-agent-loop')
+      const mainLoop = mainLoopMod.default || mainLoopMod['module.exports'] || mainLoopMod
+      const serviceMod = await import('@/lib/server/working-state/service')
+      const service = serviceMod.default || serviceMod['module.exports'] || serviceMod
+
+      storage.saveAgents({
+        'agent-a': {
+          id: 'agent-a',
+          name: 'Agent A',
+          provider: 'openai',
+          model: 'gpt-test',
+        },
+      })
+
+      storage.saveSessions({
+        main: {
+          id: 'main',
+          name: 'Main Thread',
+          shortcutForAgentId: 'agent-a',
+          cwd: process.cwd(),
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [
+            { role: 'user', text: 'Ship the release checklist.', time: 1 },
+          ],
+          createdAt: 1,
+          lastActiveAt: 1,
+          sessionType: 'human',
+          agentId: 'agent-a',
+          heartbeatEnabled: true,
+        },
+      })
+
+      service.applyWorkingStatePatch('main', {
+        objective: 'Ship the release checklist.',
+        status: 'progress',
+        nextAction: 'Verify the changelog output.',
+        planSteps: [
+          { text: 'Verify the changelog output.', status: 'active' },
+          { text: 'Publish the release notes.', status: 'resolved' },
+        ],
+        blockersUpsert: [
+          { summary: 'Waiting on release manager approval.', kind: 'approval', status: 'active' },
+        ],
+      })
+
+      const before = mainLoop.getMainLoopStateForSession('main')
+      const prompt = mainLoop.buildMainLoopHeartbeatPrompt(storage.loadSessions().main, 'fallback heartbeat')
+
+      mainLoop.handleMainLoopRunResult({
+        sessionId: 'main',
+        message: 'Continue the release checklist.',
+        internal: true,
+        source: 'heartbeat',
+        resultText: [
+          'Updated the changelog and prepared the release notes.',
+          '[MAIN_LOOP_PLAN]{"steps":["publish the release notes"],"current_step":"publish the release notes","completed_steps":["verify the changelog output"]}',
+          '[MAIN_LOOP_REVIEW]{"note":"changelog verified","confidence":0.91,"needs_replan":false}',
+          '[AGENT_HEARTBEAT_META]{"goal":"Ship the release checklist","status":"progress","next_action":"publish the release notes"}',
+        ].join('\\n'),
+        toolEvents: [{ name: 'shell', input: 'npm run type-check', output: 'ok' }],
+      })
+
+      const after = mainLoop.getMainLoopStateForSession('main')
+      const working = service.loadSessionWorkingState('main')
+
+      console.log(JSON.stringify({
+        beforeNextAction: before?.nextAction || null,
+        prompt,
+        afterNextAction: after?.nextAction || null,
+        workingNextAction: working?.nextAction || null,
+        workingPlanSteps: working?.planSteps?.map((step) => ({ text: step.text, status: step.status })) || [],
+      }))
+    `)
+
+    assert.match(String(output.beforeNextAction), /verify the changelog output/i)
+    assert.match(String(output.prompt), /verify the changelog output/i)
+    assert.match(String(output.prompt), /waiting on release manager approval/i)
+    assert.match(String(output.afterNextAction), /publish the release notes/i)
+    assert.match(String(output.workingNextAction), /publish the release notes/i)
+    assert.ok(Array.isArray(output.workingPlanSteps) && output.workingPlanSteps.some((step) => /publish the release notes/i.test(String((step as Record<string, unknown>).text))))
+  })
+})

package/src/lib/server/working-state/service.ts

@@ -0,0 +1,293 @@
+import { genId } from '@/lib/id'
+import { cleanText, cleanMultiline, normalizeList } from '@/lib/server/text-normalization'
+import type {
+  Mission,
+  SessionWorkingState,
+  WorkingBlocker,
+  WorkingPlanStepPatch,
+  WorkingStatePatch,
+  WorkingStateItemStatus,
+  WorkingStateStatus,
+} from '@/types'
+
+import {
+  deletePersistedWorkingState,
+  loadPersistedWorkingState,
+  upsertPersistedWorkingState,
+} from './repository'
+
+import {
+  normalizeWorkingState,
+  defaultWorkingState,
+  compactWorkingStateObject,
+  syncWorkingStateWithMission,
+  normalizeItemStatus,
+  normalizeStateStatus,
+  upsertItems,
+  factUpsertConfig,
+  artifactUpsertConfig,
+  decisionUpsertConfig,
+  blockerUpsertConfig,
+  questionUpsertConfig,
+  hypothesisUpsertConfig,
+  appendEvidenceRefs,
+  markSuperseded,
+  now,
+  MAX_PLAN_STEPS,
+  compactPlanSteps,
+} from '@/lib/server/working-state/normalization'
+import type {
+  WorkingStateDeterministicUpdateInput,
+  SynchronizeWorkingStateForTurnInput,
+} from '@/lib/server/working-state/normalization'
+
+import {
+  deterministicEvidencePatch,
+  extractWorkingStatePatch,
+  shouldExtractStructuredPatch,
+} from '@/lib/server/working-state/extraction'
+
+import { buildWorkingStatePromptBlockFromState } from '@/lib/server/working-state/prompt'
+
+// ---------------------------------------------------------------------------
+// Re-exports for consumer compatibility
+// ---------------------------------------------------------------------------
+
+// normalization.ts re-exports
+export {
+  // Constants
+  MAX_PLAN_STEPS,
+  MAX_CONFIRMED_FACTS,
+  MAX_ARTIFACTS,
+  MAX_DECISIONS,
+  MAX_BLOCKERS,
+  MAX_OPEN_QUESTIONS,
+  MAX_HYPOTHESES,
+  MAX_EVIDENCE_REFS,
+  EXTRACTION_TIMEOUT_MS,
+  ACTIVE_STATUS,
+  // Schemas
+  WorkingPlanStepPatchSchema,
+  WorkingFactPatchSchema,
+  WorkingArtifactPatchSchema,
+  WorkingDecisionPatchSchema,
+  WorkingBlockerPatchSchema,
+  WorkingQuestionPatchSchema,
+  WorkingHypothesisPatchSchema,
+  WorkingStatePatchSchema,
+  // Normalize functions
+  normalizeItemStatus,
+  normalizeStateStatus,
+  normalizeEvidenceIds,
+  normalizeEvidenceRef,
+  normalizePlanStep,
+  normalizeFact,
+  normalizeArtifact,
+  normalizeDecision,
+  normalizeBlocker,
+  normalizeQuestion,
+  normalizeHypothesis,
+  normalizeWorkingState,
+  normalizeMatchKey,
+  // Utility helpers
+  now,
+  itemSortRank,
+  genericCompact,
+  compactPlanSteps,
+  defaultWorkingState,
+  compactWorkingStateObject,
+  missionStatusToWorkingStateStatus,
+  syncWorkingStateWithMission,
+  // Upsert
+  upsertItems,
+  factUpsertConfig,
+  artifactUpsertConfig,
+  decisionUpsertConfig,
+  blockerUpsertConfig,
+  questionUpsertConfig,
+  hypothesisUpsertConfig,
+  appendEvidenceRefs,
+  markSuperseded,
+} from '@/lib/server/working-state/normalization'
+export type {
+  TimedWorkingItem,
+  UpsertConfig,
+  WorkingStateDeterministicUpdateInput,
+  WorkingStateExtractionInput,
+  SynchronizeWorkingStateForTurnInput,
+} from '@/lib/server/working-state/normalization'
+
+// extraction.ts re-exports
+export {
+  parseStructuredObject,
+  extractFirstJsonObject,
+  parseWorkingStatePatchResponse,
+  renderStateForExtraction,
+  summarizeToolEvents,
+  buildWorkingStatePatchPrompt,
+  collectJsonCandidates,
+  uniqueByKey,
+  looksLikeUrl,
+  looksLikeFilePath,
+  extractPlainTextArtifacts,
+  deterministicEvidencePatch,
+  extractWorkingStatePatch,
+  shouldExtractStructuredPatch,
+} from '@/lib/server/working-state/extraction'
+
+// prompt.ts re-exports
+export { buildWorkingStatePromptBlockFromState } from '@/lib/server/working-state/prompt'
+
+// ---------------------------------------------------------------------------
+// CRUD / coordination layer
+// ---------------------------------------------------------------------------
+
+export function loadSessionWorkingState(sessionId: string, options?: { mission?: Mission | null }): SessionWorkingState | null {
+  const stored = loadPersistedWorkingState(sessionId)
+  if (!stored && !options?.mission) return null
+  return normalizeWorkingState(stored, sessionId, options?.mission || null)
+}
+
+export function getOrCreateSessionWorkingState(sessionId: string, options?: { mission?: Mission | null }): SessionWorkingState {
+  return loadSessionWorkingState(sessionId, options) || defaultWorkingState(sessionId, options?.mission || null)
+}
+
+export function saveSessionWorkingState(state: SessionWorkingState): SessionWorkingState {
+  const normalized = compactWorkingStateObject(normalizeWorkingState(state, state.sessionId))
+  upsertPersistedWorkingState(normalized.sessionId, normalized as unknown as Record<string, unknown>)
+  return normalized
+}
+
+export function deleteSessionWorkingState(sessionId: string): void {
+  deletePersistedWorkingState(sessionId)
+}
+
+export function applyWorkingStatePatch(
+  sessionId: string,
+  patch: WorkingStatePatch,
+  options?: { mission?: Mission | null },
+): SessionWorkingState {
+  const current = getOrCreateSessionWorkingState(sessionId, options)
+  const next: SessionWorkingState = {
+    ...current,
+    missionId: options?.mission?.id || current.missionId || null,
+    objective: patch.objective !== undefined ? (cleanMultiline(patch.objective, 900) || null) : current.objective,
+    summary: patch.summary !== undefined ? (cleanMultiline(patch.summary, 600) || null) : current.summary,
+    constraints: patch.constraints !== undefined ? normalizeList(patch.constraints, 12, 240) : current.constraints,
+    successCriteria: patch.successCriteria !== undefined ? normalizeList(patch.successCriteria, 12, 240) : current.successCriteria,
+    status: patch.status !== undefined && patch.status !== null ? normalizeStateStatus(patch.status, current.status) : current.status,
+    nextAction: patch.nextAction !== undefined ? (cleanText(patch.nextAction, 240) || null) : current.nextAction,
+    planSteps: upsertItems(current.planSteps, patch.planSteps, {
+      max: MAX_PLAN_STEPS,
+      getPatchId: (item) => cleanText(item.id, 120) || null,
+      getPatchKey: (item) => cleanText(item.text, 240),
+      getItemKey: (item) => item.text,
+      create: (item, nowTs) => ({
+        id: cleanText(item.id, 120) || genId(12),
+        text: cleanText(item.text, 240),
+        status: normalizeItemStatus(item.status),
+        createdAt: nowTs,
+        updatedAt: nowTs,
+      }),
+      merge: (item, patchItem, nowTs) => ({
+        ...item,
+        text: cleanText(patchItem.text, 240) || item.text,
+        status: normalizeItemStatus(patchItem.status, item.status),
+        updatedAt: nowTs,
+      }),
+      compact: compactPlanSteps,
+    }),
+    confirmedFacts: upsertItems(current.confirmedFacts, patch.factsUpsert, factUpsertConfig()),
+    artifacts: upsertItems(current.artifacts, patch.artifactsUpsert, artifactUpsertConfig()),
+    decisions: upsertItems(current.decisions, patch.decisionsAppend, decisionUpsertConfig()),
+    blockers: upsertItems(current.blockers, patch.blockersUpsert, blockerUpsertConfig()),
+    openQuestions: upsertItems(current.openQuestions, patch.questionsUpsert, questionUpsertConfig()),
+    hypotheses: upsertItems(current.hypotheses, patch.hypothesesUpsert, hypothesisUpsertConfig()),
+    evidenceRefs: appendEvidenceRefs(current.evidenceRefs, patch.evidenceAppend),
+    updatedAt: now(),
+  }
+
+  next.planSteps = markSuperseded(next.planSteps, patch.supersedeIds)
+  next.confirmedFacts = markSuperseded(next.confirmedFacts, patch.supersedeIds)
+  next.artifacts = markSuperseded(next.artifacts, patch.supersedeIds)
+  next.decisions = markSuperseded(next.decisions, patch.supersedeIds)
+  next.blockers = markSuperseded(next.blockers, patch.supersedeIds)
+  next.openQuestions = markSuperseded(next.openQuestions, patch.supersedeIds)
+  next.hypotheses = markSuperseded(next.hypotheses, patch.supersedeIds)
+
+  const synced = compactWorkingStateObject(syncWorkingStateWithMission(next, options?.mission || null))
+  upsertPersistedWorkingState(sessionId, synced as unknown as Record<string, unknown>)
+  return synced
+}
+
+export function recordWorkingStateEvidence(input: WorkingStateDeterministicUpdateInput): SessionWorkingState {
+  return applyWorkingStatePatch(
+    input.sessionId,
+    deterministicEvidencePatch(input),
+    { mission: input.mission || null },
+  )
+}
+
+export async function synchronizeWorkingStateForTurn(
+  input: SynchronizeWorkingStateForTurnInput,
+  options?: {
+    generateText?: (prompt: string) => Promise<string>
+  },
+): Promise<SessionWorkingState> {
+  const deterministic = recordWorkingStateEvidence(input)
+  if (!shouldExtractStructuredPatch(input)) return deterministic
+  const patch = await extractWorkingStatePatch({
+    ...input,
+    currentState: deterministic,
+  }, options)
+  if (!patch) return deterministic
+  return applyWorkingStatePatch(input.sessionId, patch, { mission: input.mission || null })
+}
+
+export function syncWorkingStateFromMainLoopState(input: {
+  sessionId: string
+  mission?: Mission | null
+  goal?: string | null
+  summary?: string | null
+  status?: WorkingStateStatus | null
+  nextAction?: string | null
+  planSteps?: string[]
+  blockers?: Array<{ summary: string; kind?: WorkingBlocker['kind'] | null }>
+  facts?: string[]
+}): SessionWorkingState {
+  const planSteps = Array.isArray(input.planSteps)
+    ? input.planSteps.map((step, index) => ({
+      text: step,
+      status: index === 0 && input.status !== 'completed' ? 'active' : (input.status === 'completed' ? 'resolved' : 'resolved'),
+    } satisfies WorkingPlanStepPatch))
+    : undefined
+  return applyWorkingStatePatch(input.sessionId, {
+    objective: cleanMultiline(input.goal, 900) || undefined,
+    summary: cleanMultiline(input.summary, 600) || undefined,
+    status: input.status || undefined,
+    nextAction: cleanText(input.nextAction, 240) || undefined,
+    planSteps,
+    blockersUpsert: Array.isArray(input.blockers)
+      ? input.blockers.map((blocker) => ({
+        summary: cleanText(blocker.summary, 280),
+        kind: blocker.kind || undefined,
+        status: (input.status === 'completed' ? 'resolved' : 'active') as WorkingStateItemStatus,
+      })).filter((blocker) => blocker.summary)
+      : undefined,
+    factsUpsert: Array.isArray(input.facts)
+      ? input.facts.map((fact) => ({
+        statement: cleanText(fact, 280),
+        source: 'system' as const,
+        status: (input.status === 'completed' ? 'resolved' : 'active') as WorkingStateItemStatus,
+      })).filter((fact) => fact.statement)
+      : undefined,
+  }, { mission: input.mission || null })
+}
+
+export function buildWorkingStatePromptBlock(
+  sessionId: string,
+  options?: { mission?: Mission | null },
+): string {
+  const state = loadSessionWorkingState(sessionId, options)
+  return buildWorkingStatePromptBlockFromState(state)
+}

package/src/lib/validation/schemas.ts

@@ -189,6 +189,7 @@ export const ChatroomCreateSchema = z.object({
   description: z.string().optional().default(''),
   chatMode: z.enum(['sequential', 'parallel']).optional(),
   autoAddress: z.boolean().optional(),
+  routingGuidance: z.string().nullable().optional(),
   routingRules: z.array(z.object({
     id: z.string(),
     type: z.enum(['keyword', 'capability']),

package/src/lib/ws-client.ts

@@ -1,4 +1,4 @@
-import { jitteredBackoff } from '@/lib/shared-utils'
+import { jitteredBackoff, hmrSingleton } from '@/lib/shared-utils'
 
 type WsCallback = () => void
 
@@ -7,9 +7,9 @@ let wsEnabled = false
 let reconnectTimer: ReturnType<typeof setTimeout> | null = null
 let reconnectAttempt = 0
 const MAX_RECONNECT_DELAY = 30_000
-const listeners = new Map<string, Set<WsCallback>>()
+const listeners = hmrSingleton('wsClient_listeners', () => new Map<string, Set<WsCallback>>())
 let connected = false
-const connectionStateListeners = new Set<() => void>()
+const connectionStateListeners = hmrSingleton('wsClient_connectionStateListeners', () => new Set<() => void>())
 
 function getWsUrl(): string {
   if (typeof window === 'undefined') return 'ws://localhost:3457/ws'

package/src/stores/slices/task-slice.ts

@@ -56,8 +56,5 @@ export const createTaskSlice: StateCreator<AppState, [], [], TaskSlice> = (set,
     }
   },
   showArchivedTasks: false,
-  setShowArchivedTasks: (show) => {
-    set({ showArchivedTasks: show })
-    get().loadTasks(show)
-  }
+  setShowArchivedTasks: (show) => set({ showArchivedTasks: show })
 })