@geminilight/mindos 0.5.3 → 0.5.5

package/app/app/api/mcp/agents/route.ts

@@ -15,6 +15,7 @@ export async function GET() {
         configPath: status.configPath,
         hasProjectScope: !!agent.project,
         hasGlobalScope: !!agent.global,
+        preferredTransport: agent.preferredTransport,
       };
     });
     return NextResponse.json({ agents });

package/app/app/api/mcp/install/route.ts

@@ -4,9 +4,15 @@ import fs from 'fs';
 import path from 'path';
 import { MCP_AGENTS, expandHome } from '@/lib/mcp-agents';
 
+interface AgentInstallItem {
+  key: string;
+  scope: 'project' | 'global';
+  transport?: 'stdio' | 'http';
+}
+
 interface InstallRequest {
-  agents: Array<{ key: string; scope: 'project' | 'global' }>;
-  transport: 'stdio' | 'http';
+  agents: AgentInstallItem[];
+  transport: 'stdio' | 'http' | 'auto';
   url?: string;
   token?: string;
 }
@@ -20,20 +26,59 @@ function buildEntry(transport: string, url?: string, token?: string) {
   return entry;
 }
 
+async function verifyHttpConnection(url: string, token?: string): Promise<{ verified: boolean; verifyError?: string }> {
+  try {
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+    if (token) headers['Authorization'] = `Bearer ${token}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} }),
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+    if (res.ok) return { verified: true };
+    return { verified: false, verifyError: `HTTP ${res.status}` };
+  } catch (err) {
+    return { verified: false, verifyError: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 export async function POST(req: NextRequest) {
   try {
     const body = (await req.json()) as InstallRequest;
-    const { agents, transport, url, token } = body;
-    const entry = buildEntry(transport, url, token);
-    const results: Array<{ agent: string; status: string; path?: string; message?: string }> = [];
+    const { agents, transport: globalTransport, url, token } = body;
+    const results: Array<{
+      agent: string;
+      status: string;
+      path?: string;
+      message?: string;
+      transport?: string;
+      verified?: boolean;
+      verifyError?: string;
+    }> = [];
 
-    for (const { key, scope } of agents) {
+    for (const item of agents) {
+      const { key, scope } = item;
       const agent = MCP_AGENTS[key];
       if (!agent) {
         results.push({ agent: key, status: 'error', message: `Unknown agent: ${key}` });
         continue;
       }
 
+      // Resolve effective transport: agent-level > global-level > auto (use preferredTransport)
+      let effectiveTransport: 'stdio' | 'http';
+      if (item.transport && item.transport !== 'auto' as string) {
+        effectiveTransport = item.transport;
+      } else if (globalTransport && globalTransport !== 'auto') {
+        effectiveTransport = globalTransport;
+      } else {
+        effectiveTransport = agent.preferredTransport;
+      }
+
+      const entry = buildEntry(effectiveTransport, url, token);
       const isGlobal = scope === 'global';
       const configPath = isGlobal ? agent.global : agent.project;
       if (!configPath) {
@@ -59,7 +104,17 @@ export async function POST(req: NextRequest) {
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
         fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
 
-        results.push({ agent: key, status: 'ok', path: configPath });
+        const result: typeof results[number] = { agent: key, status: 'ok', path: configPath, transport: effectiveTransport };
+
+        // Verify http connections
+        if (effectiveTransport === 'http') {
+          const mcpUrl = (entry as Record<string, unknown>).url as string;
+          const verification = await verifyHttpConnection(mcpUrl, token);
+          result.verified = verification.verified;
+          if (verification.verifyError) result.verifyError = verification.verifyError;
+        }
+
+        results.push(result);
       } catch (err) {
         results.push({ agent: key, status: 'error', message: String(err) });
       }

package/app/app/api/mcp/install-skill/route.ts

@@ -0,0 +1,96 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { execSync } from 'child_process';
+import path from 'path';
+
+/* ── Agent classification ──────────────────────────────────────── */
+
+// Universal agents read directly from ~/.agents/skills/ — no symlink needed.
+const UNIVERSAL_AGENTS = new Set([
+  'amp', 'cline', 'codex', 'cursor', 'gemini-cli',
+  'github-copilot', 'kimi-cli', 'opencode', 'warp',
+]);
+
+// Agents that do NOT support Skills at all
+const SKILL_UNSUPPORTED = new Set(['claude-desktop']);
+
+// MCP agent key → npx skills agent name (for non-universal agents)
+// Keys not listed here and not in UNIVERSAL/UNSUPPORTED will use the key as-is.
+const AGENT_NAME_MAP: Record<string, string> = {
+  'claude-code': 'claude-code',
+  'windsurf': 'windsurf',
+  'trae': 'trae',
+  'openclaw': 'openclaw',
+  'codebuddy': 'codebuddy',
+};
+
+/* ── POST handler ──────────────────────────────────────────────── */
+
+interface SkillInstallRequest {
+  skill: 'mindos' | 'mindos-zh';
+  agents: string[];
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body: SkillInstallRequest = await req.json();
+    const { skill, agents } = body;
+
+    if (!skill || !['mindos', 'mindos-zh'].includes(skill)) {
+      return NextResponse.json({ error: 'Invalid skill name' }, { status: 400 });
+    }
+
+    // Source path: project root `skills/` directory
+    const source = path.resolve(process.cwd(), 'skills');
+
+    // Non-universal, skill-capable agents need explicit `-a` for symlink creation
+    const additionalAgents = (agents || [])
+      .filter(key => !UNIVERSAL_AGENTS.has(key) && !SKILL_UNSUPPORTED.has(key))
+      .map(key => AGENT_NAME_MAP[key] || key);
+
+    let cmd: string;
+    if (additionalAgents.length > 0) {
+      // Any -a command will also copy to ~/.agents/skills/ (Universal coverage)
+      cmd = `npx skills add "${source}" -s ${skill} -a ${additionalAgents.join(',')} -g -y`;
+    } else {
+      // Fallback: only install to ~/.agents/skills/ for Universal agents
+      cmd = `npx skills add "${source}" -s ${skill} -a universal -g -y`;
+    }
+
+    let stdout = '';
+    let stderr = '';
+    try {
+      stdout = execSync(cmd, {
+        encoding: 'utf-8',
+        timeout: 30_000,
+        env: { ...process.env, NODE_ENV: 'production' },
+        stdio: 'pipe',
+      });
+    } catch (err: unknown) {
+      const e = err as { stdout?: string; stderr?: string; message?: string };
+      stdout = e.stdout || '';
+      stderr = e.stderr || e.message || 'Unknown error';
+      return NextResponse.json({
+        ok: false,
+        skill,
+        agents: additionalAgents,
+        cmd,
+        stdout,
+        stderr,
+      });
+    }
+
+    return NextResponse.json({
+      ok: true,
+      skill,
+      agents: additionalAgents,
+      cmd,
+      stdout: stdout.trim(),
+    });
+  } catch (e) {
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : String(e) },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/setup/route.ts

@@ -90,9 +90,10 @@ export async function POST(req: NextRequest) {
     // Use the same resolved values that will actually be written to config
     const resolvedAuthToken   = authToken   ?? current.authToken   ?? '';
     const resolvedWebPassword = webPassword ?? '';
-    // Only compute needsRestart for re-onboard (setupPending=true means first-time setup)
+    // First-time onboard always needs restart (temporary setup port → user's chosen port).
+    // Re-onboard only needs restart if port/path/auth/password actually changed.
     const isFirstTime = current.setupPending === true || !current.mindRoot;
-    const needsRestart = !isFirstTime && (
+    const needsRestart = isFirstTime || (
       webPort              !== (current.port      ?? 3000) ||
       mcpPortNum           !== (current.mcpPort   ?? 8787) ||
       resolvedRoot         !== (current.mindRoot  || '')    ||
@@ -101,6 +102,7 @@ export async function POST(req: NextRequest) {
     );
 
     // Build config
+    const disabledSkills = body.template === 'zh' ? ['mindos'] : ['mindos-zh'];
     const config: ServerSettings = {
       ai: ai ?? current.ai,
       mindRoot: resolvedRoot,
@@ -110,6 +112,7 @@ export async function POST(req: NextRequest) {
       webPassword: webPassword ?? '',
       startMode: current.startMode,
       setupPending: false,  // clear the flag
+      disabledSkills,
     };
 
     writeSettings(config);

package/app/app/view/[...path]/ViewPageClient.tsx

@@ -8,6 +8,7 @@ import MarkdownView from '@/components/MarkdownView';
 import JsonView from '@/components/JsonView';
 import CsvView from '@/components/CsvView';
 import Backlinks from '@/components/Backlinks';
+import { useRendererState } from '@/lib/renderers/useRendererState';
 import Breadcrumb from '@/components/Breadcrumb';
 import MarkdownEditor, { MdViewMode } from '@/components/MarkdownEditor';
 import TableOfContents from '@/components/TableOfContents';
@@ -45,22 +46,7 @@ export default function ViewPageClient({
     () => false,
   );
 
-  const useRaw = useSyncExternalStore(
-    (onStoreChange) => {
-      const listener = () => onStoreChange();
-      window.addEventListener('storage', listener);
-      window.addEventListener('mindos-use-raw-change', listener);
-      return () => {
-        window.removeEventListener('storage', listener);
-        window.removeEventListener('mindos-use-raw-change', listener);
-      };
-    },
-    () => {
-      const saved = localStorage.getItem('mindos-use-raw');
-      return saved !== null ? saved === 'true' : false;
-    },
-    () => false,
-  );
+  const [useRaw, setUseRaw] = useRendererState<boolean>('_raw', filePath, false);
   const router = useRouter();
   const [editing, setEditing] = useState(initialEditing || content === '');
   const [editContent, setEditContent] = useState(content);
@@ -81,10 +67,8 @@ export default function ViewPageClient({
   const effectiveUseRaw = hydrated ? useRaw : false;
 
   const handleToggleRaw = useCallback(() => {
-    const next = !useRaw;
-    localStorage.setItem('mindos-use-raw', String(next));
-    window.dispatchEvent(new Event('mindos-use-raw-change'));
-  }, [useRaw]);
+    setUseRaw(prev => !prev);
+  }, [setUseRaw]);
 
   const renderer = resolveRenderer(filePath, extension);
   const isCsv = extension === 'csv';

package/app/components/SetupWizard.tsx

@@ -4,7 +4,7 @@ import { useState, useEffect, useCallback, useRef } from 'react';
 import {
   Sparkles, Globe, BookOpen, FileText, Copy, Check, RefreshCw,
   Loader2, ChevronLeft, ChevronRight, AlertTriangle, CheckCircle2,
-  XCircle, Zap, Brain, SkipForward,
+  XCircle, Zap, Brain, SkipForward, Info,
 } from 'lucide-react';
 import { useLocale } from '@/lib/LocaleContext';
 import { Field, Input, Select, ApiKeyInput } from '@/components/settings/Primitives';
@@ -39,12 +39,16 @@ interface AgentEntry {
   installed: boolean;
   hasProjectScope: boolean;
   hasGlobalScope: boolean;
+  preferredTransport: 'stdio' | 'http';
 }
 
 type AgentInstallState = 'pending' | 'installing' | 'ok' | 'error';
 interface AgentInstallStatus {
   state: AgentInstallState;
   message?: string;
+  transport?: string;
+  verified?: boolean;
+  verifyError?: string;
 }
 
 const TEMPLATES: Array<{ id: Template; icon: React.ReactNode; dirs: string[] }> = [
@@ -469,7 +473,7 @@ function Step3({
         <p className="text-xs" style={{ color: 'var(--muted-foreground)' }}>{s.portVerifyHint}</p>
       )}
       <p className="text-xs flex items-center gap-1.5" style={{ color: 'var(--muted-foreground)' }}>
-        <AlertTriangle size={12} /> {s.portRestartWarning}
+        <Info size={12} /> {s.portRestartWarning}
       </p>
     </div>
   );
@@ -479,19 +483,20 @@ function Step3({
 function Step5({
   agents, agentsLoading, selectedAgents, setSelectedAgents,
   agentTransport, setAgentTransport, agentScope, setAgentScope,
-  agentStatuses, s, settingsMcp,
+  agentStatuses, s, settingsMcp, template,
 }: {
   agents: AgentEntry[];
   agentsLoading: boolean;
   selectedAgents: Set<string>;
   setSelectedAgents: React.Dispatch<React.SetStateAction<Set<string>>>;
-  agentTransport: 'stdio' | 'http';
-  setAgentTransport: (v: 'stdio' | 'http') => void;
+  agentTransport: 'auto' | 'stdio' | 'http';
+  setAgentTransport: (v: 'auto' | 'stdio' | 'http') => void;
   agentScope: 'global' | 'project';
   setAgentScope: (v: 'global' | 'project') => void;
   agentStatuses: Record<string, AgentInstallStatus>;
   s: ReturnType<typeof useLocale>['t']['setup'];
   settingsMcp: ReturnType<typeof useLocale>['t']['settings']['mcp'];
+  template: Template;
 }) {
   const toggleAgent = (key: string) => {
     setSelectedAgents(prev => {
@@ -501,6 +506,11 @@ function Step5({
     });
   };
 
+  const getEffectiveTransport = (agent: AgentEntry) => {
+    if (agentTransport === 'auto') return agent.preferredTransport;
+    return agentTransport;
+  };
+
   const getStatusBadge = (key: string, installed: boolean) => {
     const st = agentStatuses[key];
     if (st) {
@@ -567,13 +577,24 @@ function Step5({
                   disabled={agentStatuses[agent.key]?.state === 'installing'}
                 />
                 <span className="text-sm flex-1" style={{ color: 'var(--foreground)' }}>{agent.name}</span>
+                <span className="text-[10px] px-1.5 py-0.5 rounded font-mono"
+                  style={{ background: 'rgba(100,100,120,0.08)', color: 'var(--muted-foreground)' }}>
+                  {getEffectiveTransport(agent)}
+                </span>
                 {getStatusBadge(agent.key, agent.installed)}
               </label>
             ))}
           </div>
+          {/* Skill auto-install hint */}
+          <div className="flex items-center gap-2 px-3 py-2 rounded-lg text-xs"
+            style={{ background: 'rgba(100,100,120,0.06)', color: 'var(--muted-foreground)' }}>
+            <Brain size={13} className="shrink-0" />
+            <span>{s.skillAutoHint(template === 'zh' ? 'mindos-zh' : 'mindos')}</span>
+          </div>
           <div className="grid grid-cols-2 gap-4">
             <Field label={s.agentTransport}>
-              <Select value={agentTransport} onChange={e => setAgentTransport(e.target.value as 'stdio' | 'http')}>
+              <Select value={agentTransport} onChange={e => setAgentTransport(e.target.value as 'auto' | 'stdio' | 'http')}>
+                <option value="auto">{s.agentTransportAuto}</option>
                 <option value="stdio">{settingsMcp.transportStdio}</option>
                 <option value="http">{settingsMcp.transportHttp}</option>
               </Select>
@@ -660,6 +681,7 @@ function RestartBlock({ s, newPort }: { s: ReturnType<typeof useLocale>['t']['se
 // ─── Step 6: Review ───────────────────────────────────────────────────────────
 function Step6({
   state, selectedAgents, agentStatuses, onRetryAgent, error, needsRestart, maskKey, s,
+  skillInstallResult,
 }: {
   state: SetupState;
   selectedAgents: Set<string>;
@@ -669,7 +691,9 @@ function Step6({
   needsRestart: boolean;
   maskKey: (key: string) => string;
   s: ReturnType<typeof useLocale>['t']['setup'];
+  skillInstallResult: { ok?: boolean; skill?: string; error?: string } | null;
 }) {
+  const skillName = state.template === 'zh' ? 'mindos-zh' : 'mindos';
   const rows: [string, string][] = [
     [s.kbPath, state.mindRoot],
     [s.template, state.template || '—'],
@@ -683,9 +707,11 @@ function Step6({
     [s.authToken, state.authToken || '—'],
     [s.webPassword, state.webPassword ? '••••••••' : '(none)'],
     [s.agentToolsTitle, selectedAgents.size > 0 ? Array.from(selectedAgents).join(', ') : '—'],
+    [s.skillLabel, skillName],
   ];
 
   const failedAgents = Object.entries(agentStatuses).filter(([, v]) => v.state === 'error');
+  const successAgents = Object.entries(agentStatuses).filter(([, v]) => v.state === 'ok');
 
   return (
     <div className="space-y-5">
@@ -702,6 +728,43 @@ function Step6({
           </div>
         ))}
       </div>
+
+      {/* Agent verification results */}
+      {successAgents.length > 0 && (
+        <div className="space-y-1.5">
+          <p className="text-xs font-medium" style={{ color: 'var(--muted-foreground)' }}>{s.reviewInstallResults}</p>
+          {successAgents.map(([key, st]) => (
+            <div key={key} className="flex items-center gap-2 text-xs px-3 py-1.5 rounded"
+              style={{ background: 'rgba(34,197,94,0.06)' }}>
+              <CheckCircle2 size={11} className="text-green-500 shrink-0" />
+              <span style={{ color: 'var(--foreground)' }}>{key}</span>
+              <span className="font-mono text-[10px] px-1 py-0.5 rounded"
+                style={{ background: 'rgba(100,100,120,0.08)', color: 'var(--muted-foreground)' }}>
+                {st.transport || 'stdio'}
+              </span>
+              {st.transport === 'http' ? (
+                st.verified ? (
+                  <span className="text-[10px] px-1.5 py-0.5 rounded"
+                    style={{ background: 'rgba(34,197,94,0.12)', color: '#22c55e' }}>
+                    {s.agentVerified}
+                  </span>
+                ) : (
+                  <span className="text-[10px] px-1.5 py-0.5 rounded"
+                    style={{ background: 'rgba(239,168,68,0.12)', color: '#f59e0b' }}
+                    title={st.verifyError}>
+                    {s.agentUnverified}
+                  </span>
+                )
+              ) : (
+                <span className="text-[10px]" style={{ color: 'var(--muted-foreground)' }}>
+                  {s.agentVerifyNote}
+                </span>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
       {failedAgents.length > 0 && (
         <div className="p-3 rounded-lg space-y-2" style={{ background: 'rgba(239,68,68,0.08)' }}>
           <p className="text-xs font-medium" style={{ color: '#ef4444' }}>{s.reviewInstallResults}</p>
@@ -723,6 +786,22 @@ function Step6({
           <p className="text-xs" style={{ color: 'var(--muted-foreground)' }}>{s.agentFailureNote}</p>
         </div>
       )}
+      {/* Skill install result */}
+      {skillInstallResult && (
+        <div className={`flex items-center gap-2 text-xs px-3 py-2 rounded-lg ${
+          skillInstallResult.ok ? '' : ''
+        }`} style={{
+          background: skillInstallResult.ok ? 'rgba(34,197,94,0.06)' : 'rgba(239,68,68,0.06)',
+        }}>
+          {skillInstallResult.ok ? (
+            <><CheckCircle2 size={11} className="text-green-500 shrink-0" />
+            <span style={{ color: 'var(--foreground)' }}>{s.skillInstalled} — {skillInstallResult.skill}</span></>
+          ) : (
+            <><XCircle size={11} className="text-red-500 shrink-0" />
+            <span style={{ color: '#ef4444' }}>{s.skillFailed}{skillInstallResult.error ? `: ${skillInstallResult.error}` : ''}</span></>
+          )}
+        </div>
+      )}
       {error && (
         <div className="p-3 rounded-lg text-sm text-red-500" style={{ background: 'rgba(239,68,68,0.1)' }}>
           {s.completeFailed}: {error}
@@ -798,9 +877,10 @@ export default function SetupWizard() {
   const [agents, setAgents] = useState<AgentEntry[]>([]);
   const [agentsLoading, setAgentsLoading] = useState(false);
   const [selectedAgents, setSelectedAgents] = useState<Set<string>>(new Set());
-  const [agentTransport, setAgentTransport] = useState<'stdio' | 'http'>('stdio');
+  const [agentTransport, setAgentTransport] = useState<'auto' | 'stdio' | 'http'>('auto');
   const [agentScope, setAgentScope] = useState<'global' | 'project'>('global');
   const [agentStatuses, setAgentStatuses] = useState<Record<string, AgentInstallStatus>>({});
+  const [skillInstallResult, setSkillInstallResult] = useState<{ ok?: boolean; skill?: string; error?: string } | null>(null);
 
   // Load existing config as defaults on mount, generate token if none exists
   useEffect(() => {
@@ -970,7 +1050,13 @@ export default function SetupWizard() {
       setAgentStatuses(initialStatuses);
 
       try {
-        const agentsPayload = Array.from(selectedAgents).map(key => ({ key, scope: agentScope }));
+        const agentsPayload = Array.from(selectedAgents).map(key => {
+          const agent = agents.find(a => a.key === key);
+          const effectiveTransport = agentTransport === 'auto'
+            ? (agent?.preferredTransport || 'stdio')
+            : agentTransport;
+          return { key, scope: agentScope, transport: effectiveTransport };
+        });
         const res = await fetch('/api/mcp/install', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
@@ -984,8 +1070,14 @@ export default function SetupWizard() {
         const data = await res.json();
         if (data.results) {
           const updated: Record<string, AgentInstallStatus> = {};
-          for (const r of data.results as Array<{ agent: string; status: string; message?: string }>) {
-            updated[r.agent] = { state: r.status === 'ok' ? 'ok' : 'error', message: r.message };
+          for (const r of data.results as Array<{ agent: string; status: string; message?: string; transport?: string; verified?: boolean; verifyError?: string }>) {
+            updated[r.agent] = {
+              state: r.status === 'ok' ? 'ok' : 'error',
+              message: r.message,
+              transport: r.transport,
+              verified: r.verified,
+              verifyError: r.verifyError,
+            };
           }
           setAgentStatuses(updated);
         }
@@ -996,6 +1088,20 @@ export default function SetupWizard() {
       }
     }
 
+    // 3. Install skill to agents
+    const skillName = state.template === 'zh' ? 'mindos-zh' : 'mindos';
+    try {
+      const skillRes = await fetch('/api/mcp/install-skill', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ skill: skillName, agents: Array.from(selectedAgents) }),
+      });
+      const skillData = await skillRes.json();
+      setSkillInstallResult(skillData);
+    } catch {
+      setSkillInstallResult({ error: 'Failed to install skill' });
+    }
+
     setSubmitting(false);
     setCompleted(true);
 
@@ -1009,11 +1115,15 @@ export default function SetupWizard() {
   const retryAgent = useCallback(async (key: string) => {
     setAgentStatuses(prev => ({ ...prev, [key]: { state: 'installing' } }));
     try {
+      const agent = agents.find(a => a.key === key);
+      const effectiveTransport = agentTransport === 'auto'
+        ? (agent?.preferredTransport || 'stdio')
+        : agentTransport;
       const res = await fetch('/api/mcp/install', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          agents: [{ key, scope: agentScope }],
+          agents: [{ key, scope: agentScope, transport: effectiveTransport }],
           transport: agentTransport,
           url: `http://localhost:${state.mcpPort}/mcp`,
           token: state.authToken || undefined,
@@ -1021,13 +1131,22 @@ export default function SetupWizard() {
       });
       const data = await res.json();
       if (data.results?.[0]) {
-        const r = data.results[0] as { agent: string; status: string; message?: string };
-        setAgentStatuses(prev => ({ ...prev, [key]: { state: r.status === 'ok' ? 'ok' : 'error', message: r.message } }));
+        const r = data.results[0] as { agent: string; status: string; message?: string; transport?: string; verified?: boolean; verifyError?: string };
+        setAgentStatuses(prev => ({
+          ...prev,
+          [key]: {
+            state: r.status === 'ok' ? 'ok' : 'error',
+            message: r.message,
+            transport: r.transport,
+            verified: r.verified,
+            verifyError: r.verifyError,
+          },
+        }));
       }
     } catch {
       setAgentStatuses(prev => ({ ...prev, [key]: { state: 'error' } }));
     }
