@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/smidja-factory/apps/visualizer/src/lib/api.ts

@@ -0,0 +1,177 @@
+import type {
+  DecisionsResponse,
+  Envelope,
+  EventRow,
+  EventsPage,
+  GateResult,
+  HealthResponse,
+  MemoryHealth,
+  MemoryInspect,
+  MemoryRecall,
+  MemoryTimeline,
+  PromptsResponse,
+  SessionDetail,
+  SessionSummary,
+  StatsResponse,
+} from './types'
+
+async function getJson(url: string): Promise<unknown> {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`GET ${url} → ${res.status}`)
+  return res.json()
+}
+
+export function fetchSessions(): Promise<SessionSummary[]> {
+  return getJson('/api/sessions') as Promise<SessionSummary[]>
+}
+
+export async function fetchSession(adwId: string): Promise<SessionDetail> {
+  const detail = (await getJson(`/api/sessions/${encodeURIComponent(adwId)}`)) as SessionDetail
+  return {
+    session: detail.session,
+    usage: detail.usage ?? { read: 0, written: 0 },
+    phases: detail.phases ?? [],
+    agents: detail.agents ?? [],
+  }
+}
+
+export async function fetchEvents(adwId: string, after: number, limit = 500): Promise<EventsPage> {
+  const page = (await getJson(
+    `/api/sessions/${encodeURIComponent(adwId)}/events?after=${after}&limit=${limit}`,
+  )) as EventsPage | EventRow[]
+  if (Array.isArray(page)) {
+    const cursor = page.reduce((max, e) => Math.max(max, e.rowid), after)
+    return { events: page, cursor, has_more: page.length === limit }
+  }
+  return { events: page.events ?? [], cursor: page.cursor ?? after, has_more: page.has_more ?? false }
+}
+
+/** Archive a run out of the review list (or restore it with archived=false). */
+export async function archiveSession(adwId: string, archived = true): Promise<void> {
+  const url = `/api/sessions/${encodeURIComponent(adwId)}/archive`
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ archived }),
+  })
+  if (!res.ok) throw new Error(`POST ${url} → ${res.status}`)
+}
+
+/** Stop a run — SIGTERM its live processes children-first. */
+export async function stopSession(adwId: string): Promise<{ stopped: number; pids: number[] }> {
+  const url = `/api/sessions/${encodeURIComponent(adwId)}/stop`
+  const res = await fetch(url, { method: 'POST' })
+  if (!res.ok) throw new Error(`POST ${url} → ${res.status}`)
+  return (await res.json()) as { stopped: number; pids: number[] }
+}
+
+/** Pause a run — SIGSTOP the live agent children (hold mid-flight). */
+export async function pauseSession(adwId: string): Promise<{ paused: number; pids: number[] }> {
+  const url = `/api/sessions/${encodeURIComponent(adwId)}/pause`
+  const res = await fetch(url, { method: 'POST' })
+  if (!res.ok) throw new Error(`POST ${url} → ${res.status}`)
+  return (await res.json()) as { paused: number; pids: number[] }
+}
+
+/** Resume a paused run — SIGCONT the agent children. */
+export async function resumeSession(adwId: string): Promise<{ resumed: number; pids: number[] }> {
+  const url = `/api/sessions/${encodeURIComponent(adwId)}/resume`
+  const res = await fetch(url, { method: 'POST' })
+  if (!res.ok) throw new Error(`POST ${url} → ${res.status}`)
+  return (await res.json()) as { resumed: number; pids: number[] }
+}
+
+/** Steer a running run — inject an engineer message into the session. */
+export async function steerSession(adwId: string, message: string): Promise<{ ok: boolean }> {
+  const url = `/api/sessions/${encodeURIComponent(adwId)}/steer`
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ message }),
+  })
+  if (!res.ok) throw new Error(`POST ${url} → ${res.status}`)
+  return (await res.json()) as { ok: boolean }
+}
+
+export function fetchHealth(): Promise<HealthResponse> {
+  return getJson('/api/health') as Promise<HealthResponse>
+}
+
+export function fetchDecisions(): Promise<DecisionsResponse> {
+  return getJson('/api/decisions') as Promise<DecisionsResponse>
+}
+
+export function fetchStats(): Promise<StatsResponse> {
+  return getJson('/api/stats') as Promise<StatsResponse>
+}
+
+// PhaseDetail imports the prompts type from here alongside fetchPrompts.
+export type { PromptsResponse }
+
+export async function fetchPrompts(adwId: string, agent: string): Promise<PromptsResponse> {
+  const res = await fetch(
+    `/api/sessions/${encodeURIComponent(adwId)}/agents/${encodeURIComponent(agent)}/prompts`,
+  )
+  // Not recorded (or endpoint not deployed yet) renders as "no prompts", not an error.
+  if (res.status === 404) return { system: null, user: null }
+  if (!res.ok) throw new Error(`GET prompts → ${res.status}`)
+  const data = (await res.json()) as Partial<PromptsResponse>
+  return { system: data.system ?? null, user: data.user ?? null }
+}
+
+export function fetchEnvelopes(adwId: string): Promise<Envelope[]> {
+  return getJson(`/api/sessions/${encodeURIComponent(adwId)}/envelopes`) as Promise<Envelope[]>
+}
+
+export function fetchGates(adwId: string): Promise<GateResult[]> {
+  return getJson(`/api/sessions/${encodeURIComponent(adwId)}/gates`) as Promise<GateResult[]>
+}
+
+/** The model's thinking/reasoning text for an agent phase (pi streams). */
+export async function fetchThinking(adwId: string, agent: string): Promise<string[]> {
+  try {
+    const res = await fetch(
+      `/api/sessions/${encodeURIComponent(adwId)}/agents/${encodeURIComponent(agent)}/thinking`,
+    )
+    if (!res.ok) return []
+    const data = (await res.json()) as { thinking?: string[] }
+    return data.thinking ?? []
+  } catch {
+    return []
+  }
+}
+
+// ── Kaia's memory (engram) ──────────────────────────────────────────────────
+
+export function fetchMemoryHealth(): Promise<MemoryHealth> {
+  return getJson('/api/memory/health') as Promise<MemoryHealth>
+}
+
+export function fetchMemoryInspect(): Promise<MemoryInspect> {
+  return getJson('/api/memory/inspect') as Promise<MemoryInspect>
+}
+
+export function fetchMemoryRecall(q: string, k = 5, mode = 'hybrid'): Promise<MemoryRecall> {
+  const params = new URLSearchParams({ q, k: String(k), mode })
+  return getJson(`/api/memory/recall?${params}`) as Promise<MemoryRecall>
+}
+
+export function fetchMemoryTimeline(entity: string): Promise<MemoryTimeline> {
+  const params = new URLSearchParams({ entity })
+  return getJson(`/api/memory/timeline?${params}`) as Promise<MemoryTimeline>
+}
+
+export async function observeMemory(
+  content: string,
+  tags: string[],
+  actors: string[],
+  salience = 0.5,
+): Promise<{ id: string }> {
+  const res = await fetch('/api/memory/observe', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ content, tags, actors, salience }),
+  })
+  if (!res.ok) throw new Error(`POST /api/memory/observe → ${res.status}`)
+  return (await res.json()) as { id: string }
+}

