@aiwg/cockpit 2026.7.7 → 2026.7.9

package/web/src/components/Memory.tsx

@@ -0,0 +1,145 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { api } from '../api';
+import { fmtId } from '../util';
+import type { MissionProjection, MissionsResponse } from '../types';
+
+interface MemoryNote {
+  id: string;
+  title: string;
+  body: string;
+  tags: string[];
+  created_at: string;
+  mission_id?: string;
+  source: 'operator' | 'mission';
+}
+
+const STORAGE_KEY = 'aiwg.cockpit.memory.notes.v1';
+
+export function Memory({ refreshTick = 0 }: { refreshTick?: number }) {
+  const [notes, setNotes] = useState<MemoryNote[]>(() => readNotes());
+  const [missions, setMissions] = useState<MissionProjection[]>([]);
+  const [query, setQuery] = useState('');
+  const [title, setTitle] = useState('');
+  const [body, setBody] = useState('');
+  const [tags, setTags] = useState('');
+  const [err, setErr] = useState('');
+
+  const persist = useCallback((next: MemoryNote[]) => {
+    setNotes(next);
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  }, []);
+
+  useEffect(() => {
+    api<MissionsResponse>('/api/missions').then((data) => {
+      setMissions(data.missions);
+      setErr('');
+      const next = mergeMissionNotes(notes, data.missions);
+      if (next !== notes) persist(next);
+    }).catch((e) => setErr((e as Error).message));
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [refreshTick]);
+
+  const filtered = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return notes;
+    return notes.filter((note) => [
+      note.title,
+      note.body,
+      note.source,
+      note.mission_id ?? '',
+      ...note.tags,
+    ].some((v) => v.toLowerCase().includes(q)));
+  }, [notes, query]);
+
+  const add = () => {
+    if (!title.trim()) return;
+    persist([{
+      id: `note-${Date.now()}`,
+      title: title.trim(),
+      body: body.trim(),
+      tags: tags.split(',').map((t) => t.trim()).filter(Boolean),
+      created_at: new Date().toISOString(),
+      source: 'operator',
+    }, ...notes]);
+    setTitle('');
+    setBody('');
+    setTags('');
+  };
+
+  const remove = (id: string) => persist(notes.filter((note) => note.id !== id));
+
+  return (
+    <>
+      <p className="hint">
+        Operator memory for Cockpit: local notes plus automatic Mission completion notes from durable
+        Mission Control state. Notes stay in this browser profile; AIWG source files are not modified.
+      </p>
+      {err && <p className="err">Mission memory sync failed: {err}</p>}
+      <section className="memory-layout">
+        <form className="memory-form" onSubmit={(e) => { e.preventDefault(); add(); }} aria-label="Add memory note">
+          <h2>Add Note</h2>
+          <label>Title<input value={title} onChange={(e) => setTitle(e.target.value)} placeholder="Note title" /></label>
+          <label>Body<textarea value={body} onChange={(e) => setBody(e.target.value)} placeholder="What should future you remember?" rows={4} /></label>
+          <label>Tags<input value={tags} onChange={(e) => setTags(e.target.value)} placeholder="cockpit, release, risk" /></label>
+          <button type="submit" disabled={!title.trim()}>Save Note</button>
+        </form>
+        <section className="memory-list" aria-label="Memory notes">
+          <div className="section-toolbar">
+            <div>
+              <h2>Notes</h2>
+              <p className="hint">{notes.length} saved · {missions.filter((m) => m.terminal).length} terminal mission(s) observed</p>
+            </div>
+            <input aria-label="Search memory notes" value={query} onChange={(e) => setQuery(e.target.value)} placeholder="Search notes" />
+          </div>
+          {!filtered.length ? <p className="empty">{query ? 'No notes match your search.' : 'No notes yet.'}</p> : (
+            <div className="note-grid">
+              {filtered.map((note) => (
+                <article className="note-card" key={note.id}>
+                  <header>
+                    <h3>{note.title}</h3>
+                    <button aria-label={`Delete note ${note.title}`} onClick={() => remove(note.id)}>Remove</button>
+                  </header>
+                  {note.body && <p>{note.body}</p>}
+                  <footer>
+                    <time dateTime={note.created_at}>{new Date(note.created_at).toLocaleString()}</time>
+                    {note.mission_id && <code>{fmtId(note.mission_id)}</code>}
+                    {note.tags.map((tag) => <span className="tag" key={tag}>{tag}</span>)}
+                  </footer>
+                </article>
+              ))}
+            </div>
+          )}
+        </section>
+      </section>
+    </>
+  );
+}
+
+function readNotes(): MemoryNote[] {
+  try {
+    const parsed = JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]');
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function mergeMissionNotes(notes: MemoryNote[], missions: MissionProjection[]) {
+  const existing = new Set(notes.map((note) => note.mission_id).filter(Boolean));
+  const additions = missions
+    .filter((mission) => mission.terminal && !existing.has(mission.id))
+    .map((mission): MemoryNote => ({
+      id: `mission-note-${mission.id}`,
+      title: mission.title.slice(0, 96),
+      body: [
+        `Status: ${mission.status}`,
+        mission.completion ? `Completion: ${mission.completion}` : '',
+        mission.error ? `Error: ${mission.error}` : '',
+      ].filter(Boolean).join('\n'),
+      tags: ['mission', mission.status, mission.source].filter(Boolean),
+      created_at: mission.completed_at ?? new Date().toISOString(),
+      mission_id: mission.id,
+      source: 'mission',
+    }));
+  return additions.length ? [...additions, ...notes] : notes;
+}

package/web/src/components/Missions.tsx

@@ -0,0 +1,135 @@
+import { useCallback, useEffect, useState } from 'react';
+import { api } from '../api';
+import { fmtId } from '../util';
+import type { MissionProjection, MissionSession, MissionsResponse } from '../types';
+
+export function Missions({ refreshTick = 0 }: { refreshTick?: number }) {
+  const [data, setData] = useState<MissionsResponse | null>(null);
+  const [err, setErr] = useState('');
+  const [selected, setSelected] = useState<string | null>(null);
+
+  const load = useCallback(() => {
+    api<MissionsResponse>('/api/missions')
+      .then((d) => {
+        setData(d);
+        setErr('');
+        setSelected((current) => current ?? d.sessions[0]?.id ?? null);
+      })
+      .catch((e) => setErr((e as Error).message));
+  }, []);
+
+  useEffect(() => { load(); }, [load, refreshTick]);
+
+  if (err) return <p className="err">Could not load Missions: {err}</p>;
+  if (!data) return <p className="empty">Loading...</p>;
+
+  const active = data.sessions.find((s) => s.id === selected) ?? data.sessions[0] ?? null;
+  const totals = summarize(data.missions);
+
+  return (
+    <>
+      <p className="hint">
+        Durable Mission Control state and live executor work share one projection. Cockpit reads
+        <code> aiwg mc </code> sessions and audit logs; the conductor remains the owner of durability.
+      </p>
+      <div className="mission-summary" aria-label="Mission status summary">
+        <span><strong>{data.count}</strong> total</span>
+        <span><strong>{totals.active}</strong> active</span>
+        <span><strong>{totals.awaiting}</strong> awaiting approval</span>
+        <span><strong>{totals.terminal}</strong> terminal</span>
+      </div>
+      {!data.sessions.length ? <p className="empty">No Mission Control sessions or live executor tasks are visible yet.</p> : (
+        <div className="missions-layout">
+          <aside className="mission-sessions" aria-label="Mission sessions">
+            {data.sessions.map((s) => (
+              <button
+                key={s.id}
+                className={s.id === active?.id ? 'selected' : ''}
+                onClick={() => setSelected(s.id)}
+                aria-pressed={s.id === active?.id}
+              >
+                <span>{s.name}</span>
+                <small>{s.source} · {s.missions.length}</small>
+              </button>
+            ))}
+          </aside>
+          {active && <MissionSessionView session={active} />}
+        </div>
+      )}
+    </>
+  );
+}
+
+function MissionSessionView({ session }: { session: MissionSession }) {
+  return (
+    <section className="mission-detail" aria-label={`${session.name} missions`}>
+      <div className="mission-detail-head">
+        <div>
+          <h2>{session.name}</h2>
+          <p>{session.source} · {session.state}{session.updated_at ? ` · updated ${new Date(session.updated_at).toLocaleString()}` : ''}</p>
+        </div>
+        <span className="badge">{session.audit_count} audit events</span>
+      </div>
+      {!session.missions.length ? <p className="empty">This session has no missions.</p> : (
+        <table>
+          <caption>{session.missions.length} mission projection(s)</caption>
+          <thead>
+            <tr><th scope="col">Mission</th><th scope="col">Status</th><th scope="col">Source</th><th scope="col">Loop</th><th scope="col">Backing</th></tr>
+          </thead>
+          <tbody>
+            {session.missions.map((m) => (
+              <tr key={m.id}>
+                <td>
+                  <strong>{m.title}</strong>
+                  {m.completion && <small className="block">Done when: {m.completion}</small>}
+                  {m.error && <small className="block err">{m.error}</small>}
+                </td>
+                <td><span className={`state ${statusClass(m.status)}`}><span className="dot" aria-hidden="true" />{m.status}</span></td>
+                <td>{m.source}</td>
+                <td>{loopText(m)}</td>
+                <td>{backingText(m)}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+      {session.audit_tail.length > 0 && (
+        <section className="audit-tail" aria-label="Mission audit tail">
+          <h3>Audit Tail</h3>
+          {session.audit_tail.map((event, i) => (
+            <p key={`${event.ts ?? 'event'}-${i}`}>
+              <code>{event.ts ? new Date(event.ts).toLocaleTimeString() : 'event'}</code>
+              {' '}{String(event.event ?? 'mission_event')}
+              {event.missionId || event.mission_id ? <> · <code>{fmtId(String(event.missionId ?? event.mission_id))}</code></> : null}
+            </p>
+          ))}
+        </section>
+      )}
+    </section>
+  );
+}
+
+function summarize(missions: MissionProjection[]) {
+  return missions.reduce((acc, mission) => {
+    if (mission.status === 'awaiting-approval' || mission.status === 'input-required') acc.awaiting += 1;
+    if (mission.terminal) acc.terminal += 1;
+    else acc.active += 1;
+    return acc;
+  }, { active: 0, awaiting: 0, terminal: 0 });
+}
+
+function statusClass(status: string) {
+  return status.replace(/[^a-z0-9_-]/gi, '-');
+}
+
+function loopText(mission: MissionProjection) {
+  if (mission.loop === undefined && !mission.max_iterations) return '-';
+  return `${mission.loop ?? 0}/${mission.max_iterations ?? '?'}`;
+}
+
+function backingText(mission: MissionProjection) {
+  if (mission.ralph_loop_id) return `Ralph ${fmtId(mission.ralph_loop_id)}`;
+  if (mission.task_id && mission.instance_id) return `${fmtId(mission.instance_id)} / ${fmtId(mission.task_id)}`;
+  if (mission.target_agent) return fmtId(mission.target_agent);
+  return '-';
+}

package/web/src/components/Telemetry.tsx

@@ -0,0 +1,85 @@
+import { useCallback, useEffect, useState } from 'react';
+import { api } from '../api';
+import { fmtId } from '../util';
+import type { Cost, EventsSnapshot, MissionsResponse } from '../types';
+
+type Filter = 'all' | 'mission' | 'task' | 'approval' | 'session' | 'inventory';
+
+export function Telemetry({ refreshTick = 0 }: { refreshTick?: number }) {
+  const [events, setEvents] = useState<EventsSnapshot | null>(null);
+  const [missions, setMissions] = useState<MissionsResponse | null>(null);
+  const [cost, setCost] = useState<Cost | null>(null);
+  const [filter, setFilter] = useState<Filter>('all');
+  const [err, setErr] = useState('');
+
+  const load = useCallback(() => {
+    Promise.all([
+      api<EventsSnapshot>('/api/events/snapshot'),
+      api<MissionsResponse>('/api/missions').catch(() => null),
+      api<Cost>('/api/cost').catch(() => null),
+    ]).then(([eventData, missionData, costData]) => {
+      setEvents(eventData);
+      setMissions(missionData);
+      setCost(costData);
+      setErr('');
+    }).catch((e) => setErr((e as Error).message));
+  }, []);
+
+  useEffect(() => { load(); }, [load, refreshTick]);
+
+  if (err) return <p className="err">Could not load telemetry: {err}</p>;
+  if (!events) return <p className="empty">Loading...</p>;
+
+  const visible = filter === 'all' ? events.events : events.events.filter((e) => e.type.startsWith(filter));
+  const missionTotals = summarizeMissions(missions);
+  const tokenTotal = cost ? cost.total.input_tokens + cost.total.output_tokens : 0;
+
+  return (
+    <>
+      <p className="hint">
+        Live Cockpit telemetry from the unified event model. This replaces the legacy dashboard feed with
+        Bridge-backed inventory, session, task, approval, Mission, and cost posture.
+      </p>
+      <section className="telemetry-kpis" aria-label="Telemetry key performance indicators">
+        <article><span>Events</span><strong>{events.count}</strong><small>{events.source}</small></article>
+        <article><span>Active Missions</span><strong>{missionTotals.active}</strong><small>{missionTotals.terminal} terminal</small></article>
+        <article><span>Approvals</span><strong>{missionTotals.awaiting}</strong><small>awaiting operator input</small></article>
+        <article><span>Spend</span><strong>{cost ? `$${cost.total.usd.toFixed(2)}` : '-'}</strong><small>{tokenTotal ? `${tokenTotal.toLocaleString()} tokens` : 'cost route unavailable'}</small></article>
+      </section>
+
+      <div className="controls" role="group" aria-label="Filter telemetry events">
+        {(['all', 'mission', 'task', 'approval', 'session', 'inventory'] as const).map((f) => (
+          <button key={f} aria-pressed={filter === f} onClick={() => setFilter(f)}>{f}</button>
+        ))}
+      </div>
+
+      {!visible.length ? <p className="empty">No events match this filter.</p> : (
+        <table>
+          <caption>{visible.length} event(s), fetched {new Date(events.fetched_at).toLocaleTimeString()}</caption>
+          <thead><tr><th scope="col">Time</th><th scope="col">Type</th><th scope="col">Subject</th><th scope="col">State</th><th scope="col">Source</th></tr></thead>
+          <tbody>
+            {visible.map((e) => (
+              <tr key={e.id}>
+                <td><time dateTime={e.ts}>{new Date(e.ts).toLocaleTimeString()}</time></td>
+                <td><span className="badge">{e.type}</span></td>
+                <td><code title={e.subject}>{fmtId(e.subject)}</code></td>
+                <td>{e.state ? <span className={`state ${e.state}`}><span className="dot" aria-hidden="true" />{e.state}</span> : '-'}</td>
+                <td>{e.source}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+    </>
+  );
+}
+
+function summarizeMissions(data: MissionsResponse | null) {
+  const summary = { active: 0, terminal: 0, awaiting: 0 };
+  for (const mission of data?.missions ?? []) {
+    if (mission.status === 'awaiting-approval' || mission.status === 'input-required') summary.awaiting += 1;
+    if (mission.terminal) summary.terminal += 1;
+    else summary.active += 1;
+  }
+  return summary;
+}

package/web/src/styles.css

@@ -18,6 +18,7 @@ header .meta { margin-left:0; color:var(--muted); font-size:13px; }
 [role=tab]:focus-visible { outline:2px solid var(--accent); outline-offset:-2px; }
 main { padding:22px; }
 button, select, input { background:var(--panel); color:var(--fg); border:1px solid var(--line); border-radius:7px; padding:7px 12px; font:inherit; }
+textarea { background:var(--panel); color:var(--fg); border:1px solid var(--line); border-radius:7px; padding:7px 12px; font:inherit; resize:vertical; }
 button { cursor:pointer; }
 button:hover:not(:disabled) { border-color:var(--accent); }
 button:disabled { opacity:.45; cursor:not-allowed; }
@@ -62,11 +63,60 @@ code { font:13px ui-monospace, monospace; color:var(--muted); }
 .response-item { display:grid; grid-template-columns:minmax(0,1fr) auto; gap:12px; align-items:start; border:1px solid var(--warn); border-radius:8px; background:rgba(253,230,138,.08); padding:12px 14px; }
 .response-item p { margin:5px 0; color:var(--fg); white-space:pre-wrap; overflow-wrap:anywhere; }
 .response-item span { color:var(--muted); font-size:12px; }
+.mission-summary { display:flex; gap:10px; flex-wrap:wrap; margin:14px 0; }
+.mission-summary span { border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:8px 12px; color:var(--muted); }
+.mission-summary strong { color:var(--fg); }
+.missions-layout { display:grid; grid-template-columns:minmax(220px, 300px) minmax(0, 1fr); gap:14px; align-items:start; margin-top:14px; }
+.mission-sessions { display:grid; gap:8px; }
+.mission-sessions button { display:grid; gap:2px; text-align:left; border-radius:8px; }
+.mission-sessions button.selected { border-color:var(--accent); background:rgba(94,234,212,.08); }
+.mission-sessions small { color:var(--muted); }
+.mission-detail { min-width:0; display:grid; gap:12px; }
+.mission-detail-head { display:flex; align-items:flex-start; justify-content:space-between; gap:12px; border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:14px; }
+.mission-detail-head h2 { margin:0; font-size:18px; }
+.mission-detail-head p { margin:3px 0 0; color:var(--muted); font-size:13px; }
+.block { display:block; margin-top:4px; color:var(--muted); font-size:12px; overflow-wrap:anywhere; }
+.audit-tail { border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:12px 14px; }
+.audit-tail h3 { margin:0 0 8px; font-size:14px; }
+.audit-tail p { margin:5px 0; color:var(--muted); font-size:13px; }
+.telemetry-kpis { display:grid; grid-template-columns:repeat(auto-fit,minmax(170px,1fr)); gap:10px; margin:14px 0; }
+.telemetry-kpis article { display:grid; gap:4px; border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:12px 14px; }
+.telemetry-kpis span, .telemetry-kpis small { color:var(--muted); font-size:12px; }
+.telemetry-kpis strong { font-size:24px; }
+.controls button[aria-pressed=true] { border-color:var(--accent); color:var(--accent); }
+.memory-layout { display:grid; grid-template-columns:minmax(260px, 360px) minmax(0, 1fr); gap:14px; align-items:start; margin-top:14px; }
+.memory-form { display:grid; gap:10px; border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:14px; }
+.memory-form h2 { margin:0; font-size:18px; }
+.memory-form label { display:grid; gap:5px; color:var(--muted); font-size:13px; }
+.memory-form input, .memory-form textarea { width:100%; }
+.memory-list { min-width:0; }
+.note-grid { display:grid; grid-template-columns:repeat(auto-fill,minmax(240px,1fr)); gap:10px; }
+.note-card { display:grid; gap:8px; border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:12px; }
+.note-card header { position:static; display:flex; align-items:flex-start; justify-content:space-between; gap:10px; padding:0; border:0; background:transparent; }
+.note-card h3 { margin:0; font-size:15px; }
+.note-card p { margin:0; color:var(--muted); white-space:pre-wrap; overflow-wrap:anywhere; }
+.note-card footer { display:flex; gap:6px; align-items:center; flex-wrap:wrap; color:var(--muted); font-size:12px; }
 .grid2 { display:grid; grid-template-columns:minmax(260px,1fr) 1.4fr; gap:16px; align-items:start; }
+.index-live { border:1px solid var(--line); border-radius:8px; background:rgba(17,24,39,.72); padding:14px; margin:14px 0 18px; }
+.index-grid { display:grid; grid-template-columns:repeat(auto-fill,minmax(180px,1fr)); gap:8px; margin-bottom:12px; }
+.index-graph { border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:10px 12px; }
+.index-graph.missing { border-color:var(--warn); }
+.index-graph p { margin:5px 0 0; color:var(--muted); font-size:13px; }
+.index-query { display:grid; grid-template-columns:minmax(220px,1fr) auto; gap:10px; align-items:end; margin-top:10px; }
+.index-query label { display:grid; gap:5px; color:var(--muted); font-size:13px; }
+.index-results { display:grid; grid-template-columns:repeat(auto-fill,minmax(240px,1fr)); gap:8px; margin-top:12px; }
+.index-results article { border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:10px 12px; }
+.index-results p { margin:5px 0; color:var(--muted); font-size:13px; overflow-wrap:anywhere; }
+.index-results small { color:var(--muted); }
 .act { text-align:left; }
 .action-cluster { display:inline-flex; align-items:stretch; gap:4px; }
 .action-cluster .act { border-radius:7px 0 0 7px; }
 .copy-command { border-radius:0 7px 7px 0; color:var(--muted); font-size:12px; padding-inline:9px; }
+.contrib-layout { display:grid; grid-template-columns:repeat(auto-fit,minmax(280px,1fr)); gap:14px; margin-top:16px; }
+.contrib-grid { display:grid; gap:10px; }
+.contrib-item { display:grid; gap:8px; align-items:start; border:1px solid var(--line); border-radius:8px; background:var(--panel); padding:12px; }
+.contrib-item p { margin:0; color:var(--muted); font-size:13px; overflow-wrap:anywhere; }
+.workflow-steps { display:flex; gap:8px; flex-wrap:wrap; }
 /* Tenor-style capability grid (modeled on fortemi-react SearchResults) */
 .capgrid { display:grid; grid-template-columns:repeat(auto-fill,minmax(230px,1fr)); gap:10px; }
 .capcard { display:block; text-align:left; background:var(--panel); border:1px solid var(--line); border-radius:10px; padding:11px 13px; cursor:pointer; }
@@ -234,7 +284,7 @@ code { font:13px ui-monospace, monospace; color:var(--muted); }
 @media (max-width: 820px) {
   header { position:static; }
   .top-status { width:100%; margin-left:0; }
-  .wall-hero, .guided-start, .radial-wall, .control-planner { grid-template-columns:1fr; align-items:start; }
+  .wall-hero, .guided-start, .radial-wall, .control-planner, .missions-layout, .memory-layout { grid-template-columns:1fr; align-items:start; }
   .hero-actions { justify-content:flex-start; }
   .telemetry-strip { grid-template-columns:repeat(2,minmax(120px,1fr)); }
   .planner-grid { grid-template-columns:1fr; }

package/web/src/types.ts

@@ -38,11 +38,78 @@ export interface RunningTask { instance_id: string; task_id: string; state: stri
 export interface SessionInfo { id: string; instance_id: string; seq?: number; members?: number; has_controller?: boolean; attach_url: string; mode?: 'direct' | 'managed'; backend?: string; session_name?: string; sessionName?: string; session_class?: string; session_backend?: string; role_policy?: string; replay?: boolean; keyframe?: boolean; controllers?: number; observers?: number }
 export interface Approval { id: string; instance_id: string; prompt: string; risk: string; status: string }
 export interface ResponseNeeded { id: string; instance_id: string; prompt: string; source: string; status: string; attach_url?: string | null }
+export interface MissionAuditEvent { event?: string; ts?: string; missionId?: string; mission_id?: string; objective?: string; [key: string]: unknown }
+export interface MissionProjection {
+  id: string;
+  session_id: string;
+  source: string;
+  title: string;
+  completion?: string;
+  status: string;
+  loop?: number;
+  max_iterations?: number;
+  priority?: string;
+  mode?: string;
+  target_agent?: string;
+  ralph_loop_id?: string;
+  ralph_pid?: number;
+  started_at?: string;
+  completed_at?: string;
+  error?: string;
+  instance_id?: string;
+  task_id?: string;
+  tenant?: string;
+  risk?: string;
+  terminal?: boolean;
+}
+export interface MissionSession {
+  id: string;
+  name: string;
+  state: string;
+  source: string;
+  created_at?: string;
+  updated_at?: string;
+  max_missions?: number;
+  audit_count: number;
+  audit_tail: MissionAuditEvent[];
+  missions: MissionProjection[];
+}
+export interface MissionsResponse {
+  source: string;
+  fetched_at: string;
+  count: number;
+  sessions: MissionSession[];
+  missions: MissionProjection[];
+}
+export interface UnifiedEvent {
+  id: string;
+  type: string;
+  source: string;
+  subject: string;
+  state?: string;
+  severity?: string;
+  ts: string;
+  ref?: Record<string, string | undefined>;
+}
+export interface EventsSnapshot {
+  source: string;
+  fetched_at: string;
+  count: number;
+  events: UnifiedEvent[];
+}
 export interface InstanceCost { instance_id: string; tenant: string; input_tokens: number; output_tokens: number; usd: number }
 export interface Cost { total: { input_tokens: number; output_tokens: number; usd: number }; per_instance: InstanceCost[] }
 export interface Loadout { id: string; label: string; description?: string; runtimes?: string[] }
 export interface ExecutorCapabilities { status: string; source?: string | null; host_runtime_enabled: boolean; raw_status?: string; error?: string }
 export interface CapabilityResult { path: string; type: string; title?: string; capability?: string; score?: number; name: string; triggers?: string[] }
 export interface ContribAction { id: string; title: string; icon?: string; group?: string; source: string; inject: { command: string; target?: string; needs_args?: boolean; args_hint?: string } }
+export interface ContribScreen { id: string; title: string; source: string; contribution: string }
+export interface ContribWorkflowStep { action: string; label?: string }
+export interface ContribWorkflow { id: string; title: string; description?: string; source: string; steps: ContribWorkflowStep[] }
+export interface ContributionsResponse { actions: ContribAction[]; screens: ContribScreen[]; workflows: ContribWorkflow[] }
+export interface IndexGraphStatus { name: string; origin: string; shared: boolean; defaultBuild: boolean; location: string; built: boolean; builtAt: string | null; ageHours: number | null; entries: number | null; missing: boolean }
+export interface IndexStatusResponse { graphs: IndexGraphStatus[]; orphanIndexDirs: string[]; warnings: unknown[]; summary: { total: number; built: number; missing: number; orphans: number; warnings: number } }
+export interface IndexQueryResult { path: string; title?: string; type?: string; phase?: string; summary?: string; score?: number }
+export interface IndexQueryResponse { results?: IndexQueryResult[]; total?: number; query?: unknown; graph?: string | null; mode?: string }
 export type Role = 'controller' | 'observer' | null;
 export interface LibraryAsset { name: string; type: string; kind: 'dir' | 'file'; origin: string; source_path?: string }