total-recall-brain 3.28.2 → 3.30.0

package/frontend/dist/index.html

@@ -17,7 +17,7 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
     <title>Total Recall — Portable Memory</title>
-    <script type="module" crossorigin src="/assets/index-U7o-qU99.js"></script>
+    <script type="module" crossorigin src="/assets/index-DGMNZi_1.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C7_Xpk27.css">
   </head>
   <body>

package/frontend/src/api/plugins.ts

@@ -1,61 +1,130 @@
 // ─── Plugins domain ───────────────────────────────────────────────────────────
+//
+// Every field here is something the node can verify: the manifest, where the
+// plugin came from, its content hash, whether it is shared, and — for peers —
+// whether that peer answered. There are no ratings, reviews or install counts.
 
 import { apiFetch, API_BASE } from "./_base"
 
+export type PluginSourceKind = "bundled" | "public" | "peer" | "git" | "local" | "link"
+
+export interface PluginSource {
+  kind: PluginSourceKind
+  ref: string
+  peer_hostname?: string | null
+}
+
+export interface PluginTask {
+  intent: string
+  schedule: string
+  command: string
+  last_run: string | null
+}
+
 export interface PluginInfo {
   id: string
   name: string
   version: string
   description: string
+  author: string | null
+  license: string | null
+  homepage: string | null
+  use_cases: string[]
   valid: boolean
   errors: string[]
+  scope: "project" | "global"
+  linked: boolean
   dir: string
-  rating: number
-  reviewCount: number
-  installCount: string
-  userRating?: number | null
-  userReview?: string | null
-  verified?: boolean
-  categories: Array<{ name: string; description?: string }>
-  tasks: Array<{ intent: string; schedule: string }>
-  openwiki_hubs: Array<{ title: string; path: string }>
-  tools: Array<{ name: string; description?: string }>
-  cli?: { command: string; handler: string } | null
+  shared: boolean
+  mesh_shared: boolean
+  share_url: string | null
+  source: PluginSource
+  installed_at: string | null
+  sha256: string | null
+  installed_sha256: string | null
+  modified_since_install: boolean
+  file_count: number | null
+  size_bytes: number | null
+  categories: Array<{ name: string; description?: string; node_type?: string }>
+  tasks: PluginTask[]
+  openwiki_hubs: Array<{ title?: string; path: string }>
+  cli: { command: string | null; subcommands: Array<{ name: string; description?: string }> } | null
+  has_generator: boolean
   manifest?: Record<string, unknown>
 }
 