package/apps/smidja-factory/apps/visualizer/src/lib/chat-api.ts

@@ -0,0 +1,95 @@
+/**
+ * Client-side API for the orchestrator chat. Typed against the same contract
+ * the server will expose once `/api/chat/*`, `/api/rosters` and `/api/models`
+ * are mounted. Until then the store runs on sample data (`chatStore.demo`).
+ */
+import type {
+  ChatHistoryResponse,
+  ChatMessage,
+  ChatMessageRequest,
+  ChatMessageResponse,
+  ModelsResponse,
+  RosterInfo,
+  RostersResponse,
+  SessionStartRequest,
+  SessionStartResponse,
+  SessionSummary,
+} from './types'
+
+async function postJson<T>(url: string, body: unknown): Promise<T> {
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new Error(`POST ${url} → ${res.status} ${text}`)
+  }
+  return (await res.json()) as T
+}
+
+async function getJson<T>(url: string): Promise<T> {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`GET ${url} → ${res.status}`)
+  return (await res.json()) as T
+}
+
+export function fetchChatHistory(sessionId: string): Promise<ChatHistoryResponse> {
+  return getJson(`/api/chat/history?session=${encodeURIComponent(sessionId)}`)
+}
+
+/** All persisted chat sessions (multi-session switcher). */
+export function fetchChatSessions(): Promise<{ id: string; messages: number; updated_at: string | null }[]> {
+  return getJson('/api/chat/sessions')
+}
+
+/** Permanently delete a persisted chat conversation. */
+export async function deleteChatSession(sessionId: string): Promise<void> {
+  const res = await fetch(`/api/chat/session?session=${encodeURIComponent(sessionId)}`, {
+    method: 'DELETE',
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new Error(`DELETE /api/chat/session → ${res.status} ${text}`)
+  }
+}
+
+export function sendChatMessage(req: ChatMessageRequest): Promise<ChatMessageResponse> {
+  return postJson('/api/chat/message', req)
+}
+
+export function fetchRosters(): Promise<RostersResponse> {
+  return getJson('/api/rosters')
+}
+
+/** Trace-db sessions. scope 'all' includes archived + plumbing one-shots. */
+export function fetchSessionSummaries(scope: 'active' | 'all' = 'all'): Promise<SessionSummary[]> {
+  return getJson(`/api/sessions?scope=${scope}`)
+}
+
+/** Stop / pause (SIGSTOP) / resume (SIGCONT) a live run via the trace-ui server. */
+export function controlChatSession(
+  adwId: string,
+  action: 'stop' | 'pause' | 'resume',
+): Promise<Record<string, unknown>> {
+  return postJson(`/api/sessions/${encodeURIComponent(adwId)}/${action}`, {})
+}
+
+export function fetchRoster(name: string): Promise<RosterInfo> {
+  return getJson(`/api/rosters/${encodeURIComponent(name)}`)
+}
+
+export function fetchModels(): Promise<ModelsResponse> {
+  return getJson('/api/models')
+}
+
+export function startSmidjaSession(req: SessionStartRequest): Promise<SessionStartResponse> {
+  return postJson('/api/chat/session', req)
+}
+
+export function steerChatSession(body: { adwId: string; message: string }): Promise<{ ok: boolean }> {
+  return postJson('/api/chat/steer', body)
+}
+
+export type { ChatMessage }

package/apps/smidja-factory/apps/visualizer/src/lib/chat-store.ts

@@ -0,0 +1,351 @@
+/**
+ * Orchestrator chat state — a small reactive store (no Pinia), mirroring the
+ * way the rest of the visualizer keeps state in component-local refs.
+ *
+ * All data comes from the real backend endpoints:
+ *   GET  /api/rosters  /api/models   → picker (teams + orchestrator models)
+ *   GET  /api/chat/history          → conversation for the active session
+ *   POST /api/chat/message          → send to Kaia (Pi)
+ *   POST /api/chat/session          → launch a smidja run
+ *   POST /api/chat/steer            → inject guidance mid-run
+ */
+import { reactive, ref } from 'vue'
+import type { ChatMessage, ModelInfo, RosterInfo, SessionLaunch, SessionStartRequest } from './types'
+import {
+  controlChatSession,
+  deleteChatSession,
+  fetchChatHistory,
+  fetchChatSessions,
+  fetchModels,
+  fetchRosters,
+  fetchSessionSummaries,
+  sendChatMessage,
+  startSmidjaSession,
+  steerChatSession,
+} from './chat-api'
+import { fetchEvents, fetchSession } from './api'
+import type { SessionDetail } from './types'
+
+export const messages = ref<ChatMessage[]>([])
+export const rosters = ref<RosterInfo[]>([])
+export const models = ref<ModelInfo[]>([])
+
+/** Models the chat pi process can actually resolve (pi --list-models catalog). */
+export const chatModels = ref<{ id: string; name: string; provider: string }[]>([])
+
+/** The model the chat talks to Kaia on; '' = server default (orchestrator cloud model). */
+export const chatModel = ref('')
+export const pending = ref(false)
+export const error = ref<string | null>(null)
+export const loaded = ref(false)
+
+/** The active chat session id (persisted conversation on the server). */
+export const sessionId = ref('default')
+
+/** All persisted chat sessions, newest first (multi-session switcher). */
+export const chatSessions = ref<{ id: string; messages: number; updated_at: string | null }[]>([])
+
+/** The session the start-form / side panel is pointed at. */
+export const activeSession = ref<SessionLaunch | null>(null)
+
+/** All past runs from the trace db (scope=all), newest first — the "Past
+ * sessions" list in the chat sidebar. Never filtered by admission/archive. */
+export const pastSessions = ref<SessionLaunch[]>([])
+
+export interface SidePanelState {
+  panel: 'idle' | 'running' | 'completed'
+  adwId: string | null
+}
+
+export const side = reactive<SidePanelState>({ panel: 'idle', adwId: null })
+
+/** Real live stats for the active session, polled from the trace db. These
+ * replace the old hardcoded ladder/cost/tokens in the sidebar's running panel
+ * (mock-data cleanup left them canned). `null` until the first poll lands. */
+export const liveStats = ref<{
+  cost: number | null
+  tokens: number | null
+  toolCalls: number | null
+  steps: { name: string; status: string }[]
+} | null>(null)
+
+/** Poll the trace db for the active session's real cost/tokens/phases. */
+export async function refreshLiveStats(): Promise<void> {
+  const adwId = activeSession.value?.smidja_id
+  if (!adwId) return
+  try {
+    const detail = (await fetchSession(adwId)) as unknown as SessionDetail
+    const s = detail.session
+    const phases = detail.phases ?? []
+    // Real tool-call count from the trace events (paginated; cap at 2 pages).
+    let toolCalls = 0
+    try {
+      let after = 0
+      for (let i = 0; i < 2; i++) {
+        const page = await fetchEvents(adwId, after)
+        toolCalls += page.events.filter((e) => e.type === 'tool_call').length
+        if (!page.has_more) break
+        after = page.cursor
+      }
+    } catch {
+      /* best-effort — the detail fields still render */
+    }
+    const steps = (phases ?? []).map((p) => ({
+      name: p.name ?? p.phase_id,
+      status: p.status ?? 'queued',
+    }))
+    liveStats.value = {
+      cost: s.total_cost ?? null,
+      tokens: s.total_tokens ?? null,
+      toolCalls,
+      steps,
+    }
+  } catch (e) {
+    liveStats.value = null
+    error.value = (e as Error).message
+  }
+}
+
+/** Load rosters + models for the picker. Called once on chat view mount. */
+export async function init(): Promise<void> {
+  error.value = null
+  try {
+    const [r, m, cm] = await Promise.all([
+      fetchRosters(),
+      fetchModels(),
+      fetch('/api/chat/models').then((res) => res.json()),
+    ])
+    rosters.value = r
+    models.value = m
+    chatModels.value = cm as { id: string; name: string; provider: string }[]
+    // Default Kaia to a WORKING local model when one is resolvable: prefer the
+    // llamacpp Q2 (native, 130K) over a stale/cloud entry, so the first message
+    // doesn't 500 with "Connection error" on an unloaded backend. Only applies
+    // when the user hasn't already picked a model this session.
+    if (!chatModel.value) {
+      const q2 = (cm as { id: string; name: string; provider: string }[]).find(
+        (m) => m.id === 'llamacpp/qwen3.6-35b-a3b@q2_k_xl',
+      )
+      if (q2) chatModel.value = q2.id
+    }
+    loaded.value = true
+  } catch (e) {
+    error.value = (e as Error).message
+  }
+}
+
+/** Load the persisted conversation for the active session. */
+export async function loadHistory(): Promise<void> {
+  error.value = null
+  try {
+    messages.value = await fetchChatHistory(sessionId.value)
+  } catch (e) {
+    error.value = (e as Error).message
+  }
+}
+
+/** Refresh the session switcher list. */
+export async function loadChatSessions(): Promise<void> {
+  try {
+    chatSessions.value = await fetchChatSessions()
+  } catch {
+    /* best-effort — the switcher can stay empty */
+  }
+}
+
+/** Switch to another persisted chat conversation. */
+export async function switchChat(id: string): Promise<void> {
+  if (id === sessionId.value) return
+  sessionId.value = id
+  activeSession.value = null
+  side.panel = 'idle'
+  side.adwId = null
+  await loadHistory()
+  await loadChatSessions()
+}
+
+/** Start a brand-new chat conversation with a fresh id. */
+export async function newChat(): Promise<void> {
+  const id = `chat-${Date.now().toString(36)}`
+  sessionId.value = id
+  messages.value = []
+  activeSession.value = null
+  side.panel = 'idle'
+  side.adwId = null
+  await loadChatSessions()
+}
+
+/** Permanently delete a chat conversation; switch to a fresh one. */
+export async function deleteChat(id: string): Promise<void> {
+  try {
+    await deleteChatSession(id)
+  } catch (e) {
+    error.value = (e as Error).message
+    return
+  }
+  if (id === sessionId.value) {
+    await newChat()
+  } else {
+    await loadChatSessions()
+  }
+}
+
+/** Send one chat message; await Kaia's reply and append both to the thread. */
+export async function sendMessage(content: string): Promise<void> {
+  const trimmed = content.trim()
+  if (!trimmed || pending.value) return
+  error.value = null
+
+  messages.value.push({
+    id: `u-${Date.now()}`,
+    ts: new Date().toISOString(),
+    role: 'user',
+    content: trimmed,
+  })
+
+  pending.value = true
+  const replyId = `k-${Date.now()}`
+  messages.value.push({
+    id: replyId,
+    ts: new Date().toISOString(),
+    role: 'kaia',
+    content: '',
+    streaming: true,
+  })
+
+  try {
+    const res = await sendChatMessage({
+      sessionId: sessionId.value,
+      content: trimmed,
+      model: chatModel.value.trim() || undefined,
+    })
+    const streamed = messages.value.find((m) => m.id === replyId)
+    if (streamed) {
+      streamed.streaming = false
+      streamed.content = res.message.content
+      streamed.tool_calls = res.message.tool_calls
+      streamed.model = res.message.model
+    }
+  } catch (e) {
+    error.value = (e as Error).message
+    const streamed = messages.value.find((m) => m.id === replyId)
+    if (streamed) {
+      streamed.streaming = false
+      streamed.role = 'error'
+      streamed.content = `Kaia is offline — ${(e as Error).message}`
+    }
+  } finally {
+    pending.value = false
+  }
+}
+
+/** Launch a smidja session from the start form. */
+export async function launchSession(req: SessionStartRequest): Promise<SessionLaunch> {
+  error.value = null
+  const res = await startSmidjaSession(req)
+  const launch: SessionLaunch = {
+    smidja_id: res.smidja_id,
+    team: res.roster,
+    model: res.model,
+    status: 'running',
+  }
+  messages.value.push({
+    id: `l-${Date.now()}`,
+    ts: new Date().toISOString(),
+    role: 'kaia',
+    content: `Launching **${res.roster}** against the task.`,
+    session_launch: launch,
+    model: res.model,
+  })
+  activeSession.value = launch
+  side.panel = 'running'
+  side.adwId = launch.smidja_id
+  return launch
+}
+
+/** Load every run (scope=all) into pastSessions, newest first, mapped to
+ * SessionLaunch for the sidebar's SessionMiniCards. */
+export async function loadPastSessions(): Promise<void> {
+  error.value = null
+  try {
+    const all = await fetchSessionSummaries('all')
+    const activeId = activeSession.value?.smidja_id
+    pastSessions.value = all
+      .filter((s) => s.smidja_id !== activeId)
+      .map((s) => ({
+        smidja_id: s.smidja_id,
+        team: s.smidja_name ?? 'smidja',
+        model: s.model ?? '',
+        status: s.status,
+      }))
+  } catch (e) {
+    error.value = (e as Error).message
+  }
+}
+
+/** Stop / pause / resume the active live session via the trace-ui server. */
+export async function controlActive(action: 'stop' | 'pause' | 'resume'): Promise<void> {
+  const adwId = activeSession.value?.smidja_id
+  if (!adwId) return
+  error.value = null
+  try {
+    await controlChatSession(adwId, action)
+    if (action === 'stop') {
+      if (activeSession.value) activeSession.value.status = 'fail'
+      side.panel = 'completed'
+      side.adwId = adwId
+    }
+    await loadPastSessions()
+  } catch (e) {
+    error.value = (e as Error).message
+  }
+}
+
+/** Auto-attach a detached/terminal-launched running session to the chat: when
+ * the trace db shows a live run we did not start from this chat, surface it as
+ * a launch card + point the sidebar at it. Covers "terminal-launched runs were
+ * invisible in Orchestrator Chat". */
+export async function syncAutoAttach(): Promise<void> {
+  error.value = null
+  try {
+    const all = await fetchSessionSummaries('all')
+    const live = all.find((s) => s.status === 'running' && s.smidja_id !== activeSession.value?.smidja_id)
+    await loadPastSessions()
+    if (!live) return
+    const launch: SessionLaunch = {
+      smidja_id: live.smidja_id,
+      team: live.smidja_name ?? 'smidja',
+      model: live.model ?? '',
+      status: 'running',
+    }
+    if (!messages.value.some((m) => m.session_launch?.smidja_id === live.smidja_id)) {
+      messages.value.push({
+        id: `auto-${Date.now()}`,
+        ts: new Date().toISOString(),
+        role: 'kaia',
+        content: `Detected a running session **${live.smidja_id}** on the trace db.`,
+        session_launch: launch,
+        model: live.model ?? '',
+      })
+    }
+    if (!activeSession.value) {
+      activeSession.value = launch
+      side.panel = 'running'
+      side.adwId = live.smidja_id
+    }
+  } catch (e) {
+    error.value = (e as Error).message
+  }
+}
+
+/** Inject guidance into the active running session. */
+export async function steerActive(message: string): Promise<void> {
+  const adwId = activeSession.value?.smidja_id
+  if (!adwId || !message.trim()) return
+  error.value = null
+  try {
+    await steerChatSession({ adwId, message })
+  } catch (e) {
+    error.value = (e as Error).message
+  }
+}