@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/lib/parsing/parse-todos.ts

@@ -0,0 +1,325 @@
+/**
+ * Todo markdown parser and line-level operations.
+ * Pure functions — no React, no side effects.
+ */
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type TodoStatus = 'todo' | 'in-progress' | 'done';
+export type Priority = 'P0' | 'P1' | 'P2' | null;
+export type DateUrgency = 'overdue' | 'today' | 'soon' | 'future' | null;
+
+export interface TodoMeta {
+  priority: Priority;
+  dueDate: string | null;
+  tags: string[];
+}
+
+export interface TodoItem {
+  id: string;
+  text: string;
+  rawText: string;
+  status: TodoStatus;
+  indent: number;
+  lineIndex: number;
+  section: string;
+  children: TodoItem[];
+  meta: TodoMeta;
+}
+
+export interface SectionMeta {
+  items: TodoItem[];
+  lastLineIndex: number;
+  headingLineIndex: number;
+}
+
+export interface FilterState {
+  priority: Priority | 'all';
+  tag: string | 'all';
+  status: TodoStatus | 'all';
+}
+
+// ─── Regex constants ─────────────────────────────────────────────────────────
+
+const H2_SECTION_RE = /^##\s+(.+)/;
+const H1_RE = /^#\s+/;
+const H3_PLUS_RE = /^#{3,6}\s+(.+)/;
+const TODO_RE = /^(\s*)- \[([ xX~])\]\s+(.*)$/;
+const PRIORITY_RE = /`(P[012])`/;
+const DATE_RE = /`(\d{4}-\d{2}-\d{2}|\d{2}-\d{2})`/;
+const TAG_RE = /#([a-zA-Z\u4e00-\u9fff][\w\u4e00-\u9fff-]*)/g;
+
+// ─── Metadata extraction ─────────────────────────────────────────────────────
+
+export function extractMeta(rawText: string): { cleanText: string; meta: TodoMeta } {
+  let text = rawText;
+  let priority: Priority = null;
+  let dueDate: string | null = null;
+  const tags: string[] = [];
+
+  const pMatch = text.match(PRIORITY_RE);
+  if (pMatch) {
+    priority = pMatch[1] as Priority;
+    text = text.replace(PRIORITY_RE, '').trim();
+  }
+
+  const dMatch = text.match(DATE_RE);
+  if (dMatch) {
+    dueDate = dMatch[1];
+    text = text.replace(DATE_RE, '').trim();
+  }
+
+  let tMatch: RegExpExecArray | null;
+  const tagRe = new RegExp(TAG_RE.source, 'g');
+  while ((tMatch = tagRe.exec(text)) !== null) {
+    tags.push(tMatch[1]);
+  }
+  if (tags.length > 0) {
+    text = text.replace(/#[a-zA-Z\u4e00-\u9fff][\w\u4e00-\u9fff-]*/g, '').trim();
+  }
+
+  text = text.replace(/\*\*(.*?)\*\*/g, '$1').trim();
+
+  return { cleanText: text, meta: { priority, dueDate, tags } };
+}
+
+// ─── Status parsing ──────────────────────────────────────────────────────────
+
+export function parseStatus(checkChar: string): TodoStatus {
+  if (checkChar === '~') return 'in-progress';
+  if (checkChar.toLowerCase() === 'x') return 'done';
+  return 'todo';
+}
+
+// ─── Core parser ─────────────────────────────────────────────────────────────
+
+export function parseMarkdownTodos(raw: string): {
+  sections: Record<string, SectionMeta>;
+  lines: string[];
+  sectionOrder: string[];
+} {
+  const lines = raw.split('\n');
+  let currentSection = 'General';
+  const sections: Record<string, SectionMeta> = {};
+  const sectionOrder: string[] = [];
+  const stack: TodoItem[] = [];
+
+  let inFrontmatter = false;
+  let frontmatterDone = false;
+
+  lines.forEach((line, lineIndex) => {
+    if (!frontmatterDone) {
+      if (lineIndex === 0 && line.trim() === '---') { inFrontmatter = true; return; }
+      if (inFrontmatter) {
+        if (line.trim() === '---') { inFrontmatter = false; frontmatterDone = true; }
+        return;
+      }
+      frontmatterDone = true;
+    }
+
+    if (H1_RE.test(line)) return;
+
+    const h2Match = line.match(H2_SECTION_RE);
+    if (h2Match) {
+      currentSection = h2Match[1].replace(/^[^\w\s\u4e00-\u9fff]+\s*/, '').trim();
+      if (!sections[currentSection]) {
+        sections[currentSection] = { items: [], lastLineIndex: -1, headingLineIndex: lineIndex };
+        sectionOrder.push(currentSection);
+      }
+      return;
+    }
+
+    if (H3_PLUS_RE.test(line)) return;
+
+    const todoMatch = line.match(TODO_RE);
+    if (!todoMatch) return;
+
+    const [, indentStr, checkChar, rawText] = todoMatch;
+    const indent = Math.floor(indentStr.length / 2);
+    const status = parseStatus(checkChar);
+    const { cleanText, meta } = extractMeta(rawText);
+
+    const item: TodoItem = {
+      id: `${lineIndex}`,
+      text: cleanText,
+      rawText,
+      status,
+      indent,
+      lineIndex,
+      section: currentSection,
+      children: [],
+      meta,
+    };
+
+    while (stack.length > 0 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+
+    if (!sections[currentSection]) {
+      sections[currentSection] = { items: [], lastLineIndex: -1, headingLineIndex: -1 };
+      sectionOrder.push(currentSection);
+    }
+
+    if (stack.length > 0) {
+      stack[stack.length - 1].children.push(item);
+    } else {
+      sections[currentSection].items.push(item);
+    }
+
+    sections[currentSection].lastLineIndex = Math.max(
+      sections[currentSection].lastLineIndex,
+      lineIndex,
+    );
+
+    stack.push(item);
+  });
+
+  return { sections, lines, sectionOrder };
+}
+
+// ─── Line operations ─────────────────────────────────────────────────────────
+
+function applyLines(lines: string[], ops: (l: string[]) => void): string {
+  const next = [...lines];
+  ops(next);
+  return next.join('\n');
+}
+
+function statusChar(s: TodoStatus): string {
+  if (s === 'done') return 'x';
+  if (s === 'in-progress') return '~';
+  return ' ';
+}
+
+export function setStatusInLines(lines: string[], lineIndex: number, status: TodoStatus): string {
+  return applyLines(lines, (l) => {
+    l[lineIndex] = l[lineIndex].replace(/- \[[ xX~]\]/, `- [${statusChar(status)}]`);
+  });
+}
+
+export function renameInLines(lines: string[], lineIndex: number, newText: string): string {
+  return applyLines(lines, (l) => {
+    l[lineIndex] = l[lineIndex].replace(/(- \[[ xX~]\]\s*)(.*)$/, `$1${newText}`);
+  });
+}
+
+export function deleteInLines(lines: string[], lineIndex: number): string {
+  return applyLines(lines, (l) => {
+    l.splice(lineIndex, 1);
+  });
+}
+
+export function addInLines(lines: string[], afterLineIndex: number, text: string): string {
+  return applyLines(lines, (l) => {
+    const insertAt = afterLineIndex < 0 ? l.length : afterLineIndex + 1;
+    l.splice(insertAt, 0, `- [ ] ${text}`);
+  });
+}
+
+export function cycleStatus(current: TodoStatus): TodoStatus {
+  if (current === 'todo') return 'in-progress';
+  if (current === 'in-progress') return 'done';
+  return 'todo';
+}
+
+// ─── Date helpers ────────────────────────────────────────────────────────────
+
+export function resolveDate(dateStr: string | null): Date | null {
+  if (!dateStr) return null;
+  const now = new Date();
+  if (/^\d{2}-\d{2}$/.test(dateStr)) {
+    return new Date(`${now.getFullYear()}-${dateStr}`);
+  }
+  return new Date(dateStr);
+}
+
+export function dateUrgency(dateStr: string | null): DateUrgency {
+  const d = resolveDate(dateStr);
+  if (!d || isNaN(d.getTime())) return null;
+  const now = new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const target = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  const diff = (target.getTime() - today.getTime()) / (1000 * 60 * 60 * 24);
+  if (diff < 0) return 'overdue';
+  if (diff === 0) return 'today';
+  if (diff <= 3) return 'soon';
+  return 'future';
+}
+
+// ─── Counting ────────────────────────────────────────────────────────────────
+
+export function countByStatus(items: TodoItem[], status: TodoStatus): number {
+  return items.reduce((n, item) => n + (item.status === status ? 1 : 0) + countByStatus(item.children, status), 0);
+}
+
+export function countTotal(items: TodoItem[]): number {
+  return items.reduce((n, item) => n + 1 + countTotal(item.children), 0);
+}
+
+export function collectAllTags(sections: Record<string, SectionMeta>): string[] {
+  const tagSet = new Set<string>();
+  function walk(items: TodoItem[]) {
+    for (const item of items) {
+      for (const tag of item.meta.tags) tagSet.add(tag);
+      walk(item.children);
+    }
+  }
+  for (const meta of Object.values(sections)) walk(meta.items);
+  return [...tagSet].sort();
+}
+
+export function collectAllPriorities(sections: Record<string, SectionMeta>): Priority[] {
+  const pSet = new Set<Priority>();
+  function walk(items: TodoItem[]) {
+    for (const item of items) {
+      if (item.meta.priority) pSet.add(item.meta.priority);
+      walk(item.children);
+    }
+  }
+  for (const meta of Object.values(sections)) walk(meta.items);
+  const order: Priority[] = ['P0', 'P1', 'P2'];
+  return order.filter(p => pSet.has(p));
+}
+
+// ─── Filter helpers ──────────────────────────────────────────────────────────
+
+export function matchesFilter(item: TodoItem, filters: FilterState): boolean {
+  if (filters.status !== 'all' && item.status !== filters.status) return false;
+  if (filters.priority !== 'all' && item.meta.priority !== filters.priority) return false;
+  if (filters.tag !== 'all' && !item.meta.tags.includes(filters.tag)) return false;
+  return true;
+}
+
+export function hasMatchingDescendant(item: TodoItem, filters: FilterState): boolean {
+  if (matchesFilter(item, filters)) return true;
+  return item.children.some(c => hasMatchingDescendant(c, filters));
+}
+
+// ─── Style constants ─────────────────────────────────────────────────────────
+
+export const PRIORITY_STYLES: Record<string, { bg: string; text: string; border: string }> = {
+  P0: { bg: 'bg-red-500/10', text: 'text-red-500', border: 'border-red-500/20' },
+  P1: { bg: 'bg-amber-500/10', text: 'text-amber-500', border: 'border-amber-500/20' },
+  P2: { bg: 'bg-blue-500/10', text: 'text-blue-500', border: 'border-blue-500/20' },
+};
+
+export const DATE_STYLES: Record<string, { text: string; bg: string }> = {
+  overdue: { text: 'text-red-500', bg: 'bg-red-500/10' },
+  today:   { text: 'text-amber-500', bg: 'bg-amber-500/10' },
+  soon:    { text: 'text-amber-400', bg: 'bg-amber-400/5' },
+  future:  { text: 'text-muted-foreground', bg: '' },
+};
+
+const SECTION_STYLES: Record<string, { dot: string; label: string }> = {
+  'TODAY':       { dot: 'bg-red-400',    label: 'text-red-400' },
+  'This Week':   { dot: 'bg-orange-400', label: 'text-orange-400' },
+  'Workflows':   { dot: 'bg-amber-400',  label: 'text-amber-400' },
+  'Backlog':     { dot: 'bg-blue-400',   label: 'text-blue-400' },
+  'Done':        { dot: 'bg-emerald-400', label: 'text-emerald-400' },
+  'Maintenance': { dot: 'bg-zinc-400',   label: 'text-zinc-400' },
+};
+
+export function sectionStyle(name: string) {
+  const key = Object.keys(SECTION_STYLES).find(k => name.includes(k));
+  return key ? SECTION_STYLES[key] : { dot: 'bg-zinc-500', label: 'text-zinc-400' };
+}

package/_standalone/lib/pdf-extract.ts

@@ -0,0 +1,37 @@
+function uint8ToBase64(bytes: Uint8Array): string {
+  let binary = '';
+  const chunkSize = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+}
+
+export async function extractPdfText(file: File): Promise<string> {
+  const buffer = await file.arrayBuffer();
+  const dataBase64 = uint8ToBase64(new Uint8Array(buffer));
+
+  const res = await fetch('/api/extract-pdf', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: file.name, dataBase64 }),
+  });
+
+  let payload: { text?: string; extracted?: 'success' | 'empty' | 'error'; extractionError?: string; error?: string } = {};
+  try {
+    payload = await res.json();
+  } catch {
+    // ignore JSON parse error
+  }
+
+  if (!res.ok) {
+    throw new Error(payload.error || `PDF extraction failed (${res.status})`);
+  }
+
+  if (payload.extracted === 'error') {
+    throw new Error(payload.extractionError || 'Failed to parse PDF');
+  }
+
+  return payload.extracted === 'success' ? (payload.text || '') : '';
+}