-export interface CatalogPlugin {
+export interface BundledPlugin {
+  id: string
+  name: string
+  version: string
+  description: string
+  use_cases: string[]
+  categories: Array<{ name: string; description?: string }>
+  tasks: Array<{ intent: string; schedule: string; command: string }>
+  cli: { command: string; subcommands: Array<{ name: string; description?: string }> } | null
+  installed: boolean
+}
+
+export interface PeerPlugin {
   id: string
   name: string
   version: string
   description: string
-  tags: string[]
-  author: string
-  sourceUrl: string
-  rating: number
-  reviewCount: number
-  installCount: string
-  userRating?: number | null
-  verified?: boolean
-  isInstalled: boolean
+  use_cases: string[]
+  sha256: string
+  file_count: number
+  size_bytes: number
+  installed: boolean
+  same_as_installed: boolean
 }
 
-export interface PluginsResponse {
-  success: boolean
-  count: number
-  plugins: PluginInfo[]
+export type PeerStatus = "ok" | "offline" | "unreachable" | "not_configured" | "unsupported" | "error"
+
+export interface PeerNode {
+  hostname: string
+  ip: string
+  online: boolean
+  os: string | null
+  status: PeerStatus
+  error?: string
+  plugins: PeerPlugin[]
+}
+
+export interface PeersResponse {
+  mesh: { available: boolean; configured: boolean }
+  peers: PeerNode[]
 }
 
-export interface CatalogResponse {
-  success: boolean
-  catalog: CatalogPlugin[]
+type Result = { success: boolean; message?: string; error?: string; plugin?: PluginInfo }
+
+async function readJson(res: Response): Promise<any> {
+  try {
+    return await res.json()
+  } catch {
+    return {}
+  }
+}
+
+async function post(url: string, body: unknown, method = "POST"): Promise<Result & Record<string, any>> {
+  try {
+    const res = await apiFetch(url, {
+      method,
+      headers: { "Content-Type": "application/json" },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    })
+    const data = await readJson(res)
+    if (!res.ok) return { success: false, error: data.error || data.message || `Request failed (${res.status})` }
+    return { success: true, ...data }
+  } catch (err: any) {
+    return { success: false, error: err?.message || "Network error" }
+  }
 }
 
 export async function fetchPlugins(): Promise<PluginInfo[]> {
   try {
     const res = await apiFetch(`${API_BASE}/api/plugins`)
     if (!res.ok) return []
-    const data: PluginsResponse = await res.json()
+    const data = await readJson(res)
     return Array.isArray(data.plugins) ? data.plugins : []
   } catch {
     return []
@@ -66,102 +135,65 @@ export async function fetchPlugin(id: string): Promise<PluginInfo | null> {
   try {
     const res = await apiFetch(`${API_BASE}/api/plugins/${encodeURIComponent(id)}`)
     if (!res.ok) return null
-    const data = await res.json()
+    const data = await readJson(res)
     return data.plugin || null
   } catch {
     return null
   }
 }
 
-export async function fetchPluginCatalog(): Promise<CatalogPlugin[]> {
+export async function fetchBundledPlugins(): Promise<BundledPlugin[]> {
   try {
-    const res = await apiFetch(`${API_BASE}/api/plugins/catalog`)
+    const res = await apiFetch(`${API_BASE}/api/plugins/available`)
     if (!res.ok) return []
-    const data: CatalogResponse = await res.json()
-    return Array.isArray(data.catalog) ? data.catalog : []
+    const data = await readJson(res)
+    return Array.isArray(data.plugins) ? data.plugins : []
   } catch {
     return []
   }
 }
 
-export async function installPlugin(options: { source: string; link?: boolean; global?: boolean }): Promise<{ success: boolean; message?: string; error?: string }> {
+/** Asks every mesh peer live; `null` means this node could not ask at all. */
+export async function fetchPeerPlugins(): Promise<PeersResponse | null> {
   try {
-    const res = await apiFetch(`${API_BASE}/api/plugins/install`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(options)
-    })
-    const data = await res.json()
-    if (!res.ok) {
-      return { success: false, error: data.error || data.message || "Failed to install plugin" }
-    }
-    return { success: true, message: data.message }
-  } catch (err: any) {
-    return { success: false, error: err.message || "Network error" }
+    const res = await apiFetch(`${API_BASE}/api/plugins/peers`)
+    if (!res.ok) return null
+    const data = await readJson(res)
+    return { mesh: data.mesh || { available: false, configured: false }, peers: Array.isArray(data.peers) ? data.peers : [] }
+  } catch {
+    return null
   }
 }
 
-export async function removePlugin(id: string, global = false): Promise<{ success: boolean; message?: string; error?: string }> {
-  try {
-    const res = await apiFetch(`${API_BASE}/api/plugins/${encodeURIComponent(id)}?global=${global ? "true" : "false"}`, {
-      method: "DELETE"
-    })
-    const data = await res.json()
-    if (!res.ok) {
-      return { success: false, error: data.error || data.message || "Failed to remove plugin" }
-    }
-    return { success: true, message: data.message }
-  } catch (err: any) {
-    return { success: false, error: err.message || "Network error" }
-  }
+export function installPlugin(options: { source: string; link?: boolean; global?: boolean }): Promise<Result> {
+  return post(`${API_BASE}/api/plugins/install`, options)
 }
 
-export async function ratePlugin(id: string, rating: number, review?: string): Promise<{ success: boolean; message?: string; error?: string }> {
-  try {
-    const res = await apiFetch(`${API_BASE}/api/plugins/${encodeURIComponent(id)}/rate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ rating, review })
-    })
-    const data = await res.json()
-    if (!res.ok) {
-      return { success: false, error: data.error || data.message || "Failed to submit rating" }
-    }
-    return { success: true, message: data.message }
-  } catch (err: any) {
-    return { success: false, error: err.message || "Network error" }
-  }
+export function removePlugin(id: string, global = false): Promise<Result> {
+  return post(`${API_BASE}/api/plugins/${encodeURIComponent(id)}${global ? "?global=true" : ""}`, undefined, "DELETE")
+}
+
+export function setPluginShared(id: string, shared: boolean): Promise<Result> {
+  return post(`${API_BASE}/api/plugins/${encodeURIComponent(id)}/share`, { shared })
 }
 
 export async function runPluginCommand(
   id: string,
   subcommand = "",
   args: string[] = []
-): Promise<{ success: boolean; output?: string; error?: string }> {
-  try {
-    const res = await apiFetch(`${API_BASE}/api/plugins/${encodeURIComponent(id)}/run`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ subcommand, args })
-    })
-    const data = await res.json()
-    if (!res.ok) {
-      return { success: false, error: data.error || data.message || "Failed to execute plugin command" }
-    }
-    return { success: true, output: data.output || "" }
-  } catch (err: any) {
-    return { success: false, error: err.message || "Network error" }
-  }
+): Promise<{ success: boolean; output?: string; error?: string; exitCode?: number | null; timedOut?: boolean }> {
+  const res = await post(`${API_BASE}/api/plugins/${encodeURIComponent(id)}/run`, { subcommand, args })
+  if (res.error) return { success: false, error: res.error }
+  return { success: !!res.ok, output: res.output || "", exitCode: res.exitCode, timedOut: res.timedOut }
 }
 
 export async function fetchPluginReadme(id: string): Promise<string> {
   try {
     const res = await apiFetch(`${API_BASE}/api/plugins/${encodeURIComponent(id)}/readme`)
     if (!res.ok) return ""
-    const data = await res.json()
+    const data = await readJson(res)
     return data.readme || ""
   } catch {
     return ""
   }
 }
-

package/frontend/src/components/ResearchAgendaTab.spec.tsx

@@ -46,6 +46,17 @@ describe('ResearchAgendaTab', () => {
     expect(screen.getByPlaceholderText('e.g. Bun vs Node.js HTTP clustering performance benchmarks')).toBeInTheDocument();
   });
 
+  it('labels who wanted each research item', () => {
+    const now = new Date().toISOString();
+    const items = [
+      { id: 'u', topic: 'Asked', status: 'pending' as const, priority: 'high' as const, notes: null, created_at: now, updated_at: now, origin: 'user' as const, requested_via: 'chat' },
+      { id: 'a', topic: 'Auto', status: 'pending' as const, priority: 'medium' as const, notes: null, created_at: now, updated_at: now, origin: 'autonomous' as const, project: 'total-recall', rationale: 'agent guessed' },
+    ];
+    render(<ResearchAgendaTab {...defaultProps} researchItems={items} />);
+    expect(screen.getByText('You asked · chat')).toBeInTheDocument();
+    expect(screen.getByText('Background research for total-recall')).toHaveAttribute('title', 'agent guessed');
+  });
+
   it('renders research items', () => {
     const items = [
       {

package/frontend/src/components/ResearchAgendaTab.tsx

@@ -13,6 +13,11 @@ export interface ResearchItem {
   research_phase?: string
   created_at: string
   updated_at: string
+  /** 'user' = a human asked; 'autonomous' = background research for a project; 'legacy' = predates provenance. */
+  origin?: 'user' | 'autonomous' | 'legacy'
+  requested_via?: string | null
+  project?: string | null
+  rationale?: string | null
 }
 
 interface ResearchAgendaTabProps {
@@ -239,6 +244,16 @@ export default function ResearchAgendaTab(props: ResearchAgendaTabProps) {
                       </td>
                       <td style={{ padding: '14px 16px' }}>
                         <div style={{ fontWeight: 600, color: 'var(--text-primary)' }}>{item.topic}</div>
+                        {(item.origin === 'autonomous' || item.origin === 'user') && (
+                          <div
+                            style={{ fontSize: 11, color: 'var(--text-tertiary)', marginTop: 2 }}
+                            title={item.origin === 'autonomous' ? item.rationale || undefined : undefined}
+                          >
+                            {item.origin === 'autonomous'
+                              ? `Background research${item.project ? ` for ${item.project}` : ''}`
+                              : `You asked${item.requested_via ? ` · ${item.requested_via}` : ''}`}
+                          </div>
+                        )}
                         {item.notes && (
                           <div style={{ fontSize: 12, color: 'var(--text-secondary)', marginTop: 4 }}>
                             {item.notes}
@@ -312,25 +327,15 @@ export default function ResearchAgendaTab(props: ResearchAgendaTabProps) {
                                     icon: '✨',
                                     desc: 'Markdown polish & premium layout restructuring'
                                   },
-                                  {
-                                    title: 'Source Monitoring',
-                                    phase: 'monitoring',
-                                    icon: '📡',
-                                    desc: 'Ongoing newsletter, RSS & release tracking'
-                                  },
-                                  {
-                                    title: 'Tangent Spawning',
-                                    phase: 'expansion',
-                                    icon: '🚀',
-                                    desc: 'Autonomously brainstorming & enqueuing tangents'
-                                  }
                                 ].map((step, idx) => {
-                                  const phases = ['acquisition', 'deliberation', 'improvement', 'monitoring', 'expansion']
+                                  // Research ends after improvement: it never re-monitors or
+                                  // spawns tangents (RESEARCH_SYSTEM2).
+                                  const phases = ['acquisition', 'deliberation', 'improvement']
                                   const activePhase = item.research_phase || 'acquisition'
                                   const activeIndex = phases.indexOf(activePhase)
 
                                   let state: 'completed' | 'active' | 'waiting' | 'failed' | 'upcoming' = 'upcoming'
-                                  if (idx < activeIndex) {
+                                  if (item.status === 'done' || idx < activeIndex) {
                                     state = 'completed'
                                   } else if (idx === activeIndex) {
                                     if (item.status === 'in_progress') state = 'active'

package/frontend/src/pages/PluginsPage.spec.tsx

@@ -1,25 +1,96 @@
-import { describe, it, expect, vi } from 'vitest';
-import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import { MemoryRouter } from 'react-router-dom';
 import PluginsPage from './PluginsPage';
 
-// Mock fetch globally
-const mockFetch = vi.fn().mockResolvedValue({
-  ok: true,
-  json: async () => ({ installed: [], catalog: [] })
+const installed = [{
+  id: 'git-sentinel', name: 'Git Sentinel', version: '1.1.0', description: 'Repository state',
+  author: 'Total Recall', license: 'MIT', homepage: null, use_cases: ['software-development'],
+  valid: true, errors: [], scope: 'project', linked: false, dir: '/p/git-sentinel', shared: true,
+  source: { kind: 'peer', ref: 'peer:mac-mini/git-sentinel', peer_hostname: 'mac-mini' },
+  installed_at: '2026-09-22T12:00:00.000Z', sha256: 'a'.repeat(64), installed_sha256: 'a'.repeat(64),
+  modified_since_install: false, file_count: 3, size_bytes: 2048, categories: [], tasks: [],
+  openwiki_hubs: [], cli: { command: 'git-sentinel', subcommands: [{ name: 'audit' }] }, has_generator: false
+}];
+
+const bundled = [
+  { id: 'git-sentinel', name: 'Git Sentinel', version: '1.1.0', description: 'Repository state', use_cases: ['software-development'], categories: [], tasks: [], cli: null, installed: true },
+  { id: 'system-monitor', name: 'System Monitor', version: '1.1.0', description: 'Host resources', use_cases: ['operations'], categories: [], tasks: [{ intent: 'x', schedule: '*/15 * * * *', command: 'sample' }], cli: null, installed: false }
+];
+
+const peers = {
+  mesh: { available: true, configured: true },
+  peers: [
+    { hostname: 'mac-mini', ip: '100.64.0.2', online: true, os: 'macOS', status: 'ok', plugins: [
+      { id: 'reading-list', name: 'Reading List', version: '0.2.0', description: 'Papers to read', use_cases: ['research'], sha256: 'b'.repeat(64), file_count: 4, size_bytes: 900, installed: false, same_as_installed: false }
+    ] },
+    { hostname: 'droplet', ip: '100.64.0.1', online: true, os: 'linux', status: 'unsupported', error: 'Peer does not serve plugins (older Total Recall version)', plugins: [] }
+  ]
+};
+
+const calls: Array<{ url: string; init?: RequestInit }> = [];
+
+function respond(body: unknown, status = 200) {
+  return Promise.resolve({ ok: status < 400, status, json: async () => body } as Response);
+}
+
+beforeEach(() => {
+  calls.length = 0;
+  globalThis.fetch = vi.fn((url: RequestInfo | URL, init?: RequestInit) => {
+    const u = String(url);
+    calls.push({ url: u, init });
+    if (u.endsWith('/api/plugins/available')) return respond({ success: true, plugins: bundled });
+    if (u.endsWith('/api/plugins/peers')) return respond({ success: true, ...peers });
+    if (u.endsWith('/api/plugins/install')) return respond({ success: true, message: 'Installed System Monitor 1.1.0 (bundled)' });
+    if (u.includes('/readme')) return respond({ success: true, readme: '# Git Sentinel' });
+    if (u.endsWith('/api/plugins')) return respond({ success: true, count: 1, plugins: installed });
+    return respond({}, 404);
+  }) as unknown as typeof fetch;
 });
-globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+function renderPage() {
+  return render(<MemoryRouter><PluginsPage /></MemoryRouter>);
+}
 
 describe('PluginsPage', () => {
-  it('renders plugins page', () => {
-    // PluginsPage reads useSearchParams(), so it must be rendered inside a
-    // Router — without one react-router throws and nothing mounts.
-    render(
-      <MemoryRouter>
-        <PluginsPage />
-      </MemoryRouter>,
-    );
-    // getByText(/Plugin/i) matched both the heading and the install button.
+  it('renders installed plugins with provenance and no fabricated social proof', async () => {
+    const { container } = renderPage();
     expect(screen.getByRole('heading', { name: /Plugins/i })).toBeInTheDocument();
+    expect(await screen.findByText('from mac-mini')).toBeInTheDocument();
+    expect(screen.getByText('shared')).toBeInTheDocument();
+    expect(container.textContent).not.toMatch(/★|rating|reviews?\b|installs\b|downloads?|verified/i);
+  });
+
+  it('installs a bundled plugin', async () => {
+    renderPage();
+    await screen.findByText('from mac-mini');
+    fireEvent.click(screen.getByRole('tab', { name: /Bundled/ }));
+    fireEvent.click(await screen.findByRole('button', { name: 'Install' }));
+    await waitFor(() => expect(calls.some(c => c.url.endsWith('/api/plugins/install'))).toBe(true));
+    const body = JSON.parse(String(calls.find(c => c.url.endsWith('/api/plugins/install'))!.init!.body));
+    expect(body).toEqual({ source: 'system-monitor' });
+  });
+
+  it('shows what each mesh peer shares and reports peers it could not use', async () => {
+    const { container } = renderPage();
+    await screen.findByText('from mac-mini');
+    fireEvent.click(screen.getByRole('tab', { name: /On the mesh/ }));
+    expect(await screen.findByText('Reading List')).toBeInTheDocument();
+    expect(screen.getByText(/no plugin sharing \(older version\)/)).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: 'Install' }));
+    await waitFor(() => {
+      const req = calls.find(c => c.url.endsWith('/api/plugins/install'));
+      expect(JSON.parse(String(req!.init!.body))).toEqual({ source: 'peer:mac-mini/reading-list' });
+    });
+    expect(container.textContent).not.toMatch(/★|rating|downloads?|verified/i);
+  });
+
+  it('filters by use case', async () => {
+    renderPage();
+    await screen.findByText('from mac-mini');
+    fireEvent.click(screen.getByRole('tab', { name: /Bundled/ }));
+    fireEvent.change(screen.getByLabelText('Filter by use case'), { target: { value: 'operations' } });
+    expect(screen.getByText('System Monitor')).toBeInTheDocument();
+    expect(screen.queryByText('Repository state')).not.toBeInTheDocument();
   });
 });