@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/types/working-state.ts

@@ -0,0 +1,204 @@
+
+export type WorkingStateStatus = 'idle' | 'progress' | 'blocked' | 'waiting' | 'completed'
+export type WorkingStateItemStatus = 'active' | 'resolved' | 'superseded'
+
+export interface EvidenceRef {
+  id: string
+  type: 'tool' | 'message' | 'task' | 'artifact' | 'error' | 'approval'
+  summary: string
+  value?: string | null
+  toolName?: string | null
+  toolCallId?: string | null
+  runId?: string | null
+  sessionId?: string | null
+  taskId?: string | null
+  createdAt: number
+}
+
+export interface WorkingPlanStep {
+  id: string
+  text: string
+  status: WorkingStateItemStatus
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingFact {
+  id: string
+  statement: string
+  source: 'user' | 'tool' | 'assistant' | 'system'
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingArtifact {
+  id: string
+  label: string
+  kind: 'file' | 'url' | 'approval' | 'message' | 'other'
+  path?: string | null
+  url?: string | null
+  sourceTool?: string | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingDecision {
+  id: string
+  summary: string
+  rationale?: string | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingBlocker {
+  id: string
+  summary: string
+  kind?: 'approval' | 'credential' | 'human_input' | 'external_dependency' | 'error' | 'other' | null
+  nextAction?: string | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingQuestion {
+  id: string
+  question: string
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingHypothesis {
+  id: string
+  statement: string
+  confidence?: 'low' | 'medium' | 'high' | null
+  status: WorkingStateItemStatus
+  evidenceIds?: string[]
+  createdAt: number
+  updatedAt: number
+}
+
+export interface WorkingPlanStepPatch {
+  id?: string | null
+  text: string
+  status?: WorkingStateItemStatus | null
+}
+
+export interface WorkingFactPatch {
+  id?: string | null
+  statement: string
+  source?: WorkingFact['source'] | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingArtifactPatch {
+  id?: string | null
+  label: string
+  kind?: WorkingArtifact['kind'] | null
+  path?: string | null
+  url?: string | null
+  sourceTool?: string | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingDecisionPatch {
+  id?: string | null
+  summary: string
+  rationale?: string | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingBlockerPatch {
+  id?: string | null
+  summary: string
+  kind?: WorkingBlocker['kind']
+  nextAction?: string | null
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingQuestionPatch {
+  id?: string | null
+  question: string
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingHypothesisPatch {
+  id?: string | null
+  statement: string
+  confidence?: WorkingHypothesis['confidence']
+  status?: WorkingStateItemStatus | null
+  evidenceIds?: string[]
+}
+
+export interface WorkingStatePatch {
+  objective?: string | null
+  summary?: string | null
+  constraints?: string[]
+  successCriteria?: string[]
+  status?: WorkingStateStatus | null
+  nextAction?: string | null
+  planSteps?: WorkingPlanStepPatch[]
+  factsUpsert?: WorkingFactPatch[]
+  artifactsUpsert?: WorkingArtifactPatch[]
+  decisionsAppend?: WorkingDecisionPatch[]
+  blockersUpsert?: WorkingBlockerPatch[]
+  questionsUpsert?: WorkingQuestionPatch[]
+  hypothesesUpsert?: WorkingHypothesisPatch[]
+  evidenceAppend?: EvidenceRef[]
+  supersedeIds?: string[]
+}
+
+export interface SessionWorkingState {
+  sessionId: string
+  objective?: string | null
+  summary?: string | null
+  constraints: string[]
+  successCriteria: string[]
+  status: WorkingStateStatus
+  nextAction?: string | null
+  planSteps: WorkingPlanStep[]
+  confirmedFacts: WorkingFact[]
+  artifacts: WorkingArtifact[]
+  decisions: WorkingDecision[]
+  blockers: WorkingBlocker[]
+  openQuestions: WorkingQuestion[]
+  hypotheses: WorkingHypothesis[]
+  evidenceRefs: EvidenceRef[]
+  createdAt: number
+  updatedAt: number
+  lastCompactedAt?: number | null
+}
+
+export interface ExecutionBriefPlanStep {
+  text: string
+  status: WorkingStateItemStatus
+}
+
+export interface ExecutionBrief {
+  sessionId?: string | null
+  objective: string | null
+  summary: string | null
+  status: WorkingStateStatus
+  nextAction: string | null
+  plan: ExecutionBriefPlanStep[]
+  blockers: string[]
+  facts: string[]
+  artifacts: string[]
+  constraints: string[]
+  successCriteria: string[]
+  evidenceRefs: EvidenceRef[]
+  parentContext: string | null
+}

package/src/views/settings/section-heartbeat.tsx

@@ -35,8 +35,8 @@ export function HeartbeatSection({ appSettings, patchSettings, inputClass }: Set
       setHeartbeatBulkNotice(
         `Stopped heartbeat on ${result.updatedSessions} session(s); cancelled ${result.cancelledQueued} queued run(s), aborted ${result.abortedRunning} running run(s).`,
       )
-    } catch (err: any) {
-      setHeartbeatBulkNotice(err?.message || 'Failed to disable heartbeat for all agents.')
+    } catch (err: unknown) {
+      setHeartbeatBulkNotice(err instanceof Error ? err.message : 'Failed to disable heartbeat for all agents.')
     } finally {
       setDisablingHeartbeats(false)
     }

package/src/views/settings/section-runtime-loop.tsx

@@ -55,20 +55,6 @@ export function RuntimeLoopSection({ appSettings, patchSettings, inputClass }: S
           </div>
         </div>
 
-        <label className="block font-display text-[11px] font-600 text-text-3 uppercase tracking-[0.08em] mb-3">Mission Human Loop</label>
-        <div className="flex items-center gap-3 mb-6">
-          <button
-            onClick={() => patchSettings({ missionHumanLoopEnabled: !(appSettings.missionHumanLoopEnabled ?? false) })}
-            className={`relative w-10 h-[22px] rounded-full transition-colors duration-200 cursor-pointer ${(appSettings.missionHumanLoopEnabled ?? false) ? 'bg-accent' : 'bg-white/[0.12]'}`}
-          >
-            <span className={`absolute top-[3px] left-[3px] w-4 h-4 rounded-full bg-white transition-transform duration-200 ${(appSettings.missionHumanLoopEnabled ?? false) ? 'translate-x-[18px]' : ''}`} />
-          </button>
-          <div>
-            <div className="text-[12px] text-text-2">Allow missions to stay open waiting for a human follow-up</div>
-            <div className="text-[11px] text-text-3/60 mt-1">Off by default for new users. When disabled, generic mission handoffs like “waiting for your next instruction” are closed instead of lingering as open waiting missions. Explicit tool approvals and real external blockers still apply.</div>
-          </div>
-        </div>
-
         <label className="flex items-center gap-1.5 font-display text-[11px] font-600 text-text-3 uppercase tracking-[0.08em] mb-3">Loop Mode <HintTip text="Bounded = fixed max steps. Ongoing = runs until the task completes (with a safety cap)" /></label>
         <div className="grid grid-cols-2 gap-2 mb-5">
           {([

package/src/app/api/canvas/[sessionId]/route.ts

@@ -1,35 +0,0 @@
-import { NextResponse } from 'next/server'
-import { loadSessions, saveSessions } from '@/lib/server/storage'
-import { notify } from '@/lib/server/ws-hub'
-import { normalizeCanvasContent } from '@/lib/canvas-content'
-import { safeParseBody } from '@/lib/server/safe-parse-body'
-
-export async function GET(_req: Request, { params }: { params: Promise<{ sessionId: string }> }) {
-  const { sessionId } = await params
-  const sessions = loadSessions()
-  const session = sessions[sessionId]
-  if (!session) return NextResponse.json({ error: 'Session not found' }, { status: 404 })
-
-  return NextResponse.json({
-    sessionId,
-    content: (session as unknown as Record<string, unknown>).canvasContent || null,
-  })
-}
-
-export async function POST(req: Request, { params }: { params: Promise<{ sessionId: string }> }) {
-  const { sessionId } = await params
-  const { data: body, error } = await safeParseBody(req)
-  if (error) return error
-  const sessions = loadSessions()
-  const session = sessions[sessionId]
-  if (!session) return NextResponse.json({ error: 'Session not found' }, { status: 404 })
-
-  const nextContent = normalizeCanvasContent(body.document ?? body.content)
-  ;(session as unknown as Record<string, unknown>).canvasContent = nextContent
-  session.lastActiveAt = Date.now()
-  sessions[sessionId] = session
-  saveSessions(sessions)
-
-  notify(`canvas:${sessionId}`)
-  return NextResponse.json({ ok: true, sessionId })
-}

package/src/app/api/missions/[id]/actions/route.ts

@@ -1,31 +0,0 @@
-import { NextResponse } from 'next/server'
-import { notFound } from '@/lib/server/collection-helpers'
-import { loadMissionById, performMissionAction } from '@/lib/server/missions/mission-service'
-
-export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const mission = loadMissionById(id)
-  if (!mission) return notFound()
-
-  const body = await req.json().catch(() => ({}))
-  const action = body?.action
-  if (action !== 'resume' && action !== 'replan' && action !== 'cancel' && action !== 'retry_verification' && action !== 'wait') {
-    return NextResponse.json({ error: 'Invalid mission action.' }, { status: 400 })
-  }
-
-  const result = performMissionAction({
-    missionId: id,
-    action,
-    reason: typeof body.reason === 'string' ? body.reason : null,
-    waitKind: typeof body.waitKind === 'string' ? body.waitKind : undefined,
-    untilAt: typeof body.untilAt === 'number' ? body.untilAt : null,
-  })
-  if (!result) {
-    return NextResponse.json({ error: 'Unable to update mission.' }, { status: 409 })
-  }
-  return NextResponse.json({
-    ok: true,
-    mission: result.mission,
-    appendedEvent: result.event,
-  })
-}

package/src/app/api/missions/[id]/events/route.ts

@@ -1,14 +0,0 @@
-import { NextResponse } from 'next/server'
-import { notFound } from '@/lib/server/collection-helpers'
-import { listMissionEventsForMission, loadMissionById } from '@/lib/server/missions/mission-service'
-
-export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const mission = loadMissionById(id)
-  if (!mission) return notFound()
-
-  const { searchParams } = new URL(req.url)
-  const limitParam = searchParams.get('limit')
-  const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined
-  return NextResponse.json(listMissionEventsForMission(id, Number.isFinite(limit) ? limit : undefined))
-}

package/src/app/api/missions/[id]/route.ts

@@ -1,10 +0,0 @@
-import { NextResponse } from 'next/server'
-import { notFound } from '@/lib/server/collection-helpers'
-import { getMissionDetail } from '@/lib/server/missions/mission-service'
-
-export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params
-  const mission = getMissionDetail(id)
-  if (!mission) return notFound()
-  return NextResponse.json(mission)
-}

package/src/app/api/missions/route.test.ts

@@ -1,244 +0,0 @@
-import assert from 'node:assert/strict'
-import test from 'node:test'
-
-import { runWithTempDataDir } from '@/lib/server/test-utils/run-with-temp-data-dir'
-
-test('missions routes list, detail, and events expose durable mission state', () => {
-  const output = runWithTempDataDir<{
-    listCount: number
-    firstMissionId: string | null
-    detailMissionId: string | null
-    linkedTaskId: string | null
-    parentMissionId: string | null
-    eventsCount: number
-    latestEventType: string | null
-  }>(`
-    const storageMod = await import('./src/lib/server/storage')
-    const listRouteMod = await import('./src/app/api/missions/route')
-    const detailRouteMod = await import('./src/app/api/missions/[id]/route')
-    const eventsRouteMod = await import('./src/app/api/missions/[id]/events/route')
-    const storage = storageMod.default || storageMod
-    const listRoute = listRouteMod.default || listRouteMod
-    const detailRoute = detailRouteMod.default || detailRouteMod
-    const eventsRoute = eventsRouteMod.default || eventsRouteMod
-
-    storage.saveAgents({
-      agentA: {
-        id: 'agentA',
-        name: 'Agent A',
-        provider: 'ollama',
-        model: 'test-model',
-        systemPrompt: 'test',
-      },
-    })
-
-    storage.saveTasks({
-      taskA: {
-        id: 'taskA',
-        title: 'Prepare release summary',
-        description: 'Create the release summary.',
-        status: 'backlog',
-        agentId: 'agentA',
-        createdAt: 1,
-        updatedAt: 1,
-        missionId: 'missionA',
-      },
-    })
-
-    storage.saveMissions({
-      missionParent: {
-        id: 'missionParent',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Parent mission',
-        status: 'active',
-        phase: 'planning',
-        sessionId: 'sessionA',
-        agentId: 'agentA',
-        taskIds: [],
-        childMissionIds: ['missionA'],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        createdAt: 1,
-        updatedAt: 1,
-      },
-      missionA: {
-        id: 'missionA',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Prepare the release handoff',
-        status: 'waiting',
-        phase: 'waiting',
-        sessionId: 'sessionA',
-        agentId: 'agentA',
-        parentMissionId: 'missionParent',
-        rootMissionId: 'missionParent',
-        taskIds: ['taskA'],
-        childMissionIds: [],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        waitState: { kind: 'approval', reason: 'Waiting for release approval.' },
-        plannerSummary: 'Track the release handoff.',
-        currentStep: 'Wait for approval',
-        createdAt: 2,
-        updatedAt: 3,
-      },
-      missionB: {
-        id: 'missionB',
-        source: 'manual',
-        sourceRef: { kind: 'manual' },
-        objective: 'Unrelated completed mission',
-        status: 'completed',
-        phase: 'completed',
-        sessionId: 'sessionB',
-        agentId: 'agentA',
-        taskIds: [],
-        childMissionIds: [],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        createdAt: 1,
-        updatedAt: 1,
-      },
-    })
-
-    storage.saveMissionEvents({
-      eventCreated: {
-        id: 'eventCreated',
-        missionId: 'missionA',
-        type: 'created',
-        source: 'chat',
-        summary: 'Mission created.',
-        sessionId: 'sessionA',
-        createdAt: 2,
-      },
-      eventWaiting: {
-        id: 'eventWaiting',
-        missionId: 'missionA',
-        type: 'waiting',
-        source: 'system',
-        summary: 'Waiting for release approval.',
-        sessionId: 'sessionA',
-        createdAt: 3,
-      },
-    })
-
-    const listResponse = await listRoute.GET(new Request('http://local/api/missions?status=waiting&sessionId=sessionA&limit=1'))
-    const listPayload = await listResponse.json()
-
-    const detailResponse = await detailRoute.GET(
-      new Request('http://local/api/missions/missionA'),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const detailPayload = await detailResponse.json()
-
-    const eventsResponse = await eventsRoute.GET(
-      new Request('http://local/api/missions/missionA/events?limit=1'),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const eventsPayload = await eventsResponse.json()
-
-    console.log(JSON.stringify({
-      listCount: Array.isArray(listPayload) ? listPayload.length : -1,
-      firstMissionId: Array.isArray(listPayload) ? listPayload[0]?.id || null : null,
-      detailMissionId: detailPayload?.mission?.id || null,
-      linkedTaskId: Array.isArray(detailPayload?.linkedTasks) ? detailPayload.linkedTasks[0]?.id || null : null,
-      parentMissionId: detailPayload?.parent?.id || null,
-      eventsCount: Array.isArray(eventsPayload) ? eventsPayload.length : -1,
-      latestEventType: Array.isArray(eventsPayload) ? eventsPayload[0]?.type || null : null,
-    }))
-  `, { prefix: 'swarmclaw-missions-route-' })
-
-  assert.equal(output.listCount, 1)
-  assert.equal(output.firstMissionId, 'missionA')
-  assert.equal(output.detailMissionId, 'missionA')
-  assert.equal(output.linkedTaskId, 'taskA')
-  assert.equal(output.parentMissionId, 'missionParent')
-  assert.equal(output.eventsCount, 1)
-  assert.equal(output.latestEventType, 'waiting')
-})
-
-test('mission actions route validates input and persists operator wait actions', () => {
-  const output = runWithTempDataDir<{
-    invalidStatus: number
-    invalidError: string | null
-    waitStatus: number
-    waitOk: boolean
-    missionStatus: string | null
-    missionPhase: string | null
-    waitKind: string | null
-    waitReason: string | null
-    eventType: string | null
-    eventAction: string | null
-  }>(`
-    const storageMod = await import('./src/lib/server/storage')
-    const actionsRouteMod = await import('./src/app/api/missions/[id]/actions/route')
-    const storage = storageMod.default || storageMod
-    const actionsRoute = actionsRouteMod.default || actionsRouteMod
-
-    storage.saveMissions({
-      missionA: {
-        id: 'missionA',
-        source: 'chat',
-        sourceRef: { kind: 'chat', sessionId: 'sessionA' },
-        objective: 'Prepare the release handoff',
-        status: 'active',
-        phase: 'planning',
-        sessionId: 'sessionA',
-        taskIds: [],
-        childMissionIds: [],
-        dependencyMissionIds: [],
-        dependencyTaskIds: [],
-        createdAt: 1,
-        updatedAt: 1,
-      },
-    })
-
-    const invalidResponse = await actionsRoute.POST(
-      new Request('http://local/api/missions/missionA/actions', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ action: 'ship_it' }),
-      }),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const invalidPayload = await invalidResponse.json()
-
-    const waitResponse = await actionsRoute.POST(
-      new Request('http://local/api/missions/missionA/actions', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({
-          action: 'wait',
-          reason: 'Waiting for operator confirmation.',
-          waitKind: 'approval',
-        }),
-      }),
-      { params: Promise.resolve({ id: 'missionA' }) },
-    )
-    const waitPayload = await waitResponse.json()
-
-    console.log(JSON.stringify({
-      invalidStatus: invalidResponse.status,
-      invalidError: invalidPayload?.error || null,
-      waitStatus: waitResponse.status,
-      waitOk: waitPayload?.ok === true,
-      missionStatus: waitPayload?.mission?.status || null,
-      missionPhase: waitPayload?.mission?.phase || null,
-      waitKind: waitPayload?.mission?.waitState?.kind || null,
-      waitReason: waitPayload?.mission?.waitState?.reason || null,
-      eventType: waitPayload?.appendedEvent?.type || null,
-      eventAction: waitPayload?.appendedEvent?.data?.action || null,
-    }))
-  `, { prefix: 'swarmclaw-missions-route-' })
-
-  assert.equal(output.invalidStatus, 400)
-  assert.match(String(output.invalidError || ''), /invalid mission action/i)
-  assert.equal(output.waitStatus, 200)
-  assert.equal(output.waitOk, true)
-  assert.equal(output.missionStatus, 'waiting')
-  assert.equal(output.missionPhase, 'waiting')
-  assert.equal(output.waitKind, 'approval')
-  assert.equal(output.waitReason, 'Waiting for operator confirmation.')
-  assert.equal(output.eventType, 'operator_action')
-  assert.equal(output.eventAction, 'wait')
-})

package/src/app/api/missions/route.ts

@@ -1,57 +0,0 @@
-import { NextResponse } from 'next/server'
-import type { MissionPhase, MissionSource, MissionStatus } from '@/types'
-import { listMissions } from '@/lib/server/missions/mission-service'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET(req: Request) {
-  const { searchParams } = new URL(req.url)
-  const sessionId = searchParams.get('sessionId')
-  const agentId = searchParams.get('agentId')
-  const projectId = searchParams.get('projectId')
-  const parentMissionId = searchParams.get('parentMissionId')
-  const limitParam = searchParams.get('limit')
-  const rawStatus = searchParams.get('status')
-  const rawPhase = searchParams.get('phase')
-  const rawSource = searchParams.get('source')
-  const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined
-  const status = rawStatus === 'non_terminal'
-    || rawStatus === 'active'
-    || rawStatus === 'waiting'
-    || rawStatus === 'completed'
-    || rawStatus === 'failed'
-    || rawStatus === 'cancelled'
-    ? rawStatus as MissionStatus | 'non_terminal'
-    : undefined
-  const phase = rawPhase === 'intake'
-    || rawPhase === 'planning'
-    || rawPhase === 'dispatching'
-    || rawPhase === 'executing'
-    || rawPhase === 'verifying'
-    || rawPhase === 'waiting'
-    || rawPhase === 'completed'
-    || rawPhase === 'failed'
-    ? rawPhase as MissionPhase
-    : undefined
-  const source = rawSource === 'chat'
-    || rawSource === 'connector'
-    || rawSource === 'heartbeat'
-    || rawSource === 'main-loop-followup'
-    || rawSource === 'task'
-    || rawSource === 'schedule'
-    || rawSource === 'delegation'
-    || rawSource === 'manual'
-    ? rawSource as MissionSource
-    : undefined
-
-  return NextResponse.json(listMissions({
-    ...(sessionId ? { sessionId } : {}),
-    ...(agentId ? { agentId } : {}),
-    ...(projectId ? { projectId } : {}),
-    ...(parentMissionId ? { parentMissionId } : {}),
-    ...(status ? { status } : {}),
-    ...(phase ? { phase } : {}),
-    ...(source ? { source } : {}),
-    ...(Number.isFinite(limit) ? { limit } : {}),
-  }))
-}