-  }, [agentScope, agentTransport, state.mcpPort, state.authToken]);
+  }, [agents, agentScope, agentTransport, state.mcpPort, state.authToken]);
 
   return (
     <div className="fixed inset-0 z-50 flex items-center justify-center overflow-y-auto"
@@ -1075,6 +1194,7 @@ export default function SetupWizard() {
             agentTransport={agentTransport} setAgentTransport={setAgentTransport}
             agentScope={agentScope} setAgentScope={setAgentScope}
             agentStatuses={agentStatuses} s={s} settingsMcp={t.settings.mcp}
+            template={state.template}
           />
         )}
         {step === 5 && (
@@ -1083,6 +1203,7 @@ export default function SetupWizard() {
             agentStatuses={agentStatuses} onRetryAgent={retryAgent}
             error={error} needsRestart={needsRestart}
             maskKey={maskKey} s={s}
+            skillInstallResult={skillInstallResult}
           />
         )}
 

package/app/components/renderers/config/manifest.ts

@@ -8,6 +8,7 @@ export const manifest: RendererDefinition = {
   icon: '🧩',
   tags: ['config', 'json', 'settings', 'schema'],
   builtin: true,
+  core: true,
   entryPath: 'CONFIG.json',
   match: ({ filePath, extension }) => extension === 'json' && /(^|\/)CONFIG\.json$/i.test(filePath),
   load: () => import('./ConfigRenderer').then(m => ({ default: m.ConfigRenderer })),

package/app/components/renderers/csv/CsvRenderer.tsx

@@ -1,10 +1,11 @@
 'use client';
 
-import { useState, useMemo, useCallback, useEffect } from 'react';
+import { useMemo, useCallback, useState } from 'react';
 import { LayoutGrid, Columns, Table2, Settings2 } from 'lucide-react';
 import type { RendererContext } from '@/lib/renderers/registry';
 import type { ViewType, CsvConfig } from './types';
-import { defaultConfig, loadConfig, saveConfig, parseCSV } from './types';
+import { defaultConfig, parseCSV } from './types';
+import { useRendererState } from '@/lib/renderers/useRendererState';
 import { TableView } from './TableView';
 import { GalleryView } from './GalleryView';
 import { BoardView } from './BoardView';
@@ -18,21 +19,14 @@ const VIEW_TABS: { id: ViewType; icon: React.ReactNode; label: string }[] = [
 
 export function CsvRenderer({ filePath, content, saveAction }: RendererContext) {
   const { headers, rows } = useMemo(() => parseCSV(content), [content]);
-  const [cfg, setCfg] = useState<CsvConfig>(() => defaultConfig(headers));
-  const [configLoaded, setConfigLoaded] = useState(false);
+  const def = useMemo(() => defaultConfig(headers), [headers]);
+  const [cfg, setCfg] = useRendererState<CsvConfig>('csv', filePath, def);
   const [showConfig, setShowConfig] = useState(false);
 
-  useEffect(() => {
-    setCfg(loadConfig(filePath, headers));
-    setConfigLoaded(true);
-  }, [filePath]); // eslint-disable-line react-hooks/exhaustive-deps
-
   const updateConfig = useCallback((next: CsvConfig) => {
     setCfg(next);
-    saveConfig(filePath, next);
-  }, [filePath]);
+  }, [setCfg]);
 
-  if (!configLoaded) return null;
   const view = cfg.activeView;
 
   return (

package/app/components/renderers/csv/manifest.ts

@@ -8,6 +8,7 @@ export const manifest: RendererDefinition = {
   icon: '📊',
   tags: ['csv', 'table', 'gallery', 'board', 'data'],
   builtin: true,
+  core: true,
   entryPath: 'Resources/Products.csv',
   match: ({ extension, filePath }) => extension === 'csv' && !/\bTODO\b/i.test(filePath),
   load: () => import('./CsvRenderer').then(m => ({ default: m.CsvRenderer })),

package/app/components/renderers/todo/manifest.ts

@@ -8,6 +8,7 @@ export const manifest: RendererDefinition = {
   icon: '✅',
   tags: ['productivity', 'tasks', 'markdown'],
   builtin: true,
+  core: true,
   entryPath: 'TODO.md',
   match: ({ filePath }) => /\bTODO\b.*\.(md|csv)$/i.test(filePath),
   load: () => import('./TodoRenderer').then(m => ({ default: m.TodoRenderer })),