package/_standalone/lib/pi-integration/session-store.ts

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { SessionManager } from '@mariozechner/pi-coding-agent';
+
+function getSessionsRoot(): string {
+  return path.join(os.homedir(), '.mindos', 'sessions');
+}
+
+export function getSessionDir(sessionId: string): string {
+  const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');
+  return path.join(getSessionsRoot(), safe);
+}
+
+export function sessionDirExists(sessionId: string): boolean {
+  const sessionDir = getSessionDir(sessionId);
+  if (!fs.existsSync(sessionDir)) return false;
+  // Check if there's at least one .jsonl file
+  try {
+    return fs.readdirSync(sessionDir).some((f) => f.endsWith('.jsonl'));
+  } catch {
+    return false;
+  }
+}
+
+export function getOrCreateSessionManager(
+  sessionId: string | undefined,
+  cwd: string,
+): SessionManager {
+  if (!sessionId) {
+    return SessionManager.inMemory(cwd);
+  }
+
+  const sessionDir = getSessionDir(sessionId);
+
+  try {
+    fs.mkdirSync(sessionDir, { recursive: true });
+
+    if (sessionDirExists(sessionId)) {
+      // Reuse the most recent session in this directory
+      return SessionManager.continueRecent(cwd, sessionDir);
+    }
+
+    // Brand new — create fresh session file
+    return SessionManager.create(cwd, sessionDir);
+  } catch (error) {
+    console.error(`[session-store] Failed to open/create session ${sessionId}, falling back to inMemory:`, error);
+    return SessionManager.inMemory(cwd);
+  }
+}
+
+export function deleteSessionDir(sessionId: string): boolean {
+  const sessionDir = getSessionDir(sessionId);
+  if (!fs.existsSync(sessionDir)) return false;
+  try {
+    fs.rmSync(sessionDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    console.error(`[session-store] Failed to delete session dir ${sessionDir}:`, error);
+    return false;
+  }
+}

package/_standalone/lib/renderers/useRendererState.ts

@@ -0,0 +1,114 @@
+'use client';
+
+import { useSyncExternalStore, useCallback, useRef } from 'react';
+
+/**
+ * Unified per-file state hook for renderers.
+ *
+ * Each renderer stores its state under a namespaced localStorage key:
+ *   `mindos-renderer:{rendererId}:{filePath}`
+ *
+ * Usage:
+ *   const [cfg, setCfg] = useRendererState<CsvConfig>('csv', filePath, defaultCfg);
+ *
+ * The state is reactive — changes from other tabs/windows or from other
+ * components calling the setter will trigger a re-render via
+ * `useSyncExternalStore`.
+ */
+
+const CHANGE_EVENT = 'mindos-renderer-state-change';
+
+function storageKey(rendererId: string, filePath: string): string {
+  return `mindos-renderer:${rendererId}:${filePath}`;
+}
+
+export function useRendererState<T>(
+  rendererId: string,
+  filePath: string,
+  defaultValue: T,
+): [T, (value: T | ((prev: T) => T)) => void] {
+  const key = storageKey(rendererId, filePath);
+
+  // Cache parsed value to maintain referential stability for useSyncExternalStore.
+  // Without this, JSON.parse returns a new object on every getSnapshot call,
+  // causing Object.is to fail → infinite re-renders for non-primitive types.
+  const cacheRef = useRef<{ key: string; raw: string | null; parsed: T }>({ key, raw: null, parsed: defaultValue });
+
+  // Reset cache when key changes (different file or different renderer)
+  if (cacheRef.current.key !== key) {
+    cacheRef.current = { key, raw: null, parsed: defaultValue };
+  }
+
+  const state = useSyncExternalStore(
+    (onStoreChange) => {
+      const listener = () => onStoreChange();
+      window.addEventListener('storage', listener);
+      window.addEventListener(CHANGE_EVENT, listener);
+      return () => {
+        window.removeEventListener('storage', listener);
+        window.removeEventListener(CHANGE_EVENT, listener);
+      };
+    },
+    () => {
+      try {
+        const raw = localStorage.getItem(key);
+        if (raw === cacheRef.current.raw) return cacheRef.current.parsed;
+        if (raw === null) {
+          cacheRef.current = { key, raw: null, parsed: defaultValue };
+          return defaultValue;
+        }
+        const parsed = JSON.parse(raw) as T;
+        cacheRef.current = { key, raw, parsed };
+        return parsed;
+      } catch {
+        return defaultValue;
+      }
+    },
+    () => defaultValue,
+  );
+
+  const setState = useCallback(
+    (value: T | ((prev: T) => T)) => {
+      try {
+        const current = (() => {
+          try {
+            const raw = localStorage.getItem(key);
+            return raw !== null ? (JSON.parse(raw) as T) : defaultValue;
+          } catch {
+            return defaultValue;
+          }
+        })();
+        const next = typeof value === 'function' ? (value as (prev: T) => T)(current) : value;
+        const serialized = JSON.stringify(next);
+        localStorage.setItem(key, serialized);
+        // Update cache eagerly so the next getSnapshot returns stable ref
+        cacheRef.current = { key, raw: serialized, parsed: next };
+      } catch { /* ignore quota errors */ }
+      window.dispatchEvent(new Event(CHANGE_EVENT));
+    },
+    [key, defaultValue],
+  );
+
+  return [state, setState];
+}
+
+/**
+ * Non-hook helpers for reading/writing renderer state outside React components.
+ */
+export function getRendererState<T>(rendererId: string, filePath: string, defaultValue: T): T {
+  if (typeof window === 'undefined') return defaultValue;
+  try {
+    const raw = localStorage.getItem(storageKey(rendererId, filePath));
+    return raw !== null ? (JSON.parse(raw) as T) : defaultValue;
+  } catch {
+    return defaultValue;
+  }
+}
+
+export function setRendererState<T>(rendererId: string, filePath: string, value: T): void {
+  if (typeof window === 'undefined') return;
+  try {
+    localStorage.setItem(storageKey(rendererId, filePath), JSON.stringify(value));
+  } catch { /* ignore */ }
+  window.dispatchEvent(new Event(CHANGE_EVENT));
+}

package/_standalone/lib/settings-ai-client.ts

@@ -0,0 +1,36 @@
+/**
+ * Client-side mirror of "can /api/ask run?" using GET /api/settings payload.
+ * Must stay aligned with server `effectiveAiConfig()` provider + key resolution.
+ */
+import { PROVIDER_PRESETS, isProviderId, getApiKeyEnvVar } from './agent/providers';
+import { type Provider } from './custom-endpoints';
+
+export type SettingsJsonForAi = {
+  ai?: {
+    activeProvider?: string;
+    providers?: Provider[];
+  };
+  envOverrides?: Partial<Record<string, boolean>>;
+};
+
+export function isAiConfiguredForAsk(data: SettingsJsonForAi): boolean {
+  const providers = data.ai?.providers ?? [];
+  const activeId = data.ai?.activeProvider;
+  const env = data.envOverrides ?? {};
+
+  const current = activeId ? providers.find(p => p.id === activeId) : providers[0];
+  if (!current) return false;
+
+  // Has API key directly
+  if (current.apiKey && current.apiKey.length > 0) return true;
+
+  // Has env var override
+  const envVar = isProviderId(current.protocol) ? getApiKeyEnvVar(current.protocol) : undefined;
+  if (envVar && env[envVar]) return true;
+
+  // Has fallback key (e.g. Ollama)
+  const preset = isProviderId(current.protocol) ? PROVIDER_PRESETS[current.protocol] : undefined;
+  if (preset?.apiKeyFallback) return true;
+
+  return false;
+}

package/_standalone/lib/space-ai-init.ts

@@ -0,0 +1,66 @@
+import { apiFetch } from '@/lib/api';
+
+/**
+ * Check if AI is available by inspecting the active provider's API key.
+ */
+export async function checkAiAvailable(): Promise<boolean> {
+  try {
+    const data = await apiFetch<{
+      ai?: { provider?: string; providers?: Record<string, { apiKey?: string }> };
+    }>('/api/settings');
+    const provider = data.ai?.provider ?? '';
+    const providers = data.ai?.providers ?? {};
+    const active = providers[provider as keyof typeof providers];
+    return !!(active?.apiKey);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Trigger AI to generate README.md and INSTRUCTION.md for a space.
+ * Dispatches `mindos:ai-init` events consumed by SpaceInitToast.
+ * The call is fire-and-forget — returns immediately after starting the stream.
+ */
+export function triggerSpaceAiInit(
+  spaceName: string,
+  spacePath: string,
+  description = '',
+): void {
+  const isZh = typeof document !== 'undefined' && document.documentElement.lang === 'zh';
+  const prompt = isZh
+    ? `初始化新建的心智空间「${spaceName}」，路径为「${spacePath}/」。${description ? `描述：「${description}」。` : ''}两个文件均已存在模板，用 write_file 覆盖：\n1. 「${spacePath}/README.md」— 写入空间用途、结构概览、使用指南\n2. 「${spacePath}/INSTRUCTION.md」— 写入 AI Agent 在此空间中的行为规则和操作约定\n\n内容简洁实用，直接使用工具写入。`
+    : `Initialize the new Mind Space "${spaceName}" at "${spacePath}/". ${description ? `Description: "${description}". ` : ''}Both files already exist with templates — use write_file to overwrite:\n1. "${spacePath}/README.md" — write purpose, structure overview, usage guidelines\n2. "${spacePath}/INSTRUCTION.md" — write rules for AI agents operating in this space\n\nKeep content concise and actionable. Write files directly using tools.`;
+
+  window.dispatchEvent(new CustomEvent('mindos:ai-init', {
+    detail: { spaceName, spacePath, description, state: 'working' },
+  }));
+
+  fetch('/api/ask', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages: [{ role: 'user', content: prompt }],
+      currentFile: spacePath + '/INSTRUCTION.md',
+    }),
+  }).then(async (res) => {
+    if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+    const reader = res.body.getReader();
+    try {
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    window.dispatchEvent(new CustomEvent('mindos:ai-init', {
+      detail: { spacePath, state: 'done' },
+    }));
+    window.dispatchEvent(new Event('mindos:files-changed'));
+  }).catch(() => {
+    window.dispatchEvent(new CustomEvent('mindos:ai-init', {
+      detail: { spacePath, state: 'error' },
+    }));
+  });
+}

package/_standalone/lib/stores/McpStoreInit.tsx

@@ -0,0 +1,18 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useMcpStore } from '@/lib/stores/mcp-store';
+
+/**
+ * Thin component that initializes MCP store side-effects (polling, event listeners).
+ * Renders nothing — drop it anywhere in the tree that needs MCP data.
+ * Replaces the old <McpProvider> wrapper.
+ */
+export default function McpStoreInit() {
+  useEffect(() => {
+    const cleanup = useMcpStore.getState()._init();
+    return cleanup;
+  }, []);
+
+  return null;
+}

package/_standalone/lib/stores/WalkthroughInit.tsx

@@ -0,0 +1,20 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useWalkthroughStore } from '@/lib/stores/walkthrough-store';
+import WalkthroughOverlay from '@/components/walkthrough/WalkthroughOverlay';
+
+/**
+ * Initializes walkthrough store and conditionally renders the overlay.
+ * Replaces the old <WalkthroughProvider> wrapper.
+ */
+export default function WalkthroughInit() {
+  useEffect(() => {
+    const cleanup = useWalkthroughStore.getState()._init();
+    return cleanup;
+  }, []);
+
+  const status = useWalkthroughStore(s => s.status);
+
+  return status === 'active' ? <WalkthroughOverlay /> : null;
+}