diff --git a/Cargo.lock b/Cargo.lock
index 893358f54..4e4224f00 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4632,7 +4632,7 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "openhuman"
-version = "0.52.4"
+version = "0.52.5"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -4687,7 +4687,6 @@ dependencies = [
  "reqwest 0.12.28",
  "ring",
  "rppal",
- "rquickjs",
  "rusqlite",
  "rustls",
  "rustls-pki-types",
@@ -5894,34 +5893,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "rquickjs"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5227859c4dfc83f428e58f9569bf439e628c8d139020e7faff437e6f5abaa0"
-dependencies = [
- "rquickjs-core",
-]
-
-[[package]]
-name = "rquickjs-core"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82e0ca83028ad5b533b53b96c395bbaab905a5774de4aaf1004eeacafa3d85d"
-dependencies = [
- "async-lock",
- "rquickjs-sys",
-]
-
-[[package]]
-name = "rquickjs-sys"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fed0097b0b4fbb2a87f6dd3b995a7c64ca56de30007eb7e867dfdfc78324ba5"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "ruma"
 version = "0.14.1"
diff --git a/Cargo.toml b/Cargo.toml
index a4dc9b03f..441155bce 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,6 @@ name = "openhuman_core"
 crate-type = ["rlib"]
 
 [dependencies]
-rquickjs = { version = "0.9", features = ["futures", "parallel"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 reqwest = { version = "0.12", default-features = false, features = ["json", "blocking", "rustls-tls", "native-tls", "stream", "http2", "multipart", "socks"] }
diff --git a/app/src-tauri/Cargo.lock b/app/src-tauri/Cargo.lock
index b91fb37eb..d60624975 100644
--- a/app/src-tauri/Cargo.lock
+++ b/app/src-tauri/Cargo.lock
@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "OpenHuman"
-version = "0.52.4"
+version = "0.52.5"
 dependencies = [
  "env_logger",
  "log",
diff --git a/app/src/components/ErrorReportNotification.tsx b/app/src/components/ErrorReportNotification.tsx
index 2c82055dd..7f84041c0 100644
--- a/app/src/components/ErrorReportNotification.tsx
+++ b/app/src/components/ErrorReportNotification.tsx
@@ -110,11 +110,6 @@ function NotificationCard({
                 DEV
               </span>
             )}
-            {report.source === 'skill' && (
-              <span className="flex-shrink-0 text-[10px] font-medium px-1.5 py-0.5 bg-primary-500/20 text-primary-400 rounded">
-                SKILL
-              </span>
-            )}
           </div>
           <p className="text-xs text-stone-400 mt-0.5 line-clamp-2">{report.message}</p>
         </div>
diff --git a/app/src/components/settings/SettingsHome.tsx b/app/src/components/settings/SettingsHome.tsx
index c7a1208c4..144bb10f1 100644
--- a/app/src/components/settings/SettingsHome.tsx
+++ b/app/src/components/settings/SettingsHome.tsx
@@ -1,6 +1,5 @@
 import { useState } from 'react';
 
-import { skillManager } from '../../lib/skills/manager';
 import { useCoreState } from '../../providers/CoreStateProvider';
 import { persistor } from '../../store';
 import { resetOpenHumanDataAndRestartCore } from '../../utils/tauriCommands';
@@ -43,14 +42,6 @@ const SettingsHome = () => {
       throw err;
     }
 
-    // Best-effort cleanup for in-memory and browser-side caches that live outside the Rust core.
-    try {
-      await skillManager.clearAllSkillsData();
-    } catch (error) {
-      console.warn('Failed to clear skills data:', error);
-      // Continue even if skill cleanup fails because the backend reset already completed.
-    }
-
     await persistor.purge();
     window.localStorage.clear();
     window.sessionStorage.clear();
@@ -247,7 +238,7 @@ const SettingsHome = () => {
                 <p>This will sign you out and permanently delete local app data including:</p>
                 <ul className="list-disc pl-5 mt-2 space-y-1">
                   <li>App settings and conversations</li>
-                  <li>All skills data</li>
+                  <li>All local integration cache data</li>
                   <li>Workspace data</li>
                   <li>All other local data</li>
                 </ul>
diff --git a/app/src/components/settings/panels/ConnectionsPanel.tsx b/app/src/components/settings/panels/ConnectionsPanel.tsx
index 55e3b1e3e..66c5ecf51 100644
--- a/app/src/components/settings/panels/ConnectionsPanel.tsx
+++ b/app/src/components/settings/panels/ConnectionsPanel.tsx
@@ -1,11 +1,9 @@
-import { useState } from 'react';
+import type { ReactElement } from 'react';
 
 import BinanceIcon from '../../../assets/icons/binance.svg';
 import GoogleIcon from '../../../assets/icons/GoogleIcon';
 import MetamaskIcon from '../../../assets/icons/metamask.svg';
 import NotionIcon from '../../../assets/icons/notion.svg';
-import type { SkillConnectionStatus } from '../../../lib/skills/types';
-import SkillSetupModal from '../../skills/SkillSetupModal';
 import SettingsHeader from '../components/SettingsHeader';
 import { useSettingsNavigation } from '../hooks/useSettingsNavigation';
 
@@ -13,63 +11,11 @@ interface ConnectOption {
   id: string;
   name: string;
   description: string;
-  icon: React.ReactElement;
+  icon: ReactElement;
   comingSoon?: boolean;
   skillId?: string;
 }
 
-// ---------------------------------------------------------------------------
-// Status badge mapping
-// ---------------------------------------------------------------------------
-
-const STATUS_BADGE_CONFIG: Record<
-  SkillConnectionStatus,
-  { label: string; bg: string; text: string; border: string }
-> = {
-  connected: {
-    label: 'Connected',
-    bg: 'bg-sage-500/20',
-    text: 'text-sage-400',
-    border: 'border-sage-500/30',
-  },
-  connecting: {
-    label: 'Connecting...',
-    bg: 'bg-amber-500/20',
-    text: 'text-amber-400',
-    border: 'border-amber-500/30',
-  },
-  not_authenticated: {
-    label: 'Not Authenticated',
-    bg: 'bg-amber-500/20',
-    text: 'text-amber-400',
-    border: 'border-amber-500/30',
-  },
-  disconnected: {
-    label: 'Disconnected',
-    bg: 'bg-stone-500/20',
-    text: 'text-stone-400',
-    border: 'border-stone-500/30',
-  },
-  error: {
-    label: 'Error',
-    bg: 'bg-coral-500/20',
-    text: 'text-coral-400',
-    border: 'border-coral-500/30',
-  },
-  offline: {
-    label: 'Offline',
-    bg: 'bg-stone-500/20',
-    text: 'text-stone-400',
-    border: 'border-stone-500/30',
-  },
-  setup_required: {
-    label: 'Setup Required',
-    bg: 'bg-primary-500/20',
-    text: 'text-primary-400',
-    border: 'border-primary-500/30',
-  },
-};
-
 /**
  * Renders a connection option row with its real-time status badge.
  * Uses useSkillConnectionStatus hook for skill-backed connections.
@@ -85,31 +31,17 @@ function ConnectionOptionRow({
   isLast: boolean;
   onConnect: (option: ConnectOption) => void;
 }) {
-  const connectionStatus = 'setup_required' as SkillConnectionStatus;
   const isDisabled = option.comingSoon;
 
-  let badge: React.ReactElement;
-  if (option.comingSoon) {
-    badge = (
-      <span className="px-2 py-1 text-xs font-medium rounded-full border bg-stone-500/20 text-stone-400 border-stone-500/30">
-        Coming Soon
-      </span>
-    );
-  } else if (option.skillId) {
-    const config = STATUS_BADGE_CONFIG[connectionStatus];
-    badge = (
-      <span
-        className={`px-2 py-1 text-xs font-medium rounded-full border ${config.bg} ${config.text} ${config.border}`}>
-        {config.label}
-      </span>
-    );
-  } else {
-    badge = (
-      <span className="px-2 py-1 text-xs font-medium rounded-full border bg-primary-500/20 text-primary-400 border-primary-500/30">
-        Connect
-      </span>
-    );
-  }
+  const badge = option.comingSoon ? (
+    <span className="px-2 py-1 text-xs font-medium rounded-full border bg-stone-500/20 text-stone-400 border-stone-500/30">
+      Coming Soon
+    </span>
+  ) : (
+    <span className="px-2 py-1 text-xs font-medium rounded-full border bg-primary-500/20 text-primary-400 border-primary-500/30">
+      Connect
+    </span>
+  );
 
   return (
     <button
@@ -141,11 +73,6 @@ function ConnectionOptionRow({
 const ConnectionsPanel = () => {
   const { navigateBack, breadcrumbs } = useSettingsNavigation();
 
-  const [setupModalOpen, setSetupModalOpen] = useState(false);
-  const [activeSkillId, setActiveSkillId] = useState<string | null>(null);
-  const [activeSkillName, setActiveSkillName] = useState<string>('');
-  const [activeSkillDescription, setActiveSkillDescription] = useState<string>('');
-
   const connectOptions: ConnectOption[] = [
     {
       id: 'google',
@@ -178,13 +105,11 @@ const ConnectionsPanel = () => {
   ];
 
   const handleConnect = (option: ConnectOption) => {
+    // TODO(connections): replace these early returns with the real connect flow.
+    // When `option.comingSoon` is false or `option.skillId` is wired, this should
+    // open the connection modal, route, or dispatch the connect action.
     if (option.comingSoon) return;
-    if (option.skillId) {
-      setActiveSkillId(option.skillId);
-      setActiveSkillName(option.name);
-      setActiveSkillDescription(option.description);
-      setSetupModalOpen(true);
-    }
+    if (option.skillId) return;
   };
 
   return (
@@ -237,19 +162,6 @@ const ConnectionsPanel = () => {
           </div>
         </div>
       </div>
-
-      {/* Setup modal */}
-      {setupModalOpen && activeSkillId && (
-        <SkillSetupModal
-          skillId={activeSkillId}
-          skillName={activeSkillName}
-          skillDescription={activeSkillDescription}
-          onClose={() => {
-            setSetupModalOpen(false);
-            setActiveSkillId(null);
-          }}
-        />
-      )}
     </div>
   );
 };
diff --git a/app/src/components/settings/panels/CronJobsPanel.tsx b/app/src/components/settings/panels/CronJobsPanel.tsx
index 2d723ba10..6a750afda 100644
--- a/app/src/components/settings/panels/CronJobsPanel.tsx
+++ b/app/src/components/settings/panels/CronJobsPanel.tsx
@@ -1,3 +1,4 @@
+import createDebug from 'debug';
 import { useCallback, useEffect, useState } from 'react';
 
 import {
@@ -8,129 +9,23 @@ import {
   openhumanCronRun,
   openhumanCronRuns,
   openhumanCronUpdate,
-  runtimeDiscoverSkills,
-  runtimeIsSkillEnabled,
-  runtimeListSkillOptions,
-  runtimeListSkills,
-  runtimeSetSkillOption,
-  type RuntimeSkillOption,
 } from '../../../utils/tauriCommands';
 import SettingsHeader from '../components/SettingsHeader';
 import { useSettingsNavigation } from '../hooks/useSettingsNavigation';
 import CoreJobList from './cron/CoreJobList';
-import RuntimeSkillCronList from './cron/RuntimeSkillCronList';
 
-type CronSkillConfig = {
-  skillId: string;
-  name: string;
-  enabled: boolean;
-  manifestTickInterval: number | null;
-  options: RuntimeSkillOption[];
-  optionsError: string | null;
-};
-
-const CRON_KEYWORDS = ['cron', 'schedule', 'interval', 'tick'];
-
-const isCronOption = (option: RuntimeSkillOption): boolean => {
-  const haystack = `${option.name} ${option.label} ${option.description ?? ''}`.toLowerCase();
-  return CRON_KEYWORDS.some(keyword => haystack.includes(keyword));
-};
+const loadCronJobsLog = createDebug('app:settings:CronJobsPanel:loadCronSkills');
 
 const CronJobsPanel = () => {
   const { navigateBack, breadcrumbs } = useSettingsNavigation();
 
   const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
   const [coreError, setCoreError] = useState<string | null>(null);
 
-  const [skills, setSkills] = useState<CronSkillConfig[]>([]);
-  const [draftValues, setDraftValues] = useState<Record<string, string>>({});
-  const [savingKey, setSavingKey] = useState<string | null>(null);
-
   const [coreJobs, setCoreJobs] = useState<CoreCronJob[]>([]);
   const [coreRunsByJob, setCoreRunsByJob] = useState<Record<string, CoreCronRun[]>>({});
   const [coreBusyKey, setCoreBusyKey] = useState<string | null>(null);
 
-  const loadRuntimeCronSkills = useCallback(async () => {
-    const [discoveredSkills, snapshots] = await Promise.all([
-      runtimeDiscoverSkills(),
-      runtimeListSkills(),
-    ]);
-
-    const discoveredById = new Map(discoveredSkills.map(skill => [skill.id, skill]));
-    const snapshotById = new Map(snapshots.map(snapshot => [snapshot.skill_id, snapshot]));
-    const allSkillIds = Array.from(new Set([...discoveredById.keys(), ...snapshotById.keys()]));
-
-    const enabledEntries = await Promise.all(
-      allSkillIds.map(async skillId => {
-        try {
-          const enabled = await runtimeIsSkillEnabled(skillId);
-          return [skillId, enabled] as const;
-        } catch {
-          return [skillId, false] as const;
-        }
-      })
-    );
-
-    const enabledMap = Object.fromEntries(enabledEntries);
-
-    const rows = await Promise.all(
-      allSkillIds.map(async skillId => {
-        const discovered = discoveredById.get(skillId);
-        const snapshot = snapshotById.get(skillId);
-
-        const baseName =
-          discovered?.name?.trim() ||
-          (typeof snapshot?.name === 'string' ? snapshot.name : skillId);
-
-        let options: RuntimeSkillOption[] = [];
-        let optionsError: string | null = null;
-
-        try {
-          const allOptions = await runtimeListSkillOptions(skillId);
-          options = allOptions.filter(isCronOption);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          optionsError = message;
-        }
-
-        const manifestTickInterval =
-          typeof discovered?.tickInterval === 'number' ? discovered.tickInterval : null;
-
-        if (manifestTickInterval === null && options.length === 0) {
-          return null;
-        }
-
-        return {
-          skillId,
-          name: baseName,
-          enabled: enabledMap[skillId] ?? false,
-          manifestTickInterval,
-          options,
-          optionsError,
-        } satisfies CronSkillConfig;
-      })
-    );
-
-    const filtered = rows
-      .filter((row): row is CronSkillConfig => row !== null)
-      .sort((a, b) => a.name.localeCompare(b.name));
-
-    setSkills(filtered);
-    setDraftValues(prev => {
-      const next = { ...prev };
-      for (const skill of filtered) {
-        for (const option of skill.options) {
-          const key = `${skill.skillId}:${option.name}`;
-          if (next[key] === undefined) {
-            next[key] = option.value == null ? '' : String(option.value);
-          }
-        }
-      }
-      return next;
-    });
-  }, []);
-
   const loadCoreCronJobs = useCallback(async () => {
     const response = await openhumanCronList();
     const sorted = [...response.result].sort((a, b) => {
@@ -141,94 +36,26 @@ const CronJobsPanel = () => {
     setCoreJobs(sorted);
   }, []);
 
-  const loadCronSkills = useCallback(async () => {
+  const loadCoreCronJobsOnly = useCallback(async () => {
+    loadCronJobsLog('start');
     setLoading(true);
-    setError(null);
     setCoreError(null);
 
-    try {
-      await loadRuntimeCronSkills();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(`Failed to load runtime cron jobs: ${message}`);
-    }
-
     try {
       await loadCoreCronJobs();
+      loadCronJobsLog('success');
     } catch (err) {
+      loadCronJobsLog('failure', err);
       const message = err instanceof Error ? err.message : String(err);
       setCoreError(`Failed to load core cron jobs: ${message}`);
     } finally {
       setLoading(false);
     }
-  }, [loadCoreCronJobs, loadRuntimeCronSkills]);
+  }, [loadCoreCronJobs]);
 
   useEffect(() => {
-    void loadCronSkills();
-  }, [loadCronSkills]);
-
-  const updateOptionInState = (
-    skillId: string,
-    optionName: string,
-    value: RuntimeSkillOption['value']
-  ) => {
-    setSkills(prev =>
-      prev.map(skill => {
-        if (skill.skillId !== skillId) return skill;
-        return {
-          ...skill,
-          options: skill.options.map(option =>
-            option.name === optionName ? { ...option, value } : option
-          ),
-        };
-      })
-    );
-  };
-
-  const saveOptionValue = async (skillId: string, option: RuntimeSkillOption, rawValue: string) => {
-    const key = `${skillId}:${option.name}`;
-    setSavingKey(key);
-    setError(null);
-
-    try {
-      let nextValue: RuntimeSkillOption['value'] = rawValue;
-
-      if (option.type === 'number') {
-        const parsed = Number(rawValue);
-        if (!Number.isFinite(parsed)) {
-          throw new Error('Please enter a valid number for this cron option.');
-        }
-        nextValue = parsed;
-      }
-
-      await runtimeSetSkillOption(skillId, option.name, nextValue);
-      updateOptionInState(skillId, option.name, nextValue);
-      setDraftValues(prev => ({ ...prev, [key]: String(nextValue) }));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(`Failed to update ${option.label}: ${message}`);
-    } finally {
-      setSavingKey(null);
-    }
-  };
-
-  const toggleBooleanOption = async (skillId: string, option: RuntimeSkillOption) => {
-    const key = `${skillId}:${option.name}`;
-    setSavingKey(key);
-    setError(null);
-
-    try {
-      const nextValue = !(option.value === true);
-      await runtimeSetSkillOption(skillId, option.name, nextValue);
-      updateOptionInState(skillId, option.name, nextValue);
-      setDraftValues(prev => ({ ...prev, [key]: String(nextValue) }));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(`Failed to update ${option.label}: ${message}`);
-    } finally {
-      setSavingKey(null);
-    }
-  };
+    void loadCoreCronJobsOnly();
+  }, [loadCoreCronJobsOnly]);
 
   const toggleCoreJob = async (job: CoreCronJob) => {
     const key = `core-toggle:${job.id}`;
@@ -313,17 +140,9 @@ const CronJobsPanel = () => {
       <div className="p-4 space-y-4">
         <section className="space-y-1">
           <h3 className="text-sm font-semibold text-stone-900">Scheduled Jobs</h3>
-          <p className="text-xs text-stone-400">
-            Manage cron jobs from both the core scheduler and runtime skills.
-          </p>
+          <p className="text-xs text-stone-400">Manage cron jobs from the core scheduler.</p>
         </section>
 
-        {error && (
-          <div className="rounded-lg border border-coral-300 bg-coral-50 px-4 py-3 text-sm text-coral-700">
-            {error}
-          </div>
-        )}
-
         {coreError && (
           <div className="rounded-lg border border-amber-300 bg-amber-50 px-4 py-3 text-sm text-amber-700">
             {coreError}
@@ -340,24 +159,11 @@ const CronJobsPanel = () => {
           onLoadCoreRuns={jobId => void loadCoreRuns(jobId)}
           onRemoveCoreJob={jobId => void removeCoreJob(jobId)}
         />
-
-        <RuntimeSkillCronList
-          loading={loading}
-          skills={skills}
-          draftValues={draftValues}
-          savingKey={savingKey}
-          onSetDraftValues={setDraftValues}
-          onSaveOptionValue={(skillId, option, rawValue) =>
-            void saveOptionValue(skillId, option, rawValue)
-          }
-          onToggleBooleanOption={(skillId, option) => void toggleBooleanOption(skillId, option)}
-        />
-
         <div>
           <button
             type="button"
             className="btn btn-outline btn-sm"
-            onClick={() => void loadCronSkills()}>
+            onClick={() => void loadCoreCronJobsOnly()}>
             Refresh Cron Jobs
           </button>
         </div>
diff --git a/app/src/components/settings/panels/RecoveryPhrasePanel.tsx b/app/src/components/settings/panels/RecoveryPhrasePanel.tsx
index 8baa39c0c..4ac3c955e 100644
--- a/app/src/components/settings/panels/RecoveryPhrasePanel.tsx
+++ b/app/src/components/settings/panels/RecoveryPhrasePanel.tsx
@@ -1,10 +1,8 @@
 import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 
-import { skillManager } from '../../../lib/skills/manager';
 import { useCoreState } from '../../../providers/CoreStateProvider';
 import {
   deriveAesKeyFromMnemonic,
-  deriveEvmAddressFromMnemonic,
   generateMnemonicPhrase,
   MNEMONIC_GENERATE_WORD_COUNT,
   validateMnemonicPhrase,
@@ -177,14 +175,11 @@ const RecoveryPhrasePanel = () => {
       }
 
       const aesKey = deriveAesKeyFromMnemonic(phraseToUse);
-      const walletAddress = deriveEvmAddressFromMnemonic(phraseToUse);
-
       if (!user?._id) {
         setError('User not loaded. Please sign in again or refresh the page.');
         return;
       }
       await setEncryptionKey(aesKey);
-      await skillManager.setWalletAddress(walletAddress);
       setSuccess(true);
     } catch (e) {
       setError(e instanceof Error ? e.message : 'Something went wrong. Please try again.');
diff --git a/app/src/components/settings/panels/cron/RuntimeSkillCronList.tsx b/app/src/components/settings/panels/cron/RuntimeSkillCronList.tsx
deleted file mode 100644
index adfd17ce2..000000000
--- a/app/src/components/settings/panels/cron/RuntimeSkillCronList.tsx
+++ /dev/null
@@ -1,173 +0,0 @@
-import type { RuntimeSkillOption } from '../../../../utils/tauriCommands';
-
-interface CronSkillConfig {
-  skillId: string;
-  name: string;
-  enabled: boolean;
-  manifestTickInterval: number | null;
-  options: RuntimeSkillOption[];
-  optionsError: string | null;
-}
-
-interface RuntimeSkillCronListProps {
-  loading: boolean;
-  skills: CronSkillConfig[];
-  draftValues: Record<string, string>;
-  savingKey: string | null;
-  onSetDraftValues: (updater: (prev: Record<string, string>) => Record<string, string>) => void;
-  onSaveOptionValue: (skillId: string, option: RuntimeSkillOption, rawValue: string) => void;
-  onToggleBooleanOption: (skillId: string, option: RuntimeSkillOption) => void;
-}
-
-const RuntimeSkillCronList = ({
-  loading,
-  skills,
-  draftValues,
-  savingKey,
-  onSetDraftValues,
-  onSaveOptionValue,
-  onToggleBooleanOption,
-}: RuntimeSkillCronListProps) => {
-  const hasAnyRuntimeCronConfig = skills.length > 0;
-
-  return (
-    <section className="rounded-xl border border-stone-200 bg-white">
-      <div className="p-4 border-b border-stone-200">
-        <h3 className="text-sm font-semibold text-stone-900">Runtime Skill Cron Settings</h3>
-        <p className="text-xs text-stone-500 mt-1">
-          Skill-level cron and interval options from the runtime.
-        </p>
-      </div>
-
-      {loading && (
-        <div className="p-4 text-sm text-stone-400">Loading runtime cron settings...</div>
-      )}
-
-      {!loading && !hasAnyRuntimeCronConfig && (
-        <div className="p-4 text-sm text-stone-400">
-          No cron-capable skills were found in the current runtime.
-        </div>
-      )}
-
-      {!loading &&
-        skills.map((skill, skillIndex) => (
-          <div
-            key={skill.skillId}
-            className={`p-4 ${skillIndex === 0 ? '' : 'border-t border-stone-200'}`}>
-            <div className="flex items-center justify-between gap-3 mb-3">
-              <div>
-                <div className="text-sm font-semibold text-stone-900">{skill.name}</div>
-                <div className="text-[11px] text-stone-400">{skill.skillId}</div>
-              </div>
-              <span
-                className={`px-2 py-1 text-[11px] font-semibold uppercase border rounded-full ${
-                  skill.enabled
-                    ? 'bg-sage-50 text-sage-700 border-sage-200'
-                    : 'bg-stone-100 text-stone-600 border-stone-200'
-                }`}>
-                {skill.enabled ? 'Enabled' : 'Disabled'}
-              </span>
-            </div>
-
-            {skill.manifestTickInterval !== null && (
-              <div className="rounded-lg border border-stone-200 bg-stone-50 px-3 py-2 text-xs text-stone-600 mb-3">
-                Manifest tick interval:{' '}
-                <span className="font-semibold">{skill.manifestTickInterval}s</span>
-              </div>
-            )}
-
-            {skill.optionsError && (
-              <div className="rounded-lg border border-amber-300 bg-amber-50 px-3 py-2 text-xs text-amber-700 mb-3">
-                Could not load runtime options: {skill.optionsError}
-              </div>
-            )}
-
-            {skill.options.length > 0 && (
-              <div className="space-y-2">
-                {skill.options.map(option => {
-                  const optionKey = `${skill.skillId}:${option.name}`;
-                  const draft = draftValues[optionKey] ?? '';
-                  const busy = savingKey === optionKey;
-
-                  return (
-                    <div
-                      key={optionKey}
-                      className="rounded-lg border border-stone-200 bg-stone-50 p-3 space-y-2">
-                      <div>
-                        <div className="text-xs font-medium text-stone-700">{option.label}</div>
-                        {option.description && (
-                          <div className="text-[11px] text-stone-500 mt-0.5">
-                            {option.description}
-                          </div>
-                        )}
-                      </div>
-
-                      {option.type === 'boolean' && (
-                        <label className="flex items-center gap-2 text-xs text-stone-600">
-                          <input
-                            type="checkbox"
-                            className="checkbox checkbox-primary"
-                            checked={option.value === true}
-                            disabled={busy || !skill.enabled}
-                            onChange={() => onToggleBooleanOption(skill.skillId, option)}
-                          />
-                          {busy ? 'Saving…' : option.value === true ? 'Enabled' : 'Disabled'}
-                        </label>
-                      )}
-
-                      {option.type === 'select' && option.options && (
-                        <div className="flex items-center gap-2">
-                          <select
-                            value={draft}
-                            disabled={busy || !skill.enabled}
-                            onChange={event => {
-                              const next = event.target.value;
-                              onSetDraftValues(prev => ({ ...prev, [optionKey]: next }));
-                              onSaveOptionValue(skill.skillId, option, next);
-                            }}
-                            className="select select-bordered w-full text-slate-900 bg-white">
-                            {option.options.map(item => (
-                              <option key={item.value} value={item.value}>
-                                {item.label}
-                              </option>
-                            ))}
-                          </select>
-                        </div>
-                      )}
-
-                      {(option.type === 'text' || option.type === 'number') && (
-                        <div className="flex items-center gap-2">
-                          <input
-                            type={option.type === 'number' ? 'number' : 'text'}
-                            value={draft}
-                            disabled={busy || !skill.enabled}
-                            onChange={event =>
-                              onSetDraftValues(prev => ({
-                                ...prev,
-                                [optionKey]: event.target.value,
-                              }))
-                            }
-                            className="input input-bordered w-full text-slate-900 bg-white"
-                            placeholder={option.type === 'number' ? '60' : '*/5 * * * *'}
-                          />
-                          <button
-                            type="button"
-                            className="btn btn-primary btn-sm"
-                            disabled={busy || !skill.enabled}
-                            onClick={() => onSaveOptionValue(skill.skillId, option, draft)}>
-                            {busy ? 'Saving…' : 'Save'}
-                          </button>
-                        </div>
-                      )}
-                    </div>
-                  );
-                })}
-              </div>
-            )}
-          </div>
-        ))}
-    </section>
-  );
-};
-
-export default RuntimeSkillCronList;
diff --git a/app/src/components/skills/AuthModeSelector.tsx b/app/src/components/skills/AuthModeSelector.tsx
deleted file mode 100644
index a4e6ebdf3..000000000
--- a/app/src/components/skills/AuthModeSelector.tsx
+++ /dev/null
@@ -1,139 +0,0 @@
-/**
- * Card-based selector for skill authentication modes.
- * Displays available auth modes (managed, self_hosted, text) as clickable cards.
- * For managed mode, clicking immediately triggers the OAuth flow.
- */
-
-import type { ReactElement } from "react";
-import type { AuthMode } from "../../lib/skills/types.ts";
-
-interface AuthModeSelectorProps {
-  modes: AuthMode[];
-  onSelect: (mode: AuthMode) => void;
-  disabled?: boolean;
-}
-
-const MODE_ICONS: Record<string, (props: { className: string }) => ReactElement> = {
-  managed: ({ className }) => (
-    <svg className={className} fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path
-        strokeLinecap="round"
-        strokeLinejoin="round"
-        strokeWidth={1.5}
-        d="M9 12.75L11.25 15 15 9.75m-3-7.036A11.959 11.959 0 013.598 6 11.99 11.99 0 003 9.749c0 5.592 3.824 10.29 9 11.623 5.176-1.332 9-6.03 9-11.622 0-1.31-.21-2.571-.598-3.751h-.152c-3.196 0-6.1-1.248-8.25-3.285z"
-      />
-    </svg>
-  ),
-  self_hosted: ({ className }) => (
-    <svg className={className} fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path
-        strokeLinecap="round"
-        strokeLinejoin="round"
-        strokeWidth={1.5}
-        d="M5.25 14.25h13.5m-13.5 0a3 3 0 01-3-3m3 3a3 3 0 100 6h13.5a3 3 0 100-6m-16.5-3a3 3 0 013-3h13.5a3 3 0 013 3m-19.5 0a4.5 4.5 0 01.9-2.7L5.737 5.1a3.375 3.375 0 012.7-1.35h7.126c1.062 0 2.062.5 2.7 1.35l2.587 3.45a4.5 4.5 0 01.9 2.7m0 0a3 3 0 01-3 3m0 3h.008v.008h-.008v-.008zm0-6h.008v.008h-.008v-.008zm-3 6h.008v.008h-.008v-.008zm0-6h.008v.008h-.008v-.008z"
-      />
-    </svg>
-  ),
-  text: ({ className }) => (
-    <svg className={className} fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path
-        strokeLinecap="round"
-        strokeLinejoin="round"
-        strokeWidth={1.5}
-        d="M19.5 14.25v-2.625a3.375 3.375 0 00-3.375-3.375h-1.5A1.125 1.125 0 0113.5 7.125v-1.5a3.375 3.375 0 00-3.375-3.375H8.25m0 12.75h7.5m-7.5 3H12M10.5 2.25H5.625c-.621 0-1.125.504-1.125 1.125v17.25c0 .621.504 1.125 1.125 1.125h12.75c.621 0 1.125-.504 1.125-1.125V11.25a9 9 0 00-9-9z"
-      />
-    </svg>
-  ),
-};
-
-const DEFAULT_LABELS: Record<string, string> = {
-  managed: "OpenHuman Managed",
-  self_hosted: "Self-hosted",
-  text: "Credential Text",
-};
-
-const DEFAULT_DESCRIPTIONS: Record<string, string> = {
-  managed: "One-click setup through OpenHuman",
-  self_hosted: "Enter your own API credentials",
-  text: "Paste credential content directly",
-};
-
-function formatProviderName(provider: string): string {
-  const names: Record<string, string> = {
-    notion: "Notion",
-    google: "Google",
-    github: "GitHub",
-    slack: "Slack",
-    discord: "Discord",
-    twitter: "Twitter",
-    linear: "Linear",
-    gitlab: "GitLab",
-  };
-  return names[provider] ?? provider.charAt(0).toUpperCase() + provider.slice(1);
-}
-
-export default function AuthModeSelector({
-  modes,
-  onSelect,
-  disabled,
-}: AuthModeSelectorProps) {
-  return (
-    <div className="space-y-3">
-      <div className="text-center mb-4">
-        <h3 className="text-lg font-semibold text-stone-900">
-          Choose how to connect
-        </h3>
-        <p className="text-sm text-stone-500 mt-1">
-          Select an authentication method
-        </p>
-      </div>
-
-      {modes.map((mode) => {
-        const IconComponent = MODE_ICONS[mode.type] ?? MODE_ICONS.self_hosted;
-        const label =
-          mode.type === "managed" && mode.provider
-            ? mode.label ?? `Connect with ${formatProviderName(mode.provider)}`
-            : mode.label ?? DEFAULT_LABELS[mode.type] ?? mode.type;
-        const description =
-          mode.description ?? DEFAULT_DESCRIPTIONS[mode.type] ?? "";
-
-        return (
-          <button
-            key={mode.type}
-            type="button"
-            onClick={() => onSelect(mode)}
-            disabled={disabled}
-            className="w-full flex items-center gap-4 p-4 bg-stone-50 border border-stone-200 rounded-xl hover:bg-stone-100 hover:border-stone-300 transition-colors text-left disabled:opacity-50 disabled:cursor-not-allowed group"
-          >
-            <div className="flex-shrink-0 w-10 h-10 rounded-lg bg-white border border-stone-200 flex items-center justify-center group-hover:border-primary-300 transition-colors">
-              <IconComponent className="w-5 h-5 text-stone-500 group-hover:text-primary-500 transition-colors" />
-            </div>
-            <div className="flex-1 min-w-0">
-              <div className="text-sm font-medium text-stone-900">
-                {label}
-              </div>
-              {description && (
-                <div className="text-xs text-stone-500 mt-0.5">
-                  {description}
-                </div>
-              )}
-            </div>
-            <svg
-              className="w-4 h-4 text-stone-400 group-hover:text-stone-600 transition-colors flex-shrink-0"
-              fill="none"
-              stroke="currentColor"
-              viewBox="0 0 24 24"
-            >
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M9 5l7 7-7 7"
-              />
-            </svg>
-          </button>
-        );
-      })}
-    </div>
-  );
-}
diff --git a/app/src/components/skills/SetupFormRenderer.tsx b/app/src/components/skills/SetupFormRenderer.tsx
deleted file mode 100644
index f9624fe38..000000000
--- a/app/src/components/skills/SetupFormRenderer.tsx
+++ /dev/null
@@ -1,269 +0,0 @@
-/**
- * Dynamic form renderer for skill setup steps.
- * Takes a SetupStep and renders appropriate form fields.
- */
-
-import { useState } from "react";
-import type { SetupStep, SetupFieldError } from "../../lib/skills/types";
-
-interface SetupFormRendererProps {
-  step: SetupStep;
-  errors?: SetupFieldError[] | null;
-  loading?: boolean;
-  onSubmit: (values: Record<string, unknown>) => void;
-  onCancel: () => void;
-}
-
-export default function SetupFormRenderer({
-  step,
-  errors,
-  loading,
-  onSubmit,
-  onCancel,
-}: SetupFormRendererProps) {
-  const [values, setValues] = useState<Record<string, unknown>>(() => {
-    const defaults: Record<string, unknown> = {};
-    for (const field of step.fields) {
-      if (field.default !== undefined && field.default !== null) {
-        defaults[field.name] = field.default;
-      } else if (field.type === "boolean") {
-        defaults[field.name] = false;
-      } else {
-        defaults[field.name] = "";
-      }
-    }
-    return defaults;
-  });
-
-  const [showPasswords, setShowPasswords] = useState<Record<string, boolean>>(
-    {},
-  );
-
-  const getFieldError = (fieldName: string): string | undefined => {
-    return errors?.find((e) => e.field === fieldName)?.message;
-  };
-
-  const getGeneralError = (): string | undefined => {
-    return errors?.find((e) => e.field === "")?.message;
-  };
-
-  const handleSubmit = (e: React.FormEvent) => {
-    e.preventDefault();
-    onSubmit(values);
-  };
-
-  const updateValue = (name: string, value: unknown) => {
-    setValues((prev) => ({ ...prev, [name]: value }));
-  };
-
-  return (
-    <form onSubmit={handleSubmit} className="space-y-4">
-      {/* Step header */}
-      <div className="mb-4">
-        <h3 className="text-lg font-semibold text-stone-900">{step.title}</h3>
-        {step.description && (
-          <p className="text-sm text-stone-400 mt-1">{step.description}</p>
-        )}
-      </div>
-
-      {/* General error */}
-      {getGeneralError() && (
-        <div className="p-3 bg-coral-500/10 border border-coral-500/30 rounded-xl">
-          <p className="text-sm text-coral-400">{getGeneralError()}</p>
-        </div>
-      )}
-
-      {/* Form fields */}
-      {step.fields.map((field) => {
-        const fieldError = getFieldError(field.name);
-        const value = values[field.name];
-
-        return (
-          <div key={field.name} className="space-y-1.5">
-            <label className="block text-sm font-medium text-stone-700">
-              {field.label}
-              {field.required && (
-                <span className="text-coral-400 ml-0.5">*</span>
-              )}
-            </label>
-
-            {field.description && (
-              <p className="text-xs text-stone-500">{field.description}</p>
-            )}
-
-            {/* Text / Number input */}
-            {(field.type === "text" || field.type === "number") && (
-              <input
-                type={field.type === "number" ? "number" : "text"}
-                value={String(value ?? "")}
-                onChange={(e) =>
-                  updateValue(
-                    field.name,
-                    field.type === "number"
-                      ? Number(e.target.value)
-                      : e.target.value,
-                  )
-                }
-                placeholder={field.placeholder ?? undefined}
-                disabled={loading}
-                className={`w-full px-3 py-2.5 bg-stone-50 border rounded-xl text-sm text-stone-900 placeholder-stone-400 focus:outline-none focus:ring-1 transition-colors ${
-                  fieldError
-                    ? "border-coral-500/50 focus:ring-coral-500/30"
-                    : "border-stone-200 focus:ring-primary-500/30 focus:border-primary-500/50"
-                }`}
-              />
-            )}
-
-            {/* Password input */}
-            {field.type === "password" && (
-              <div className="relative">
-                <input
-                  type={showPasswords[field.name] ? "text" : "password"}
-                  value={String(value ?? "")}
-                  onChange={(e) => updateValue(field.name, e.target.value)}
-                  placeholder={field.placeholder ?? undefined}
-                  disabled={loading}
-                  className={`w-full px-3 py-2.5 pr-10 bg-stone-50 border rounded-xl text-sm text-stone-900 placeholder-stone-400 focus:outline-none focus:ring-1 transition-colors ${
-                    fieldError
-                      ? "border-coral-500/50 focus:ring-coral-500/30"
-                      : "border-stone-200 focus:ring-primary-500/30 focus:border-primary-500/50"
-                  }`}
-                />
-                <button
-                  type="button"
-                  onClick={() =>
-                    setShowPasswords((prev) => ({
-                      ...prev,
-                      [field.name]: !prev[field.name],
-                    }))
-                  }
-                  className="absolute right-3 top-1/2 -translate-y-1/2 text-stone-500 hover:text-stone-700"
-                >
-                  {showPasswords[field.name] ? (
-                    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13.875 18.825A10.05 10.05 0 0112 19c-4.478 0-8.268-2.943-9.543-7a9.97 9.97 0 011.563-3.029m5.858.908a3 3 0 114.243 4.243M9.878 9.878l4.242 4.242M9.878 9.878L3 3m6.878 6.879L21 21" />
-                    </svg>
-                  ) : (
-                    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 12a3 3 0 11-6 0 3 3 0 016 0z" />
-                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z" />
-                    </svg>
-                  )}
-                </button>
-              </div>
-            )}
-
-            {/* Select dropdown */}
-            {field.type === "select" && (
-              <select
-                value={String(value ?? "")}
-                onChange={(e) => updateValue(field.name, e.target.value)}
-                disabled={loading}
-                className={`w-full px-3 py-2.5 bg-stone-50 border rounded-xl text-sm text-stone-900 focus:outline-none focus:ring-1 transition-colors ${
-                  fieldError
-                    ? "border-coral-500/50 focus:ring-coral-500/30"
-                    : "border-stone-200 focus:ring-primary-500/30 focus:border-primary-500/50"
-                }`}
-              >
-                <option value="">Select...</option>
-                {field.options?.map((opt) => (
-                  <option key={opt.value} value={opt.value}>
-                    {opt.label}
-                  </option>
-                ))}
-              </select>
-            )}
-
-            {/* Textarea */}
-            {field.type === "textarea" && (
-              <textarea
-                value={String(value ?? "")}
-                onChange={(e) => updateValue(field.name, e.target.value)}
-                placeholder={field.placeholder ?? undefined}
-                disabled={loading}
-                rows={8}
-                className={`w-full px-3 py-2.5 bg-stone-50 border rounded-xl text-sm text-stone-900 placeholder-stone-400 font-mono focus:outline-none focus:ring-1 transition-colors resize-y ${
-                  fieldError
-                    ? "border-coral-500/50 focus:ring-coral-500/30"
-                    : "border-stone-200 focus:ring-primary-500/30 focus:border-primary-500/50"
-                }`}
-              />
-            )}
-
-            {/* Boolean toggle */}
-            {field.type === "boolean" && (
-              <label className="flex items-center space-x-3 cursor-pointer">
-                <div
-                  role="switch"
-                  aria-checked={Boolean(value)}
-                  onClick={() =>
-                    !loading && updateValue(field.name, !value)
-                  }
-                  className={`relative w-10 h-5 rounded-full transition-colors ${
-                    value ? "bg-primary-500" : "bg-stone-600"
-                  }`}
-                >
-                  <div
-                    className={`absolute top-0.5 left-0.5 w-4 h-4 rounded-full bg-white transition-transform ${
-                      value ? "translate-x-5" : "translate-x-0"
-                    }`}
-                  />
-                </div>
-                <span className="text-sm text-stone-700">
-                  {value ? "Enabled" : "Disabled"}
-                </span>
-              </label>
-            )}
-
-            {/* Field error */}
-            {fieldError && (
-              <p className="text-xs text-coral-400 mt-1">{fieldError}</p>
-            )}
-          </div>
-        );
-      })}
-
-      {/* Actions */}
-      <div className="flex space-x-3 pt-2">
-        <button
-          type="button"
-          onClick={onCancel}
-          disabled={loading}
-          className="flex-1 py-2.5 text-sm font-medium text-stone-600 bg-stone-100 border border-stone-200 rounded-xl hover:bg-stone-200 transition-colors disabled:opacity-50"
-        >
-          Cancel
-        </button>
-        <button
-          type="submit"
-          disabled={loading}
-          className="flex-1 py-2.5 text-sm font-medium text-white bg-primary-500 rounded-xl hover:bg-primary-600 transition-colors disabled:opacity-50 flex items-center justify-center"
-        >
-          {loading ? (
-            <svg
-              className="animate-spin h-4 w-4 text-white"
-              xmlns="http://www.w3.org/2000/svg"
-              fill="none"
-              viewBox="0 0 24 24"
-            >
-              <circle
-                className="opacity-25"
-                cx="12"
-                cy="12"
-                r="10"
-                stroke="currentColor"
-                strokeWidth="4"
-              />
-              <path
-                className="opacity-75"
-                fill="currentColor"
-                d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"
-              />
-            </svg>
-          ) : (
-            "Continue"
-          )}
-        </button>
-      </div>
-    </form>
-  );
-}
diff --git a/app/src/components/skills/SkillCard.tsx b/app/src/components/skills/SkillCard.tsx
index c5ebb23f7..e2c29e3cc 100644
--- a/app/src/components/skills/SkillCard.tsx
+++ b/app/src/components/skills/SkillCard.tsx
@@ -1,22 +1,7 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
-
-import SkillDebugModal from './SkillDebugModal';
-import { DefaultIcon, STATUS_DISPLAY, type SkillListEntry } from './shared';
-import {
-  useSkillConnectionStatus,
-  useSkillDataDirectoryStats,
-  useSkillState,
-} from '../../lib/skills/hooks';
-import { skillManager } from '../../lib/skills/manager';
-import type { SkillConnectionStatus, SkillHostConnectionState } from '../../lib/skills/types';
-import {
-  deriveSkillSyncSummaryText,
-  deriveSkillSyncUiState,
-  type SkillSyncStatsLike,
-} from '../../pages/skillsSyncUi';
+import { useEffect, useRef, useState, type ReactNode } from 'react';
 
 export interface UnifiedSkillCardProps {
-  icon: React.ReactNode;
+  icon: ReactNode;
   title: string;
   description: string;
   statusDot?: string;
@@ -27,7 +12,7 @@ export interface UnifiedSkillCardProps {
   onCtaClick: () => void;
   secondaryActions?: Array<{
     label: string;
-    icon: React.ReactNode;
+    icon: ReactNode;
     onClick: () => void;
     disabled?: boolean;
     testId?: string;
@@ -80,28 +65,26 @@ export function UnifiedSkillCard({
   const ctaStyle = CTA_STYLES[ctaVariant] ?? CTA_STYLES.primary;
 
   return (
-    <div className="flex items-center gap-3 p-3 rounded-xl bg-white border border-stone-100 hover:bg-stone-50 transition-colors">
-      <div className="w-8 h-8 flex items-center justify-center text-stone-600 flex-shrink-0">
+    <div className="flex items-center gap-3 rounded-xl border border-stone-100 bg-white p-3 transition-colors hover:bg-stone-50">
+      <div className="flex h-8 w-8 flex-shrink-0 items-center justify-center text-stone-600">
         {icon}
       </div>
 
-      <div className="flex-1 min-w-0">
+      <div className="min-w-0 flex-1">
         <div className="flex items-center gap-2">
-          <span className="text-sm font-semibold text-stone-900 truncate">{title}</span>
-          {statusDot && (
-            <div className={`w-1.5 h-1.5 rounded-full flex-shrink-0 ${statusDot}`} />
-          )}
+          <span className="truncate text-sm font-semibold text-stone-900">{title}</span>
+          {statusDot && <div className={`h-1.5 w-1.5 flex-shrink-0 rounded-full ${statusDot}`} />}
           {statusLabel && (
-            <span className={`text-xs flex-shrink-0 ${statusColor ?? 'text-stone-400'}`}>
+            <span className={`flex-shrink-0 text-xs ${statusColor ?? 'text-stone-400'}`}>
               {statusLabel}
             </span>
           )}
         </div>
         {description && (
-          <p className="mt-1 text-xs leading-relaxed text-stone-600 line-clamp-2">{description}</p>
+          <p className="mt-1 line-clamp-2 text-xs leading-relaxed text-stone-600">{description}</p>
         )}
         {syncSummaryText && !syncProgress?.active && (
-          <p className="text-[11px] text-stone-500 truncate mt-1">{syncSummaryText}</p>
+          <p className="mt-1 truncate text-[11px] text-stone-500">{syncSummaryText}</p>
         )}
         {syncProgress?.active && (
           <div className="mt-1.5">
@@ -112,20 +95,22 @@ export function UnifiedSkillCard({
                   style={{ width: `${syncProgress.percent}%` }}
                 />
               ) : (
-                <div className="h-full w-1/2 rounded-full bg-primary-400/80 animate-pulse" />
+                <div className="h-full w-1/2 animate-pulse rounded-full bg-primary-400/80" />
               )}
             </div>
             {syncProgress.message && (
-              <p className="text-[11px] text-primary-600 truncate mt-1">{syncProgress.message}</p>
+              <p className="mt-1 truncate text-[11px] text-primary-600">{syncProgress.message}</p>
             )}
             {syncProgress.metricsText && (
-              <p className="text-[11px] text-stone-500 truncate mt-0.5">{syncProgress.metricsText}</p>
+              <p className="mt-0.5 truncate text-[11px] text-stone-500">
+                {syncProgress.metricsText}
+              </p>
             )}
           </div>
         )}
       </div>
 
-      <div className="flex items-center gap-1 flex-shrink-0">
+      <div className="flex flex-shrink-0 items-center gap-1">
         {secondaryActions && secondaryActions.length > 0 && (
           <div className="relative" ref={menuRef}>
             <button
@@ -134,9 +119,9 @@ export function UnifiedSkillCard({
                 e.stopPropagation();
                 setMenuOpen(prev => !prev);
               }}
-              className="w-7 h-7 flex items-center justify-center rounded-lg text-stone-400 hover:text-stone-700 hover:bg-stone-100 transition-colors"
+              className="flex h-7 w-7 items-center justify-center rounded-lg text-stone-400 transition-colors hover:bg-stone-100 hover:text-stone-700"
               title="More actions">
-              <svg className="w-3.5 h-3.5" fill="currentColor" viewBox="0 0 24 24">
+              <svg className="h-3.5 w-3.5" fill="currentColor" viewBox="0 0 24 24">
                 <circle cx="5" cy="12" r="2" />
                 <circle cx="12" cy="12" r="2" />
                 <circle cx="19" cy="12" r="2" />
@@ -171,7 +156,7 @@ export function UnifiedSkillCard({
             e.stopPropagation();
             onCtaClick();
           }}
-          className={`flex-shrink-0 rounded-lg border px-3 py-1.5 text-[11px] font-medium transition-colors ${ctaStyle} ${ctaDisabled ? 'opacity-50 cursor-not-allowed' : ''}`}>
+          className={`flex-shrink-0 rounded-lg border px-3 py-1.5 text-[11px] font-medium transition-colors ${ctaStyle} ${ctaDisabled ? 'cursor-not-allowed opacity-50' : ''}`}>
           {ctaLabel}
         </button>
       </div>
@@ -179,161 +164,4 @@ export function UnifiedSkillCard({
   );
 }
 
-// Wrapper that handles all skill hooks and maps to UnifiedSkillCard
-interface ThirdPartySkillCardProps {
-  skill: SkillListEntry;
-  onSetup: () => void;
-  isInstalling?: boolean;
-}
-
-export function ThirdPartySkillCard({ skill, onSetup, isInstalling }: ThirdPartySkillCardProps) {
-  const connectionStatus = useSkillConnectionStatus(skill.id);
-  const statusDisplay = STATUS_DISPLAY[connectionStatus] ?? STATUS_DISPLAY.offline;
-  const skillState = useSkillState<SkillHostConnectionState & Record<string, unknown>>(skill.id);
-  const diskStats = useSkillDataDirectoryStats(skill.id, connectionStatus === 'connected');
-  const syncStats = useMemo((): SkillSyncStatsLike | undefined => {
-    const base: SkillSyncStatsLike = { ...diskStats };
-    const sc = skillState?.syncCount;
-    if (typeof sc === 'number' && Number.isFinite(sc)) base.syncCount = sc;
-    const last =
-      typeof skillState?.lastSyncAtMs === 'number'
-        ? skillState.lastSyncAtMs
-        : typeof skillState?.lastSyncTime === 'number'
-          ? skillState.lastSyncTime
-          : undefined;
-    if (last != null && Number.isFinite(last)) base.lastSyncAtMs = last;
-    if (
-      base.syncCount == null &&
-      base.lastSyncAtMs == null &&
-      base.localDataBytes == null &&
-      base.localFileCount == null
-    ) {
-      return undefined;
-    }
-    return base;
-  }, [diskStats, skillState]);
-
-  const [manualSyncing, setManualSyncing] = useState(false);
-  const [debugOpen, setDebugOpen] = useState(false);
-  const syncUi = useMemo(() => deriveSkillSyncUiState(skill.id, skillState), [skill.id, skillState]);
-  const syncSummaryText = useMemo(
-    () => deriveSkillSyncSummaryText(skillState, syncStats),
-    [skillState, syncStats]
-  );
-  const isSyncing = manualSyncing || syncUi.isSyncing;
-
-  const handleSync = async () => {
-    setManualSyncing(true);
-    try {
-      await skillManager.triggerSync(skill.id);
-    } catch (err) {
-      console.error(`Sync failed for ${skill.id}:`, err);
-    } finally {
-      setManualSyncing(false);
-    }
-  };
-
-  function statusDotClass(status: SkillConnectionStatus): string {
-    switch (status) {
-      case 'connected': return 'bg-sage-500';
-      case 'connecting': return 'bg-amber-500 animate-pulse';
-      case 'error': return 'bg-coral-500';
-      default: return 'bg-stone-400';
-    }
-  }
-
-  function ctaLabel(): string {
-    if (isInstalling) return 'Enabling...';
-    switch (connectionStatus) {
-      case 'offline': return 'Enable';
-      case 'setup_required': return 'Setup';
-      case 'error': return 'Retry';
-      default: return 'Manage';
-    }
-  }
-
-  function ctaVariant(): 'primary' | 'sage' | 'amber' {
-    if (connectionStatus === 'offline') return 'sage';
-    if (connectionStatus === 'error') return 'amber';
-    return 'primary';
-  }
-
-  const secondaryActions =
-    connectionStatus === 'connected'
-      ? [
-          {
-            label: 'Sync',
-            icon: (
-              <svg
-                className={`w-3.5 h-3.5 ${isSyncing ? 'animate-spin' : ''}`}
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24">
-                <path
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                  strokeWidth={2}
-                  d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"
-                />
-              </svg>
-            ),
-            onClick: () => void handleSync(),
-            disabled: isSyncing,
-            testId: `skill-sync-button-${skill.id}`,
-          },
-          {
-            label: 'Debug',
-            icon: (
-              <svg className="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                  strokeWidth={2}
-                  d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
-                />
-              </svg>
-            ),
-            onClick: () => setDebugOpen(true),
-            testId: `skill-debug-button-${skill.id}`,
-          },
-        ]
-      : undefined;
-
-  return (
-    <>
-      <UnifiedSkillCard
-        icon={skill.icon ?? <DefaultIcon />}
-        title={skill.name}
-        description={skill.description}
-        statusDot={statusDotClass(connectionStatus)}
-        statusLabel={statusDisplay.text}
-        statusColor={statusDisplay.color}
-        ctaLabel={ctaLabel()}
-        ctaVariant={ctaVariant()}
-        ctaDisabled={isInstalling}
-        onCtaClick={() => onSetup()}
-        secondaryActions={secondaryActions}
-        syncProgress={
-          isSyncing
-            ? {
-                active: true,
-                percent: syncUi.progressPercent ?? undefined,
-                message: syncUi.progressMessage ?? undefined,
-                metricsText: syncUi.metricsText ?? undefined,
-              }
-            : { active: false }
-        }
-        syncSummaryText={syncSummaryText ?? undefined}
-      />
-      {debugOpen && (
-        <SkillDebugModal
-          skillId={skill.id}
-          skillName={skill.name}
-          onClose={() => setDebugOpen(false)}
-        />
-      )}
-    </>
-  );
-}
-
 export default UnifiedSkillCard;
diff --git a/app/src/components/skills/SkillDebugModal.tsx b/app/src/components/skills/SkillDebugModal.tsx
deleted file mode 100644
index 8b36dd4ab..000000000
--- a/app/src/components/skills/SkillDebugModal.tsx
+++ /dev/null
@@ -1,385 +0,0 @@
-/**
- * Debug modal for inspecting a skill's runtime state and calling its tools.
- * Shows: snapshot metadata, published state, tool definitions, and a tool executor.
- */
-
-import { useState, useEffect, useRef, useCallback } from 'react';
-import { createPortal } from 'react-dom';
-
-import { useSkillSnapshot } from '../../lib/skills/hooks';
-import { callCoreRpc } from '../../services/coreRpcClient';
-import type { SkillSnapshotRpc } from '../../lib/skills/skillsApi';
-
-interface SkillDebugModalProps {
-  skillId: string;
-  skillName: string;
-  onClose: () => void;
-}
-
-interface ToolCallResult {
-  toolName: string;
-  result: unknown;
-  isError: boolean;
-  durationMs: number;
-}
-
-export default function SkillDebugModal({ skillId, skillName, onClose }: SkillDebugModalProps) {
-  const modalRef = useRef<HTMLDivElement>(null);
-  const snap = useSkillSnapshot(skillId);
-  const [activeTab, setActiveTab] = useState<'state' | 'tools'>('state');
-  const [expandedTool, setExpandedTool] = useState<string | null>(null);
-  const [toolArgs, setToolArgs] = useState<Record<string, string>>({});
-  const [toolLoading, setToolLoading] = useState<string | null>(null);
-  const [toolResult, setToolResult] = useState<ToolCallResult | null>(null);
-
-  // Escape key
-  useEffect(() => {
-    const handleEscape = (e: KeyboardEvent) => {
-      if (e.key === 'Escape') onClose();
-    };
-    document.addEventListener('keydown', handleEscape);
-    return () => document.removeEventListener('keydown', handleEscape);
-  }, [onClose]);
-
-  // Focus trap
-  useEffect(() => {
-    modalRef.current?.focus();
-  }, []);
-
-  const handleBackdropClick = (e: React.MouseEvent) => {
-    if (e.target === e.currentTarget) onClose();
-  };
-
-  const handleCallTool = useCallback(
-    async (toolName: string) => {
-      setToolLoading(toolName);
-      setToolResult(null);
-      const start = Date.now();
-      try {
-        // Parse args JSON
-        let args: Record<string, unknown> = {};
-        const rawArgs = toolArgs[toolName];
-        if (rawArgs?.trim()) {
-          args = JSON.parse(rawArgs);
-        }
-
-        const result = await callCoreRpc<{
-          content: Array<{ type: string; text?: string; data?: unknown }>;
-          is_error: boolean;
-        }>({
-          method: 'openhuman.skills_call_tool',
-          params: { skill_id: skillId, tool_name: toolName, arguments: args },
-        });
-
-        setToolResult({
-          toolName,
-          result,
-          isError: result.is_error ?? false,
-          durationMs: Date.now() - start,
-        });
-      } catch (err) {
-        setToolResult({
-          toolName,
-          result: err instanceof Error ? err.message : String(err),
-          isError: true,
-          durationMs: Date.now() - start,
-        });
-      } finally {
-        setToolLoading(null);
-      }
-    },
-    [skillId, toolArgs]
-  );
-
-  const formatJson = (value: unknown) => {
-    try {
-      return JSON.stringify(value, null, 2);
-    } catch {
-      return String(value);
-    }
-  };
-
-  const tabs = [
-    { id: 'state' as const, label: 'State' },
-    { id: 'tools' as const, label: `Tools (${snap?.tools.length ?? 0})` },
-  ];
-
-  const content = (
-    <div
-      className="fixed inset-0 z-[9999] bg-black/30 backdrop-blur-sm flex items-center justify-center p-4"
-      onClick={handleBackdropClick}
-      role="dialog"
-      aria-modal="true">
-      <div
-        ref={modalRef}
-        className="bg-white border border-stone-200 rounded-3xl shadow-large w-full max-w-[600px] max-h-[80vh] overflow-hidden animate-fade-up focus:outline-none"
-        style={{ animationDuration: '200ms' }}
-        tabIndex={-1}
-        onClick={e => e.stopPropagation()}>
-        {/* Header */}
-        <div className="p-4 border-b border-stone-200 flex items-center justify-between">
-          <div>
-            <h2 className="text-base font-semibold text-stone-900">
-              Debug: {skillName}
-            </h2>
-            <div className="flex items-center gap-2 mt-1">
-              <StatusBadge label={snap?.status ?? 'unknown'} />
-              <StatusBadge label={snap?.connection_status ?? 'unknown'} variant="blue" />
-              {snap?.setup_complete && <StatusBadge label="setup complete" variant="green" />}
-            </div>
-          </div>
-          <button
-            type="button"
-            onClick={onClose}
-            className="p-1 text-stone-400 hover:text-stone-900 transition-colors rounded-lg hover:bg-stone-100">
-            <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
-            </svg>
-          </button>
-        </div>
-
-        {/* Tabs */}
-        <div className="flex border-b border-stone-200">
-          {tabs.map(tab => (
-            <button
-              key={tab.id}
-              type="button"
-              data-testid={tab.id === 'tools' ? 'skill-debug-tab-tools' : 'skill-debug-tab-state'}
-              onClick={() => setActiveTab(tab.id)}
-              className={`flex-1 py-2 text-xs font-medium transition-colors ${
-                activeTab === tab.id
-                  ? 'text-primary-500 border-b-2 border-primary-500'
-                  : 'text-stone-600 hover:text-stone-700'
-              }`}>
-              {tab.label}
-            </button>
-          ))}
-        </div>
-
-        {/* Content */}
-        <div className="overflow-y-auto" style={{ maxHeight: 'calc(80vh - 140px)' }}>
-          {activeTab === 'state' && <StateTab snap={snap} formatJson={formatJson} />}
-          {activeTab === 'tools' && (
-            <ToolsTab
-              snap={snap}
-              expandedTool={expandedTool}
-              setExpandedTool={setExpandedTool}
-              toolArgs={toolArgs}
-              setToolArgs={setToolArgs}
-              toolLoading={toolLoading}
-              toolResult={toolResult}
-              onCallTool={handleCallTool}
-              formatJson={formatJson}
-            />
-          )}
-        </div>
-      </div>
-    </div>
-  );
-
-  return createPortal(content, document.body);
-}
-
-// --- Sub-components ---
-
-function StatusBadge({ label, variant = 'default' }: { label: string; variant?: 'default' | 'green' | 'blue' }) {
-  const colors = {
-    default: 'bg-stone-100 text-stone-600',
-    green: 'bg-sage-100 text-sage-600',
-    blue: 'bg-primary-100 text-primary-500',
-  };
-  return (
-    <span className={`px-2 py-0.5 text-[10px] font-mono rounded ${colors[variant]}`}>
-      {label}
-    </span>
-  );
-}
-
-function StateTab({
-  snap,
-  formatJson,
-}: {
-  snap: SkillSnapshotRpc | null;
-  formatJson: (v: unknown) => string;
-}) {
-  if (!snap) {
-    return <div className="p-4 text-sm text-stone-500">Skill not running. No state available.</div>;
-  }
-
-  const stateEntries = Object.entries(snap.state || {});
-
-  return (
-    <div className="p-4 space-y-3">
-      {/* Metadata */}
-      <Section title="Metadata">
-        <KV label="skill_id" value={snap.skill_id} />
-        <KV label="status" value={snap.status} />
-        <KV label="connection_status" value={snap.connection_status} />
-        <KV label="setup_complete" value={String(snap.setup_complete)} />
-        {snap.error && <KV label="error" value={snap.error} isError />}
-      </Section>
-
-      {/* Published state */}
-      <Section title={`Published State (${stateEntries.length} keys)`}>
-        {stateEntries.length === 0 ? (
-          <p className="text-xs text-stone-500 italic">No published state</p>
-        ) : (
-          <pre className="text-xs text-stone-700 font-mono bg-stone-50 rounded-lg p-3 overflow-x-auto whitespace-pre-wrap break-all max-h-64 overflow-y-auto">
-            {formatJson(snap.state)}
-          </pre>
-        )}
-      </Section>
-
-      {/* Raw snapshot */}
-      <Section title="Raw Snapshot">
-        <pre className="text-xs text-stone-600 font-mono bg-stone-50 rounded-lg p-3 overflow-x-auto whitespace-pre-wrap break-all max-h-48 overflow-y-auto">
-          {formatJson(snap)}
-        </pre>
-      </Section>
-    </div>
-  );
-}
-
-function ToolsTab({
-  snap,
-  expandedTool,
-  setExpandedTool,
-  toolArgs,
-  setToolArgs,
-  toolLoading,
-  toolResult,
-  onCallTool,
-  formatJson,
-}: {
-  snap: SkillSnapshotRpc | null;
-  expandedTool: string | null;
-  setExpandedTool: (name: string | null) => void;
-  toolArgs: Record<string, string>;
-  setToolArgs: (args: Record<string, string>) => void;
-  toolLoading: string | null;
-  toolResult: ToolCallResult | null;
-  onCallTool: (name: string) => void;
-  formatJson: (v: unknown) => string;
-}) {
-  if (!snap || snap.tools.length === 0) {
-    return <div className="p-4 text-sm text-stone-500">No tools available.</div>;
-  }
-
-  return (
-    <div className="p-3 space-y-1">
-      {snap.tools.map(tool => {
-        const isExpanded = expandedTool === tool.name;
-        const isLoading = toolLoading === tool.name;
-        const hasResult = toolResult?.toolName === tool.name;
-
-        return (
-          <div key={tool.name} className="border border-stone-200 rounded-xl overflow-hidden">
-            {/* Tool header */}
-            <button
-              type="button"
-              data-testid={`skill-debug-tool-header-${tool.name}`}
-              onClick={() => setExpandedTool(isExpanded ? null : tool.name)}
-              className="w-full flex items-center justify-between p-3 text-left hover:bg-stone-50 transition-colors">
-              <div className="min-w-0">
-                <span className="text-sm font-mono text-primary-500">{tool.name}</span>
-                <p className="text-xs text-stone-400 mt-0.5 line-clamp-1">{tool.description}</p>
-              </div>
-              <svg
-                className={`w-4 h-4 text-stone-500 flex-shrink-0 ml-2 transition-transform ${isExpanded ? 'rotate-180' : ''}`}
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
-              </svg>
-            </button>
-
-            {/* Expanded content */}
-            {isExpanded && (
-              <div className="px-3 pb-3 space-y-2 border-t border-stone-200">
-                {/* Input schema */}
-                {tool.inputSchema != null && (
-                  <div className="mt-2">
-                    <label className="text-[10px] font-medium text-stone-500 uppercase tracking-wider">
-                      Input Schema
-                    </label>
-                    <pre className="text-xs text-stone-600 font-mono bg-stone-50 rounded-lg p-2 mt-1 overflow-x-auto max-h-32 overflow-y-auto">
-                      {formatJson(tool.inputSchema)}
-                    </pre>
-                  </div>
-                )}
-
-                {/* Args input */}
-                <div>
-                  <label className="text-[10px] font-medium text-stone-500 uppercase tracking-wider">
-                    Arguments (JSON)
-                  </label>
-                  <textarea
-                    data-testid={`skill-debug-tool-args-${tool.name}`}
-                    value={toolArgs[tool.name] ?? '{}'}
-                    onChange={e => setToolArgs({ ...toolArgs, [tool.name]: e.target.value })}
-                    placeholder="{}"
-                    rows={3}
-                    className="w-full mt-1 px-3 py-2 text-xs font-mono bg-stone-50 border border-stone-200 rounded-lg text-stone-700 placeholder-stone-400 focus:outline-none focus:border-primary-500/50 resize-y"
-                  />
-                </div>
-
-                {/* Call button */}
-                <button
-                  type="button"
-                  data-testid={`skill-debug-execute-${tool.name}`}
-                  onClick={() => onCallTool(tool.name)}
-                  disabled={isLoading}
-                  className="w-full py-2 text-xs font-medium bg-primary-50 text-primary-500 border border-primary-500/30 rounded-lg hover:bg-primary-100 disabled:opacity-50 transition-colors flex items-center justify-center gap-2">
-                  {isLoading ? (
-                    <>
-                      <svg className="animate-spin w-3 h-3" fill="none" viewBox="0 0 24 24">
-                        <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                        <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
-                      </svg>
-                      Running...
-                    </>
-                  ) : (
-                    'Execute Tool'
-                  )}
-                </button>
-
-                {/* Result */}
-                {hasResult && toolResult && (
-                  <div className={`rounded-lg p-3 ${toolResult.isError ? 'bg-red-500/10 border border-red-500/30' : 'bg-sage-500/10 border border-sage-500/30'}`}>
-                    <div className="flex items-center justify-between mb-1">
-                      <span className={`text-[10px] font-medium uppercase tracking-wider ${toolResult.isError ? 'text-red-400' : 'text-sage-400'}`}>
-                        {toolResult.isError ? 'Error' : 'Result'}
-                      </span>
-                      <span className="text-[10px] text-stone-500">{toolResult.durationMs}ms</span>
-                    </div>
-                    <pre className="text-xs font-mono text-stone-700 whitespace-pre-wrap break-all max-h-48 overflow-y-auto">
-                      {formatJson(toolResult.result)}
-                    </pre>
-                  </div>
-                )}
-              </div>
-            )}
-          </div>
-        );
-      })}
-    </div>
-  );
-}
-
-function Section({ title, children }: { title: string; children: React.ReactNode }) {
-  return (
-    <div>
-      <h3 className="text-[10px] font-medium text-stone-500 uppercase tracking-wider mb-1.5">{title}</h3>
-      {children}
-    </div>
-  );
-}
-
-function KV({ label, value, isError }: { label: string; value: string; isError?: boolean }) {
-  return (
-    <div className="flex items-center gap-2 py-0.5">
-      <span className="text-xs text-stone-500 font-mono min-w-[120px]">{label}</span>
-      <span className={`text-xs font-mono ${isError ? 'text-red-500' : 'text-stone-700'}`}>{value}</span>
-    </div>
-  );
-}
diff --git a/app/src/components/skills/SkillManagementPanel.tsx b/app/src/components/skills/SkillManagementPanel.tsx
deleted file mode 100644
index 4d1bd2f8e..000000000
--- a/app/src/components/skills/SkillManagementPanel.tsx
+++ /dev/null
@@ -1,323 +0,0 @@
-/**
- * Management panel shown when clicking a connected (setupComplete) skill.
- * Displays connection status, configurable options, and action buttons.
- */
-
-import { useState, useEffect, useCallback } from "react";
-import {
-  useSkillSnapshot,
-  useSkillConnectionStatus,
-  useSkillConnectionInfo,
-  useSkillState,
-} from "../../lib/skills/hooks";
-import { skillManager } from "../../lib/skills/manager";
-import type {
-  SkillOptionDefinition,
-} from "../../lib/skills/types";
-
-interface SkillManagementPanelProps {
-  skillId: string;
-  onClose: () => void;
-  /** If provided, shows a "Re-run Setup" button. Omit for skills without setup. */
-  onReconfigure?: () => void;
-}
-
-
-export default function SkillManagementPanel({
-  skillId,
-  onClose,
-  onReconfigure,
-}: SkillManagementPanelProps) {
-  const snap = useSkillSnapshot(skillId);
-  const skill = snap ? { manifest: { id: snap.skill_id, name: snap.name }, tools: snap.tools } : undefined;
-  const connectionStatus = useSkillConnectionStatus(skillId);
-  const connectionInfo = useSkillConnectionInfo(skillId);
-  const skillState = useSkillState<{
-    syncInProgress?: boolean;
-    syncProgress?: number | null;
-    syncProgressMessage?: string | null;
-    syncCompleted?: boolean;
-    syncError?: string | null;
-    lastSyncTime?: number | null;
-    storage?: {
-      chatCount?: number;
-      messageCount?: number;
-      contactCount?: number;
-      unreadCount?: number;
-    };
-  }>(skillId);
-
-  const [options, setOptions] = useState<SkillOptionDefinition[]>([]);
-  const [togglingOption, setTogglingOption] = useState<string | null>(null);
-  const [restarting, setRestarting] = useState(false);
-  const [disconnecting, setDisconnecting] = useState(false);
-  const [confirmDisconnect, setConfirmDisconnect] = useState(false);
-
-  // Load options from the skill process
-  useEffect(() => {
-    let cancelled = false;
-    async function load() {
-      if (!skillManager.isSkillRunning(skillId)) return;
-      try {
-        const opts = await skillManager.listOptions(skillId);
-        if (!cancelled) setOptions(opts);
-      } catch {
-        // Skill may not support options
-      }
-    }
-    load();
-    return () => {
-      cancelled = true;
-    };
-  }, [skillId, connectionStatus]);
-
-  const handleToggleOption = useCallback(
-    async (name: string, currentValue: unknown) => {
-      setTogglingOption(name);
-      try {
-        const newValue = !currentValue;
-        await skillManager.setOption(skillId, name, newValue);
-        const opts = await skillManager.listOptions(skillId);
-        setOptions(opts);
-      } catch (err) {
-        console.error("[SkillManagementPanel] Toggle option failed:", err);
-      } finally {
-        setTogglingOption(null);
-      }
-    },
-    [skillId],
-  );
-
-  const handleSelectOption = useCallback(
-    async (name: string, value: string) => {
-      setTogglingOption(name);
-      try {
-        await skillManager.setOption(skillId, name, value);
-        const opts = await skillManager.listOptions(skillId);
-        setOptions(opts);
-      } catch (err) {
-        console.error("[SkillManagementPanel] Set option failed:", err);
-      } finally {
-        setTogglingOption(null);
-      }
-    },
-    [skillId],
-  );
-
-  const handleRestart = useCallback(async () => {
-    if (!skill?.manifest) return;
-    setRestarting(true);
-    try {
-      // await skillManager.stopSkill(skillId);
-      // await skillManager.startSkill(skill.manifest);
-      await skillManager.triggerSync(skillId);
-    } catch (err) {
-      console.error("[SkillManagementPanel] Restart failed:", err);
-    } finally {
-      setRestarting(false);
-    }
-  }, [skillId, skill?.manifest]);
-
-  const handleDisconnect = useCallback(async () => {
-    setDisconnecting(true);
-    try {
-      await skillManager.disconnectSkill(skillId);
-      onClose();
-    } catch (err) {
-      console.error("[SkillManagementPanel] Disconnect failed:", err);
-      setDisconnecting(false);
-    }
-  }, [skillId, onClose]);
-
-  const handleSync = useCallback(async () => {
-    try {
-      await skillManager.triggerSync(skillId);
-    } catch (err) {
-      console.error("[SkillManagementPanel] Sync trigger failed:", err);
-    }
-  }, [skillId]);
-
-  const syncInProgress = skillState?.syncInProgress ?? false;
-  const syncProgress = skillState?.syncProgress ?? null;
-  const syncProgressMessage = skillState?.syncProgressMessage ?? null;
-  const syncCompleted = skillState?.syncCompleted ?? false;
-  const syncError = skillState?.syncError ?? null;
-  const lastSyncTime = skillState?.lastSyncTime ?? null;
-  // const storage = skillState?.storage;
-  const hasSyncSupport = syncCompleted || syncInProgress || syncError !== null;
-
-  return (
-    <div className="space-y-4">
-      {/* Error message */}
-      {connectionInfo.error && (
-        <div className="text-xs text-coral-400 bg-coral-500/10 border border-coral-500/20 rounded-lg px-3 py-2 break-words">
-          {connectionInfo.error}
-        </div>
-      )}
-
-      {/* Data Sync */}
-      {hasSyncSupport && (
-        <div className="space-y-2">
-          <div className="flex items-center justify-between px-0.5">
-            <div className="text-xs font-medium text-stone-400">Data Sync</div>
-            <button
-              onClick={handleSync}
-              disabled={syncInProgress || connectionStatus !== "connected"}
-              className="px-2.5 py-1 text-[11px] font-medium text-primary-300 bg-primary-500/10 border border-primary-500/30 rounded-lg hover:bg-primary-500/20 transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
-            >
-              {syncInProgress ? "Syncing..." : "Sync Now"}
-            </button>
-          </div>
-
-          {syncInProgress && (
-            <div className="rounded-lg bg-stone-800/40 border border-stone-700/40 px-3 py-2.5 space-y-2">
-              {syncProgressMessage && (
-                <div className="text-[11px] text-stone-400 truncate">
-                  {syncProgressMessage}
-                </div>
-              )}
-              <div className="flex items-center gap-2">
-                <div className="flex-1 h-1.5 bg-stone-700/60 rounded-full overflow-hidden">
-                  <div
-                    className="h-full bg-primary-500 rounded-full transition-all duration-300 ease-out"
-                    style={{ width: `${syncProgress ?? 0}%` }}
-                  />
-                </div>
-                {syncProgress !== null && (
-                  <span className="text-[11px] text-stone-500 tabular-nums w-8 text-right">
-                    {syncProgress}%
-                  </span>
-                )}
-              </div>
-            </div>
-          )}
-
-          {!syncInProgress && syncError && (
-            <div className="text-[11px] text-coral-400 bg-coral-500/10 border border-coral-500/20 rounded-lg px-3 py-2 break-words">
-              Sync failed: {syncError}
-            </div>
-          )}
-
-          {!syncInProgress && syncCompleted && (
-            <div className="rounded-lg bg-stone-800/40 border border-stone-700/40 px-3 py-2">
-              {lastSyncTime && (
-                <div className="text-[11px] text-stone-400">
-                  Last synced: {new Date(lastSyncTime).toLocaleString()}
-                </div>
-              )}
-              {/* {storage && (storage.chatCount > 0 || storage.messageCount > 0 || storage.contactCount > 0) && (
-                <div className="text-[11px] text-stone-500 mt-0.5">
-                  {[
-                    storage.chatCount > 0 && `${storage.chatCount} chats`,
-                    storage.messageCount > 0 && `${storage.messageCount.toLocaleString()} messages`,
-                    storage.contactCount > 0 && `${storage.contactCount} contacts`,
-                  ].filter(Boolean).join(" \u00B7 ")}
-                </div>
-              )} */}
-            </div>
-          )}
-        </div>
-      )}
-
-      {/* Options */}
-      {options.length > 0 && (
-        <div className="space-y-1">
-          <div className="text-xs font-medium text-stone-400 px-0.5 mb-2">
-            Options
-          </div>
-          {options.map((opt) => (
-            <div
-              key={opt.name}
-              className="flex items-center justify-between rounded-lg bg-stone-800/40 border border-stone-700/40 px-3 py-2.5"
-            >
-              <div className="min-w-0 mr-3">
-                <div className="text-xs font-medium text-stone-200">
-                  {opt.label}
-                </div>
-                {opt.description && (
-                  <div className="text-[11px] text-stone-500 mt-0.5 line-clamp-1">
-                    {opt.description}
-                  </div>
-                )}
-              </div>
-              {opt.type === "boolean" && (
-                <button
-                  onClick={() => handleToggleOption(opt.name, opt.value)}
-                  disabled={togglingOption === opt.name}
-                  className={`relative flex-shrink-0 w-9 h-5 rounded-full transition-colors duration-200 ${opt.value ? "bg-primary-500" : "bg-stone-600"
-                    } ${togglingOption === opt.name ? "opacity-50" : ""}`}
-                >
-                  <span
-                    className={`absolute top-0.5 left-0.5 w-4 h-4 bg-white rounded-full shadow transition-transform duration-200 ${opt.value ? "translate-x-4" : "translate-x-0"
-                      }`}
-                  />
-                </button>
-              )}
-              {opt.type === "select" && opt.options && (
-                <select
-                  value={String(opt.value ?? "")}
-                  onChange={(e) => handleSelectOption(opt.name, e.target.value)}
-                  disabled={togglingOption === opt.name}
-                  className={`flex-shrink-0 text-xs bg-stone-700/60 border border-stone-600/50 text-stone-200 rounded-lg px-2 py-1.5 outline-none focus:border-primary-500/50 transition-colors ${
-                    togglingOption === opt.name ? "opacity-50" : ""
-                  }`}
-                >
-                  {opt.options.map((o) => (
-                    <option key={o.value} value={o.value}>
-                      {o.label}
-                    </option>
-                  ))}
-                </select>
-              )}
-            </div>
-          ))}
-        </div>
-      )}
-
-      {/* Action buttons — single row */}
-      <div className="pt-1">
-        {!confirmDisconnect ? (
-          <div className="flex space-x-2">
-            <button
-              onClick={handleRestart}
-              disabled={restarting}
-              className="flex-1 px-3 py-2 text-xs font-medium text-white bg-stone-700/60 border border-stone-600/50 rounded-xl hover:bg-stone-700 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-            >
-              {restarting ? "Restarting..." : "Restart"}
-            </button>
-            {onReconfigure && (
-              <button
-                onClick={onReconfigure}
-                className="flex-1 px-3 py-2 text-xs font-medium text-primary-300 bg-primary-500/10 border border-primary-500/30 rounded-xl hover:bg-primary-500/20 transition-colors"
-              >
-                Re-run Setup
-              </button>
-            )}
-            <button
-              onClick={() => setConfirmDisconnect(true)}
-              className="flex-1 px-3 py-2 text-xs font-medium text-coral-400 bg-coral-500/10 border border-coral-500/30 rounded-xl hover:bg-coral-500/20 transition-colors"
-            >
-              Disconnect
-            </button>
-          </div>
-        ) : (
-          <div className="flex space-x-2">
-            <button
-              onClick={() => setConfirmDisconnect(false)}
-              className="flex-1 px-3 py-2 text-xs font-medium text-stone-400 bg-stone-800/50 border border-stone-700 rounded-xl hover:bg-stone-800 transition-colors"
-            >
-              Cancel
-            </button>
-            <button
-              onClick={handleDisconnect}
-              disabled={disconnecting}
-              className="flex-1 px-3 py-2 text-xs font-medium text-white bg-coral-500 rounded-xl hover:bg-coral-600 transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-            >
-              {disconnecting ? "Disconnecting..." : "Confirm Disconnect"}
-            </button>
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}
diff --git a/app/src/components/skills/SkillSetupModal.tsx b/app/src/components/skills/SkillSetupModal.tsx
deleted file mode 100644
index d36ca431e..000000000
--- a/app/src/components/skills/SkillSetupModal.tsx
+++ /dev/null
@@ -1,188 +0,0 @@
-/**
- * Modal wrapper for the skill setup wizard or management panel.
- * Shows management view for connected skills, setup wizard otherwise.
- * Uses createPortal like the settings modal system.
- */
-
-import { useState, useEffect, useRef } from "react";
-import { createPortal } from "react-dom";
-import { useSkillSnapshot } from "../../lib/skills/hooks";
-import SkillSetupWizard from "./SkillSetupWizard";
-import SkillManagementPanel from "./SkillManagementPanel";
-
-interface SkillSetupModalProps {
-  skillId: string;
-  skillName: string;
-  skillDescription: string;
-  /** Whether this skill has interactive setup hooks. */
-  hasSetup?: boolean;
-  skillType?: 'openhuman' | 'openclaw';
-  onClose: () => void;
-}
-
-export default function SkillSetupModal({
-  skillId,
-  skillName,
-  skillDescription,
-  hasSetup = true,
-  skillType = 'openhuman',
-  onClose,
-}: SkillSetupModalProps) {
-  const modalRef = useRef<HTMLDivElement>(null);
-  const snap = useSkillSnapshot(skillId);
-  const setupComplete = snap?.setup_complete ?? false;
-  // Lock the mode in once we have a concrete snapshot — `useSkillSnapshot`
-  // returns `null` on the first render while it fetches, so reading
-  // `setup_complete` at mount time would always see `false` and wrongly
-  // default an already-connected skill into the setup wizard.
-  //
-  // We keep `sessionMode` stable after the first resolution so that an
-  // OAuth flow that flips `setup_complete` to true mid-wizard does not
-  // yank the user out of the wizard's own "complete" success screen.
-  // The user can still switch modes explicitly via `setMode` below
-  // (e.g. SkillManagementPanel's "Reconfigure" button).
-  const [sessionMode, setSessionMode] = useState<"manage" | "setup" | null>(
-    () => (!hasSetup ? "manage" : null),
-  );
-
-  useEffect(() => {
-    if (sessionMode !== null) return;
-    // Wait for the first concrete snapshot before deciding.
-    if (snap === null) return;
-    setSessionMode(setupComplete ? "manage" : "setup");
-  }, [sessionMode, snap, setupComplete]);
-
-  const setMode = (m: "manage" | "setup") => setSessionMode(m);
-  const mode = sessionMode;
-
-  // Handle escape key
-  useEffect(() => {
-    const handleEscape = (e: KeyboardEvent) => {
-      if (e.key === "Escape") {
-        onClose();
-      }
-    };
-
-    document.addEventListener("keydown", handleEscape);
-    return () => document.removeEventListener("keydown", handleEscape);
-  }, [onClose]);
-
-  // Focus management
-  useEffect(() => {
-    const previousFocus = document.activeElement as HTMLElement;
-    if (modalRef.current) {
-      modalRef.current.focus();
-    }
-    return () => {
-      if (previousFocus?.focus) {
-        previousFocus.focus();
-      }
-    };
-  }, []);
-
-  const handleBackdropClick = (e: React.MouseEvent) => {
-    if (e.target === e.currentTarget) {
-      onClose();
-    }
-  };
-
-  const headerTitle =
-    mode === null
-      ? skillName
-      : mode === "manage"
-        ? `Manage ${skillName}`
-        : `Connect ${skillName}`;
-
-  const modalContent = (
-    <div
-      className="fixed inset-0 z-[9999] bg-black/30 backdrop-blur-sm flex items-center justify-center p-4"
-      onClick={handleBackdropClick}
-      role="dialog"
-      aria-modal="true"
-      aria-labelledby="skill-setup-title"
-    >
-      <div
-        ref={modalRef}
-        className="bg-white border border-stone-200 rounded-3xl shadow-large w-full max-w-[460px] overflow-hidden animate-fade-up focus:outline-none focus:ring-0"
-        style={{
-          animationDuration: "200ms",
-          animationTimingFunction: "cubic-bezier(0.25, 0.46, 0.45, 0.94)",
-          animationFillMode: "both",
-        }}
-        tabIndex={-1}
-        onClick={(e) => e.stopPropagation()}
-      >
-        {/* Header */}
-        <div className="p-4 border-b border-stone-200">
-          <div className="flex items-start justify-between">
-            <div className="flex-1 min-w-0 pr-2">
-              <div className="flex items-center gap-2">
-                <h2
-                  id="skill-setup-title"
-                  className="text-base font-semibold text-stone-900"
-                >
-                  {headerTitle}
-                </h2>
-                <span
-                  className={`px-1.5 py-0.5 text-[10px] font-medium rounded-md ${
-                    skillType === 'openclaw'
-                      ? 'bg-violet-500/15 text-violet-400'
-                      : 'bg-sage-500/15 text-sage-400'
-                  }`}
-                >
-                  {skillType}
-                </span>
-              </div>
-              {skillDescription && (
-                <p className="text-xs text-stone-400 mt-1.5 line-clamp-2">
-                  {skillDescription}
-                </p>
-              )}
-            </div>
-            <button
-              onClick={onClose}
-              className="p-1 text-stone-400 hover:text-stone-900 transition-colors rounded-lg hover:bg-stone-100 flex-shrink-0"
-            >
-              <svg
-                className="w-5 h-5"
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-              >
-                <path
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                  strokeWidth={2}
-                  d="M6 18L18 6M6 6l12 12"
-                />
-              </svg>
-            </button>
-          </div>
-        </div>
-
-        {/* Content */}
-        <div className="p-4">
-          {mode === null ? (
-            <div className="flex items-center justify-center py-8 text-sm text-stone-400">
-              Loading…
-            </div>
-          ) : mode === "manage" ? (
-            <SkillManagementPanel
-              skillId={skillId}
-              onClose={onClose}
-              onReconfigure={hasSetup ? () => setMode("setup") : undefined}
-            />
-          ) : (
-            <SkillSetupWizard
-              skillId={skillId}
-              onComplete={onClose}
-              onCancel={setupComplete ? () => setMode("manage") : onClose}
-            />
-          )}
-        </div>
-      </div>
-    </div>
-  );
-
-  return createPortal(modalContent, document.body);
-}
diff --git a/app/src/components/skills/SkillSetupWizard.tsx b/app/src/components/skills/SkillSetupWizard.tsx
deleted file mode 100644
index 9af036ebd..000000000
--- a/app/src/components/skills/SkillSetupWizard.tsx
+++ /dev/null
@@ -1,992 +0,0 @@
-/**
- * Multi-step setup wizard for a single skill.
- *
- * Supports two sequential phases:
- * 1. **Auth phase** (optional): If the skill declares `setup.auth`, the user
- *    picks an auth mode (managed / self_hosted / text), enters credentials,
- *    and the skill validates them via `onAuthComplete`.
- * 2. **Setup phase**: The normal setup flow runs (`onSetupStart` → form steps
- *    → `onSetupSubmit`).
- *
- * For legacy skills with only `setup.oauth`, the OAuth config is auto-synthesized
- * as a single "managed" auth mode.
- */
-
-import { useState, useEffect, useCallback, useRef } from "react";
-import { useSkillSnapshot } from "../../lib/skills/hooks.ts";
-import { skillManager } from "../../lib/skills/manager.ts";
-import { getSkillSnapshot, installSkill, listAvailable, setSetupComplete, startSkill } from "../../lib/skills/skillsApi.ts";
-import { callCoreRpc } from "../../services/coreRpcClient.ts";
-import { apiClient } from "../../services/apiClient.ts";
-import { openUrl } from "../../utils/openUrl.ts";
-import type { SetupStep, SetupFieldError, AuthMode, SkillAuthConfig } from "../../lib/skills/types.ts";
-import SetupFormRenderer from "./SetupFormRenderer.tsx";
-import AuthModeSelector from "./AuthModeSelector.tsx";
-import { IS_DEV } from "../../utils/config.ts";
-
-const SKILL_RUNNING_WAIT_MS = 10_000;
-const SKILL_RUNNING_POLL_MS = 250;
-
-/** Poll `skills_status` until the lifecycle reports `running` (or throw on error / timeout). */
-const waitForSkillRunning = async (skillId: string): Promise<void> => {
-  const deadline = Date.now() + SKILL_RUNNING_WAIT_MS;
-  while (Date.now() < deadline) {
-    const snapshot = await getSkillSnapshot(skillId);
-    if (snapshot.status === "running") return;
-    if (snapshot.status === "error") {
-      throw new Error(snapshot.error ? String(snapshot.error) : "Skill failed to start");
-    }
-    await new Promise<void>(resolve => {
-      setTimeout(resolve, SKILL_RUNNING_POLL_MS);
-    });
-  }
-  throw new Error("Timed out waiting for skill to start");
-};
-
-interface SkillSetupWizardProps {
-  skillId: string;
-  onComplete: () => void;
-  onCancel: () => void;
-}
-
-interface OAuthConfig {
-  provider: string;
-  scopes: string[];
-}
-
-type WizardState =
-  // Auth phases
-  | { phase: "loading" }
-  | { phase: "auth_mode_select"; auth: SkillAuthConfig }
-  | { phase: "auth_form"; mode: AuthMode; errors?: SetupFieldError[] | null }
-  | { phase: "auth_submitting"; mode: AuthMode }
-  | { phase: "auth_managed_waiting"; mode: AuthMode }
-  // Legacy OAuth (when no setup.auth, only setup.oauth)
-  | { phase: "oauth"; oauth: OAuthConfig }
-  | { phase: "oauth_waiting"; oauth: OAuthConfig }
-  // Setup phases (run after auth succeeds, or directly for non-auth skills)
-  | { phase: "step"; step: SetupStep; errors?: SetupFieldError[] | null }
-  | { phase: "submitting"; step: SetupStep }
-  | { phase: "complete"; message?: string }
-  | { phase: "error"; message: string };
-
-export default function SkillSetupWizard({
-  skillId,
-  onComplete,
-  onCancel,
-}: SkillSetupWizardProps) {
-  const [state, setState] = useState<WizardState>({ phase: "loading" });
-  /** Ensures managed OAuth auto-advance runs once per browser-login attempt. */
-  const managedOAuthAdvancedRef = useRef(false);
-  /** Ensures legacy OAuth persistence + complete runs once per connected transition. */
-  const legacyOAuthAdvancedRef = useRef(false);
-
-  useEffect(() => {
-    managedOAuthAdvancedRef.current = false;
-    legacyOAuthAdvancedRef.current = false;
-  }, [skillId]);
-
-  // Watch skill snapshot for OAuth/managed completion
-  const snap = useSkillSnapshot(skillId);
-  const isConnected = snap?.connection_status === "connected" || snap?.setup_complete === true;
-
-  // --- Transition from auth to setup ---
-
-  const transitionToSetup = useCallback(async () => {
-    try {
-      // Ensure skill runtime is running.
-      // Note: if the skill is already running, startSkill returns Ok (not an
-      // error), so any exception here is a real failure that must surface.
-      await startSkill(skillId);
-      await waitForSkillRunning(skillId);
-
-      const firstStep = await skillManager.startSetup(skillId);
-      if (!firstStep) {
-        // No setup steps needed — auth alone is sufficient
-        await setSetupComplete(skillId, true);
-        setState({ phase: "complete", message: "Successfully connected!" });
-      } else {
-        setState({ phase: "step", step: firstStep });
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      setState({ phase: "error", message: msg });
-    }
-  }, [skillId]);
-
-  // --- Managed OAuth ---
-
-  const handleManagedAuth = useCallback(
-    async (mode: AuthMode) => {
-      if (!mode.provider) {
-        setState({ phase: "error", message: "Managed mode requires a provider." });
-        return;
-      }
-      try {
-        const shouldShowJson = IS_DEV ? 'responseType=json&' : '';
-        const data = await apiClient.get<{ oauthUrl?: string }>(
-          `/auth/${mode.provider}/connect?${shouldShowJson}skillId=${skillId}&encryptionMode=encrypted`,
-        );
-        if (!data.oauthUrl) {
-          setState({ phase: "error", message: "Failed to get OAuth URL from backend." });
-          return;
-        }
-        await openUrl(data.oauthUrl);
-        managedOAuthAdvancedRef.current = false;
-        setState({ phase: "auth_managed_waiting", mode });
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        setState({ phase: "error", message: `OAuth connection failed: ${msg}` });
-      }
-    },
-    [skillId],
-  );
-
-  // --- Auth mode selection ---
-
-  const handleAuthModeSelected = useCallback(
-    (mode: AuthMode) => {
-      if (mode.type === "managed") {
-        handleManagedAuth(mode);
-      } else {
-        // self_hosted or text: show credential form
-        setState({ phase: "auth_form", mode });
-      }
-    },
-    [handleManagedAuth],
-  );
-
-  // --- Auth form submission ---
-
-  const handleAuthFormSubmit = useCallback(
-    async (values: Record<string, unknown>) => {
-      if (state.phase !== "auth_form") return;
-
-      const { mode } = state;
-      setState({ phase: "auth_submitting", mode });
-
-      try {
-        // Ensure skill runtime is running.
-        // Note: if the skill is already running, startSkill returns Ok (not an
-        // error), so any exception here is a real failure that must surface.
-        await startSkill(skillId);
-        await waitForSkillRunning(skillId);
-
-        // Build credential payload
-        const credentials =
-          mode.type === "text"
-            ? { content: values.content }
-            : values;
-
-        // Send auth/complete RPC to skill
-        const result = await callCoreRpc({
-          method: "openhuman.skills_rpc",
-          params: {
-            skill_id: skillId,
-            method: "auth/complete",
-            params: { mode: mode.type, credentials },
-          },
-        }) as { status?: string; errors?: SetupFieldError[]; message?: string } | null;
-
-        if (result?.status === "error" && result.errors) {
-          setState({ phase: "auth_form", mode, errors: result.errors });
-          return;
-        }
-
-        if (result?.status === "error") {
-          setState({
-            phase: "error",
-            message: result.message ?? "Auth validation failed.",
-          });
-          return;
-        }
-
-        // Auth succeeded — transition to setup phase
-        await transitionToSetup();
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        setState({ phase: "error", message: msg });
-      }
-    },
-    [state, skillId, transitionToSetup],
-  );
-
-  // Detect managed OAuth completion
-  useEffect(() => {
-    if (state.phase === "auth_managed_waiting" && isConnected) {
-      if (managedOAuthAdvancedRef.current) return;
-      managedOAuthAdvancedRef.current = true;
-      void (async () => {
-        try {
-          await startSkill(skillId);
-          await waitForSkillRunning(skillId);
-        } catch (e) {
-          console.warn("[SkillSetupWizard] post-OAuth startSkill:", e);
-          setState({ phase: "error", message: "Failed to start skill after OAuth." });
-          return;
-        }
-        try {
-          const firstStep = await skillManager.startSetup(skillId);
-          if (firstStep) {
-            setState({ phase: "step", step: firstStep });
-          } else {
-            await setSetupComplete(skillId, true);
-            setState({
-              phase: "complete",
-              message: "Successfully connected! You can close this window.",
-            });
-          }
-        } catch (e) {
-          console.warn("[SkillSetupWizard] post-OAuth startSetup:", e);
-          setState({ phase: "error", message: "Setup failed" });
-        }
-      })();
-      return;
-    }
-    // Legacy OAuth completion
-    if (
-      (state.phase === "oauth" || state.phase === "oauth_waiting") &&
-      isConnected
-    ) {
-      if (legacyOAuthAdvancedRef.current) return;
-      legacyOAuthAdvancedRef.current = true;
-      void (async () => {
-        try {
-          await setSetupComplete(skillId, true);
-          setState({
-            phase: "complete",
-            message:
-              "Successfully connected! You can close this window.",
-          });
-        } catch (e) {
-          console.warn("[SkillSetupWizard] legacy OAuth setSetupComplete:", e);
-          legacyOAuthAdvancedRef.current = false;
-          setState({
-            phase: "error",
-            message: "Failed to save setup state.",
-          });
-        }
-      })();
-    }
-  }, [isConnected, state.phase, skillId]);
-
-  // Start the setup flow on mount
-  useEffect(() => {
-    let cancelled = false;
-
-    async function initSetup() {
-      try {
-        console.log("[SkillSetupWizard] initSetup", skillId);
-
-        const available = await listAvailable();
-        const entry = available.find(e => e.id === skillId);
-
-        if (!entry) {
-          if (!cancelled) {
-            setState({
-              phase: "error",
-              message: "Skill not found in registry. Try refreshing the page.",
-            });
-          }
-          return;
-        }
-
-        const setup = entry.setup as {
-          required?: boolean;
-          oauth?: OAuthConfig;
-          auth?: SkillAuthConfig;
-        } | null | undefined;
-
-        // Priority 1: Advanced auth config
-        if (setup?.auth && setup.auth.modes.length > 0) {
-          if (!cancelled) {
-            if (setup.auth.modes.length === 1) {
-              const mode = setup.auth.modes[0];
-              handleAuthModeSelected(mode);
-            } else {
-              setState({ phase: "auth_mode_select", auth: setup.auth });
-            }
-          }
-          return;
-        }
-
-        // Priority 2: Legacy OAuth config
-        if (setup?.oauth) {
-          if (!cancelled) {
-            setState({
-              phase: "oauth",
-              oauth: {
-                provider: setup.oauth.provider,
-                scopes: setup.oauth.scopes,
-              },
-            });
-          }
-          return;
-        }
-
-        // Priority 3: Non-auth — start form-based setup directly
-        try {
-          await startSkill(skillId);
-          console.log("[SkillSetupWizard] skill started via RPC", skillId);
-          await waitForSkillRunning(skillId);
-        } catch (startErr) {
-          console.warn("[SkillSetupWizard] runtime start failed:", startErr);
-          if (!cancelled) {
-            const msg = startErr instanceof Error ? startErr.message : String(startErr);
-            setState({ phase: "error", message: msg });
-          }
-          return;
-        }
-
-        if (cancelled) return;
-
-        console.log("[SkillSetupWizard] starting setup", skillId);
-        const firstStep = await skillManager.startSetup(skillId);
-        console.log("[SkillSetupWizard] setup started", skillId, firstStep);
-        if (!cancelled) {
-          if (!firstStep) {
-            setState({
-              phase: "error",
-              message: "This skill requires setup but no setup steps were returned. Try restarting the app.",
-            });
-          } else {
-            setState({ phase: "step", step: firstStep });
-          }
-        }
-      } catch (err) {
-        if (!cancelled) {
-          const msg = err instanceof Error ? err.message : String(err);
-          setState({ phase: "error", message: msg });
-        }
-      }
-    }
-
-    initSetup();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [skillId, handleAuthModeSelected]);
-
-  // --- Setup form submission (existing flow) ---
-
-  const handleSetupSubmit = useCallback(
-    async (values: Record<string, unknown>) => {
-      if (state.phase !== "step") return;
-
-      const currentStep = state.step;
-      setState({ phase: "submitting", step: currentStep });
-
-      try {
-        const result = await skillManager.submitSetup(
-          skillId,
-          currentStep.id,
-          values,
-        );
-
-        switch (result.status) {
-          case "next":
-            if (result.nextStep) {
-              setState({ phase: "step", step: result.nextStep });
-            }
-            break;
-          case "error":
-            setState({
-              phase: "step",
-              step: currentStep,
-              errors: result.errors,
-            });
-            break;
-          case "complete":
-            setState({
-              phase: "complete",
-              message: result.message ?? "Setup complete!",
-            });
-            break;
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        setState({ phase: "error", message: msg });
-      }
-    },
-    [state, skillId],
-  );
-
-  // --- Legacy OAuth handler ---
-
-  const handleOAuthLogin = useCallback(async () => {
-    if (state.phase !== "oauth") return;
-
-    const { oauth } = state;
-
-    try {
-      const shouldShowJson = IS_DEV ? 'responseType=json&' : '';
-      const data = await apiClient.get<{ oauthUrl?: string }>(
-        `/auth/${oauth.provider}/connect?${shouldShowJson}skillId=${skillId}`,
-      );
-
-      if (!data.oauthUrl) {
-        console.error("[SkillSetupWizard] Backend did not return oauthUrl:", data);
-        setState({ phase: "error", message: "Failed to get OAuth URL from backend." });
-        return;
-      }
-
-      await openUrl(data.oauthUrl);
-      setState({ phase: "oauth_waiting", oauth });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error("[SkillSetupWizard] OAuth connect error:", err);
-      setState({ phase: "error", message: `OAuth connection failed: ${msg}` });
-    }
-  }, [state, skillId]);
-
-  // --- Cancel ---
-
-  const handleCancel = useCallback(async () => {
-    if (
-      state.phase !== "oauth" &&
-      state.phase !== "oauth_waiting" &&
-      state.phase !== "auth_mode_select" &&
-      state.phase !== "auth_form" &&
-      state.phase !== "auth_managed_waiting"
-    ) {
-      try {
-        await skillManager.cancelSetup(skillId);
-      } catch {
-        // Ignore cancel errors
-      }
-    }
-    onCancel();
-  }, [skillId, onCancel, state.phase]);
-
-  // --- Render ---
-
-  switch (state.phase) {
-    case "loading":
-      return <LoadingView />;
-
-    case "auth_mode_select":
-      return (
-        <div className="py-4">
-          <AuthModeSelector
-            modes={state.auth.modes}
-            onSelect={handleAuthModeSelected}
-          />
-          <div className="mt-4">
-            <button
-              onClick={handleCancel}
-              className="w-full py-2.5 text-sm font-medium text-stone-600 bg-stone-100 border border-stone-200 rounded-xl hover:bg-stone-200 transition-colors"
-            >
-              Cancel
-            </button>
-          </div>
-        </div>
-      );
-
-    case "auth_form":
-      return (
-        <SetupFormRenderer
-          step={buildAuthFormStep(state.mode)}
-          errors={state.errors}
-          loading={false}
-          onSubmit={handleAuthFormSubmit}
-          onCancel={handleCancel}
-        />
-      );
-
-    case "auth_submitting":
-      return (
-        <SetupFormRenderer
-          step={buildAuthFormStep(state.mode)}
-          loading={true}
-          onSubmit={() => {}}
-          onCancel={() => {}}
-        />
-      );
-
-    case "auth_managed_waiting":
-      return (
-        <OAuthLoginView
-          provider={state.mode.provider ?? "service"}
-          onLogin={() => handleManagedAuth(state.mode)}
-          onCancel={handleCancel}
-          waiting={true}
-          skillId={skillId}
-          onManualComplete={transitionToSetup}
-        />
-      );
-
-    case "oauth":
-      return (
-        <OAuthLoginView
-          provider={state.oauth.provider}
-          onLogin={handleOAuthLogin}
-          onCancel={handleCancel}
-          waiting={false}
-        />
-      );
-
-    case "oauth_waiting":
-      return (
-        <OAuthLoginView
-          provider={state.oauth.provider}
-          onLogin={handleOAuthLogin}
-          onCancel={handleCancel}
-          waiting={true}
-        />
-      );
-
-    case "step":
-      return (
-        <SetupFormRenderer
-          step={state.step}
-          errors={state.errors}
-          loading={false}
-          onSubmit={handleSetupSubmit}
-          onCancel={handleCancel}
-        />
-      );
-
-    case "submitting":
-      return (
-        <SetupFormRenderer
-          step={state.step}
-          loading={true}
-          onSubmit={() => {}}
-          onCancel={() => {}}
-        />
-      );
-
-    case "complete":
-      return (
-        <div className="text-center py-8">
-          <div className="w-12 h-12 mx-auto mb-4 rounded-full bg-sage-500/20 flex items-center justify-center">
-            <svg
-              className="w-6 h-6 text-sage-500"
-              fill="none"
-              stroke="currentColor"
-              viewBox="0 0 24 24"
-            >
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M5 13l4 4L19 7"
-              />
-            </svg>
-          </div>
-          <h3 className="text-lg font-semibold text-stone-900 mb-2">
-            Connected!
-          </h3>
-          {state.message && (
-            <p className="text-sm text-stone-600 mb-6">{state.message}</p>
-          )}
-          <button
-            onClick={onComplete}
-            className="px-6 py-2.5 text-sm font-medium text-white bg-primary-500 rounded-xl hover:bg-primary-600 transition-colors"
-          >
-            Done
-          </button>
-        </div>
-      );
-
-    case "error":
-      return (
-        <div className="text-center py-8">
-          <div className="w-12 h-12 mx-auto mb-4 rounded-full bg-coral-500/20 flex items-center justify-center">
-            <svg
-              className="w-6 h-6 text-coral-500"
-              fill="none"
-              stroke="currentColor"
-              viewBox="0 0 24 24"
-            >
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M6 18L18 6M6 6l12 12"
-              />
-            </svg>
-          </div>
-          <h3 className="text-lg font-semibold text-stone-900 mb-2">
-            Setup Failed
-          </h3>
-          <p className="text-sm text-stone-600 mb-6">{state.message}</p>
-          <div className="flex space-x-3 justify-center">
-            <button
-              onClick={handleCancel}
-              className="px-6 py-2.5 text-sm font-medium text-stone-600 bg-stone-100 border border-stone-200 rounded-xl hover:bg-stone-200 transition-colors"
-            >
-              Close
-            </button>
-          </div>
-        </div>
-      );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Build a synthetic SetupStep from an AuthMode for rendering via SetupFormRenderer. */
-function buildAuthFormStep(mode: AuthMode): SetupStep {
-  if (mode.type === "text") {
-    return {
-      id: "auth_text",
-      title: mode.label ?? "Credential Text",
-      description: mode.textDescription ?? "Paste your credential content below.",
-      fields: [
-        {
-          name: "content",
-          type: "textarea",
-          label: "Credential Content",
-          required: true,
-          placeholder: mode.textPlaceholder ?? undefined,
-        },
-      ],
-    };
-  }
-
-  // self_hosted: use the mode's declared fields
-  return {
-    id: `auth_${mode.type}`,
-    title: mode.label ?? "Enter Credentials",
-    description: mode.description ?? "Provide your credentials to connect.",
-    fields: (mode.fields ?? []).map(f => ({
-      name: f.name ?? "",
-      type: f.type ?? "text",
-      label: f.label ?? f.name ?? "",
-      required: f.required ?? false,
-      default: f.default,
-      placeholder: f.placeholder,
-      description: f.description,
-      options: f.options,
-    })),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Loading View
-// ---------------------------------------------------------------------------
-
-function LoadingView() {
-  return (
-    <div className="flex items-center justify-center py-12">
-      <svg
-        className="animate-spin h-6 w-6 text-primary-500"
-        xmlns="http://www.w3.org/2000/svg"
-        fill="none"
-        viewBox="0 0 24 24"
-      >
-        <circle
-          className="opacity-25"
-          cx="12"
-          cy="12"
-          r="10"
-          stroke="currentColor"
-          strokeWidth="4"
-        />
-        <path
-          className="opacity-75"
-          fill="currentColor"
-          d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"
-        />
-      </svg>
-      <span className="ml-3 text-sm text-stone-600">
-        Starting setup...
-      </span>
-    </div>
-  );
-}
-
-// ---------------------------------------------------------------------------
-// OAuth Login View
-// ---------------------------------------------------------------------------
-
-function formatProviderName(provider: string): string {
-  const names: Record<string, string> = {
-    notion: "Notion",
-    google: "Google",
-    github: "GitHub",
-    slack: "Slack",
-    discord: "Discord",
-    twitter: "Twitter",
-    linear: "Linear",
-  };
-  return names[provider] ?? provider.charAt(0).toUpperCase() + provider.slice(1);
-}
-
-interface OAuthLoginViewProps {
-  provider: string;
-  onLogin: () => void;
-  onCancel: () => void;
-  waiting: boolean;
-  /** Skill ID — needed for dev-mode manual integration ID entry. */
-  skillId?: string;
-  /** Called after manual dev-mode completion to advance the wizard. */
-  onManualComplete?: () => void;
-}
-
-function OAuthLoginView({
-  provider,
-  onLogin,
-  onCancel,
-  waiting,
-  skillId,
-  onManualComplete: _onManualComplete,
-}: OAuthLoginViewProps) {
-  const providerName = formatProviderName(provider);
-  const [devIntegrationId, setDevIntegrationId] = useState("");
-  const [devEncryptionKey, setDevEncryptionKey] = useState("");
-  const [devSubmitting, setDevSubmitting] = useState(false);
-  const [devError, setDevError] = useState("");
-
-  const handleDevManualComplete = useCallback(async () => {
-    const id = devIntegrationId.trim();
-    const encKey = devEncryptionKey.trim();
-    if (!id || !skillId) return;
-    if (!encKey) { setDevError("Encryption key is required"); return; }
-    if (/["\\]/.test(encKey) || encKey !== encKey.replace(/[^\x20-\x7e]/g, "")) { setDevError("Encryption key contains invalid characters"); return; }
-    setDevSubmitting(true);
-    setDevError("");
-    try {
-      // 1. Use the manually-provided client-side encryption key
-      const clientKeyShare: string | undefined = encKey || undefined;
-
-      // 2. Ensure skill is installed, then start the runtime
-      try {
-        await installSkill(skillId);
-      } catch {
-        // May already be installed
-      }
-      try {
-        await startSkill(skillId);
-      } catch (startErr) {
-        throw new Error(`Failed to start skill: ${startErr instanceof Error ? startErr.message : String(startErr)}`);
-      }
-
-      // 3. Wait for skill to be fully running (QuickJS init is async)
-      let running = false;
-      for (let i = 0; i < 30; i++) {
-        try {
-          const snap = await getSkillSnapshot(skillId);
-          if (snap.status === "running") { running = true; break; }
-          if (snap.status === "error") throw new Error(`Skill init failed: ${snap.error ?? "unknown error"}`);
-        } catch (snapErr) {
-          if (snapErr instanceof Error && snapErr.message.includes("Skill init failed")) throw snapErr;
-        }
-        await new Promise((r) => setTimeout(r, 300));
-      }
-      if (!running) throw new Error("Skill did not reach running state within timeout");
-
-      // 4. Notify skill of OAuth completion — the snapshot effect will
-      //    detect the connected state and transition to setup automatically.
-      await skillManager.notifyOAuthComplete(skillId, id, provider, {
-        clientKeyShare,
-      });
-    } catch (err) {
-      setDevError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setDevSubmitting(false);
-    }
-  }, [devIntegrationId, devEncryptionKey, skillId, provider]);
-
-  return (
-    <div className="py-6">
-      {/* Provider icon */}
-      <div className="flex justify-center mb-5">
-        <div className="w-14 h-14 rounded-2xl bg-stone-50 border border-stone-200 flex items-center justify-center shadow-sm">
-          <ProviderIcon provider={provider} />
-        </div>
-      </div>
-
-      {/* Title and description */}
-      <div className="text-center mb-6">
-        <h3 className="text-lg font-semibold text-stone-900 mb-2">
-          Connect to {providerName}
-        </h3>
-        <p className="text-sm text-stone-600">
-          {waiting
-            ? "Waiting for authorization. Complete the login in your browser..."
-            : `Sign in with your ${providerName} account to connect this skill.`}
-        </p>
-      </div>
-
-      {/* Login button or waiting state */}
-      {waiting ? (
-        <div className="flex flex-col items-center gap-4">
-          <div className="flex items-center gap-3 px-4 py-3 bg-stone-50 border border-stone-200 rounded-xl">
-            <svg
-              className="animate-spin h-4 w-4 text-primary-500"
-              xmlns="http://www.w3.org/2000/svg"
-              fill="none"
-              viewBox="0 0 24 24"
-            >
-              <circle
-                className="opacity-25"
-                cx="12"
-                cy="12"
-                r="10"
-                stroke="currentColor"
-                strokeWidth="4"
-              />
-              <path
-                className="opacity-75"
-                fill="currentColor"
-                d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"
-              />
-            </svg>
-            <span className="text-sm text-stone-700">
-              Waiting for {providerName} authorization...
-            </span>
-          </div>
-
-          <button
-            onClick={onLogin}
-            className="text-xs text-primary-600 hover:text-primary-700 transition-colors"
-          >
-            Open login page again
-          </button>
-
-          {/* Dev-mode: manual integration ID + encryption key entry */}
-          {IS_DEV && skillId && (
-            <div className="mt-4 pt-4 border-t border-stone-700/50">
-              <p className="text-[10px] text-stone-500 uppercase tracking-wider mb-2">Dev mode</p>
-              <div className="flex flex-col gap-2">
-                <input
-                  type="text"
-                  placeholder="Integration ID (24-char hex)"
-                  value={devIntegrationId}
-                  onChange={(e) => setDevIntegrationId(e.target.value)}
-                  className="w-full px-3 py-1.5 text-xs bg-stone-800 border border-stone-700 rounded-lg text-white placeholder:text-stone-500 focus:outline-none focus:border-primary-500"
-                />
-                <div className="flex gap-2">
-                  <input
-                    type="password"
-                    placeholder="Client-side encryption key"
-                    value={devEncryptionKey}
-                    onChange={(e) => setDevEncryptionKey(e.target.value)}
-                    onKeyDown={(e) => { if (e.key === "Enter") handleDevManualComplete(); }}
-                    className="flex-1 px-3 py-1.5 text-xs bg-stone-800 border border-stone-700 rounded-lg text-white placeholder:text-stone-500 focus:outline-none focus:border-primary-500"
-                  />
-                  <button
-                    onClick={handleDevManualComplete}
-                    disabled={devSubmitting || !devIntegrationId.trim() || !devEncryptionKey.trim()}
-                    className="px-3 py-1.5 text-xs font-medium text-white bg-primary-600 rounded-lg hover:bg-primary-500 disabled:opacity-40 transition-colors"
-                  >
-                    {devSubmitting ? "..." : "Go"}
-                  </button>
-                </div>
-              </div>
-              {devError && (
-                <p className="mt-1.5 text-[11px] text-coral-400">{devError}</p>
-              )}
-            </div>
-          )}
-        </div>
-      ) : (
-        <button
-          onClick={onLogin}
-          className="w-full py-3 text-sm font-medium text-white bg-primary-500 rounded-xl hover:bg-primary-600 transition-colors flex items-center justify-center gap-2"
-        >
-          <svg
-            className="w-4 h-4"
-            fill="none"
-            stroke="currentColor"
-            viewBox="0 0 24 24"
-          >
-            <path
-              strokeLinecap="round"
-              strokeLinejoin="round"
-              strokeWidth={2}
-              d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14"
-            />
-          </svg>
-          Sign in with {providerName}
-        </button>
-      )}
-
-      {/* Cancel */}
-      <div className="mt-4">
-        <button
-          onClick={onCancel}
-          className="w-full py-2.5 text-sm font-medium text-stone-600 bg-stone-100 border border-stone-200 rounded-xl hover:bg-stone-200 transition-colors"
-        >
-          Cancel
-        </button>
-      </div>
-    </div>
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Provider Icons
-// ---------------------------------------------------------------------------
-
-function ProviderIcon({ provider }: { provider: string }) {
-  switch (provider) {
-    case "notion":
-      return (
-        <svg className="w-7 h-7" viewBox="0 0 100 100" fill="none">
-          <path
-            d="M6.017 4.313l55.333-4.087c6.797-.583 8.543-.19 12.817 2.917l17.663 12.443c2.913 2.14 3.883 2.723 3.883 5.053v68.243c0 4.277-1.553 6.807-6.99 7.193L24.467 99.967c-4.08.193-6.023-.39-8.16-3.113L3.3 79.94c-2.333-3.113-3.3-5.443-3.3-8.167V11.113c0-3.497 1.553-6.413 6.017-6.8z"
-            fill="#fff"
-          />
-          <path
-            fillRule="evenodd"
-            clipRule="evenodd"
-            d="M61.35.227L6.017 4.313C1.553 4.7 0 7.617 0 11.113v60.66c0 2.723.967 5.053 3.3 8.167l12.993 16.913c2.137 2.723 4.08 3.307 8.16 3.113l64.257-3.89c5.433-.387 6.99-2.917 6.99-7.193V20.64c0-2.21-.873-2.847-3.443-4.733L75.34 3.57l-.027-.02C71.587.527 69.087-.36 61.35.227zM25.723 19.01c-5.167.39-6.337.477-9.277-1.84l-6.44-5.057c-.773-.78-.39-1.75 1.553-1.947l52.893-3.89c4.473-.39 6.797 1.167 8.543 2.527l7.41 5.443c.39.193.97 1.357 0 1.357l-54.88 3.213-.003.003v-.01zm-6.6 73.793V28.883c0-2.53.777-3.697 3.107-3.89L81.44 21.78c2.14-.193 3.107 1.167 3.107 3.693v63.537c0 2.53-1.16 4.667-4.467 4.86L27.45 97.077c-3.113.193-4.337-.97-4.337-4.273h.01zm51.57-62.177c.39 1.75 0 3.5-1.75 3.7l-2.527.48v47.013c-2.14 1.167-4.273 1.75-5.637 1.75-2.53 0-3.303-.78-5.247-3.107l-16.08-25.283v24.477l5.25 1.17s0 3.5-4.857 3.5L28.337 79.4c-.39-.78 0-2.723 1.357-3.11l3.497-.97V40.763l-4.857-.39c-.39-1.75.583-4.277 3.3-4.473L42.63 35.32l16.667 25.477V37.853l-4.473-.58c-.39-2.14 1.163-3.5 3.303-3.697l12.567-.75z"
-            fill="#000"
-          />
-        </svg>
-      );
-    case "google":
-      return (
-        <svg className="w-6 h-6" viewBox="0 0 24 24">
-          <path
-            d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92a5.06 5.06 0 01-2.2 3.32v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.1z"
-            fill="#4285F4"
-          />
-          <path
-            d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
-            fill="#34A853"
-          />
-          <path
-            d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
-            fill="#FBBC05"
-          />
-          <path
-            d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
-            fill="#EA4335"
-          />
-        </svg>
-      );
-    case "github":
-      return (
-        <svg className="w-7 h-7 text-stone-800" fill="currentColor" viewBox="0 0 24 24">
-          <path
-            fillRule="evenodd"
-            clipRule="evenodd"
-            d="M12 2C6.477 2 2 6.484 2 12.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0112 6.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.202 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.943.359.309.678.92.678 1.855 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0022 12.017C22 6.484 17.522 2 12 2z"
-          />
-        </svg>
-      );
-    default:
-      return (
-        <svg
-          className="w-7 h-7 text-stone-500"
-          fill="none"
-          stroke="currentColor"
-          viewBox="0 0 24 24"
-        >
-          <path
-            strokeLinecap="round"
-            strokeLinejoin="round"
-            strokeWidth={1.5}
-            d="M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1"
-          />
-        </svg>
-      );
-  }
-}
diff --git a/app/src/components/skills/shared.tsx b/app/src/components/skills/shared.tsx
deleted file mode 100644
index 0ce5857ef..000000000
--- a/app/src/components/skills/shared.tsx
+++ /dev/null
@@ -1,175 +0,0 @@
-import { useState } from 'react';
-
-import GoogleIcon from '../../assets/icons/GoogleIcon';
-import NotionIcon from '../../assets/icons/notion.svg';
-import TelegramIcon from '../../assets/icons/telegram.svg';
-import { skillManager } from '../../lib/skills/manager';
-import type { SkillConnectionStatus, SkillType } from '../../lib/skills/types';
-
-// Map skill IDs to icons
-export const SKILL_ICONS: Record<string, React.ReactElement> = {
-  telegram: <img src={TelegramIcon} alt="Telegram" className="w-5 h-5" />,
-  email: <GoogleIcon className="w-5 h-5" />,
-  notion: <img src={NotionIcon} alt="Notion" className="w-5 h-5" />,
-  github: (
-    <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 24 24">
-      <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z" />
-    </svg>
-  ),
-  otter: (
-    <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 24 24">
-      <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm-2 15l-5-5 1.41-1.41L10 14.17l7.59-7.59L19 8l-9 9z" />
-    </svg>
-  ),
-};
-
-// Default icon for unknown skills
-export const DefaultIcon = () => (
-  <div className="w-5 h-5 rounded-full bg-primary-500/20 flex items-center justify-center">
-    <svg className="w-3 h-3 text-primary-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path
-        strokeLinecap="round"
-        strokeLinejoin="round"
-        strokeWidth={2}
-        d="M12 6v6m0 0v6m0-6h6m-6 0H6"
-      />
-    </svg>
-  </div>
-);
-
-// Status display text and colors
-export const STATUS_DISPLAY: Record<SkillConnectionStatus, { text: string; color: string }> = {
-  connected: { text: 'Connected', color: 'text-sage-400' },
-  connecting: { text: 'Connecting', color: 'text-amber-400' },
-  not_authenticated: { text: 'Not Auth', color: 'text-amber-400' },
-  disconnected: { text: 'Disconnected', color: 'text-stone-400' },
-  error: { text: 'Error', color: 'text-coral-400' },
-  offline: { text: 'Offline', color: 'text-stone-500' },
-  setup_required: { text: 'Setup', color: 'text-primary-400' },
-};
-
-// Priority order for sorting (lower number = higher priority)
-export const STATUS_PRIORITY: Record<SkillConnectionStatus, number> = {
-  connected: 1,
-  connecting: 2,
-  not_authenticated: 3,
-  disconnected: 4,
-  setup_required: 5,
-  offline: 6,
-  error: 7,
-};
-
-export interface SkillListEntry {
-  id: string;
-  name: string;
-  description: string;
-  ignoreInProduction?: boolean;
-  icon?: React.ReactElement;
-  hasSetup: boolean;
-  /** Unified registry type: "openhuman" (QuickJS) or "openclaw" (SKILL.md/TOML). */
-  skill_type?: SkillType;
-}
-
-// Contextual action button for skills
-export function SkillActionButton({
-  skill,
-  connectionStatus,
-  onOpenModal,
-}: {
-  skill: SkillListEntry;
-  connectionStatus: SkillConnectionStatus;
-  onOpenModal: () => void;
-}) {
-  const [loading, setLoading] = useState(false);
-
-  const handleEnable = async (e: React.MouseEvent) => {
-    e.stopPropagation();
-    if (skill.hasSetup) {
-      // Skills with setup (e.g. OAuth) go straight to the setup modal
-      // — no need to start the QuickJS runtime first.
-      onOpenModal();
-      return;
-    }
-    setLoading(true);
-    try {
-      await skillManager.startSkill({
-        id: skill.id,
-        name: skill.name,
-        version: '0.0.0',
-        description: skill.description,
-        runtime: 'quickjs',
-        setup: undefined,
-      });
-    } catch (err) {
-      console.error(`Failed to enable ${skill.id}:`, err);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  if (loading) {
-    return (
-      <div className="px-4 py-1.5 text-xs font-medium text-stone-400 flex-shrink-0 ml-3">
-        <svg className="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
-          <circle
-            className="opacity-25"
-            cx="12"
-            cy="12"
-            r="10"
-            stroke="currentColor"
-            strokeWidth="4"
-          />
-          <path
-            className="opacity-75"
-            fill="currentColor"
-            d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"
-          />
-        </svg>
-      </div>
-    );
-  }
-
-  if (connectionStatus === 'offline') {
-    return (
-      <button
-        onClick={handleEnable}
-        className="ml-3 flex-shrink-0 rounded-lg border border-sage-200 bg-sage-50 px-4 py-1.5 text-xs font-medium text-sage-700 transition-colors hover:bg-sage-100">
-        Enable
-      </button>
-    );
-  }
-
-  if (connectionStatus === 'setup_required') {
-    return (
-      <button
-        onClick={e => {
-          e.stopPropagation();
-          onOpenModal();
-        }}
-        className="ml-3 flex-shrink-0 rounded-lg border border-primary-200 bg-primary-50 px-4 py-1.5 text-xs font-medium text-primary-700 transition-colors hover:bg-primary-100">
-        Setup
-      </button>
-    );
-  }
-
-  if (connectionStatus === 'error') {
-    return (
-      <button
-        onClick={handleEnable}
-        className="ml-3 flex-shrink-0 rounded-lg border border-amber-200 bg-amber-50 px-4 py-1.5 text-xs font-medium text-amber-700 transition-colors hover:bg-amber-100">
-        Retry
-      </button>
-    );
-  }
-
-  return (
-    <button
-      onClick={e => {
-        e.stopPropagation();
-        onOpenModal();
-      }}
-      className="ml-3 flex-shrink-0 rounded-lg border border-primary-200 bg-primary-50 px-4 py-1.5 text-xs font-medium text-primary-700 transition-colors hover:bg-primary-100">
-      Configure
-    </button>
-  );
-}
diff --git a/app/src/features/autocomplete/useAutocompleteSkillStatus.ts b/app/src/features/autocomplete/useAutocompleteSkillStatus.ts
index 4b054f43e..a9a66bd74 100644
--- a/app/src/features/autocomplete/useAutocompleteSkillStatus.ts
+++ b/app/src/features/autocomplete/useAutocompleteSkillStatus.ts
@@ -4,8 +4,8 @@
  */
 import { useMemo } from 'react';
 
-import type { SkillConnectionStatus } from '../../lib/skills/types';
 import { useCoreState } from '../../providers/CoreStateProvider';
+import type { SkillConnectionStatus } from '../../types/skillStatus';
 
 export interface AutocompleteSkillStatus {
   connectionStatus: SkillConnectionStatus;
diff --git a/app/src/features/screen-intelligence/useScreenIntelligenceSkillStatus.ts b/app/src/features/screen-intelligence/useScreenIntelligenceSkillStatus.ts
index b6d6121cf..69466c252 100644
--- a/app/src/features/screen-intelligence/useScreenIntelligenceSkillStatus.ts
+++ b/app/src/features/screen-intelligence/useScreenIntelligenceSkillStatus.ts
@@ -4,8 +4,8 @@
  */
 import { useMemo } from 'react';
 
-import type { SkillConnectionStatus } from '../../lib/skills/types';
 import { useCoreState } from '../../providers/CoreStateProvider';
+import type { SkillConnectionStatus } from '../../types/skillStatus';
 
 export interface ScreenIntelligenceSkillStatus {
   connectionStatus: SkillConnectionStatus;
diff --git a/app/src/features/voice/useVoiceSkillStatus.ts b/app/src/features/voice/useVoiceSkillStatus.ts
index 36167db21..39b3f193c 100644
--- a/app/src/features/voice/useVoiceSkillStatus.ts
+++ b/app/src/features/voice/useVoiceSkillStatus.ts
@@ -7,8 +7,8 @@
  */
 import { useCallback, useEffect, useMemo, useState } from 'react';
 
-import type { SkillConnectionStatus } from '../../lib/skills/types';
 import { useCoreState } from '../../providers/CoreStateProvider';
+import type { SkillConnectionStatus } from '../../types/skillStatus';
 import { isTauri } from '../../utils/tauriCommands/common';
 import {
   openhumanVoiceServerStatus,
diff --git a/app/src/lib/composio/composioApi.ts b/app/src/lib/composio/composioApi.ts
index 11d4af236..d204f6a08 100644
--- a/app/src/lib/composio/composioApi.ts
+++ b/app/src/lib/composio/composioApi.ts
@@ -7,9 +7,8 @@
  * `/agent-integrations/composio/*` routes, so the frontend never talks
  * to Composio directly and never handles the API key.
  *
- * This mirrors the shape of `lib/skills/skillsApi.ts`. Keep the two
- * files stylistically consistent so the parallel domain stays easy to
- * grok.
+ * Keep this file stylistically consistent with the other RPC wrappers
+ * in `app/src/utils/tauriCommands` so the domain stays easy to grok.
  */
 import { callCoreRpc } from '../../services/coreRpcClient';
 import type {
diff --git a/app/src/lib/skills/hooks.ts b/app/src/lib/skills/hooks.ts
deleted file mode 100644
index ea28fccb6..000000000
--- a/app/src/lib/skills/hooks.ts
+++ /dev/null
@@ -1,280 +0,0 @@
-/**
- * React hooks for consuming skill state via RPC.
- *
- * All state is fetched from the Rust core sidecar and cached locally.
- * Tauri events trigger re-fetches for instant reactivity.
- */
-
-import { useCallback, useEffect, useRef, useState } from 'react';
-
-import type { SkillSyncStatsLike } from '../../pages/skillsSyncUi';
-import { runtimeSkillDataStats } from '../../utils/tauriCommands';
-import type { SkillConnectionStatus, SkillHostConnectionState } from './types';
-import { onSkillStateChange } from './skillEvents';
-import {
-  getAllSnapshots,
-  getSkillSnapshot,
-  listAvailable,
-  type AvailableSkillEntryRpc,
-  type SkillSnapshotRpc,
-} from './skillsApi';
-
-/** Snapshot used when `skills_status` fails (skill not loaded in runtime yet, RPC error, etc.). */
-const offlineSkillSnapshot = (
-  skillId: string,
-  previous?: SkillSnapshotRpc | null,
-): SkillSnapshotRpc => ({
-  skill_id: skillId,
-  name: previous?.name ?? '',
-  status: previous?.status ?? 'installed',
-  tools: previous?.tools ?? [],
-  state: previous?.state ?? {},
-  setup_complete: previous?.setup_complete ?? false,
-  connection_status: previous?.connection_status ?? 'offline',
-  error: previous?.error,
-});
-
-// ---------------------------------------------------------------------------
-// Legacy pure function kept for compatibility (used by sync.ts, skillsSyncUi)
-// ---------------------------------------------------------------------------
-
-export function deriveConnectionStatus(
-  lifecycleStatus: string | undefined,
-  setupComplete: boolean | undefined,
-  skillState: Record<string, unknown> | undefined,
-): SkillConnectionStatus {
-  if (!lifecycleStatus || lifecycleStatus === 'installed' || lifecycleStatus === 'stopping') {
-    return 'offline';
-  }
-  if (lifecycleStatus === 'error') return 'error';
-  if (lifecycleStatus === 'setup_required' || lifecycleStatus === 'setup_in_progress') {
-    return 'setup_required';
-  }
-  if (lifecycleStatus === 'starting') return 'connecting';
-
-  const hostState = skillState as SkillHostConnectionState | undefined;
-  const connStatus = hostState?.connection_status;
-  const authStatus = hostState?.auth_status;
-
-  if (!connStatus && !authStatus) {
-    if (setupComplete && (lifecycleStatus === 'ready' || lifecycleStatus === 'running')) {
-      return 'connected';
-    }
-    if (!hostState) return 'connecting';
-    return 'connecting';
-  }
-
-  if (connStatus === 'error' || authStatus === 'error') return 'error';
-  if (connStatus === 'connecting' || authStatus === 'authenticating') return 'connecting';
-  if (connStatus === 'connected') {
-    if (!authStatus || authStatus === 'authenticated') return 'connected';
-    if (authStatus === 'not_authenticated') return 'not_authenticated';
-  }
-  if (connStatus === 'disconnected') {
-    return setupComplete ? 'disconnected' : 'setup_required';
-  }
-
-  return 'connecting';
-}
-
-// ---------------------------------------------------------------------------
-// RPC-backed hooks
-// ---------------------------------------------------------------------------
-
-/**
- * Fetch a single skill snapshot, re-fetching on skill events and polling
- * periodically (the core sidecar has no push channel to the frontend).
- */
-export function useSkillSnapshot(skillId: string | undefined): SkillSnapshotRpc | null {
-  const [snap, setSnap] = useState<SkillSnapshotRpc | null>(null);
-  const mountedRef = useRef(true);
-
-  const refresh = useCallback(async () => {
-    if (!skillId) return;
-    try {
-      const s = await getSkillSnapshot(skillId);
-      if (mountedRef.current) setSnap(s);
-    } catch {
-      // Skill may not be in the runtime yet (e.g. never started) — `skills_status`
-      // returns an error and would otherwise leave `snap` null forever.  UI such as
-      // SkillSetupModal waits for a non-null snapshot before leaving its loading
-      // state, so we synthesize an offline snapshot instead of staying stuck.
-      if (mountedRef.current) {
-        setSnap(previous => offlineSkillSnapshot(skillId, previous));
-      }
-    }
-  }, [skillId]);
-
-  useEffect(() => {
-    mountedRef.current = true;
-    refresh();
-    const unsub = onSkillStateChange((changedId) => {
-      if (!changedId || changedId === skillId) refresh();
-    });
-    // Poll every 3s to catch background state changes from the core sidecar
-    const interval = setInterval(refresh, 3000);
-    return () => {
-      mountedRef.current = false;
-      unsub();
-      clearInterval(interval);
-    };
-  }, [skillId, refresh]);
-
-  return snap;
-}
-
-/** Fetch all running skill snapshots, re-fetching on skill events and polling. */
-export function useAllSkillSnapshots(): SkillSnapshotRpc[] {
-  const [snaps, setSnaps] = useState<SkillSnapshotRpc[]>([]);
-  const mountedRef = useRef(true);
-
-  const refresh = useCallback(async () => {
-    try {
-      const s = await getAllSnapshots();
-      if (mountedRef.current) setSnaps(s);
-    } catch {
-      // Core not ready yet
-    }
-  }, []);
-
-  useEffect(() => {
-    mountedRef.current = true;
-    refresh();
-    const unsub = onSkillStateChange(() => refresh());
-    const interval = setInterval(refresh, 3000);
-    return () => {
-      mountedRef.current = false;
-      unsub();
-      clearInterval(interval);
-    };
-  }, [refresh]);
-
-  return snaps;
-}
-
-/** Fetch available skills from registry. */
-export function useAvailableSkills(): {
-  skills: AvailableSkillEntryRpc[];
-  loading: boolean;
-  refresh: () => Promise<void>;
-} {
-  const [skills, setSkills] = useState<AvailableSkillEntryRpc[]>([]);
-  const [loading, setLoading] = useState(true);
-  const mountedRef = useRef(true);
-
-  const refresh = useCallback(async () => {
-    try {
-      const s = await listAvailable();
-      if (mountedRef.current) setSkills(s);
-    } catch {
-      // Registry not reachable
-    } finally {
-      if (mountedRef.current) setLoading(false);
-    }
-  }, []);
-
-  useEffect(() => {
-    mountedRef.current = true;
-    refresh();
-    return () => {
-      mountedRef.current = false;
-    };
-  }, [refresh]);
-
-  return { skills, loading, refresh };
-}
-
-/**
- * Returns the connection status for a skill.
- * Reads from the Rust-derived `connection_status` field in the snapshot.
- */
-export function useSkillConnectionStatus(skillId: string): SkillConnectionStatus {
-  const snap = useSkillSnapshot(skillId);
-  if (!snap) return 'offline';
-  return (snap.connection_status as SkillConnectionStatus) || 'offline';
-}
-
-/**
- * Returns the raw skill-pushed state (from reverse RPC state/set).
- */
-export function useSkillState<T = Record<string, unknown>>(
-  skillId: string,
-): T | undefined {
-  const snap = useSkillSnapshot(skillId);
-  return snap?.state as T | undefined;
-}
-
-/**
- * Returns connection status info including error messages.
- */
-export function useSkillConnectionInfo(skillId: string): {
-  status: SkillConnectionStatus;
-  error?: string | null;
-  isInitialized: boolean;
-} {
-  const snap = useSkillSnapshot(skillId);
-
-  if (!snap) {
-    return { status: 'offline', error: null, isInitialized: false };
-  }
-
-  const status = (snap.connection_status as SkillConnectionStatus) || 'offline';
-  const hostState = snap.state as SkillHostConnectionState | undefined;
-
-  let error: string | null | undefined;
-  if (status === 'error') {
-    error = hostState?.connection_error ?? hostState?.auth_error ?? snap.error ?? null;
-  }
-
-  return {
-    status,
-    error,
-    isInitialized: !!hostState?.is_initialized,
-  };
-}
-
-/**
- * Disk usage under the skill data directory (from core RPC). Refreshes on skill events
- * and periodically while the skill is connected.
- */
-export function useSkillDataDirectoryStats(
-  skillId: string,
-  fetchEnabled: boolean,
-): Pick<SkillSyncStatsLike, 'localDataBytes' | 'localFileCount'> | undefined {
-  const [stats, setStats] = useState<
-    Pick<SkillSyncStatsLike, 'localDataBytes' | 'localFileCount'> | undefined
-  >(undefined);
-
-  useEffect(() => {
-    if (!fetchEnabled) {
-      setStats(undefined);
-      return;
-    }
-    let cancelled = false;
-    const load = async () => {
-      try {
-        const d = await runtimeSkillDataStats(skillId);
-        if (!cancelled) {
-          setStats({
-            localDataBytes: d.total_bytes,
-            localFileCount: d.file_count,
-          });
-        }
-      } catch {
-        if (!cancelled) setStats(undefined);
-      }
-    };
-    void load();
-    const interval = setInterval(load, 30_000);
-    const unsub = onSkillStateChange((id) => {
-      if (!id || id === skillId) void load();
-    });
-    return () => {
-      cancelled = true;
-      clearInterval(interval);
-      unsub();
-    };
-  }, [skillId, fetchEnabled]);
-
-  return stats;
-}
diff --git a/app/src/lib/skills/index.ts b/app/src/lib/skills/index.ts
deleted file mode 100644
index 9dbdf336e..000000000
--- a/app/src/lib/skills/index.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-export { SkillTransport } from "./transport";
-export { SkillRuntime } from "./runtime";
-export { skillManager } from "./manager";
-export { syncToolsToBackend } from "./sync";
-export * from "./types";
-export * from "./paths";
-export * from "./hooks";
diff --git a/app/src/lib/skills/manager.ts b/app/src/lib/skills/manager.ts
deleted file mode 100644
index 4347e33ac..000000000
--- a/app/src/lib/skills/manager.ts
+++ /dev/null
@@ -1,719 +0,0 @@
-/**
- * Skill Manager — orchestrates multiple skill runtimes.
- *
- * Singleton that manages skill discovery, lifecycle, setup flows,
- * and tool invocation. Dispatches status changes to Redux.
- */
-
-import { callCoreRpc } from "../../services/coreRpcClient";
-import { getCoreStateSnapshot, patchCoreStateSnapshot } from "../../lib/coreState/store";
-import { SkillRuntime } from "./runtime";
-import { emitSkillStateChange } from "./skillEvents";
-import {
-  getSkillSnapshot,
-  setSetupComplete as rpcSetSetupComplete,
-  stopSkill as rpcStopSkill,
-  revokeOAuth as rpcRevokeOAuth,
-  removePersistedOAuthCredential,
-  removePersistedClientKey,
-  revokeAuth as rpcRevokeAuth,
-  removePersistedAuthCredential,
-} from "./skillsApi";
-import { syncToolsToBackend } from "./sync";
-import type {
-  SkillManifest,
-  SkillStatus,
-  SetupStep,
-  SetupResult,
-  SkillToolDefinition,
-  SkillOptionDefinition,
-} from "./types";
-import {
-  runtimeSkillDataDir,
-  runtimeSkillDataRead,
-  runtimeSkillDataWrite,
-} from "../../utils/tauriCommands";
-import { toolExecutionTimeoutMsFromEnv, withTimeout } from "../../utils/withTimeout";
-// Env vars kept for reverse RPC compatibility (may be used by skills via state)
-
-
-class SkillManager {
-  private runtimes = new Map<string, SkillRuntime>();
-  private resyncAfterReconnectInProgress = false;
-
-  /**
-   * Get skill-specific load parameters (e.g., wallet address for wallet skill)
-   */
-  private getSkillLoadParams(skillId: string): Record<string, unknown> {
-    const params: Record<string, unknown> = {};
-
-    if (skillId === "wallet") {
-      const primaryAddress = getCoreStateSnapshot().snapshot.localState.primaryWalletAddress;
-      if (primaryAddress) {
-        params.walletAddress = primaryAddress;
-      }
-    }
-
-    return params;
-  }
-
-  /**
-   * Add a discovered skill manifest to Redux.
-   */
-  registerSkill(manifest: SkillManifest): void {
-    if (manifest.id.includes("_")) {
-      console.error(
-        `Skill name "${manifest.id}" contains underscore. Skill names cannot contain underscores as they are used for tool namespacing (skillId__toolName).`
-      );
-      return;
-    }
-    // Registration is now handled by the Rust engine; just notify hooks
-    emitSkillStateChange(manifest.id);
-  }
-
-  /**
-   * Start a skill — spawn process, load, check setup status.
-   * If setup is already complete, loads the skill fully and lists tools.
-   */
-  async startSkill(manifest: SkillManifest): Promise<void> {
-    const skillId = manifest.id;
-
-    if (this.runtimes.has(skillId)) {
-      const existing = this.runtimes.get(skillId)!;
-      if (existing.isRunning) return;
-      this.runtimes.delete(skillId);
-    }
-
-    emitSkillStateChange(skillId);
-
-    const runtime = new SkillRuntime(manifest);
-    runtime.onReverseRpc(async (method, params) => {
-      return this.handleReverseRpc(skillId, method, params);
-    });
-
-    try {
-      await runtime.start();
-      this.runtimes.set(skillId, runtime);
-
-      const loadParams = this.getSkillLoadParams(manifest.id);
-      await runtime.load(loadParams);
-
-      // If no setup required, mark complete and activate
-      if (!manifest.setup?.required) {
-        await rpcSetSetupComplete(skillId, true).catch(() => {});
-        await this.activateSkill(skillId);
-      }
-
-      emitSkillStateChange(skillId);
-    } catch (err) {
-      this.runtimes.delete(skillId);
-      emitSkillStateChange(skillId);
-      throw err;
-    }
-  }
-
-  /**
-   * After realtime socket reconnect: refresh tool lists for every running skill so
-   * `tool:sync` matches the Rust engine (issue #215).
-   */
-  async resyncRunningSkillsAfterReconnect(): Promise<void> {
-    if (this.resyncAfterReconnectInProgress) return;
-    this.resyncAfterReconnectInProgress = true;
-    try {
-      const ids = [...this.runtimes.keys()];
-      await Promise.all(ids.map((id) => this.activateSkill(id)));
-    } finally {
-      this.resyncAfterReconnectInProgress = false;
-    }
-  }
-
-  /**
-   * Activate a skill that has completed setup — list its tools and mark as ready.
-   */
-  private async activateSkill(skillId: string): Promise<void> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) return;
-
-    try {
-      await runtime.listTools();
-      // Tools are tracked by the Rust engine; just sync to backend and notify hooks
-      syncToolsToBackend();
-      emitSkillStateChange(skillId);
-    } catch (err) {
-      console.error(`[SkillManager] Failed to activate skill ${skillId}:`, err);
-      emitSkillStateChange(skillId);
-    }
-  }
-
-  /**
-   * Start the setup flow for a skill. Returns the first step, or null if
-   * the skill doesn't implement setup/start (e.g. OAuth-only skills).
-   *
-   * OAuth-based skills never instantiate a frontend `SkillRuntime` — they
-   * live only in the Rust core (see `shared.tsx` "no need to start the
-   * QuickJS runtime first"). For those we fall back to the core RPC
-   * `openhuman.skills_setup_start`, mirroring the fallback pattern in
-   * `notifyOAuthComplete`. If the core errors (e.g. the skill doesn't
-   * implement `onSetupStart` at all, which is common for pure OAuth
-   * skills), we treat it as "no more setup steps" — the wizard interprets
-   * that as success and shows the "Connected!" screen.
-   */
-  async startSetup(skillId: string): Promise<SetupStep | null> {
-    console.log("[SkillManager] startSetup", skillId);
-    const runtime = this.runtimes.get(skillId);
-    if (runtime) {
-      emitSkillStateChange(skillId);
-      console.log("[SkillManager] setup started (local runtime)", skillId);
-      return runtime.setupStart();
-    }
-
-    // No frontend runtime — dispatch via core RPC pass-through.
-    //
-    // The core side returns `null` (not an error) when the skill has no
-    // `onSetupStart` handler — see `handle_js_call` in
-    // `src/openhuman/skills/qjs_skill_instance/js_handlers.rs`, which
-    // falls through to `return "null"` when the function is missing.
-    // So any exception thrown here is a *real* failure (skill not
-    // running, RPC transport error, JS exception in the handler, …)
-    // and must be propagated so the caller can surface it to the user
-    // instead of silently pretending setup succeeded.
-    try {
-      const result = (await callCoreRpc({
-        method: "openhuman.skills_setup_start",
-        params: { skill_id: skillId },
-      })) as { step?: SetupStep } | null;
-      emitSkillStateChange(skillId);
-      console.log(
-        "[SkillManager] setup started (core RPC fallback)",
-        skillId,
-        result,
-      );
-      if (!result || !result.step) {
-        return null;
-      }
-      return result.step;
-    } catch (err) {
-      console.warn(
-        "[SkillManager] setup_start core fallback failed",
-        skillId,
-        err,
-      );
-      emitSkillStateChange(skillId);
-      throw err;
-    }
-  }
-
-  /**
-   * Submit a setup step. Returns the result (next step, error, or complete).
-   */
-  async submitSetup(
-    skillId: string,
-    stepId: string,
-    values: Record<string, unknown>,
-  ): Promise<SetupResult> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) {
-      throw new Error(`Skill ${skillId} is not running`);
-    }
-
-    const result = await runtime.setupSubmit(stepId, values);
-
-    if (result.status === "complete") {
-      await rpcSetSetupComplete(skillId, true).catch(() => {});
-      await this.activateSkill(skillId);
-    }
-
-    return result;
-  }
-
-  /**
-   * Cancel the setup flow for a skill.
-   */
-  async cancelSetup(skillId: string): Promise<void> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) return;
-
-    try {
-      await runtime.setupCancel();
-    } catch {
-      // Ignore errors on cancel
-    }
-    emitSkillStateChange(skillId);
-  }
-
-  /**
-   * Call a tool on a running skill.
-   */
-  async callTool(
-    skillId: string,
-    name: string,
-    args: Record<string, unknown>,
-  ): Promise<{ content: Array<{ type: string; text: string }>; isError: boolean }> {
-    console.log(`[SkillManager] callTool skill="${skillId}" tool="${name}"`);
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) {
-      console.error(`[SkillManager] callTool failed — skill "${skillId}" has no running runtime`);
-      throw new Error(`Skill ${skillId} is not running`);
-    }
-    const timeoutMs = toolExecutionTimeoutMsFromEnv();
-    const result = await withTimeout(
-      runtime.callTool(name, args),
-      timeoutMs,
-      `[SkillManager] callTool skill="${skillId}" tool="${name}"`,
-    );
-    console.log(`[SkillManager] callTool result skill="${skillId}" tool="${name}" isError=${result.isError}`);
-    return result;
-  }
-
-  /**
-   * Get the list of tools for a running skill.
-   */
-  async listTools(skillId: string): Promise<SkillToolDefinition[]> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) {
-      throw new Error(`Skill ${skillId} is not running`);
-    }
-    return runtime.listTools();
-  }
-
-  /**
-   * List runtime-configurable options for a running skill.
-   */
-  async listOptions(skillId: string): Promise<SkillOptionDefinition[]> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) {
-      throw new Error(`Skill ${skillId} is not running`);
-    }
-    return runtime.listOptions();
-  }
-
-  /**
-   * Trigger a manual sync for a running skill.
-   * Progress updates are published to Redux via the skill's state fields.
-   */
-  async triggerSync(skillId: string): Promise<void> {
-    const timeoutMs = toolExecutionTimeoutMsFromEnv();
-    const runtime = this.runtimes.get(skillId);
-    if (runtime) {
-      await withTimeout(
-        runtime.triggerSync(),
-        timeoutMs,
-        `[SkillManager] triggerSync skill="${skillId}"`,
-      );
-    } else {
-      // Try via core RPC pass-through
-      try {
-        await withTimeout(
-          callCoreRpc({
-            method: "openhuman.skills_sync",
-            params: { skill_id: skillId },
-          }),
-          timeoutMs,
-          `[SkillManager] skills_sync skill="${skillId}"`,
-        );
-      } catch {
-        // Skill not running — skip sync silently
-      }
-    }
-  }
-
-  /**
-   * Set a single option on a running skill.
-   */
-  async setOption(skillId: string, name: string, value: unknown): Promise<void> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) {
-      throw new Error(`Skill ${skillId} is not running`);
-    }
-    await runtime.setOption(name, value);
-    // Refresh tools list since tool_filter options can change available tools
-    await this.activateSkill(skillId);
-  }
-
-  /**
-   * Notify a skill that OAuth completed successfully.
-   * Called by the deep link handler after backend OAuth callback.
-   * For Gmail, pass extraCredential.accessToken so the skill uses the token directly.
-   * When the encrypted OAuth flow is used, pass extraCredential.clientKeyShare
-   * so the skill runtime can persist and use it for encrypted proxy requests.
-   */
-  async notifyOAuthComplete(
-    skillId: string,
-    integrationId: string,
-    provider?: string,
-    extraCredential?: { accessToken?: string; clientKeyShare?: string },
-  ): Promise<void> {
-    // Persist setup completion via RPC (always, regardless of runtime)
-    await rpcSetSetupComplete(skillId, true).catch(() => {});
-
-    // Try to notify the local runtime if one exists
-    const runtime = this.runtimes.get(skillId);
-    if (runtime?.isRunning) {
-      const credential = {
-        credentialId: integrationId,
-        provider: provider ?? "unknown",
-        grantedScopes: [] as string[],
-        ...extraCredential,
-      };
-      try {
-        await runtime.oauthComplete(credential);
-      } catch (err) {
-        console.warn(`[SkillManager] oauthComplete RPC failed for ${skillId}:`, err);
-      }
-      await this.activateSkill(skillId);
-    } else {
-      // No local runtime — try notifying via core RPC pass-through.
-      // The credential object must use `credentialId` (not `integrationId`)
-      // to match what the JS bootstrap's oauth.fetch expects.
-      try {
-        await callCoreRpc({
-          method: "openhuman.skills_rpc",
-          params: {
-            skill_id: skillId,
-            method: "oauth/complete",
-            params: {
-              credentialId: integrationId,
-              provider: provider ?? "unknown",
-              grantedScopes: [] as string[],
-              ...extraCredential,
-            },
-          },
-        });
-      } catch {
-        // Skill may not be running in the core either — that's OK,
-        // setup_complete is already persisted above
-      }
-    }
-
-    emitSkillStateChange(skillId);
-  }
-
-  /**
-   * Forward session start to all ready skills.
-   */
-  async sessionStart(sessionId: string): Promise<void> {
-    for (const [, runtime] of this.runtimes) {
-      if (runtime.isRunning) {
-        try {
-          await runtime.sessionStart(sessionId);
-        } catch {
-          // Non-critical
-        }
-      }
-    }
-  }
-
-  /**
-   * Forward session end to all ready skills.
-   */
-  async sessionEnd(sessionId: string): Promise<void> {
-    for (const [, runtime] of this.runtimes) {
-      if (runtime.isRunning) {
-        try {
-          await runtime.sessionEnd(sessionId);
-        } catch {
-          // Non-critical
-        }
-      }
-    }
-  }
-
-  /**
-   * Disconnect a skill — revoke OAuth and/or auth credentials, stop it, and reset setup state.
-   */
-  async disconnectSkill(skillId: string): Promise<void> {
-    // Read the stored credential IDs so revoke handlers clear the right data.
-    let credentialId: string | undefined;
-    let authMode: string | undefined;
-    try {
-      const snap = await getSkillSnapshot(skillId);
-      const oauthCred = snap?.state?.__oauth_credential as
-        | { credentialId?: string }
-        | string
-        | undefined;
-      if (oauthCred && typeof oauthCred === "object") {
-        credentialId = oauthCred.credentialId;
-      }
-      const authCred = snap?.state?.__auth_credential as
-        | { mode?: string }
-        | string
-        | undefined;
-      if (authCred && typeof authCred === "object") {
-        authMode = authCred.mode;
-      }
-    } catch {
-      // Snapshot may fail if skill isn't registered yet
-    }
-
-    // Revoke credentials before stopping so the running skill can clean up.
-    let oauthRevokeSucceeded = false;
-    let authRevokeSucceeded = false;
-
-    // Try revoking OAuth credential
-    try {
-      await rpcRevokeOAuth(skillId, credentialId ?? "default");
-      oauthRevokeSucceeded = true;
-    } catch (err) {
-      console.debug(
-        "[SkillManager] oauth/revoked failed (runtime may be stopped):",
-        err,
-      );
-    }
-
-    // Try revoking auth credential (attempt even if authMode is unknown)
-    try {
-      await rpcRevokeAuth(skillId, authMode ?? "unknown");
-      authRevokeSucceeded = true;
-    } catch (err) {
-      console.debug(
-        "[SkillManager] auth/revoked failed (runtime may be stopped):",
-        err,
-      );
-    }
-
-    try {
-      // Stop the frontend-side runtime (if any)
-      await this.stopSkill(skillId);
-      // Stop the core sidecar skill process
-      try {
-        await rpcStopSkill(skillId);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes("not found") || msg.includes("not registered")) {
-          console.debug("[SkillManager] core skills_stop: already stopped");
-        } else {
-          console.error("[SkillManager] core skills_stop failed:", err);
-          throw err;
-        }
-      }
-    } finally {
-      // Host-side fallback cleanup if RPC revoke failed
-      if (!oauthRevokeSucceeded) {
-        await removePersistedOAuthCredential(skillId).catch((err) => {
-          console.debug(
-            "[SkillManager] host-side OAuth credential cleanup failed:",
-            err,
-          );
-        });
-      }
-      if (!authRevokeSucceeded) {
-        await removePersistedAuthCredential(skillId).catch((err) => {
-          console.debug(
-            "[SkillManager] host-side auth credential cleanup failed:",
-            err,
-          );
-        });
-      }
-      // Always clear the client-side encryption key
-      await removePersistedClientKey(skillId).catch((err) => {
-        console.debug(
-          "[SkillManager] host-side client key cleanup failed:",
-          err,
-        );
-      });
-    }
-
-    await rpcSetSetupComplete(skillId, false).catch(() => {});
-    emitSkillStateChange(skillId);
-    syncToolsToBackend();
-  }
-
-  /**
-   * Stop a specific skill.
-   */
-  async stopSkill(skillId: string): Promise<void> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime) return;
-
-    try {
-      await runtime.stop();
-    } catch {
-      // Ignore stop errors
-    }
-    this.runtimes.delete(skillId);
-    emitSkillStateChange(skillId);
-    syncToolsToBackend();
-  }
-
-  /**
-   * Stop all running skills.
-   */
-  async stopAll(): Promise<void> {
-    const ids = Array.from(this.runtimes.keys());
-    await Promise.all(ids.map((id) => this.stopSkill(id)));
-  }
-
-  /**
-   * Check if a skill is currently running.
-   */
-  isSkillRunning(skillId: string): boolean {
-    return this.runtimes.get(skillId)?.isRunning ?? false;
-  }
-
-  /**
-   * Get the current status of a skill from Redux.
-   */
-  getSkillStatus(_skillId: string): SkillStatus | undefined {
-    // Status is now tracked by the Rust engine; use useSkillSnapshot() hook for reads
-    return undefined;
-  }
-
-  /**
-   * Reload a skill with updated parameters (e.g., after authentication).
-   */
-  async reloadSkill(skillId: string): Promise<void> {
-    const runtime = this.runtimes.get(skillId);
-    if (!runtime || !runtime.isRunning) {
-      return; // Skill not running, nothing to reload
-    }
-
-    try {
-      // Get updated load parameters
-      const loadParams = this.getSkillLoadParams(skillId);
-
-      // Reload the skill with new parameters
-      await runtime.load(loadParams);
-
-      await this.activateSkill(skillId);
-    } catch (err) {
-      console.error(`Error reloading skill ${skillId}:`, err);
-    }
-  }
-
-  /**
-   * Set the wallet address in the frontend app and notify the wallet skill (onLoad).
-   * Updates Redux (primaryWalletAddressByUser) and, if the wallet skill is running,
-   * sends load params so the skill receives onLoad({ walletAddress }).
-   */
-  async setWalletAddress(address: string): Promise<void> {
-    await callCoreRpc({
-      method: "openhuman.app_state_update_local_state",
-      params: { primaryWalletAddress: address },
-    });
-    patchCoreStateSnapshot({
-      snapshot: {
-        localState: {
-          ...getCoreStateSnapshot().snapshot.localState,
-          primaryWalletAddress: address,
-        },
-      },
-    });
-    const runtime = this.runtimes.get("wallet");
-    if (runtime?.isRunning) {
-      await runtime.load({ walletAddress: address });
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // Reverse RPC handling
-  // -----------------------------------------------------------------------
-
-  private async handleReverseRpc(
-    skillId: string,
-    method: string,
-    params: Record<string, unknown>,
-  ): Promise<unknown> {
-    switch (method) {
-      case "state/get":
-        // State is managed by the Rust engine's published_state
-        return { state: {} };
-
-      case "state/set": {
-        // State is managed by the Rust engine; just notify hooks to re-fetch
-        emitSkillStateChange(skillId);
-        syncToolsToBackend();
-        return { ok: true };
-      }
-
-      case "data/read": {
-        const filename = params.filename as string;
-        try {
-          const content = await runtimeSkillDataRead(skillId, filename);
-          return { content };
-        } catch {
-          return { content: "" };
-        }
-      }
-
-      case "data/write": {
-        const filename = params.filename as string;
-        const content = params.content as string;
-        try {
-          await runtimeSkillDataWrite(skillId, filename, content);
-        } catch (err) {
-          console.error("[skill-manager] data/write error:", err);
-        }
-        return { ok: true };
-      }
-
-      case "intelligence/emitEvent":
-        // Future: forward to intelligence system
-        console.debug("[skill-manager] Intelligence event:", params);
-        return { ok: true };
-
-      case "entities/upsert":
-        // Future: forward to entity manager
-        console.debug("[skill-manager] Entity upsert:", params);
-        return { ok: true };
-
-      case "entities/search":
-        // Future: forward to entity manager
-        return { results: [] };
-
-      case "entities/upsertRelationship":
-        console.debug("[skill-manager] Relationship upsert:", params);
-        return { ok: true };
-
-      case "entities/getRelationships":
-        return { results: [] };
-
-      default:
-        throw new Error(`Unknown reverse RPC method: ${method}`);
-    }
-  }
-
-  /**
-   * Clear all skills databases and cached data.
-   * Used for nuclear reset functionality.
-   */
-  async clearAllSkillsData(): Promise<void> {
-    try {
-      // Stop all running skills first
-      await this.stopAll();
-
-      // Get all skill IDs from runtime map
-      const skillIds = Array.from(this.runtimes.keys());
-
-      // Clear data for each skill
-      const clearPromises = skillIds.map(async (skillId) => {
-        try {
-          // Get skill data directory path
-          const dataDir = await runtimeSkillDataDir(skillId);
-
-          // Note: We don't directly delete directories here since there's no exposed
-          // Tauri command for that. Instead, we rely on the backend to handle
-          // clearing when skills are disabled/reset via Redux state clearing.
-
-          console.log(`[SkillManager] Skill ${skillId} data directory: ${dataDir}`);
-        } catch (err) {
-          console.warn(`[SkillManager] Failed to get data directory for skill ${skillId}:`, err);
-        }
-      });
-
-      await Promise.all(clearPromises);
-
-      console.log("[SkillManager] Skills data clearing initiated");
-    } catch (error) {
-      console.error("[SkillManager] Failed to clear skills data:", error);
-      throw new Error("Failed to clear skills databases");
-    }
-  }
-}
-
-// Export singleton
-export const skillManager = new SkillManager();
-
-// Debug: expose to window for console testing
-if (typeof window !== 'undefined') {
-  (window as unknown as { __skillManager: SkillManager }).__skillManager = skillManager;
-}
diff --git a/app/src/lib/skills/paths.ts b/app/src/lib/skills/paths.ts
deleted file mode 100644
index c3f00ae43..000000000
--- a/app/src/lib/skills/paths.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Path resolution for skills directories.
- *
- * With the V8 runtime, paths are primarily resolved by the Rust backend.
- * These helpers provide client-side path computation for UI display and
- * manifest file resolution.
- */
-
-import { IS_DEV } from "../../utils/config";
-
-/**
- * Get the root directory for discovering skills.
- * In dev, skills are in the submodule `skills/skills/` dir.
- * In production, paths are resolved by the Rust engine.
- */
-export function getSkillsBaseDir(): string {
-  if (IS_DEV) {
-    return "skills";
-  }
-  return "";
-}
-
-/**
- * Get the module path for a skill given its ID.
- * For V8 skills, this is the skill ID itself.
- */
-export function getSkillModulePath(skillId: string): string {
-  return skillId;
-}
-
-/**
- * Get the manifest path for a skill.
- */
-export function getSkillManifestPath(skillId: string): string {
-  if (IS_DEV) {
-    return `skills/skills/${skillId}/manifest.json`;
-  }
-  return `skills/${skillId}/manifest.json`;
-}
diff --git a/app/src/lib/skills/runtime.ts b/app/src/lib/skills/runtime.ts
deleted file mode 100644
index afb4dd061..000000000
--- a/app/src/lib/skills/runtime.ts
+++ /dev/null
@@ -1,233 +0,0 @@
-/**
- * Skill runtime — higher-level wrapper around SkillTransport
- * for managing a single skill's lifecycle.
- *
- * Skills are managed by the Rust QuickJS runtime engine.
- * This class wraps the transport layer to provide the same API
- * that the SkillManager expects.
- */
-
-import { callCoreRpc } from "../../services/coreRpcClient";
-import { runtimeSkillDataDir } from "../../utils/tauriCommands";
-import { SkillTransport, type ReverseRpcHandler } from "./transport";
-import type {
-  SkillManifest,
-  SetupStep,
-  SetupResult,
-  SkillToolDefinition,
-  SkillOptionDefinition,
-  PingResult,
-} from "./types";
-
-export class SkillRuntime {
-  private transport: SkillTransport;
-  private manifest: SkillManifest;
-  private _started = false;
-
-  constructor(manifest: SkillManifest) {
-    this.transport = new SkillTransport();
-    this.manifest = manifest;
-  }
-
-  /**
-   * Set a handler for reverse RPC calls from the skill process.
-   * Reverse RPC is handled by bridge globals, so this
-   * is kept for API compatibility.
-   */
-  onReverseRpc(handler: ReverseRpcHandler): void {
-    this.transport.onReverseRpc(handler);
-  }
-
-
-  /**
-   * Start the skill in the QuickJS runtime engine.
-   * The Rust engine handles process management, so we just tell it to start
-   * and then initialize the transport for RPC routing.
-   */
-  async start(): Promise<void> {
-    // Start the skill in the Rust QuickJS runtime via core RPC
-    await callCoreRpc({
-      method: 'openhuman.skills_start',
-      params: { skill_id: this.manifest.id },
-    });
-
-    // Initialize the transport for RPC routing
-    await this.transport.start(this.manifest.id);
-    this._started = true;
-  }
-
-  /**
-   * Send skill/load with manifest + data dir.
-   * Loading is handled by the Rust engine during start_skill,
-   * so this sends a no-op skill/load RPC for protocol compatibility.
-   */
-  async load(additionalParams?: Record<string, unknown>): Promise<void> {
-    const dataDir = await runtimeSkillDataDir(this.manifest.id);
-    await this.transport.request("skill/load", {
-      manifest: this.manifest,
-      dataDir,
-      ...(additionalParams || {}),
-    });
-  }
-
-  /**
-   * Start the setup flow. Returns the first SetupStep.
-   * Returns null if the skill does not implement setup/start (e.g. OAuth-only skills).
-   */
-  async setupStart(): Promise<SetupStep | null> {
-    console.log("[SkillRuntime] setupStart", this.skillId);
-    const result = await this.transport.request<{ step: SetupStep } | null>(
-      "setup/start"
-    );
-    console.log("[SkillRuntime] setupStart result", this.skillId, result);
-    if (!result || !result.step) {
-      return null;
-    }
-    return result.step;
-  }
-
-  /**
-   * Submit a setup step. Returns SetupResult with next/error/complete.
-   */
-  async setupSubmit(
-    stepId: string,
-    values: Record<string, unknown>
-  ): Promise<SetupResult> {
-    return this.transport.request<SetupResult>("setup/submit", {
-      stepId,
-      values,
-    });
-  }
-
-  /**
-   * Cancel the setup flow.
-   */
-  async setupCancel(): Promise<void> {
-    await this.transport.request("setup/cancel");
-  }
-
-  /**
-   * List available tools.
-   */
-  async listTools(): Promise<SkillToolDefinition[]> {
-    const result = await this.transport.request<{
-      tools: SkillToolDefinition[];
-    }>("tools/list");
-    return result.tools;
-  }
-
-  /**
-   * List runtime-configurable options with current values.
-   */
-  async listOptions(): Promise<SkillOptionDefinition[]> {
-    const result = await this.transport.request<{
-      options: SkillOptionDefinition[];
-    }>("options/list");
-    return result.options;
-  }
-
-  /**
-   * Set a single option value.
-   */
-  async setOption(name: string, value: unknown): Promise<void> {
-    await this.transport.request("options/set", { name, value });
-  }
-
-  /**
-   * Call a tool by name with arguments.
-   */
-  async callTool(
-    name: string,
-    args: Record<string, unknown>
-  ): Promise<{
-    content: Array<{ type: string; text: string }>;
-    isError: boolean;
-  }> {
-    console.log(`[SkillRuntime] callTool skill="${this.manifest.id}" tool="${name}"`);
-    const result = await this.transport.request<{ content: Array<{ type: string; text: string }>; isError: boolean }>("tools/call", { name, arguments: args });
-    console.log(`[SkillRuntime] tools/call response skill="${this.manifest.id}" tool="${name}" isError=${result.isError}`);
-    return result;
-  }
-
-  /**
-   * Ping the skill to verify its external service connection is healthy.
-   * Returns null if the skill doesn't implement onPing (backward compatible).
-   */
-  async ping(): Promise<PingResult | null> {
-    return this.transport.request<PingResult | null>("skill/ping");
-  }
-
-  /**
-   * Trigger the skill's onSync lifecycle hook.
-   * Progress updates flow via published state fields, not the RPC response.
-   */
-  async triggerSync(): Promise<unknown> {
-    return this.transport.request("skill/sync");
-  }
-
-  /**
-   * Trigger periodic tick.
-   */
-  async tick(): Promise<void> {
-    await this.transport.request("skill/tick");
-  }
-
-  /**
-   * Notify skill of session start.
-   */
-  async sessionStart(sessionId: string): Promise<void> {
-    await this.transport.request("skill/sessionStart", { sessionId });
-  }
-
-  /**
-   * Notify skill of session end.
-   */
-  async sessionEnd(sessionId: string): Promise<void> {
-    await this.transport.request("skill/sessionEnd", { sessionId });
-  }
-
-  /**
-   * Notify the skill that OAuth completed successfully.
-   * Sets the credential on the bridge and calls onOAuthComplete.
-   */
-  async oauthComplete(args: {
-    credentialId: string;
-    provider: string;
-    grantedScopes?: string[];
-    accountLabel?: string;
-  }): Promise<void> {
-    await this.transport.request("oauth/complete", args as unknown as Record<string, unknown>);
-  }
-
-  /**
-   * Notify the skill that an OAuth credential was revoked.
-   */
-  async oauthRevoked(args: {
-    credentialId: string;
-    reason: string;
-  }): Promise<void> {
-    await this.transport.request("oauth/revoked", args as unknown as Record<string, unknown>);
-  }
-
-  /**
-   * Unload and stop the skill.
-   */
-  async stop(): Promise<void> {
-    if (!this._started) return;
-    try {
-      await this.transport.request("skill/shutdown");
-    } catch {
-      // Skill may already be stopped
-    }
-    await this.transport.kill();
-    this._started = false;
-  }
-
-  get isRunning(): boolean {
-    return this._started && this.transport.isRunning;
-  }
-
-  get skillId(): string {
-    return this.manifest.id;
-  }
-}
diff --git a/app/src/lib/skills/skillEvents.ts b/app/src/lib/skills/skillEvents.ts
deleted file mode 100644
index 2222cff9f..000000000
--- a/app/src/lib/skills/skillEvents.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- * Skill state event bus — bridges Tauri runtime events to React hooks.
- *
- * When the Rust core emits skill state changes, listeners here trigger
- * re-fetches in the React hooks that consume skill state via RPC.
- */
-
-import { listen } from '@tauri-apps/api/event';
-
-type Listener = (skillId?: string) => void;
-
-const listeners = new Set<Listener>();
-
-/** Subscribe to skill state invalidation events. Returns unsubscribe fn. */
-export function onSkillStateChange(fn: Listener): () => void {
-  listeners.add(fn);
-  return () => listeners.delete(fn);
-}
-
-/** Notify all listeners that skill state has changed. */
-export function emitSkillStateChange(skillId?: string): void {
-  for (const fn of listeners) {
-    fn(skillId);
-  }
-}
-
-/** Setup Tauri event listeners that bridge to the skill event bus. */
-export async function setupTauriSkillEventBridge(): Promise<() => void> {
-  try {
-    const unlistenStatus = await listen<{ skill_id?: string }>(
-      'runtime:skill-status-changed',
-      (event) => {
-        emitSkillStateChange(event.payload?.skill_id);
-      },
-    );
-
-    const unlistenState = await listen<{ skill_id?: string }>(
-      'runtime:skill-state-changed',
-      (event) => {
-        emitSkillStateChange(event.payload?.skill_id);
-      },
-    );
-
-    return () => {
-      unlistenStatus();
-      unlistenState();
-    };
-  } catch {
-    // Not in Tauri environment
-    return () => {};
-  }
-}
diff --git a/app/src/lib/skills/skillsApi.ts b/app/src/lib/skills/skillsApi.ts
deleted file mode 100644
index 32378fbf4..000000000
--- a/app/src/lib/skills/skillsApi.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-/**
- * Imperative RPC wrapper for skill state — single source of truth.
- *
- * Replaces direct Redux access for skill state reads and writes.
- * All functions call the Rust core sidecar via JSON-RPC.
- */
-
-import { callCoreRpc } from '../../services/coreRpcClient';
-
-// Re-export types that consumers need
-export interface SkillSnapshotRpc {
-  skill_id: string;
-  name: string;
-  status: string;
-  tools: Array<{ name: string; description: string; inputSchema?: unknown }>;
-  error?: string | null;
-  state: Record<string, unknown>;
-  setup_complete: boolean;
-  connection_status: string;
-}
-
-export interface AvailableSkillEntryRpc {
-  id: string;
-  name: string;
-  version: string;
-  description: string;
-  runtime: string;
-  entry: string;
-  auto_start: boolean;
-  platforms?: string[] | null;
-  setup?: {
-    required?: boolean;
-    label?: string;
-    oauth?: { provider: string; scopes: string[]; apiBaseUrl: string };
-    auth?: { modes: Array<{
-      type: string;
-      label?: string;
-      description?: string;
-      provider?: string;
-      scopes?: string[];
-      apiBaseUrl?: string;
-      fields?: Array<Record<string, unknown>>;
-      textDescription?: string;
-      textPlaceholder?: string;
-    }> };
-  } | null;
-  ignore_in_production: boolean;
-  download_url: string;
-  manifest_url: string;
-  checksum_sha256?: string | null;
-  category: string;
-  installed: boolean;
-  installed_version?: string | null;
-  update_available: boolean;
-}
-
-export interface InstalledSkillInfoRpc {
-  id: string;
-  name: string;
-  version: string;
-  description: string;
-  runtime: string;
-}
-
-// --- Read operations ---
-
-export async function getSkillSnapshot(skillId: string): Promise<SkillSnapshotRpc> {
-  return callCoreRpc<SkillSnapshotRpc>({
-    method: 'openhuman.skills_status',
-    params: { skill_id: skillId },
-  });
-}
-
-export async function getAllSnapshots(): Promise<SkillSnapshotRpc[]> {
-  return callCoreRpc<SkillSnapshotRpc[]>({
-    method: 'openhuman.skills_get_all_snapshots',
-  });
-}
-
-export async function listAvailable(): Promise<AvailableSkillEntryRpc[]> {
-  return callCoreRpc<AvailableSkillEntryRpc[]>({
-    method: 'openhuman.skills_list_available',
-  });
-}
-
-export async function listInstalled(): Promise<InstalledSkillInfoRpc[]> {
-  return callCoreRpc<InstalledSkillInfoRpc[]>({
-    method: 'openhuman.skills_list_installed',
-  });
-}
-
-export async function searchSkills(
-  query: string,
-  category?: string,
-): Promise<AvailableSkillEntryRpc[]> {
-  return callCoreRpc<AvailableSkillEntryRpc[]>({
-    method: 'openhuman.skills_search',
-    params: { query, category },
-  });
-}
-
-// --- Write operations ---
-
-export async function startSkill(skillId: string): Promise<SkillSnapshotRpc> {
-  return callCoreRpc<SkillSnapshotRpc>({
-    method: 'openhuman.skills_start',
-    params: { skill_id: skillId },
-  });
-}
-
-export async function stopSkill(skillId: string): Promise<void> {
-  await callCoreRpc({ method: 'openhuman.skills_stop', params: { skill_id: skillId } });
-}
-
-export async function installSkill(skillId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_install',
-    params: { skill_id: skillId },
-  });
-}
-
-export async function uninstallSkill(skillId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_uninstall',
-    params: { skill_id: skillId },
-  });
-}
-
-export async function setSetupComplete(skillId: string, complete: boolean): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_set_setup_complete',
-    params: { skill_id: skillId, complete },
-  });
-}
-
-export async function revokeOAuth(skillId: string, integrationId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_rpc',
-    params: {
-      skill_id: skillId,
-      method: 'oauth/revoked',
-      params: { integrationId },
-    },
-  });
-}
-
-/**
- * Host-side fallback: delete oauth_credential.json from the skill's data dir.
- * Used when the runtime is already stopped so oauth/revoked RPC can't reach it.
- */
-export async function removePersistedOAuthCredential(skillId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_data_write',
-    params: { skill_id: skillId, filename: 'oauth_credential.json', content: '' },
-  });
-}
-
-/** Revoke advanced auth credential via skill RPC. */
-export async function revokeAuth(skillId: string, mode?: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_rpc',
-    params: {
-      skill_id: skillId,
-      method: 'auth/revoked',
-      params: { mode: mode ?? 'unknown' },
-    },
-  });
-}
-
-/**
- * Host-side fallback: delete auth_credential.json from the skill's data dir.
- * Used when the runtime is already stopped so auth/revoked RPC can't reach it.
- */
-export async function removePersistedAuthCredential(skillId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_data_write',
-    params: { skill_id: skillId, filename: 'auth_credential.json', content: '' },
-  });
-}
-
-/** Host-side fallback: clear client_key.json from the skill's data dir. */
-export async function removePersistedClientKey(skillId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_data_write',
-    params: { skill_id: skillId, filename: 'client_key.json', content: '' },
-  });
-}
-
-export async function disableSkill(skillId: string): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_disable',
-    params: { skill_id: skillId },
-  });
-}
-
-export async function fetchRegistryFresh(): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_registry_fetch',
-    params: { force: true },
-  });
-}
diff --git a/app/src/lib/skills/sync.ts b/app/src/lib/skills/sync.ts
deleted file mode 100644
index 707e3c561..000000000
--- a/app/src/lib/skills/sync.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Sync tool/skill state to the backend via `tool:sync` socket event.
- *
- * Called whenever skill connection state changes or the socket reconnects,
- * so the backend always has an up-to-date picture of connected tools.
- */
-
-import { socketService } from '../../services/socketService';
-import { getAllSnapshots } from './skillsApi';
-import type { SkillConnectionStatus } from './types';
-
-interface ToolSyncEntry {
-  skillId: string;
-  name: string;
-  status: SkillConnectionStatus;
-  tools: string[];
-}
-
-/**
- * Fetch all skill snapshots from the Rust engine and emit a `tool:sync`
- * event with the full list.
- */
-export function syncToolsToBackend(): void {
-  getAllSnapshots()
-    .then(snapshots => {
-      const tools: ToolSyncEntry[] = snapshots.map(snap => ({
-        skillId: snap.skill_id,
-        name: snap.name,
-        status: (snap.connection_status as SkillConnectionStatus) || 'offline',
-        tools: (snap.tools ?? []).map(t => t.name),
-      }));
-
-      socketService.emit('tool:sync', { tools });
-    })
-    .catch(err => {
-      console.warn('[sync] Failed to fetch snapshots for tool:sync:', err);
-    });
-}
diff --git a/app/src/lib/skills/transport.ts b/app/src/lib/skills/transport.ts
deleted file mode 100644
index 075b0334f..000000000
--- a/app/src/lib/skills/transport.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-/**
- * JSON-RPC 2.0 transport over Tauri IPC commands.
- *
- * Routes JSON-RPC requests to the Rust QuickJS runtime engine via
- * `invoke('runtime_rpc', ...)`. Reverse RPC (state/get, state/set,
- * data/read, data/write) is handled by bridge globals inside the
- * QuickJS engine.
- */
-
-import { runtimeRpc, runtimeStopSkill } from '../../utils/tauriCommands';
-
-export type ReverseRpcHandler = (
-  method: string,
-  params: Record<string, unknown>
-) => Promise<unknown>;
-
-export class SkillTransport {
-  private skillId: string | null = null;
-  private _started = false;
-
-  /**
-   * Set a handler for reverse RPC calls from the skill process.
-   * With QuickJS, reverse RPC is handled by bridge globals, so this
-   * is kept for API compatibility but is a no-op.
-   */
-  onReverseRpc(_handler: ReverseRpcHandler): void {
-    // No-op: QuickJS bridge globals handle state/data directly
-  }
-
-  /**
-   * Initialize the transport for a skill.
-   * With QuickJS, the skill process is managed by the Rust runtime engine,
-   * so this just stores the skill ID for routing RPC calls.
-   *
-   * @param skillId - The skill ID to route requests to.
-   */
-  async start(skillId: string): Promise<void> {
-    this.skillId = skillId;
-    this._started = true;
-    console.log("[skill-transport] Initialized for skill:", skillId);
-  }
-
-  /**
-   * Send a JSON-RPC request to the skill via Tauri IPC.
-   */
-  async request<T = unknown>(
-    method: string,
-    params?: Record<string, unknown>
-  ): Promise<T> {
-    if (!this.skillId || !this._started) {
-      throw new Error("Skill transport not started");
-    }
-
-    console.log("[skill-transport] →", { skillId: this.skillId, method, params });
-
-    const result = await runtimeRpc<T>(this.skillId, method, params ?? {});
-
-    console.log("[skill-transport] ←", { skillId: this.skillId, method, result });
-
-    return result;
-  }
-
-  /**
-   * Send a JSON-RPC notification (no response expected).
-   * Implemented as a fire-and-forget request.
-   */
-  notify(method: string, params?: Record<string, unknown>): void {
-    if (!this.skillId || !this._started) {
-      console.warn("[skill-transport] Cannot notify - not started", { method });
-      return;
-    }
-
-    console.log("[skill-transport] Sending notification", {
-      skillId: this.skillId,
-      method,
-    });
-
-    // Fire and forget
-    runtimeRpc(this.skillId, method, params ?? {}).catch((err: unknown) => {
-      console.error("[skill-transport] Notification error:", err);
-    });
-  }
-
-  /**
-   * Stop the transport. With QuickJS, this is a no-op since the
-   * Rust engine manages skill lifecycle. Use runtime_stop_skill instead.
-   */
-  async kill(): Promise<void> {
-    if (this.skillId && this._started) {
-      try {
-        await runtimeStopSkill(this.skillId);
-      } catch {
-        // Skill may already be stopped
-      }
-    }
-    this._started = false;
-  }
-
-  get isRunning(): boolean {
-    return this._started;
-  }
-}
diff --git a/app/src/lib/skills/types.ts b/app/src/lib/skills/types.ts
deleted file mode 100644
index 8aac46296..000000000
--- a/app/src/lib/skills/types.ts
+++ /dev/null
@@ -1,245 +0,0 @@
-/**
- * Type definitions for the skills system.
- * Mirrors the Python types in dev/types/setup_types.py and dev/types/skill_types.py.
- */
-
-// ---------------------------------------------------------------------------
-// Skill Manifest (from manifest.json)
-// ---------------------------------------------------------------------------
-
-export type SkillPlatform = "windows" | "macos" | "linux";
-
-/** Unified registry skill type discriminant. */
-export type SkillType = 'openhuman' | 'openclaw';
-
-export interface SkillManifest {
-  id: string;
-  name: string;
-  version: string;
-  description: string;
-  runtime: "quickjs";
-  entry?: string;
-  tick_interval?: number;
-  env?: string[];
-  dependencies?: string[];
-  setup?: {
-    required: boolean;
-    label?: string;
-    /** Legacy OAuth configuration. Prefer `auth` for new skills. */
-    oauth?: {
-      provider: string;
-      scopes: string[];
-      apiBaseUrl: string;
-    };
-    /** Advanced auth configuration with multiple auth modes. */
-    auth?: SkillAuthConfig;
-  };
-  /** Platform filter. When present, only listed platforms load this skill.
-   *  When absent or empty, the skill is available on all platforms. */
-  platforms?: SkillPlatform[];
-  /** When true, skill is hidden in production builds. */
-  ignoreInProduction?: boolean;
-  /** Unified registry type: "openhuman" (QuickJS) or "openclaw" (skill.md/TOML). */
-  skill_type?: SkillType;
-}
-
-// ---------------------------------------------------------------------------
-// Setup Flow Types
-// ---------------------------------------------------------------------------
-
-export interface SetupFieldOption {
-  label: string;
-  value: string;
-}
-
-export interface SetupField {
-  name: string;
-  type: "text" | "number" | "password" | "select" | "multiselect" | "boolean" | "textarea";
-  label: string;
-  description?: string | null;
-  required: boolean;
-  default?: string | number | boolean | string[] | null;
-  placeholder?: string | null;
-  options?: SetupFieldOption[] | null;
-}
-
-export interface SetupStep {
-  id: string;
-  title: string;
-  description?: string | null;
-  fields: SetupField[];
-}
-
-export interface SetupFieldError {
-  field: string;
-  message: string;
-}
-
-export interface SetupResult {
-  status: "next" | "error" | "complete";
-  nextStep?: SetupStep | null;
-  errors?: SetupFieldError[] | null;
-  message?: string | null;
-}
-
-// ---------------------------------------------------------------------------
-// Advanced Auth Configuration
-// ---------------------------------------------------------------------------
-
-/** A single authentication mode that a skill supports. */
-export interface AuthMode {
-  type: "managed" | "self_hosted" | "text";
-  label?: string;
-  description?: string;
-  /** Managed mode: OAuth provider name. */
-  provider?: string;
-  /** Managed mode: OAuth scopes. */
-  scopes?: string[];
-  /** Managed mode: base URL for API proxying. */
-  apiBaseUrl?: string;
-  /** Self-hosted mode: form fields for credential input. */
-  fields?: SetupField[];
-  /** Text mode: hint above the textarea. */
-  textDescription?: string;
-  /** Text mode: placeholder in the textarea. */
-  textPlaceholder?: string;
-}
-
-/** Advanced auth configuration with multiple auth modes. */
-export interface SkillAuthConfig {
-  modes: AuthMode[];
-}
-
-// ---------------------------------------------------------------------------
-// JSON-RPC 2.0
-// ---------------------------------------------------------------------------
-
-export interface JsonRpcRequest {
-  jsonrpc: "2.0";
-  id: number;
-  method: string;
-  params?: Record<string, unknown>;
-}
-
-export interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  id: number;
-  result?: unknown;
-  error?: { code: number; message: string };
-}
-
-export interface JsonRpcNotification {
-  jsonrpc: "2.0";
-  method: string;
-  params?: Record<string, unknown>;
-}
-
-// ---------------------------------------------------------------------------
-// Skill Tools
-// ---------------------------------------------------------------------------
-
-export interface SkillToolDefinition {
-  name: string;
-  description: string;
-  inputSchema: {
-    type: "object";
-    properties: Record<string, unknown>;
-    required?: string[];
-  };
-}
-
-export interface SkillToolResult {
-  content: Array<{ type: string; text: string }>;
-  isError: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Skill Options
-// ---------------------------------------------------------------------------
-
-export interface SkillOptionDefinition {
-  name: string;
-  type: "boolean" | "text" | "number" | "select";
-  label: string;
-  description?: string | null;
-  default?: string | number | boolean | null;
-  options?: SetupFieldOption[] | null;
-  group?: string | null;
-  toolFilter?: string[] | null;
-  /** Current value (returned by options/list) */
-  value?: string | number | boolean | null;
-}
-
-// ---------------------------------------------------------------------------
-// Skill Status
-// ---------------------------------------------------------------------------
-
-export type SkillStatus =
-  | "installed"
-  | "starting"
-  | "running"
-  | "setup_required"
-  | "setup_in_progress"
-  | "ready"
-  | "error"
-  | "stopping";
-
-// ---------------------------------------------------------------------------
-// Skill Connection Status (unified status derived from skill-pushed state)
-// ---------------------------------------------------------------------------
-
-/**
- * Unified connection status for display in the UI.
- * Derived from the skill's own `connection_status` + `auth_status`
- * (pushed via reverse RPC state/set) combined with lifecycle status.
- */
-export type SkillConnectionStatus =
-  | "connected"          // Service fully connected and authenticated
-  | "connecting"         // In the process of connecting or authenticating
-  | "not_authenticated"  // Process running, connected to service, but not authed
-  | "disconnected"       // Process running but not connected to service
-  | "error"              // Connection or auth error
-  | "offline"            // Skill process not running
-  | "setup_required";    // Needs initial setup
-
-/**
- * Standard state fields that skills should push via state/set reverse RPC.
- * Each skill maps its internal status to these fields.
- */
-export interface SkillHostConnectionState {
-  connection_status?: "disconnected" | "connecting" | "connected" | "error";
-  auth_status?: "not_authenticated" | "authenticating" | "authenticated" | "error";
-  connection_error?: string | null;
-  auth_error?: string | null;
-  is_initialized?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Redux skill state shape
-// ---------------------------------------------------------------------------
-
-export interface OAuthCredential {
-  credentialId: string;
-  provider: string;
-  grantedScopes?: string[];
-}
-
-// ---------------------------------------------------------------------------
-// Ping / Health-Check
-// ---------------------------------------------------------------------------
-
-export interface PingResult {
-  ok: boolean;
-  errorType?: "network" | "auth";
-  errorMessage?: string;
-}
-
-export interface SkillState {
-  manifest: SkillManifest;
-  status: SkillStatus;
-  error?: string;
-  setupComplete: boolean;
-  tools: SkillToolDefinition[];
-  /** Persisted OAuth credential so it survives app restarts. */
-  oauthCredential?: OAuthCredential;
-}
diff --git a/app/src/pages/Conversations.tsx b/app/src/pages/Conversations.tsx
index 97e882b14..68db0e6ff 100644
--- a/app/src/pages/Conversations.tsx
+++ b/app/src/pages/Conversations.tsx
@@ -285,7 +285,6 @@ const Conversations = () => {
       dispatch(setSelectedThread(DEFAULT_THREAD_ID));
       void dispatch(loadThreadMessages(DEFAULT_THREAD_ID));
     });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [dispatch]);
 
   useEffect(() => {
diff --git a/app/src/pages/Mnemonic.tsx b/app/src/pages/Mnemonic.tsx
index a22729bae..75a8e4177 100644
--- a/app/src/pages/Mnemonic.tsx
+++ b/app/src/pages/Mnemonic.tsx
@@ -2,11 +2,9 @@ import { type KeyboardEvent, useCallback, useEffect, useMemo, useRef, useState }
 import { useNavigate } from 'react-router-dom';
 
 import LottieAnimation from '../components/LottieAnimation';
-import { skillManager } from '../lib/skills/manager';
 import { useCoreState } from '../providers/CoreStateProvider';
 import {
   deriveAesKeyFromMnemonic,
-  deriveEvmAddressFromMnemonic,
   generateMnemonicPhrase,
   MNEMONIC_GENERATE_WORD_COUNT,
   validateMnemonicPhrase,
@@ -158,8 +156,6 @@ const Mnemonic = () => {
       }
 
       const aesKey = deriveAesKeyFromMnemonic(phraseToUse);
-      const walletAddress = deriveEvmAddressFromMnemonic(phraseToUse);
-
       if (!user?._id) {
         const msg = 'User not loaded. Please sign in again or refresh the page.';
         setError(msg);
@@ -167,7 +163,6 @@ const Mnemonic = () => {
         return;
       }
       await setEncryptionKey(aesKey);
-      await skillManager.setWalletAddress(walletAddress);
       navigate('/home');
     } catch (e) {
       setError(e instanceof Error ? e.message : 'Something went wrong. Please try again.');
diff --git a/app/src/pages/__tests__/skillsSyncUi.test.ts b/app/src/pages/__tests__/skillsSyncUi.test.ts
deleted file mode 100644
index 70260f53b..000000000
--- a/app/src/pages/__tests__/skillsSyncUi.test.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { deriveSkillSyncUiState } from '../skillsSyncUi';
-
-describe('deriveSkillSyncUiState', () => {
-  it('uses explicit progress and message for gmail', () => {
-    const result = deriveSkillSyncUiState('gmail', {
-      syncInProgress: true,
-      syncProgress: 42,
-      syncProgressMessage: 'Fetching page 2...',
-      totalEmails: 120,
-      newEmailsCount: 5,
-    });
-
-    expect(result.isSyncing).toBe(true);
-    expect(result.progressPercent).toBe(42);
-    expect(result.progressMessage).toBe('Fetching page 2...');
-    expect(result.metricsText).toContain('120 emails');
-    expect(result.metricsText).toContain('5 new emails');
-  });
-
-  it('falls back to indeterminate mode and default message when no numeric progress', () => {
-    const result = deriveSkillSyncUiState('notion', {
-      syncInProgress: true,
-      totalPages: 34,
-      pagesWithSummary: 12,
-      summariesPending: 4,
-    });
-
-    expect(result.isSyncing).toBe(true);
-    expect(result.progressPercent).toBeNull();
-    expect(result.progressMessage).toBe('Syncing Notion documents...');
-    expect(result.metricsText).toContain('34 pages');
-    expect(result.metricsText).toContain('12 pages summarized');
-  });
-
-  it('returns no sync UI when sync is idle', () => {
-    const result = deriveSkillSyncUiState('google-drive', {
-      syncInProgress: false,
-      syncProgress: 80,
-      syncProgressMessage: 'Syncing',
-      totalDocuments: 11,
-    });
-
-    expect(result.isSyncing).toBe(false);
-    expect(result.progressPercent).toBeNull();
-    expect(result.progressMessage).toBeNull();
-    expect(result.metricsText).toBeNull();
-  });
-
-  it('clamps out-of-range progress values', () => {
-    const high = deriveSkillSyncUiState('gmail', { syncInProgress: true, syncProgress: 150 });
-    const low = deriveSkillSyncUiState('gmail', { syncInProgress: true, syncProgress: -20 });
-
-    expect(high.progressPercent).toBe(100);
-    expect(low.progressPercent).toBe(0);
-  });
-});
diff --git a/app/src/pages/onboarding/steps/SkillsStep.tsx b/app/src/pages/onboarding/steps/SkillsStep.tsx
index 15172fe59..8aba20c5c 100644
--- a/app/src/pages/onboarding/steps/SkillsStep.tsx
+++ b/app/src/pages/onboarding/steps/SkillsStep.tsx
@@ -1,17 +1,5 @@
-import { useMemo, useState } from 'react';
+import { useState } from 'react';
 
-import {
-  DefaultIcon,
-  SKILL_ICONS,
-  SkillActionButton,
-  type SkillListEntry,
-  STATUS_DISPLAY,
-} from '../../../components/skills/shared';
-import SkillSetupModal from '../../../components/skills/SkillSetupModal';
-import { useAvailableSkills, useSkillConnectionStatus } from '../../../lib/skills/hooks';
-import { installSkill } from '../../../lib/skills/skillsApi';
-import type { SkillConnectionStatus } from '../../../lib/skills/types';
-import { IS_DEV } from '../../../utils/config';
 import OnboardingNextButton from '../components/OnboardingNextButton';
 
 interface SkillsStepProps {
@@ -19,103 +7,15 @@ interface SkillsStepProps {
   onBack?: () => void;
 }
 
-/** Status dot color for skill connection status */
-function statusDotClass(status: SkillConnectionStatus): string {
-  switch (status) {
-    case 'connected':
-      return 'bg-sage-400';
-    case 'connecting':
-      return 'bg-amber-400 animate-pulse';
-    case 'error':
-      return 'bg-coral-400';
-    default:
-      return 'bg-stone-300';
-  }
-}
-
-function SkillRow({ skill, onSetup }: { skill: SkillListEntry; onSetup: () => void }) {
-  const connectionStatus = useSkillConnectionStatus(skill.id);
-  const statusDisplay = STATUS_DISPLAY[connectionStatus] || STATUS_DISPLAY.offline;
-
-  return (
-    <div className="flex items-center gap-3 p-3 rounded-xl border border-stone-200 bg-white hover:border-stone-300 transition-colors">
-      <div className="w-6 h-6 flex items-center justify-center text-stone-600 flex-shrink-0">
-        {skill.icon || <DefaultIcon />}
-      </div>
-      <div className="flex-1 min-w-0">
-        <div className="flex items-center gap-2">
-          <span className="text-sm font-medium text-stone-900 truncate">{skill.name}</span>
-          <div
-            className={`w-1.5 h-1.5 rounded-full flex-shrink-0 ${statusDotClass(connectionStatus)}`}
-          />
-          <span className={`text-xs flex-shrink-0 ${statusDisplay.color}`}>
-            {statusDisplay.text}
-          </span>
-        </div>
-        {skill.description && (
-          <p className="text-xs text-stone-500 mt-0.5 truncate">{skill.description}</p>
-        )}
-      </div>
-      <SkillActionButton skill={skill} connectionStatus={connectionStatus} onOpenModal={onSetup} />
-    </div>
-  );
-}
-
 const SkillsStep = ({ onNext, onBack: _onBack }: SkillsStepProps) => {
-  const { skills: availableSkills, loading: skillsLoading } = useAvailableSkills();
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [installing, setInstalling] = useState<string | null>(null);
-  const [setupModalOpen, setSetupModalOpen] = useState(false);
-  const [activeSkillId, setActiveSkillId] = useState<string | null>(null);
-  const [activeSkillName, setActiveSkillName] = useState('');
-  const [activeSkillDescription, setActiveSkillDescription] = useState('');
-  const [activeSkillHasSetup, setActiveSkillHasSetup] = useState(false);
-
-  const skillsList: SkillListEntry[] = useMemo(() => {
-    return availableSkills
-      .filter(e => {
-        if (e.id.includes('_')) return false;
-        if (!IS_DEV && e.ignore_in_production) return false;
-        return true;
-      })
-      .map(e => ({
-        id: e.id,
-        name: e.name || e.id.charAt(0).toUpperCase() + e.id.slice(1),
-        description: e.description || '',
-        icon: SKILL_ICONS[e.id],
-        ignoreInProduction: e.ignore_in_production,
-        hasSetup: !!(e.setup && e.setup.required),
-      }));
-  }, [availableSkills]);
-
-  const sortedSkills = useMemo(() => {
-    return [...skillsList].sort((a, b) => a.name.localeCompare(b.name));
-  }, [skillsList]);
-
-  const openSkillSetup = async (skill: SkillListEntry) => {
-    try {
-      setInstalling(skill.id);
-      await installSkill(skill.id);
-    } catch (err) {
-      console.warn(`[SkillsStep] install failed for ${skill.id}, continuing:`, err);
-    } finally {
-      setInstalling(null);
-    }
-
-    setActiveSkillId(skill.id);
-    setActiveSkillName(skill.name);
-    setActiveSkillDescription(skill.description);
-    setActiveSkillHasSetup(skill.hasSetup);
-    setSetupModalOpen(true);
-  };
 
   const handleFinish = async () => {
     setError(null);
     setLoading(true);
     try {
-      const connectedIds = sortedSkills.map(s => s.id);
-      await onNext(connectedIds);
+      await onNext([]);
     } catch (e) {
       setError(e instanceof Error ? e.message : 'Something went wrong. Please try again.');
     } finally {
@@ -126,47 +26,26 @@ const SkillsStep = ({ onNext, onBack: _onBack }: SkillsStepProps) => {
   return (
     <div className="rounded-2xl border border-stone-200 bg-white p-8 shadow-soft animate-fade-up">
       <div className="text-center mb-4">
-        <h1 className="text-xl font-bold mb-2 text-stone-900">Install Skills</h1>
+        <h1 className="text-xl font-bold mb-2 text-stone-900">Connect Integrations Later</h1>
         <p className="text-stone-600 text-sm">
-          Skills give OpenHuman richer context & access to your workflow. All data consumed by
-          skills is saved and processed locally. You can connect as many skills as you want.
+          OpenHuman no longer installs local QuickJS skills during onboarding. You can connect
+          channels and Composio integrations later from the Integrations page once setup is
+          complete.
         </p>
       </div>
 
-      <div className="space-y-2 mb-4 max-h-[380px] overflow-y-auto pr-1">
-        {skillsLoading || installing ? (
-          <div className="rounded-2xl p-6 text-center">
-            <p className="text-sm text-stone-500">
-              {installing ? `Installing ${installing}...` : 'Loading skills...'}
-            </p>
-          </div>
-        ) : sortedSkills.length === 0 ? (
-          <div className="rounded-2xl p-6 text-center">
-            <p className="text-sm text-stone-500">No skills discovered</p>
-          </div>
-        ) : (
-          sortedSkills.map(skill => (
-            <SkillRow key={skill.id} skill={skill} onSetup={() => openSkillSetup(skill)} />
-          ))
-        )}
+      <div className="mb-4 rounded-2xl border border-stone-200 bg-stone-50 p-4 text-sm text-stone-600">
+        Available after onboarding:
+        <div className="mt-2 space-y-1 text-left text-stone-500">
+          <div>Channels like Telegram and Discord</div>
+          <div>Composio integrations like Gmail, Notion, and GitHub</div>
+          <div>Built-in features like Voice, Screen Intelligence, and Autocomplete</div>
+        </div>
       </div>
 
       {error && <p className="text-coral-400 text-sm mb-3 text-center">{error}</p>}
 
       <OnboardingNextButton onClick={handleFinish} loading={loading} loadingLabel="Loading..." />
-
-      {setupModalOpen && activeSkillId && (
-        <SkillSetupModal
-          skillId={activeSkillId}
-          skillName={activeSkillName}
-          skillDescription={activeSkillDescription}
-          hasSetup={activeSkillHasSetup}
-          onClose={() => {
-            setSetupModalOpen(false);
-            setActiveSkillId(null);
-          }}
-        />
-      )}
     </div>
   );
 };
diff --git a/app/src/pages/skillsSyncUi.ts b/app/src/pages/skillsSyncUi.ts
deleted file mode 100644
index 7d668429f..000000000
--- a/app/src/pages/skillsSyncUi.ts
+++ /dev/null
@@ -1,179 +0,0 @@
-import type { SkillHostConnectionState } from '../lib/skills/types';
-
-export interface SkillSyncUiState {
-  isSyncing: boolean;
-  progressPercent: number | null;
-  progressMessage: string | null;
-  metricsText: string | null;
-}
-
-type SkillStateRecord = SkillHostConnectionState & Record<string, unknown>;
-export interface SkillSyncStatsLike {
-  syncCount?: number;
-  lastSyncAtMs?: number | null;
-  localDataBytes?: number | null;
-  localFileCount?: number | null;
-}
-
-function readNumber(value: unknown): number | null {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string' && value.trim() !== '') {
-    const parsed = Number(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-
-function readBoolean(value: unknown): boolean | null {
-  return typeof value === 'boolean' ? value : null;
-}
-
-function clampPercent(value: number): number {
-  if (value < 0) return 0;
-  if (value > 100) return 100;
-  return value;
-}
-
-function formatNumber(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
-  return String(n);
-}
-
-function formatBytes(bytes: number): string {
-  if (!Number.isFinite(bytes) || bytes < 0) return '0 B';
-  if (bytes < 1024) return `${Math.round(bytes)} B`;
-  const units = ['KB', 'MB', 'GB', 'TB'];
-  let value = bytes / 1024;
-  let unitIndex = 0;
-  while (value >= 1024 && unitIndex < units.length - 1) {
-    value /= 1024;
-    unitIndex += 1;
-  }
-  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unitIndex]}`;
-}
-
-function formatRelativeTime(ms: number): string {
-  const delta = Date.now() - ms;
-  if (delta < 60_000) return 'just now';
-  if (delta < 3_600_000) return `${Math.max(1, Math.floor(delta / 60_000))}m ago`;
-  if (delta < 86_400_000) return `${Math.max(1, Math.floor(delta / 3_600_000))}h ago`;
-  return `${Math.max(1, Math.floor(delta / 86_400_000))}d ago`;
-}
-
-function buildMetricsText(state: SkillStateRecord): string | null {
-  const values = {
-    newEmailsCount: readNumber(state.newEmailsCount),
-    totalEmails: readNumber(state.totalEmails),
-    totalDocuments: readNumber(state.totalDocuments),
-    totalPages: readNumber(state.totalPages),
-    pagesWithSummary: readNumber(state.pagesWithSummary),
-    summariesPending: readNumber(state.summariesPending),
-    totalFiles: readNumber(state.totalFiles),
-    itemsDone: readNumber(state.itemsDone),
-    itemsTotal: readNumber(state.itemsTotal),
-  };
-
-  const parts: string[] = [];
-  if (values.newEmailsCount != null)
-    parts.push(`${formatNumber(values.newEmailsCount)} new emails`);
-  if (values.totalEmails != null) parts.push(`${formatNumber(values.totalEmails)} emails`);
-  if (values.totalDocuments != null) parts.push(`${formatNumber(values.totalDocuments)} docs`);
-  if (values.totalPages != null) parts.push(`${formatNumber(values.totalPages)} pages`);
-  if (values.pagesWithSummary != null)
-    parts.push(`${formatNumber(values.pagesWithSummary)} pages summarized`);
-  if (values.summariesPending != null)
-    parts.push(`${formatNumber(values.summariesPending)} summaries pending`);
-  if (values.totalFiles != null) parts.push(`${formatNumber(values.totalFiles)} files`);
-  if (values.itemsDone != null && values.itemsTotal != null && values.itemsTotal > 0) {
-    parts.push(`${formatNumber(values.itemsDone)}/${formatNumber(values.itemsTotal)} items`);
-  }
-
-  if (parts.length === 0) return null;
-  return parts.slice(0, 3).join(' · ');
-}
-
-function defaultProgressMessage(skillId: string): string {
-  if (skillId === 'gmail') return 'Syncing emails...';
-  if (skillId === 'google-drive') return 'Syncing documents...';
-  if (skillId === 'notion') return 'Syncing Notion documents...';
-  return 'Syncing...';
-}
-
-export function deriveSkillSyncUiState(
-  skillId: string,
-  skillState: SkillStateRecord | undefined
-): SkillSyncUiState {
-  if (!skillState) {
-    return { isSyncing: false, progressPercent: null, progressMessage: null, metricsText: null };
-  }
-
-  const isSyncing = readBoolean(skillState.syncInProgress) === true;
-
-  const explicitProgress =
-    readNumber(skillState.syncProgress) ??
-    readNumber(skillState.progressPercent) ??
-    readNumber(skillState.progress);
-
-  const itemDone = readNumber(skillState.itemsDone);
-  const itemTotal = readNumber(skillState.itemsTotal);
-  const ratioProgress =
-    explicitProgress == null && itemDone != null && itemTotal != null && itemTotal > 0
-      ? (itemDone / itemTotal) * 100
-      : null;
-
-  const progressPercent =
-    explicitProgress != null
-      ? clampPercent(explicitProgress)
-      : ratioProgress != null
-        ? clampPercent(ratioProgress)
-        : null;
-
-  const progressMessageRaw =
-    typeof skillState.syncProgressMessage === 'string' ? skillState.syncProgressMessage.trim() : '';
-
-  return {
-    isSyncing,
-    progressPercent: isSyncing ? progressPercent : null,
-    progressMessage: isSyncing ? progressMessageRaw || defaultProgressMessage(skillId) : null,
-    metricsText: isSyncing ? buildMetricsText(skillState) : null,
-  };
-}
-
-export function deriveSkillSyncSummaryText(
-  skillState: SkillStateRecord | undefined,
-  syncStats: SkillSyncStatsLike | undefined
-): string | null {
-  const parts: string[] = [];
-
-  const syncCount = readNumber(syncStats?.syncCount);
-  if (syncCount != null && syncCount > 0) {
-    parts.push(`${formatNumber(syncCount)} sync${syncCount === 1 ? '' : 's'}`);
-  }
-
-  const localDataBytes = readNumber(syncStats?.localDataBytes);
-  if (localDataBytes != null && localDataBytes > 0) {
-    parts.push(`${formatBytes(localDataBytes)} local`);
-  }
-
-  const localFileCount = readNumber(syncStats?.localFileCount);
-  if (localFileCount != null && localFileCount > 0) {
-    parts.push(`${formatNumber(localFileCount)} files`);
-  }
-
-  const lastSyncAtMs = readNumber(syncStats?.lastSyncAtMs);
-  if (lastSyncAtMs != null && lastSyncAtMs > 0) {
-    parts.push(`last ${formatRelativeTime(lastSyncAtMs)}`);
-  } else {
-    const lastSyncFromSkill =
-      readNumber(skillState?.lastSyncTime) ??
-      readNumber(skillState?.last_sync) ??
-      readNumber(skillState?.last_sync_time);
-    if (lastSyncFromSkill != null && lastSyncFromSkill > 0) {
-      parts.push(`last ${formatRelativeTime(lastSyncFromSkill)}`);
-    }
-  }
-
-  if (parts.length === 0) return null;
-  return parts.slice(0, 3).join(' · ');
-}
diff --git a/app/src/services/errorReportQueue.ts b/app/src/services/errorReportQueue.ts
index 0526fff65..47a12fbaf 100644
--- a/app/src/services/errorReportQueue.ts
+++ b/app/src/services/errorReportQueue.ts
@@ -2,7 +2,7 @@
  * Error Report Queue
  *
  * Module-level error queue with zero React/Redux/Sentry dependencies.
- * Captures errors from all sources (React, global JS, skill runtime) and
+ * Captures errors from all sources (React, global JS, core/runtime services) and
  * lets the notification UI subscribe to display them for user opt-in reporting.
  */
 import * as Sentry from '@sentry/react';
@@ -45,7 +45,7 @@ export interface SanitizedSentryEvent {
 export interface PendingErrorReport {
   id: string;
   timestamp: number;
-  source: 'react' | 'global' | 'skill' | 'manual';
+  source: 'react' | 'global' | 'manual';
   title: string;
   message: string;
   componentStack?: string;
diff --git a/app/src/services/socketService.ts b/app/src/services/socketService.ts
index f4c283823..7bc079f30 100644
--- a/app/src/services/socketService.ts
+++ b/app/src/services/socketService.ts
@@ -4,7 +4,6 @@ import { io, Socket } from 'socket.io-client';
 
 import { getCoreStateSnapshot } from '../lib/coreState/store';
 import { SocketIOMCPTransportImpl } from '../lib/mcp';
-import { skillManager, syncToolsToBackend } from '../lib/skills';
 import { store } from '../store';
 import { upsertChannelConnection } from '../store/channelConnectionsSlice';
 import { resetForUser, setSocketIdForUser, setStatusForUser } from '../store/socketSlice';
@@ -198,10 +197,6 @@ class SocketService {
       socketLog('Connected', { socketId, userId: uid });
       store.dispatch(setStatusForUser({ userId: uid, status: 'connected' }));
       store.dispatch(setSocketIdForUser({ userId: uid, socketId }));
-      syncToolsToBackend();
-      void skillManager.resyncRunningSkillsAfterReconnect().catch(err => {
-        console.warn('[socket] resync running skills after reconnect failed:', err);
-      });
     });
 
     this.socket.on('ready', () => {
diff --git a/app/src/types/skillStatus.ts b/app/src/types/skillStatus.ts
new file mode 100644
index 000000000..0c2a7a09e
--- /dev/null
+++ b/app/src/types/skillStatus.ts
@@ -0,0 +1,8 @@
+export type SkillConnectionStatus =
+  | 'connected'
+  | 'connecting'
+  | 'not_authenticated'
+  | 'disconnected'
+  | 'error'
+  | 'offline'
+  | 'setup_required';
diff --git a/app/src/utils/desktopDeepLinkListener.ts b/app/src/utils/desktopDeepLinkListener.ts
index b88b23ea2..f8db0affe 100644
--- a/app/src/utils/desktopDeepLinkListener.ts
+++ b/app/src/utils/desktopDeepLinkListener.ts
@@ -3,9 +3,6 @@ import { getCurrentWindow } from '@tauri-apps/api/window';
 import { getCurrent, onOpenUrl } from '@tauri-apps/plugin-deep-link';
 
 import { getCoreStateSnapshot } from '../lib/coreState/store';
-import { skillManager } from '../lib/skills/manager';
-import { emitSkillStateChange } from '../lib/skills/skillEvents';
-import { startSkill } from '../lib/skills/skillsApi';
 import { consumeLoginToken } from '../services/api/authApi';
 import { buildManualSentryEvent, enqueueError } from '../services/errorReportQueue';
 import { evaluateOAuthAppVersionGate } from './oauthAppVersionGate';
@@ -105,7 +102,7 @@ const handlePaymentDeepLink = async (parsed: URL) => {
 };
 
 /**
- * Handle `openhuman://oauth/success?integrationId=...&skillId=...`
+ * Handle `openhuman://oauth/success?...`
  * and `openhuman://oauth/error?error=...&provider=...` deep links.
  */
 const handleOAuthDeepLink = async (parsed: URL) => {
@@ -116,11 +113,11 @@ const handleOAuthDeepLink = async (parsed: URL) => {
 
   if (path === 'success') {
     const integrationId = parsed.searchParams.get('integrationId');
-    const skillId = parsed.searchParams.get('skillId');
+    const toolkit = parsed.searchParams.get('toolkit') || parsed.searchParams.get('provider');
 
-    if (!integrationId || !skillId) {
-      // Do not log full URL — query can contain secrets (e.g. clientKey).
-      console.error('[DeepLink] OAuth success missing integrationId or skillId');
+    if (!integrationId) {
+      // Do not log full URL — query can contain secrets.
+      console.error('[DeepLink] OAuth success missing integrationId');
       return;
     }
 
@@ -164,40 +161,17 @@ const handleOAuthDeepLink = async (parsed: URL) => {
             current: versionGate.current,
             minimum: versionGate.minimum,
             downloadUrl: versionGate.downloadUrl,
-            skillId,
             integrationId,
           },
         })
       );
       return;
     }
-
-    // Extract client key share from URL params (returned directly by backend in OAuth callback).
-    const clientKeyShare = parsed.searchParams.get('clientKey') || undefined;
-
     console.log(
-      `[DeepLink] OAuth success for skill=${skillId} integration=${integrationId} encrypted=${!!clientKeyShare}`
+      `[DeepLink] OAuth success for integration=${integrationId}${toolkit ? ` toolkit=${toolkit}` : ''}`
     );
-
-    // 2. Start the skill in the core QuickJS runtime (if not already running).
-    //    This also sets enabled=true via the preferences store.
-    try {
-      await startSkill(skillId);
-      console.log(`[DeepLink] Skill '${skillId}' started in core runtime`);
-    } catch (startErr) {
-      console.warn(`[DeepLink] Could not start skill '${skillId}' in runtime:`, startErr);
-    }
-
-    // 3. Notify the running skill of the OAuth credential and mark setup_complete.
-    //    Initial data sync is left to the user / cron / skill UI — not auto-run here.
-    try {
-      await skillManager.notifyOAuthComplete(skillId, integrationId, undefined, { clientKeyShare });
-      console.log(`[DeepLink] OAuth complete sent to skill '${skillId}'`);
-    } catch (runtimeErr) {
-      console.warn('[DeepLink] Runtime notify failed:', runtimeErr);
-    }
-
-    emitSkillStateChange(skillId);
+    window.dispatchEvent(new CustomEvent('oauth:success', { detail: { integrationId, toolkit } }));
+    window.location.hash = '/skills';
   } else if (path === 'error') {
     const error = parsed.searchParams.get('error') ?? 'Unknown error';
     const provider = parsed.searchParams.get('provider') ?? 'unknown';
@@ -273,7 +247,7 @@ export const setupDesktopDeepLinkListener = async () => {
 
     if (typeof window !== 'undefined') {
       // window.__simulateDeepLink('openhuman://auth?token=1234567890')
-      // window.__simulateDeepLink('openhuman://oauth/success?integrationId=69cafd0b103bd070232d3223&skillId=notion')
+      // window.__simulateDeepLink('openhuman://oauth/success?integrationId=69cafd0b103bd070232d3223&provider=notion')
       const win = window as Window & { __simulateDeepLink?: (url: string) => Promise<void> };
       win.__simulateDeepLink = (url: string) => handleDeepLinkUrls([url]);
     }
diff --git a/app/src/utils/tauriCommands/index.ts b/app/src/utils/tauriCommands/index.ts
index 3bcc6bf6a..ec7af23ef 100644
--- a/app/src/utils/tauriCommands/index.ts
+++ b/app/src/utils/tauriCommands/index.ts
@@ -15,5 +15,4 @@ export * from './cron';
 export * from './service';
 export * from './accessibility';
 export * from './autocomplete';
-export * from './skills';
 export * from './voice';
diff --git a/app/src/utils/tauriCommands/skills.ts b/app/src/utils/tauriCommands/skills.ts
deleted file mode 100644
index 8bbb4b4fd..000000000
--- a/app/src/utils/tauriCommands/skills.ts
+++ /dev/null
@@ -1,172 +0,0 @@
-/**
- * Skill runtime commands.
- */
-import { callCoreRpc } from '../../services/coreRpcClient';
-import { isTauri } from './common';
-
-export type IntegrationStatus = 'Available' | 'Active' | 'ComingSoon';
-export type IntegrationCategory =
-  | 'Chat'
-  | 'AiModel'
-  | 'Productivity'
-  | 'MusicAudio'
-  | 'SmartHome'
-  | 'ToolsAutomation'
-  | 'MediaCreative'
-  | 'Social'
-  | 'Platform';
-
-export interface IntegrationInfo {
-  name: string;
-  description: string;
-  category: IntegrationCategory;
-  status: IntegrationStatus;
-  setup_hints: string[];
-}
-
-export interface SkillSnapshot {
-  skill_id: string;
-  name: string;
-  status: unknown;
-  tools: Array<{ name: string; description: string; input_schema?: unknown }>;
-  error?: string | null;
-  state?: Record<string, unknown>;
-}
-
-export interface RuntimeDiscoveredSkill {
-  id: string;
-  name: string;
-  runtime?: string;
-  entry?: string;
-  autoStart?: boolean;
-  version?: string;
-  ignoreInProduction?: boolean;
-  description?: string;
-  platforms?: string[];
-  tickInterval?: number | null;
-  setup?: {
-    required?: boolean;
-    label?: string;
-    oauth?: { provider: string; scopes: string[]; apiBaseUrl: string };
-  };
-}
-
-export interface RuntimeSkillOption {
-  name: string;
-  type: 'boolean' | 'text' | 'number' | 'select';
-  label: string;
-  description?: string | null;
-  default?: string | number | boolean | null;
-  options?: Array<{ label: string; value: string }> | null;
-  value?: string | number | boolean | null;
-}
-
-export interface RuntimeSkillDataStats {
-  exists: boolean;
-  path: string;
-  total_bytes: number;
-  file_count: number;
-}
-
-export async function runtimeListSkills(): Promise<SkillSnapshot[]> {
-  return await callCoreRpc<SkillSnapshot[]>({ method: 'openhuman.skills_list' });
-}
-
-export async function runtimeDiscoverSkills(): Promise<RuntimeDiscoveredSkill[]> {
-  return await callCoreRpc<RuntimeDiscoveredSkill[]>({ method: 'openhuman.skills_discover' });
-}
-
-export async function runtimeStartSkill(skillId: string): Promise<SkillSnapshot> {
-  return await callCoreRpc<SkillSnapshot>({
-    method: 'openhuman.skills_start',
-    params: { skill_id: skillId },
-  });
-}
-
-export async function runtimeStopSkill(skillId: string): Promise<void> {
-  await callCoreRpc({ method: 'openhuman.skills_stop', params: { skill_id: skillId } });
-}
-
-export async function runtimeRpc<T = unknown>(
-  skillId: string,
-  method: string,
-  params: Record<string, unknown> = {}
-): Promise<T> {
-  return await callCoreRpc<T>({
-    method: 'openhuman.skills_rpc',
-    params: { skill_id: skillId, method, params },
-  });
-}
-
-export async function runtimeSkillDataRead(skillId: string, filename: string): Promise<string> {
-  const result = await callCoreRpc<{ content: string }>({
-    method: 'openhuman.skills_data_read',
-    params: { skill_id: skillId, filename },
-  });
-  return result.content;
-}
-
-export async function runtimeSkillDataWrite(
-  skillId: string,
-  filename: string,
-  content: string
-): Promise<void> {
-  await callCoreRpc({
-    method: 'openhuman.skills_data_write',
-    params: { skill_id: skillId, filename, content },
-  });
-}
-
-export async function runtimeSkillDataDir(skillId: string): Promise<string> {
-  const result = await callCoreRpc<{ path: string }>({
-    method: 'openhuman.skills_data_dir',
-    params: { skill_id: skillId },
-  });
-  return result.path;
-}
-
-export async function runtimeListSkillOptions(skillId: string): Promise<RuntimeSkillOption[]> {
-  if (!isTauri()) {
-    throw new Error('Not running in Tauri');
-  }
-  const response = await runtimeRpc<{ options?: RuntimeSkillOption[] }>(
-    skillId,
-    'options/list',
-    {}
-  );
-  return response.options ?? [];
-}
-
-export async function runtimeSetSkillOption(
-  skillId: string,
-  name: string,
-  value: unknown
-): Promise<void> {
-  if (!isTauri()) {
-    throw new Error('Not running in Tauri');
-  }
-  await runtimeRpc(skillId, 'options/set', { name, value });
-}
-
-export async function runtimeIsSkillEnabled(skillId: string): Promise<boolean> {
-  const result = await callCoreRpc<{ enabled: boolean }>({
-    method: 'openhuman.skills_is_enabled',
-    params: { skill_id: skillId },
-  });
-  return result.enabled;
-}
-
-export async function runtimeEnableSkill(skillId: string): Promise<void> {
-  await callCoreRpc({ method: 'openhuman.skills_enable', params: { skill_id: skillId } });
-}
-
-export async function runtimeDisableSkill(skillId: string): Promise<void> {
-  await callCoreRpc({ method: 'openhuman.skills_disable', params: { skill_id: skillId } });
-}
-
-export async function runtimeSkillDataStats(skillId: string): Promise<RuntimeSkillDataStats> {
-  return await callCoreRpc<RuntimeSkillDataStats>({
-    method: 'openhuman.skills_data_stats',
-    params: { skill_id: skillId },
-  });
-}
diff --git a/app/test/Mnemonic.test.tsx b/app/test/Mnemonic.test.tsx
index b93813929..099153135 100644
--- a/app/test/Mnemonic.test.tsx
+++ b/app/test/Mnemonic.test.tsx
@@ -34,16 +34,12 @@ const {
   mockGenerateMnemonicPhrase,
   mockValidateMnemonicPhrase,
   mockDeriveAesKey,
-  mockDeriveEvm,
-  mockSetWalletAddress,
   mockSetEncryptionKey,
   mockUseCoreState,
 } = vi.hoisted(() => ({
   mockGenerateMnemonicPhrase: vi.fn(() => FIXED_MNEMONIC),
   mockValidateMnemonicPhrase: vi.fn(() => true),
   mockDeriveAesKey: vi.fn(() => 'aes-key-hex'),
-  mockDeriveEvm: vi.fn(() => '0xDeAdBeEf'),
-  mockSetWalletAddress: vi.fn().mockResolvedValue(undefined),
   mockSetEncryptionKey: vi.fn().mockResolvedValue(undefined),
   mockUseCoreState: vi.fn(),
 }));
@@ -53,11 +49,6 @@ vi.mock('../src/utils/cryptoKeys', () => ({
   generateMnemonicPhrase: mockGenerateMnemonicPhrase,
   validateMnemonicPhrase: mockValidateMnemonicPhrase,
   deriveAesKeyFromMnemonic: mockDeriveAesKey,
-  deriveEvmAddressFromMnemonic: mockDeriveEvm,
-}));
-
-vi.mock('../src/lib/skills/manager', () => ({
-  skillManager: { setWalletAddress: mockSetWalletAddress },
 }));
 
 vi.mock('../src/providers/CoreStateProvider', () => ({ useCoreState: () => mockUseCoreState() }));
@@ -101,8 +92,6 @@ beforeEach(() => {
   mockGenerateMnemonicPhrase.mockClear();
   mockValidateMnemonicPhrase.mockClear();
   mockDeriveAesKey.mockClear();
-  mockDeriveEvm.mockClear();
-  mockSetWalletAddress.mockClear();
   mockSetEncryptionKey.mockClear();
   mockUseCoreState.mockReturnValue({
     snapshot: { currentUser: mockUser, sessionToken: 'jwt-token' },
@@ -425,11 +414,10 @@ describe('Mnemonic — import mode: validation', () => {
 
 describe('Mnemonic — handleContinue: generate mode', () => {
   it('shows loading text while processing', async () => {
-    // Make setWalletAddress hang so we can observe the loading state
-    let resolveWallet!: () => void;
-    mockSetWalletAddress.mockReturnValueOnce(
+    let resolveEncryptionKey!: () => void;
+    mockSetEncryptionKey.mockReturnValueOnce(
       new Promise<void>(res => {
-        resolveWallet = res;
+        resolveEncryptionKey = res;
       })
     );
 
@@ -443,7 +431,7 @@ describe('Mnemonic — handleContinue: generate mode', () => {
     await waitFor(() => expect(screen.getByText('Securing Your Data...')).toBeInTheDocument());
 
     await act(async () => {
-      resolveWallet();
+      resolveEncryptionKey();
     });
   });
 
@@ -455,11 +443,10 @@ describe('Mnemonic — handleContinue: generate mode', () => {
       fireEvent.click(continueButton());
     });
 
-    await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalled());
     expect(mockSetEncryptionKey).toHaveBeenCalledWith('aes-key-hex');
   });
 
-  it('calls deriveAesKeyFromMnemonic and deriveEvmAddressFromMnemonic with the mnemonic', async () => {
+  it('calls deriveAesKeyFromMnemonic with the generated mnemonic', async () => {
     renderWithUser();
     fireEvent.click(screen.getByRole('checkbox'));
 
@@ -467,20 +454,7 @@ describe('Mnemonic — handleContinue: generate mode', () => {
       fireEvent.click(continueButton());
     });
 
-    await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalled());
     expect(mockDeriveAesKey).toHaveBeenCalledWith(FIXED_MNEMONIC);
-    expect(mockDeriveEvm).toHaveBeenCalledWith(FIXED_MNEMONIC);
-  });
-
-  it('calls skillManager.setWalletAddress with the derived EVM address', async () => {
-    renderWithUser();
-    fireEvent.click(screen.getByRole('checkbox'));
-
-    await act(async () => {
-      fireEvent.click(continueButton());
-    });
-
-    await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalledWith('0xDeAdBeEf'));
   });
 
   it('shows "User not loaded" error when user._id is missing', async () => {
@@ -523,7 +497,6 @@ describe('Mnemonic — handleContinue: generate mode', () => {
 
     // No dispatch should have happened
     await new Promise(r => setTimeout(r, 50));
-    expect(mockSetWalletAddress).not.toHaveBeenCalled();
     expect(mockSetEncryptionKey).not.toHaveBeenCalled();
   });
 });
@@ -537,7 +510,7 @@ describe('Mnemonic — handleContinue: import mode', () => {
     mockValidateMnemonicPhrase.mockReturnValue(true);
   });
 
-  it('derives keys from the imported phrase and navigates to /home', async () => {
+  it('derives the encryption key from the imported phrase and navigates to /home', async () => {
     renderWithUser();
     switchToImport();
     fillAllImportWords();
@@ -546,7 +519,6 @@ describe('Mnemonic — handleContinue: import mode', () => {
       fireEvent.click(continueButton());
     });
 
-    await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalledWith('0xDeAdBeEf'));
     expect(mockDeriveAesKey).toHaveBeenCalledWith(FIXED_MNEMONIC);
   });
 
@@ -559,7 +531,6 @@ describe('Mnemonic — handleContinue: import mode', () => {
       fireEvent.click(continueButton());
     });
 
-    await waitFor(() => expect(mockSetWalletAddress).toHaveBeenCalled());
     expect(mockSetEncryptionKey).toHaveBeenCalledWith('aes-key-hex');
   });
 
@@ -596,8 +567,8 @@ describe('Mnemonic — handleContinue: import mode', () => {
     await waitFor(() => expect(screen.getByText(/user not loaded/i)).toBeInTheDocument());
   });
 
-  it('shows an error when skillManager.setWalletAddress throws during import', async () => {
-    mockSetWalletAddress.mockRejectedValueOnce(new Error('wallet error'));
+  it('shows an error when setEncryptionKey throws during import', async () => {
+    mockSetEncryptionKey.mockRejectedValueOnce(new Error('encryption error'));
 
     renderWithUser();
     switchToImport();
@@ -607,7 +578,7 @@ describe('Mnemonic — handleContinue: import mode', () => {
       fireEvent.click(continueButton());
     });
 
-    await waitFor(() => expect(screen.getByText('wallet error')).toBeInTheDocument());
+    await waitFor(() => expect(screen.getByText('encryption error')).toBeInTheDocument());
   });
 });
 
@@ -617,10 +588,10 @@ describe('Mnemonic — handleContinue: import mode', () => {
 
 describe('Mnemonic — loading state', () => {
   it('disables Continue button while loading', async () => {
-    let resolveWallet!: () => void;
-    mockSetWalletAddress.mockReturnValueOnce(
+    let resolveEncryptionKey!: () => void;
+    mockSetEncryptionKey.mockReturnValueOnce(
       new Promise<void>(res => {
-        resolveWallet = res;
+        resolveEncryptionKey = res;
       })
     );
 
@@ -635,7 +606,7 @@ describe('Mnemonic — loading state', () => {
     expect(btn).toBeDisabled();
 
     await act(async () => {
-      resolveWallet();
+      resolveEncryptionKey();
     });
   });
 
diff --git a/src/core/all.rs b/src/core/all.rs
index 9bf3cde07..94aab8dd2 100644
--- a/src/core/all.rs
+++ b/src/core/all.rs
@@ -83,7 +83,6 @@ fn build_registered_controllers() -> Vec<RegisteredController> {
     controllers.extend(
         crate::openhuman::screen_intelligence::all_screen_intelligence_registered_controllers(),
     );
-    controllers.extend(crate::openhuman::skills::all_skills_registered_controllers());
     controllers.extend(crate::openhuman::socket::all_socket_registered_controllers());
     controllers.extend(crate::openhuman::workspace::all_workspace_registered_controllers());
     controllers.extend(crate::openhuman::tools::all_tools_registered_controllers());
@@ -126,7 +125,6 @@ fn build_declared_controller_schemas() -> Vec<ControllerSchema> {
     schemas.extend(
         crate::openhuman::screen_intelligence::all_screen_intelligence_controller_schemas(),
     );
-    schemas.extend(crate::openhuman::skills::all_skills_controller_schemas());
     schemas.extend(crate::openhuman::socket::all_socket_controller_schemas());
     schemas.extend(crate::openhuman::workspace::all_workspace_controller_schemas());
     schemas.extend(crate::openhuman::tools::all_tools_controller_schemas());
@@ -182,7 +180,6 @@ pub fn namespace_description(namespace: &str) -> Option<&'static str> {
         "migrate" => Some("Data migration utilities."),
         "screen_intelligence" => Some("Screen capture, permissions, and accessibility automation."),
         "service" => Some("Desktop service lifecycle management."),
-        "skills" => Some("Skill registry, runtime lifecycle, setup, tools, and sync."),
         "socket" => Some("Skills runtime socket bridge controls."),
         "memory" => Some("Document storage, vector search, key-value store, and knowledge graph."),
         "referral" => Some("Referral codes, stats, and apply flows via the hosted backend API."),
diff --git a/src/core/cli.rs b/src/core/cli.rs
index 88986e856..ed3c557b1 100644
--- a/src/core/cli.rs
+++ b/src/core/cli.rs
@@ -54,7 +54,6 @@ pub fn run_from_cli_args(args: &[String]) -> Result<()> {
     match args[0].as_str() {
         "run" | "serve" => run_server_command(&args[1..]),
         "call" => run_call_command(&args[1..]),
-        "skills" => crate::core::skills_cli::run_skills_command(&args[1..]),
         "screen-intelligence" => {
             crate::core::screen_intelligence_cli::run_screen_intelligence_command(&args[1..])
         }
diff --git a/src/core/jsonrpc.rs b/src/core/jsonrpc.rs
index 7c13ba274..e2b3088d3 100644
--- a/src/core/jsonrpc.rs
+++ b/src/core/jsonrpc.rs
@@ -489,32 +489,11 @@ async fn events_handler(
 
 /// Handler for the webhook debug events SSE endpoint.
 async fn webhook_events_handler() -> Response {
-    let Some(engine) = crate::openhuman::skills::global_engine() else {
-        let stream = tokio_stream::once(Ok::<Event, std::convert::Infallible>(
-            Event::default()
-                .event("webhooks_debug")
-                .data("{\"event_type\":\"runtime_unavailable\"}"),
-        ));
-        return Sse::new(stream)
-            .keep_alive(KeepAlive::new().interval(std::time::Duration::from_secs(10)))
-            .into_response();
-    };
-
-    let rx = engine.webhook_router().subscribe_debug_events();
-    let stream = tokio_stream::wrappers::BroadcastStream::new(rx).filter_map(move |item| {
-        let event = match item {
-            Ok(ev) => ev,
-            Err(_) => return None,
-        };
-        let data = match serde_json::to_string(&event) {
-            Ok(data) => data,
-            Err(_) => return None,
-        };
-        Some(Ok::<Event, std::convert::Infallible>(
-            Event::default().event("webhooks_debug").data(data),
-        ))
-    });
-
+    let stream = tokio_stream::once(Ok::<Event, std::convert::Infallible>(
+        Event::default()
+            .event("webhooks_debug")
+            .data("{\"event_type\":\"runtime_removed\"}"),
+    ));
     Sse::new(stream)
         .keep_alive(KeepAlive::new().interval(std::time::Duration::from_secs(10)))
         .into_response()
@@ -581,7 +560,7 @@ fn core_host() -> String {
 /// Runs the HTTP/JSON-RPC server.
 ///
 /// This function binds to the specified host and port, initializes the router,
-/// bootstraps the skill runtime, and starts serving requests.
+/// bootstraps long-lived runtime infrastructure, and starts serving requests.
 pub async fn run_server(
     host: Option<&str>,
     port: Option<u16>,
@@ -825,7 +804,6 @@ fn register_domain_subscribers(workspace_dir: std::path::PathBuf) {
         }
 
         crate::openhuman::health::bus::register_health_subscriber();
-        crate::openhuman::skills::bus::register_skill_cleanup_subscriber();
         crate::openhuman::memory::conversations::register_conversation_persistence_subscriber(
             workspace_dir,
         );
@@ -841,47 +819,23 @@ fn register_domain_subscribers(workspace_dir: std::path::PathBuf) {
         crate::openhuman::agent::bus::register_agent_handlers();
 
         log::info!(
-            "[event_bus] webhook, channel, health, skill, composio, restart subscribers + agent native handlers registered"
+            "[event_bus] webhook, channel, health, conversation persistence, composio, restart subscribers + agent native handlers registered"
         );
     });
 }
 
-/// Initializes the QuickJS skill runtime, socket manager, and registers them
-/// globally so RPC handlers (`openhuman.skills_*`, `openhuman.socket_*`) can
-/// reach them.
+/// Initializes long-lived socket/event-bus infrastructure.
 pub async fn bootstrap_skill_runtime() {
-    use crate::openhuman::skills::paths::resolve_runtime_paths;
-    use crate::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
     use crate::openhuman::socket::{set_global_socket_manager, SocketManager};
     use std::sync::Arc;
-
-    // Resolve per-user scoped paths via Config so `skills_data` lives under
-    // `~/.openhuman/users/{user_id}/skills_data` when an active user is set,
-    // matching how config, workspace, and auth are scoped.
-    let paths = resolve_runtime_paths().await;
-    let skills_data_dir = paths.skills_data_dir.clone();
-    let workspace_dir = paths.workspace_dir.clone();
-
-    if let Err(e) = std::fs::create_dir_all(&skills_data_dir) {
-        log::error!(
-            "[runtime] Failed to create skills data dir {}: {e}",
-            skills_data_dir.display()
-        );
-        return;
-    }
-
-    let engine = match RuntimeEngine::new(skills_data_dir) {
-        Ok(e) => Arc::new(e),
+    let cfg = match crate::openhuman::config::Config::load_or_init().await {
+        Ok(cfg) => cfg,
         Err(e) => {
-            log::error!("[runtime] Failed to create RuntimeEngine: {e}");
+            log::error!("[runtime] Failed to load config for socket manager: {e}");
             return;
         }
     };
-
-    // Point the engine at the (also scoped) workspace directory for
-    // user-installed skills.
-    let _ = std::fs::create_dir_all(&workspace_dir);
-    engine.set_workspace_dir(workspace_dir.clone());
+    let workspace_dir = cfg.workspace_dir.clone();
 
     // --- Event bus bootstrap ---
     // Ensure the global event bus is initialized (no-op if already done by start_channels).
@@ -909,23 +863,6 @@ pub async fn bootstrap_skill_runtime() {
     set_global_socket_manager(socket_mgr.clone());
     log::info!("[socket] SocketManager initialized and registered globally");
 
-    // Register engine globally so RPC handlers can access it.
-    set_global_engine(engine.clone());
-
-    // Start the ping scheduler (background health checks).
-    engine.ping_scheduler().start();
-
-    // Start the cron scheduler.
-    engine.cron_scheduler().start();
-
-    log::info!("[runtime] Skill runtime initialized");
-
-    // Auto-start skills in the background so it doesn't block server startup.
-    let engine_for_skills = engine.clone();
-    tokio::spawn(async move {
-        engine_for_skills.auto_start_skills().await;
-    });
-
     // Auto-connect socket to backend if a session token is already stored.
     // This runs in the background so it doesn't block server startup.
     tokio::spawn(async move {
diff --git a/src/core/mod.rs b/src/core/mod.rs
index 08195ab9b..948dc3687 100644
--- a/src/core/mod.rs
+++ b/src/core/mod.rs
@@ -12,7 +12,6 @@ pub mod memory_cli;
 pub mod rpc_log;
 pub mod screen_intelligence_cli;
 pub mod shutdown;
-pub mod skills_cli;
 pub mod socketio;
 pub mod text_input_cli;
 pub mod tree_summarizer_cli;
diff --git a/src/core/skills_cli.rs b/src/core/skills_cli.rs
deleted file mode 100644
index acf42de52..000000000
--- a/src/core/skills_cli.rs
+++ /dev/null
@@ -1,541 +0,0 @@
-//! `openhuman skills` — lightweight CLI for skill development.
-//!
-//! Boots **only** the QuickJS skill runtime (no Socket.IO, no local-AI, no
-//! Telegram auth) and exposes a minimal JSON-RPC server so skill authors can
-//! test against the real runtime without building the full desktop app.
-//!
-//! Usage:
-//!   openhuman skills run   [--skills-dir <path>] [--port <u16>] [-v]
-//!   openhuman skills list  [--skills-dir <path>]
-//!   openhuman skills start <skill-id> [--skills-dir <path>]
-//!   openhuman skills call  <skill-id> <tool-name> [--args '<json>'] [--skills-dir <path>]
-//!   openhuman skills test  <skill-id> [--skills-dir <path>]
-
-use anyhow::Result;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-/// Entry point for `openhuman skills <subcommand>`.
-pub fn run_skills_command(args: &[String]) -> Result<()> {
-    if args.is_empty() || is_help(&args[0]) {
-        print_skills_help();
-        return Ok(());
-    }
-
-    match args[0].as_str() {
-        "run" => run_skills_server(&args[1..]),
-        "list" => run_skills_list(&args[1..]),
-        "start" => run_skills_start(&args[1..]),
-        "call" => run_skills_call(&args[1..]),
-        "test" => run_skills_test(&args[1..]),
-        other => Err(anyhow::anyhow!(
-            "unknown skills subcommand '{other}'. Run `openhuman skills --help`."
-        )),
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Shared helpers
-// ---------------------------------------------------------------------------
-
-/// Common options parsed from CLI flags.
-struct SkillsOpts {
-    skills_dir: Option<PathBuf>,
-    port: u16,
-    verbose: bool,
-}
-
-fn parse_common_opts(args: &[String]) -> Result<(SkillsOpts, Vec<String>)> {
-    let mut skills_dir: Option<PathBuf> = None;
-    let mut port: u16 = 7799; // default skills-dev port (different from main 7788)
-    let mut verbose = false;
-    let mut rest = Vec::new();
-    let mut i = 0;
-
-    while i < args.len() {
-        match args[i].as_str() {
-            "--skills-dir" => {
-                let val = args
-                    .get(i + 1)
-                    .ok_or_else(|| anyhow::anyhow!("missing value for --skills-dir"))?;
-                skills_dir = Some(PathBuf::from(val));
-                i += 2;
-            }
-            "--port" => {
-                let val = args
-                    .get(i + 1)
-                    .ok_or_else(|| anyhow::anyhow!("missing value for --port"))?;
-                port = val
-                    .parse()
-                    .map_err(|e| anyhow::anyhow!("invalid --port: {e}"))?;
-                i += 2;
-            }
-            "-v" | "--verbose" => {
-                verbose = true;
-                i += 1;
-            }
-            "-h" | "--help" => {
-                // Caller will handle this
-                rest.push(args[i].clone());
-                i += 1;
-            }
-            _ => {
-                rest.push(args[i].clone());
-                i += 1;
-            }
-        }
-    }
-
-    Ok((
-        SkillsOpts {
-            skills_dir,
-            port,
-            verbose,
-        },
-        rest,
-    ))
-}
-
-/// Bootstrap the QuickJS skill runtime with an optional skills directory override.
-async fn bootstrap_skills_runtime(
-    skills_dir: Option<&PathBuf>,
-) -> Result<Arc<crate::openhuman::skills::qjs_engine::RuntimeEngine>> {
-    use crate::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
-
-    // If --skills-dir is given, set SKILLS_LOCAL_DIR so the engine picks it up.
-    if let Some(dir) = skills_dir {
-        let canonical = dir.canonicalize().unwrap_or_else(|_| dir.clone());
-        std::env::set_var("SKILLS_LOCAL_DIR", &canonical);
-        log::info!("[skills-cli] SKILLS_LOCAL_DIR = {:?}", canonical);
-    }
-
-    // Resolve per-user scoped paths via Config so `skills_data` honours
-    // `active_user.toml` and lives under `~/.openhuman/users/{user_id}/skills_data`
-    // for authenticated users. See `openhuman::skills::paths`.
-    let paths = crate::openhuman::skills::paths::resolve_runtime_paths().await;
-    let skills_data_dir = paths.skills_data_dir.clone();
-    let workspace_dir = paths.workspace_dir.clone();
-
-    std::fs::create_dir_all(&skills_data_dir).map_err(|e| {
-        anyhow::anyhow!(
-            "failed to create skills data dir {}: {e}",
-            skills_data_dir.display()
-        )
-    })?;
-
-    let engine = RuntimeEngine::new(skills_data_dir)
-        .map_err(|e| anyhow::anyhow!("failed to create RuntimeEngine: {e}"))?;
-    let engine = Arc::new(engine);
-
-    // Point at the (also scoped) workspace directory for user-installed skills.
-    let _ = std::fs::create_dir_all(&workspace_dir);
-    engine.set_workspace_dir(workspace_dir);
-
-    // Register globally so RPC handlers can access it.
-    set_global_engine(engine.clone());
-
-    // Start cron + ping schedulers.
-    engine.ping_scheduler().start();
-    engine.cron_scheduler().start();
-
-    log::info!("[skills-cli] Skill runtime initialized");
-    Ok(engine)
-}
-
-// ---------------------------------------------------------------------------
-// Subcommands
-// ---------------------------------------------------------------------------
-
-/// `openhuman skills run` — start a minimal JSON-RPC server with just the skill runtime.
-fn run_skills_server(args: &[String]) -> Result<()> {
-    let (opts, rest) = parse_common_opts(args)?;
-
-    if rest.iter().any(|a| is_help(a)) {
-        println!("Usage: openhuman skills run [--skills-dir <path>] [--port <u16>] [-v]");
-        println!();
-        println!("Start a lightweight JSON-RPC server with only the skill runtime.");
-        println!("Skills are auto-discovered and auto-started.");
-        println!();
-        println!(
-            "  --skills-dir <path>  Directory containing compiled skills (default: auto-detect)"
-        );
-        println!("  --port <u16>         Listen port (default: 7799)");
-        println!("  -v, --verbose        Enable debug logging");
-        return Ok(());
-    }
-
-    crate::core::logging::init_for_cli_run(
-        opts.verbose,
-        crate::core::logging::CliLogDefault::Global,
-    );
-
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?;
-
-    rt.block_on(async {
-        let engine = bootstrap_skills_runtime(opts.skills_dir.as_ref()).await?;
-
-        // Auto-start all skills.
-        engine.auto_start_skills().await;
-
-        // Build a minimal HTTP router (health + JSON-RPC only).
-        let app = build_skills_only_router();
-
-        let bind_addr = format!("127.0.0.1:{}", opts.port);
-        let listener = tokio::net::TcpListener::bind(&bind_addr).await?;
-
-        log::info!("[skills-cli] Skills runtime ready — http://{bind_addr}/rpc (JSON-RPC 2.0)");
-        log::info!("[skills-cli] Health check: http://{bind_addr}/health");
-
-        // Print discovered skills summary.
-        let skills = engine.list_skills();
-        if skills.is_empty() {
-            log::warn!(
-                "[skills-cli] No skills discovered. Check --skills-dir or SKILLS_LOCAL_DIR."
-            );
-        } else {
-            for snap in &skills {
-                log::info!("[skills-cli]   {} — {:?}", snap.skill_id, snap.status,);
-            }
-        }
-
-        eprintln!();
-        eprintln!("  Skills dev server listening on http://{bind_addr}");
-        eprintln!("  Press Ctrl+C to stop.");
-        eprintln!();
-
-        axum::serve(listener, app).await?;
-        Ok(())
-    })
-}
-
-/// `openhuman skills list` — discover and list available skills.
-fn run_skills_list(args: &[String]) -> Result<()> {
-    let (opts, rest) = parse_common_opts(args)?;
-
-    if rest.iter().any(|a| is_help(a)) {
-        println!("Usage: openhuman skills list [--skills-dir <path>]");
-        println!();
-        println!("Discover and list all available skills.");
-        return Ok(());
-    }
-
-    init_quiet_logging(opts.verbose);
-
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?;
-
-    rt.block_on(async {
-        let engine = bootstrap_skills_runtime(opts.skills_dir.as_ref()).await?;
-        let manifests = engine.discover_skills().await.map_err(anyhow::Error::msg)?;
-
-        if manifests.is_empty() {
-            println!("No skills found.");
-        } else {
-            println!("{:<20} {:<10} NAME", "ID", "VERSION");
-            println!("{}", "-".repeat(60));
-            for m in &manifests {
-                println!(
-                    "{:<20} {:<10} {}",
-                    m.id,
-                    m.version.as_deref().unwrap_or("-"),
-                    m.name
-                );
-            }
-            println!("\n{} skill(s) found.", manifests.len());
-        }
-        Ok(())
-    })
-}
-
-/// `openhuman skills start <skill-id>` — start a single skill and print its state.
-fn run_skills_start(args: &[String]) -> Result<()> {
-    let (opts, rest) = parse_common_opts(args)?;
-
-    if rest.is_empty() || rest.iter().any(|a| is_help(a)) {
-        println!("Usage: openhuman skills start <skill-id> [--skills-dir <path>] [-v]");
-        println!();
-        println!("Start a single skill and print its initialization state.");
-        return Ok(());
-    }
-
-    let skill_id = &rest[0];
-    init_quiet_logging(opts.verbose);
-
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?;
-
-    rt.block_on(async {
-        let engine = bootstrap_skills_runtime(opts.skills_dir.as_ref()).await?;
-
-        match engine.start_skill(skill_id).await {
-            Ok(snap) => {
-                println!(
-                    "{}",
-                    serde_json::to_string_pretty(&snap).unwrap_or_else(|_| format!("{:?}", snap))
-                );
-            }
-            Err(e) => {
-                eprintln!("Failed to start skill '{}': {}", skill_id, e);
-                std::process::exit(1);
-            }
-        }
-        Ok(())
-    })
-}
-
-/// `openhuman skills call <skill-id> <tool-name> [--args '<json>']` — call a tool.
-fn run_skills_call(args: &[String]) -> Result<()> {
-    let (opts, rest) = parse_common_opts(args)?;
-
-    // Extract --args from rest
-    let mut tool_args = serde_json::Value::Object(serde_json::Map::new());
-    let mut positional = Vec::new();
-    let mut i = 0;
-    while i < rest.len() {
-        if rest[i] == "--args" {
-            let val = rest
-                .get(i + 1)
-                .ok_or_else(|| anyhow::anyhow!("missing value for --args"))?;
-            tool_args = serde_json::from_str(val)
-                .map_err(|e| anyhow::anyhow!("invalid --args JSON: {e}"))?;
-            i += 2;
-        } else if is_help(&rest[i]) {
-            println!("Usage: openhuman skills call <skill-id> <tool-name> [--args '<json>'] [--skills-dir <path>] [-v]");
-            println!();
-            println!("Start a skill, then call one of its tools and print the result.");
-            return Ok(());
-        } else {
-            positional.push(rest[i].clone());
-            i += 1;
-        }
-    }
-
-    if positional.len() < 2 {
-        return Err(anyhow::anyhow!(
-            "expected: openhuman skills call <skill-id> <tool-name>"
-        ));
-    }
-
-    let skill_id = &positional[0];
-    let tool_name = &positional[1];
-
-    init_quiet_logging(opts.verbose);
-
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?;
-
-    rt.block_on(async {
-        let engine = bootstrap_skills_runtime(opts.skills_dir.as_ref()).await?;
-
-        // Start the skill first.
-        engine
-            .start_skill(skill_id)
-            .await
-            .map_err(anyhow::Error::msg)?;
-
-        // Call the tool.
-        match engine.call_tool(skill_id, tool_name, tool_args).await {
-            Ok(result) => {
-                println!(
-                    "{}",
-                    serde_json::to_string_pretty(&result)
-                        .unwrap_or_else(|_| format!("{:?}", result))
-                );
-            }
-            Err(e) => {
-                eprintln!("Tool call failed: {}.{} — {}", skill_id, tool_name, e);
-                std::process::exit(1);
-            }
-        }
-        Ok(())
-    })
-}
-
-/// `openhuman skills test <skill-id>` — start a skill, run basic health checks.
-fn run_skills_test(args: &[String]) -> Result<()> {
-    let (opts, rest) = parse_common_opts(args)?;
-
-    if rest.is_empty() || rest.iter().any(|a| is_help(a)) {
-        println!("Usage: openhuman skills test <skill-id> [--skills-dir <path>] [-v]");
-        println!();
-        println!("Start a skill, verify lifecycle hooks, list tools, and print a summary.");
-        return Ok(());
-    }
-
-    let skill_id = &rest[0];
-    init_quiet_logging(opts.verbose);
-
-    let rt = tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()?;
-
-    rt.block_on(async {
-        let engine = bootstrap_skills_runtime(opts.skills_dir.as_ref()).await?;
-
-        eprintln!("--- Testing skill: {} ---\n", skill_id);
-
-        // 1. Start the skill.
-        eprint!("  [1/3] Starting skill... ");
-        match engine.start_skill(skill_id).await {
-            Ok(snap) => {
-                eprintln!("OK ({:?})", snap.status);
-            }
-            Err(e) => {
-                eprintln!("FAIL: {}", e);
-                std::process::exit(1);
-            }
-        }
-
-        // 2. List tools.
-        eprint!("  [2/3] Listing tools... ");
-        let all_tools = engine.all_tools();
-        let skill_tools: Vec<_> = all_tools
-            .iter()
-            .filter(|(sid, _)| sid == skill_id)
-            .collect();
-        eprintln!("{} tool(s) registered", skill_tools.len());
-        for (_, tool) in &skill_tools {
-            eprintln!("         - {}: {}", tool.name, tool.description);
-        }
-
-        // 3. Stop the skill.
-        eprint!("  [3/3] Stopping skill... ");
-        match engine.stop_skill(skill_id).await {
-            Ok(()) => eprintln!("OK"),
-            Err(e) => eprintln!("WARN: {}", e),
-        }
-
-        eprintln!("\n--- All checks passed ---");
-        Ok(())
-    })
-}
-
-// ---------------------------------------------------------------------------
-// Minimal HTTP router (skills-only)
-// ---------------------------------------------------------------------------
-
-fn build_skills_only_router() -> axum::Router {
-    use axum::routing::{get, post};
-
-    axum::Router::new()
-        .route("/health", get(health))
-        .route("/rpc", post(rpc))
-        .route("/tools", get(list_tools))
-        .route("/skills", get(list_skills))
-}
-
-async fn health() -> impl axum::response::IntoResponse {
-    axum::Json(serde_json::json!({ "ok": true, "mode": "skills-dev" }))
-}
-
-async fn rpc(
-    axum::Json(req): axum::Json<crate::core::types::RpcRequest>,
-) -> axum::response::Response {
-    use crate::core::types::{RpcError, RpcFailure, RpcSuccess};
-    use axum::response::IntoResponse;
-
-    let id = req.id.clone();
-    let state = crate::core::jsonrpc::default_state();
-
-    match crate::core::jsonrpc::invoke_method(state, req.method.as_str(), req.params).await {
-        Ok(value) => (
-            axum::http::StatusCode::OK,
-            axum::Json(RpcSuccess {
-                jsonrpc: "2.0",
-                id,
-                result: value,
-            }),
-        )
-            .into_response(),
-        Err(message) => (
-            axum::http::StatusCode::OK,
-            axum::Json(RpcFailure {
-                jsonrpc: "2.0",
-                id,
-                error: RpcError {
-                    code: -32000,
-                    message,
-                    data: None,
-                },
-            }),
-        )
-            .into_response(),
-    }
-}
-
-async fn list_tools() -> impl axum::response::IntoResponse {
-    let engine = crate::openhuman::skills::global_engine();
-    match engine {
-        Some(e) => {
-            let tools: Vec<_> = e
-                .all_tools()
-                .into_iter()
-                .map(|(skill_id, tool)| {
-                    serde_json::json!({
-                        "skill_id": skill_id,
-                        "name": tool.name,
-                        "description": tool.description,
-                    })
-                })
-                .collect();
-            axum::Json(serde_json::json!({ "tools": tools }))
-        }
-        None => axum::Json(serde_json::json!({ "tools": [], "error": "runtime not initialized" })),
-    }
-}
-
-async fn list_skills() -> impl axum::response::IntoResponse {
-    let engine = crate::openhuman::skills::global_engine();
-    match engine {
-        Some(e) => {
-            let skills = e.list_skills();
-            axum::Json(serde_json::json!({ "skills": skills }))
-        }
-        None => axum::Json(serde_json::json!({ "skills": [], "error": "runtime not initialized" })),
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/// Quiet logging: only `warn` unless verbose (used for non-server subcommands).
-fn init_quiet_logging(verbose: bool) {
-    if !verbose && std::env::var_os("RUST_LOG").is_none() {
-        std::env::set_var("RUST_LOG", "warn");
-    }
-    crate::core::logging::init_for_cli_run(verbose, crate::core::logging::CliLogDefault::Global);
-}
-
-fn is_help(value: &str) -> bool {
-    matches!(value, "-h" | "--help" | "help")
-}
-
-fn print_skills_help() {
-    println!("openhuman skills — skill development runtime\n");
-    println!("Usage:");
-    println!("  openhuman skills run   [--skills-dir <path>] [--port <u16>] [-v]");
-    println!("  openhuman skills list  [--skills-dir <path>]");
-    println!("  openhuman skills start <skill-id> [--skills-dir <path>] [-v]");
-    println!(
-        "  openhuman skills call  <skill-id> <tool-name> [--args '<json>'] [--skills-dir <path>]"
-    );
-    println!("  openhuman skills test  <skill-id> [--skills-dir <path>] [-v]");
-    println!();
-    println!("Subcommands:");
-    println!("  run    Start a lightweight JSON-RPC server with only the skill runtime");
-    println!("  list   Discover and list available skills");
-    println!("  start  Start a single skill and print its state");
-    println!("  call   Start a skill and call one of its tools");
-    println!("  test   Start a skill, verify lifecycle, list tools, stop");
-    println!();
-    println!("Common options:");
-    println!("  --skills-dir <path>  Compiled skills directory (overrides auto-detection)");
-    println!("  --port <u16>         Server port for 'run' (default: 7799)");
-    println!("  -v, --verbose        Enable debug logging");
-}
diff --git a/src/openhuman/agent/agents/skills_agent/agent.toml b/src/openhuman/agent/agents/skills_agent/agent.toml
index f44c0acc1..9553df451 100644
--- a/src/openhuman/agent/agents/skills_agent/agent.toml
+++ b/src/openhuman/agent/agents/skills_agent/agent.toml
@@ -1,6 +1,6 @@
 id = "skills_agent"
 display_name = "Skills Agent"
-when_to_use = "Service integration specialist — executes skill-category tools that reach external SaaS. This covers Composio (1000+ OAuth integrations: Gmail, Notion, GitHub, Slack, …) as well as any installed QuickJS skill tools. Use when the task should be completed via a managed integration rather than raw HTTP/file I/O. Pair with a `skill_filter` argument to scope to a single QuickJS skill when applicable."
+when_to_use = "Service integration specialist — executes skill-category tools that reach external SaaS. This primarily covers Composio (1000+ OAuth integrations: Gmail, Notion, GitHub, Slack, …). Use when the task should be completed via a managed integration rather than raw HTTP/file I/O."
 temperature = 0.4
 max_iterations = 10
 sandbox_mode = "none"
diff --git a/src/openhuman/agent/agents/skills_agent/prompt.md b/src/openhuman/agent/agents/skills_agent/prompt.md
index ceca84c08..8c5ae5752 100644
--- a/src/openhuman/agent/agents/skills_agent/prompt.md
+++ b/src/openhuman/agent/agents/skills_agent/prompt.md
@@ -1,6 +1,6 @@
 # Skills Agent — Service Integration Specialist
 
-You are the **Skills Agent**. You interact with connected external services — primarily through **Composio** (a managed OAuth gateway for 1000+ apps like Gmail, Notion, GitHub, Slack) and, when installed, user-provided **QuickJS skill tools**.
+You are the **Skills Agent**. You interact with connected external services primarily through **Composio** (a managed OAuth gateway for 1000+ apps like Gmail, Notion, GitHub, Slack).
 
 ## Available tool surfaces
 
@@ -10,8 +10,6 @@ You are the **Skills Agent**. You interact with connected external services —
    - `composio_authorize` — start an OAuth handoff for a toolkit; returns a `connectUrl`.
    - `composio_list_tools` — list available action schemas (optionally filtered by toolkit). Use the returned `function.name` slug as the `tool` argument to `composio_execute`.
    - `composio_execute` — run a Composio action with `{ tool, arguments }` (e.g. `tool = "GMAIL_SEND_EMAIL"`).
-2. **QuickJS skill tools** — when present, these follow the `{skill_id}__{tool_name}` convention (e.g. `notion__create_page`, `gmail__send_email`). They behave like any other tool but run inside the skill runtime.
-
 ## Typical Composio flow
 
 1. Call `composio_list_connections` to see what the user already has connected.
@@ -21,7 +19,6 @@ You are the **Skills Agent**. You interact with connected external services —
 
 ## Rules
 
-- **Prefer Composio** for standard SaaS tasks unless a QuickJS skill offers a better-fit capability.
 - **Never fabricate action slugs.** Always pull them from `composio_list_tools` before calling `composio_execute`.
 - **Respect rate limits** — Composio and upstream providers both throttle. Back off on errors rather than retrying tightly.
 - **Handle OAuth expiry** — if an action fails with an auth error, surface the need to re-authorise rather than looping.
diff --git a/src/openhuman/agent/harness/session/builder.rs b/src/openhuman/agent/harness/session/builder.rs
index b3aa4e952..0c16abba9 100644
--- a/src/openhuman/agent/harness/session/builder.rs
+++ b/src/openhuman/agent/harness/session/builder.rs
@@ -327,17 +327,6 @@ impl Agent {
             config,
         );
 
-        // Bridge skill tools (Notion, Gmail, etc.) from the QuickJS runtime
-        // into the agent's tool registry so the LLM can call them.
-        let skill_tools = tools::collect_skill_tools();
-        if !skill_tools.is_empty() {
-            log::info!(
-                "[agent] Injecting {} skill tool(s) into agent registry",
-                skill_tools.len()
-            );
-            tools.extend(skill_tools);
-        }
-
         let model_name = config
             .default_model
             .as_deref()
diff --git a/src/openhuman/composio/tools.rs b/src/openhuman/composio/tools.rs
index 660c7c357..5272ad3d8 100644
--- a/src/openhuman/composio/tools.rs
+++ b/src/openhuman/composio/tools.rs
@@ -58,8 +58,8 @@ impl Tool for ComposioListToolkitsTool {
     }
     fn category(&self) -> ToolCategory {
         // Composio proxies to external SaaS (Gmail, Notion, …), so it
-        // lives in the Skill category alongside QuickJS skill tools and
-        // is picked up by sub-agents with `category_filter = "skill"`.
+        // lives in the Skill category and is picked up by sub-agents
+        // with `category_filter = "skill"`.
         ToolCategory::Skill
     }
     async fn execute(&self, _args: Value) -> anyhow::Result<ToolResult> {
diff --git a/src/openhuman/skills/bridge/mod.rs b/src/openhuman/skills/bridge/mod.rs
deleted file mode 100644
index a6b506504..000000000
--- a/src/openhuman/skills/bridge/mod.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-//! Bridge modules for the skill runtime.
-//!
-//! This module provides bridges between the JavaScript execution environment
-//! and the native Rust backend. These bridges allow skills to perform
-//! operations that are not natively supported by the JS runtime or require
-//! elevated permissions.
-
-pub mod net;
diff --git a/src/openhuman/skills/bridge/net.rs b/src/openhuman/skills/bridge/net.rs
deleted file mode 100644
index d1d6f511f..000000000
--- a/src/openhuman/skills/bridge/net.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! HTTP networking bridge for skills.
-//!
-//! Provides a synchronous HTTP client bridge designed for environments
-//! where the standard asynchronous `fetch` API may not be suitable,
-//! such as within certain V8 isolates or when strict synchronous
-//! execution is required.
-
-use serde::Deserialize;
-use std::collections::HashMap;
-
-/// Options for an HTTP fetch request, typically deserialized from a JSON string
-/// provided by the JavaScript runtime.
-#[derive(Default, Deserialize)]
-pub struct FetchOptions {
-    /// The HTTP method to use (e.g., "GET", "POST"). Defaults to "GET".
-    pub method: Option<String>,
-    /// A map of HTTP headers to include in the request.
-    pub headers: Option<HashMap<String, String>>,
-    /// The raw string body of the request.
-    pub body: Option<String>,
-    /// The request timeout in seconds. Defaults to 30.
-    pub timeout: Option<u64>,
-}
-
-/// Performs a synchronous HTTP fetch operation.
-///
-/// This function spawns a dedicated OS thread to execute the request using `reqwest::blocking`,
-/// which ensures it doesn't block the main Tokio executor or the JavaScript event loop.
-/// It uses a synchronous channel to wait for the result from the background thread.
-///
-/// Returns a JSON-formatted string containing the status code, headers, and body.
-///
-/// # Errors
-/// Returns an error string if the request fails, the background thread panics,
-/// or the operation times out (120 seconds hard limit).
-pub fn http_fetch(url: &str, options_json: &str) -> Result<String, String> {
-    let url = url.to_string();
-    let options_json = options_json.to_string();
-
-    let (tx, rx) = std::sync::mpsc::sync_channel::<Result<String, String>>(1);
-
-    // Spawn a thread because reqwest::blocking can conflict with the Tokio runtime
-    // if called directly from an async context.
-    std::thread::spawn(move || {
-        let result = do_fetch(&url, &options_json);
-        let _ = tx.send(result);
-    });
-
-    // Wait with a generous timeout (HTTP timeout + buffer)
-    rx.recv_timeout(std::time::Duration::from_secs(120))
-        .map_err(|e| format!("HTTP fetch failed: {e}"))?
-}
-
-/// Internal implementation of the HTTP request using the `reqwest::blocking` client.
-fn do_fetch(url: &str, options_json: &str) -> Result<String, String> {
-    let options: FetchOptions = serde_json::from_str(options_json).unwrap_or_default();
-
-    let timeout_secs = options.timeout.unwrap_or(30);
-    let client = reqwest::blocking::Client::builder()
-        .use_rustls_tls()
-        .timeout(std::time::Duration::from_secs(timeout_secs))
-        .build()
-        .map_err(|e| format!("Failed to create HTTP client: {e}"))?;
-
-    let mut req = match options.method.as_deref() {
-        Some("POST") | Some("post") => client.post(url),
-        Some("PUT") | Some("put") => client.put(url),
-        Some("DELETE") | Some("delete") => client.delete(url),
-        Some("PATCH") | Some("patch") => client.patch(url),
-        Some("HEAD") | Some("head") => client.head(url),
-        _ => client.get(url),
-    };
-
-    if let Some(headers) = options.headers {
-        for (key, value) in headers {
-            req = req.header(&key, &value);
-        }
-    }
-
-    if let Some(body) = options.body {
-        req = req.body(body);
-    }
-
-    let resp = req.send().map_err(|e| {
-        // Walk the full error chain to provide detailed diagnostics for TLS, DNS, or network issues.
-        let mut msg = format!("HTTP request failed: {e}");
-        let mut source = std::error::Error::source(&e);
-        while let Some(cause) = source {
-            msg.push_str(&format!(" | caused by: {cause}"));
-            source = std::error::Error::source(cause);
-        }
-        msg
-    })?;
-
-    let status = resp.status().as_u16();
-    let headers: HashMap<String, String> = resp
-        .headers()
-        .iter()
-        .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
-        .collect();
-    let body = resp
-        .text()
-        .map_err(|e| format!("Failed to read response body: {e}"))?;
-
-    let result = serde_json::json!({
-        "status": status,
-        "headers": headers,
-        "body": body,
-    });
-
-    Ok(result.to_string())
-}
diff --git a/src/openhuman/skills/bus.rs b/src/openhuman/skills/bus.rs
index d75a85f2d..a7705d147 100644
--- a/src/openhuman/skills/bus.rs
+++ b/src/openhuman/skills/bus.rs
@@ -1,79 +1,3 @@
-//! Event bus handlers for the skills domain.
-//!
-//! Keeps skill lifecycle side effects behind the message bus so callers can
-//! stop skills without importing cron/webhook cleanup concerns directly.
+//! Legacy no-op event bus hooks retained while call-sites are cleaned up.
 
-use std::sync::{Arc, OnceLock};
-
-use async_trait::async_trait;
-
-use crate::core::event_bus::{DomainEvent, EventHandler, SubscriptionHandle};
-
-static SKILL_CLEANUP_HANDLE: OnceLock<SubscriptionHandle> = OnceLock::new();
-
-/// Register the long-lived skill cleanup subscriber on the global event bus.
-pub fn register_skill_cleanup_subscriber() {
-    if SKILL_CLEANUP_HANDLE.get().is_some() {
-        return;
-    }
-
-    match crate::core::event_bus::subscribe_global(Arc::new(SkillCleanupSubscriber)) {
-        Some(handle) => {
-            let _ = SKILL_CLEANUP_HANDLE.set(handle);
-        }
-        None => {
-            log::warn!(
-                "[event_bus] failed to register skill cleanup subscriber — bus not initialized"
-            );
-        }
-    }
-}
-
-pub struct SkillCleanupSubscriber;
-
-#[async_trait]
-impl EventHandler for SkillCleanupSubscriber {
-    fn name(&self) -> &str {
-        "skill::cleanup"
-    }
-
-    fn domains(&self) -> Option<&[&str]> {
-        Some(&["skill"])
-    }
-
-    async fn handle(&self, event: &DomainEvent) {
-        let DomainEvent::SkillStopped { skill_id } = event else {
-            return;
-        };
-
-        let Some(engine) = crate::openhuman::skills::global_engine() else {
-            log::warn!(
-                "[skills:bus] received SkillStopped for '{}' but runtime engine is unavailable",
-                skill_id
-            );
-            return;
-        };
-
-        log::debug!(
-            "[skills:bus] handling SkillStopped cleanup for '{}'",
-            skill_id
-        );
-        engine.cron_scheduler().unregister_all_for_skill(skill_id);
-        engine.webhook_router().unregister_skill(skill_id);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn ignores_non_skill_stop_events() {
-        let sub = SkillCleanupSubscriber;
-        sub.handle(&DomainEvent::SkillLoaded {
-            skill_id: "gmail".into(),
-            runtime: "qjs".into(),
-        })
-        .await;
-    }
-}
+pub fn register_skill_cleanup_subscriber() {}
diff --git a/src/openhuman/skills/cron_scheduler.rs b/src/openhuman/skills/cron_scheduler.rs
deleted file mode 100644
index fc8d8bca7..000000000
--- a/src/openhuman/skills/cron_scheduler.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-//! `CronScheduler` — global Tokio-based cron scheduler.
-//!
-//! Manages scheduled tasks (cron jobs) registered by skills. It runs a background
-//! tick loop that evaluates all active schedules and triggers the corresponding
-//! skills when their schedules are due.
-//!
-//! Cron expressions use 6 fields (seconds included):
-//! `sec min hour day-of-month month day-of-week`
-//! Example: `"0 */5 * * * *"` triggers every 5 minutes at second 0.
-
-use std::collections::HashMap;
-use std::str::FromStr;
-use std::sync::Arc;
-
-use chrono::Utc;
-use cron::Schedule;
-use parking_lot::RwLock;
-use tokio::sync::watch;
-
-use crate::openhuman::skills::skill_registry::SkillRegistry;
-
-/// Represents a single registered cron schedule.
-struct CronEntry {
-    /// The parsed cron schedule.
-    schedule: Schedule,
-    /// The unique identifier of the skill that owns this schedule.
-    skill_id: String,
-    /// A skill-specific identifier for the schedule.
-    schedule_id: String,
-    /// The timestamp when this schedule last fired.
-    last_fired: Option<chrono::DateTime<Utc>>,
-}
-
-/// A global scheduler for managing and triggering cron-based skill events.
-pub struct CronScheduler {
-    /// Active cron schedules, keyed by a composite of skill ID and schedule ID.
-    entries: Arc<RwLock<HashMap<String, CronEntry>>>,
-    /// A reference to the global skill registry, used to dispatch triggers.
-    registry: Arc<RwLock<Option<Arc<SkillRegistry>>>>,
-    /// A channel used to signal the background tick loop to terminate.
-    stop_tx: watch::Sender<bool>,
-}
-
-impl CronScheduler {
-    /// Creates a new `CronScheduler` instance.
-    pub fn new() -> Self {
-        let (stop_tx, _) = watch::channel(false);
-        Self {
-            entries: Arc::new(RwLock::new(HashMap::new())),
-            registry: Arc::new(RwLock::new(None)),
-            stop_tx,
-        }
-    }
-
-    /// Sets the skill registry reference for the scheduler.
-    ///
-    /// This is typically called during system initialization after the registry has been created.
-    pub fn set_registry(&self, registry: Arc<SkillRegistry>) {
-        *self.registry.write() = Some(registry);
-    }
-
-    /// Registers a new cron schedule for a specific skill.
-    ///
-    /// # Errors
-    /// Returns an error if the provided `cron_expr` is not a valid cron expression.
-    #[allow(dead_code)]
-    pub fn register(
-        &self,
-        skill_id: &str,
-        schedule_id: &str,
-        cron_expr: &str,
-    ) -> Result<(), String> {
-        let schedule = Schedule::from_str(cron_expr)
-            .map_err(|e| format!("Invalid cron expression '{}': {e}", cron_expr))?;
-
-        let key = format!("{}:{}", skill_id, schedule_id);
-        self.entries.write().insert(
-            key,
-            CronEntry {
-                schedule,
-                skill_id: skill_id.to_string(),
-                schedule_id: schedule_id.to_string(),
-                last_fired: None,
-            },
-        );
-
-        log::info!(
-            "[cron] Registered '{}' for skill '{}': {}",
-            schedule_id,
-            skill_id,
-            cron_expr
-        );
-        Ok(())
-    }
-
-    /// Unregisters a specific cron schedule for a skill.
-    #[allow(dead_code)]
-    pub fn unregister(&self, skill_id: &str, schedule_id: &str) {
-        let key = format!("{}:{}", skill_id, schedule_id);
-        self.entries.write().remove(&key);
-        log::info!(
-            "[cron] Unregistered '{}' for skill '{}'",
-            schedule_id,
-            skill_id
-        );
-    }
-
-    /// Unregisters all cron schedules associated with a specific skill.
-    ///
-    /// This is typically called when a skill is stopped or uninstalled.
-    pub fn unregister_all_for_skill(&self, skill_id: &str) {
-        let prefix = format!("{}:", skill_id);
-        self.entries.write().retain(|k, _| !k.starts_with(&prefix));
-        log::info!("[cron] Unregistered all schedules for skill '{}'", skill_id);
-    }
-
-    /// Lists all registered schedules for a specific skill.
-    ///
-    /// Returns a vector of tuples containing the schedule ID and the next expected fire time
-    /// formatted as an RFC3339 string.
-    #[allow(dead_code)]
-    pub fn list_schedules(&self, skill_id: &str) -> Vec<(String, String)> {
-        let entries = self.entries.read();
-        let prefix = format!("{}:", skill_id);
-        entries
-            .iter()
-            .filter(|(k, _)| k.starts_with(&prefix))
-            .map(|(_, e)| {
-                let next = e
-                    .schedule
-                    .upcoming(Utc)
-                    .next()
-                    .map(|t| t.to_rfc3339())
-                    .unwrap_or_default();
-                (e.schedule_id.clone(), next)
-            })
-            .collect()
-    }
-
-    /// Starts the background tick loop as a Tokio task.
-    ///
-    /// The loop ticks every 5 seconds, evaluating all schedules and firing those that are due.
-    /// Returns the handle to the spawned task.
-    pub fn start(&self) -> tokio::task::JoinHandle<()> {
-        let entries = self.entries.clone();
-        let registry = self.registry.clone();
-        let mut stop_rx = self.stop_tx.subscribe();
-
-        tokio::spawn(async move {
-            log::info!("[cron] Scheduler started (5s tick interval)");
-
-            loop {
-                tokio::select! {
-                    _ = tokio::time::sleep(std::time::Duration::from_secs(5)) => {
-                        let reg = registry.read().clone();
-                        Self::tick(&entries, &reg).await;
-                    }
-                    _ = stop_rx.changed() => {
-                        log::info!("[cron] Scheduler stopped");
-                        break;
-                    }
-                }
-            }
-        })
-    }
-
-    /// Signals the background tick loop to stop.
-    #[allow(dead_code)]
-    pub fn stop(&self) {
-        let _ = self.stop_tx.send(true);
-    }
-
-    /// Internal tick logic: evaluates all registered schedules against the current time.
-    ///
-    /// If a schedule is due, it adds it to a list of triggers and dispatches them
-    /// via the skill registry.
-    async fn tick(
-        entries: &Arc<RwLock<HashMap<String, CronEntry>>>,
-        registry: &Option<Arc<SkillRegistry>>,
-    ) {
-        let now = Utc::now();
-        let mut to_fire: Vec<(String, String)> = Vec::new();
-
-        {
-            let mut entries = entries.write();
-            for entry in entries.values_mut() {
-                // Determine if the schedule should fire based on the last fire time
-                // or a lookback window for new schedules.
-                let should_fire = if let Some(last) = entry.last_fired {
-                    // Check if there's a fire time between last_fired and now
-                    entry
-                        .schedule
-                        .after(&last)
-                        .next()
-                        .map(|next| next <= now)
-                        .unwrap_or(false)
-                } else {
-                    // First tick for this entry: check if there's a fire time in the last 30s window
-                    let window_start = now - chrono::Duration::seconds(30);
-                    entry
-                        .schedule
-                        .after(&window_start)
-                        .next()
-                        .map(|next| next <= now)
-                        .unwrap_or(false)
-                };
-
-                if should_fire {
-                    to_fire.push((entry.skill_id.clone(), entry.schedule_id.clone()));
-                    entry.last_fired = Some(now);
-                }
-            }
-        }
-
-        // Dispatch triggers to the registry
-        if let Some(registry) = registry {
-            for (skill_id, schedule_id) in to_fire {
-                log::info!("[cron] Firing '{}' for skill '{}'", schedule_id, skill_id);
-                if let Err(e) = registry.trigger_cron(&skill_id, &schedule_id).await {
-                    log::warn!(
-                        "[cron] Failed to trigger '{}:{}': {e}",
-                        skill_id,
-                        schedule_id
-                    );
-                }
-            }
-        }
-    }
-}
-
-impl Default for CronScheduler {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/src/openhuman/skills/manifest.rs b/src/openhuman/skills/manifest.rs
deleted file mode 100644
index 7fe2481d3..000000000
--- a/src/openhuman/skills/manifest.rs
+++ /dev/null
@@ -1,332 +0,0 @@
-//! Skill manifest parsing and validation.
-//!
-//! Each skill directory must contain a `manifest.json` file that describes the skill's
-//! metadata, runtime requirements, authentication modes, and setup configuration.
-//! This module parses these files and produces a `SkillConfig` for the runtime engine.
-
-use crate::openhuman::skills::types::SkillConfig;
-use serde::{Deserialize, Serialize};
-use std::path::Path;
-
-/// Setup configuration defined in `manifest.json`.
-///
-/// This describes whether a skill requires manual setup and what authentication
-/// or configuration fields should be presented to the user in the UI.
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct SkillSetup {
-    /// Whether the skill requires setup before it can be used.
-    #[serde(default)]
-    pub required: bool,
-    /// human-readable label for the setup process.
-    pub label: Option<String>,
-    /// OAuth configuration (provider, scopes, apiBaseUrl).
-    ///
-    /// NOTE: This is considered legacy — prefer `auth` for new skills.
-    pub oauth: Option<serde_json::Value>,
-    /// Advanced authentication configuration with support for multiple modes.
-    ///
-    /// When present, the UI shows a mode selector (e.g., managed vs. self-hosted).
-    #[serde(default)]
-    pub auth: Option<SkillAuthConfig>,
-}
-
-/// Supported authentication mode types.
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum SkillAuthType {
-    /// Authentication managed by the OpenHuman platform.
-    Managed,
-    /// User-provided credentials for a self-hosted instance.
-    SelfHosted,
-    /// Raw text input (e.g., for API keys or service account JSON).
-    Text,
-}
-
-/// Advanced authentication configuration declaring available modes.
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct SkillAuthConfig {
-    /// List of available authentication modes. At least one mode is required.
-    #[serde(deserialize_with = "deserialize_non_empty_modes")]
-    pub modes: Vec<SkillAuthMode>,
-}
-
-/// Custom deserializer to ensure that `auth.modes` contains at least one entry.
-fn deserialize_non_empty_modes<'de, D>(deserializer: D) -> Result<Vec<SkillAuthMode>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let modes = Vec::<SkillAuthMode>::deserialize(deserializer)?;
-    if modes.is_empty() {
-        return Err(serde::de::Error::custom(
-            "auth.modes must contain at least one mode",
-        ));
-    }
-    Ok(modes)
-}
-
-/// A single authentication mode that a skill supports.
-///
-/// The fields in this struct are used selectively based on the `mode_type`.
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct SkillAuthMode {
-    /// The type of authentication mode (managed, self_hosted, or text).
-    #[serde(rename = "type")]
-    pub mode_type: SkillAuthType,
-    /// human-readable label for this mode in the UI.
-    pub label: Option<String>,
-    /// Short description of the mode shown below the label.
-    pub description: Option<String>,
-
-    // --- Managed mode fields ---
-    /// OAuth provider name (e.g., "google", "github", "notion").
-    pub provider: Option<String>,
-    /// List of OAuth scopes to request from the provider.
-    pub scopes: Option<Vec<String>>,
-    /// Base URL for API requests that are proxied through the OpenHuman backend.
-    #[serde(rename = "apiBaseUrl")]
-    pub api_base_url: Option<String>,
-
-    // --- Self-hosted mode fields ---
-    /// Dynamic form fields for credential input, represented as JSON objects.
-    #[serde(default)]
-    pub fields: Vec<serde_json::Value>,
-
-    // --- Text mode fields ---
-    /// Hint text shown above the textarea input.
-    #[serde(rename = "textDescription")]
-    pub text_description: Option<String>,
-    /// Placeholder text displayed inside the textarea.
-    #[serde(rename = "textPlaceholder")]
-    pub text_placeholder: Option<String>,
-}
-
-/// The raw manifest structure as it appears in `manifest.json`.
-#[derive(Debug, Deserialize, serde::Serialize)]
-pub struct SkillManifest {
-    /// Unique identifier for the skill (e.g., "price-tracker").
-    pub id: String,
-    /// Human-readable name of the skill.
-    pub name: String,
-    /// The runtime environment required by the skill. Defaults to "v8".
-    #[serde(default = "default_runtime")]
-    pub runtime: String,
-    /// The main entry point script file, relative to the skill directory.
-    #[serde(default = "default_entry_point")]
-    pub entry: String,
-    /// Optional memory limit for the skill in megabytes. Defaults to 64 MB.
-    pub memory_limit_mb: Option<usize>,
-    /// Whether the skill should automatically start when the application launches.
-    #[serde(default)]
-    pub auto_start: bool,
-    /// Informational version string.
-    pub version: Option<String>,
-    /// If true, the skill will be ignored in production builds.
-    #[serde(default, rename = "ignoreInProduction")]
-    pub ignore_in_production: bool,
-    /// human-readable description of the skill's purpose.
-    pub description: Option<String>,
-    /// Optional setup configuration for the skill.
-    #[serde(default)]
-    pub setup: Option<SkillSetup>,
-    /// Optional list of platforms where this skill is supported (e.g., ["macos", "windows"]).
-    /// If absent or empty, the skill is assumed to support all platforms.
-    #[serde(default)]
-    pub platforms: Option<Vec<String>>,
-    /// The type of skill, used for unified registry dispatch.
-    /// "openhuman" indicates a standard QuickJS skill.
-    #[serde(default = "default_skill_type")]
-    pub skill_type: String,
-}
-
-fn default_skill_type() -> String {
-    "openhuman".to_string()
-}
-
-fn default_runtime() -> String {
-    "v8".to_string()
-}
-
-fn default_entry_point() -> String {
-    "index.js".to_string()
-}
-
-/// Returns the current operating system as a string compatible with manifest platform filters.
-fn current_platform() -> &'static str {
-    match std::env::consts::OS {
-        "windows" => "windows",
-        "macos" => "macos",
-        "linux" => "linux",
-        _ => "unknown",
-    }
-}
-
-impl SkillManifest {
-    /// Parse a `SkillManifest` from a JSON string.
-    pub fn from_json(json: &str) -> Result<Self, String> {
-        serde_json::from_str(json).map_err(|e| format!("Failed to parse manifest: {e}"))
-    }
-
-    /// Read and parse a `SkillManifest` from a file path asynchronously.
-    pub async fn from_path(path: &Path) -> Result<Self, String> {
-        let content = tokio::fs::read_to_string(path)
-            .await
-            .map_err(|e| format!("Failed to read manifest at {}: {e}", path.display()))?;
-        Self::from_json(&content)
-    }
-
-    /// Check if the manifest specifies a JavaScript-compatible runtime.
-    ///
-    /// Currently accepts "v8", "javascript", and "quickjs".
-    pub fn is_javascript(&self) -> bool {
-        matches!(self.runtime.as_str(), "v8" | "javascript" | "quickjs")
-    }
-
-    /// Check if the skill is supported on the current execution platform.
-    ///
-    /// Returns true if `platforms` is not specified or if the current platform
-    /// is explicitly included in the list.
-    pub fn supports_current_platform(&self) -> bool {
-        let platforms = match &self.platforms {
-            Some(p) if !p.is_empty() => p,
-            _ => return true, // No restriction → available everywhere
-        };
-        let current = current_platform();
-        platforms.iter().any(|p| p == current)
-    }
-
-    /// Convert the manifest into a `SkillConfig` for use by the `RuntimeEngine`.
-    ///
-    /// This resolves default values and converts megabytes to bytes.
-    pub fn to_config(&self) -> SkillConfig {
-        SkillConfig {
-            skill_id: self.id.clone(),
-            name: self.name.clone(),
-            entry_point: self.entry.clone(),
-            memory_limit: self
-                .memory_limit_mb
-                .map(|mb| mb * 1024 * 1024)
-                .unwrap_or(64 * 1024 * 1024),
-            auto_start: self.auto_start,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    const MINIMAL_MANIFEST: &str = r#"{"id":"test","name":"Test Skill"}"#;
-
-    const FULL_MANIFEST: &str = r#"{
-        "id": "price-tracker",
-        "name": "Price Tracker",
-        "runtime": "quickjs",
-        "entry": "main.js",
-        "memory_limit_mb": 128,
-        "auto_start": true,
-        "version": "1.0.0",
-        "description": "Tracks prices",
-        "platforms": ["macos", "linux"]
-    }"#;
-
-    #[test]
-    fn parse_minimal_manifest() {
-        let m = SkillManifest::from_json(MINIMAL_MANIFEST).unwrap();
-        assert_eq!(m.id, "test");
-        assert_eq!(m.name, "Test Skill");
-        assert_eq!(m.runtime, "v8"); // default
-        assert_eq!(m.entry, "index.js"); // default
-        assert!(!m.auto_start);
-        assert!(m.memory_limit_mb.is_none());
-        assert!(m.platforms.is_none());
-    }
-
-    #[test]
-    fn parse_full_manifest() {
-        let m = SkillManifest::from_json(FULL_MANIFEST).unwrap();
-        assert_eq!(m.id, "price-tracker");
-        assert_eq!(m.runtime, "quickjs");
-        assert_eq!(m.entry, "main.js");
-        assert_eq!(m.memory_limit_mb, Some(128));
-        assert!(m.auto_start);
-        assert_eq!(m.platforms.as_ref().unwrap().len(), 2);
-    }
-
-    #[test]
-    fn parse_invalid_json_returns_error() {
-        assert!(SkillManifest::from_json("not json").is_err());
-    }
-
-    #[test]
-    fn is_javascript_known_runtimes() {
-        for rt in &["v8", "javascript", "quickjs"] {
-            let json = format!(r#"{{"id":"t","name":"T","runtime":"{}"}}"#, rt);
-            let m = SkillManifest::from_json(&json).unwrap();
-            assert!(m.is_javascript(), "expected is_javascript() for '{rt}'");
-        }
-    }
-
-    #[test]
-    fn is_javascript_unknown_runtime() {
-        let m = SkillManifest::from_json(r#"{"id":"t","name":"T","runtime":"python"}"#).unwrap();
-        assert!(!m.is_javascript());
-    }
-
-    #[test]
-    fn supports_current_platform_no_restriction() {
-        let m = SkillManifest::from_json(MINIMAL_MANIFEST).unwrap();
-        assert!(m.supports_current_platform());
-    }
-
-    #[test]
-    fn supports_current_platform_empty_vec() {
-        let m = SkillManifest::from_json(r#"{"id":"t","name":"T","platforms":[]}"#).unwrap();
-        assert!(m.supports_current_platform());
-    }
-
-    #[test]
-    fn to_config_memory_limit_conversion() {
-        let m = SkillManifest::from_json(FULL_MANIFEST).unwrap();
-        let cfg = m.to_config();
-        assert_eq!(cfg.memory_limit, 128 * 1024 * 1024);
-        assert_eq!(cfg.skill_id, "price-tracker");
-        assert_eq!(cfg.entry_point, "main.js");
-        assert!(cfg.auto_start);
-    }
-
-    #[test]
-    fn to_config_default_memory_limit() {
-        let m = SkillManifest::from_json(MINIMAL_MANIFEST).unwrap();
-        let cfg = m.to_config();
-        assert_eq!(cfg.memory_limit, 64 * 1024 * 1024);
-    }
-
-    #[test]
-    fn auth_mode_type_deserializes_known_types() {
-        let json = r#"{"id":"t","name":"T","setup":{"required":true,"auth":{"modes":[
-            {"type":"managed","label":"Cloud","provider":"google"},
-            {"type":"self_hosted","label":"Own"},
-            {"type":"text","label":"Token"}
-        ]}}}"#;
-        let m = SkillManifest::from_json(json).unwrap();
-        let modes = &m.setup.unwrap().auth.unwrap().modes;
-        assert_eq!(modes.len(), 3);
-        assert_eq!(modes[0].mode_type, SkillAuthType::Managed);
-        assert_eq!(modes[1].mode_type, SkillAuthType::SelfHosted);
-        assert_eq!(modes[2].mode_type, SkillAuthType::Text);
-    }
-
-    #[test]
-    fn auth_mode_type_rejects_invalid_type() {
-        let json = r#"{"id":"t","name":"T","setup":{"required":true,"auth":{"modes":[
-            {"type":"banana","label":"Bad"}
-        ]}}}"#;
-        assert!(SkillManifest::from_json(json).is_err());
-    }
-
-    #[test]
-    fn auth_modes_rejects_empty() {
-        let json = r#"{"id":"t","name":"T","setup":{"required":true,"auth":{"modes":[]}}}"#;
-        assert!(SkillManifest::from_json(json).is_err());
-    }
-}
diff --git a/src/openhuman/skills/mod.rs b/src/openhuman/skills/mod.rs
index c7eb16009..488957a14 100644
--- a/src/openhuman/skills/mod.rs
+++ b/src/openhuman/skills/mod.rs
@@ -1,34 +1,7 @@
-//! The `skills` module provides the core runtime and management system for OpenHuman skills.
-//!
-//! It includes:
-//! - A QuickJS-based engine for executing skill code (`qjs_engine.rs`)
-//! - A registry for managing installed and active skills (`skill_registry.rs`)
-//! - Manifest parsing and validation for skill metadata (`manifest.rs`)
-//! - Various operations for skill lifecycle management (`ops.rs`, `registry_ops.rs`)
+//! Legacy skill metadata helpers retained after QuickJS runtime removal.
 
-pub mod bridge;
 pub mod bus;
-pub mod cron_scheduler;
-pub mod manifest;
 pub mod ops;
-pub mod paths;
-pub mod ping_scheduler;
-pub mod preferences;
-pub mod qjs_engine;
-pub mod qjs_skill_instance;
-pub mod quickjs_libs;
-mod registry_cache;
-pub mod registry_ops;
-pub mod registry_types;
-mod schemas;
-pub mod skill_registry;
 pub mod types;
-pub mod utils;
-pub mod working_memory;
 
 pub use ops::*;
-pub use qjs_engine::{global_engine, replace_global_engine, require_engine, set_global_engine};
-pub use schemas::{
-    all_controller_schemas as all_skills_controller_schemas,
-    all_registered_controllers as all_skills_registered_controllers,
-};
diff --git a/src/openhuman/skills/paths.rs b/src/openhuman/skills/paths.rs
deleted file mode 100644
index b2c767a39..000000000
--- a/src/openhuman/skills/paths.rs
+++ /dev/null
@@ -1,173 +0,0 @@
-//! Path resolution for the skills runtime.
-//!
-//! Skill runtime state (OAuth tokens, webhook routes, ops snapshots, per-skill
-//! data dirs) must live **under the active user's scoped directory** —
-//! `~/.openhuman/users/{user_id}/skills_data` — so that switching users on the
-//! same machine cleanly isolates OAuth credentials, sync cursors, and cached
-//! results.
-//!
-//! Before this helper was introduced, both `core::jsonrpc::bootstrap_skill_runtime`
-//! and `core::skills_cli::bootstrap_skills_runtime` reconstructed the base path
-//! manually from `$OPENHUMAN_WORKSPACE` or `~/.openhuman`, bypassing
-//! `Config::load_or_init` and therefore ignoring `active_user.toml`. That left
-//! every skill's data pooled at `~/.openhuman/skills_data` regardless of which
-//! user was logged in — the single unscoped slice of state in an otherwise
-//! user-scoped layout.
-//!
-//! This module centralises resolution so every bootstrap site produces the
-//! same scoped paths.
-
-use std::path::PathBuf;
-
-/// Paths required to initialise the QuickJS skills runtime.
-#[derive(Debug, Clone)]
-pub struct SkillsRuntimePaths {
-    /// Where per-skill persistent state lives (OAuth tokens, ops snapshots,
-    /// `skill-preferences.json`, `webhook_routes.json`, per-skill subdirs).
-    pub skills_data_dir: PathBuf,
-    /// The workspace directory the engine uses for user-installed skills
-    /// from the registry and for agent definitions (`agents/*.toml`).
-    pub workspace_dir: PathBuf,
-}
-
-/// Resolve skills runtime paths via `Config::load_or_init` so they honour
-/// `active_user.toml` and the full per-user scoping pipeline.
-///
-/// If config loading fails (e.g. the process is booting before any config
-/// file has been written) this falls back to the legacy unscoped layout so
-/// the runtime can still come up — but emits a warning so the degraded mode
-/// is visible in logs.
-pub async fn resolve_runtime_paths() -> SkillsRuntimePaths {
-    match crate::openhuman::config::Config::load_or_init().await {
-        Ok(config) => {
-            // `config_path` is `{openhuman_dir}/config.toml`. Its parent is the
-            // openhuman_dir itself — which, when an active user is set, is
-            // `{root}/users/{user_id}` (see `resolve_runtime_config_dirs` in
-            // `config/schema/load.rs`). Sibling-of-config matches the existing
-            // on-disk convention for skills_data (it used to sit next to
-            // config.toml at `~/.openhuman/skills_data`).
-            let openhuman_dir = config
-                .config_path
-                .parent()
-                .map(PathBuf::from)
-                .unwrap_or_else(|| config.workspace_dir.clone());
-
-            let skills_data_dir = openhuman_dir.join("skills_data");
-            let workspace_dir = config.workspace_dir.clone();
-
-            log::debug!(
-                "[skills:paths] resolved via Config openhuman_dir={} workspace_dir={} skills_data_dir={}",
-                openhuman_dir.display(),
-                workspace_dir.display(),
-                skills_data_dir.display(),
-            );
-
-            warn_if_legacy_unscoped_data_exists(&skills_data_dir);
-
-            SkillsRuntimePaths {
-                skills_data_dir,
-                workspace_dir,
-            }
-        }
-        Err(err) => {
-            log::warn!(
-                "[skills:paths] Config::load_or_init failed ({err}) — falling back to legacy unscoped layout"
-            );
-            legacy_unscoped_paths()
-        }
-    }
-}
-
-/// Warn (once per bootstrap) if the legacy, unscoped
-/// `~/.openhuman/skills_data` directory still exists while we are now
-/// resolving to a different (user-scoped) location. This tells the user why
-/// their skills appear to have "forgotten" their OAuth credentials after
-/// upgrading and where to find the stale data.
-///
-/// We deliberately **do not** auto-migrate: the legacy dir was shared
-/// across every user of the machine, so silently moving it into whichever
-/// user happened to log in first could leak another user's tokens.
-fn warn_if_legacy_unscoped_data_exists(resolved_skills_data_dir: &std::path::Path) {
-    let Some(home) = dirs::home_dir() else {
-        return;
-    };
-    let legacy = home.join(".openhuman").join("skills_data");
-    if !legacy.exists() {
-        return;
-    }
-    if legacy == resolved_skills_data_dir {
-        // We resolved to the legacy path itself (unauthenticated layout) —
-        // nothing to warn about.
-        return;
-    }
-    log::warn!(
-        "[skills:paths] legacy unscoped skills_data still present at {} but runtime now uses {}. \
-         Skills will start fresh. Manually move the subdirectories you want to preserve \
-         (e.g. per-skill OAuth tokens, webhook_routes.json) into the new path.",
-        legacy.display(),
-        resolved_skills_data_dir.display(),
-    );
-}
-
-/// Legacy fallback — the original resolution that was inlined in both
-/// bootstrap sites. Used only when `Config::load_or_init` fails during
-/// runtime bootstrap.
-fn legacy_unscoped_paths() -> SkillsRuntimePaths {
-    let base_dir = std::env::var("OPENHUMAN_WORKSPACE")
-        .ok()
-        .filter(|s| !s.is_empty())
-        .map(PathBuf::from)
-        .unwrap_or_else(|| {
-            dirs::home_dir()
-                .unwrap_or_else(|| PathBuf::from("."))
-                .join(".openhuman")
-        });
-    SkillsRuntimePaths {
-        skills_data_dir: base_dir.join("skills_data"),
-        workspace_dir: base_dir.join("workspace"),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// RAII guard that restores `OPENHUMAN_WORKSPACE` on drop so tests
-    /// remain panic-safe and don't pollute sibling tests that read the
-    /// same env var.
-    struct EnvGuard {
-        key: &'static str,
-        previous: Option<String>,
-    }
-
-    impl EnvGuard {
-        fn set(key: &'static str, value: &str) -> Self {
-            let previous = std::env::var(key).ok();
-            std::env::set_var(key, value);
-            Self { key, previous }
-        }
-    }
-
-    impl Drop for EnvGuard {
-        fn drop(&mut self) {
-            match self.previous.take() {
-                Some(value) => std::env::set_var(self.key, value),
-                None => std::env::remove_var(self.key),
-            }
-        }
-    }
-
-    #[test]
-    fn legacy_fallback_uses_env_workspace_when_set() {
-        let _guard = EnvGuard::set("OPENHUMAN_WORKSPACE", "/tmp/openhuman-test-paths");
-        let paths = legacy_unscoped_paths();
-        assert_eq!(
-            paths.skills_data_dir,
-            PathBuf::from("/tmp/openhuman-test-paths/skills_data")
-        );
-        assert_eq!(
-            paths.workspace_dir,
-            PathBuf::from("/tmp/openhuman-test-paths/workspace")
-        );
-    }
-}
diff --git a/src/openhuman/skills/ping_scheduler.rs b/src/openhuman/skills/ping_scheduler.rs
deleted file mode 100644
index f79a89cbf..000000000
--- a/src/openhuman/skills/ping_scheduler.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-//! `PingScheduler` — background Tokio task that periodically health-checks running skills.
-//!
-//! Every minute, the scheduler pings all skills with a status of `Running` by
-//! sending an RPC `skill/ping` message. The response is interpreted as follows:
-//! - `null` / `{ ok: true }` → healthy, no action required.
-//! - `{ ok: false, errorType: "auth" }` → stop the skill and set an error status (authentication failure).
-//! - `{ ok: false, errorType: "network" }` → update `connection_status` in the skill's published state to `"error"`, but keep the skill running.
-//!
-//! This ensures that running skills are responsive and can report their internal health state.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Duration;
-
-use parking_lot::RwLock;
-use serde::Deserialize;
-use tokio::sync::watch;
-
-use crate::openhuman::skills::skill_registry::SkillRegistry;
-use crate::openhuman::skills::types::{SkillMessage, SkillStatus};
-
-/// The interval between consecutive health-check sweeps across all skills.
-const PING_INTERVAL: Duration = Duration::from_secs(60);
-
-/// The maximum time allowed for a skill to respond to a ping RPC.
-const PING_TIMEOUT: Duration = Duration::from_secs(30);
-
-/// Structure for parsing the result returned by a skill's native `onPing()` handler.
-#[derive(Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct PingResult {
-    /// Whether the skill reports itself as healthy.
-    ok: bool,
-    /// Categorization of the error if `ok` is false (e.g., "auth", "network").
-    #[serde(default)]
-    error_type: Option<String>,
-    /// A descriptive error message provided by the skill.
-    #[serde(default)]
-    error_message: Option<String>,
-}
-
-/// A scheduler that manages the health-monitoring lifecycle of running skills.
-pub struct PingScheduler {
-    /// A reference to the global skill registry, used to list skills and send ping messages.
-    registry: Arc<RwLock<Option<Arc<SkillRegistry>>>>,
-    /// A channel used to signal the background tick loop to stop.
-    stop_tx: watch::Sender<bool>,
-}
-
-impl PingScheduler {
-    /// Creates a new `PingScheduler` instance.
-    pub fn new() -> Self {
-        let (stop_tx, _) = watch::channel(false);
-        Self {
-            registry: Arc::new(RwLock::new(None)),
-            stop_tx,
-        }
-    }
-
-    /// Sets the skill registry reference for the scheduler.
-    pub fn set_registry(&self, registry: Arc<SkillRegistry>) {
-        *self.registry.write() = Some(registry);
-    }
-
-    /// Starts the background ping monitoring loop as a Tokio task.
-    ///
-    /// The loop performs a sweep of all running skills every `PING_INTERVAL`.
-    /// Returns the handle to the spawned task.
-    pub fn start(&self) -> tokio::task::JoinHandle<()> {
-        let registry = self.registry.clone();
-        let mut stop_rx = self.stop_tx.subscribe();
-
-        tokio::spawn(async move {
-            log::info!(
-                "[ping] Scheduler started ({}s interval)",
-                PING_INTERVAL.as_secs()
-            );
-
-            loop {
-                tokio::select! {
-                    _ = tokio::time::sleep(PING_INTERVAL) => {
-                        let reg = registry.read().clone();
-                        Self::tick(&reg).await;
-                    }
-                    _ = stop_rx.changed() => {
-                        log::info!("[ping] Scheduler stopped");
-                        break;
-                    }
-                }
-            }
-        })
-    }
-
-    /// Signals the background ping monitoring loop to stop.
-    #[allow(dead_code)]
-    pub fn stop(&self) {
-        let _ = self.stop_tx.send(true);
-    }
-
-    /// Performs a single sweep across all running and connected skills.
-    ///
-    /// Skills that are still in setup or not explicitly "connected" are skipped to avoid
-    /// interfering with their initialization.
-    async fn tick(registry: &Option<Arc<SkillRegistry>>) {
-        let registry = match registry {
-            Some(r) => r,
-            None => return,
-        };
-
-        // Collect IDs of skills that are eligible for health checks.
-        let running: Vec<String> = registry
-            .list_skills()
-            .into_iter()
-            .filter(|s| {
-                s.status == SkillStatus::Running
-                    && s.state
-                        .get("connection_status")
-                        .and_then(|v| v.as_str())
-                        .is_some_and(|cs| cs == "connected")
-            })
-            .map(|s| s.skill_id)
-            .collect();
-
-        if running.is_empty() {
-            return;
-        }
-
-        log::debug!("[ping] Pinging {} running skill(s)", running.len());
-
-        // Dispatch pings to all eligible skills concurrently.
-        let futures: Vec<_> = running
-            .into_iter()
-            .map(|skill_id| {
-                let registry = Arc::clone(registry);
-                async move {
-                    Self::ping_skill(&skill_id, &registry).await;
-                }
-            })
-            .collect();
-
-        futures::future::join_all(futures).await;
-    }
-
-    /// Pings a single skill via RPC and processes its response.
-    async fn ping_skill(skill_id: &str, registry: &Arc<SkillRegistry>) {
-        log::debug!("[ping] Pinging skill '{}'", skill_id);
-
-        // Send the `skill/ping` RPC message.
-        let (tx, rx) = tokio::sync::oneshot::channel();
-        if let Err(e) = registry.send_message(
-            skill_id,
-            SkillMessage::Rpc {
-                method: "skill/ping".to_string(),
-                params: serde_json::json!({}),
-                reply: tx,
-            },
-        ) {
-            log::warn!("[ping] Failed to send ping to '{}': {}", skill_id, e);
-            return;
-        }
-
-        // Wait for the skill to reply, with a safety timeout.
-        let reply = match tokio::time::timeout(PING_TIMEOUT, rx).await {
-            Ok(Ok(result)) => result,
-            Ok(Err(_)) => {
-                log::warn!("[ping] Ping channel closed for '{}'", skill_id);
-                return;
-            }
-            Err(_) => {
-                log::warn!("[ping] Ping timed out for '{}'", skill_id);
-                return;
-            }
-        };
-
-        // Parse the RPC result.
-        let value = match reply {
-            Ok(v) => v,
-            Err(e) => {
-                log::warn!("[ping] Ping RPC error for '{}': {}", skill_id, e);
-                return;
-            }
-        };
-
-        // Interpret the result. A null response is considered a successful health check.
-        if value.is_null() {
-            return;
-        }
-
-        let ping_result: PingResult = match serde_json::from_value(value) {
-            Ok(r) => r,
-            Err(e) => {
-                log::debug!(
-                    "[ping] Could not parse ping result for '{}': {} — treating as healthy",
-                    skill_id,
-                    e
-                );
-                return;
-            }
-        };
-
-        if ping_result.ok {
-            return;
-        }
-
-        // ----- Handle ping failure reporting -----
-        let error_type = ping_result.error_type.as_deref().unwrap_or("unknown");
-        let error_message = ping_result
-            .error_message
-            .as_deref()
-            .unwrap_or("Ping failed");
-
-        log::warn!(
-            "[ping] Skill '{}' ping failed: type={}, message={}",
-            skill_id,
-            error_type,
-            error_message
-        );
-
-        match error_type {
-            "auth" => {
-                // Critical authentication failure: stop the skill immediately.
-                log::info!("[ping] Stopping skill '{}' due to auth failure", skill_id);
-
-                if let Err(e) = registry.stop_skill(skill_id).await {
-                    log::error!("[ping] Failed to stop skill '{}': {}", skill_id, e);
-                }
-            }
-            _ => {
-                // Non-critical network or transient error: update the skill's state.
-                let mut patch = HashMap::new();
-                patch.insert("connection_status".to_string(), serde_json::json!("error"));
-                patch.insert(
-                    "connection_error".to_string(),
-                    serde_json::json!(error_message),
-                );
-                if let Err(e) = registry.merge_published_state(skill_id, patch).await {
-                    log::warn!(
-                        "[ping] Could not merge ping failure into published state for '{}': {}",
-                        skill_id,
-                        e
-                    );
-                }
-            }
-        }
-    }
-}
-
-impl Default for PingScheduler {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/src/openhuman/skills/preferences.rs b/src/openhuman/skills/preferences.rs
deleted file mode 100644
index 9fdc71528..000000000
--- a/src/openhuman/skills/preferences.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-//! Persistent skill preferences management.
-//!
-//! This module manages user-defined preferences for skills. The only thing it
-//! tracks today is whether a skill's setup process (e.g. OAuth) has been
-//! completed. Setup completion is the single source of truth for "should this
-//! skill be running": there is no separate `enabled` toggle. Preferences are
-//! persisted to a JSON file on disk so they survive application restarts.
-
-use parking_lot::RwLock;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::path::PathBuf;
-
-/// Represents the user's persistent preferences for a single skill.
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
-pub struct SkillPreference {
-    /// Whether the skill's required setup process (e.g., OAuth) has been completed.
-    /// A skill with `setup_complete = true` is automatically started by the runtime.
-    #[serde(default)]
-    pub setup_complete: bool,
-}
-
-/// A thread-safe store for managing and persisting skill preferences.
-pub struct PreferencesStore {
-    /// The file path where preferences are saved.
-    path: PathBuf,
-    /// An in-memory cache of the preferences, protected by a read-write lock.
-    cache: RwLock<HashMap<String, SkillPreference>>,
-}
-
-impl PreferencesStore {
-    /// Creates a new `PreferencesStore` located in the specified data directory.
-    ///
-    /// Automatically attempts to load existing preferences from `skill-preferences.json`.
-    pub fn new(data_dir: &PathBuf) -> Self {
-        let path = data_dir.join("skill-preferences.json");
-        let store = Self {
-            path,
-            cache: RwLock::new(HashMap::new()),
-        };
-        store.load();
-        store
-    }
-
-    /// Loads preferences from the persistent file on disk into the in-memory cache.
-    ///
-    /// If the file is missing or contains invalid JSON, the cache is initialized as empty.
-    /// Legacy entries that still carry an `enabled` field are silently ignored — only
-    /// `setup_complete` is read.
-    fn load(&self) {
-        if let Ok(content) = std::fs::read_to_string(&self.path) {
-            if let Ok(prefs) = serde_json::from_str::<HashMap<String, SkillPreference>>(&content) {
-                *self.cache.write() = prefs;
-                return;
-            }
-        }
-        *self.cache.write() = HashMap::new();
-    }
-
-    /// Persists the current in-memory preferences cache to the disk as pretty-printed JSON.
-    fn save(&self) {
-        let cache = self.cache.read();
-        if let Ok(json) = serde_json::to_string_pretty(&*cache) {
-            if let Some(parent) = self.path.parent() {
-                let _ = std::fs::create_dir_all(parent);
-            }
-            if let Err(e) = std::fs::write(&self.path, json) {
-                log::error!("[preferences] Failed to save preferences: {e}");
-            }
-        }
-    }
-
-    /// Updates the preference for a skill using the provided closure and persists the change.
-    fn update<F: FnOnce(&mut SkillPreference)>(&self, skill_id: &str, f: F) {
-        let mut cache = self.cache.write();
-        let pref = cache
-            .entry(skill_id.to_string())
-            .or_insert(SkillPreference::default());
-        f(pref);
-        drop(cache); // Explicitly release lock before saving to avoid potential deadlocks
-        self.save();
-    }
-
-    /// Checks if a skill's setup process has been recorded as complete.
-    pub fn is_setup_complete(&self, skill_id: &str) -> bool {
-        self.cache
-            .read()
-            .get(skill_id)
-            .map(|p| p.setup_complete)
-            .unwrap_or(false)
-    }
-
-    /// Marks a skill's setup as complete (or incomplete) and persists the state.
-    pub fn set_setup_complete(&self, skill_id: &str, complete: bool) {
-        self.update(skill_id, |p| {
-            p.setup_complete = complete;
-        });
-        log::info!(
-            "[preferences] setup_complete for '{}' set to {}",
-            skill_id,
-            complete
-        );
-    }
-
-    /// Returns a snapshot of all current skill preferences.
-    pub fn get_all(&self) -> HashMap<String, SkillPreference> {
-        self.cache.read().clone()
-    }
-
-    /// Resolves whether a skill should be started, factoring in user preferences and manifest defaults.
-    ///
-    /// Priority order:
-    /// 1. If `setup_complete` is true, the skill should start.
-    /// 2. Otherwise, fall back to the `auto_start` value from the skill's manifest.
-    pub fn resolve_should_start(&self, skill_id: &str, manifest_auto_start: bool) -> bool {
-        if self.is_setup_complete(skill_id) {
-            return true;
-        }
-        manifest_auto_start
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn temp_store() -> (PreferencesStore, tempfile::TempDir) {
-        let dir = tempfile::tempdir().unwrap();
-        let store = PreferencesStore::new(&dir.path().to_path_buf());
-        (store, dir)
-    }
-
-    #[test]
-    fn setup_complete_roundtrip() {
-        let (store, _dir) = temp_store();
-        assert!(!store.is_setup_complete("s1"));
-        store.set_setup_complete("s1", true);
-        assert!(store.is_setup_complete("s1"));
-        store.set_setup_complete("s1", false);
-        assert!(!store.is_setup_complete("s1"));
-    }
-
-    #[test]
-    fn persistence_across_reload() {
-        let dir = tempfile::tempdir().unwrap();
-        let path = dir.path().to_path_buf();
-        {
-            let store = PreferencesStore::new(&path);
-            store.set_setup_complete("x", true);
-        }
-        // Reload from disk
-        let store2 = PreferencesStore::new(&path);
-        assert!(store2.is_setup_complete("x"));
-    }
-
-    #[test]
-    fn missing_file_returns_defaults() {
-        let dir = tempfile::tempdir().unwrap();
-        let store = PreferencesStore::new(&dir.path().to_path_buf());
-        assert!(!store.is_setup_complete("nonexistent"));
-    }
-
-    #[test]
-    fn corrupt_file_returns_defaults() {
-        let dir = tempfile::tempdir().unwrap();
-        let file = dir.path().join("skill-preferences.json");
-        std::fs::write(&file, "not valid json {{{}").unwrap();
-        let store = PreferencesStore::new(&dir.path().to_path_buf());
-        assert!(!store.is_setup_complete("any"));
-    }
-
-    #[test]
-    fn resolve_should_start_setup_complete_overrides_manifest() {
-        let (store, _dir) = temp_store();
-        store.set_setup_complete("s1", true);
-        // Even if manifest says false, setup_complete wins
-        assert!(store.resolve_should_start("s1", false));
-    }
-
-    #[test]
-    fn resolve_should_start_falls_back_to_manifest() {
-        let (store, _dir) = temp_store();
-        assert!(store.resolve_should_start("unknown", true));
-        assert!(!store.resolve_should_start("unknown", false));
-    }
-
-    #[test]
-    fn get_all_returns_complete_map() {
-        let (store, _dir) = temp_store();
-        store.set_setup_complete("a", true);
-        store.set_setup_complete("b", false);
-        let all = store.get_all();
-        assert_eq!(all.len(), 2);
-        assert!(all["a"].setup_complete);
-        assert!(!all["b"].setup_complete);
-    }
-}
diff --git a/src/openhuman/skills/qjs_engine.rs b/src/openhuman/skills/qjs_engine.rs
deleted file mode 100644
index 7fe28b7df..000000000
--- a/src/openhuman/skills/qjs_engine.rs
+++ /dev/null
@@ -1,1004 +0,0 @@
-//! RuntimeEngine — top-level orchestrator for the QuickJS skill runtime.
-//!
-//! Manages skill lifecycle and provides the public API consumed by RPC handlers.
-//! Uses QuickJS (via rquickjs) for JavaScript execution.
-
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use parking_lot::RwLock;
-
-/// Global RuntimeEngine instance. Uses `RwLock` so it can be swapped in tests.
-static GLOBAL_ENGINE: parking_lot::RwLock<Option<Arc<RuntimeEngine>>> =
-    parking_lot::RwLock::new(None);
-
-/// Store a reference to the RuntimeEngine so RPC handlers can access it.
-/// In production, call this once during app setup. In tests, can be called
-/// multiple times (each call replaces the previous engine).
-pub fn set_global_engine(engine: Arc<RuntimeEngine>) {
-    *GLOBAL_ENGINE.write() = Some(engine);
-}
-
-/// Swap the global engine and return the previous value (for isolated tests / harnesses).
-pub fn replace_global_engine(engine: Option<Arc<RuntimeEngine>>) -> Option<Arc<RuntimeEngine>> {
-    std::mem::replace(&mut *GLOBAL_ENGINE.write(), engine)
-}
-
-/// Get a clone of the global RuntimeEngine Arc.
-/// Returns `None` if the engine has not been initialized yet.
-pub fn global_engine() -> Option<Arc<RuntimeEngine>> {
-    GLOBAL_ENGINE.read().clone()
-}
-
-/// Get the global RuntimeEngine or return an error string.
-pub fn require_engine() -> Result<Arc<RuntimeEngine>, String> {
-    global_engine().ok_or_else(|| "skill runtime not initialized".to_string())
-}
-
-use crate::core::event_bus::{publish_global, DomainEvent};
-use crate::openhuman::memory::MemoryClientRef;
-use crate::openhuman::skills::cron_scheduler::CronScheduler;
-use crate::openhuman::skills::manifest::SkillManifest;
-use crate::openhuman::skills::ping_scheduler::PingScheduler;
-use crate::openhuman::skills::preferences::PreferencesStore;
-use crate::openhuman::skills::qjs_skill_instance::{BridgeDeps, QjsSkillInstance};
-use crate::openhuman::skills::skill_registry::SkillRegistry;
-use crate::openhuman::skills::types::{SkillSnapshot, SkillStatus, ToolCallOrigin, ToolResult};
-use crate::openhuman::webhooks::WebhookRouter;
-
-/// The central runtime engine using QuickJS.
-///
-/// This struct orchestrates the lifecycle of all JavaScript-based skills,
-/// managing their discovery, startup, shutdown, and communication.
-pub struct RuntimeEngine {
-    /// Registry of all skills currently known to the runtime.
-    registry: Arc<SkillRegistry>,
-    /// Global cron scheduler for timed skill triggers.
-    cron_scheduler: Arc<CronScheduler>,
-    /// Background ping scheduler for skill health checks.
-    ping_scheduler: Arc<PingScheduler>,
-    /// Persistent user enable/disable preferences for skills.
-    preferences: Arc<PreferencesStore>,
-    /// Base data directory for skills (platform-aware).
-    skills_data_dir: PathBuf,
-    /// Directory containing skill source files (overridable).
-    skills_source_dir: RwLock<Option<PathBuf>>,
-    /// Resource directory (bundled skills in production).
-    resource_dir: RwLock<Option<PathBuf>>,
-    /// Memory client for skill data persistence.
-    memory_client: RwLock<Option<MemoryClientRef>>,
-    /// Webhook router for tunnel-to-skill routing.
-    webhook_router: Arc<WebhookRouter>,
-    /// Workspace directory for user-installed skills from registry.
-    workspace_dir: RwLock<Option<PathBuf>>,
-}
-
-impl RuntimeEngine {
-    /// Create a new RuntimeEngine with the specified data directory.
-    ///
-    /// This initializes all core components including the registry, schedulers,
-    /// and preference store.
-    pub fn new(skills_data_dir: PathBuf) -> Result<Self, String> {
-        let registry = Arc::new(SkillRegistry::new());
-        let cron_scheduler = Arc::new(CronScheduler::new());
-        cron_scheduler.set_registry(Arc::clone(&registry));
-        let ping_scheduler = Arc::new(PingScheduler::new());
-        ping_scheduler.set_registry(Arc::clone(&registry));
-        let preferences = Arc::new(PreferencesStore::new(&skills_data_dir));
-
-        // Use the process-global memory client singleton so the ingestion
-        // queue worker outlives individual skill instances.
-        let memory_client = match crate::openhuman::memory::global::init_default() {
-            Ok(client) => {
-                log::info!("[runtime] Using global MemoryClient for skills");
-                Some(client)
-            }
-            Err(e) => {
-                log::warn!("[runtime] Global MemoryClient not available: {e}");
-                None
-            }
-        };
-
-        // Initialize webhook router with persistence
-        let webhook_routes_path = skills_data_dir.join("webhook_routes.json");
-        let webhook_router = Arc::new(WebhookRouter::new(Some(webhook_routes_path)));
-
-        log::info!("[runtime] QuickJS RuntimeEngine created");
-
-        Ok(Self {
-            registry,
-            cron_scheduler,
-            ping_scheduler,
-            preferences,
-            skills_data_dir,
-            skills_source_dir: RwLock::new(None),
-            resource_dir: RwLock::new(None),
-            memory_client: RwLock::new(memory_client),
-            webhook_router,
-            workspace_dir: RwLock::new(None),
-        })
-    }
-
-    /// Get a clone of the skill registry Arc.
-    pub fn registry(&self) -> Arc<SkillRegistry> {
-        Arc::clone(&self.registry)
-    }
-
-    /// Get a clone of the cron scheduler Arc.
-    pub fn cron_scheduler(&self) -> Arc<CronScheduler> {
-        Arc::clone(&self.cron_scheduler)
-    }
-
-    /// Get a clone of the ping scheduler Arc.
-    pub fn ping_scheduler(&self) -> Arc<PingScheduler> {
-        Arc::clone(&self.ping_scheduler)
-    }
-
-    /// Set the memory client for skill data persistence.
-    pub fn set_memory_client(&self, client: MemoryClientRef) {
-        *self.memory_client.write() = Some(client);
-    }
-
-    /// Set the directory containing skill source files.
-    #[allow(dead_code)]
-    pub fn set_skills_source_dir(&self, dir: PathBuf) {
-        *self.skills_source_dir.write() = Some(dir);
-    }
-
-    /// Set the Tauri resource directory (for bundled skills in production).
-    pub fn set_resource_dir(&self, dir: PathBuf) {
-        log::info!("[runtime] Resource directory set to: {:?}", dir);
-        *self.resource_dir.write() = Some(dir);
-    }
-
-    /// Get a clone of the webhook router Arc.
-    pub fn webhook_router(&self) -> Arc<WebhookRouter> {
-        Arc::clone(&self.webhook_router)
-    }
-
-    /// Set the workspace directory for user-installed skills from the registry.
-    pub fn set_workspace_dir(&self, dir: PathBuf) {
-        log::info!("[runtime] Workspace directory set to: {:?}", dir);
-        *self.workspace_dir.write() = Some(dir);
-    }
-
-    /// Resolve the directory where skills should be loaded from.
-    ///
-    /// The resolution follows this priority:
-    /// 1. `SKILLS_LOCAL_DIR` environment variable (for development)
-    /// 2. Programmatically set source directory
-    /// 3. Standard development paths (`openhuman-skills/skills` in CWD or parent)
-    /// 4. Bundled resource directory (production)
-    /// 5. App data directory (fallback)
-    fn get_skills_source_dir(&self) -> Result<PathBuf, String> {
-        // 0. SKILLS_LOCAL_DIR env var (highest priority — explicit local dev override)
-        if let Ok(local_dir) = std::env::var("SKILLS_LOCAL_DIR") {
-            let local_path = PathBuf::from(&local_dir);
-            if local_path.exists() {
-                log::info!("[runtime] Using SKILLS_LOCAL_DIR: {:?}", local_path);
-                return Ok(local_path);
-            }
-            log::warn!(
-                "[runtime] SKILLS_LOCAL_DIR set to {:?} but directory does not exist",
-                local_path
-            );
-        }
-
-        // 1. Explicitly set source dir (programmatic override)
-        if let Some(dir) = self.skills_source_dir.read().as_ref() {
-            log::info!("[runtime] Using explicit skills source dir: {:?}", dir);
-            return Ok(dir.clone());
-        }
-
-        let current =
-            std::env::current_dir().map_err(|e| format!("Failed to get current dir: {e}"))?;
-
-        // 2. Dev: cwd/openhuman-skills/skills
-        let dev_skills = current.join("openhuman-skills").join("skills");
-        if dev_skills.exists() {
-            log::info!("[runtime] Using dev skills dir: {:?}", dev_skills);
-            return Ok(dev_skills);
-        }
-
-        // 3. Dev: ../openhuman-skills/skills
-        if let Some(parent) = current.parent() {
-            let parent_skills = parent.join("openhuman-skills").join("skills");
-            if parent_skills.exists() {
-                log::info!("[runtime] Using parent dev skills dir: {:?}", parent_skills);
-                return Ok(parent_skills);
-            }
-        }
-
-        // 4. Production: bundled resources
-        if let Some(resource_dir) = self.resource_dir.read().as_ref() {
-            let bundled_skills = resource_dir
-                .join("_up_")
-                .join("openhuman-skills")
-                .join("skills");
-            if bundled_skills.exists() {
-                log::info!(
-                    "[runtime] Using bundled skills from resources: {:?}",
-                    bundled_skills
-                );
-                return Ok(bundled_skills);
-            }
-
-            let bundled_skills_alt = resource_dir.join("skills");
-            if bundled_skills_alt.exists() {
-                log::info!(
-                    "[runtime] Using bundled skills from resources (alt): {:?}",
-                    bundled_skills_alt
-                );
-                return Ok(bundled_skills_alt);
-            }
-
-            log::warn!(
-                "[runtime] Resource dir set but skills not found. Checked: {:?} and {:?}",
-                bundled_skills,
-                bundled_skills_alt
-            );
-        }
-
-        // 5. Final fallback: app data dir
-        let prod_dir = self.skills_data_dir.clone();
-        log::info!(
-            "[runtime] Skills source dir (data dir fallback): {:?}",
-            prod_dir
-        );
-        Ok(prod_dir)
-    }
-
-    /// Expose the resolved skills source directory (for external callers like unified registry).
-    pub fn skills_source_dir(&self) -> Result<PathBuf, String> {
-        self.get_skills_source_dir()
-    }
-
-    /// Discover all JavaScript skills from the skills source directory and workspace.
-    ///
-    /// Returns a list of `SkillManifest` for all valid skills found.
-    pub async fn discover_skills(&self) -> Result<Vec<SkillManifest>, String> {
-        let mut manifests = Vec::new();
-        let mut seen_ids = std::collections::HashSet::new();
-
-        // 1. Scan bundled/dev skills source directory
-        let skills_dir = self.get_skills_source_dir()?;
-        if skills_dir.exists() {
-            self.scan_skills_dir(&skills_dir, &mut manifests, &mut seen_ids)
-                .await?;
-        }
-
-        // 2. Scan workspace skills directory (user-installed from registry)
-        let workspace_dir_opt = self.workspace_dir.read().clone();
-        if let Some(workspace_dir) = workspace_dir_opt {
-            let workspace_skills = workspace_dir.join("skills");
-            if workspace_skills.exists() {
-                log::info!(
-                    "[runtime] Also scanning workspace skills dir: {:?}",
-                    workspace_skills
-                );
-                self.scan_skills_dir(&workspace_skills, &mut manifests, &mut seen_ids)
-                    .await?;
-            }
-        }
-
-        Ok(manifests)
-    }
-
-    /// Scan a single directory for skill manifests, skipping already-seen IDs.
-    async fn scan_skills_dir(
-        &self,
-        dir: &std::path::Path,
-        manifests: &mut Vec<SkillManifest>,
-        seen_ids: &mut std::collections::HashSet<String>,
-    ) -> Result<(), String> {
-        let mut entries = tokio::fs::read_dir(dir)
-            .await
-            .map_err(|e| format!("Failed to read skills dir {:?}: {e}", dir))?;
-
-        while let Ok(Some(entry)) = entries.next_entry().await {
-            let path = entry.path();
-            if path.is_dir() {
-                let manifest_path = path.join("manifest.json");
-                if manifest_path.exists() {
-                    match SkillManifest::from_path(&manifest_path).await {
-                        Ok(manifest)
-                            if manifest.is_javascript() && manifest.supports_current_platform() =>
-                        {
-                            if seen_ids.contains(&manifest.id) {
-                                log::debug!(
-                                    "[runtime] Skipping duplicate skill '{}' from {:?}",
-                                    manifest.id,
-                                    dir
-                                );
-                                continue;
-                            }
-                            log::info!(
-                                "[runtime] Discovered skill '{}': {}",
-                                manifest.id,
-                                manifest.name
-                            );
-                            seen_ids.insert(manifest.id.clone());
-                            manifests.push(manifest);
-                        }
-                        Ok(manifest) if manifest.is_javascript() => {
-                            log::info!(
-                                "[runtime] Skipping skill '{}': not supported on this platform",
-                                manifest.id
-                            );
-                        }
-                        Ok(_) => {
-                            log::info!(
-                                "[runtime] Skipping skill '{}': not a JavaScript skill",
-                                manifest_path.display()
-                            );
-                        }
-                        Err(e) => {
-                            log::warn!("Failed to parse manifest at {:?}: {e}", manifest_path);
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Start a specific skill by its ID.
-    ///
-    /// This resolves the skill directory, creates a `QjsSkillInstance`,
-    /// spawns its execution task, and registers it in the registry.
-    /// It then waits for the skill to reach the `Running` state or fail.
-    pub async fn start_skill(&self, skill_id: &str) -> Result<SkillSnapshot, String> {
-        // Check if already running
-        if self.registry.has_skill(skill_id) {
-            if let Some(snap) = self.registry.get_skill(skill_id) {
-                if snap.status == SkillStatus::Running || snap.status == SkillStatus::Initializing {
-                    return Ok(snap);
-                }
-                self.registry.unregister(skill_id);
-            }
-        }
-
-        // Look in bundled/dev source dir first, then workspace
-        let skills_dir = self.get_skills_source_dir()?;
-        let mut skill_dir = skills_dir.join(skill_id);
-        let mut manifest_path = skill_dir.join("manifest.json");
-        log::debug!(
-            "[runtime] start_skill '{}': manifest_path={:?}, exists={}",
-            skill_id,
-            manifest_path,
-            manifest_path.exists()
-        );
-
-        if !manifest_path.exists() {
-            // Try workspace skills directory
-            if let Some(workspace_dir) = self.workspace_dir.read().as_ref() {
-                let ws_skill_dir = workspace_dir.join("skills").join(skill_id);
-                let ws_manifest = ws_skill_dir.join("manifest.json");
-                log::debug!(
-                    "[runtime] start_skill '{}': workspace check {:?}, exists={}",
-                    skill_id,
-                    ws_manifest,
-                    ws_manifest.exists()
-                );
-                if ws_manifest.exists() {
-                    log::info!("[runtime] Found skill '{}' in workspace dir", skill_id);
-                    skill_dir = ws_skill_dir;
-                    manifest_path = ws_manifest;
-                }
-            } else {
-                log::warn!(
-                    "[runtime] start_skill '{}': workspace_dir is not set",
-                    skill_id
-                );
-            }
-        }
-
-        if !manifest_path.exists() {
-            return Err(format!("Skill '{}' not found (no manifest.json)", skill_id));
-        }
-
-        let manifest = SkillManifest::from_path(&manifest_path).await?;
-        if !manifest.is_javascript() {
-            return Err(format!(
-                "Skill '{}' uses runtime '{}', not a supported JavaScript runtime",
-                skill_id, manifest.runtime
-            ));
-        }
-
-        let runtime_name = manifest.runtime.clone();
-        let config = manifest.to_config();
-        let data_dir = self.skills_data_dir.join(skill_id);
-
-        // Create the QuickJS skill instance
-        log::info!(
-            "[runtime] Creating QuickJS skill instance for '{}'",
-            skill_id
-        );
-        log::info!("[runtime] Config: {:?}", config);
-        log::info!("[runtime] Skill dir: {:?}", skill_dir);
-        log::info!("[runtime] Data dir: {:?}", data_dir);
-        let (instance, rx) = QjsSkillInstance::new(config.clone(), skill_dir, data_dir.clone());
-        log::info!(
-            "[runtime] QuickJS skill instance created for '{}'",
-            skill_id
-        );
-
-        // Bundle bridge dependencies (no creation lock needed for QuickJS)
-        let deps = BridgeDeps {
-            cron_scheduler: self.cron_scheduler.clone(),
-            skill_registry: self.registry.clone(),
-            memory_client: self.memory_client.read().clone(),
-            webhook_router: Some(self.webhook_router.clone()),
-            data_dir: data_dir.clone(),
-        };
-
-        // Spawn the skill's execution loop in a background task
-        let task_handle = instance.spawn(rx, deps);
-
-        // Register in the registry so other components can find it
-        self.registry.register(
-            skill_id,
-            config,
-            instance.sender.clone(),
-            instance.state.clone(),
-            task_handle,
-        );
-
-        self.emit_status_change(skill_id);
-
-        // Wait for initialization to complete by polling the skill state
-        let state = instance.state.clone();
-        let skill_id_owned = skill_id.to_string();
-        let max_wait = std::time::Duration::from_secs(10);
-        let poll_interval = std::time::Duration::from_millis(50);
-        let start = std::time::Instant::now();
-
-        loop {
-            let current_status = state.read().status;
-
-            match current_status {
-                SkillStatus::Running => {
-                    self.emit_status_change(&skill_id_owned);
-                    publish_global(DomainEvent::SkillLoaded {
-                        skill_id: skill_id_owned.clone(),
-                        runtime: runtime_name.clone(),
-                    });
-                    return Ok(instance.snapshot());
-                }
-                SkillStatus::Error => {
-                    let error_msg = state
-                        .read()
-                        .error
-                        .clone()
-                        .unwrap_or_else(|| "Unknown initialization error".to_string());
-                    // Don't unregister — keep the skill with Error status so the
-                    // UI can see what happened and allow restart.
-                    self.emit_status_change(&skill_id_owned);
-                    publish_global(DomainEvent::SkillStartFailed {
-                        skill_id: skill_id_owned.clone(),
-                        error: error_msg.clone(),
-                    });
-                    return Err(format!(
-                        "Skill '{}' failed to start: {}",
-                        skill_id_owned, error_msg
-                    ));
-                }
-                SkillStatus::Stopped => {
-                    // Don't unregister — keep the skill with Stopped status so the
-                    // UI can still query it and allow restart.
-                    self.emit_status_change(&skill_id_owned);
-                    return Err(format!(
-                        "Skill '{}' stopped unexpectedly during initialization",
-                        skill_id_owned
-                    ));
-                }
-                SkillStatus::Initializing | SkillStatus::Pending => {
-                    if start.elapsed() > max_wait {
-                        log::warn!(
-                            "[runtime] Skill '{}' initialization timeout, returning current state",
-                            skill_id_owned
-                        );
-                        return Ok(instance.snapshot());
-                    }
-                    tokio::time::sleep(poll_interval).await;
-                }
-                SkillStatus::Stopping => {
-                    return Err(format!(
-                        "Skill '{}' is in unexpected Stopping state during startup",
-                        skill_id_owned
-                    ));
-                }
-            }
-        }
-    }
-
-    /// Stop a running skill.
-    ///
-    /// This sends a stop signal to the skill, unregisters it from schedulers
-    /// and the webhook router, and updates its status.
-    pub async fn stop_skill(&self, skill_id: &str) -> Result<(), String> {
-        self.registry.stop_skill(skill_id).await?;
-        self.emit_status_change(skill_id);
-        publish_global(DomainEvent::SkillStopped {
-            skill_id: skill_id.to_string(),
-        });
-        Ok(())
-    }
-
-    /// List all registered skills, enriched with persistent preferences.
-    pub fn list_skills(&self) -> Vec<SkillSnapshot> {
-        let mut snapshots = self.registry.list_skills();
-        for snap in &mut snapshots {
-            self.enrich_snapshot(snap);
-        }
-        snapshots
-    }
-
-    /// Get the state of a specific skill, enriched with persistent preferences.
-    pub fn get_skill_state(&self, skill_id: &str) -> Option<SkillSnapshot> {
-        self.registry.get_skill(skill_id).map(|mut snap| {
-            self.enrich_snapshot(&mut snap);
-            snap
-        })
-    }
-
-    /// Populate `setup_complete` from preferences and re-derive `connection_status`.
-    fn enrich_snapshot(&self, snap: &mut SkillSnapshot) {
-        snap.setup_complete = self.preferences.is_setup_complete(&snap.skill_id);
-        snap.connection_status = crate::openhuman::skills::types::derive_connection_status(
-            snap.status,
-            snap.setup_complete,
-            &snap.state,
-        );
-    }
-
-    /// Get the preferences store (for RPC handlers that need to set setup_complete).
-    pub fn preferences(&self) -> &PreferencesStore {
-        &self.preferences
-    }
-
-    /// Call a tool on a skill by its name and arguments.
-    pub async fn call_tool(
-        &self,
-        skill_id: &str,
-        tool_name: &str,
-        arguments: serde_json::Value,
-    ) -> Result<ToolResult, String> {
-        let started_at = std::time::Instant::now();
-        let result = self
-            .registry
-            .call_tool(skill_id, tool_name, arguments.clone())
-            .await;
-        let result_text = match &result {
-            Ok(r) => Some(r.output()),
-            Err(e) => Some(e.clone()),
-        };
-        publish_global(DomainEvent::SkillExecuted {
-            skill_id: skill_id.to_string(),
-            tool_name: tool_name.to_string(),
-            arguments,
-            result: result_text,
-            success: result.is_ok(),
-            elapsed_ms: started_at.elapsed().as_millis() as u64,
-        });
-        result
-    }
-
-    /// Call a tool from inside a running skill. Enforces self-only invocation.
-    ///
-    /// This is used when a skill wants to call its own tools or when inter-skill
-    /// communication is permitted.
-    pub async fn call_tool_as_skill(
-        &self,
-        caller_skill_id: &str,
-        target_skill_id: &str,
-        tool_name: &str,
-        arguments: serde_json::Value,
-    ) -> Result<ToolResult, String> {
-        let started_at = std::time::Instant::now();
-        let result = self
-            .registry
-            .call_tool_scoped(
-                ToolCallOrigin::SkillSelf {
-                    skill_id: caller_skill_id.to_string(),
-                },
-                target_skill_id,
-                tool_name,
-                arguments.clone(),
-            )
-            .await;
-        let result_text = match &result {
-            Ok(r) => Some(r.output()),
-            Err(e) => Some(e.clone()),
-        };
-        publish_global(DomainEvent::SkillExecuted {
-            skill_id: target_skill_id.to_string(),
-            tool_name: tool_name.to_string(),
-            arguments,
-            result: result_text,
-            success: result.is_ok(),
-            elapsed_ms: started_at.elapsed().as_millis() as u64,
-        });
-        result
-    }
-
-    /// Broadcast a server event to all running skills.
-    pub async fn broadcast_event(&self, event: &str, data: serde_json::Value) {
-        self.registry.broadcast_event(event, data).await;
-    }
-
-    /// Get all tool definitions across all running skills.
-    pub fn all_tools(&self) -> Vec<(String, crate::openhuman::skills::types::ToolDefinition)> {
-        self.registry.all_tools()
-    }
-
-    /// Log a skill status change (event emission is handled by the Socket manager).
-    fn emit_status_change(&self, skill_id: &str) {
-        if let Some(snap) = self.registry.get_skill(skill_id) {
-            log::debug!(
-                "[runtime] Skill status changed: {} → {:?}",
-                skill_id,
-                snap.status
-            );
-        }
-    }
-
-    /// Auto-start skills based on user preferences and manifest defaults.
-    ///
-    /// No stagger delay is needed for QuickJS as instances are lightweight.
-    pub async fn auto_start_skills(&self) {
-        match self.discover_skills().await {
-            Ok(manifests) => {
-                for manifest in manifests {
-                    let should_start = self
-                        .preferences
-                        .resolve_should_start(&manifest.id, manifest.auto_start);
-                    if should_start {
-                        log::info!(
-                            "[runtime] Auto-starting skill: {} ({})",
-                            manifest.name,
-                            manifest.id
-                        );
-                        if let Err(e) = self.start_skill(&manifest.id).await {
-                            log::error!(
-                                "[runtime] Failed to auto-start skill '{}': {e}",
-                                manifest.id
-                            );
-                        }
-                    }
-                }
-            }
-            Err(e) => {
-                log::warn!("[runtime] Failed to discover skills for auto-start: {e}");
-            }
-        }
-    }
-
-    /// Get all stored skill preferences.
-    pub fn get_preferences(
-        &self,
-    ) -> std::collections::HashMap<String, crate::openhuman::skills::preferences::SkillPreference>
-    {
-        self.preferences.get_all()
-    }
-
-    /// Read a KV value from a skill's database.
-    ///
-    /// NOTE: This was removed during runtime cleanup and currently returns an error.
-    pub fn kv_get(&self, _skill_id: &str, _key: &str) -> Result<serde_json::Value, String> {
-        Err("KV storage removed during runtime cleanup".to_string())
-    }
-
-    /// Write a KV value into a skill's database.
-    ///
-    /// NOTE: This was removed during runtime cleanup and currently returns an error.
-    pub fn kv_set(
-        &self,
-        _skill_id: &str,
-        _key: &str,
-        _value: &serde_json::Value,
-    ) -> Result<(), String> {
-        Err("KV storage removed during runtime cleanup".to_string())
-    }
-
-    /// Route a JSON-RPC method call to a specific skill.
-    ///
-    /// This handles built-in skill methods (setup, tools, session) and
-    /// routes others to the skill's custom RPC handler.
-    pub async fn rpc(
-        &self,
-        skill_id: &str,
-        method: &str,
-        params: serde_json::Value,
-    ) -> Result<serde_json::Value, String> {
-        use crate::openhuman::skills::types::SkillMessage;
-
-        match method {
-            "skill/load" => {
-                // Extract load params (exclude manifest and dataDir) and send to skill
-                let load_params: serde_json::Map<String, serde_json::Value> = params
-                    .as_object()
-                    .map(|obj| {
-                        obj.iter()
-                            .filter(|(k, _)| k.as_str() != "manifest" && k.as_str() != "dataDir")
-                            .map(|(k, v)| (k.clone(), v.clone()))
-                            .collect()
-                    })
-                    .unwrap_or_default();
-                if !load_params.is_empty() {
-                    let msg = SkillMessage::LoadParams {
-                        params: serde_json::Value::Object(load_params),
-                    };
-                    if let Err(e) = self.registry.send_message(skill_id, msg) {
-                        log::warn!(
-                            "[runtime] Failed to send LoadParams to skill '{}': {}",
-                            skill_id,
-                            e
-                        );
-                    }
-                }
-                Ok(serde_json::json!({ "ok": true }))
-            }
-
-            "setup/start" => {
-                log::info!("[runtime] setup/start for '{}'", skill_id);
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry
-                    .send_message(skill_id, SkillMessage::SetupStart { reply: tx })?;
-                rx.await
-                    .map_err(|_| "SetupStart channel closed".to_string())?
-            }
-
-            "setup/submit" => {
-                let step_id = params
-                    .get("stepId")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string();
-                let values = params
-                    .get("values")
-                    .cloned()
-                    .unwrap_or(serde_json::json!({}));
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry.send_message(
-                    skill_id,
-                    SkillMessage::SetupSubmit {
-                        step_id,
-                        values,
-                        reply: tx,
-                    },
-                )?;
-                rx.await
-                    .map_err(|_| "SetupSubmit channel closed".to_string())?
-            }
-
-            "setup/cancel" => {
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry
-                    .send_message(skill_id, SkillMessage::SetupCancel { reply: tx })?;
-                rx.await
-                    .map_err(|_| "SetupCancel channel closed".to_string())?
-                    .map(|()| serde_json::json!({ "ok": true }))
-            }
-
-            "tools/list" => {
-                let snap = self.registry.get_skill(skill_id);
-                let tools = snap
-                    .map(|s| {
-                        s.tools
-                            .iter()
-                            .map(|t| serde_json::to_value(t).unwrap_or_default())
-                            .collect::<Vec<_>>()
-                    })
-                    .unwrap_or_default();
-                Ok(serde_json::json!({ "tools": tools }))
-            }
-
-            "tools/call" => {
-                let tool_name = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
-                let arguments = params
-                    .get("arguments")
-                    .cloned()
-                    .unwrap_or(serde_json::json!({}));
-                let result = self.call_tool(skill_id, tool_name, arguments).await?;
-                serde_json::to_value(&result)
-                    .map_err(|e| format!("Failed to serialize tool result: {e}"))
-            }
-
-            "options/list" => {
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry
-                    .send_message(skill_id, SkillMessage::ListOptions { reply: tx })?;
-                rx.await
-                    .map_err(|_| "ListOptions channel closed".to_string())?
-            }
-
-            "options/set" => {
-                let name = params
-                    .get("name")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string();
-                let value = params
-                    .get("value")
-                    .cloned()
-                    .unwrap_or(serde_json::Value::Null);
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry.send_message(
-                    skill_id,
-                    SkillMessage::SetOption {
-                        name,
-                        value,
-                        reply: tx,
-                    },
-                )?;
-                rx.await
-                    .map_err(|_| "SetOption channel closed".to_string())?
-                    .map(|()| serde_json::json!({ "ok": true }))
-            }
-
-            "skill/tick" => {
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry
-                    .send_message(skill_id, SkillMessage::Tick { reply: tx })?;
-                rx.await
-                    .map_err(|_| "Tick channel closed".to_string())?
-                    .map(|()| serde_json::json!({ "ok": true }))
-            }
-
-            "skill/sessionStart" => {
-                let session_id = params
-                    .get("sessionId")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string();
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry.send_message(
-                    skill_id,
-                    SkillMessage::SessionStart {
-                        session_id,
-                        reply: tx,
-                    },
-                )?;
-                rx.await
-                    .map_err(|_| "SessionStart channel closed".to_string())?
-                    .map(|()| serde_json::json!({ "ok": true }))
-            }
-
-            "skill/sessionEnd" => {
-                let session_id = params
-                    .get("sessionId")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string();
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry.send_message(
-                    skill_id,
-                    SkillMessage::SessionEnd {
-                        session_id,
-                        reply: tx,
-                    },
-                )?;
-                rx.await
-                    .map_err(|_| "SessionEnd channel closed".to_string())?
-                    .map(|()| serde_json::json!({ "ok": true }))
-            }
-
-            "skill/shutdown" => {
-                self.stop_skill(skill_id).await?;
-                Ok(serde_json::json!({ "ok": true }))
-            }
-
-            _ => {
-                let (tx, rx) = tokio::sync::oneshot::channel();
-                self.registry.send_message(
-                    skill_id,
-                    SkillMessage::Rpc {
-                        method: method.to_string(),
-                        params,
-                        reply: tx,
-                    },
-                )?;
-                rx.await.map_err(|_| "Rpc channel closed".to_string())?
-            }
-        }
-    }
-
-    /// Read a file from a skill's data directory.
-    pub fn data_read(&self, skill_id: &str, filename: &str) -> Result<String, String> {
-        let data_dir = self.skills_data_dir.join(skill_id);
-        let path = data_dir.join(filename);
-        std::fs::read_to_string(&path)
-            .map_err(|e| format!("Failed to read data file '{}': {e}", filename))
-    }
-
-    /// Write a file to a skill's data directory.
-    pub fn data_write(&self, skill_id: &str, filename: &str, content: &str) -> Result<(), String> {
-        let data_dir = self.skills_data_dir.join(skill_id);
-        let path = data_dir.join(filename);
-        if let Some(parent) = path.parent() {
-            std::fs::create_dir_all(parent)
-                .map_err(|e| format!("Failed to create data dir: {e}"))?;
-        }
-        std::fs::write(&path, content)
-            .map_err(|e| format!("Failed to write data file '{}': {e}", filename))
-    }
-
-    /// Get the data directory path for a specific skill.
-    pub fn skill_data_dir(&self, skill_id: &str) -> PathBuf {
-        self.skills_data_dir.join(skill_id)
-    }
-
-    /// Calculate total file count and byte size under the skill's data directory (recursive).
-    pub fn skill_data_directory_stats(&self, skill_id: &str) -> SkillDataDirectoryStats {
-        let path = self.skill_data_dir(skill_id);
-        let exists = path.exists();
-        let (total_bytes, file_count) = match directory_byte_and_file_count(&path) {
-            Ok(v) => v,
-            Err(err) => {
-                log::warn!(
-                    "skill data directory stats failed for '{}': {} — {}",
-                    skill_id,
-                    path.display(),
-                    err
-                );
-                (0, 0)
-            }
-        };
-        SkillDataDirectoryStats {
-            exists,
-            path: path.display().to_string(),
-            total_bytes,
-            file_count,
-        }
-    }
-}
-
-/// Disk usage statistics for a skill's persisted data folder.
-///
-/// This is exposed to the UI for display in sync summaries.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SkillDataDirectoryStats {
-    /// Whether the directory exists on disk.
-    pub exists: bool,
-    /// Absolute path to the data directory.
-    pub path: String,
-    /// Total size in bytes of all files in the directory.
-    pub total_bytes: u64,
-    /// Total number of files in the directory.
-    pub file_count: u64,
-}
-
-/// Recursively calculate the total byte size and file count of a directory.
-fn directory_byte_and_file_count(path: &std::path::Path) -> std::io::Result<(u64, u64)> {
-    use std::fs;
-    if !path.exists() {
-        return Ok((0, 0));
-    }
-    let mut total_bytes = 0u64;
-    let mut file_count = 0u64;
-
-    /// Internal recursive function to walk the directory tree.
-    fn walk(
-        path: &std::path::Path,
-        total_bytes: &mut u64,
-        file_count: &mut u64,
-    ) -> std::io::Result<()> {
-        let read = fs::read_dir(path)?;
-        for entry in read {
-            let entry = entry?;
-            let meta = entry.metadata()?;
-            let p = entry.path();
-            if meta.is_dir() {
-                walk(&p, total_bytes, file_count)?;
-            } else if meta.is_file() {
-                *total_bytes += meta.len();
-                *file_count += 1;
-            }
-        }
-        Ok(())
-    }
-    walk(path, &mut total_bytes, &mut file_count)?;
-    Ok((total_bytes, file_count))
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/event_loop/mod.rs b/src/openhuman/skills/qjs_skill_instance/event_loop/mod.rs
deleted file mode 100644
index ef235d1c2..000000000
--- a/src/openhuman/skills/qjs_skill_instance/event_loop/mod.rs
+++ /dev/null
@@ -1,950 +0,0 @@
-//! Main event loop and message routing for QuickJS skill instances.
-//!
-//! This module implements the central execution loop that drives a skill's
-//! JavaScript environment. It handles timer callbacks, routes incoming system
-//! messages (RPCs, tool calls, events), manages asynchronous tool execution,
-//! and persists skill state to the OpenHuman memory system.
-
-mod rpc_handlers;
-mod webhook_handler;
-
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Duration;
-
-use parking_lot::RwLock;
-use tokio::sync::mpsc;
-
-use crate::openhuman::{
-    memory::{
-        MemoryClientRef, MemoryIngestionConfig, MemoryIngestionRequest, NamespaceDocumentInput,
-    },
-    skills::{
-        quickjs_libs::qjs_ops,
-        types::{SkillMessage, SkillStatus, ToolResult},
-        working_memory::{skills_working_memory_enabled, working_memory_documents_from_sync},
-    },
-    tool_timeout::{tool_execution_timeout_duration, tool_execution_timeout_secs},
-};
-
-use super::js_handlers::{
-    call_lifecycle, handle_cron_trigger, handle_js_call, handle_js_void_call, handle_server_event,
-    read_pending_tool_result, start_async_tool_call,
-};
-use super::js_helpers::{
-    drive_jobs, restore_auth_credential, restore_client_key, restore_oauth_credential,
-};
-use super::types::SkillState;
-
-/// Payload queued for the background memory-write worker.
-pub(crate) struct MemoryWriteJob {
-    /// Reference to the memory client for storage and ingestion.
-    client: MemoryClientRef,
-    /// ID of the skill that produced the data.
-    skill: String,
-    /// Title for the persisted document.
-    title: String,
-    /// Stringified JSON content of the skill's published state.
-    content: String,
-    /// Whether to derive and persist user working-memory documents from this
-    /// payload. Set `true` only for explicit `skill/sync` enqueues; leave
-    /// `false` for Tick and CronTrigger enqueues so that `working.user.*`
-    /// documents are only produced from intentional sync payloads.
-    extract_working_memory: bool,
-}
-
-/// Maximum number of memory-write jobs that can be buffered before back-pressure
-/// causes `persist_state_to_memory` to drop new writes.
-const MEMORY_WRITE_CHANNEL_CAPACITY: usize = 16;
-
-/// Spawn a bounded background worker that consumes `MemoryWriteJob` items.
-///
-/// This worker performs two main tasks for each job:
-/// 1. Stores the raw state snapshot in the memory store using `store_skill_sync`.
-/// 2. Ingests the content into the memory graph (vector store) using `ingest_doc`.
-///
-/// Specialized logic exists for certain skills (like Notion) to ingest content
-/// at a more granular level (e.g., per-page).
-fn spawn_memory_write_worker() -> mpsc::Sender<MemoryWriteJob> {
-    let (tx, mut rx) = mpsc::channel::<MemoryWriteJob>(MEMORY_WRITE_CHANNEL_CAPACITY);
-    tokio::spawn(async move {
-        while let Some(job) = rx.recv().await {
-            log::debug!(
-                "[memory] store_skill_sync: skill={}, title={}, content_len={}",
-                job.skill,
-                job.title,
-                job.content.len(),
-            );
-
-            // Persist the full state blob to the skill's sync history
-            if let Err(e) = job
-                .client
-                .store_skill_sync(
-                    &job.skill,
-                    "default",
-                    &job.title,
-                    &job.content,
-                    None,
-                    None,
-                    None,
-                    None,
-                    None,
-                    None,
-                )
-                .await
-            {
-                log::warn!("[memory] store_skill_sync failed for '{}': {e}", job.title);
-                continue;
-            }
-            log::debug!("[memory] store_skill_sync succeeded for '{}'", job.title);
-
-            if job.extract_working_memory {
-                if skills_working_memory_enabled() {
-                    let working_memory =
-                        working_memory_documents_from_sync(&job.skill, &job.content);
-                    let mut working_persisted = 0usize;
-                    let mut working_failed = 0usize;
-                    for doc in working_memory.documents {
-                        let key = doc.key.clone();
-                        match job.client.put_doc(doc).await {
-                            Ok(_) => {
-                                working_persisted += 1;
-                            }
-                            Err(e) => {
-                                working_failed += 1;
-                                log::warn!(
-                                    "[skills-working-memory] put_doc failed for skill='{}' key='{}': {}",
-                                    job.skill,
-                                    key,
-                                    e
-                                );
-                            }
-                        }
-                    }
-                    log::info!(
-                        "[skills-working-memory] sync_batch skill='{}' title='{}' scalar_fields={} \
-                         skipped_sensitive={} prefs={} goals={} constraints={} entities={} \
-                         generated_docs={} persisted_docs={} failed_docs={}",
-                        job.skill,
-                        job.title,
-                        working_memory.stats.scalar_fields_seen,
-                        working_memory.stats.sensitive_fields_skipped,
-                        working_memory.stats.preferences,
-                        working_memory.stats.goals,
-                        working_memory.stats.constraints,
-                        working_memory.stats.entities,
-                        working_memory.stats.documents_generated,
-                        working_persisted,
-                        working_failed,
-                    );
-                } else {
-                    log::debug!(
-                        "[skills-working-memory] disabled by OPENHUMAN_SKILLS_WORKING_MEMORY_ENABLED; skill='{}' title='{}'",
-                        job.skill,
-                        job.title
-                    );
-                }
-            } else {
-                log::debug!(
-                    "[skills-working-memory] skipping working-memory extraction for non-sync job; skill='{}' title='{}'",
-                    job.skill,
-                    job.title
-                );
-            }
-
-            let namespace = format!("skill-{}", job.skill.trim());
-            let skill = job.skill.trim().to_lowercase();
-
-            // Perform category-specific ingestion logic
-            match skill.as_str() {
-                "notion" => {
-                    // For Notion, we extract individual pages and ingest them as separate documents
-                    let pages = extract_pages_from_sync(&job.content);
-                    if pages.is_empty() {
-                        log::debug!(
-                            "[memory] notion: no pages with content in '{}', skipping ingestion",
-                            job.title,
-                        );
-                    } else {
-                        log::debug!(
-                            "[memory] notion: ingesting {} pages individually",
-                            pages.len(),
-                        );
-                        for page in &pages {
-                            let page_key = format!("page-{}", page.id);
-                            // Store the individual page as a sub-sync
-                            if let Err(e) = job
-                                .client
-                                .store_skill_sync(
-                                    &job.skill,
-                                    "default",
-                                    &page.title,
-                                    &page.content,
-                                    Some("notion".to_string()),
-                                    Some(serde_json::json!({
-                                        "page_id": page.id,
-                                        "url": page.url,
-                                    })),
-                                    None,
-                                    None,
-                                    None,
-                                    Some(page_key.clone()),
-                                )
-                                .await
-                            {
-                                log::warn!(
-                                    "[memory] notion: store page '{}' failed: {e}",
-                                    page.title,
-                                );
-                                continue;
-                            }
-                            // Ingest the page into the vector graph
-                            ingest_single_doc(
-                                &job.client,
-                                &namespace,
-                                &page_key,
-                                &page.title,
-                                &page.content,
-                            )
-                            .await;
-                        }
-                    }
-                }
-                _ => {
-                    // Standard skill: ingest the full content as a single document after stripping secrets
-                    let safe_content = strip_credentials(&job.content);
-                    ingest_single_doc(
-                        &job.client,
-                        &namespace,
-                        &job.title,
-                        &job.title,
-                        &safe_content,
-                    )
-                    .await;
-                }
-            }
-        }
-        log::debug!("[memory] memory-write worker shutting down");
-    });
-    tx
-}
-
-/// A page extracted from a skill sync blob.
-struct SyncPage {
-    id: String,
-    title: String,
-    url: String,
-    content: String,
-}
-
-/// Parse the sync content as JSON and extract individual pages that have `content_text`.
-fn extract_pages_from_sync(content: &str) -> Vec<SyncPage> {
-    let Ok(value) = serde_json::from_str::<serde_json::Value>(content) else {
-        return Vec::new();
-    };
-    let Some(pages) = value.get("pages").and_then(|p| p.as_array()) else {
-        return Vec::new();
-    };
-    pages
-        .iter()
-        .filter_map(|page| {
-            let content_text = page.get("content_text")?.as_str()?;
-            if content_text.trim().is_empty() {
-                return None;
-            }
-            Some(SyncPage {
-                id: page.get("id")?.as_str()?.to_string(),
-                title: page
-                    .get("title")
-                    .and_then(|t| t.as_str())
-                    .unwrap_or("Untitled")
-                    .to_string(),
-                url: page
-                    .get("url")
-                    .and_then(|u| u.as_str())
-                    .unwrap_or("")
-                    .to_string(),
-                content: content_text.to_string(),
-            })
-        })
-        .collect()
-}
-
-/// Remove sensitive fields (like OAuth credentials) from a JSON sync blob before ingestion.
-fn strip_credentials(content: &str) -> String {
-    let Ok(mut value) = serde_json::from_str::<serde_json::Value>(content) else {
-        return content.to_string();
-    };
-    if let Some(obj) = value.as_object_mut() {
-        obj.remove("__oauth_credential");
-    }
-    serde_json::to_string(&value).unwrap_or_else(|_| content.to_string())
-}
-
-/// Store and ingest a single document into the memory graph.
-async fn ingest_single_doc(
-    client: &MemoryClientRef,
-    namespace: &str,
-    key: &str,
-    title: &str,
-    content: &str,
-) {
-    let request = MemoryIngestionRequest {
-        document: NamespaceDocumentInput {
-            namespace: namespace.to_string(),
-            key: key.to_string(),
-            title: title.to_string(),
-            content: content.to_string(),
-            source_type: "doc".to_string(),
-            priority: "medium".to_string(),
-            tags: Vec::new(),
-            metadata: serde_json::json!({}),
-            category: "core".to_string(),
-            session_id: None,
-            document_id: None,
-        },
-        config: MemoryIngestionConfig::default(),
-    };
-    log::debug!("[memory] ingest_doc starting for '{}'", title);
-    match client.ingest_doc(request).await {
-        Ok(result) => {
-            log::info!(
-                "[memory] ingest_doc succeeded for '{}': {} entities, {} relations, {} chunks",
-                title,
-                result.entity_count,
-                result.relation_count,
-                result.chunk_count,
-            );
-        }
-        Err(e) => {
-            log::warn!(
-                "[memory] ingest_doc failed for '{}' (non-fatal): {e}",
-                title,
-            );
-        }
-    }
-}
-
-/// Snapshot the skill's published state and queue it for background memory persistence.
-///
-/// `extract_working_memory` should be `true` only for explicit `skill/sync` enqueues so
-/// that user working-memory documents (`working.user.*`) are derived only from intentional
-/// sync payloads, not from every Tick or CronTrigger write.
-pub(crate) fn persist_state_to_memory(
-    skill_id: &str,
-    title_suffix: &str,
-    ops_state: &Arc<RwLock<qjs_ops::SkillState>>,
-    memory_client: &Option<MemoryClientRef>,
-    memory_write_tx: &mpsc::Sender<MemoryWriteJob>,
-    extract_working_memory: bool,
-) {
-    let state_snapshot = ops_state.read().data.clone();
-    log::debug!(
-        "[skill:{}] persist_state_to_memory({}): {} keys in snapshot",
-        skill_id,
-        title_suffix,
-        state_snapshot.len(),
-    );
-    if state_snapshot.is_empty() {
-        return;
-    }
-    let Some(client) = memory_client.clone() else {
-        log::debug!(
-            "[skill:{}] persist_state_to_memory: no memory client available, skipping",
-            skill_id,
-        );
-        return;
-    };
-    let skill = skill_id.to_string();
-    let content = serde_json::to_string_pretty(&serde_json::Value::Object(state_snapshot))
-        .unwrap_or_else(|_| "{}".to_string());
-    let title = format!("{} {}", skill, title_suffix);
-    if let Err(e) = memory_write_tx.try_send(MemoryWriteJob {
-        client,
-        skill,
-        title: title.clone(),
-        content,
-        extract_working_memory,
-    }) {
-        log::warn!(
-            "[memory] persist_state_to_memory: channel full, dropping write for '{title}': {e}"
-        );
-    }
-}
-
-/// State for a pending asynchronous tool call being tracked by the event loop.
-struct PendingToolCall {
-    /// Channel to send the result back to the system.
-    reply: tokio::sync::oneshot::Sender<Result<ToolResult, String>>,
-    /// Instant when the call is considered timed out.
-    deadline: tokio::time::Instant,
-}
-
-/// The main event loop that drives the QuickJS runtime.
-///
-/// This loop runs indefinitely until the skill is stopped or the channel disconnects.
-/// It performs the following steps in each iteration:
-/// 1. Polls and fires ready timers.
-/// 2. Handles incoming messages from the system channel.
-/// 3. Drives the QuickJS job queue (promises, microtasks).
-/// 4. Checks status of pending asynchronous tool calls.
-/// 5. Synchronizes published state between the bridge and the host.
-/// 6. Calculates and executes an appropriate sleep duration.
-pub(crate) async fn run_event_loop(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    rx: &mut mpsc::Receiver<SkillMessage>,
-    state: &Arc<RwLock<SkillState>>,
-    skill_id: &str,
-    timer_state: &Arc<RwLock<qjs_ops::TimerState>>,
-    ops_state: &Arc<RwLock<qjs_ops::SkillState>>,
-    memory_client: Option<MemoryClientRef>,
-    data_dir: &std::path::Path,
-) {
-    const MAX_IDLE_SLEEP: Duration = Duration::from_millis(100);
-    const MIN_SLEEP: Duration = Duration::from_millis(1);
-    const TOOL_POLL_SLEEP: Duration = Duration::from_millis(5);
-
-    let memory_write_tx = spawn_memory_write_worker();
-    let mut pending_tool: Option<PendingToolCall> = None;
-    let mut sync_in_flight = false;
-
-    loop {
-        // 1. Poll and fire ready timers (setTimeout / setInterval)
-        let (ready_timers, _) = qjs_ops::poll_timers(timer_state);
-        for timer_id in ready_timers {
-            fire_timer_callback(ctx, timer_id).await;
-        }
-
-        // 2. Check for incoming messages (non-blocking try_recv)
-        match rx.try_recv() {
-            Ok(msg) => {
-                let should_stop = handle_message(
-                    rt,
-                    ctx,
-                    msg,
-                    state,
-                    skill_id,
-                    &mut pending_tool,
-                    &mut sync_in_flight,
-                    &memory_client,
-                    ops_state,
-                    data_dir,
-                    &memory_write_tx,
-                )
-                .await;
-                if should_stop {
-                    break;
-                }
-            }
-            Err(mpsc::error::TryRecvError::Empty) => {}
-            Err(mpsc::error::TryRecvError::Disconnected) => {
-                log::info!(
-                    "[skill:{}] Message channel disconnected, stopping",
-                    skill_id
-                );
-                break;
-            }
-        }
-
-        // 3. Drive QuickJS job queue (process pending promises and microtasks)
-        drive_jobs(rt).await;
-
-        // 4. Check if a pending async tool call has completed in the JS environment
-        if pending_tool.is_some() {
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__pendingToolDone === true")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                log::info!("[skill:{}] Pending async tool call completed", skill_id);
-                let result = read_pending_tool_result(ctx).await;
-                if let Some(ptc) = pending_tool.take() {
-                    log::info!(
-                        "[skill:{}] Sending tool result (is_err={})",
-                        skill_id,
-                        result.is_err()
-                    );
-                    let _ = ptc.reply.send(result);
-                }
-            } else if let Some(ref ptc) = pending_tool {
-                // Check for timeout
-                let now = tokio::time::Instant::now();
-                if now >= ptc.deadline {
-                    log::error!(
-                        "[skill:{}] Async tool call timed out after {}s",
-                        skill_id,
-                        tool_execution_timeout_secs()
-                    );
-                    if let Some(ptc) = pending_tool.take() {
-                        let _ = ptc
-                            .reply
-                            .send(Err("Tool async execution timed out".to_string()));
-                    }
-                }
-            }
-        }
-
-        // 4b. Check if a background sync has completed
-        if sync_in_flight {
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__syncInFlight === false")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                sync_in_flight = false;
-                log::info!(
-                    "[skill:{}] Background sync completed, persisting state to memory",
-                    skill_id
-                );
-                persist_state_to_memory(
-                    skill_id,
-                    "periodic sync",
-                    ops_state,
-                    &memory_client,
-                    &memory_write_tx,
-                    true,
-                );
-            }
-        }
-
-        // 5. Sync bridge-level published state to the instance's SkillState
-        {
-            let mut ops = ops_state.write();
-            if ops.dirty {
-                ops.dirty = false;
-                let new_map: HashMap<String, serde_json::Value> = ops
-                    .data
-                    .iter()
-                    .map(|(k, v): (&String, &serde_json::Value)| (k.clone(), v.clone()))
-                    .collect();
-                state.write().published_state = new_map;
-            }
-        }
-
-        // 6. Calculate sleep duration to save CPU cycles when idle
-        let sleep_duration = if pending_tool.is_some() || sync_in_flight {
-            // Poll more frequently when waiting for an async tool result or sync
-            TOOL_POLL_SLEEP
-        } else {
-            let (_, next_timer) = qjs_ops::poll_timers(timer_state);
-            match next_timer {
-                Some(d) if d < MIN_SLEEP => MIN_SLEEP,
-                Some(d) if d > MAX_IDLE_SLEEP => MAX_IDLE_SLEEP,
-                Some(d) => d,
-                None => MAX_IDLE_SLEEP,
-            }
-        };
-
-        tokio::time::sleep(sleep_duration).await;
-    }
-}
-
-/// Fire a timer callback in the JavaScript environment.
-async fn fire_timer_callback(ctx: &rquickjs::AsyncContext, timer_id: u32) {
-    let code = format!("globalThis.__handleTimer({});", timer_id);
-    ctx.with(|js_ctx| {
-        if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(code.as_bytes()) {
-            log::error!("[timer] Callback for timer {} failed: {}", timer_id, e);
-        }
-    })
-    .await;
-}
-
-/// Process a single message received from the host system.
-///
-/// Returns `true` if the message indicates that the event loop should terminate (e.g., Stop).
-async fn handle_message(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    msg: SkillMessage,
-    state: &Arc<RwLock<SkillState>>,
-    skill_id: &str,
-    pending_tool: &mut Option<PendingToolCall>,
-    sync_in_flight: &mut bool,
-    memory_client: &Option<MemoryClientRef>,
-    ops_state: &Arc<RwLock<qjs_ops::SkillState>>,
-    data_dir: &std::path::Path,
-    memory_write_tx: &mpsc::Sender<MemoryWriteJob>,
-) -> bool {
-    match msg {
-        SkillMessage::CallTool {
-            tool_name,
-            arguments,
-            reply,
-        } => {
-            log::info!(
-                "[skill:{}] event_loop: CallTool '{}' received",
-                skill_id,
-                tool_name
-            );
-
-            // Always restore credentials before a tool call to ensure JS has latest tokens
-            restore_oauth_credential(ctx, skill_id, data_dir).await;
-            restore_auth_credential(ctx, skill_id, data_dir).await;
-            restore_client_key(ctx, skill_id, data_dir).await;
-
-            match start_async_tool_call(ctx, &tool_name, arguments).await {
-                Ok(Some(sync_result)) => {
-                    // Tool returned a result immediately (synchronous)
-                    let _ = reply.send(Ok(sync_result));
-                }
-                Ok(None) => {
-                    // Tool returned a Promise, set up tracking for the event loop
-                    *pending_tool = Some(PendingToolCall {
-                        reply,
-                        deadline: tokio::time::Instant::now() + tool_execution_timeout_duration(),
-                    });
-                }
-                Err(e) => {
-                    let _ = reply.send(Err(e));
-                }
-            }
-        }
-        SkillMessage::ServerEvent { event, data } => {
-            let _ = handle_server_event(rt, ctx, &event, data).await;
-        }
-        SkillMessage::CronTrigger { schedule_id } => {
-            // Trigger the cron handler and persist any updated state to memory
-            match handle_cron_trigger(rt, ctx, &schedule_id).await {
-                Ok(_) => {
-                    persist_state_to_memory(
-                        skill_id,
-                        &format!("cron sync ({})", schedule_id),
-                        ops_state,
-                        memory_client,
-                        memory_write_tx,
-                        false,
-                    );
-                }
-                Err(e) => {
-                    log::warn!(
-                        "[skill:{}] cron trigger '{}' failed: {e}",
-                        skill_id,
-                        schedule_id,
-                    );
-                }
-            }
-        }
-        SkillMessage::Stop { reply } => {
-            // Clean up lifecycle and clear credentials from the runtime
-            let _ = call_lifecycle(rt, ctx, "stop", None).await;
-
-            let clear_code = r#"(function() {
-                if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {
-                    globalThis.oauth.__setCredential(null);
-                }
-                if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {
-                    globalThis.state.set('__oauth_credential', '');
-                }
-            })()"#;
-            ctx.with(|js_ctx| {
-                let _ = js_ctx.eval::<rquickjs::Value, _>(clear_code.as_bytes());
-            })
-            .await;
-            state.write().status = SkillStatus::Stopped;
-            log::info!("[skill:{}] Stopped", skill_id);
-            let _ = reply.send(());
-
-            return true;
-        }
-        SkillMessage::SetupStart { reply } => {
-            let result = handle_js_call(rt, ctx, "onSetupStart", "{}").await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::SetupSubmit {
-            step_id,
-            values,
-            reply,
-        } => {
-            let args = serde_json::json!({ "stepId": step_id, "values": values });
-            let result = handle_js_call(rt, ctx, "onSetupSubmit", &args.to_string()).await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::SetupCancel { reply } => {
-            let result = handle_js_void_call(rt, ctx, "onSetupCancel", "{}").await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::ListOptions { reply } => {
-            let result = handle_js_call(rt, ctx, "onListOptions", "{}").await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::SetOption { name, value, reply } => {
-            let args = serde_json::json!({ "name": name, "value": value });
-            let result = handle_js_void_call(rt, ctx, "onSetOption", &args.to_string()).await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::SessionStart { session_id, reply } => {
-            let args = serde_json::json!({ "sessionId": session_id });
-            let result = handle_js_void_call(rt, ctx, "onSessionStart", &args.to_string()).await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::SessionEnd { session_id, reply } => {
-            let args = serde_json::json!({ "sessionId": session_id });
-            let result = handle_js_void_call(rt, ctx, "onSessionEnd", &args.to_string()).await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::Tick { reply } => {
-            let result = handle_js_void_call(rt, ctx, "onTick", "{}").await;
-            if result.is_ok() {
-                persist_state_to_memory(
-                    skill_id,
-                    "tick sync",
-                    ops_state,
-                    memory_client,
-                    memory_write_tx,
-                    false,
-                );
-            }
-            let _ = reply.send(result);
-        }
-        SkillMessage::LoadParams { params } => {
-            let params_str = serde_json::to_string(&params).unwrap_or_else(|_| "{}".to_string());
-            if let Err(e) = handle_js_void_call(rt, ctx, "onLoad", &params_str).await {
-                log::warn!(
-                    "[skill:{}] onLoad failed (skill may not export it): {}",
-                    skill_id,
-                    e
-                );
-            }
-        }
-        SkillMessage::Error {
-            error_type,
-            message,
-            source,
-            recoverable,
-        } => {
-            let args = serde_json::json!({
-                "type": error_type,
-                "message": message,
-                "source": source,
-                "recoverable": recoverable,
-            });
-            if let Err(e) = handle_js_void_call(rt, ctx, "onError", &args.to_string()).await {
-                log::warn!("[skill:{}] onError() handler failed: {e}", skill_id);
-            }
-        }
-        SkillMessage::WebhookRequest {
-            correlation_id,
-            method,
-            path,
-            headers,
-            query,
-            body,
-            tunnel_id,
-            tunnel_name,
-            reply,
-        } => {
-            let result = webhook_handler::handle_webhook_request(
-                rt,
-                ctx,
-                skill_id,
-                correlation_id,
-                method,
-                path,
-                headers,
-                query,
-                body,
-                tunnel_id,
-                tunnel_name,
-                data_dir,
-            )
-            .await;
-            let _ = reply.send(result);
-        }
-        SkillMessage::Rpc {
-            method,
-            params,
-            reply,
-        } => {
-            let result = match method.as_str() {
-                "oauth/complete" => {
-                    rpc_handlers::handle_oauth_complete(rt, ctx, skill_id, params, data_dir).await
-                }
-                "skill/ping" => handle_js_call(rt, ctx, "onPing", "{}").await,
-                "skill/sync" => {
-                    let result = rpc_handlers::handle_sync(
-                        rt,
-                        ctx,
-                        skill_id,
-                        ops_state,
-                        memory_client,
-                        memory_write_tx,
-                    )
-                    .await;
-                    if result.is_ok() {
-                        *sync_in_flight = true;
-                    }
-                    result
-                }
-                "oauth/revoked" => {
-                    rpc_handlers::handle_oauth_revoked(
-                        rt,
-                        ctx,
-                        skill_id,
-                        params,
-                        data_dir,
-                        memory_client,
-                    )
-                    .await
-                }
-                "auth/complete" => {
-                    rpc_handlers::handle_auth_complete(rt, ctx, skill_id, params, data_dir).await
-                }
-                "auth/revoked" => {
-                    rpc_handlers::handle_auth_revoked(
-                        rt,
-                        ctx,
-                        skill_id,
-                        params,
-                        data_dir,
-                        memory_client,
-                    )
-                    .await
-                }
-                _ => {
-                    let args = serde_json::json!({ "method": method, "params": params });
-                    handle_js_call(rt, ctx, "onRpc", &args.to_string()).await
-                }
-            };
-
-            let _ = reply.send(result);
-        }
-    }
-    false
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn extract_pages_from_notion_sync() {
-        let content = serde_json::json!({
-            "snapshot_version": "notion-sync-v2",
-            "pages": [
-                {
-                    "id": "page-1",
-                    "title": "Meeting Notes",
-                    "url": "https://notion.so/page-1",
-                    "content_text": "Attendees: Alice, Bob. Decision: ship by Friday.",
-                    "has_content": true
-                },
-                {
-                    "id": "page-2",
-                    "title": "Empty Page",
-                    "url": "https://notion.so/page-2",
-                    "content_text": "",
-                    "has_content": false
-                },
-                {
-                    "id": "page-3",
-                    "title": "Whitespace Only",
-                    "url": "https://notion.so/page-3",
-                    "content_text": "   ",
-                    "has_content": false
-                }
-            ]
-        })
-        .to_string();
-
-        let pages = extract_pages_from_sync(&content);
-        assert_eq!(
-            pages.len(),
-            1,
-            "only page with real content should be extracted"
-        );
-        assert_eq!(pages[0].id, "page-1");
-        assert_eq!(pages[0].title, "Meeting Notes");
-        assert_eq!(
-            pages[0].content,
-            "Attendees: Alice, Bob. Decision: ship by Friday."
-        );
-    }
-
-    #[test]
-    fn extract_pages_skips_gmail_sync() {
-        let content = serde_json::json!({
-            "__oauth_credential": {"credentialId": "abc123"},
-            "auth_status": "authenticated",
-            "emails": [],
-            "totalEmails": 0,
-            "syncInProgress": false
-        })
-        .to_string();
-
-        let pages = extract_pages_from_sync(&content);
-        assert!(pages.is_empty(), "gmail sync data should not produce pages");
-    }
-
-    #[test]
-    fn extract_pages_skips_ops_state_with_empty_pages() {
-        let content = serde_json::json!({
-            "auth_status": "authenticated",
-            "pages": [],
-            "totalPages": 0,
-            "syncInProgress": false
-        })
-        .to_string();
-
-        let pages = extract_pages_from_sync(&content);
-        assert!(
-            pages.is_empty(),
-            "empty pages array should produce no results"
-        );
-    }
-
-    #[test]
-    fn extract_pages_skips_non_json() {
-        let pages = extract_pages_from_sync("this is plain text, not json");
-        assert!(
-            pages.is_empty(),
-            "non-JSON content should produce no results"
-        );
-    }
-
-    #[test]
-    fn extract_pages_skips_pages_without_content_text() {
-        let content = serde_json::json!({
-            "pages": [
-                {"id": "page-1", "title": "No Content Field"},
-                {"id": "page-2", "title": "Null Content", "content_text": null}
-            ]
-        })
-        .to_string();
-
-        let pages = extract_pages_from_sync(&content);
-        assert!(
-            pages.is_empty(),
-            "pages without content_text should be skipped"
-        );
-    }
-
-    #[test]
-    fn strip_credentials_removes_oauth() {
-        let content = serde_json::json!({
-            "__oauth_credential": {"credentialId": "secret123"},
-            "auth_status": "authenticated",
-            "emails": []
-        })
-        .to_string();
-
-        let safe = strip_credentials(&content);
-        assert!(!safe.contains("secret123"), "credential should be stripped");
-        assert!(safe.contains("authenticated"), "other fields preserved");
-    }
-
-    #[test]
-    fn strip_credentials_passthrough_non_json() {
-        let content = "plain text content";
-        assert_eq!(strip_credentials(content), content);
-    }
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/event_loop/rpc_handlers.rs b/src/openhuman/skills/qjs_skill_instance/event_loop/rpc_handlers.rs
deleted file mode 100644
index aadf64379..000000000
--- a/src/openhuman/skills/qjs_skill_instance/event_loop/rpc_handlers.rs
+++ /dev/null
@@ -1,560 +0,0 @@
-//! RPC message handlers for the skill event loop.
-//!
-//! This module implements handlers for various JSON-RPC methods targeted at
-//! a running skill instance, including authentication flows (OAuth, Auth),
-//! synchronization, and revocation events.
-
-use std::sync::Arc;
-
-use parking_lot::RwLock;
-use tokio::sync::mpsc;
-
-use crate::openhuman::{memory::MemoryClientRef, skills::quickjs_libs::qjs_ops};
-
-use super::super::js_handlers::{handle_js_call, handle_js_void_call};
-use super::{persist_state_to_memory, MemoryWriteJob};
-
-/// Handle `oauth/complete` RPC.
-///
-/// Mirrors `handle_auth_complete`: temp-inject the new credentials into the
-/// JS bridges, ask `start({ oauth, validate: true })` to validate them
-/// against the upstream API, and only persist to disk if start() returns
-/// `{ status: "complete" }`. There is no separate `onOAuthComplete` JS hook
-/// — `start()` is the single entry point for "this skill is now connected".
-pub(crate) async fn handle_oauth_complete(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    params: serde_json::Value,
-    data_dir: &std::path::Path,
-) -> Result<serde_json::Value, String> {
-    let cred_json = serde_json::to_string(&params).unwrap_or_else(|_| "null".to_string());
-
-    // Extract client key share (required for encrypted OAuth proxy requests).
-    // We have to inject it before start() runs because the proxy validation
-    // call inside start() needs it to encrypt the outgoing request.
-    let client_key = params
-        .get("clientKeyShare")
-        .and_then(|v| v.as_str())
-        .unwrap_or("");
-
-    let client_key_js = if !client_key.is_empty() {
-        format!(
-            r#"globalThis.__oauthClientKey = "{key}";"#,
-            key = client_key
-        )
-    } else {
-        String::new()
-    };
-
-    // Step 1: Temporary injection so the JS `oauth` bridge sees the new
-    // credential while start() runs validation through the proxy.
-    let inject_code = format!(
-        r#"(function() {{
-            if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {{
-                globalThis.oauth.__setCredential({cred});
-            }}
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                globalThis.state.set('__oauth_credential', {cred});
-            }}
-            {client_key_js}
-        }})()"#,
-        cred = cred_json,
-        client_key_js = client_key_js,
-    );
-    ctx.with(|js_ctx| {
-        let _ = js_ctx.eval::<rquickjs::Value, _>(inject_code.as_bytes());
-    })
-    .await;
-
-    // Step 2: Build a `{ oauth, auth, validate: true }` arg bag and call
-    // start(). Auth comes from disk so the skill still has the full picture
-    // if it's already connected via auth/complete; oauth is the freshly
-    // submitted credential we want validated.
-    let auth_on_disk = match std::fs::read_to_string(data_dir.join("auth_credential.json")) {
-        Ok(s) if !s.trim().is_empty() => {
-            serde_json::from_str::<serde_json::Value>(&s).unwrap_or(serde_json::Value::Null)
-        }
-        _ => serde_json::Value::Null,
-    };
-    let start_args_value = serde_json::json!({
-        "oauth": params,
-        "auth": auth_on_disk,
-        "validate": true,
-    });
-    let start_args =
-        serde_json::to_string(&start_args_value).unwrap_or_else(|_| "null".to_string());
-    let result = handle_js_call(rt, ctx, "start", &start_args).await;
-
-    // Evaluate validation result
-    let validation_failed = match &result {
-        Err(_) => true,
-        Ok(val) => val.get("status").and_then(|s| s.as_str()) == Some("error"),
-    };
-
-    if validation_failed {
-        // Rollback temporary injection — credential never made it to disk so
-        // a follow-up restart will see the skill as disconnected again.
-        let clear_code = r#"(function() {
-            if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {
-                globalThis.oauth.__setCredential(null);
-            }
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {
-                globalThis.state.set('__oauth_credential', '');
-            }
-            globalThis.__oauthClientKey = null;
-        })()"#;
-        ctx.with(|js_ctx| {
-            let _ = js_ctx.eval::<rquickjs::Value, _>(clear_code.as_bytes());
-        })
-        .await;
-        log::info!(
-            "[skill:{}] oauth/complete validation failed, credential not persisted",
-            skill_id
-        );
-        return result;
-    }
-
-    // Step 3: Validation passed — persist credentials and client key to disk
-    // so they survive restarts.
-    let cred_path = data_dir.join("oauth_credential.json");
-    if let Err(e) = std::fs::write(&cred_path, &cred_json) {
-        log::error!(
-            "[skill:{}] Failed to persist OAuth credential: {e}",
-            skill_id
-        );
-    } else {
-        log::info!(
-            "[skill:{}] OAuth credential persisted to {}",
-            skill_id,
-            cred_path.display()
-        );
-    }
-
-    if !client_key.is_empty() {
-        let key_path = data_dir.join("client_key.json");
-        let key_json = serde_json::json!({ "clientKey": client_key }).to_string();
-        if let Err(e) = std::fs::write(&key_path, &key_json) {
-            log::error!(
-                "[skill:{}] Failed to persist client key share: {e}",
-                skill_id
-            );
-        } else {
-            log::info!(
-                "[skill:{}] Client key share persisted to {}",
-                skill_id,
-                key_path.display()
-            );
-        }
-    }
-
-    result
-}
-
-/// Handle `oauth/revoked` RPC.
-///
-/// 1. Clears credentials and client keys from the JS runtime.
-/// 2. Deletes credential files from disk.
-/// 3. Spawns a background task to clear the skill's memory store.
-/// 4. Invokes the `onOAuthRevoked` lifecycle handler in JS.
-pub(crate) async fn handle_oauth_revoked(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    params: serde_json::Value,
-    data_dir: &std::path::Path,
-    memory_client: &Option<MemoryClientRef>,
-) -> Result<serde_json::Value, String> {
-    let clear_code = r#"(function() {
-        if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {
-            globalThis.oauth.__setCredential(null);
-        }
-        if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {
-            globalThis.state.set('__oauth_credential', '');
-        }
-        globalThis.__oauthClientKey = null;
-    })()"#;
-    ctx.with(|js_ctx| {
-        let _ = js_ctx.eval::<rquickjs::Value, _>(clear_code.as_bytes());
-    })
-    .await;
-
-    let cred_path = data_dir.join("oauth_credential.json");
-    let _ = std::fs::remove_file(&cred_path);
-    let key_path = data_dir.join("client_key.json");
-    let _ = std::fs::remove_file(&key_path);
-    log::info!(
-        "[skill:{}] OAuth credential and client key cleared from store and disk",
-        skill_id
-    );
-
-    // Trigger memory cleanup for this skill/integration
-    if let Some(client) = memory_client.clone() {
-        let skill = skill_id.to_string();
-        let integration_id = params
-            .get("integrationId")
-            .and_then(|v| v.as_str())
-            .unwrap_or("unknown")
-            .to_string();
-        tokio::spawn(async move {
-            if let Err(e) = client.clear_skill_memory(&skill, &integration_id).await {
-                log::warn!("[memory] clear_skill_memory failed: {e}");
-            } else {
-                log::info!("[memory] Cleared memory for {}:{}", skill, integration_id);
-            }
-        });
-    }
-
-    let params_str = serde_json::to_string(&params).unwrap_or_else(|_| "{}".to_string());
-    handle_js_void_call(rt, ctx, "onOAuthRevoked", &params_str)
-        .await
-        .map(|()| serde_json::json!({ "ok": true }))
-}
-
-/// Handle `auth/complete` RPC.
-///
-/// There is no separate `onAuthComplete` JS hook anymore. The flow is:
-///   1. Temporarily inject the new credentials into the JS bridges.
-///   2. Call `start({ oauth, auth, validate: true })`. start() owns both
-///      validation (when `validate` is set) and activation (cron, etc.) — it
-///      returns `{ status: "complete" }` or `{ status: "error", errors: [...] }`.
-///   3. If start() returned an error, roll back the temporary injection and
-///      surface the result to the caller (no persistence on disk).
-///   4. Otherwise persist the credentials to disk so they survive restarts.
-pub(crate) async fn handle_auth_complete(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    params: serde_json::Value,
-    data_dir: &std::path::Path,
-) -> Result<serde_json::Value, String> {
-    let cred_json = serde_json::to_string(&params).unwrap_or_else(|_| "null".to_string());
-    let is_managed = params
-        .get("mode")
-        .and_then(|v| v.as_str())
-        .map(|m| m == "managed")
-        .unwrap_or(false);
-
-    // Step 1: Temporary injection so the JS bridges (`auth`, and `oauth` for
-    // managed mode) see the new credentials while start() runs validation.
-    let temp_code = format!(
-        r#"(function() {{
-            if (typeof globalThis.auth !== 'undefined' && globalThis.auth.__setCredential) {{
-                globalThis.auth.__setCredential({cred});
-            }}
-        }})()"#,
-        cred = cred_json
-    );
-    ctx.with(|js_ctx| {
-        let _ = js_ctx.eval::<rquickjs::Value, _>(temp_code.as_bytes());
-    })
-    .await;
-
-    // Step 2: Build a `{ oauth, auth, validate: true }` arg bag and call
-    // start(). We pass the freshly-submitted auth params (not what's on disk)
-    // so the validation step inside start() inspects the *new* credentials.
-    // OAuth comes from disk so the skill still has the full picture.
-    let oauth_on_disk = match std::fs::read_to_string(data_dir.join("oauth_credential.json")) {
-        Ok(s) if !s.trim().is_empty() => {
-            serde_json::from_str::<serde_json::Value>(&s).unwrap_or(serde_json::Value::Null)
-        }
-        _ => serde_json::Value::Null,
-    };
-    let start_args_value = serde_json::json!({
-        "oauth": oauth_on_disk,
-        "auth": params,
-        "validate": true,
-    });
-    let start_args =
-        serde_json::to_string(&start_args_value).unwrap_or_else(|_| "null".to_string());
-    let result = handle_js_call(rt, ctx, "start", &start_args).await;
-
-    // Evaluate validation result
-    let validation_failed = match &result {
-        Err(_) => true,
-        Ok(val) => val.get("status").and_then(|s| s.as_str()) == Some("error"),
-    };
-
-    if validation_failed {
-        // Rollback temporary injection — credentials never made it to disk so
-        // a follow-up restart will see the skill as disconnected again.
-        let clear_code = r#"(function() {
-            if (typeof globalThis.auth !== 'undefined' && globalThis.auth.__setCredential) {
-                globalThis.auth.__setCredential(null);
-            }
-        })()"#;
-        ctx.with(|js_ctx| {
-            let _ = js_ctx.eval::<rquickjs::Value, _>(clear_code.as_bytes());
-        })
-        .await;
-        log::info!(
-            "[skill:{}] auth/complete validation failed, credentials not persisted",
-            skill_id
-        );
-        return result;
-    }
-
-    // Step 3: Permanent injection and persistence. start() already activated
-    // cron etc. above; this just makes sure the bridges and disk reflect the
-    // new credentials so a future restart restores the same state.
-    let managed_bridge = if is_managed {
-        let creds_json = serde_json::to_string(
-            params
-                .get("credentials")
-                .unwrap_or(&serde_json::Value::Null),
-        )
-        .unwrap_or_else(|_| "null".to_string());
-        format!(
-            r#"
-            if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {{
-                globalThis.oauth.__setCredential({creds});
-            }}
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                globalThis.state.set('__oauth_credential', {creds});
-            }}"#,
-            creds = creds_json
-        )
-    } else {
-        String::new()
-    };
-
-    let persist_code = format!(
-        r#"(function() {{
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                globalThis.state.set('__auth_credential', {cred});
-            }}
-            {managed_bridge}
-        }})()"#,
-        cred = cred_json,
-        managed_bridge = managed_bridge
-    );
-    ctx.with(|js_ctx| {
-        let _ = js_ctx.eval::<rquickjs::Value, _>(persist_code.as_bytes());
-    })
-    .await;
-
-    let cred_path = data_dir.join("auth_credential.json");
-    if let Err(e) = std::fs::write(&cred_path, &cred_json) {
-        log::error!(
-            "[skill:{}] Failed to persist auth credential: {e}",
-            skill_id
-        );
-    } else {
-        log::info!(
-            "[skill:{}] Auth credential persisted to {}",
-            skill_id,
-            cred_path.display()
-        );
-    }
-
-    // Back-compatibility for managed mode
-    if is_managed {
-        let oauth_cred_json = serde_json::to_string(
-            params
-                .get("credentials")
-                .unwrap_or(&serde_json::Value::Null),
-        )
-        .unwrap_or_else(|_| "null".to_string());
-        let oauth_path = data_dir.join("oauth_credential.json");
-        let _ = std::fs::write(&oauth_path, &oauth_cred_json);
-    }
-
-    result
-}
-
-/// Handle `auth/revoked` RPC.
-///
-/// Clears Auth credentials (and managed OAuth credentials if applicable) from
-/// the runtime and disk. Also triggers a background memory cleanup.
-pub(crate) async fn handle_auth_revoked(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    params: serde_json::Value,
-    data_dir: &std::path::Path,
-    memory_client: &Option<MemoryClientRef>,
-) -> Result<serde_json::Value, String> {
-    let is_managed = params
-        .get("mode")
-        .and_then(|v| v.as_str())
-        .map(|m| m == "managed")
-        .unwrap_or(false);
-
-    let managed_clear = if is_managed {
-        r#"
-        if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {
-            globalThis.oauth.__setCredential(null);
-        }
-        if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {
-            globalThis.state.set('__oauth_credential', '');
-        }"#
-    } else {
-        ""
-    };
-
-    let clear_code = format!(
-        r#"(function() {{
-            if (typeof globalThis.auth !== 'undefined' && globalThis.auth.__setCredential) {{
-                globalThis.auth.__setCredential(null);
-            }}
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                globalThis.state.set('__auth_credential', '');
-            }}
-            globalThis.__oauthClientKey = null;
-            {managed_clear}
-        }})()"#,
-        managed_clear = managed_clear
-    );
-    ctx.with(|js_ctx| {
-        let _ = js_ctx.eval::<rquickjs::Value, _>(clear_code.as_bytes());
-    })
-    .await;
-
-    let cred_path = data_dir.join("auth_credential.json");
-    let _ = std::fs::remove_file(&cred_path);
-    let key_path = data_dir.join("client_key.json");
-    let _ = std::fs::remove_file(&key_path);
-    if is_managed {
-        let oauth_path = data_dir.join("oauth_credential.json");
-        let _ = std::fs::remove_file(&oauth_path);
-    }
-    log::info!(
-        "[skill:{}] Auth credential and client key cleared from store and disk",
-        skill_id
-    );
-
-    if let Some(client) = memory_client.clone() {
-        let skill = skill_id.to_string();
-        let integration_id = params
-            .get("integrationId")
-            .and_then(|v| v.as_str())
-            .unwrap_or("unknown")
-            .to_string();
-        tokio::spawn(async move {
-            if let Err(e) = client.clear_skill_memory(&skill, &integration_id).await {
-                log::warn!("[memory] clear_skill_memory failed: {e}");
-            } else {
-                log::info!("[memory] Cleared memory for {}:{}", skill, integration_id);
-            }
-        });
-    }
-
-    let params_str = serde_json::to_string(&params).unwrap_or_else(|_| "{}".to_string());
-    handle_js_void_call(rt, ctx, "onAuthRevoked", &params_str)
-        .await
-        .map(|()| serde_json::json!({ "ok": true }))
-}
-
-/// Handle `skill/sync` RPC.
-///
-/// Fires `onSync` in the JS runtime as a background task and returns immediately.
-/// The JS function runs asynchronously via the QuickJS job queue — progress is
-/// published by the skill through `state.setPartial()` and can be read via
-/// `sync-status` tool or `skills_status` RPC.
-///
-/// On completion (success or failure) the JS skill updates its own state. A
-/// memory snapshot is persisted once the sync finishes via a completion callback
-/// injected into the JS promise chain.
-pub(crate) async fn handle_sync(
-    _rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    ops_state: &Arc<RwLock<qjs_ops::SkillState>>,
-    memory_client: &Option<MemoryClientRef>,
-    memory_write_tx: &mpsc::Sender<MemoryWriteJob>,
-) -> Result<serde_json::Value, String> {
-    let skill_id_owned = skill_id.to_string();
-
-    // Clone handles for the completion callback
-    let ops_for_cb = ops_state.clone();
-    let mem_client_for_cb = memory_client.clone();
-    let mem_tx_for_cb = memory_write_tx.clone();
-
-    // Fire onSync without awaiting the promise — it runs in the QuickJS job
-    // queue and the event loop drives it on subsequent ticks.
-    let start_result = ctx
-        .with(|js_ctx| {
-            let code = r#"(function() {
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || globalThis);
-                var fn = skill.onSync || globalThis.onSync;
-                if (typeof fn !== 'function') {
-                    return "no_handler";
-                }
-                var result = fn.call(skill, {});
-                if (result && typeof result.then === 'function') {
-                    // Mark sync as in-flight so completion callback can persist memory
-                    globalThis.__syncInFlight = true;
-                    result.then(
-                        function() {
-                            globalThis.__syncInFlight = false;
-                            console.log('[notion][sync] background sync completed successfully');
-                        },
-                        function(e) {
-                            globalThis.__syncInFlight = false;
-                            console.error('[notion][sync] background sync failed: ' + (e && e.message ? e.message : String(e)));
-                        }
-                    );
-                    return "started";
-                }
-                // Synchronous — already done
-                return "done";
-            })()"#;
-
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s),
-                Err(e) => {
-                    let detail = super::super::js_helpers::format_js_exception(&js_ctx, &e);
-                    Err(format!("onSync() failed to start: {detail}"))
-                }
-            }
-        })
-        .await;
-
-    match start_result {
-        Ok(ref status) if status == "no_handler" => {
-            // Skills without an `onSync` handler should treat a sync RPC
-            // as a no-op rather than a hard error. Plenty of skills don't
-            // need a periodic sync (e.g. `server-ping`, utility skills),
-            // and the cron driver fires `skills_sync` against every skill
-            // on its schedule — raising here would turn a blanket sweep
-            // into a cascade of RPC errors in logs/dashboards.
-            log::debug!(
-                "[skill:{}] sync no-op: skill does not implement onSync",
-                skill_id_owned
-            );
-            Ok(serde_json::json!({
-                "status": "no_handler",
-                "skipped": true,
-                "reason": "Skill does not implement onSync"
-            }))
-        }
-        Ok(ref status) => {
-            log::info!(
-                "[skill:{}] sync started in background (status={})",
-                skill_id_owned,
-                status
-            );
-
-            // If synchronous ("done"), persist memory now
-            if status == "done" {
-                persist_state_to_memory(
-                    &skill_id_owned,
-                    "periodic sync",
-                    &ops_for_cb,
-                    &mem_client_for_cb,
-                    &mem_tx_for_cb,
-                    true,
-                );
-            }
-
-            Ok(serde_json::json!({
-                "ok": true,
-                "status": status,
-                "message": "Sync started in background. Query sync-status for progress."
-            }))
-        }
-        Err(e) => Err(e),
-    }
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/event_loop/webhook_handler.rs b/src/openhuman/skills/qjs_skill_instance/event_loop/webhook_handler.rs
deleted file mode 100644
index 41b9afefb..000000000
--- a/src/openhuman/skills/qjs_skill_instance/event_loop/webhook_handler.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! Webhook request handler for the skill event loop.
-//!
-//! This module provides the logic for processing incoming HTTP webhooks targeted
-//! at a specific skill. It bridges the system-level webhook request into a
-//! call to the skill's `onWebhookRequest` JavaScript handler.
-
-use std::collections::HashMap;
-
-use crate::openhuman::webhooks::WebhookResponseData;
-
-use crate::openhuman::skills::qjs_skill_instance::js_handlers::handle_js_call;
-use crate::openhuman::skills::qjs_skill_instance::js_helpers::{
-    restore_auth_credential, restore_client_key, restore_oauth_credential,
-};
-
-/// Handle an incoming webhook request.
-///
-/// This function performs the following steps:
-/// 1. Restores the skill's authentication credentials into the JS context.
-/// 2. Invokes the `onWebhookRequest` JavaScript function with the request details.
-/// 3. Parses the JavaScript response (status code, headers, body) into `WebhookResponseData`.
-pub(crate) async fn handle_webhook_request(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    correlation_id: String,
-    method: String,
-    path: String,
-    headers: HashMap<String, serde_json::Value>,
-    query: HashMap<String, String>,
-    body: String,
-    tunnel_id: String,
-    tunnel_name: String,
-    data_dir: &std::path::Path,
-) -> Result<WebhookResponseData, String> {
-    log::info!(
-        "[skill:{}] event_loop: WebhookRequest {} {} (tunnel={})",
-        skill_id,
-        method,
-        path,
-        tunnel_id,
-    );
-
-    // Restore credentials in case the handler needs to make authenticated API calls
-    restore_oauth_credential(ctx, skill_id, data_dir).await;
-    restore_auth_credential(ctx, skill_id, data_dir).await;
-    restore_client_key(ctx, skill_id, data_dir).await;
-
-    let args = serde_json::json!({
-        "correlationId": correlation_id,
-        "method": method,
-        "path": path,
-        "headers": headers,
-        "query": query,
-        "body": body,
-        "tunnelId": tunnel_id,
-        "tunnelName": tunnel_name,
-    });
-
-    // Call the JavaScript onWebhookRequest handler
-    match handle_js_call(rt, ctx, "onWebhookRequest", &args.to_string()).await {
-        Ok(response_val) => {
-            // Extract HTTP status code from the JS response object
-            let status_code = response_val
-                .get("statusCode")
-                .and_then(|v| v.as_u64())
-                .unwrap_or(200) as u16;
-
-            // Extract headers from the JS response object
-            let resp_headers: HashMap<String, String> = response_val
-                .get("headers")
-                .map(|v| match serde_json::from_value(v.clone()) {
-                    Ok(h) => h,
-                    Err(e) => {
-                        log::warn!(
-                            "[skill] Failed to parse webhook response headers: {e}, raw: {v}"
-                        );
-                        HashMap::new()
-                    }
-                })
-                .unwrap_or_default();
-
-            // Extract response body (usually a string or serialized JSON)
-            let resp_body = response_val
-                .get("body")
-                .and_then(|v| v.as_str())
-                .unwrap_or("")
-                .to_string();
-
-            log::debug!(
-                "[skill:{}] event_loop: WebhookRequest handled -> status {}",
-                skill_id,
-                status_code,
-            );
-
-            Ok(WebhookResponseData {
-                correlation_id,
-                status_code,
-                headers: resp_headers,
-                body: resp_body,
-            })
-        }
-        Err(e) => {
-            log::warn!(
-                "[skill:{}] event_loop: onWebhookRequest failed: {}",
-                skill_id,
-                e,
-            );
-            Err(e)
-        }
-    }
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/instance.rs b/src/openhuman/skills/qjs_skill_instance/instance.rs
deleted file mode 100644
index 3526ed6ce..000000000
--- a/src/openhuman/skills/qjs_skill_instance/instance.rs
+++ /dev/null
@@ -1,308 +0,0 @@
-//! Implementation of the QuickJS skill instance.
-//!
-//! This module contains the main logic for initializing and spawning the execution
-//! loop of a QuickJS-based skill. It handles setting up the runtime, context,
-//! registering native bridges, loading the skill bundle, and transitioning through
-//! lifecycle stages (init, start, running).
-
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use parking_lot::RwLock;
-use tokio::sync::mpsc;
-
-use crate::openhuman::skills::quickjs_libs::{qjs_ops, IdbStorage};
-use crate::openhuman::skills::types::{SkillConfig, SkillMessage, SkillSnapshot, SkillStatus};
-
-use super::event_loop::run_event_loop;
-use super::js_handlers::{call_lifecycle, handle_js_call};
-use super::js_helpers::{
-    drive_jobs, extract_tools, format_js_exception, restore_auth_credential, restore_client_key,
-    restore_oauth_credential,
-};
-use super::types::{BridgeDeps, QjsSkillInstance, SkillState};
-
-/// Read persisted oauth/auth credentials from a skill's data directory and
-/// produce a JS expression suitable for `start({ oauth, auth })`.
-///
-/// This is the canonical shape passed to `start()`: a single object with
-/// `oauth` and `auth` keys, each either an object or `null`. Skills can read
-/// either field directly or rely on the runtime bridges that have already
-/// been populated by the `restore_*_credential` helpers.
-pub(crate) fn build_start_credentials_arg(data_dir: &std::path::Path) -> String {
-    fn read_json(path: &std::path::Path) -> serde_json::Value {
-        match std::fs::read_to_string(path) {
-            Ok(s) if !s.trim().is_empty() => {
-                serde_json::from_str(&s).unwrap_or(serde_json::Value::Null)
-            }
-            _ => serde_json::Value::Null,
-        }
-    }
-
-    let oauth = read_json(&data_dir.join("oauth_credential.json"));
-    let auth = read_json(&data_dir.join("auth_credential.json"));
-    let arg = serde_json::json!({
-        "oauth": oauth,
-        "auth": auth,
-    });
-    serde_json::to_string(&arg).unwrap_or_else(|_| "{\"oauth\":null,\"auth\":null}".to_string())
-}
-
-impl QjsSkillInstance {
-    /// Create a new QuickJS skill instance.
-    ///
-    /// Returns the instance and a channel to receive messages from the system.
-    pub fn new(
-        config: SkillConfig,
-        skill_dir: PathBuf,
-        data_dir: PathBuf,
-    ) -> (Self, mpsc::Receiver<SkillMessage>) {
-        let (tx, rx) = mpsc::channel(64);
-        let instance = Self {
-            config,
-            state: Arc::new(RwLock::new(SkillState::default())),
-            sender: tx,
-            skill_dir,
-            data_dir,
-        };
-        (instance, rx)
-    }
-
-    /// Take a snapshot of the current skill state.
-    ///
-    /// Note: `setup_complete` and `connection_status` are populated later
-    /// by `RuntimeEngine::enrich_snapshot()` which has access to `PreferencesStore`.
-    pub fn snapshot(&self) -> SkillSnapshot {
-        let state = self.state.read();
-        SkillSnapshot {
-            skill_id: self.config.skill_id.clone(),
-            name: self.config.name.clone(),
-            status: state.status,
-            tools: state.tools.clone(),
-            error: state.error.clone(),
-            state: state.published_state.clone(),
-            setup_complete: false,
-            connection_status: String::new(),
-        }
-    }
-
-    /// Spawn the skill's execution loop as a tokio task.
-    ///
-    /// This function sets up the entire QuickJS environment, including memory limits,
-    /// native bridge registration (ops), bootstrap code, and the skill's own bundle.
-    /// It then transitions through the `init()` and `start()` lifecycles before
-    /// entering the main event loop.
-    pub fn spawn(
-        &self,
-        mut rx: mpsc::Receiver<SkillMessage>,
-        deps: BridgeDeps,
-    ) -> tokio::task::JoinHandle<()> {
-        let config = self.config.clone();
-        let state = self.state.clone();
-        let skill_dir = self.skill_dir.clone();
-        let data_dir = self.data_dir.clone();
-
-        tokio::spawn(async move {
-            // Update status to Initializing as we begin setup
-            state.write().status = SkillStatus::Initializing;
-
-            // Create persistent storage (IndexedDB-like) in the skill's data directory
-            let storage: IdbStorage = match IdbStorage::new(&data_dir) {
-                Ok(s) => s,
-                Err(e) => {
-                    let mut s = state.write();
-                    s.status = SkillStatus::Error;
-                    s.error = Some(format!("Failed to create storage: {e}"));
-                    log::error!("[skill:{}] Storage creation failed: {e}", config.skill_id);
-                    return;
-                }
-            };
-
-            // Read the entry point JS file from the skill bundle directory
-            let entry_path = skill_dir.join(&config.entry_point);
-            let js_source = match tokio::fs::read_to_string(&entry_path).await {
-                Ok(src) => src,
-                Err(e) => {
-                    let mut s = state.write();
-                    s.status = SkillStatus::Error;
-                    s.error = Some(format!("Failed to read {}: {e}", config.entry_point));
-                    log::error!(
-                        "[skill:{}] Failed to read entry point: {e}",
-                        config.skill_id
-                    );
-                    return;
-                }
-            };
-
-            // Create a fresh QuickJS runtime. QuickJS allows multiple runtimes in one process.
-            let rt = match rquickjs::AsyncRuntime::new() {
-                Ok(rt) => rt,
-                Err(e) => {
-                    let mut s = state.write();
-                    s.status = SkillStatus::Error;
-                    s.error = Some(format!("Failed to create QuickJS runtime: {e}"));
-                    log::error!(
-                        "[skill:{}] Failed to create QuickJS runtime: {e}",
-                        config.skill_id
-                    );
-                    return;
-                }
-            };
-
-            // Apply resource constraints to the runtime
-            rt.set_memory_limit(config.memory_limit).await;
-            rt.set_max_stack_size(512 * 1024).await; // 512KB stack is usually plenty for skills
-
-            // Create context with the full standard library (Date, Math, JSON, etc.)
-            let ctx = match rquickjs::AsyncContext::full(&rt).await {
-                Ok(ctx) => ctx,
-                Err(e) => {
-                    let mut s = state.write();
-                    s.status = SkillStatus::Error;
-                    s.error = Some(format!("Failed to create QuickJS context: {e}"));
-                    log::error!("[skill:{}] Failed to create context: {e}", config.skill_id);
-                    return;
-                }
-            };
-
-            // Prepare internal state containers for JS features
-            let timer_state = Arc::new(RwLock::new(qjs_ops::TimerState::default()));
-            let ws_state = Arc::new(RwLock::new(qjs_ops::WebSocketState::default()));
-            let published_state = Arc::new(RwLock::new(qjs_ops::SkillState::default()));
-
-            // Register native bridges (ops) and perform bootstrap
-            let skill_id = config.skill_id.clone();
-            let init_result = ctx
-                .with(|js_ctx| {
-                    // SkillContext contains dependencies required by native bridges
-                    let skill_context = qjs_ops::SkillContext {
-                        skill_id: skill_id.clone(),
-                        data_dir: data_dir.clone(),
-                        memory_client: deps.memory_client.clone(),
-                        webhook_router: deps.webhook_router.clone(),
-                    };
-
-                    // Register functions on the global scope via the __ops bridge
-                    if let Err(e) = qjs_ops::register_ops(
-                        &js_ctx,
-                        storage.clone(),
-                        skill_context,
-                        published_state.clone(),
-                        timer_state.clone(),
-                        ws_state.clone(),
-                    ) {
-                        return Err(format!("Failed to register ops: {e}"));
-                    }
-
-                    // Load bootstrap code to set up high-level JS APIs (Fetch, Timers, etc.)
-                    let bootstrap_code = include_str!("../quickjs_libs/bootstrap.js");
-                    if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(bootstrap_code) {
-                        let detail = format_js_exception(&js_ctx, &e);
-                        return Err(format!("Bootstrap failed: {detail}"));
-                    }
-
-                    // Inject the skill ID into the global scope for internal JS use
-                    let bridge_code = format!(
-                        r#"globalThis.__skillId = "{}";"#,
-                        skill_id.replace('"', r#"\""#)
-                    );
-                    if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(bridge_code.as_bytes()) {
-                        let detail = format_js_exception(&js_ctx, &e);
-                        return Err(format!("Skill init failed: {detail}"));
-                    }
-
-                    // Evaluate the actual skill bundle code
-                    if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(js_source.as_bytes()) {
-                        let detail = format_js_exception(&js_ctx, &e);
-                        return Err(format!("Skill load failed: {detail}"));
-                    }
-
-                    // Inspect the global scope to extract tool definitions (tools_list)
-                    extract_tools(&js_ctx, &state);
-
-                    Ok(())
-                })
-                .await;
-
-            if let Err(e) = init_result {
-                let mut s = state.write();
-                s.status = SkillStatus::Error;
-                s.error = Some(e.clone());
-                log::error!("[skill:{}] {e}", config.skill_id);
-                return;
-            }
-
-            // Restore previously saved authentication state from the data directory
-            restore_oauth_credential(&ctx, &config.skill_id, &data_dir).await;
-            restore_auth_credential(&ctx, &config.skill_id, &data_dir).await;
-            restore_client_key(&ctx, &config.skill_id, &data_dir).await;
-
-            // Trigger the `init()` lifecycle callback in the JS skill
-            if let Err(e) = call_lifecycle(&rt, &ctx, "init", None).await {
-                let mut s = state.write();
-                s.status = SkillStatus::Error;
-                s.error = Some(format!("init() failed: {e}"));
-                log::error!("[skill:{}] init() failed: {e}", config.skill_id);
-                return;
-            }
-
-            // Execute any microtasks or pending promises scheduled during init()
-            drive_jobs(&rt).await;
-
-            // Build the credential bag passed to `start(creds)`. We read the
-            // persisted credential files from disk so the skill receives the
-            // canonical view that matches what the bridges (`oauth`, `auth`)
-            // already see in JS land. If no creds are stored we still pass an
-            // explicit `{ oauth: null, auth: null }` so start() always has a
-            // well-defined shape — that is the whole point of this contract.
-            let start_args = build_start_credentials_arg(&data_dir);
-            log::info!(
-                "[skill:{}] Calling start() with credentials (oauth={}, auth={})",
-                config.skill_id,
-                !start_args.contains("\"oauth\":null"),
-                !start_args.contains("\"auth\":null"),
-            );
-
-            // Trigger the `start()` lifecycle callback
-            if let Err(e) = call_lifecycle(&rt, &ctx, "start", Some(&start_args)).await {
-                let mut s = state.write();
-                s.status = SkillStatus::Error;
-                s.error = Some(format!("start() failed: {e}"));
-                log::error!("[skill:{}] start() failed: {e}", config.skill_id);
-                return;
-            }
-
-            // Execute any microtasks or pending promises scheduled during start()
-            drive_jobs(&rt).await;
-
-            // Mark the skill as officially running
-            state.write().status = SkillStatus::Running;
-            log::info!("[skill:{}] Running (QuickJS)", config.skill_id);
-
-            // Execute an initial `onPing` call to verify the JS -> Bridge connection is healthy
-            match handle_js_call(&rt, &ctx, "onPing", "{}").await {
-                Ok(value) => {
-                    log::info!("[skill:{}] Initial ping result: {}", config.skill_id, value);
-                }
-                Err(e) => {
-                    log::warn!("[skill:{}] Initial ping failed: {}", config.skill_id, e);
-                }
-            }
-            drive_jobs(&rt).await;
-
-            // Hand over control to the main event loop which waits for system/RPC messages
-            run_event_loop(
-                &rt,
-                &ctx,
-                &mut rx,
-                &state,
-                &config.skill_id,
-                &timer_state,
-                &published_state,
-                deps.memory_client.clone(),
-                &data_dir,
-            )
-            .await;
-        })
-    }
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/js_handlers.rs b/src/openhuman/skills/qjs_skill_instance/js_handlers.rs
deleted file mode 100644
index 553d8e194..000000000
--- a/src/openhuman/skills/qjs_skill_instance/js_handlers.rs
+++ /dev/null
@@ -1,759 +0,0 @@
-//! Handlers for invoking JavaScript functions from the Rust host.
-//!
-//! This module provides a set of high-level functions to call into a skill's
-//! JavaScript environment. It handles the complexity of bridging between
-//! Rust's async model and QuickJS's execution model, including support for
-//! Promise-returning JS functions via a polling-based mechanism.
-
-use std::time::Duration;
-
-use crate::openhuman::skills::types::{ToolContent, ToolResult};
-
-use super::js_helpers::{drive_jobs, format_js_exception};
-
-/// Call a lifecycle function on the skill object.
-///
-/// Handles both synchronous and asynchronous (Promise-returning) lifecycle
-/// methods like `init`, `start`, and `stop`. If the JS function returns a Promise,
-/// this handler will poll for completion for up to 30 seconds.
-///
-/// `args_json` is a JavaScript expression injected as the first argument when
-/// calling the lifecycle function. Pass `None` to call the function with no
-/// arguments. Use this to forward credentials into `start(creds)`.
-pub(crate) async fn call_lifecycle(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    name: &str,
-    args_json: Option<&str>,
-) -> Result<(), String> {
-    let name = name.to_string();
-    // Default to no argument so existing call sites (init, stop) keep their
-    // current behavior. When args_json is supplied it must already be a valid
-    // JS expression (e.g. JSON or `null`).
-    let args_expr = args_json.unwrap_or("").to_string();
-
-    // First, try to initiate the call in the JS context
-    let is_promise = ctx
-        .with(|js_ctx| {
-            // JS wrapper to find and call the lifecycle function, handling both
-            // ESM-style exports and global definitions.
-            let code = format!(
-                r#"(function() {{
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || globalThis);
-                var fn = skill.{name} || globalThis.{name};
-                if (typeof fn === 'function') {{
-                    var result = fn.call(skill, {args_expr});
-                    if (result && typeof result.then === 'function') {{
-                        // Function returned a Promise, set up global tracking flags
-                        globalThis.__pendingLifecycleDone = false;
-                        globalThis.__pendingLifecycleError = undefined;
-                        result.then(
-                            function() {{ globalThis.__pendingLifecycleDone = true; }},
-                            function(e) {{
-                                globalThis.__pendingLifecycleError = e && e.message ? e.message : String(e);
-                                globalThis.__pendingLifecycleDone = true;
-                            }}
-                        );
-                        return "1";
-                    }}
-                }}
-                return "0";
-            }})()"#
-            );
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s == "1"),
-                Err(e) => {
-                    let detail = format_js_exception(&js_ctx, &e);
-                    Err(format!("{name}() failed: {detail}"))
-                }
-            }
-        })
-        .await?;
-
-    // If it was a Promise, poll the global flags until they indicate completion
-    if is_promise {
-        let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
-
-        loop {
-            // Must drive the QuickJS job queue to allow Promises to resolve
-            drive_jobs(rt).await;
-
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__pendingLifecycleDone === true")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                let error = ctx
-                    .with(|js_ctx| {
-                        let has_error = js_ctx
-                            .eval::<bool, _>(b"globalThis.__pendingLifecycleError !== undefined")
-                            .unwrap_or(false);
-                        let err = if has_error {
-                            Some(
-                                js_ctx
-                                    .eval::<String, _>(b"String(globalThis.__pendingLifecycleError)")
-                                    .unwrap_or_else(|_| "Unknown error".to_string()),
-                            )
-                        } else {
-                            None
-                        };
-                        // Clean up tracking flags
-                        let _ = js_ctx.eval::<rquickjs::Value, _>(
-                            b"delete globalThis.__pendingLifecycleDone; delete globalThis.__pendingLifecycleError;",
-                        );
-                        err
-                    })
-                    .await;
-
-                if let Some(err_msg) = error {
-                    return Err(format!("{name}() rejected: {err_msg}"));
-                }
-                return Ok(());
-            }
-
-            if tokio::time::Instant::now() >= deadline {
-                ctx.with(|js_ctx| {
-                    let _ = js_ctx.eval::<rquickjs::Value, _>(
-                        b"delete globalThis.__pendingLifecycleDone; delete globalThis.__pendingLifecycleError;",
-                    );
-                })
-                .await;
-                return Err(format!("{name}() timed out after 30s"));
-            }
-
-            // Yield control back to the executor before next poll
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-    }
-
-    Ok(())
-}
-
-/// Start an asynchronous tool call.
-///
-/// This function invokes the `execute()` method of a tool defined in JavaScript.
-///
-/// - If the tool is synchronous: returns `Ok(Some(ToolResult))` immediately.
-/// - If the tool is asynchronous: returns `Ok(None)`. The caller is responsible
-///   for polling `globalThis.__pendingToolDone` and eventually calling
-///   `read_pending_tool_result`.
-pub(crate) async fn start_async_tool_call(
-    ctx: &rquickjs::AsyncContext,
-    tool_name: &str,
-    arguments: serde_json::Value,
-) -> Result<Option<ToolResult>, String> {
-    log::info!(
-        "[tool_call] start_async_tool_call: tool='{}' args={}",
-        tool_name,
-        arguments
-    );
-
-    let args_str =
-        serde_json::to_string(&arguments).map_err(|e| format!("Failed to serialize args: {e}"))?;
-    let tool_name = tool_name.to_string();
-
-    let eval_result = ctx
-        .with(|js_ctx| {
-            // JS wrapper to find the tool by name and execute it with provided arguments.
-            let code = format!(
-                r#"(function() {{
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || null);
-                var tools = (skill && skill.tools) || globalThis.tools || [];
-                for (var i = 0; i < tools.length; i++) {{
-                    if (tools[i].name === "{}") {{
-                        var args = {};
-                        var result = tools[i].execute(args);
-                        if (result && typeof result.then === 'function') {{
-                            // Async tool: set up Promise tracking
-                            globalThis.__pendingToolResult = undefined;
-                            globalThis.__pendingToolError = undefined;
-                            globalThis.__pendingToolDone = false;
-                            result.then(
-                                function(v) {{
-                                    globalThis.__pendingToolResult = v;
-                                    globalThis.__pendingToolDone = true;
-                                }},
-                                function(e) {{
-                                    globalThis.__pendingToolError = e;
-                                    globalThis.__pendingToolDone = true;
-                                }}
-                            );
-                            return "__PROMISE__";
-                        }}
-                        // Sync tool: return serialized result
-                        if (result && typeof result === 'object') {{
-                            return JSON.stringify(result);
-                        }}
-                        return String(result);
-                    }}
-                }}
-                throw new Error("Tool '{}' not found");
-            }})()"#,
-                tool_name.replace('"', r#"\""#),
-                args_str,
-                tool_name.replace('"', r#"\""#),
-            );
-
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => {
-                    log::debug!(
-                        "[tool_call] JS eval succeeded: result_type={}",
-                        if s == "__PROMISE__" {
-                            "promise"
-                        } else {
-                            "sync"
-                        }
-                    );
-                    Ok(s)
-                }
-                Err(e) => {
-                    let detail = format_js_exception(&js_ctx, &e);
-                    log::error!("[tool_call] JS eval failed: {}", detail);
-                    Err(format!("Tool execution failed: {detail}"))
-                }
-            }
-        })
-        .await?;
-
-    if eval_result == "__PROMISE__" {
-        log::info!(
-            "[tool_call] tool '{}' returned Promise — async mode",
-            tool_name
-        );
-        Ok(None)
-    } else {
-        log::info!(
-            "[tool_call] tool '{}' returned sync result (len={})",
-            tool_name,
-            eval_result.len()
-        );
-        Ok(Some(ToolResult {
-            content: vec![ToolContent::Text { text: eval_result }],
-            is_error: false,
-        }))
-    }
-}
-
-/// Read the result of a completed async tool call from JS globals.
-///
-/// This should only be called after verifying that `globalThis.__pendingToolDone` is true.
-pub(crate) async fn read_pending_tool_result(
-    ctx: &rquickjs::AsyncContext,
-) -> Result<ToolResult, String> {
-    let result_text = ctx
-        .with(|js_ctx| {
-            // JS wrapper to extract the resolved value or error from tracking globals
-            let code = r#"(function() {
-                var err = globalThis.__pendingToolError;
-                globalThis.__pendingToolError = undefined;
-                globalThis.__pendingToolDone = false;
-                if (err !== undefined) {
-                    var msg = (typeof err === 'object' && err !== null && err.message)
-                        ? err.message
-                        : String(err);
-                    globalThis.__pendingToolResult = undefined;
-                    throw new Error(msg);
-                }
-                var r = globalThis.__pendingToolResult;
-                globalThis.__pendingToolResult = undefined;
-                if (r === undefined || r === null) return "null";
-                if (typeof r === 'object') return JSON.stringify(r);
-                return String(r);
-            })()"#;
-
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s),
-                Err(e) => {
-                    let detail = format_js_exception(&js_ctx, &e);
-                    Err(format!("Tool async execution failed: {detail}"))
-                }
-            }
-        })
-        .await?;
-
-    Ok(ToolResult {
-        content: vec![ToolContent::Text { text: result_text }],
-        is_error: false,
-    })
-}
-
-/// Handle a server-sent event targeted at the skill.
-///
-/// Invokes the `onServerEvent` handler in JS. Supports async handlers.
-pub(crate) async fn handle_server_event(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    event: &str,
-    data: serde_json::Value,
-) -> Result<(), String> {
-    let data_str = serde_json::to_string(&data).unwrap_or_else(|_| "null".to_string());
-    let event = event.to_string();
-
-    let is_promise = ctx
-        .with(|js_ctx| {
-            let code = format!(
-                r#"(function() {{
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || globalThis);
-                var fn = skill.onServerEvent || globalThis.onServerEvent;
-                if (typeof fn === 'function') {{
-                    var result = fn.call(skill, "{}", {});
-                    if (result && typeof result.then === 'function') {{
-                        globalThis.__pendingEventDone = false;
-                        globalThis.__pendingEventError = undefined;
-                        result.then(
-                            function() {{ globalThis.__pendingEventDone = true; }},
-                            function(e) {{
-                                globalThis.__pendingEventError = e && e.message ? e.message : String(e);
-                                globalThis.__pendingEventDone = true;
-                            }}
-                        );
-                        return "1";
-                    }}
-                }}
-                return "0";
-            }})()"#,
-                event.replace('"', r#"\""#),
-                data_str,
-            );
-
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s == "1"),
-                Err(e) => Err(format!("Event handler failed: {e}")),
-            }
-        })
-        .await?;
-
-    if is_promise {
-        let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
-
-        loop {
-            drive_jobs(rt).await;
-
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__pendingEventDone === true")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                let error = ctx
-                    .with(|js_ctx| {
-                        let has_error = js_ctx
-                            .eval::<bool, _>(b"globalThis.__pendingEventError !== undefined")
-                            .unwrap_or(false);
-                        let err = if has_error {
-                            Some(
-                                js_ctx
-                                    .eval::<String, _>(b"String(globalThis.__pendingEventError)")
-                                    .unwrap_or_else(|_| "Unknown error".to_string()),
-                            )
-                        } else {
-                            None
-                        };
-                        let _ = js_ctx.eval::<rquickjs::Value, _>(
-                            b"delete globalThis.__pendingEventDone; delete globalThis.__pendingEventError;",
-                        );
-                        err
-                    })
-                    .await;
-
-                if let Some(err_msg) = error {
-                    return Err(format!("onServerEvent() rejected: {err_msg}"));
-                }
-                return Ok(());
-            }
-
-            if tokio::time::Instant::now() >= deadline {
-                ctx.with(|js_ctx| {
-                    let _ = js_ctx.eval::<rquickjs::Value, _>(
-                        b"delete globalThis.__pendingEventDone; delete globalThis.__pendingEventError;",
-                    );
-                })
-                .await;
-                return Err("onServerEvent() timed out after 30s".to_string());
-            }
-
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-    }
-
-    Ok(())
-}
-
-/// Handle a scheduled cron trigger.
-///
-/// Invokes the `onCronTrigger` handler in JS. Supports async handlers.
-pub(crate) async fn handle_cron_trigger(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    schedule_id: &str,
-) -> Result<(), String> {
-    let schedule_id = schedule_id.to_string();
-
-    let is_promise = ctx
-        .with(|js_ctx| {
-            let code = format!(
-                r#"(function() {{
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || globalThis);
-                var fn = skill.onCronTrigger || globalThis.onCronTrigger;
-                if (typeof fn === 'function') {{
-                    var result = fn.call(skill, "{}");
-                    if (result && typeof result.then === 'function') {{
-                        globalThis.__pendingCronDone = false;
-                        globalThis.__pendingCronError = undefined;
-                        result.then(
-                            function() {{ globalThis.__pendingCronDone = true; }},
-                            function(e) {{
-                                globalThis.__pendingCronError = e && e.message ? e.message : String(e);
-                                globalThis.__pendingCronDone = true;
-                            }}
-                        );
-                        return "1";
-                    }}
-                }}
-                return "0";
-            }})()"#,
-                schedule_id.replace('"', r#"\""#),
-            );
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s == "1"),
-                Err(e) => Err(format!("Cron trigger failed: {e}")),
-            }
-        })
-        .await?;
-
-    if is_promise {
-        let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
-
-        loop {
-            drive_jobs(rt).await;
-
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__pendingCronDone === true")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                let error = ctx
-                    .with(|js_ctx| {
-                        let has_error = js_ctx
-                            .eval::<bool, _>(b"globalThis.__pendingCronError !== undefined")
-                            .unwrap_or(false);
-                        let err = if has_error {
-                            Some(
-                                js_ctx
-                                    .eval::<String, _>(b"String(globalThis.__pendingCronError)")
-                                    .unwrap_or_else(|_| "Unknown error".to_string()),
-                            )
-                        } else {
-                            None
-                        };
-                        let _ = js_ctx.eval::<rquickjs::Value, _>(
-                            b"delete globalThis.__pendingCronDone; delete globalThis.__pendingCronError;",
-                        );
-                        err
-                    })
-                    .await;
-
-                if let Some(err_msg) = error {
-                    return Err(format!("onCronTrigger() rejected: {err_msg}"));
-                }
-                return Ok(());
-            }
-
-            if tokio::time::Instant::now() >= deadline {
-                ctx.with(|js_ctx| {
-                    let _ = js_ctx.eval::<rquickjs::Value, _>(
-                        b"delete globalThis.__pendingCronDone; delete globalThis.__pendingCronError;",
-                    );
-                })
-                .await;
-                return Err("onCronTrigger() timed out after 30s".to_string());
-            }
-
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-    }
-
-    Ok(())
-}
-
-/// Call a JS function on the skill object that returns a JSON value.
-///
-/// Used for generic RPC methods. Supports both synchronous and asynchronous functions.
-pub(crate) async fn handle_js_call(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    fn_name: &str,
-    args_json: &str,
-) -> Result<serde_json::Value, String> {
-    let fn_name = fn_name.to_string();
-    let args_json = args_json.to_string();
-
-    let result_text = ctx
-        .with(|js_ctx| {
-            let code = format!(
-                r#"(function() {{
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || globalThis);
-                var fn = skill.{fn_name} || globalThis.{fn_name};
-                if (typeof fn === 'function') {{
-                    var result = fn.call(skill, {args_json});
-                    if (result && typeof result.then === 'function') {{
-                        globalThis.__pendingRpcResult = undefined;
-                        globalThis.__pendingRpcError = undefined;
-                        globalThis.__pendingRpcDone = false;
-                        result.then(
-                            function(v) {{
-                                globalThis.__pendingRpcResult = v;
-                                globalThis.__pendingRpcDone = true;
-                            }},
-                            function(e) {{
-                                globalThis.__pendingRpcError = e && e.message ? e.message : String(e);
-                                globalThis.__pendingRpcDone = true;
-                            }}
-                        );
-                        return "__PROMISE__";
-                    }}
-                    return JSON.stringify(result === undefined ? null : result);
-                }}
-                return "null";
-            }})()"#
-            );
-
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s),
-                Err(e) => {
-                    let detail = format_js_exception(&js_ctx, &e);
-                    Err(format!("{fn_name}() failed: {detail}"))
-                }
-            }
-        })
-        .await?;
-
-    if result_text == "__PROMISE__" {
-        log::info!("[handle_js_call] {fn_name}() returned Promise, polling for resolution");
-
-        let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
-        let mut poll_count: u32 = 0;
-
-        loop {
-            // Drive the QuickJS job queue to process microtasks and promise resolutions
-            drive_jobs(rt).await;
-            poll_count += 1;
-
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__pendingRpcDone === true")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                log::info!("[handle_js_call] {fn_name}() resolved after {poll_count} polls");
-                let result = ctx
-                    .with(|js_ctx| {
-                        let has_error = js_ctx
-                            .eval::<bool, _>(b"globalThis.__pendingRpcError !== undefined")
-                            .unwrap_or(false);
-
-                        let val = if has_error {
-                            let err_msg = js_ctx
-                                .eval::<String, _>(b"String(globalThis.__pendingRpcError)")
-                                .unwrap_or_else(|_| "Unknown error".to_string());
-                            Err(format!("{fn_name}() rejected: {err_msg}"))
-                        } else {
-                            let json_str = js_ctx
-                                .eval::<String, _>(
-                                    b"JSON.stringify(globalThis.__pendingRpcResult === undefined ? null : globalThis.__pendingRpcResult)"
-                                )
-                                .unwrap_or_else(|_| "null".to_string());
-                            Ok(json_str)
-                        };
-
-                        // Clean up globals
-                        let _ = js_ctx.eval::<rquickjs::Value, _>(
-                            b"delete globalThis.__pendingRpcDone; delete globalThis.__pendingRpcResult; delete globalThis.__pendingRpcError;",
-                        );
-                        val
-                    })
-                    .await;
-
-                return match result {
-                    Ok(json_str) => serde_json::from_str(&json_str)
-                        .map_err(|e| format!("{fn_name}() returned invalid JSON: {e}")),
-                    Err(e) => Err(e),
-                };
-            }
-
-            if tokio::time::Instant::now() >= deadline {
-                log::error!(
-                    "[handle_js_call] {fn_name}() TIMED OUT after 30s ({poll_count} polls). \
-                     Promise never resolved — likely a stalled microtask or unhandled async error."
-                );
-                // Dump JS state for debugging
-                let debug_info = ctx
-                    .with(|js_ctx| {
-                        js_ctx
-                            .eval::<String, _>(
-                                b"JSON.stringify({ pendingDone: globalThis.__pendingRpcDone, pendingResult: typeof globalThis.__pendingRpcResult, pendingError: globalThis.__pendingRpcError })"
-                            )
-                            .unwrap_or_else(|_| "eval failed".to_string())
-                    })
-                    .await;
-                log::error!("[handle_js_call] {fn_name}() debug state: {debug_info}");
-
-                ctx.with(|js_ctx| {
-                    let _ = js_ctx.eval::<rquickjs::Value, _>(
-                        b"delete globalThis.__pendingRpcDone; delete globalThis.__pendingRpcResult; delete globalThis.__pendingRpcError;",
-                    );
-                })
-                .await;
-                return Err(format!("{fn_name}() timed out after 30s"));
-            }
-
-            // Log progress every 2 seconds so we can see if the loop is running
-            if poll_count.is_multiple_of(400) {
-                let elapsed = 30
-                    - deadline
-                        .duration_since(tokio::time::Instant::now())
-                        .as_secs();
-                log::warn!(
-                    "[handle_js_call] {fn_name}() still waiting after ~{elapsed}s ({poll_count} polls)"
-                );
-            }
-
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-    } else {
-        serde_json::from_str(&result_text)
-            .map_err(|e| format!("{fn_name}() returned invalid JSON: {e}"))
-    }
-}
-
-/// Call a JS function on the skill object that returns void.
-///
-/// Used for generic RPC notifications. Supports both synchronous and asynchronous functions.
-pub(crate) async fn handle_js_void_call(
-    rt: &rquickjs::AsyncRuntime,
-    ctx: &rquickjs::AsyncContext,
-    fn_name: &str,
-    args_json: &str,
-) -> Result<(), String> {
-    let fn_name = fn_name.to_string();
-    let args_json = args_json.to_string();
-
-    let is_promise = ctx
-        .with(|js_ctx| {
-            let code = format!(
-                r#"(function() {{
-                var skill = globalThis.__skill && globalThis.__skill.default
-                    ? globalThis.__skill.default
-                    : (globalThis.__skill || globalThis);
-                var fn = skill.{fn_name} || globalThis.{fn_name};
-                if (typeof fn === 'function') {{
-                    var result = fn.call(skill, {args_json});
-                    if (result && typeof result.then === 'function') {{
-                        globalThis.__pendingRpcVoidDone = false;
-                        globalThis.__pendingRpcVoidError = undefined;
-                        result.then(
-                            function() {{ globalThis.__pendingRpcVoidDone = true; }},
-                            function(e) {{
-                                globalThis.__pendingRpcVoidError = e && e.message ? e.message : String(e);
-                                globalThis.__pendingRpcVoidDone = true;
-                            }}
-                        );
-                        return "1";
-                    }}
-                }}
-                return "0";
-            }})()"#
-            );
-
-            match js_ctx.eval::<String, _>(code.as_bytes()) {
-                Ok(s) => Ok(s == "1"),
-                Err(e) => {
-                    let detail = format_js_exception(&js_ctx, &e);
-                    Err(format!("{fn_name}() failed: {detail}"))
-                }
-            }
-        })
-        .await?;
-
-    if is_promise {
-        let deadline = tokio::time::Instant::now() + Duration::from_secs(30);
-
-        loop {
-            drive_jobs(rt).await;
-
-            let done = ctx
-                .with(|js_ctx| {
-                    js_ctx
-                        .eval::<bool, _>(b"globalThis.__pendingRpcVoidDone === true")
-                        .unwrap_or(false)
-                })
-                .await;
-
-            if done {
-                let error = ctx
-                    .with(|js_ctx| {
-                        let has_error = js_ctx
-                            .eval::<bool, _>(b"globalThis.__pendingRpcVoidError !== undefined")
-                            .unwrap_or(false);
-                        let err = if has_error {
-                            Some(
-                                js_ctx
-                                    .eval::<String, _>(b"String(globalThis.__pendingRpcVoidError)")
-                                    .unwrap_or_else(|_| "Unknown error".to_string()),
-                            )
-                        } else {
-                            None
-                        };
-                        let _ = js_ctx.eval::<rquickjs::Value, _>(
-                            b"delete globalThis.__pendingRpcVoidDone; delete globalThis.__pendingRpcVoidError;",
-                        );
-                        err
-                    })
-                    .await;
-
-                if let Some(err_msg) = error {
-                    return Err(format!("{fn_name}() rejected: {err_msg}"));
-                }
-                return Ok(());
-            }
-
-            if tokio::time::Instant::now() >= deadline {
-                ctx.with(|js_ctx| {
-                    let _ = js_ctx.eval::<rquickjs::Value, _>(
-                        b"delete globalThis.__pendingRpcVoidDone; delete globalThis.__pendingRpcVoidError;",
-                    );
-                })
-                .await;
-                return Err(format!("{fn_name}() timed out after 30s"));
-            }
-
-            tokio::time::sleep(Duration::from_millis(5)).await;
-        }
-    }
-
-    Ok(())
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/js_helpers.rs b/src/openhuman/skills/qjs_skill_instance/js_helpers.rs
deleted file mode 100644
index eef631628..000000000
--- a/src/openhuman/skills/qjs_skill_instance/js_helpers.rs
+++ /dev/null
@@ -1,246 +0,0 @@
-//! Helper functions for the QuickJS skill runtime.
-//!
-//! This module provides utility functions for error formatting, job queue
-//! management, tool discovery, and state restoration (e.g., credentials).
-
-use std::sync::Arc;
-
-use parking_lot::RwLock;
-
-use crate::openhuman::skills::types::ToolDefinition;
-
-use super::types::SkillState;
-
-/// Extract a human-readable error message from a QuickJS exception.
-///
-/// When `rquickjs` returns `Error::Exception`, the actual JS error object
-/// is stored in the context and must be retrieved using `Ctx::catch()`.
-/// This function attempts to extract the `.message` and `.stack` properties
-/// from the exception object, falling back to a string representation if they are missing.
-pub(crate) fn format_js_exception(js_ctx: &rquickjs::Ctx<'_>, err: &rquickjs::Error) -> String {
-    if !err.is_exception() {
-        return format!("{err}");
-    }
-
-    let exception = js_ctx.catch();
-
-    // Try to get .message and .stack from the exception object
-    if let Some(obj) = exception.as_object() {
-        let message: String = obj.get::<_, String>("message").unwrap_or_default();
-        let stack: String = obj.get::<_, String>("stack").unwrap_or_default();
-
-        if !message.is_empty() {
-            if !stack.is_empty() {
-                return format!("{message}\n{stack}");
-            }
-            return message;
-        }
-    }
-
-    // Fallback: try to stringify the exception value directly
-    if let Ok(s) = exception.get::<String>() {
-        return s;
-    }
-
-    format!("{err}")
-}
-
-/// Drive the QuickJS job queue until no more jobs are pending.
-///
-/// This is essential for progressing asynchronous operations like Promises
-/// within the JavaScript environment. It calls `rt.idle()` which blocks
-/// the current task until all pending JS jobs have been processed.
-pub(crate) async fn drive_jobs(rt: &rquickjs::AsyncRuntime) {
-    // idle() runs all pending futures and jobs
-    rt.idle().await;
-}
-
-/// Extract tool definitions from the loaded skill.
-///
-/// This function inspects the `globalThis.__skill` or `globalThis.tools`
-/// to find exposed tool definitions (name, description, schema) and updates
-/// the instance's shared `SkillState`.
-pub(crate) fn extract_tools(js_ctx: &rquickjs::Ctx<'_>, state: &Arc<RwLock<SkillState>>) {
-    let code = r#"
-        (function() {
-            var skill = globalThis.__skill && globalThis.__skill.default
-                ? globalThis.__skill.default
-                : (globalThis.__skill || null);
-            var tools = (skill && skill.tools) || globalThis.tools || [];
-            return JSON.stringify(tools.map(function(t) {
-                return {
-                    name: t.name || "",
-                    description: t.description || "",
-                    inputSchema: t.inputSchema || t.input_schema || {}
-                };
-            }));
-        })()
-    "#;
-
-    // eval with String type hint tells rquickjs to convert the result to a Rust String
-    match js_ctx.eval::<String, _>(code) {
-        Ok(json_str) => match serde_json::from_str::<Vec<ToolDefinition>>(&json_str) {
-            Ok(tools) => {
-                state.write().tools = tools;
-            }
-            Err(e) => {
-                log::warn!("[tools] Failed to parse tools JSON: {e}");
-            }
-        },
-        Err(e) => {
-            log::warn!("[tools] Failed to extract tools: {e}");
-        }
-    }
-}
-
-/// Load a persisted OAuth credential from the skill's data directory and inject it.
-///
-/// Reads `{data_dir}/oauth_credential.json` and injects it into both the
-/// `oauth` bridge and the in-memory state so that tools have immediate access.
-pub(crate) async fn restore_oauth_credential(
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    data_dir: &std::path::Path,
-) {
-    let cred_path = data_dir.join("oauth_credential.json");
-    let cred_json = match std::fs::read_to_string(&cred_path) {
-        Ok(s) if !s.is_empty() => s,
-        _ => return,
-    };
-
-    // Inject credential into both oauth bridge and in-memory state
-    let code = format!(
-        r#"(function() {{
-            var cred = {cred};
-            if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {{
-                globalThis.oauth.__setCredential(cred);
-            }}
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                globalThis.state.set('__oauth_credential', cred);
-            }}
-            return true;
-        }})()"#,
-        cred = cred_json
-    );
-
-    let restored = ctx
-        .with(|js_ctx| js_ctx.eval::<bool, _>(code.as_bytes()).unwrap_or(false))
-        .await;
-
-    if restored {
-        log::info!(
-            "[skill:{}] Restored OAuth credential from {}",
-            skill_id,
-            cred_path.display()
-        );
-    }
-}
-
-/// Load a persisted client key share and inject it into the JS context.
-///
-/// This key is required for encrypted proxy requests via the `oauth.fetch()` API.
-pub(crate) async fn restore_client_key(
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    data_dir: &std::path::Path,
-) {
-    let key_path = data_dir.join("client_key.json");
-    let key_json = match std::fs::read_to_string(&key_path) {
-        Ok(s) if !s.is_empty() => s,
-        _ => return,
-    };
-
-    // Parse the stored JSON to extract the base64 key string
-    let key_str = match serde_json::from_str::<serde_json::Value>(&key_json) {
-        Ok(v) => v
-            .get("clientKey")
-            .and_then(|k| k.as_str())
-            .unwrap_or("")
-            .to_string(),
-        Err(_) => return,
-    };
-    if key_str.is_empty() {
-        return;
-    }
-
-    let code = format!(
-        r#"(function() {{
-            globalThis.__oauthClientKey = "{key}";
-            return true;
-        }})()"#,
-        key = key_str
-    );
-
-    let restored = ctx
-        .with(|js_ctx| js_ctx.eval::<bool, _>(code.as_bytes()).unwrap_or(false))
-        .await;
-
-    if restored {
-        log::info!(
-            "[skill:{}] Restored client key share from {}",
-            skill_id,
-            key_path.display()
-        );
-    }
-}
-
-/// Load a persisted auth credential and inject it into the JS context.
-///
-/// Handles both standard auth and "managed" mode, where it also bridges to
-/// the OAuth credential system for backward compatibility.
-pub(crate) async fn restore_auth_credential(
-    ctx: &rquickjs::AsyncContext,
-    skill_id: &str,
-    data_dir: &std::path::Path,
-) {
-    let cred_path = data_dir.join("auth_credential.json");
-    let cred_json = match std::fs::read_to_string(&cred_path) {
-        Ok(s) if !s.is_empty() => s,
-        _ => return,
-    };
-
-    // Inject credential into auth bridge and in-memory state.
-    // For managed mode, also bridge to the oauth credential system.
-    let code = format!(
-        r#"(function() {{
-            var cred = {cred};
-            if (typeof globalThis.auth !== 'undefined' && globalThis.auth.__setCredential) {{
-                globalThis.auth.__setCredential(cred);
-            }}
-            if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                globalThis.state.set('__auth_credential', cred);
-            }}
-            // For managed mode, bridge to oauth system for backward compat.
-            // For non-managed modes, clear any stale oauth credentials.
-            if (cred && cred.mode === 'managed' && cred.credentials) {{
-                if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {{
-                    globalThis.oauth.__setCredential(cred.credentials);
-                }}
-                if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                    globalThis.state.set('__oauth_credential', cred.credentials);
-                }}
-            }} else {{
-                if (typeof globalThis.oauth !== 'undefined' && globalThis.oauth.__setCredential) {{
-                    globalThis.oauth.__setCredential(null);
-                }}
-                if (typeof globalThis.state !== 'undefined' && globalThis.state.set) {{
-                    globalThis.state.set('__oauth_credential', null);
-                }}
-            }}
-            return true;
-        }})()"#,
-        cred = cred_json
-    );
-
-    let restored = ctx
-        .with(|js_ctx| js_ctx.eval::<bool, _>(code.as_bytes()).unwrap_or(false))
-        .await;
-
-    if restored {
-        log::info!(
-            "[skill:{}] Restored auth credential from {}",
-            skill_id,
-            cred_path.display()
-        );
-    }
-}
diff --git a/src/openhuman/skills/qjs_skill_instance/mod.rs b/src/openhuman/skills/qjs_skill_instance/mod.rs
deleted file mode 100644
index b29a2483d..000000000
--- a/src/openhuman/skills/qjs_skill_instance/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! QuickJS Skill Instance management.
-//!
-//! This module provides the infrastructure to run OpenHuman skills within an isolated
-//! QuickJS JavaScript environment. Each skill runs in its own dedicated context,
-//! with restricted access to system resources via a set of native "ops" (bridges).
-//!
-//! Key characteristics of the QuickJS runtime:
-//! - Contexts are `Send + Sync`, allowing for efficient use of `tokio::spawn`.
-//! - Lightweight memory footprint per instance (~1-2MB).
-//! - Direct memory and stack limits can be applied per instance.
-//! - Asynchronous execution model integrated with the Rust event loop.
-
-mod event_loop;
-mod instance;
-mod js_handlers;
-mod js_helpers;
-mod types;
-
-pub use types::{BridgeDeps, QjsSkillInstance, SkillState};
diff --git a/src/openhuman/skills/qjs_skill_instance/types.rs b/src/openhuman/skills/qjs_skill_instance/types.rs
deleted file mode 100644
index c1135b322..000000000
--- a/src/openhuman/skills/qjs_skill_instance/types.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! Type definitions for the QuickJS skill instance.
-//!
-//! This module defines the core data structures used by the QuickJS skill runtime,
-//! including shared state, dependencies, and the main instance handle.
-
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use parking_lot::RwLock;
-use tokio::sync::mpsc;
-
-use crate::openhuman::skills::cron_scheduler::CronScheduler;
-use crate::openhuman::skills::skill_registry::SkillRegistry;
-use crate::openhuman::skills::types::{SkillConfig, SkillMessage, SkillStatus, ToolDefinition};
-
-/// Dependencies passed to a skill instance during initialization.
-///
-/// These resources are used to set up the native "ops" (bridges) that allow
-/// the JavaScript environment to interact with the host system.
-pub struct BridgeDeps {
-    /// Global scheduler for periodic tasks.
-    pub cron_scheduler: Arc<CronScheduler>,
-    /// Access to the global skill registry.
-    pub skill_registry: Arc<SkillRegistry>,
-    /// Client for interacting with the OpenHuman memory system.
-    pub memory_client: Option<crate::openhuman::memory::MemoryClientRef>,
-    /// Router for incoming webhooks targeted at skills.
-    pub webhook_router: Option<Arc<crate::openhuman::webhooks::WebhookRouter>>,
-    /// Base directory where the skill can store persistent data.
-    pub data_dir: PathBuf,
-}
-
-/// Shared mutable state for a single skill instance.
-///
-/// This state is accessed by both the Rust host and the JavaScript runtime.
-pub struct SkillState {
-    /// Current lifecycle status (Initializing, Running, Error, etc.).
-    pub status: SkillStatus,
-    /// List of tools exposed by this skill to the LLM/system.
-    pub tools: Vec<ToolDefinition>,
-    /// Last error message, if status is `Error`.
-    pub error: Option<String>,
-    /// Arbitrary state published by the skill for UI or system use.
-    pub published_state: HashMap<String, serde_json::Value>,
-}
-
-impl Default for SkillState {
-    fn default() -> Self {
-        Self {
-            status: SkillStatus::Pending,
-            tools: Vec::new(),
-            error: None,
-            published_state: HashMap::new(),
-        }
-    }
-}
-
-/// A handle to a running QuickJS skill instance.
-///
-/// It encapsulates the configuration, shared state, and a communication
-/// channel to the instance's background task.
-pub struct QjsSkillInstance {
-    /// Static configuration for the skill (ID, name, entry point, etc.).
-    pub config: SkillConfig,
-    /// Thread-safe reference to the instance's mutable state.
-    pub state: Arc<RwLock<SkillState>>,
-    /// Channel used to send messages (e.g., sync, tool calls) to the background task.
-    pub sender: mpsc::Sender<SkillMessage>,
-    /// Path to the directory containing the skill's source bundle.
-    pub skill_dir: PathBuf,
-    /// Path to the directory where the skill stores its persistent data.
-    pub data_dir: PathBuf,
-}
diff --git a/src/openhuman/skills/quickjs_libs/bootstrap.js b/src/openhuman/skills/quickjs_libs/bootstrap.js
deleted file mode 100644
index 97aeba296..000000000
--- a/src/openhuman/skills/quickjs_libs/bootstrap.js
+++ /dev/null
@@ -1,1366 +0,0 @@
-/**
- * Bootstrap JavaScript for QuickJS Runtime
- *
- * Provides browser-like API shims for skill execution.
- * These shims call Rust "ops" for actual I/O.
- */
-
-// Make globalThis.self and globalThis.window point to globalThis
-globalThis.self = globalThis;
-globalThis.window = globalThis;
-
-// ============================================================================
-// Console (uses Rust logging)
-// ============================================================================
-globalThis.console = {
-  log: function (...args) {
-    __ops.console_log(args.map(String).join(" "));
-  },
-  info: function (...args) {
-    __ops.console_log(args.map(String).join(" "));
-  },
-  warn: function (...args) {
-    __ops.console_warn(args.map(String).join(" "));
-  },
-  error: function (...args) {
-    __ops.console_error(args.map(String).join(" "));
-  },
-  debug: function (...args) {
-    __ops.console_log("[DEBUG] " + args.map(String).join(" "));
-  },
-};
-
-// ============================================================================
-// Timers (setTimeout, setInterval, clearTimeout, clearInterval)
-// ============================================================================
-const timerCallbacks = new Map();
-let nextTimerId = 1;
-
-globalThis.setTimeout = function (callback, delay, ...args) {
-  const id = nextTimerId++;
-  timerCallbacks.set(id, { callback, args, type: "timeout" });
-  __ops.timer_start(id, delay || 0, false);
-  return id;
-};
-
-globalThis.setInterval = function (callback, delay, ...args) {
-  const id = nextTimerId++;
-  timerCallbacks.set(id, { callback, args, type: "interval" });
-  __ops.timer_start(id, delay || 0, true);
-  return id;
-};
-
-globalThis.clearTimeout = function (id) {
-  timerCallbacks.delete(id);
-  __ops.timer_cancel(id);
-};
-
-globalThis.clearInterval = function (id) {
-  timerCallbacks.delete(id);
-  __ops.timer_cancel(id);
-};
-
-// Timer callback handler (called from Rust)
-globalThis.__handleTimer = function (id) {
-  const timer = timerCallbacks.get(id);
-  if (timer) {
-    if (timer.type === "timeout") {
-      timerCallbacks.delete(id);
-    }
-    try {
-      timer.callback.apply(null, timer.args);
-    } catch (e) {
-      console.error("Timer callback error:", e);
-    }
-  }
-};
-
-// ============================================================================
-// AbortController / AbortSignal Polyfill
-// ============================================================================
-class AbortSignal {
-  constructor() {
-    this.aborted = false;
-    this.reason = undefined;
-    this._listeners = [];
-  }
-
-  addEventListener(type, listener) {
-    if (type === "abort") {
-      this._listeners.push(listener);
-    }
-  }
-
-  removeEventListener(type, listener) {
-    if (type === "abort") {
-      const idx = this._listeners.indexOf(listener);
-      if (idx >= 0) this._listeners.splice(idx, 1);
-    }
-  }
-
-  throwIfAborted() {
-    if (this.aborted) {
-      throw this.reason || new Error("Aborted");
-    }
-  }
-}
-
-class AbortController {
-  constructor() {
-    this.signal = new AbortSignal();
-  }
-
-  abort(reason) {
-    if (!this.signal.aborted) {
-      this.signal.aborted = true;
-      this.signal.reason = reason || new Error("Aborted");
-      for (const listener of this.signal._listeners) {
-        try {
-          listener({ type: "abort", target: this.signal });
-        } catch (e) {
-          console.error("AbortController listener error:", e);
-        }
-      }
-    }
-  }
-}
-
-globalThis.AbortController = AbortController;
-globalThis.AbortSignal = AbortSignal;
-
-// ============================================================================
-// Fetch API
-// ============================================================================
-globalThis.fetch = function (url, options) {
-  options = options || {};
-  var method = options.method || "GET";
-  var headers = options.headers || {};
-  var body = options.body || null;
-
-  // Convert Headers object to plain object if needed
-  var headersObj = {};
-  if (headers instanceof Headers) {
-    headers.forEach(function (value, key) {
-      headersObj[key] = value;
-    });
-  } else {
-    headersObj = headers;
-  }
-
-  // __ops.fetch expects a JSON string for options (not a JS object)
-  var resultJson = __ops.fetch(
-    url.toString(),
-    JSON.stringify({
-      method: method,
-      headers: headersObj,
-      body:
-        typeof body === "string" ? body : body ? JSON.stringify(body) : null,
-    }),
-  );
-
-  // __ops.fetch returns a JSON string — parse it to access status/headers/body
-  var parsed = JSON.parse(resultJson);
-
-  return new Response(parsed.body, {
-    status: parsed.status,
-    statusText: parsed.statusText || "",
-    headers: new Headers(parsed.headers || {}),
-  });
-};
-
-// Response class for fetch
-class Response {
-  constructor(body, init = {}) {
-    this._body = body;
-    this.status = init.status || 200;
-    this.statusText = init.statusText || "";
-    this.headers = init.headers || new Headers();
-    this.ok = this.status >= 200 && this.status < 300;
-  }
-
-  text() {
-    return this._body;
-  }
-
-  json() {
-    return JSON.parse(this._body);
-  }
-
-  arrayBuffer() {
-    var encoder = new TextEncoder();
-    return encoder.encode(this._body).buffer;
-  }
-
-  blob() {
-    throw new Error("Blob not supported");
-  }
-}
-
-// Headers class for fetch
-class Headers {
-  constructor(init = {}) {
-    this._headers = {};
-    if (init) {
-      if (typeof init.forEach === "function") {
-        init.forEach((value, key) => {
-          this._headers[key.toLowerCase()] = value;
-        });
-      } else {
-        Object.entries(init).forEach(([key, value]) => {
-          this._headers[key.toLowerCase()] = value;
-        });
-      }
-    }
-  }
-
-  get(name) {
-    return this._headers[name.toLowerCase()] || null;
-  }
-
-  set(name, value) {
-    this._headers[name.toLowerCase()] = value;
-  }
-
-  has(name) {
-    return name.toLowerCase() in this._headers;
-  }
-
-  delete(name) {
-    delete this._headers[name.toLowerCase()];
-  }
-
-  forEach(callback) {
-    Object.entries(this._headers).forEach(([key, value]) => {
-      callback(value, key, this);
-    });
-  }
-}
-
-globalThis.Response = Response;
-globalThis.Headers = Headers;
-
-// ============================================================================
-// WebSocket API
-// ============================================================================
-class WebSocket {
-  static CONNECTING = 0;
-  static OPEN = 1;
-  static CLOSING = 2;
-  static CLOSED = 3;
-
-  constructor(url, protocols) {
-    this.url = url;
-    this.protocols = protocols;
-    this.readyState = WebSocket.CONNECTING;
-    this.binaryType = "blob";
-    this._id = null;
-
-    // Event handlers
-    this.onopen = null;
-    this.onclose = null;
-    this.onerror = null;
-    this.onmessage = null;
-
-    // Connect asynchronously
-    this._connect();
-  }
-
-  async _connect() {
-    try {
-      this._id = await __ops.ws_connect(this.url);
-      this.readyState = WebSocket.OPEN;
-
-      // Register for message callbacks
-      WebSocket._instances.set(this._id, this);
-
-      if (this.onopen) {
-        this.onopen({ type: "open", target: this });
-      }
-
-      // Start receiving messages
-      this._startReceiving();
-    } catch (e) {
-      this.readyState = WebSocket.CLOSED;
-      if (this.onerror) {
-        this.onerror({ type: "error", error: e, target: this });
-      }
-    }
-  }
-
-  async _startReceiving() {
-    while (this.readyState === WebSocket.OPEN) {
-      try {
-        const message = await __ops.ws_recv(this._id);
-        if (message === null) {
-          // Connection closed
-          this._handleClose(1000, "");
-          break;
-        }
-
-        if (this.onmessage) {
-          this.onmessage({ type: "message", data: message, target: this });
-        }
-      } catch (e) {
-        if (this.readyState === WebSocket.OPEN) {
-          this._handleClose(1006, e.toString());
-        }
-        break;
-      }
-    }
-  }
-
-  _handleClose(code, reason) {
-    this.readyState = WebSocket.CLOSED;
-    WebSocket._instances.delete(this._id);
-
-    if (this.onclose) {
-      this.onclose({
-        type: "close",
-        code,
-        reason,
-        wasClean: code === 1000,
-        target: this,
-      });
-    }
-  }
-
-  send(data) {
-    if (this.readyState !== WebSocket.OPEN) {
-      throw new Error("WebSocket is not open");
-    }
-
-    const dataStr = typeof data === "string" ? data : JSON.stringify(data);
-    __ops.ws_send(this._id, dataStr);
-  }
-
-  close(code = 1000, reason = "") {
-    if (
-      this.readyState === WebSocket.CLOSING ||
-      this.readyState === WebSocket.CLOSED
-    ) {
-      return;
-    }
-
-    this.readyState = WebSocket.CLOSING;
-    __ops.ws_close(this._id, code, reason);
-  }
-}
-
-WebSocket._instances = new Map();
-globalThis.WebSocket = WebSocket;
-
-// ============================================================================
-// IndexedDB API (persistent local storage)
-// ============================================================================
-class IDBFactory {
-  open(name, version = 1) {
-    return new IDBOpenDBRequest(name, version);
-  }
-
-  deleteDatabase(name) {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        await __ops.idb_delete_database(name);
-        request._success(undefined);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-}
-
-class IDBRequest {
-  constructor() {
-    this.result = undefined;
-    this.error = null;
-    this.readyState = "pending";
-    this.onsuccess = null;
-    this.onerror = null;
-  }
-
-  _success(result) {
-    this.result = result;
-    this.readyState = "done";
-    if (this.onsuccess) {
-      this.onsuccess({ type: "success", target: this });
-    }
-  }
-
-  _error(error) {
-    this.error = error;
-    this.readyState = "done";
-    if (this.onerror) {
-      this.onerror({ type: "error", target: this });
-    }
-  }
-}
-
-class IDBOpenDBRequest extends IDBRequest {
-  constructor(name, version) {
-    super();
-    this.onupgradeneeded = null;
-    this.onblocked = null;
-    this._name = name;
-    this._version = version;
-    this._open();
-  }
-
-  async _open() {
-    try {
-      const info = await __ops.idb_open(this._name, this._version);
-      const db = new IDBDatabase(
-        this._name,
-        this._version,
-        info.objectStores || [],
-      );
-
-      if (info.needsUpgrade) {
-        if (this.onupgradeneeded) {
-          const event = {
-            type: "upgradeneeded",
-            target: this,
-            oldVersion: info.oldVersion || 0,
-            newVersion: this._version,
-          };
-          // Temporarily set result for upgrade
-          this.result = db;
-          this.onupgradeneeded(event);
-        }
-      }
-
-      this._success(db);
-    } catch (e) {
-      this._error(e);
-    }
-  }
-}
-
-class IDBDatabase {
-  constructor(name, version, objectStoreNames) {
-    this.name = name;
-    this.version = version;
-    this.objectStoreNames = objectStoreNames;
-    this.onclose = null;
-    this.onerror = null;
-    this.onversionchange = null;
-  }
-
-  createObjectStore(name, options = {}) {
-    __ops.idb_create_object_store(this.name, name, options);
-    this.objectStoreNames.push(name);
-    return new IDBObjectStore(this, name);
-  }
-
-  deleteObjectStore(name) {
-    __ops.idb_delete_object_store(this.name, name);
-    const idx = this.objectStoreNames.indexOf(name);
-    if (idx >= 0) this.objectStoreNames.splice(idx, 1);
-  }
-
-  transaction(storeNames, mode = "readonly") {
-    return new IDBTransaction(this, storeNames, mode);
-  }
-
-  close() {
-    __ops.idb_close(this.name);
-  }
-}
-
-class IDBTransaction {
-  constructor(db, storeNames, mode) {
-    this.db = db;
-    this.mode = mode;
-    this.error = null;
-    this.oncomplete = null;
-    this.onerror = null;
-    this.onabort = null;
-    this._storeNames = Array.isArray(storeNames) ? storeNames : [storeNames];
-  }
-
-  objectStore(name) {
-    if (!this._storeNames.includes(name)) {
-      throw new Error(`Object store "${name}" not in transaction scope`);
-    }
-    return new IDBObjectStore(this.db, name, this);
-  }
-
-  abort() {
-    if (this.onabort) {
-      this.onabort({ type: "abort", target: this });
-    }
-  }
-
-  _complete() {
-    if (this.oncomplete) {
-      this.oncomplete({ type: "complete", target: this });
-    }
-  }
-}
-
-class IDBObjectStore {
-  constructor(db, name, transaction = null) {
-    this._db = db;
-    this.name = name;
-    this._transaction = transaction;
-  }
-
-  get(key) {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        const value = await __ops.idb_get(this._db.name, this.name, key);
-        request._success(value);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-
-  put(value, key) {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        await __ops.idb_put(this._db.name, this.name, key, value);
-        request._success(key);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-
-  add(value, key) {
-    return this.put(value, key);
-  }
-
-  delete(key) {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        await __ops.idb_delete(this._db.name, this.name, key);
-        request._success(undefined);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-
-  clear() {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        await __ops.idb_clear(this._db.name, this.name);
-        request._success(undefined);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-
-  getAll(query, count) {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        const values = await __ops.idb_get_all(this._db.name, this.name, count);
-        request._success(values);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-
-  getAllKeys(query, count) {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        const keys = await __ops.idb_get_all_keys(
-          this._db.name,
-          this.name,
-          count,
-        );
-        request._success(keys);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-
-  count() {
-    const request = new IDBRequest();
-    (async () => {
-      try {
-        const count = await __ops.idb_count(this._db.name, this.name);
-        request._success(count);
-      } catch (e) {
-        request._error(e);
-      }
-    })();
-    return request;
-  }
-}
-
-globalThis.indexedDB = new IDBFactory();
-globalThis.IDBFactory = IDBFactory;
-globalThis.IDBRequest = IDBRequest;
-globalThis.IDBOpenDBRequest = IDBOpenDBRequest;
-globalThis.IDBDatabase = IDBDatabase;
-globalThis.IDBTransaction = IDBTransaction;
-globalThis.IDBObjectStore = IDBObjectStore;
-
-// ============================================================================
-// TextEncoder / TextDecoder (for binary data handling)
-// ============================================================================
-if (typeof globalThis.TextEncoder === "undefined") {
-  globalThis.TextEncoder = class TextEncoder {
-    encode(str) {
-      const arr = [];
-      for (let i = 0; i < str.length; i++) {
-        let c = str.charCodeAt(i);
-        if (c < 128) {
-          arr.push(c);
-        } else if (c < 2048) {
-          arr.push((c >> 6) | 192, (c & 63) | 128);
-        } else {
-          arr.push((c >> 12) | 224, ((c >> 6) & 63) | 128, (c & 63) | 128);
-        }
-      }
-      return new Uint8Array(arr);
-    }
-  };
-}
-
-if (typeof globalThis.TextDecoder === "undefined") {
-  globalThis.TextDecoder = class TextDecoder {
-    decode(arr) {
-      if (!arr) return "";
-      const bytes = arr instanceof Uint8Array ? arr : new Uint8Array(arr);
-      let result = "";
-      for (let i = 0; i < bytes.length; i++) {
-        result += String.fromCharCode(bytes[i]);
-      }
-      return result;
-    }
-  };
-}
-
-// ============================================================================
-// atob / btoa (Base64)
-// ============================================================================
-if (typeof globalThis.atob === "undefined") {
-  globalThis.atob = function (str) {
-    return __ops.atob(str);
-  };
-}
-
-if (typeof globalThis.btoa === "undefined") {
-  globalThis.btoa = function (str) {
-    return __ops.btoa(str);
-  };
-}
-
-// ============================================================================
-// Crypto API (basic)
-// ============================================================================
-globalThis.crypto = {
-  getRandomValues: function (array) {
-    const bytes = __ops.crypto_random(array.length);
-    array.set(bytes);
-    return array;
-  },
-};
-
-// ============================================================================
-// Performance API (basic)
-// ============================================================================
-globalThis.performance = {
-  now: function () {
-    return __ops.performance_now();
-  },
-};
-
-// ============================================================================
-// Skill Bridge API
-// ============================================================================
-// These are exposed to skills via the `platform`, `db`, `state`, etc globals
-
-globalThis.__db = {
-  exec: function (sql, paramsJson) {
-    return __ops.db_exec(sql, paramsJson);
-  },
-  get: function (sql, paramsJson) {
-    return __ops.db_get(sql, paramsJson);
-  },
-  all: function (sql, paramsJson) {
-    return __ops.db_all(sql, paramsJson);
-  },
-  kvGet: function (key) {
-    return __ops.db_kv_get(key);
-  },
-  kvSet: function (key, valueJson) {
-    return __ops.db_kv_set(key, valueJson);
-  },
-};
-
-globalThis.__platform = {
-  os: function () {
-    return __ops.platform_os();
-  },
-  env: function (key) {
-    return __ops.platform_env(key);
-  },
-};
-
-/**
- * Base URL for OAuth proxy and webhook API calls.
- * Uses BACKEND_URL, then VITE_BACKEND_URL, then production default.
- * Trailing slashes are stripped.
- */
-globalThis.__resolveBackendBaseUrl = () => {
-  let raw = (
-    __platform.env("BACKEND_URL") ||
-    __platform.env("VITE_BACKEND_URL") ||
-    ""
-  ).trim();
-  if (!raw) {
-    return "https://api.tinyhumans.ai";
-  }
-  while (raw.length > 0 && raw.charAt(raw.length - 1) === "/") {
-    raw = raw.slice(0, -1);
-  }
-  return raw;
-};
-
-// High-level wrappers for skills (QuickJS bridge)
-globalThis.db = {
-  exec: function (sql, params) {
-    return __db.exec(sql, params ? JSON.stringify(params) : undefined);
-  },
-  get: function (sql, params) {
-    var result = __db.get(sql, params ? JSON.stringify(params) : undefined);
-    return JSON.parse(result);
-  },
-  all: function (sql, params) {
-    var result = __db.all(sql, params ? JSON.stringify(params) : undefined);
-    return JSON.parse(result);
-  },
-  kvGet: function (key) {
-    var result = __db.kvGet(key);
-    return JSON.parse(result);
-  },
-  kvSet: function (key, value) {
-    return __db.kvSet(key, JSON.stringify(value));
-  },
-};
-
-globalThis.net = {
-  fetch: function (url, options) {
-    var result = __ops.fetch(url, options ? JSON.stringify(options) : "{}");
-    return JSON.parse(result);
-  },
-};
-
-globalThis.platform = {
-  os: function () {
-    return __platform.os();
-  },
-  env: function (key) {
-    return __platform.env(key);
-  },
-  /**
-   * Desktop-style notification hook. The QuickJS host has no system tray UI here;
-   * avoid logging title/body (may contain PII); shim exists so sync flows do not throw "not a function".
-   */
-  notify: function (_title, _body) {
-    console.log("[platform.notify] notification requested");
-  },
-};
-
-// ============================================================================
-// Memory Bridge (for skills to send memory payloads to backend)
-// ============================================================================
-globalThis.memory = {
-  /**
-   * Insert a memory payload through the native memory bridge.
-   * Provider is inferred from the current skill ID on the Rust side.
-   * @param {object} metadata - Memory payload metadata.
-   * @returns {boolean}
-   */
-  insert: function (metadata) {
-    if (!metadata || typeof metadata !== "object") {
-      throw new Error("memory.insert requires an object payload");
-    }
-
-    __ops.memory_insert(JSON.stringify(metadata));
-    return true;
-  },
-};
-
-// ============================================================================
-// State Bridge API (for skills to publish state)
-// ============================================================================
-globalThis.__state = {
-  get: function (key) {
-    return __ops.state_get(key);
-  },
-  set: function (key, valueJson) {
-    return __ops.state_set(key, valueJson);
-  },
-  setPartial: function (partialJson) {
-    return __ops.state_set_partial(partialJson);
-  },
-};
-
-globalThis.state = {
-  get: function (key) {
-    var result = __ops.store_get(key);
-    return JSON.parse(result);
-  },
-  set: function (key, value) {
-    __ops.store_set(key, JSON.stringify(value));
-    __state.set(key, JSON.stringify(value));
-  },
-  setPartial: function (partial) {
-    var keys = Object.keys(partial);
-    for (var i = 0; i < keys.length; i++) {
-      __ops.store_set(keys[i], JSON.stringify(partial[keys[i]]));
-    }
-    __state.setPartial(JSON.stringify(partial));
-  },
-  delete: function (key) {
-    return __ops.store_delete(key);
-  },
-  keys: function () {
-    var result = __ops.store_keys();
-    return JSON.parse(result);
-  },
-};
-
-// ============================================================================
-// Data Bridge API (for skills to read/write files)
-// ============================================================================
-globalThis.__data = {
-  read: function (filename) {
-    return __ops.data_read(filename);
-  },
-  write: function (filename, content) {
-    return __ops.data_write(filename, content);
-  },
-};
-
-globalThis.data = {
-  read: function (filename) {
-    return __data.read(filename);
-  },
-  write: function (filename, content) {
-    return __data.write(filename, content);
-  },
-};
-
-// ============================================================================
-// OAuth Bridge API (credential management and authenticated proxy)
-// ============================================================================
-(function () {
-  globalThis.__oauthCredential = null;
-
-  globalThis.oauth = {
-    /** Get the current OAuth credential, or null if not connected. */
-    getCredential: function () {
-      return globalThis.__oauthCredential;
-    },
-
-    /**
-     * Make an authenticated API request proxied through the backend.
-     * Path is relative to manifest's apiBaseUrl.
-     *
-     * When a client key share is available (`__oauthClientKey`), uses the
-     * encrypted proxy endpoint (`/proxy/encrypted/:id/`) with the
-     * `X-Encryption-Key` header so the backend can reconstruct the full
-     * encryption key and decrypt OAuth tokens server-side.
-     */
-    fetch: function (path, options) {
-      if (!globalThis.__oauthCredential) {
-        return {
-          status: 401,
-          headers: {},
-          body: JSON.stringify({
-            error: "No OAuth credential. Complete OAuth setup first.",
-          }),
-        };
-      }
-      const backendUrl = globalThis.__resolveBackendBaseUrl();
-      const jwtToken = __ops.get_session_token() || "";
-      const cleanPath = path.charAt(0) === "/" ? path.slice(1) : path;
-      const credentialId = globalThis.__oauthCredential.credentialId;
-      const clientKey = globalThis.__oauthClientKey || null;
-
-      // Use encrypted proxy when client key share is available
-      let proxyUrl;
-      if (clientKey) {
-        proxyUrl = `${backendUrl}/proxy/encrypted/${credentialId}/${cleanPath}`;
-      } else {
-        proxyUrl = `${backendUrl}/proxy/by-id/${credentialId}/${cleanPath}`;
-      }
-
-      var method = (options && options.method) || "GET";
-      var headers = { "Content-Type": "application/json" };
-      if (jwtToken) {
-        headers["Authorization"] = "Bearer " + jwtToken;
-      }
-      if (clientKey) {
-        headers["X-Encryption-Key"] = clientKey;
-      }
-      if (options && options.headers) {
-        for (var k in options.headers) {
-          headers[k] = options.headers[k];
-        }
-      }
-      var fetchOpts = {
-        method: method,
-        headers: headers,
-        body: options ? options.body : undefined,
-        timeout: options ? options.timeout : undefined,
-      };
-
-      console.log(
-        "[oauth.fetch] " +
-          method +
-          " " +
-          proxyUrl +
-          " (credentialId=" +
-          credentialId +
-          ", encrypted=" +
-          !!clientKey +
-          ", jwtToken=" +
-          jwtToken +
-          ", Notion-Version=" +
-          (headers["Notion-Version"] || "none") +
-          ")",
-      );
-      var result = net.fetch(proxyUrl, fetchOpts);
-      console.log(
-        "[oauth.fetch] response status=" +
-          result.status +
-          " body_len=" +
-          (result.body ? result.body.length : 0),
-      );
-
-      // Detect auth failures from both HTTP status codes and structured proxy error bodies.
-      // The encrypted proxy route returns { success: false, error, authError: true, reconnectRequired: true }
-      // as a JSON body — sometimes with a non-401/403 HTTP status — so we must check both.
-      var isAuthError = result.status === 401 || result.status === 403;
-      var reconnectRequired = false;
-      if (!isAuthError && result.body) {
-        try {
-          var parsed = JSON.parse(result.body);
-          if (parsed.authError === true) {
-            isAuthError = true;
-            reconnectRequired = parsed.reconnectRequired === true;
-            console.warn(
-              "[oauth.fetch] authError in response body (status=" +
-                result.status +
-                ", reconnectRequired=" +
-                reconnectRequired +
-                ")",
-            );
-          }
-        } catch (e) {
-          /* non-JSON body — ignore */
-        }
-      } else if (isAuthError) {
-        reconnectRequired = true;
-      }
-
-      if (isAuthError) {
-        console.warn(
-          "[oauth.fetch] Got auth error (status=" +
-            result.status +
-            ") — clearing invalid credential for re-auth",
-        );
-        globalThis.__oauthCredential = null;
-        if (typeof globalThis.state !== "undefined" && globalThis.state.set) {
-          globalThis.state.set("__oauth_credential", "");
-          globalThis.state.setPartial({
-            connection_status: "error",
-            connection_error:
-              "Integration token expired or invalid. Please reconnect.",
-            auth_status: "not_authenticated",
-            reconnect_required: reconnectRequired,
-          });
-        }
-      }
-
-      return result;
-    },
-
-    /** Revoke the current OAuth credential server-side. */
-    revoke: function () {
-      if (globalThis.__oauthCredential) {
-        try {
-          const backendUrl = globalThis.__resolveBackendBaseUrl();
-          const jwtToken = __ops.get_session_token() || "";
-          const revokeOpts = {
-            method: "DELETE",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${jwtToken}`,
-            },
-          };
-          net.fetch(
-            `${backendUrl}/auth/integrations/${globalThis.__oauthCredential.credentialId}`,
-            revokeOpts,
-          );
-        } catch (e) {
-          /* best effort */
-        }
-      }
-      globalThis.__oauthCredential = null;
-      return true;
-    },
-
-    /** Internal: set credential (called by runtime on oauth/complete). */
-    __setCredential: function (cred) {
-      globalThis.__oauthCredential = cred;
-    },
-  };
-})();
-
-// ============================================================================
-// Advanced Auth Bridge API (self-hosted / text credential management)
-// ============================================================================
-(function () {
-  globalThis.__authCredential = null;
-
-  globalThis.auth = {
-    /**
-     * Get the full auth credential object, or null if not set.
-     * Shape: { mode: "managed"|"self_hosted"|"text", credentials: {...} }
-     */
-    getCredential: function () {
-      return globalThis.__authCredential;
-    },
-
-    /**
-     * Get the auth mode string, or null.
-     * @returns {"managed"|"self_hosted"|"text"|null}
-     */
-    getMode: function () {
-      return globalThis.__authCredential
-        ? globalThis.__authCredential.mode
-        : null;
-    },
-
-    /**
-     * Get just the credentials map (e.g. { client_id, client_secret, url, content }).
-     * @returns {Object|null}
-     */
-    getCredentials: function () {
-      return globalThis.__authCredential
-        ? globalThis.__authCredential.credentials
-        : null;
-    },
-
-    /**
-     * Make an HTTP request with credentials auto-injected.
-     * For self_hosted: auto-adds Authorization header from client_id/client_secret.
-     * For managed: delegates to oauth.fetch.
-     * For text: no auto-injection (skill should handle manually).
-     */
-    fetch: function (url, options) {
-      if (!globalThis.__authCredential) {
-        return {
-          status: 401,
-          headers: {},
-          body: JSON.stringify({
-            error: "No auth credential. Complete auth setup first.",
-          }),
-        };
-      }
-
-      var mode = globalThis.__authCredential.mode;
-      var creds = globalThis.__authCredential.credentials;
-
-      // Managed mode: delegate to oauth.fetch for proxy behavior
-      if (mode === "managed" && typeof globalThis.oauth !== "undefined") {
-        return globalThis.oauth.fetch(url, options);
-      }
-
-      var headers = {};
-      if (options && options.headers) {
-        for (var k in options.headers) {
-          headers[k] = options.headers[k];
-        }
-      }
-      if (!headers["Content-Type"]) {
-        headers["Content-Type"] = "application/json";
-      }
-
-      // Check for existing Authorization header (case-insensitive)
-      var hasAuth = false;
-      for (var hk in headers) {
-        if (hk.toLowerCase() === "authorization") {
-          hasAuth = true;
-          break;
-        }
-      }
-
-      // Self-hosted: auto-inject basic auth if client_id + client_secret present
-      if (
-        mode === "self_hosted" &&
-        creds.client_id &&
-        creds.client_secret &&
-        !hasAuth
-      ) {
-        headers["Authorization"] =
-          "Basic " + btoa(creds.client_id + ":" + creds.client_secret);
-        hasAuth = true;
-      }
-
-      // Self-hosted with access_token or refresh_token: inject Bearer token
-      if (mode === "self_hosted" && !hasAuth && creds.access_token) {
-        headers["Authorization"] = "Bearer " + creds.access_token;
-        hasAuth = true;
-      }
-
-      // Do NOT auto-inject session JWT for text mode or when auth is already set.
-      // Text mode credentials are opaque — the skill handles auth manually.
-
-      var fetchOpts = {
-        method: (options && options.method) || "GET",
-        headers: headers,
-        body: options ? options.body : undefined,
-        timeout: options ? options.timeout : undefined,
-      };
-
-      console.log(
-        "[auth.fetch] " + fetchOpts.method + " " + url + " (mode=" + mode + ")",
-      );
-      var result = net.fetch(url, fetchOpts);
-      console.log("[auth.fetch] response status=" + result.status);
-
-      // Auto-clear on 401/403 so user is prompted to re-auth
-      if (result.status === 401 || result.status === 403) {
-        console.warn(
-          "[auth.fetch] Got " +
-            result.status +
-            " — clearing invalid credential",
-        );
-        globalThis.__authCredential = null;
-        if (typeof globalThis.state !== "undefined" && globalThis.state.set) {
-          globalThis.state.set("__auth_credential", "");
-          globalThis.state.setPartial({
-            connection_status: "error",
-            connection_error:
-              "Auth credential expired or invalid. Please reconnect.",
-            auth_status: "not_authenticated",
-          });
-        }
-      }
-
-      return result;
-    },
-
-    /**
-     * Internal: set credential (called by runtime on auth/complete).
-     * Skills should not call this directly.
-     */
-    __setCredential: function (cred) {
-      globalThis.__authCredential = cred;
-    },
-  };
-})();
-
-// ============================================================================
-// Tools array (skills assign to this global)
-// ============================================================================
-globalThis.tools = [];
-
-// ============================================================================
-// Cron Bridge API (placeholder - requires integration with CronScheduler)
-// ============================================================================
-globalThis.cron = {
-  register: function (scheduleId, cronExpr) {
-    console.warn("[cron] register not implemented in QuickJS runtime yet");
-    return false;
-  },
-  unregister: function (scheduleId) {
-    console.warn("[cron] unregister not implemented in QuickJS runtime yet");
-    return false;
-  },
-  list: function () {
-    console.warn("[cron] list not implemented in QuickJS runtime yet");
-    return [];
-  },
-};
-
-// ============================================================================
-// Skills Bridge API (placeholder - requires integration with SkillRegistry)
-// ============================================================================
-globalThis.skills = {
-  list: function () {
-    console.warn(
-      "[skills] list is intentionally unavailable in isolated runtime",
-    );
-    return [];
-  },
-  callTool: function (skillId, toolName, args) {
-    console.warn("[skills] callTool is disabled by runtime isolation policy");
-    return { error: "Cross-skill invocation is disabled" };
-  },
-};
-
-// Model API — removed (inference handled at the Rust/agent layer, not in skills)
-
-// ============================================================================
-// Webhook / Tunnel API (skill-scoped)
-// ============================================================================
-// All operations are scoped to the calling skill. The Rust bridge injects the
-// skill_id automatically — JS code cannot impersonate another skill.
-
-globalThis.webhook = {
-  /**
-   * Register this skill to receive webhooks for a tunnel UUID.
-   * Rejects if the tunnel is already owned by a different skill.
-   * @param {string} tunnelUuid - The tunnel UUID (from createTunnel or backend)
-   * @param {string} [tunnelName] - Human-readable name for display
-   * @param {string} [backendTunnelId] - Backend MongoDB _id for CRUD
-   */
-  register: function (tunnelUuid, tunnelName, backendTunnelId) {
-    __ops.webhook_register(
-      tunnelUuid,
-      tunnelName || null,
-      backendTunnelId || null,
-    );
-  },
-
-  /**
-   * Unregister this skill from a tunnel.
-   * Rejects if the tunnel is not owned by this skill.
-   * @param {string} tunnelUuid
-   */
-  unregister: function (tunnelUuid) {
-    __ops.webhook_unregister(tunnelUuid);
-  },
-
-  /**
-   * List only this skill's registered tunnel mappings.
-   * Never includes other skills' tunnels.
-   * @returns {Array<{tunnel_uuid: string, skill_id: string, tunnel_name: string|null}>}
-   */
-  list: function () {
-    var json = __ops.webhook_list();
-    return JSON.parse(json);
-  },
-
-  /**
-   * Create a new tunnel via the backend API, automatically registered to
-   * this skill.
-   * @param {string} name - Tunnel name
-   * @param {string} [description] - Optional description
-   * @returns {Promise<{id: string, uuid: string, webhookUrl: string}>}
-   */
-  createTunnel: async function (name, description) {
-    const backendUrl = globalThis.__resolveBackendBaseUrl();
-    const jwtToken = __ops.get_session_token() || "";
-
-    var result = await net.fetch(`${backendUrl}/webhooks/core`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Bearer " + jwtToken,
-      },
-      body: JSON.stringify({ name: name, description: description || "" }),
-      timeout: 15000,
-    });
-
-    var parsed = JSON.parse(result);
-    if (parsed.status >= 400) {
-      throw new Error(
-        "Failed to create tunnel: " + parsed.status + " " + parsed.body,
-      );
-    }
-    var data = JSON.parse(parsed.body);
-    var tunnel = data.data || data.tunnel || data;
-
-    // Auto-register this tunnel to the calling skill
-    if (tunnel.uuid) {
-      webhook.register(tunnel.uuid, name, tunnel._id || tunnel.id || null);
-    }
-
-    // Build webhook URL for the caller
-    tunnel.webhookUrl =
-      backendUrl.replace(/\/$/, "") + "/webhooks/ingress/" + tunnel.uuid;
-
-    console.log(
-      "[webhook] Created tunnel: " + name + " → " + tunnel.webhookUrl,
-    );
-    return tunnel;
-  },
-
-  /**
-   * List locally registered tunnels scoped to this skill.
-   * Returns the local webhook registrations, not data from the backend API.
-   * @returns {Promise<Array>} Array of local tunnel registration objects.
-   */
-  listTunnels: async function () {
-    return webhook.list();
-  },
-
-  /**
-   * Delete a tunnel. Fails if the tunnel is not owned by this skill.
-   * @param {string} tunnelUuid - The tunnel UUID to delete
-   */
-  deleteTunnel: async function (tunnelUuid) {
-    var registration = null;
-    webhook.list().forEach(function (reg) {
-      if (reg.tunnel_uuid === tunnelUuid) {
-        registration = reg;
-      }
-    });
-    if (!registration) {
-      throw new Error(
-        "[webhook] Tunnel is not registered to this skill: " + tunnelUuid,
-      );
-    }
-    if (!registration.backend_tunnel_id) {
-      throw new Error(
-        "[webhook] Missing backend tunnel id for deleteTunnel; re-create or re-register this tunnel",
-      );
-    }
-
-    // Delete from backend first
-    const backendUrl = globalThis.__resolveBackendBaseUrl();
-    const jwtToken = __ops.get_session_token() || "";
-
-    var result = await net.fetch(
-      `${backendUrl}/webhooks/core/${registration.backend_tunnel_id}`,
-      {
-        method: "DELETE",
-        headers: { Authorization: "Bearer " + jwtToken },
-        timeout: 10000,
-      },
-    );
-
-    var parsed = JSON.parse(result);
-    if (parsed.status >= 400 && parsed.status !== 404) {
-      throw new Error(
-        "[webhook] Backend delete failed with status " + parsed.status,
-      );
-    }
-
-    // Backend confirmed deletion (or 404 = already gone) — now safe to
-    // remove the local registration.
-    webhook.unregister(tunnelUuid);
-
-    console.log("[webhook] Deleted tunnel: " + tunnelUuid);
-  },
-};
-
-console.log("[bootstrap] Webhook API initialized");
-console.log("[bootstrap] QuickJS browser APIs initialized");
diff --git a/src/openhuman/skills/quickjs_libs/mod.rs b/src/openhuman/skills/quickjs_libs/mod.rs
deleted file mode 100644
index e77a91326..000000000
--- a/src/openhuman/skills/quickjs_libs/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//! QuickJS Runtime Support Module.
-//!
-//! This module provides a QuickJS JavaScript runtime (via the `rquickjs` crate)
-//! for executing skill JavaScript code. it includes supporting shims and
-//! environment bindings to provide a browser-like or Node-like environment
-//! for skills.
-
-pub mod qjs_ops;
-pub mod storage;
-
-pub use storage::IdbStorage;
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/mod.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/mod.rs
deleted file mode 100644
index 29fda8909..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/mod.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-//! QuickJS native operations registered on `globalThis.__ops`.
-//!
-//! This module acts as the hub for all native Rust functions exposed to the
-//! JavaScript environment. Operations are categorized into submodules:
-//! - `types`       — shared state structs, constants, and error helpers.
-//! - `ops_core`    — fundamental APIs like console, crypto, and timers.
-//! - `ops_net`     — networking APIs like fetch and WebSockets.
-//! - `ops_storage` — persistence APIs like IndexedDB and SQL bridges.
-//! - `ops_state`   — skill-specific state and memory bridge.
-//! - `ops_webhook` — webhook registration and management.
-
-pub mod ops;
-mod ops_core;
-mod ops_net;
-mod ops_state;
-mod ops_storage;
-mod ops_webhook;
-pub mod types;
-
-// Re-export public API used by `qjs_skill_instance`
-pub use ops::*;
-pub use types::{poll_timers, SkillContext, SkillState, TimerState, WebSocketState};
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/ops.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/ops.rs
deleted file mode 100644
index 2a8fa33dd..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/ops.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use super::*;
-
-use parking_lot::RwLock;
-use rquickjs::{Ctx, Object, Result as JsResult};
-use std::sync::Arc;
-
-use super::types::SkillContext as SC;
-use crate::openhuman::skills::quickjs_libs::storage::IdbStorage;
-
-/// Registers all native Rust operations onto the JavaScript `globalThis.__ops` object.
-///
-/// This function initializes all operation sub-categories (core, net, storage, state, webhook)
-/// and binds them to the provided QuickJS context.
-pub fn register_ops(
-    ctx: &Ctx<'_>,
-    storage: IdbStorage,
-    skill_context: SC,
-    skill_state: Arc<RwLock<SkillState>>,
-    timer_state: Arc<RwLock<TimerState>>,
-    ws_state: Arc<RwLock<WebSocketState>>,
-) -> JsResult<()> {
-    let globals = ctx.globals();
-    let ops = Object::new(ctx.clone())?;
-
-    ops_core::register(ctx, &ops, timer_state)?;
-    ops_net::register(ctx, &ops, ws_state)?;
-    ops_storage::register(ctx, &ops, storage, skill_context.clone())?;
-    ops_state::register(ctx, &ops, skill_state, skill_context.clone())?;
-    ops_webhook::register(ctx, &ops, skill_context)?;
-
-    globals.set("__ops", ops)?;
-    Ok(())
-}
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_core.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/ops_core.rs
deleted file mode 100644
index d1c198853..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_core.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-//! Core native operations: console, crypto, performance, platform, and timers.
-
-use parking_lot::RwLock;
-use rquickjs::{Ctx, Function, Object};
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-use super::types::{TimerEntry, TimerState, ALLOWED_ENV_VARS};
-
-/// Reads the session JWT from the on-disk credentials store.
-///
-/// This checks the standard OpenHuman configuration directory and attempts
-/// to retrieve the active session token. Returns `None` on any failure.
-fn token_from_credentials_store() -> Option<String> {
-    use crate::openhuman::config::{read_active_user_id, user_openhuman_dir};
-    use crate::openhuman::credentials::{AuthService, APP_SESSION_PROVIDER};
-
-    let home = directories::UserDirs::new()?.home_dir().to_path_buf();
-    let default_dir = home.join(".openhuman");
-
-    // Resolve the workspace directory
-    let root_dir = match std::env::var("OPENHUMAN_WORKSPACE") {
-        Ok(ws) if !ws.is_empty() => {
-            let ws_path = std::path::PathBuf::from(&ws);
-            if ws_path.join("config.toml").exists() {
-                ws_path
-            } else {
-                default_dir
-            }
-        }
-        _ => default_dir,
-    };
-
-    if !root_dir.exists() {
-        return None;
-    }
-
-    // If there is an active user, credentials are stored in the user-scoped
-    // subdirectory (e.g. ~/.openhuman/users/<user_id>/). Fall back to the
-    // root dir for single-user / pre-login scenarios.
-    let state_dir = match read_active_user_id(&root_dir) {
-        Some(uid) => {
-            let user_dir = user_openhuman_dir(&root_dir, &uid);
-            if user_dir.exists() {
-                user_dir
-            } else {
-                root_dir
-            }
-        }
-        None => root_dir,
-    };
-
-    let auth = AuthService::new(&state_dir, true);
-    let profile = auth.get_profile(APP_SESSION_PROVIDER, None).ok()??;
-    profile.token.filter(|t| !t.trim().is_empty())
-}
-
-/// Registers core operations (console, crypto, performance, platform, timers)
-/// onto the provided JavaScript object.
-pub fn register<'js>(
-    ctx: &Ctx<'js>,
-    ops: &Object<'js>,
-    timer_state: Arc<RwLock<TimerState>>,
-) -> rquickjs::Result<()> {
-    // ========================================================================
-    // Console
-    // Binds JS `console.log`, `warn`, and `error` to the Rust `log` crate.
-    // ========================================================================
-
-    ops.set(
-        "console_log",
-        Function::new(ctx.clone(), |msg: String| {
-            log::info!("[js] {}", msg);
-        }),
-    )?;
-
-    ops.set(
-        "console_warn",
-        Function::new(ctx.clone(), |msg: String| {
-            log::warn!("[js] {}", msg);
-        }),
-    )?;
-
-    ops.set(
-        "console_error",
-        Function::new(ctx.clone(), |msg: String| {
-            log::error!("[js] {}", msg);
-        }),
-    )?;
-
-    // ========================================================================
-    // Crypto
-    // Basic cryptographic utilities (random bytes, base64 encoding/decoding).
-    // ========================================================================
-
-    ops.set(
-        "crypto_random",
-        Function::new(ctx.clone(), |len: usize| -> Vec<u8> {
-            use rand::RngCore;
-            let mut buf = vec![0u8; len];
-            rand::rng().fill_bytes(&mut buf);
-            buf
-        }),
-    )?;
-
-    ops.set(
-        "atob",
-        Function::new(ctx.clone(), |input: String| -> rquickjs::Result<String> {
-            use base64::Engine;
-            let bytes = base64::engine::general_purpose::STANDARD
-                .decode(&input)
-                .map_err(|e| super::types::js_err(e.to_string()))?;
-            String::from_utf8(bytes).map_err(|e| super::types::js_err(e.to_string()))
-        }),
-    )?;
-
-    ops.set(
-        "btoa",
-        Function::new(ctx.clone(), |input: String| -> String {
-            use base64::Engine;
-            base64::engine::general_purpose::STANDARD.encode(input.as_bytes())
-        }),
-    )?;
-
-    // ========================================================================
-    // Performance
-    // ========================================================================
-
-    ops.set(
-        "performance_now",
-        Function::new(ctx.clone(), || -> f64 {
-            std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap()
-                .as_secs_f64()
-                * 1000.0
-        }),
-    )?;
-
-    // ========================================================================
-    // Platform
-    // Exposure of OS type and safe environment variables.
-    // ========================================================================
-
-    ops.set(
-        "platform_os",
-        Function::new(ctx.clone(), || -> &'static str {
-            match std::env::consts::OS {
-                "windows" => "windows",
-                "macos" => "macos",
-                "linux" => "linux",
-                _ => "unknown",
-            }
-        }),
-    )?;
-
-    ops.set(
-        "platform_env",
-        Function::new(ctx.clone(), |key: String| -> Option<String> {
-            if ALLOWED_ENV_VARS.contains(&key.as_str()) {
-                std::env::var(&key).ok()
-            } else {
-                None
-            }
-        }),
-    )?;
-
-    ops.set(
-        "get_session_token",
-        Function::new(ctx.clone(), || -> String {
-            // Try the on-disk credentials store first (where login actually persists
-            // the JWT), then fall back to the legacy JWT_TOKEN env var.
-            if let Some(token) = token_from_credentials_store() {
-                return token;
-            }
-            std::env::var("JWT_TOKEN").unwrap_or_default()
-        }),
-    )?;
-
-    // ========================================================================
-    // Timers
-    // Native implementations for setTimeout and setInterval.
-    // ========================================================================
-
-    {
-        let ts = timer_state.clone();
-        ops.set(
-            "timer_start",
-            Function::new(
-                ctx.clone(),
-                move |id: u32, delay_ms: u32, is_interval: bool| {
-                    let mut state = ts.write();
-                    state.timers.insert(
-                        id,
-                        TimerEntry {
-                            deadline: Instant::now() + Duration::from_millis(delay_ms as u64),
-                            delay_ms,
-                            is_interval,
-                        },
-                    );
-                },
-            ),
-        )?;
-    }
-
-    {
-        let ts = timer_state;
-        ops.set(
-            "timer_cancel",
-            Function::new(ctx.clone(), move |id: u32| {
-                let mut state = ts.write();
-                state.timers.remove(&id);
-            }),
-        )?;
-    }
-
-    Ok(())
-}
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_net.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/ops_net.rs
deleted file mode 100644
index 0c97b48ae..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_net.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-//! Network native operations: fetch and WebSockets.
-//!
-//! The JS-facing `fetch` is **synchronous** — it blocks the QuickJS thread
-//! until the HTTP round-trip completes. Internally it uses the async reqwest
-//! client on the tokio runtime via `block_in_place` so other tokio tasks
-//! (event loop message handling, etc.) continue to make progress.
-
-use parking_lot::RwLock;
-use rquickjs::{Ctx, Function, Object};
-use std::collections::HashMap;
-use std::sync::{Arc, OnceLock};
-
-use super::types::{js_err, WebSocketConnection, WebSocketState};
-
-/// Shared HTTP client — built once and reused across all fetch calls.
-static HTTP_CLIENT: OnceLock<reqwest::Client> = OnceLock::new();
-
-/// Returns a reference to the global shared HTTP client, initializing it if necessary.
-fn get_http_client() -> &'static reqwest::Client {
-    HTTP_CLIENT.get_or_init(|| {
-        reqwest::Client::builder()
-            .use_rustls_tls()
-            .connect_timeout(std::time::Duration::from_secs(10))
-            // Disable connection pooling — reused connections hang on
-            // consecutive POST requests through the staging proxy.
-            .pool_idle_timeout(std::time::Duration::from_millis(0))
-            .pool_max_idle_per_host(0)
-            .build()
-            .expect("failed to build shared HTTP client")
-    })
-}
-
-/// Perform a synchronous HTTP fetch, blocking the calling thread while the
-/// async reqwest request completes on the tokio runtime.
-fn do_fetch(url: String, options: String) -> Result<String, rquickjs::Error> {
-    let opts: serde_json::Value =
-        serde_json::from_str(&options).map_err(|e| js_err(e.to_string()))?;
-
-    let method = opts["method"].as_str().unwrap_or("GET");
-    let headers_obj = opts["headers"].as_object();
-    let body = opts["body"].as_str();
-    let timeout_secs = opts["timeout"]
-        .as_u64()
-        .or_else(|| opts["timeout"].as_f64().map(|f| f as u64))
-        .unwrap_or(30);
-
-    log::info!(
-        "[net.fetch] {} {} (timeout={}s)",
-        method,
-        &url,
-        timeout_secs
-    );
-
-    let client = get_http_client();
-    let mut req = match method {
-        "GET" => client.get(&url),
-        "POST" => client.post(&url),
-        "PUT" => client.put(&url),
-        "PATCH" => client.patch(&url),
-        "DELETE" => client.delete(&url),
-        "HEAD" => client.head(&url),
-        _ => client.get(&url),
-    };
-
-    req = req.timeout(std::time::Duration::from_secs(timeout_secs));
-
-    if let Some(h) = headers_obj {
-        for (k, v) in h {
-            if let Some(val_str) = v.as_str() {
-                req = req.header(k, val_str);
-            }
-        }
-    }
-
-    if let Some(b) = body {
-        req = req.body(b.to_string());
-    }
-
-    // Block the current thread while the async HTTP request runs on tokio.
-    // `block_in_place` moves this thread out of the tokio worker pool so
-    // other tasks (event loop messages, etc.) continue to make progress.
-    let result = tokio::task::block_in_place(|| {
-        let handle = tokio::runtime::Handle::current();
-        handle.block_on(async {
-            let total_deadline = std::time::Duration::from_secs(timeout_secs + 5);
-
-            let response = tokio::time::timeout(total_deadline, req.send())
-                .await
-                .map_err(|_| js_err(format!("request timed out after {}s", timeout_secs + 5)))?
-                .map_err(|e| {
-                    let mut msg = e.to_string();
-                    let mut source = std::error::Error::source(&e);
-                    while let Some(cause) = source {
-                        msg.push_str(&format!(" | caused by: {cause}"));
-                        source = std::error::Error::source(cause);
-                    }
-                    js_err(msg)
-                })?;
-
-            let status = response.status().as_u16();
-            let status_text = response
-                .status()
-                .canonical_reason()
-                .unwrap_or("")
-                .to_string();
-            let headers: HashMap<String, String> = response
-                .headers()
-                .iter()
-                .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
-                .collect();
-
-            let body_text = tokio::time::timeout(
-                std::time::Duration::from_secs(timeout_secs + 5),
-                response.text(),
-            )
-            .await
-            .map_err(|_| js_err(format!("body read timed out after {}s", timeout_secs + 5)))?
-            .map_err(|e| js_err(e.to_string()))?;
-
-            log::info!(
-                "[net.fetch] {} {} status={} ({}b)",
-                method,
-                &url,
-                status,
-                body_text.len()
-            );
-
-            let result = serde_json::json!({
-                "status": status,
-                "statusText": status_text,
-                "headers": headers,
-                "body": body_text,
-            });
-
-            Ok::<String, rquickjs::Error>(result.to_string())
-        })
-    });
-
-    result
-}
-
-/// Registers network operations (fetch, WebSocket) onto the provided JavaScript object.
-pub fn register<'js>(
-    ctx: &Ctx<'js>,
-    ops: &Object<'js>,
-    ws_state: Arc<RwLock<WebSocketState>>,
-) -> rquickjs::Result<()> {
-    // ========================================================================
-    // Fetch — synchronous from JS's perspective
-    // ========================================================================
-
-    ops.set(
-        "fetch",
-        Function::new(ctx.clone(), move |url: String, options: String| {
-            do_fetch(url, options)
-        }),
-    )?;
-
-    // ========================================================================
-    // WebSocket (Placeholders)
-    // ========================================================================
-
-    {
-        let ws = ws_state.clone();
-        ops.set(
-            "ws_connect",
-            Function::new(ctx.clone(), move |url: String| {
-                let mut state = ws.write();
-                let id = state.next_id;
-                state.next_id += 1;
-                state.connections.insert(id, WebSocketConnection { url });
-                Ok::<u32, rquickjs::Error>(id)
-            }),
-        )?;
-    }
-
-    {
-        let ws = ws_state.clone();
-        ops.set(
-            "ws_send",
-            Function::new(ctx.clone(), move |_id: u32, _data: String| {
-                let _state = ws.read();
-            }),
-        )?;
-    }
-
-    {
-        let _ws = ws_state.clone();
-        ops.set(
-            "ws_recv",
-            Function::new(ctx.clone(), move |_id: u32| {
-                Ok::<Option<String>, rquickjs::Error>(None)
-            }),
-        )?;
-    }
-
-    {
-        let ws = ws_state;
-        ops.set(
-            "ws_close",
-            Function::new(ctx.clone(), move |id: u32, _code: u16, _reason: String| {
-                let mut state = ws.write();
-                state.connections.remove(&id);
-            }),
-        )?;
-    }
-    Ok(())
-}
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_state.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/ops_state.rs
deleted file mode 100644
index 3e87e8a44..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_state.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-//! State and memory operations: skill state get/set, filesystem data access, and memory insertion.
-
-use crate::openhuman::memory::NamespaceDocumentInput;
-use parking_lot::RwLock;
-use rquickjs::{Ctx, Function, Object};
-use serde::Deserialize;
-use std::sync::Arc;
-
-use super::types::{js_err, SkillContext, SkillState};
-
-/// Input structure for the `memory_insert` operation.
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct JsMemoryInsertInput {
-    /// Title of the document to be stored in memory.
-    title: String,
-    /// Content of the document.
-    content: String,
-    /// Type of the source (e.g., "doc", "chat", "email").
-    source_type: Option<String>,
-    /// Optional metadata associated with the document.
-    metadata: Option<serde_json::Value>,
-    /// Priority of the document ("high", "medium", "low").
-    priority: Option<String>,
-    /// Unix timestamp when the document was created.
-    created_at: Option<f64>,
-    /// Unix timestamp when the document was last updated.
-    updated_at: Option<f64>,
-    /// Optional unique identifier for the document.
-    document_id: Option<String>,
-}
-
-/// Registers state and memory operations onto the provided JavaScript object.
-pub fn register<'js>(
-    ctx: &Ctx<'js>,
-    ops: &Object<'js>,
-    skill_state: Arc<RwLock<SkillState>>,
-    skill_context: SkillContext,
-) -> rquickjs::Result<()> {
-    // ========================================================================
-    // State Bridge
-    // Allows skills to get and set shared state.
-    // ========================================================================
-
-    {
-        let ss = skill_state.clone();
-        ops.set(
-            "state_get",
-            Function::new(
-                ctx.clone(),
-                move |key: String| -> rquickjs::Result<String> {
-                    let state = ss.read();
-                    let value = state
-                        .data
-                        .get(&key)
-                        .cloned()
-                        .unwrap_or(serde_json::Value::Null);
-                    serde_json::to_string(&value).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let ss = skill_state.clone();
-        ops.set(
-            "state_set",
-            Function::new(
-                ctx.clone(),
-                move |key: String, value_json: String| -> rquickjs::Result<()> {
-                    let value: serde_json::Value =
-                        serde_json::from_str(&value_json).map_err(|e| js_err(e.to_string()))?;
-                    let mut state = ss.write();
-                    state.data.insert(key, value);
-                    state.dirty = true;
-                    Ok(())
-                },
-            ),
-        )?;
-    }
-
-    {
-        let ss = skill_state;
-        ops.set(
-            "state_set_partial",
-            Function::new(
-                ctx.clone(),
-                move |partial_json: String| -> rquickjs::Result<()> {
-                    let partial: serde_json::Map<String, serde_json::Value> =
-                        serde_json::from_str(&partial_json).map_err(|e| js_err(e.to_string()))?;
-                    let mut state = ss.write();
-                    for (k, v) in partial {
-                        state.data.insert(k, v);
-                    }
-                    state.dirty = true;
-                    Ok(())
-                },
-            ),
-        )?;
-    }
-
-    // ========================================================================
-    // Data Bridge
-    // Direct filesystem access within the skill's data directory.
-    // ========================================================================
-
-    {
-        let sc = skill_context.clone();
-        ops.set(
-            "data_read",
-            Function::new(
-                ctx.clone(),
-                move |filename: String| -> rquickjs::Result<String> {
-                    let path = sc.data_dir.join(&filename);
-                    std::fs::read_to_string(&path).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let sc = skill_context.clone();
-        ops.set(
-            "data_write",
-            Function::new(
-                ctx.clone(),
-                move |filename: String, content: String| -> rquickjs::Result<()> {
-                    let path = sc.data_dir.join(&filename);
-                    std::fs::write(&path, content).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    // ========================================================================
-    // Memory Bridge
-    // Integration with the OpenHuman memory system.
-    // ========================================================================
-
-    {
-        let sc = skill_context;
-        ops.set(
-            "memory_insert",
-            Function::new(
-                ctx.clone(),
-                move |metadata_json: String| -> rquickjs::Result<()> {
-                    let input: JsMemoryInsertInput =
-                        serde_json::from_str(&metadata_json).map_err(|e| js_err(e.to_string()))?;
-
-                    // Basic validation
-                    if input.title.trim().is_empty() {
-                        return Err(js_err("memory.insert requires a non-empty title"));
-                    }
-                    if input.content.trim().is_empty() {
-                        return Err(js_err("memory.insert requires non-empty content"));
-                    }
-
-                    let client = sc
-                        .memory_client
-                        .clone()
-                        .ok_or_else(|| js_err("Memory client is not initialized"))?;
-
-                    let skill_id = sc.skill_id.clone();
-                    let namespace = format!("skill-{skill_id}");
-
-                    let source_type = input
-                        .source_type
-                        .unwrap_or_else(|| "doc".to_string())
-                        .to_ascii_lowercase();
-                    if !matches!(source_type.as_str(), "doc" | "chat" | "email") {
-                        return Err(js_err("sourceType must be one of: doc, chat, email"));
-                    }
-
-                    let priority = input
-                        .priority
-                        .unwrap_or_else(|| "medium".to_string())
-                        .to_ascii_lowercase();
-                    if !matches!(priority.as_str(), "high" | "medium" | "low") {
-                        return Err(js_err("priority must be one of: high, medium, low"));
-                    }
-
-                    let metadata = input.metadata.unwrap_or_else(|| serde_json::json!({}));
-
-                    // Spawn the memory insertion in the background to avoid blocking the JS loop
-                    tokio::spawn(async move {
-                        if let Err(e) = client
-                            .put_doc(NamespaceDocumentInput {
-                                namespace,
-                                key: input.title.clone(),
-                                title: input.title.clone(),
-                                content: input.content.clone(),
-                                source_type,
-                                priority,
-                                tags: Vec::new(),
-                                metadata,
-                                category: "core".to_string(),
-                                session_id: None,
-                                document_id: input.document_id,
-                            })
-                            .await
-                        {
-                            log::warn!("[quickjs] memory_insert failed for '{}': {}", skill_id, e);
-                        } else {
-                            log::info!(
-                                "[quickjs] memory_insert stored '{}': title='{}'",
-                                skill_id,
-                                input.title
-                            );
-                        }
-                    });
-
-                    Ok(())
-                },
-            ),
-        )?;
-    }
-
-    Ok(())
-}
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_storage.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/ops_storage.rs
deleted file mode 100644
index 760a886eb..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_storage.rs
+++ /dev/null
@@ -1,369 +0,0 @@
-//! Storage native operations: IndexedDB emulation and SQL database/key-value bridges.
-
-use rquickjs::{Ctx, Function, Object};
-
-use super::types::{js_err, SkillContext};
-use crate::openhuman::skills::quickjs_libs::storage::IdbStorage;
-
-/// Registers storage operations (IndexedDB, DB bridge, Store bridge) onto the provided JavaScript object.
-pub fn register<'js>(
-    ctx: &Ctx<'js>,
-    ops: &Object<'js>,
-    storage: IdbStorage,
-    skill_context: SkillContext,
-) -> rquickjs::Result<()> {
-    // ========================================================================
-    // IndexedDB
-    // Synchronous emulation of the browser's IndexedDB API.
-    // ========================================================================
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_open",
-            Function::new(
-                ctx.clone(),
-                move |name: String, version: u32| -> rquickjs::Result<String> {
-                    let result = s.open_database(&name, version).map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_close",
-            Function::new(ctx.clone(), move |name: String| {
-                s.close_database(&name);
-            }),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_delete_database",
-            Function::new(ctx.clone(), move |name: String| -> rquickjs::Result<()> {
-                s.delete_database(&name).map_err(js_err)
-            }),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_create_object_store",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String,
-                      store_name: String,
-                      options: String|
-                      -> rquickjs::Result<()> {
-                    let opts: serde_json::Value =
-                        serde_json::from_str(&options).map_err(|e| js_err(e.to_string()))?;
-                    let key_path = opts["keyPath"].as_str();
-                    let auto_increment = opts["autoIncrement"].as_bool().unwrap_or(false);
-                    s.create_object_store(&db_name, &store_name, key_path, auto_increment)
-                        .map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_delete_object_store",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String, store_name: String| -> rquickjs::Result<()> {
-                    s.delete_object_store(&db_name, &store_name).map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_get",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String,
-                      store_name: String,
-                      key: String|
-                      -> rquickjs::Result<String> {
-                    let key_val: serde_json::Value =
-                        serde_json::from_str(&key).map_err(|e| js_err(e.to_string()))?;
-                    let result = s.get(&db_name, &store_name, &key_val).map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_put",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String,
-                      store_name: String,
-                      key: String,
-                      value: String|
-                      -> rquickjs::Result<()> {
-                    let key_val: serde_json::Value =
-                        serde_json::from_str(&key).map_err(|e| js_err(e.to_string()))?;
-                    let value_val: serde_json::Value =
-                        serde_json::from_str(&value).map_err(|e| js_err(e.to_string()))?;
-                    s.put(&db_name, &store_name, &key_val, &value_val)
-                        .map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_delete",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String, store_name: String, key: String| -> rquickjs::Result<()> {
-                    let key_val: serde_json::Value =
-                        serde_json::from_str(&key).map_err(|e| js_err(e.to_string()))?;
-                    s.delete(&db_name, &store_name, &key_val).map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_clear",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String, store_name: String| -> rquickjs::Result<()> {
-                    s.clear(&db_name, &store_name).map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_get_all",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String,
-                      store_name: String,
-                      count: Option<u32>|
-                      -> rquickjs::Result<String> {
-                    let result = s.get_all(&db_name, &store_name, count).map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_get_all_keys",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String,
-                      store_name: String,
-                      count: Option<u32>|
-                      -> rquickjs::Result<String> {
-                    let result = s
-                        .get_all_keys(&db_name, &store_name, count)
-                        .map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        ops.set(
-            "idb_count",
-            Function::new(
-                ctx.clone(),
-                move |db_name: String, store_name: String| -> rquickjs::Result<u32> {
-                    s.count(&db_name, &store_name).map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    // ========================================================================
-    // DB Bridge
-    // Direct SQL access to a skill-dedicated SQLite database.
-    // ========================================================================
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "db_exec",
-            Function::new(
-                ctx.clone(),
-                move |sql: String, params_json: Option<String>| -> rquickjs::Result<i64> {
-                    let params: Vec<serde_json::Value> = if let Some(p) = params_json {
-                        serde_json::from_str(&p).map_err(|e| js_err(e.to_string()))?
-                    } else {
-                        Vec::new()
-                    };
-                    let rows = s
-                        .skill_db_exec(&sc.skill_id, &sql, &params)
-                        .map_err(js_err)?;
-                    Ok(rows as i64)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "db_get",
-            Function::new(
-                ctx.clone(),
-                move |sql: String, params_json: Option<String>| -> rquickjs::Result<String> {
-                    let params: Vec<serde_json::Value> = if let Some(p) = params_json {
-                        serde_json::from_str(&p).map_err(|e| js_err(e.to_string()))?
-                    } else {
-                        Vec::new()
-                    };
-                    let result = s
-                        .skill_db_get(&sc.skill_id, &sql, &params)
-                        .map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "db_all",
-            Function::new(
-                ctx.clone(),
-                move |sql: String, params_json: Option<String>| -> rquickjs::Result<String> {
-                    let params: Vec<serde_json::Value> = if let Some(p) = params_json {
-                        serde_json::from_str(&p).map_err(|e| js_err(e.to_string()))?
-                    } else {
-                        Vec::new()
-                    };
-                    let result = s
-                        .skill_db_all(&sc.skill_id, &sql, &params)
-                        .map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "db_kv_get",
-            Function::new(
-                ctx.clone(),
-                move |key: String| -> rquickjs::Result<String> {
-                    let result = s.skill_kv_get(&sc.skill_id, &key).map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "db_kv_set",
-            Function::new(
-                ctx.clone(),
-                move |key: String, value_json: String| -> rquickjs::Result<()> {
-                    let value: serde_json::Value =
-                        serde_json::from_str(&value_json).map_err(|e| js_err(e.to_string()))?;
-                    s.skill_kv_set(&sc.skill_id, &key, &value).map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    // ========================================================================
-    // Store Bridge
-    // High-level key-value store for skills.
-    // ========================================================================
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "store_get",
-            Function::new(
-                ctx.clone(),
-                move |key: String| -> rquickjs::Result<String> {
-                    let result = s.skill_store_get(&sc.skill_id, &key).map_err(js_err)?;
-                    serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "store_set",
-            Function::new(
-                ctx.clone(),
-                move |key: String, value_json: String| -> rquickjs::Result<()> {
-                    let value: serde_json::Value =
-                        serde_json::from_str(&value_json).map_err(|e| js_err(e.to_string()))?;
-                    s.skill_store_set(&sc.skill_id, &key, &value)
-                        .map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    {
-        let s = storage.clone();
-        let sc = skill_context.clone();
-        ops.set(
-            "store_delete",
-            Function::new(ctx.clone(), move |key: String| -> rquickjs::Result<()> {
-                s.skill_store_delete(&sc.skill_id, &key).map_err(js_err)
-            }),
-        )?;
-    }
-
-    {
-        let s = storage;
-        let sc = skill_context;
-        ops.set(
-            "store_keys",
-            Function::new(ctx.clone(), move || -> rquickjs::Result<String> {
-                let keys = s.skill_store_keys(&sc.skill_id).map_err(js_err)?;
-                serde_json::to_string(&keys).map_err(|e| js_err(e.to_string()))
-            }),
-        )?;
-    }
-
-    Ok(())
-}
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_webhook.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/ops_webhook.rs
deleted file mode 100644
index a5527fd18..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/ops_webhook.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-//! Webhook native operations: register, unregister, and list tunnel-to-skill mappings.
-//!
-//! All operations are scoped to the calling skill — the `skill_id` is baked
-//! into the closure context at startup and cannot be overridden from JavaScript.
-
-use rquickjs::{Ctx, Function, Object};
-
-use super::types::{js_err, SkillContext};
-
-/// Registers webhook operations onto the provided JavaScript object.
-pub fn register<'js>(
-    ctx: &Ctx<'js>,
-    ops: &Object<'js>,
-    skill_context: SkillContext,
-) -> rquickjs::Result<()> {
-    // ========================================================================
-    // Webhook Registration
-    // Registers a tunnel UUID to be routed to this skill.
-    // ========================================================================
-
-    {
-        let sc = skill_context.clone();
-        ops.set(
-            "webhook_register",
-            Function::new(
-                ctx.clone(),
-                move |tunnel_uuid: String,
-                      tunnel_name: rquickjs::Value<'_>,
-                      backend_tunnel_id: rquickjs::Value<'_>|
-                      -> rquickjs::Result<()> {
-                    let router = sc
-                        .webhook_router
-                        .as_ref()
-                        .ok_or_else(|| js_err("Webhook router not available"))?;
-
-                    let name = tunnel_name.as_string().and_then(|s| s.to_string().ok());
-                    let backend_id = backend_tunnel_id
-                        .as_string()
-                        .and_then(|s| s.to_string().ok());
-
-                    router
-                        .register(&tunnel_uuid, &sc.skill_id, name, backend_id)
-                        .map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    // ========================================================================
-    // Webhook Unregistration
-    // Removes a tunnel registration for this skill.
-    // ========================================================================
-
-    {
-        let sc = skill_context.clone();
-        ops.set(
-            "webhook_unregister",
-            Function::new(
-                ctx.clone(),
-                move |tunnel_uuid: String| -> rquickjs::Result<()> {
-                    let router = sc
-                        .webhook_router
-                        .as_ref()
-                        .ok_or_else(|| js_err("Webhook router not available"))?;
-
-                    router
-                        .unregister(&tunnel_uuid, &sc.skill_id)
-                        .map_err(js_err)
-                },
-            ),
-        )?;
-    }
-
-    // ========================================================================
-    // Webhook Listing
-    // Returns a JSON array of all tunnel registrations for this skill.
-    // ========================================================================
-
-    {
-        let sc = skill_context;
-        ops.set(
-            "webhook_list",
-            Function::new(ctx.clone(), move || -> rquickjs::Result<String> {
-                let router = sc
-                    .webhook_router
-                    .as_ref()
-                    .ok_or_else(|| js_err("Webhook router not available"))?;
-
-                let registrations = router.list_for_skill(&sc.skill_id);
-                serde_json::to_string(&registrations).map_err(|e| js_err(e.to_string()))
-            }),
-        )?;
-    }
-
-    Ok(())
-}
diff --git a/src/openhuman/skills/quickjs_libs/qjs_ops/types.rs b/src/openhuman/skills/quickjs_libs/qjs_ops/types.rs
deleted file mode 100644
index 0cbe54f6a..000000000
--- a/src/openhuman/skills/quickjs_libs/qjs_ops/types.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-//! Shared types, state structs, and helpers for QuickJS operations.
-
-use parking_lot::RwLock;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::time::{Duration, Instant};
-
-// ============================================================================
-// Timer State
-// ============================================================================
-
-/// Represents a single timer (setTimeout or setInterval) in the JS environment.
-#[derive(Debug)]
-pub struct TimerEntry {
-    /// The absolute time when this timer should trigger.
-    pub deadline: Instant,
-    /// The delay in milliseconds between executions (used for intervals).
-    pub delay_ms: u32,
-    /// Whether this is a recurring interval timer.
-    pub is_interval: bool,
-}
-
-/// Tracks all active timers for a single QuickJS instance.
-#[derive(Debug, Default)]
-pub struct TimerState {
-    /// Active timers keyed by their unique numeric ID.
-    pub timers: HashMap<u32, TimerEntry>,
-}
-
-impl TimerState {
-    /// Polls all timers and returns a list of IDs that have reached their deadline.
-    /// Recurring interval timers have their deadlines updated for the next execution.
-    pub fn poll_ready(&mut self) -> Vec<u32> {
-        let now = Instant::now();
-        let mut ready = Vec::new();
-        let mut to_remove = Vec::new();
-
-        // Identify timers that have expired
-        for (&id, entry) in &self.timers {
-            if now >= entry.deadline {
-                ready.push(id);
-                if !entry.is_interval {
-                    to_remove.push(id);
-                }
-            }
-        }
-
-        // Clean up one-shot timers
-        for id in to_remove {
-            self.timers.remove(&id);
-        }
-
-        // Reschedule recurring intervals
-        for &id in &ready {
-            if let Some(entry) = self.timers.get_mut(&id) {
-                if entry.is_interval {
-                    entry.deadline = now + Duration::from_millis(entry.delay_ms as u64);
-                }
-            }
-        }
-
-        ready
-    }
-
-    /// Returns the duration until the next timer is scheduled to trigger.
-    /// Returns `None` if no timers are active.
-    pub fn time_until_next(&self) -> Option<Duration> {
-        let now = Instant::now();
-        self.timers
-            .values()
-            .map(|e| e.deadline.saturating_duration_since(now))
-            .min()
-    }
-}
-
-/// Helper function to poll timers and calculate the wait time until the next event.
-pub fn poll_timers(timer_state: &RwLock<TimerState>) -> (Vec<u32>, Option<Duration>) {
-    let mut ts = timer_state.write();
-    let ready = ts.poll_ready();
-    let next = ts.time_until_next();
-    (ready, next)
-}
-
-// ============================================================================
-// Skill Context
-// ============================================================================
-
-/// Holds environment-level context for a specific skill.
-#[derive(Clone)]
-pub struct SkillContext {
-    /// Unique identifier for the skill.
-    pub skill_id: String,
-    /// Path to the directory where the skill can store persistent data.
-    pub data_dir: PathBuf,
-    /// Optional client for interacting with the OpenHuman memory system.
-    pub memory_client: Option<crate::openhuman::memory::MemoryClientRef>,
-    /// Optional router for handling incoming webhooks for this skill.
-    pub webhook_router: Option<std::sync::Arc<crate::openhuman::webhooks::WebhookRouter>>,
-}
-
-// ============================================================================
-// Skill State (shared published state)
-// ============================================================================
-
-/// Represents the observable/shared state of a skill.
-/// This state is typically synced between the Rust backend and the JS environment.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SkillState {
-    /// The actual data stored in the state, represented as a JSON map.
-    #[serde(flatten)]
-    pub data: serde_json::Map<String, serde_json::Value>,
-    /// Set to true when data is modified; the event loop clears it after syncing.
-    #[serde(skip)]
-    pub dirty: bool,
-}
-
-impl Default for SkillState {
-    fn default() -> Self {
-        Self {
-            data: serde_json::Map::new(),
-            dirty: false,
-        }
-    }
-}
-
-// ============================================================================
-// WebSocket State (placeholder)
-// ============================================================================
-
-/// Represents an active WebSocket connection.
-#[derive(Debug)]
-pub struct WebSocketConnection {
-    /// The remote URL of the WebSocket.
-    pub url: String,
-}
-
-/// Tracks all active WebSocket connections for a QuickJS instance.
-#[derive(Debug, Default)]
-pub struct WebSocketState {
-    /// Active connections keyed by their unique numeric ID.
-    pub connections: HashMap<u32, WebSocketConnection>,
-    /// The next ID to assign to a new connection.
-    pub next_id: u32,
-}
-
-// ============================================================================
-// Constants & Helpers
-// ============================================================================
-
-/// List of environment variables that are allowed to be accessed from within the JS environment.
-pub const ALLOWED_ENV_VARS: &[&str] = &["VITE_BACKEND_URL", "BACKEND_URL", "JWT_TOKEN", "NODE_ENV"];
-
-/// Sanitize error message for use with QuickJS/rquickjs.
-///
-/// This avoids characters that might trigger rquickjs internal errors or formatting issues
-/// when creating a JS exception from a Rust error.
-fn sanitize_error_message(msg: &str) -> String {
-    msg.chars()
-        .map(|c| {
-            if c == ',' || c == '-' {
-                ' '
-            } else if c.is_ascii() && !c.is_ascii_control() {
-                c
-            } else if c == '\n' || c == '\r' || c == '\t' {
-                ' '
-            } else {
-                '?'
-            }
-        })
-        .collect()
-}
-
-/// Creates a `rquickjs::Error` with a sanitized message.
-pub fn js_err(msg: impl AsRef<str>) -> rquickjs::Error {
-    let sanitized = sanitize_error_message(msg.as_ref());
-    rquickjs::Error::new_from_js_message("skill", "RuntimeError", sanitized)
-}
diff --git a/src/openhuman/skills/quickjs_libs/storage.rs b/src/openhuman/skills/quickjs_libs/storage.rs
deleted file mode 100644
index 959b54c15..000000000
--- a/src/openhuman/skills/quickjs_libs/storage.rs
+++ /dev/null
@@ -1,709 +0,0 @@
-//! IndexedDB Storage Layer (SQLite-backed).
-//!
-//! This module provides a persistent storage implementation for skills,
-//! designed to be compatible with the browser's IndexedDB API.
-//! It uses SQLite as the underlying storage engine and provides:
-//! - IndexedDB API emulation.
-//! - Skill-specific database access (SQL bridge).
-//! - Skill key-value storage (KV bridge).
-//! - Skill-specific object stores.
-
-use parking_lot::RwLock;
-use rusqlite::{params, Connection, OpenFlags};
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
-/// Result of opening an IndexedDB database.
-/// Used by the IndexedDB emulation layer to communicate the state of the database to the JavaScript runtime.
-#[derive(Debug, Clone, serde::Serialize)]
-pub struct IdbOpenResult {
-    /// Whether a version upgrade is needed (requested version > current version).
-    pub needs_upgrade: bool,
-    /// The previous version (0 if new database).
-    pub old_version: u32,
-    /// List of existing object store names in the database.
-    pub object_stores: Vec<String>,
-}
-
-/// IndexedDB-compatible storage backed by SQLite.
-///
-/// Manages multiple SQLite databases, typically one per skill or per logical IndexedDB instance.
-#[derive(Clone)]
-pub struct IdbStorage {
-    /// Base directory where SQLite database files are stored.
-    data_dir: PathBuf,
-    /// Cache of open database connections, keyed by database name.
-    /// Connections are wrapped in Mutex for thread-safe access to SQLite.
-    connections: Arc<RwLock<HashMap<String, Arc<parking_lot::Mutex<Connection>>>>>,
-    /// Tracks the current version of open databases.
-    #[allow(dead_code)]
-    versions: Arc<RwLock<HashMap<String, u32>>>,
-}
-
-impl IdbStorage {
-    /// Creates a new `IdbStorage` instance using the specified directory for data.
-    ///
-    /// # Errors
-    /// Returns an error string if the data directory cannot be created.
-    pub fn new(data_dir: &Path) -> Result<Self, String> {
-        std::fs::create_dir_all(data_dir)
-            .map_err(|e| format!("Failed to create data directory: {e}"))?;
-
-        Ok(Self {
-            data_dir: data_dir.to_path_buf(),
-            connections: Arc::new(RwLock::new(HashMap::new())),
-            versions: Arc::new(RwLock::new(HashMap::new())),
-        })
-    }
-
-    /// Gets an existing database connection or opens a new one if not already cached.
-    ///
-    /// This method also initializes the internal metadata tables (`_idb_meta`, `_idb_stores`)
-    /// if they don't exist.
-    fn get_connection(&self, db_name: &str) -> Result<Arc<parking_lot::Mutex<Connection>>, String> {
-        // Check if already open
-        if let Some(conn) = self.connections.read().get(db_name) {
-            return Ok(conn.clone());
-        }
-
-        // Open/create the database file. We use SQLITE_OPEN_NO_MUTEX because we
-        // handle synchronization via parking_lot::Mutex.
-        let db_path = self.data_dir.join(format!("{}.sqlite", db_name));
-        let conn = Connection::open_with_flags(
-            &db_path,
-            OpenFlags::SQLITE_OPEN_READ_WRITE
-                | OpenFlags::SQLITE_OPEN_CREATE
-                | OpenFlags::SQLITE_OPEN_NO_MUTEX,
-        )
-        .map_err(|e| format!("Failed to open database '{}': {}", db_name, e))?;
-
-        // Initialize schema for IndexedDB emulation
-        conn.execute_batch(
-            r#"
-            CREATE TABLE IF NOT EXISTS _idb_meta (
-                key TEXT PRIMARY KEY,
-                value TEXT
-            );
-            CREATE TABLE IF NOT EXISTS _idb_stores (
-                name TEXT PRIMARY KEY,
-                key_path TEXT,
-                auto_increment INTEGER DEFAULT 0
-            );
-            "#,
-        )
-        .map_err(|e| format!("Failed to initialize database schema: {e}"))?;
-
-        let conn = Arc::new(parking_lot::Mutex::new(conn));
-        self.connections
-            .write()
-            .insert(db_name.to_string(), conn.clone());
-
-        Ok(conn)
-    }
-
-    /// Opens or creates an IndexedDB-style database.
-    ///
-    /// Checks the current version and determines if an upgrade is necessary.
-    /// Returns metadata about the database including existing object stores.
-    pub fn open_database(&self, name: &str, version: u32) -> Result<IdbOpenResult, String> {
-        let conn = self.get_connection(name)?;
-        let conn_guard = conn.lock();
-
-        // Get current version from metadata table
-        let current_version: u32 = conn_guard
-            .query_row(
-                "SELECT value FROM _idb_meta WHERE key = 'version'",
-                [],
-                |row| row.get::<_, String>(0),
-            )
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(0);
-
-        // Check if upgrade needed
-        let needs_upgrade = version > current_version;
-
-        if needs_upgrade {
-            // Update version in metadata
-            conn_guard
-                .execute(
-                    "INSERT OR REPLACE INTO _idb_meta (key, value) VALUES ('version', ?)",
-                    params![version.to_string()],
-                )
-                .map_err(|e| format!("Failed to update version: {e}"))?;
-        }
-
-        // Get object store names from the registry
-        let mut stmt = conn_guard
-            .prepare("SELECT name FROM _idb_stores")
-            .map_err(|e| format!("Failed to query object stores: {e}"))?;
-
-        let object_stores: Vec<String> = stmt
-            .query_map([], |row| row.get(0))
-            .map_err(|e| format!("Failed to fetch object stores: {e}"))?
-            .filter_map(|r| r.ok())
-            .collect();
-
-        self.versions.write().insert(name.to_string(), version);
-
-        Ok(IdbOpenResult {
-            needs_upgrade,
-            old_version: current_version,
-            object_stores,
-        })
-    }
-
-    /// Closes a database connection and removes it from the internal cache.
-    pub fn close_database(&self, name: &str) {
-        self.connections.write().remove(name);
-        self.versions.write().remove(name);
-    }
-
-    /// Deletes a database file and its associated connection.
-    ///
-    /// # Errors
-    /// Returns an error if the file cannot be removed.
-    pub fn delete_database(&self, name: &str) -> Result<(), String> {
-        self.close_database(name);
-        let db_path = self.data_dir.join(format!("{}.sqlite", name));
-        if db_path.exists() {
-            std::fs::remove_file(&db_path)
-                .map_err(|e| format!("Failed to delete database: {e}"))?;
-        }
-        Ok(())
-    }
-
-    /// Creates a new object store within a database.
-    ///
-    /// This registers the store in `_idb_stores` and creates a corresponding SQLite table.
-    pub fn create_object_store(
-        &self,
-        db_name: &str,
-        store_name: &str,
-        key_path: Option<&str>,
-        auto_increment: bool,
-    ) -> Result<(), String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        // Register the store in the metadata table
-        conn_guard
-            .execute(
-                "INSERT OR REPLACE INTO _idb_stores (name, key_path, auto_increment) VALUES (?, ?, ?)",
-                params![store_name, key_path, auto_increment as i32],
-            )
-            .map_err(|e| format!("Failed to create object store: {e}"))?;
-
-        // Create the data table for this specific object store
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        conn_guard
-            .execute(
-                &format!(
-                    r#"
-                    CREATE TABLE IF NOT EXISTS "{}" (
-                        key TEXT PRIMARY KEY,
-                        value TEXT
-                    )
-                    "#,
-                    table_name
-                ),
-                [],
-            )
-            .map_err(|e| format!("Failed to create store table: {e}"))?;
-
-        Ok(())
-    }
-
-    /// Deletes an object store and its associated data table.
-    pub fn delete_object_store(&self, db_name: &str, store_name: &str) -> Result<(), String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        // Remove from the object store registry
-        conn_guard
-            .execute(
-                "DELETE FROM _idb_stores WHERE name = ?",
-                params![store_name],
-            )
-            .map_err(|e| format!("Failed to delete object store: {e}"))?;
-
-        // Drop the actual data table
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        conn_guard
-            .execute(&format!("DROP TABLE IF EXISTS \"{}\"", table_name), [])
-            .map_err(|e| format!("Failed to drop store table: {e}"))?;
-
-        Ok(())
-    }
-
-    /// Retrieves a value from an object store by its key.
-    ///
-    /// Keys and values are handled as JSON strings in the underlying SQLite table.
-    pub fn get(
-        &self,
-        db_name: &str,
-        store_name: &str,
-        key: &serde_json::Value,
-    ) -> Result<Option<serde_json::Value>, String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        let key_str = serde_json::to_string(key).unwrap_or_else(|_| "null".to_string());
-
-        let result: Option<String> = conn_guard
-            .query_row(
-                &format!("SELECT value FROM \"{}\" WHERE key = ?", table_name),
-                params![key_str],
-                |row| row.get(0),
-            )
-            .ok();
-
-        match result {
-            Some(value_str) => {
-                let value: serde_json::Value =
-                    serde_json::from_str(&value_str).unwrap_or(serde_json::Value::Null);
-                Ok(Some(value))
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// Inserts or updates a value in an object store.
-    pub fn put(
-        &self,
-        db_name: &str,
-        store_name: &str,
-        key: &serde_json::Value,
-        value: &serde_json::Value,
-    ) -> Result<(), String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        let key_str = serde_json::to_string(key).unwrap_or_else(|_| "null".to_string());
-        let value_str = serde_json::to_string(value).unwrap_or_else(|_| "null".to_string());
-
-        conn_guard
-            .execute(
-                &format!(
-                    "INSERT OR REPLACE INTO \"{}\" (key, value) VALUES (?, ?)",
-                    table_name
-                ),
-                params![key_str, value_str],
-            )
-            .map_err(|e| format!("Failed to put value: {e}"))?;
-
-        Ok(())
-    }
-
-    /// Deletes a value from an object store by its key.
-    pub fn delete(
-        &self,
-        db_name: &str,
-        store_name: &str,
-        key: &serde_json::Value,
-    ) -> Result<(), String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        let key_str = serde_json::to_string(key).unwrap_or_else(|_| "null".to_string());
-
-        conn_guard
-            .execute(
-                &format!("DELETE FROM \"{}\" WHERE key = ?", table_name),
-                params![key_str],
-            )
-            .map_err(|e| format!("Failed to delete value: {e}"))?;
-
-        Ok(())
-    }
-
-    /// Clears all values from an object store.
-    pub fn clear(&self, db_name: &str, store_name: &str) -> Result<(), String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-
-        conn_guard
-            .execute(&format!("DELETE FROM \"{}\"", table_name), [])
-            .map_err(|e| format!("Failed to clear store: {e}"))?;
-
-        Ok(())
-    }
-
-    /// Retrieves all values from an object store, optionally limited by `count`.
-    pub fn get_all(
-        &self,
-        db_name: &str,
-        store_name: &str,
-        count: Option<u32>,
-    ) -> Result<Vec<serde_json::Value>, String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        let limit = count.map(|c| format!(" LIMIT {}", c)).unwrap_or_default();
-
-        let mut stmt = conn_guard
-            .prepare(&format!("SELECT value FROM \"{}\"{}", table_name, limit))
-            .map_err(|e| format!("Failed to query values: {e}"))?;
-
-        let values: Vec<serde_json::Value> = stmt
-            .query_map([], |row| row.get::<_, String>(0))
-            .map_err(|e| format!("Failed to fetch values: {e}"))?
-            .filter_map(|r| r.ok())
-            .filter_map(|s| serde_json::from_str(&s).ok())
-            .collect();
-
-        Ok(values)
-    }
-
-    /// Retrieves all keys from an object store, optionally limited by `count`.
-    pub fn get_all_keys(
-        &self,
-        db_name: &str,
-        store_name: &str,
-        count: Option<u32>,
-    ) -> Result<Vec<serde_json::Value>, String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-        let limit = count.map(|c| format!(" LIMIT {}", c)).unwrap_or_default();
-
-        let mut stmt = conn_guard
-            .prepare(&format!("SELECT key FROM \"{}\"{}", table_name, limit))
-            .map_err(|e| format!("Failed to query keys: {e}"))?;
-
-        let keys: Vec<serde_json::Value> = stmt
-            .query_map([], |row| row.get::<_, String>(0))
-            .map_err(|e| format!("Failed to fetch keys: {e}"))?
-            .filter_map(|r| r.ok())
-            .filter_map(|s| serde_json::from_str(&s).ok())
-            .collect();
-
-        Ok(keys)
-    }
-
-    /// Counts the number of values in an object store.
-    pub fn count(&self, db_name: &str, store_name: &str) -> Result<u32, String> {
-        let conn = self.get_connection(db_name)?;
-        let conn_guard = conn.lock();
-
-        let table_name = format!("store_{}", sanitize_name(store_name));
-
-        let count: u32 = conn_guard
-            .query_row(
-                &format!("SELECT COUNT(*) FROM \"{}\"", table_name),
-                [],
-                |row| row.get(0),
-            )
-            .map_err(|e| format!("Failed to count values: {e}"))?;
-
-        Ok(count)
-    }
-
-    // ========================================================================
-    // Skill Database Bridge Methods
-    // ========================================================================
-
-    /// Executes a SQL statement for a specific skill and returns the number of affected rows.
-    ///
-    /// This is used by the skill's database bridge to perform direct SQL operations.
-    pub fn skill_db_exec(
-        &self,
-        skill_id: &str,
-        sql: &str,
-        params: &[serde_json::Value],
-    ) -> Result<usize, String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        // Convert JSON parameters to SQLite-compatible types
-        let params: Vec<Box<dyn rusqlite::ToSql>> = params
-            .iter()
-            .map(|v| -> Box<dyn rusqlite::ToSql> { Box::new(json_to_sql(v)) })
-            .collect();
-
-        let params_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|b| b.as_ref()).collect();
-
-        conn_guard
-            .execute(sql, params_refs.as_slice())
-            .map_err(|e| format!("SQL exec failed: {e}"))
-    }
-
-    /// Executes a SQL query for a specific skill and returns a single row as a JSON object.
-    ///
-    /// Returns `null` if no rows match the query.
-    pub fn skill_db_get(
-        &self,
-        skill_id: &str,
-        sql: &str,
-        params: &[serde_json::Value],
-    ) -> Result<serde_json::Value, String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        let params: Vec<Box<dyn rusqlite::ToSql>> = params
-            .iter()
-            .map(|v| -> Box<dyn rusqlite::ToSql> { Box::new(json_to_sql(v)) })
-            .collect();
-
-        let params_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|b| b.as_ref()).collect();
-
-        let mut stmt = conn_guard
-            .prepare(sql)
-            .map_err(|e| format!("SQL prepare failed: {e}"))?;
-
-        let column_count = stmt.column_count();
-        // Capture column names before iterating over rows
-        let column_names: Vec<String> = (0..column_count)
-            .map(|i| stmt.column_name(i).unwrap_or("?").to_string())
-            .collect();
-
-        let result = stmt.query_row(params_refs.as_slice(), |row| {
-            let mut obj = serde_json::Map::new();
-            for (i, col_name) in column_names.iter().enumerate() {
-                let value = sql_to_json(row, i);
-                obj.insert(col_name.clone(), value);
-            }
-            Ok(serde_json::Value::Object(obj))
-        });
-
-        match result {
-            Ok(v) => Ok(v),
-            Err(rusqlite::Error::QueryReturnedNoRows) => Ok(serde_json::Value::Null),
-            Err(e) => Err(format!("SQL query failed: {e}")),
-        }
-    }
-
-    /// Executes a SQL query for a specific skill and returns all matching rows as a JSON array.
-    pub fn skill_db_all(
-        &self,
-        skill_id: &str,
-        sql: &str,
-        params: &[serde_json::Value],
-    ) -> Result<serde_json::Value, String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        let params: Vec<Box<dyn rusqlite::ToSql>> = params
-            .iter()
-            .map(|v| -> Box<dyn rusqlite::ToSql> { Box::new(json_to_sql(v)) })
-            .collect();
-
-        let params_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|b| b.as_ref()).collect();
-
-        let mut stmt = conn_guard
-            .prepare(sql)
-            .map_err(|e| format!("SQL prepare failed: {e}"))?;
-
-        let column_count = stmt.column_count();
-        let column_names: Vec<String> = (0..column_count)
-            .map(|i| stmt.column_name(i).unwrap_or("?").to_string())
-            .collect();
-
-        let rows = stmt
-            .query_map(params_refs.as_slice(), |row| {
-                let mut obj = serde_json::Map::new();
-                for (i, name) in column_names.iter().enumerate() {
-                    let value = sql_to_json(row, i);
-                    obj.insert(name.clone(), value);
-                }
-                Ok(serde_json::Value::Object(obj))
-            })
-            .map_err(|e| format!("SQL query failed: {e}"))?
-            .filter_map(|r| r.ok())
-            .collect::<Vec<_>>();
-
-        Ok(serde_json::Value::Array(rows))
-    }
-
-    /// Gets a value from the skill's key-value store.
-    ///
-    /// The KV store is implemented as a specialized `_kv` table in the skill's database.
-    pub fn skill_kv_get(&self, skill_id: &str, key: &str) -> Result<serde_json::Value, String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        // Ensure KV table exists
-        conn_guard
-            .execute(
-                "CREATE TABLE IF NOT EXISTS _kv (key TEXT PRIMARY KEY, value TEXT)",
-                [],
-            )
-            .map_err(|e| format!("Failed to create KV table: {e}"))?;
-
-        let result: Option<String> = conn_guard
-            .query_row("SELECT value FROM _kv WHERE key = ?", params![key], |row| {
-                row.get(0)
-            })
-            .ok();
-
-        match result {
-            Some(v) => serde_json::from_str(&v).map_err(|e| format!("Failed to parse value: {e}")),
-            None => Ok(serde_json::Value::Null),
-        }
-    }
-
-    /// Sets a value in the skill's key-value store.
-    pub fn skill_kv_set(
-        &self,
-        skill_id: &str,
-        key: &str,
-        value: &serde_json::Value,
-    ) -> Result<(), String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        // Ensure KV table exists
-        conn_guard
-            .execute(
-                "CREATE TABLE IF NOT EXISTS _kv (key TEXT PRIMARY KEY, value TEXT)",
-                [],
-            )
-            .map_err(|e| format!("Failed to create KV table: {e}"))?;
-
-        let value_str = serde_json::to_string(value).unwrap_or_else(|_| "null".to_string());
-
-        conn_guard
-            .execute(
-                "INSERT OR REPLACE INTO _kv (key, value) VALUES (?, ?)",
-                params![key, value_str],
-            )
-            .map_err(|e| format!("Failed to set value: {e}"))?;
-
-        Ok(())
-    }
-
-    // ========================================================================
-    // Skill Store Bridge Methods (same as KV but different namespace)
-    // ========================================================================
-
-    /// Gets a value from the skill's "store" (a logical namespace within the KV store).
-    pub fn skill_store_get(&self, skill_id: &str, key: &str) -> Result<serde_json::Value, String> {
-        self.skill_kv_get(skill_id, &format!("_store_{}", key))
-    }
-
-    /// Sets a value in the skill's "store".
-    pub fn skill_store_set(
-        &self,
-        skill_id: &str,
-        key: &str,
-        value: &serde_json::Value,
-    ) -> Result<(), String> {
-        self.skill_kv_set(skill_id, &format!("_store_{}", key), value)
-    }
-
-    /// Deletes a value from the skill's "store".
-    pub fn skill_store_delete(&self, skill_id: &str, key: &str) -> Result<(), String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        conn_guard
-            .execute(
-                "DELETE FROM _kv WHERE key = ?",
-                params![format!("_store_{}", key)],
-            )
-            .map_err(|e| format!("Failed to delete value: {e}"))?;
-
-        Ok(())
-    }
-
-    /// Lists all keys currently present in the skill's "store".
-    pub fn skill_store_keys(&self, skill_id: &str) -> Result<Vec<String>, String> {
-        let db_name = format!("skill_{}", skill_id);
-        let conn = self.get_connection(&db_name)?;
-        let conn_guard = conn.lock();
-
-        // Ensure KV table exists
-        conn_guard
-            .execute(
-                "CREATE TABLE IF NOT EXISTS _kv (key TEXT PRIMARY KEY, value TEXT)",
-                [],
-            )
-            .map_err(|e| format!("Failed to create KV table: {e}"))?;
-
-        let mut stmt = conn_guard
-            .prepare("SELECT key FROM _kv WHERE key LIKE '_store_%'")
-            .map_err(|e| format!("Failed to query keys: {e}"))?;
-
-        let keys: Vec<String> = stmt
-            .query_map([], |row| row.get::<_, String>(0))
-            .map_err(|e| format!("Failed to fetch keys: {e}"))?
-            .filter_map(|r| r.ok())
-            .map(|k| k.strip_prefix("_store_").unwrap_or(&k).to_string())
-            .collect();
-
-        Ok(keys)
-    }
-}
-
-/// Sanitize a name for use as a SQLite table name.
-/// Replaces non-alphanumeric characters with underscores.
-fn sanitize_name(name: &str) -> String {
-    name.chars()
-        .map(|c| {
-            if c.is_alphanumeric() || c == '_' {
-                c
-            } else {
-                '_'
-            }
-        })
-        .collect()
-}
-
-/// Convert a JSON value to a SQLite-compatible `rusqlite::types::Value`.
-fn json_to_sql(v: &serde_json::Value) -> rusqlite::types::Value {
-    match v {
-        serde_json::Value::Null => rusqlite::types::Value::Null,
-        serde_json::Value::Bool(b) => rusqlite::types::Value::Integer(*b as i64),
-        serde_json::Value::Number(n) => {
-            if let Some(i) = n.as_i64() {
-                rusqlite::types::Value::Integer(i)
-            } else if let Some(f) = n.as_f64() {
-                rusqlite::types::Value::Real(f)
-            } else {
-                rusqlite::types::Value::Text(n.to_string())
-            }
-        }
-        serde_json::Value::String(s) => rusqlite::types::Value::Text(s.clone()),
-        serde_json::Value::Array(_) | serde_json::Value::Object(_) => {
-            rusqlite::types::Value::Text(v.to_string())
-        }
-    }
-}
-
-/// Convert a value from a SQLite row to a `serde_json::Value`.
-/// Attempts to parse strings as JSON if possible.
-fn sql_to_json(row: &rusqlite::Row, idx: usize) -> serde_json::Value {
-    use rusqlite::types::ValueRef;
-
-    match row.get_ref(idx) {
-        Ok(ValueRef::Null) => serde_json::Value::Null,
-        Ok(ValueRef::Integer(i)) => serde_json::json!(i),
-        Ok(ValueRef::Real(f)) => serde_json::json!(f),
-        Ok(ValueRef::Text(s)) => {
-            let s = String::from_utf8_lossy(s).to_string();
-            // Try to parse as JSON, otherwise treat as a raw string
-            serde_json::from_str(&s).unwrap_or_else(|_| serde_json::json!(s))
-        }
-        Ok(ValueRef::Blob(b)) => {
-            serde_json::json!(base64::Engine::encode(
-                &base64::engine::general_purpose::STANDARD,
-                b
-            ))
-        }
-        Err(_) => serde_json::Value::Null,
-    }
-}
diff --git a/src/openhuman/skills/registry_cache.rs b/src/openhuman/skills/registry_cache.rs
deleted file mode 100644
index 3474b419c..000000000
--- a/src/openhuman/skills/registry_cache.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-//! Registry cache management — disk-based caching for the remote skill registry.
-//!
-//! This module provides utilities for fetching the remote skill registry and
-//! caching it locally on disk to reduce network traffic and allow for offline
-//! operation or faster startup.
-
-use std::path::{Path, PathBuf};
-
-use super::registry_types::{CachedRegistry, RemoteSkillRegistry, SkillCategory};
-
-/// Time-to-live for the cached registry in seconds (1 hour).
-pub(crate) const CACHE_TTL_SECS: i64 = 3600;
-
-/// Default URL for fetching the remote skill registry.
-pub(crate) const DEFAULT_REGISTRY_URL: &str = "https://raw.githubusercontent.com/tinyhumansai/openhuman-skills/refs/heads/build/skills/registry.json";
-
-/// Resolves the URL to use for the skill registry, favoring the `SKILLS_REGISTRY_URL`
-/// environment variable if set.
-pub(crate) fn registry_url() -> String {
-    std::env::var("SKILLS_REGISTRY_URL")
-        .ok()
-        .filter(|v| !v.is_empty())
-        .unwrap_or_else(|| DEFAULT_REGISTRY_URL.to_string())
-}
-
-/// Returns the path to the local skills directory if specified by the `SKILLS_LOCAL_DIR`
-/// environment variable.
-pub(crate) fn local_skills_dir() -> Option<PathBuf> {
-    std::env::var("SKILLS_LOCAL_DIR").ok().map(PathBuf::from)
-}
-
-/// Determines if a given URL represents a local file path or a `file://` URI.
-pub(crate) fn is_local_path(url: &str) -> bool {
-    url.starts_with('/') || url.starts_with("file://")
-}
-
-/// Reads a file from a local path or `file://` URI.
-pub(crate) fn read_local_file(url: &str) -> Result<Vec<u8>, String> {
-    let path = if let Some(stripped) = url.strip_prefix("file://") {
-        PathBuf::from(stripped)
-    } else {
-        PathBuf::from(url)
-    };
-    std::fs::read(&path).map_err(|e| format!("failed to read local file {}: {e}", path.display()))
-}
-
-/// Constructs the path to the registry cache file within the workspace.
-pub(crate) fn cache_path(workspace_dir: &Path) -> PathBuf {
-    workspace_dir.join("skills").join(".registry-cache.json")
-}
-
-/// Determines if the cached registry is still within its TTL.
-pub(crate) fn is_cache_fresh(cached: &CachedRegistry) -> bool {
-    let Ok(fetched) = chrono::DateTime::parse_from_rfc3339(&cached.fetched_at) else {
-        return false;
-    };
-    let now = chrono::Utc::now();
-    (now - fetched.to_utc()).num_seconds() < CACHE_TTL_SECS
-}
-
-/// Reads the cached skill registry from disk if it exists.
-pub(crate) fn read_cache(workspace_dir: &Path) -> Option<CachedRegistry> {
-    let path = cache_path(workspace_dir);
-    let content = std::fs::read_to_string(&path).ok()?;
-    serde_json::from_str(&content).ok()
-}
-
-/// Persists the skill registry to the local cache file.
-pub(crate) fn write_cache(
-    workspace_dir: &Path,
-    registry: &RemoteSkillRegistry,
-) -> Result<(), String> {
-    let cached = CachedRegistry {
-        fetched_at: chrono::Utc::now().to_rfc3339(),
-        registry: registry.clone(),
-    };
-    let path = cache_path(workspace_dir);
-    if let Some(parent) = path.parent() {
-        std::fs::create_dir_all(parent).map_err(|e| format!("failed to create cache dir: {e}"))?;
-    }
-    let json = serde_json::to_string_pretty(&cached).map_err(|e| e.to_string())?;
-    std::fs::write(&path, json).map_err(|e| format!("failed to write cache: {e}"))?;
-    Ok(())
-}
-
-/// Automatically tags each skill entry in the registry with its appropriate category
-/// based on the source list (core or third-party).
-pub(crate) fn tag_categories(registry: &mut RemoteSkillRegistry) {
-    for entry in &mut registry.skills.core {
-        entry.category = SkillCategory::Core;
-    }
-    for entry in &mut registry.skills.third_party {
-        entry.category = SkillCategory::ThirdParty;
-    }
-}
diff --git a/src/openhuman/skills/registry_ops.rs b/src/openhuman/skills/registry_ops.rs
deleted file mode 100644
index a426d6661..000000000
--- a/src/openhuman/skills/registry_ops.rs
+++ /dev/null
@@ -1,876 +0,0 @@
-//! Core operations for the OpenHuman Skills registry.
-//!
-//! This module handles fetching the skill registry (from remote or local sources),
-//! searching available skills, and performing installation/uninstallation of
-//! skill bundles into the workspace.
-
-use std::path::Path;
-
-use sha2::{Digest, Sha256};
-
-use super::registry_cache::{
-    is_cache_fresh, is_local_path, local_skills_dir, read_cache, read_local_file, registry_url,
-    tag_categories, write_cache,
-};
-use super::registry_types::{
-    AvailableSkillEntry, InstalledSkillInfo, RegistrySkillEntry, RemoteSkillRegistry,
-};
-
-/// Fetch the skill registry. Supports both remote HTTP URLs and local file paths.
-///
-/// When `SKILLS_REGISTRY_URL` points to a local file (absolute path or `file://` URI),
-/// the registry is read directly from disk — no caching is applied so changes are
-/// picked up immediately (ideal for local development).
-///
-/// For remote URLs, uses a 1-hour disk cache unless `force` is true.
-pub async fn registry_fetch(
-    workspace_dir: &Path,
-    force: bool,
-) -> Result<RemoteSkillRegistry, String> {
-    let url = registry_url();
-
-    // --- Local file path: read directly, skip cache for instant dev feedback ---
-    if is_local_path(&url) {
-        log::info!("[registry] reading local registry from {url}");
-        let bytes = read_local_file(&url)?;
-        let body = String::from_utf8(bytes)
-            .map_err(|e| format!("registry file is not valid UTF-8: {e}"))?;
-        let mut registry: RemoteSkillRegistry = serde_json::from_str(&body)
-            .map_err(|e| format!("failed to parse local registry JSON: {e}"))?;
-
-        // Ensure category flags are set correctly based on the registry structure
-        tag_categories(&mut registry);
-
-        log::info!(
-            "[registry] loaded {} core + {} third-party skills from local file",
-            registry.skills.core.len(),
-            registry.skills.third_party.len()
-        );
-        return Ok(registry);
-    }
-
-    // --- Remote URL: use disk cache ---
-    if !force {
-        if let Some(cached) = read_cache(workspace_dir) {
-            if is_cache_fresh(&cached) {
-                log::debug!("[registry] returning cached registry");
-                return Ok(cached.registry);
-            }
-        }
-    }
-
-    log::info!("[registry] fetching registry from {url}");
-
-    // Use rustls explicitly so we never fall back to native-tls (which can hang
-    // on macOS under the Hardened Runtime when the system keychain is restricted).
-    let client = reqwest::Client::builder()
-        .timeout(std::time::Duration::from_secs(30))
-        .use_rustls_tls()
-        .build()
-        .map_err(|e| format!("failed to create HTTP client: {e}"))?;
-
-    let resp = client
-        .get(&url)
-        .send()
-        .await
-        .map_err(|e| format!("failed to fetch registry from {url}: {e}"))?;
-
-    if !resp.status().is_success() {
-        return Err(format!(
-            "registry fetch failed with status {}",
-            resp.status()
-        ));
-    }
-
-    let body = resp
-        .text()
-        .await
-        .map_err(|e| format!("failed to read registry body: {e}"))?;
-
-    let mut registry: RemoteSkillRegistry =
-        serde_json::from_str(&body).map_err(|e| format!("failed to parse registry JSON: {e}"))?;
-
-    tag_categories(&mut registry);
-    write_cache(workspace_dir, &registry)?;
-
-    log::info!(
-        "[registry] fetched {} core + {} third-party skills",
-        registry.skills.core.len(),
-        registry.skills.third_party.len()
-    );
-
-    Ok(registry)
-}
-
-/// Search the registry by query string, optionally filtering by category.
-///
-/// Matches against the skill ID, name, and description.
-pub async fn registry_search(
-    workspace_dir: &Path,
-    query: &str,
-    category: Option<&str>,
-) -> Result<Vec<RegistrySkillEntry>, String> {
-    let registry = registry_fetch(workspace_dir, false).await?;
-    let query_lower = query.to_lowercase();
-
-    // Closure to check if a skill entry matches the search query
-    let matches_query = |entry: &RegistrySkillEntry| -> bool {
-        entry.id.to_lowercase().contains(&query_lower)
-            || entry.name.to_lowercase().contains(&query_lower)
-            || entry.description.to_lowercase().contains(&query_lower)
-    };
-
-    let mut results: Vec<RegistrySkillEntry> = Vec::new();
-
-    let include_core = category.is_none_or(|c| c == "core");
-    let include_third_party = category.is_none_or(|c| c == "third_party");
-
-    if include_core {
-        results.extend(
-            registry
-                .skills
-                .core
-                .into_iter()
-                .filter(|e| matches_query(e)),
-        );
-    }
-    if include_third_party {
-        results.extend(
-            registry
-                .skills
-                .third_party
-                .into_iter()
-                .filter(|e| matches_query(e)),
-        );
-    }
-
-    Ok(results)
-}
-
-/// Fetch bytes from a URL — supports both local file paths and HTTP URLs.
-async fn fetch_url_bytes(url: &str) -> Result<Vec<u8>, String> {
-    if is_local_path(url) {
-        return read_local_file(url);
-    }
-
-    log::debug!("[registry] fetch_url_bytes: connecting to {url}");
-
-    // Use rustls explicitly so we never fall back to native-tls (which can hang
-    // on macOS under the Hardened Runtime when the system keychain is restricted).
-    let client = reqwest::Client::builder()
-        .timeout(std::time::Duration::from_secs(30))
-        .use_rustls_tls()
-        .build()
-        .map_err(|e| format!("failed to create HTTP client: {e}"))?;
-
-    let resp = client
-        .get(url)
-        .send()
-        .await
-        .map_err(|e| format!("[registry] network error fetching {url}: {e}"))?;
-
-    if !resp.status().is_success() {
-        return Err(format!(
-            "[registry] fetch {url} returned HTTP {}",
-            resp.status()
-        ));
-    }
-
-    let bytes = resp
-        .bytes()
-        .await
-        .map(|b| b.to_vec())
-        .map_err(|e| format!("[registry] failed to read response body from {url}: {e}"))?;
-
-    log::debug!(
-        "[registry] fetch_url_bytes: {} bytes from {url}",
-        bytes.len()
-    );
-    Ok(bytes)
-}
-
-/// Install a skill from the registry or local directory.
-///
-/// When `SKILLS_LOCAL_DIR` is set, copies files directly from the local skills
-/// directory (e.g. `$SKILLS_LOCAL_DIR/<skill_id>/`) instead of downloading.
-/// This also works when registry entry URLs are local file paths.
-pub async fn skill_install(workspace_dir: &Path, skill_id: &str) -> Result<(), String> {
-    log::info!(
-        "[registry] skills_install: starting — skill_id={skill_id} workspace={}",
-        workspace_dir.display()
-    );
-
-    // --- Fast path: SKILLS_LOCAL_DIR copies directly from local dev directory ---
-    // This allows developers to work on skills locally and see changes reflected instantly
-    // in the app without having to publish to a registry.
-    if let Some(local_dir) = local_skills_dir() {
-        let local_skill = local_dir.join(skill_id);
-        if local_skill.exists() {
-            log::info!(
-                "[registry] installing '{skill_id}' from local dir: {}",
-                local_skill.display()
-            );
-            let skill_dir = workspace_dir.join("skills").join(skill_id);
-            copy_dir_recursive(&local_skill, &skill_dir)?;
-            log::info!("[registry] skill '{skill_id}' installed from local dir");
-            return Ok(());
-        }
-        log::warn!(
-            "[registry] SKILLS_LOCAL_DIR set but '{skill_id}' not found at {}; falling back to registry",
-            local_skill.display()
-        );
-    }
-
-    // --- Standard path: fetch from registry (remote or local URLs) ---
-    log::debug!("[registry] skills_install: fetching registry for '{skill_id}'");
-    let registry = registry_fetch(workspace_dir, false).await?;
-    log::debug!("[registry] skills_install: registry fetched, looking up '{skill_id}'");
-
-    let entry = registry
-        .skills
-        .core
-        .iter()
-        .chain(registry.skills.third_party.iter())
-        .find(|e| e.id == skill_id)
-        .ok_or_else(|| format!("skill '{skill_id}' not found in registry"))?
-        .clone();
-
-    log::debug!(
-        "[registry] skills_install: found entry '{skill_id}' v{} manifest={} bundle={}",
-        entry.version,
-        entry.manifest_url,
-        entry.download_url
-    );
-
-    let skill_dir = workspace_dir.join("skills").join(skill_id);
-    std::fs::create_dir_all(&skill_dir).map_err(|e| format!("failed to create skill dir: {e}"))?;
-
-    // Fetch manifest (local or remote)
-    log::info!(
-        "[registry] skills_install: fetching manifest for '{skill_id}' from {}",
-        entry.manifest_url
-    );
-    let manifest_bytes = fetch_url_bytes(&entry.manifest_url).await?;
-    log::debug!(
-        "[registry] skills_install: manifest fetched ({} bytes)",
-        manifest_bytes.len()
-    );
-
-    // Fetch JS bundle (local or remote)
-    log::info!(
-        "[registry] skills_install: fetching JS bundle for '{skill_id}' from {}",
-        entry.download_url
-    );
-    let js_bytes = fetch_url_bytes(&entry.download_url).await?;
-    log::debug!(
-        "[registry] skills_install: JS bundle fetched ({} bytes)",
-        js_bytes.len()
-    );
-
-    // Verify checksum if present to ensure integrity of the downloaded bundle
-    if let Some(expected) = &entry.checksum_sha256 {
-        let mut hasher = Sha256::new();
-        hasher.update(&js_bytes);
-        let actual = format!("{:x}", hasher.finalize());
-        if actual != *expected {
-            // Clean up the directory if verification fails
-            let _ = std::fs::remove_dir_all(&skill_dir);
-            return Err(format!(
-                "checksum mismatch for '{skill_id}': expected {expected}, got {actual}"
-            ));
-        }
-        log::debug!("[registry] checksum verified for '{skill_id}'");
-    }
-
-    // Write the fetched files to the local skill directory
-    std::fs::write(skill_dir.join("manifest.json"), &manifest_bytes)
-        .map_err(|e| format!("failed to write manifest: {e}"))?;
-    std::fs::write(skill_dir.join(&entry.entry), &js_bytes)
-        .map_err(|e| format!("failed to write JS bundle: {e}"))?;
-
-    log::info!("[registry] skill '{skill_id}' installed successfully");
-    Ok(())
-}
-
-/// Recursively copy a directory tree from `src` to `dst`.
-///
-/// Used primarily for local skill development to sync files from a source directory.
-fn copy_dir_recursive(src: &Path, dst: &Path) -> Result<(), String> {
-    std::fs::create_dir_all(dst)
-        .map_err(|e| format!("failed to create dir {}: {e}", dst.display()))?;
-
-    let entries =
-        std::fs::read_dir(src).map_err(|e| format!("failed to read dir {}: {e}", src.display()))?;
-
-    for entry in entries {
-        let entry = entry.map_err(|e| format!("failed to read dir entry: {e}"))?;
-        let src_path = entry.path();
-        let dst_path = dst.join(entry.file_name());
-
-        if src_path.is_dir() {
-            copy_dir_recursive(&src_path, &dst_path)?;
-        } else {
-            std::fs::copy(&src_path, &dst_path).map_err(|e| {
-                format!(
-                    "failed to copy {} -> {}: {e}",
-                    src_path.display(),
-                    dst_path.display()
-                )
-            })?;
-        }
-    }
-
-    Ok(())
-}
-
-/// Uninstall a skill by removing its directory from the workspace.
-pub async fn skill_uninstall(workspace_dir: &Path, skill_id: &str) -> Result<(), String> {
-    let skill_dir = workspace_dir.join("skills").join(skill_id);
-    if !skill_dir.exists() {
-        return Err(format!("skill '{skill_id}' is not installed"));
-    }
-
-    std::fs::remove_dir_all(&skill_dir)
-        .map_err(|e| format!("failed to remove skill directory: {e}"))?;
-
-    log::info!("[registry] skill '{skill_id}' uninstalled");
-    Ok(())
-}
-
-/// List all installed skills by scanning the workspace skills directory.
-///
-/// Parses the `manifest.json` in each subdirectory to gather skill information.
-pub async fn skills_list_installed(
-    workspace_dir: &Path,
-) -> Result<Vec<InstalledSkillInfo>, String> {
-    let skills_dir = workspace_dir.join("skills");
-    let entries = match std::fs::read_dir(&skills_dir) {
-        Ok(entries) => entries,
-        Err(_) => return Ok(Vec::new()),
-    };
-
-    let mut installed = Vec::new();
-    for entry in entries.filter_map(Result::ok) {
-        let path = entry.path();
-        if !path.is_dir() {
-            continue;
-        }
-
-        let dir_name = entry.file_name().to_string_lossy().to_string();
-        // Skip hidden directories
-        if dir_name.starts_with('.') {
-            continue;
-        }
-
-        let manifest_path = path.join("manifest.json");
-        if !manifest_path.exists() {
-            continue;
-        }
-
-        let content = match std::fs::read_to_string(&manifest_path) {
-            Ok(c) => c,
-            Err(_) => continue,
-        };
-
-        if let Ok(manifest) = serde_json::from_str::<serde_json::Value>(&content) {
-            installed.push(InstalledSkillInfo {
-                id: manifest
-                    .get("id")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or(&dir_name)
-                    .to_string(),
-                name: manifest
-                    .get("name")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or(&dir_name)
-                    .to_string(),
-                version: manifest
-                    .get("version")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string(),
-                description: manifest
-                    .get("description")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("")
-                    .to_string(),
-                runtime: manifest
-                    .get("runtime")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or("quickjs")
-                    .to_string(),
-            });
-        }
-    }
-
-    Ok(installed)
-}
-
-/// List all available skills from the registry, enriched with installed status.
-///
-/// Compares the remote registry with the locally installed skills to determine
-/// if a skill is installed and if updates are available.
-pub async fn skills_list_available(
-    workspace_dir: &Path,
-) -> Result<Vec<AvailableSkillEntry>, String> {
-    let registry = registry_fetch(workspace_dir, false).await?;
-    let installed = skills_list_installed(workspace_dir).await?;
-
-    let installed_map: std::collections::HashMap<&str, &InstalledSkillInfo> =
-        installed.iter().map(|s| (s.id.as_str(), s)).collect();
-
-    let mut available = Vec::new();
-
-    let all_entries = registry
-        .skills
-        .core
-        .into_iter()
-        .chain(registry.skills.third_party.into_iter());
-
-    for entry in all_entries {
-        let is_installed = installed_map.contains_key(entry.id.as_str());
-        let installed_version = installed_map
-            .get(entry.id.as_str())
-            .map(|s| s.version.clone());
-        let update_available = installed_version
-            .as_ref()
-            .is_some_and(|v| !v.is_empty() && *v != entry.version);
-
-        available.push(AvailableSkillEntry {
-            registry: entry,
-            installed: is_installed,
-            installed_version,
-            update_available,
-        });
-    }
-
-    Ok(available)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::registry_cache::{is_cache_fresh, write_cache};
-    use super::super::registry_types::{CachedRegistry, RegistrySkillCategories, SkillCategory};
-    use super::*;
-
-    fn make_workspace() -> tempfile::TempDir {
-        let dir = tempfile::TempDir::new().unwrap();
-        std::fs::create_dir_all(dir.path().join("skills")).unwrap();
-        dir
-    }
-
-    fn sample_registry() -> RemoteSkillRegistry {
-        RemoteSkillRegistry {
-            version: 1,
-            generated_at: "2026-03-30T12:00:00Z".to_string(),
-            skills: RegistrySkillCategories {
-                core: vec![
-                    RegistrySkillEntry {
-                        id: "gmail".to_string(),
-                        name: "Gmail".to_string(),
-                        version: "1.0.0".to_string(),
-                        description: "Gmail integration for email".to_string(),
-                        runtime: "quickjs".to_string(),
-                        entry: "index.js".to_string(),
-                        auto_start: false,
-                        platforms: Some(vec!["macos".into(), "windows".into()]),
-                        setup: None,
-                        ignore_in_production: false,
-                        download_url: String::new(),
-                        manifest_url: String::new(),
-                        checksum_sha256: None,
-                        author: None,
-                        repository: None,
-                        category: SkillCategory::Core,
-                    },
-                    RegistrySkillEntry {
-                        id: "notion".to_string(),
-                        name: "Notion".to_string(),
-                        version: "1.1.0".to_string(),
-                        description: "Notion workspace integration".to_string(),
-                        runtime: "quickjs".to_string(),
-                        entry: "index.js".to_string(),
-                        auto_start: false,
-                        platforms: None,
-                        setup: None,
-                        ignore_in_production: false,
-                        download_url: String::new(),
-                        manifest_url: String::new(),
-                        checksum_sha256: None,
-                        author: None,
-                        repository: None,
-                        category: SkillCategory::Core,
-                    },
-                ],
-                third_party: vec![RegistrySkillEntry {
-                    id: "custom-tracker".to_string(),
-                    name: "Custom Tracker".to_string(),
-                    version: "0.1.0".to_string(),
-                    description: "A custom price tracker".to_string(),
-                    runtime: "quickjs".to_string(),
-                    entry: "index.js".to_string(),
-                    auto_start: false,
-                    platforms: None,
-                    setup: None,
-                    ignore_in_production: false,
-                    download_url: String::new(),
-                    manifest_url: String::new(),
-                    checksum_sha256: None,
-                    author: Some("dev".into()),
-                    repository: Some("https://github.com/dev/tracker".into()),
-                    category: SkillCategory::ThirdParty,
-                }],
-            },
-        }
-    }
-
-    fn create_installed_skill(workspace: &Path, id: &str, version: &str) {
-        let skill_dir = workspace.join("skills").join(id);
-        std::fs::create_dir_all(&skill_dir).unwrap();
-        let manifest = serde_json::json!({
-            "id": id,
-            "name": id,
-            "version": version,
-            "description": format!("Test skill {id}"),
-            "runtime": "quickjs",
-            "entry": "index.js"
-        });
-        std::fs::write(
-            skill_dir.join("manifest.json"),
-            serde_json::to_string_pretty(&manifest).unwrap(),
-        )
-        .unwrap();
-        std::fs::write(skill_dir.join("index.js"), "function init() {}").unwrap();
-    }
-
-    // --- Cache tests ---
-
-    #[test]
-    fn test_registry_cache_write_and_read() {
-        let ws = make_workspace();
-        let registry = sample_registry();
-        write_cache(ws.path(), &registry).unwrap();
-
-        let cached = read_cache(ws.path()).unwrap();
-        assert_eq!(cached.registry.version, 1);
-        assert_eq!(cached.registry.skills.core.len(), 2);
-    }
-
-    #[test]
-    fn test_registry_cache_ttl_expired() {
-        let _ws = make_workspace();
-        let cached = CachedRegistry {
-            fetched_at: "2020-01-01T00:00:00Z".to_string(),
-            registry: sample_registry(),
-        };
-        assert!(!is_cache_fresh(&cached));
-
-        let fresh = CachedRegistry {
-            fetched_at: chrono::Utc::now().to_rfc3339(),
-            registry: sample_registry(),
-        };
-        assert!(is_cache_fresh(&fresh));
-    }
-
-    // --- Search tests (using cache directly to avoid HTTP) ---
-
-    fn search_entries(entries: &[RegistrySkillEntry], query: &str) -> Vec<RegistrySkillEntry> {
-        let query_lower = query.to_lowercase();
-        entries
-            .iter()
-            .filter(|e| {
-                e.id.to_lowercase().contains(&query_lower)
-                    || e.name.to_lowercase().contains(&query_lower)
-                    || e.description.to_lowercase().contains(&query_lower)
-            })
-            .cloned()
-            .collect()
-    }
-
-    #[test]
-    fn test_registry_search_by_name() {
-        let registry = sample_registry();
-        let all: Vec<_> = registry
-            .skills
-            .core
-            .iter()
-            .chain(registry.skills.third_party.iter())
-            .cloned()
-            .collect();
-        let results = search_entries(&all, "gmail");
-        assert_eq!(results.len(), 1);
-        assert_eq!(results[0].id, "gmail");
-    }
-
-    #[test]
-    fn test_registry_search_by_description() {
-        let registry = sample_registry();
-        let all: Vec<_> = registry
-            .skills
-            .core
-            .iter()
-            .chain(registry.skills.third_party.iter())
-            .cloned()
-            .collect();
-        let results = search_entries(&all, "price tracker");
-        assert_eq!(results.len(), 1);
-        assert_eq!(results[0].id, "custom-tracker");
-    }
-
-    #[test]
-    fn test_registry_search_case_insensitive() {
-        let registry = sample_registry();
-        let all: Vec<_> = registry
-            .skills
-            .core
-            .iter()
-            .chain(registry.skills.third_party.iter())
-            .cloned()
-            .collect();
-        let results = search_entries(&all, "NOTION");
-        assert_eq!(results.len(), 1);
-        assert_eq!(results[0].id, "notion");
-    }
-
-    #[test]
-    fn test_registry_search_with_category_filter() {
-        let registry = sample_registry();
-        // Core only
-        let results = search_entries(&registry.skills.core, "email");
-        assert_eq!(results.len(), 1); // gmail matches "Gmail integration for email"
-        assert_eq!(results[0].id, "gmail");
-
-        // Third party only
-        let results = search_entries(&registry.skills.third_party, "tracker");
-        assert_eq!(results.len(), 1);
-        assert_eq!(results[0].id, "custom-tracker");
-    }
-
-    // --- Install/Uninstall tests using mock HTTP server ---
-
-    #[tokio::test]
-    async fn test_skill_install_creates_files() {
-        let manifest = serde_json::json!({
-            "id": "test-skill",
-            "name": "Test Skill",
-            "version": "1.0.0",
-            "runtime": "quickjs",
-            "entry": "index.js"
-        });
-        let src = tempfile::TempDir::new().unwrap();
-        let manifest_source_path = src.path().join("manifest.json");
-        let js_source_path = src.path().join("index.js");
-        let manifest_source_url = reqwest::Url::from_file_path(&manifest_source_path)
-            .expect("manifest source path must convert to file:// URL")
-            .to_string();
-        let js_source_url = reqwest::Url::from_file_path(&js_source_path)
-            .expect("js source path must convert to file:// URL")
-            .to_string();
-        std::fs::write(
-            &manifest_source_path,
-            serde_json::to_string(&manifest).unwrap(),
-        )
-        .unwrap();
-        std::fs::write(&js_source_path, "function init() { console.log('hello'); }").unwrap();
-
-        // Build a registry pointing at our mock server
-        let registry = RemoteSkillRegistry {
-            version: 1,
-            generated_at: chrono::Utc::now().to_rfc3339(),
-            skills: RegistrySkillCategories {
-                core: vec![RegistrySkillEntry {
-                    id: "test-skill".to_string(),
-                    name: "Test Skill".to_string(),
-                    version: "1.0.0".to_string(),
-                    description: "A test skill".to_string(),
-                    runtime: "quickjs".to_string(),
-                    entry: "index.js".to_string(),
-                    auto_start: false,
-                    platforms: None,
-                    setup: None,
-                    ignore_in_production: false,
-                    download_url: js_source_url.clone(),
-                    manifest_url: manifest_source_url.clone(),
-                    checksum_sha256: None,
-                    author: None,
-                    repository: None,
-                    category: SkillCategory::Core,
-                }],
-                third_party: vec![],
-            },
-        };
-
-        let ws = make_workspace();
-        // Pre-populate cache so skill_install doesn't need to fetch registry via HTTP
-        write_cache(ws.path(), &registry).unwrap();
-
-        skill_install(ws.path(), "test-skill").await.unwrap();
-
-        let manifest_path = ws.path().join("skills/test-skill/manifest.json");
-        let js_path = ws.path().join("skills/test-skill/index.js");
-        assert!(manifest_path.exists(), "manifest.json should exist");
-        assert!(js_path.exists(), "index.js should exist");
-
-        let installed_manifest: serde_json::Value =
-            serde_json::from_str(&std::fs::read_to_string(&manifest_path).unwrap()).unwrap();
-        assert_eq!(installed_manifest["id"], "test-skill");
-
-        let installed_js = std::fs::read_to_string(&js_path).unwrap();
-        assert!(installed_js.contains("init"));
-    }
-
-    #[tokio::test]
-    async fn test_skill_install_checksum_verification() {
-        let js_content = "function init() { return 42; }";
-        let mut hasher = Sha256::new();
-        hasher.update(js_content.as_bytes());
-        let correct_checksum = format!("{:x}", hasher.finalize());
-        let src = tempfile::TempDir::new().unwrap();
-        let manifest_source_path = src.path().join("manifest.json");
-        let js_source_path = src.path().join("index.js");
-        let manifest_source_url = reqwest::Url::from_file_path(&manifest_source_path)
-            .expect("manifest source path must convert to file:// URL")
-            .to_string();
-        let js_source_url = reqwest::Url::from_file_path(&js_source_path)
-            .expect("js source path must convert to file:// URL")
-            .to_string();
-        std::fs::write(
-            &manifest_source_path,
-            r#"{"id":"cs-skill","name":"CS Skill","version":"1.0.0"}"#,
-        )
-        .unwrap();
-        std::fs::write(&js_source_path, js_content).unwrap();
-
-        // Test with correct checksum
-        let registry = RemoteSkillRegistry {
-            version: 1,
-            generated_at: chrono::Utc::now().to_rfc3339(),
-            skills: RegistrySkillCategories {
-                core: vec![RegistrySkillEntry {
-                    id: "cs-skill".to_string(),
-                    name: "CS Skill".to_string(),
-                    version: "1.0.0".to_string(),
-                    description: "".to_string(),
-                    runtime: "quickjs".to_string(),
-                    entry: "index.js".to_string(),
-                    auto_start: false,
-                    platforms: None,
-                    setup: None,
-                    ignore_in_production: false,
-                    download_url: js_source_url.clone(),
-                    manifest_url: manifest_source_url.clone(),
-                    checksum_sha256: Some(correct_checksum.clone()),
-                    author: None,
-                    repository: None,
-                    category: SkillCategory::Core,
-                }],
-                third_party: vec![],
-            },
-        };
-
-        let ws = make_workspace();
-        write_cache(ws.path(), &registry).unwrap();
-        assert!(skill_install(ws.path(), "cs-skill").await.is_ok());
-
-        // Test with wrong checksum
-        let ws2 = make_workspace();
-        let mut bad_registry = registry.clone();
-        bad_registry.skills.core[0].checksum_sha256 = Some("wrong_checksum".to_string());
-        write_cache(ws2.path(), &bad_registry).unwrap();
-        let result = skill_install(ws2.path(), "cs-skill").await;
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("checksum mismatch"));
-    }
-
-    #[tokio::test]
-    async fn test_skill_install_not_in_registry() {
-        let ws = make_workspace();
-        let registry = RemoteSkillRegistry {
-            version: 1,
-            generated_at: chrono::Utc::now().to_rfc3339(),
-            skills: RegistrySkillCategories {
-                core: vec![],
-                third_party: vec![],
-            },
-        };
-        write_cache(ws.path(), &registry).unwrap();
-
-        let result = skill_install(ws.path(), "nonexistent").await;
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("not found in registry"));
-    }
-
-    #[tokio::test]
-    async fn test_skill_uninstall_removes_directory() {
-        let ws = make_workspace();
-        create_installed_skill(ws.path(), "to-remove", "1.0.0");
-
-        assert!(ws.path().join("skills/to-remove").exists());
-        skill_uninstall(ws.path(), "to-remove").await.unwrap();
-        assert!(!ws.path().join("skills/to-remove").exists());
-    }
-
-    #[tokio::test]
-    async fn test_skill_uninstall_nonexistent() {
-        let ws = make_workspace();
-        let result = skill_uninstall(ws.path(), "does-not-exist").await;
-        assert!(result.is_err());
-        assert!(result.unwrap_err().contains("not installed"));
-    }
-
-    #[tokio::test]
-    async fn test_list_installed_empty() {
-        let ws = make_workspace();
-        let installed = skills_list_installed(ws.path()).await.unwrap();
-        assert!(installed.is_empty());
-    }
-
-    #[tokio::test]
-    async fn test_list_installed_with_skills() {
-        let ws = make_workspace();
-        create_installed_skill(ws.path(), "gmail", "1.0.0");
-        create_installed_skill(ws.path(), "notion", "1.1.0");
-
-        let installed = skills_list_installed(ws.path()).await.unwrap();
-        assert_eq!(installed.len(), 2);
-
-        let ids: Vec<&str> = installed.iter().map(|s| s.id.as_str()).collect();
-        assert!(ids.contains(&"gmail"));
-        assert!(ids.contains(&"notion"));
-    }
-
-    #[tokio::test]
-    async fn test_list_available_marks_installed() {
-        let ws = make_workspace();
-
-        // Install gmail at version 1.0.0 (registry has 1.0.0)
-        create_installed_skill(ws.path(), "gmail", "1.0.0");
-        // Install notion at version 1.0.0 (registry has 1.1.0 → update available)
-        create_installed_skill(ws.path(), "notion", "1.0.0");
-
-        // Write a registry to cache
-        let registry = sample_registry();
-        write_cache(ws.path(), &registry).unwrap();
-
-        let available = skills_list_available(ws.path()).await.unwrap();
-        assert_eq!(available.len(), 3); // gmail, notion, custom-tracker
-
-        let gmail = available.iter().find(|a| a.registry.id == "gmail").unwrap();
-        assert!(gmail.installed);
-        assert!(!gmail.update_available); // same version
-
-        let notion = available
-            .iter()
-            .find(|a| a.registry.id == "notion")
-            .unwrap();
-        assert!(notion.installed);
-        assert!(notion.update_available); // 1.0.0 vs 1.1.0
-
-        let tracker = available
-            .iter()
-            .find(|a| a.registry.id == "custom-tracker")
-            .unwrap();
-        assert!(!tracker.installed);
-        assert!(!tracker.update_available);
-    }
-}
diff --git a/src/openhuman/skills/registry_types.rs b/src/openhuman/skills/registry_types.rs
deleted file mode 100644
index 90a9a4613..000000000
--- a/src/openhuman/skills/registry_types.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-//! Data types for the OpenHuman Skills registry and installation system.
-//!
-//! This module defines the structures used to represent the remote skill registry,
-//! individual skill entries, and the state of installed skills.
-
-use serde::{Deserialize, Serialize};
-
-/// The full remote skill registry document.
-///
-/// This is typically fetched from a remote JSON file and describes all
-/// available skills and their metadata.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RemoteSkillRegistry {
-    /// Schema version of the registry.
-    pub version: u32,
-    /// ISO 8601 timestamp of when the registry was last generated.
-    pub generated_at: String,
-    /// Categorized skill entries.
-    pub skills: RegistrySkillCategories,
-}
-
-/// Containers for different categories of skills.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RegistrySkillCategories {
-    /// Officially maintained skills.
-    #[serde(default)]
-    pub core: Vec<RegistrySkillEntry>,
-    /// Community-contributed skills.
-    #[serde(default)]
-    pub third_party: Vec<RegistrySkillEntry>,
-}
-
-/// A single skill entry from the remote registry.
-///
-/// Contains all the metadata required to display, install, and run a skill.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct RegistrySkillEntry {
-    /// Unique identifier for the skill (e.g., "gmail").
-    pub id: String,
-    /// Human-readable name of the skill.
-    pub name: String,
-    /// SemVer version string.
-    #[serde(default)]
-    pub version: String,
-    /// Brief description of what the skill does.
-    #[serde(default)]
-    pub description: String,
-    /// The runtime required to execute the skill (usually "quickjs").
-    #[serde(default = "default_runtime")]
-    pub runtime: String,
-    /// The entry point file within the skill bundle (e.g., "index.js").
-    #[serde(default = "default_entry")]
-    pub entry: String,
-    /// If true, the skill should be started automatically when the app loads.
-    #[serde(default)]
-    pub auto_start: bool,
-    /// List of platforms supported by this skill (e.g., ["macos", "windows"]).
-    pub platforms: Option<Vec<String>>,
-    /// Optional JSON schema defining the setup configuration for this skill.
-    pub setup: Option<serde_json::Value>,
-    /// If true, this skill is excluded from production builds.
-    #[serde(default)]
-    pub ignore_in_production: bool,
-    /// URL to download the skill bundle (JS file).
-    pub download_url: String,
-    /// URL to fetch the detailed skill manifest.
-    pub manifest_url: String,
-    /// Optional SHA-256 checksum of the download bundle for integrity verification.
-    pub checksum_sha256: Option<String>,
-    /// Author of the skill.
-    pub author: Option<String>,
-    /// URL to the skill's source code repository.
-    pub repository: Option<String>,
-    /// The category this skill belongs to (set dynamically during fetch).
-    #[serde(default)]
-    pub category: SkillCategory,
-}
-
-/// Categorization for skills.
-#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum SkillCategory {
-    /// Official OpenHuman skills.
-    #[default]
-    Core,
-    /// User-created or community skills.
-    ThirdParty,
-}
-
-/// A skill entry enriched with installation status.
-///
-/// Used by the UI to show which skills are installed and if updates are available.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct AvailableSkillEntry {
-    /// The base registry entry.
-    #[serde(flatten)]
-    pub registry: RegistrySkillEntry,
-    /// Whether the skill is currently installed in the local workspace.
-    pub installed: bool,
-    /// The version of the skill currently installed (if any).
-    pub installed_version: Option<String>,
-    /// Whether a newer version is available in the registry.
-    pub update_available: bool,
-}
-
-/// Basic information about a skill that is already installed.
-///
-/// This is gathered by scanning the local `skills/` directory.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InstalledSkillInfo {
-    /// Unique identifier for the skill.
-    pub id: String,
-    /// Human-readable name.
-    pub name: String,
-    /// Currently installed version.
-    pub version: String,
-    /// Description from the local manifest.
-    pub description: String,
-    /// Required runtime.
-    pub runtime: String,
-}
-
-/// Cache wrapper for registry disk persistence.
-///
-/// Includes a timestamp to facilitate TTL-based cache invalidation.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CachedRegistry {
-    /// ISO 8601 timestamp of when the registry was last fetched.
-    pub fetched_at: String,
-    /// The cached registry document.
-    pub registry: RemoteSkillRegistry,
-}
-
-/// Default runtime for skills if not specified.
-fn default_runtime() -> String {
-    "quickjs".into()
-}
-
-/// Default entry point filename if not specified.
-fn default_entry() -> String {
-    "index.js".into()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_deserialize_registry_json() {
-        let json = r#"{
-            "version": 1,
-            "generated_at": "2026-03-30T12:00:00Z",
-            "skills": {
-                "core": [{
-                    "id": "gmail",
-                    "name": "Gmail",
-                    "version": "1.0.0",
-                    "description": "Gmail integration",
-                    "runtime": "quickjs",
-                    "entry": "index.js",
-                    "auto_start": false,
-                    "platforms": ["windows", "macos", "linux"],
-                    "download_url": "https://skills.openhuman.ai/skills/gmail/index.js",
-                    "manifest_url": "https://skills.openhuman.ai/skills/gmail/manifest.json",
-                    "checksum_sha256": "abc123"
-                }],
-                "third_party": []
-            }
-        }"#;
-
-        let registry: RemoteSkillRegistry = serde_json::from_str(json).unwrap();
-        assert_eq!(registry.version, 1);
-        assert_eq!(registry.skills.core.len(), 1);
-        assert_eq!(registry.skills.core[0].id, "gmail");
-        assert_eq!(
-            registry.skills.core[0].checksum_sha256.as_deref(),
-            Some("abc123")
-        );
-        assert!(registry.skills.third_party.is_empty());
-    }
-
-    #[test]
-    fn test_deserialize_minimal_entry() {
-        let json = r#"{
-            "id": "test",
-            "name": "Test",
-            "download_url": "https://example.com/test/index.js",
-            "manifest_url": "https://example.com/test/manifest.json"
-        }"#;
-
-        let entry: RegistrySkillEntry = serde_json::from_str(json).unwrap();
-        assert_eq!(entry.id, "test");
-        assert_eq!(entry.runtime, "quickjs");
-        assert_eq!(entry.entry, "index.js");
-        assert!(!entry.auto_start);
-        assert!(entry.platforms.is_none());
-        assert!(entry.checksum_sha256.is_none());
-        assert_eq!(entry.category, SkillCategory::Core);
-    }
-
-    #[test]
-    fn test_deserialize_with_third_party() {
-        let json = r#"{
-            "version": 1,
-            "generated_at": "2026-03-30T12:00:00Z",
-            "skills": {
-                "core": [{
-                    "id": "notion",
-                    "name": "Notion",
-                    "version": "1.1.0",
-                    "description": "Notion integration",
-                    "download_url": "https://skills.openhuman.ai/skills/notion/index.js",
-                    "manifest_url": "https://skills.openhuman.ai/skills/notion/manifest.json"
-                }],
-                "third_party": [{
-                    "id": "custom-skill",
-                    "name": "Custom Skill",
-                    "version": "0.1.0",
-                    "description": "A third-party skill",
-                    "download_url": "https://example.com/custom/index.js",
-                    "manifest_url": "https://example.com/custom/manifest.json",
-                    "author": "third-party-dev",
-                    "repository": "https://github.com/dev/custom-skill",
-                    "category": "third_party"
-                }]
-            }
-        }"#;
-
-        let registry: RemoteSkillRegistry = serde_json::from_str(json).unwrap();
-        assert_eq!(registry.skills.core.len(), 1);
-        assert_eq!(registry.skills.third_party.len(), 1);
-        assert_eq!(
-            registry.skills.third_party[0].author.as_deref(),
-            Some("third-party-dev")
-        );
-        assert_eq!(
-            registry.skills.third_party[0].category,
-            SkillCategory::ThirdParty
-        );
-    }
-}
diff --git a/src/openhuman/skills/schemas.rs b/src/openhuman/skills/schemas.rs
deleted file mode 100644
index eaa3f4223..000000000
--- a/src/openhuman/skills/schemas.rs
+++ /dev/null
@@ -1,1133 +0,0 @@
-//! JSON-RPC schemas and handlers for the OpenHuman Skills system.
-//!
-//! This module defines the interface between the frontend/RPC clients and the
-//! skills registry and runtime: skill installation, and runtime control
-//! (start, stop, tool calls, etc.).
-
-use std::collections::HashMap;
-
-use serde::Deserialize;
-use serde_json::{Map, Value};
-
-use crate::core::all::{ControllerFuture, RegisteredController};
-use crate::core::{ControllerSchema, FieldSchema, TypeSchema};
-use crate::openhuman::config::rpc as config_rpc;
-
-use super::qjs_engine::require_engine;
-use super::registry_ops;
-use super::types::{derive_connection_status, SkillSnapshot, SkillStatus};
-
-/// Returns all controller schemas defined in this module.
-pub fn all_controller_schemas() -> Vec<ControllerSchema> {
-    vec![
-        skills_schema("registry_fetch"),
-        skills_schema("search"),
-        skills_schema("install"),
-        skills_schema("uninstall"),
-        skills_schema("list_installed"),
-        skills_schema("list_available"),
-        skills_schema("start"),
-        skills_schema("stop"),
-        // Runtime controllers
-        skills_schema("status"),
-        skills_schema("setup_start"),
-        skills_schema("list_tools"),
-        skills_schema("sync"),
-        skills_schema("call_tool"),
-        skills_schema("rpc"),
-        skills_schema("discover"),
-        skills_schema("list"),
-        skills_schema("data_read"),
-        skills_schema("data_write"),
-        skills_schema("data_dir"),
-        skills_schema("data_stats"),
-        skills_schema("enable"),
-        skills_schema("disable"),
-        skills_schema("is_enabled"),
-        skills_schema("set_setup_complete"),
-        skills_schema("get_all_snapshots"),
-    ]
-}
-
-/// Returns all registered controllers (schema + handler) for the skills system.
-pub fn all_registered_controllers() -> Vec<RegisteredController> {
-    vec![
-        RegisteredController {
-            schema: skills_schema("registry_fetch"),
-            handler: handle_skills_registry_fetch,
-        },
-        RegisteredController {
-            schema: skills_schema("search"),
-            handler: handle_skills_search,
-        },
-        RegisteredController {
-            schema: skills_schema("install"),
-            handler: handle_skills_install,
-        },
-        RegisteredController {
-            schema: skills_schema("uninstall"),
-            handler: handle_skills_uninstall,
-        },
-        RegisteredController {
-            schema: skills_schema("list_installed"),
-            handler: handle_skills_list_installed,
-        },
-        RegisteredController {
-            schema: skills_schema("list_available"),
-            handler: handle_skills_list_available,
-        },
-        RegisteredController {
-            schema: skills_schema("start"),
-            handler: handle_skills_start,
-        },
-        RegisteredController {
-            schema: skills_schema("stop"),
-            handler: handle_skills_stop,
-        },
-        // Runtime controllers
-        RegisteredController {
-            schema: skills_schema("status"),
-            handler: handle_skills_status,
-        },
-        RegisteredController {
-            schema: skills_schema("setup_start"),
-            handler: handle_skills_setup_start,
-        },
-        RegisteredController {
-            schema: skills_schema("list_tools"),
-            handler: handle_skills_list_tools,
-        },
-        RegisteredController {
-            schema: skills_schema("sync"),
-            handler: handle_skills_sync,
-        },
-        RegisteredController {
-            schema: skills_schema("call_tool"),
-            handler: handle_skills_call_tool,
-        },
-        RegisteredController {
-            schema: skills_schema("rpc"),
-            handler: handle_skills_rpc,
-        },
-        RegisteredController {
-            schema: skills_schema("discover"),
-            handler: handle_skills_discover,
-        },
-        RegisteredController {
-            schema: skills_schema("list"),
-            handler: handle_skills_list,
-        },
-        RegisteredController {
-            schema: skills_schema("data_read"),
-            handler: handle_skills_data_read,
-        },
-        RegisteredController {
-            schema: skills_schema("data_write"),
-            handler: handle_skills_data_write,
-        },
-        RegisteredController {
-            schema: skills_schema("data_dir"),
-            handler: handle_skills_data_dir,
-        },
-        RegisteredController {
-            schema: skills_schema("data_stats"),
-            handler: handle_skills_data_stats,
-        },
-        RegisteredController {
-            schema: skills_schema("enable"),
-            handler: handle_skills_enable,
-        },
-        RegisteredController {
-            schema: skills_schema("disable"),
-            handler: handle_skills_disable,
-        },
-        RegisteredController {
-            schema: skills_schema("is_enabled"),
-            handler: handle_skills_is_enabled,
-        },
-        RegisteredController {
-            schema: skills_schema("set_setup_complete"),
-            handler: handle_skills_set_setup_complete,
-        },
-        RegisteredController {
-            schema: skills_schema("get_all_snapshots"),
-            handler: handle_skills_get_all_snapshots,
-        },
-    ]
-}
-
-// --- Skills registry schemas ---
-
-/// Helper to create a schema for skills-related functions.
-fn skills_schema(function: &str) -> ControllerSchema {
-    match function {
-        "registry_fetch" => ControllerSchema {
-            namespace: "skills",
-            function: "registry_fetch",
-            description: "Fetch the remote skill registry (cached with 1h TTL).",
-            inputs: vec![FieldSchema {
-                name: "force",
-                ty: TypeSchema::Option(Box::new(TypeSchema::Bool)),
-                comment: "Force a fresh fetch, bypassing cache.",
-                required: false,
-            }],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "The full registry JSON.",
-                required: true,
-            }],
-        },
-        "search" => ControllerSchema {
-            namespace: "skills",
-            function: "search",
-            description: "Search available skills by name, description, or ID.",
-            inputs: vec![
-                FieldSchema {
-                    name: "query",
-                    ty: TypeSchema::String,
-                    comment: "Search query string.",
-                    required: true,
-                },
-                FieldSchema {
-                    name: "category",
-                    ty: TypeSchema::Option(Box::new(TypeSchema::String)),
-                    comment: "Filter by category: 'core' or 'third_party'.",
-                    required: false,
-                },
-            ],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Array of matching skill entries.",
-                required: true,
-            }],
-        },
-        "install" => ControllerSchema {
-            namespace: "skills",
-            function: "install",
-            description: "Download and install a skill from the registry.",
-            inputs: vec![FieldSchema {
-                name: "skill_id",
-                ty: TypeSchema::String,
-                comment: "The skill ID to install.",
-                required: true,
-            }],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Installation result.",
-                required: true,
-            }],
-        },
-        "uninstall" => ControllerSchema {
-            namespace: "skills",
-            function: "uninstall",
-            description: "Remove an installed skill from the workspace.",
-            inputs: vec![FieldSchema {
-                name: "skill_id",
-                ty: TypeSchema::String,
-                comment: "The skill ID to uninstall.",
-                required: true,
-            }],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Uninstallation result.",
-                required: true,
-            }],
-        },
-        "list_installed" => ControllerSchema {
-            namespace: "skills",
-            function: "list_installed",
-            description: "List all locally installed skills.",
-            inputs: vec![],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Array of installed skill info.",
-                required: true,
-            }],
-        },
-        "list_available" => ControllerSchema {
-            namespace: "skills",
-            function: "list_available",
-            description: "List all available skills with installed status.",
-            inputs: vec![],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Array of available skill entries with installed flags.",
-                required: true,
-            }],
-        },
-        // --- Runtime controllers ---
-        "start" => ControllerSchema {
-            namespace: "skills",
-            function: "start",
-            description: "Start (load and initialize) a skill by ID.",
-            inputs: vec![skill_id_input("The skill ID to start.")],
-            outputs: vec![FieldSchema {
-                name: "skill",
-                ty: TypeSchema::Json,
-                comment: "Skill snapshot after start (id, name, status, tools, state).",
-                required: true,
-            }],
-        },
-        "stop" => ControllerSchema {
-            namespace: "skills",
-            function: "stop",
-            description: "Stop a running skill by ID.",
-            inputs: vec![skill_id_input("The skill ID to stop.")],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Stop acknowledgment.",
-                required: true,
-            }],
-        },
-        "status" => ControllerSchema {
-            namespace: "skills",
-            function: "status",
-            description: "Get the runtime status and state of a skill.",
-            inputs: vec![skill_id_input("The skill ID to query.")],
-            outputs: vec![FieldSchema {
-                name: "skill",
-                ty: TypeSchema::Json,
-                comment: "Skill snapshot (id, name, status, tools, error, state).",
-                required: true,
-            }],
-        },
-        "setup_start" => ControllerSchema {
-            namespace: "skills",
-            function: "setup_start",
-            description:
-                "Trigger the setup flow for a running skill, returning the first setup step.",
-            inputs: vec![skill_id_input("The skill ID to set up.")],
-            outputs: vec![FieldSchema {
-                name: "step",
-                ty: TypeSchema::Json,
-                comment:
-                    "First setup step definition (fields, labels, etc.) or null if no setup needed.",
-                required: true,
-            }],
-        },
-        "list_tools" => ControllerSchema {
-            namespace: "skills",
-            function: "list_tools",
-            description: "List all tools exposed by a running skill.",
-            inputs: vec![skill_id_input("The skill ID whose tools to list.")],
-            outputs: vec![FieldSchema {
-                name: "tools",
-                ty: TypeSchema::Array(Box::new(TypeSchema::Json)),
-                comment: "Array of tool definitions (name, description, inputSchema).",
-                required: true,
-            }],
-        },
-        "sync" => ControllerSchema {
-            namespace: "skills",
-            function: "sync",
-            description: "Trigger a sync (tick) on a running skill.",
-            inputs: vec![skill_id_input("The skill ID to sync.")],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Sync acknowledgment.",
-                required: true,
-            }],
-        },
-        "call_tool" => ControllerSchema {
-            namespace: "skills",
-            function: "call_tool",
-            description: "Call a specific tool on a running skill.",
-            inputs: vec![
-                skill_id_input("The skill ID that owns the tool."),
-                FieldSchema {
-                    name: "tool_name",
-                    ty: TypeSchema::String,
-                    comment: "Name of the tool to call.",
-                    required: true,
-                },
-                FieldSchema {
-                    name: "arguments",
-                    ty: TypeSchema::Option(Box::new(TypeSchema::Json)),
-                    comment: "JSON arguments to pass to the tool.",
-                    required: false,
-                },
-            ],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Tool execution result (content blocks, is_error flag).",
-                required: true,
-            }],
-        },
-        "rpc" => ControllerSchema {
-            namespace: "skills",
-            function: "rpc",
-            description:
-                "Send an arbitrary RPC method to a running skill (e.g. oauth/complete, skill/sync).",
-            inputs: vec![
-                skill_id_input("The target skill ID."),
-                FieldSchema {
-                    name: "method",
-                    ty: TypeSchema::String,
-                    comment: "RPC method name (e.g. oauth/complete, skill/ping).",
-                    required: true,
-                },
-                FieldSchema {
-                    name: "params",
-                    ty: TypeSchema::Option(Box::new(TypeSchema::Json)),
-                    comment: "JSON params to pass to the RPC handler.",
-                    required: false,
-                },
-            ],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "RPC handler result.",
-                required: true,
-            }],
-        },
-        "discover" => ControllerSchema {
-            namespace: "skills",
-            function: "discover",
-            description:
-                "Discover all available skill manifests from source and workspace directories.",
-            inputs: vec![],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Array of skill manifests.",
-                required: true,
-            }],
-        },
-        "list" => ControllerSchema {
-            namespace: "skills",
-            function: "list",
-            description: "List all registered (running or stopped) skill snapshots.",
-            inputs: vec![],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Array of skill snapshots.",
-                required: true,
-            }],
-        },
-        "data_read" => ControllerSchema {
-            namespace: "skills",
-            function: "data_read",
-            description: "Read a file from a skill's data directory.",
-            inputs: vec![
-                skill_id_input("The skill ID."),
-                FieldSchema {
-                    name: "filename",
-                    ty: TypeSchema::String,
-                    comment: "Filename to read.",
-                    required: true,
-                },
-            ],
-            outputs: vec![FieldSchema {
-                name: "content",
-                ty: TypeSchema::String,
-                comment: "File content.",
-                required: true,
-            }],
-        },
-        "data_write" => ControllerSchema {
-            namespace: "skills",
-            function: "data_write",
-            description: "Write a file to a skill's data directory.",
-            inputs: vec![
-                skill_id_input("The skill ID."),
-                FieldSchema {
-                    name: "filename",
-                    ty: TypeSchema::String,
-                    comment: "Filename to write.",
-                    required: true,
-                },
-                FieldSchema {
-                    name: "content",
-                    ty: TypeSchema::String,
-                    comment: "Content to write.",
-                    required: true,
-                },
-            ],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Write acknowledgment.",
-                required: true,
-            }],
-        },
-        "data_dir" => ControllerSchema {
-            namespace: "skills",
-            function: "data_dir",
-            description: "Get the data directory path for a skill.",
-            inputs: vec![skill_id_input("The skill ID.")],
-            outputs: vec![FieldSchema {
-                name: "path",
-                ty: TypeSchema::String,
-                comment: "Absolute path to the skill's data directory.",
-                required: true,
-            }],
-        },
-        "data_stats" => ControllerSchema {
-            namespace: "skills",
-            function: "data_stats",
-            description: "Recursive file count and byte size for a skill's data directory.",
-            inputs: vec![skill_id_input("The skill ID.")],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "exists, path, total_bytes, file_count.",
-                required: true,
-            }],
-        },
-        "enable" => ControllerSchema {
-            namespace: "skills",
-            function: "enable",
-            description: "Enable a skill (set preference and start it).",
-            inputs: vec![skill_id_input("The skill ID to enable.")],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Enable acknowledgment.",
-                required: true,
-            }],
-        },
-        "disable" => ControllerSchema {
-            namespace: "skills",
-            function: "disable",
-            description: "Disable a skill (set preference and stop it).",
-            inputs: vec![skill_id_input("The skill ID to disable.")],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Disable acknowledgment.",
-                required: true,
-            }],
-        },
-        "is_enabled" => ControllerSchema {
-            namespace: "skills",
-            function: "is_enabled",
-            description: "Check whether a skill is enabled in user preferences.",
-            inputs: vec![skill_id_input("The skill ID to check.")],
-            outputs: vec![FieldSchema {
-                name: "enabled",
-                ty: TypeSchema::Bool,
-                comment: "Whether the skill is enabled.",
-                required: true,
-            }],
-        },
-        "set_setup_complete" => ControllerSchema {
-            namespace: "skills",
-            function: "set_setup_complete",
-            description: "Persist setup completion flag for a skill.",
-            inputs: vec![
-                skill_id_input("The skill ID."),
-                FieldSchema {
-                    name: "complete",
-                    ty: TypeSchema::Bool,
-                    comment: "Whether setup is complete.",
-                    required: true,
-                },
-            ],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Acknowledgment.",
-                required: true,
-            }],
-        },
-        "get_all_snapshots" => ControllerSchema {
-            namespace: "skills",
-            function: "get_all_snapshots",
-            description:
-                "Get all skill snapshots enriched with setup_complete and connection_status.",
-            inputs: vec![],
-            outputs: vec![FieldSchema {
-                name: "result",
-                ty: TypeSchema::Json,
-                comment: "Array of enriched skill snapshots.",
-                required: true,
-            }],
-        },
-        _ => ControllerSchema {
-            namespace: "skills",
-            function: "unknown",
-            description: "Unknown skills controller function.",
-            inputs: vec![],
-            outputs: vec![FieldSchema {
-                name: "error",
-                ty: TypeSchema::String,
-                comment: "Lookup error details.",
-                required: true,
-            }],
-        },
-    }
-}
-
-/// Helper to create a standard `skill_id` input field schema.
-fn skill_id_input(comment: &'static str) -> FieldSchema {
-    FieldSchema {
-        name: "skill_id",
-        ty: TypeSchema::String,
-        comment,
-        required: true,
-    }
-}
-
-// --- Skills registry handlers ---
-
-/// Parameters for the `skills.registry_fetch` RPC method.
-#[derive(Deserialize)]
-struct RegistryFetchParams {
-    /// If true, bypasses the disk cache and fetches a fresh copy from the remote registry.
-    #[serde(default)]
-    force: Option<bool>,
-}
-
-/// Parameters for the `skills.search` RPC method.
-#[derive(Deserialize)]
-struct SearchParams {
-    /// The search query string (matches ID, name, or description).
-    query: String,
-    /// Optional category filter: "core" or "third_party".
-    category: Option<String>,
-}
-
-/// Common parameters for RPC methods that take a `skill_id`.
-#[derive(Deserialize)]
-struct SkillIdParams {
-    /// The unique identifier of the skill.
-    skill_id: String,
-}
-
-/// RPC handler to fetch the remote skill registry.
-fn handle_skills_registry_fetch(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: RegistryFetchParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let config = config_rpc::load_config_with_timeout().await?;
-        let registry =
-            registry_ops::registry_fetch(&config.workspace_dir, p.force.unwrap_or(false)).await?;
-        serde_json::to_value(registry).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to search for available skills in the registry.
-fn handle_skills_search(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SearchParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let config = config_rpc::load_config_with_timeout().await?;
-        let results =
-            registry_ops::registry_search(&config.workspace_dir, &p.query, p.category.as_deref())
-                .await?;
-        serde_json::to_value(results).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to install a skill by ID.
-fn handle_skills_install(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let config = config_rpc::load_config_with_timeout().await?;
-
-        // Sync the engine's workspace_dir with the current config so that a
-        // subsequent `skills_start` call finds the files we are about to write.
-        // This is necessary when the user logged in *after* the core bootstrapped:
-        // the engine was initialised with the pre-login (unscoped) workspace path,
-        // but config.workspace_dir now points to the user-scoped directory.
-        if let Ok(engine) = require_engine() {
-            log::debug!(
-                "[skills_install] syncing engine workspace_dir to {:?}",
-                config.workspace_dir
-            );
-            engine.set_workspace_dir(config.workspace_dir.clone());
-        }
-
-        registry_ops::skill_install(&config.workspace_dir, &p.skill_id).await?;
-        Ok(serde_json::json!({
-            "success": true,
-            "skill_id": p.skill_id
-        }))
-    })
-}
-
-/// RPC handler to uninstall a skill by ID.
-fn handle_skills_uninstall(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let config = config_rpc::load_config_with_timeout().await?;
-        registry_ops::skill_uninstall(&config.workspace_dir, &p.skill_id).await?;
-        Ok(serde_json::json!({
-            "success": true,
-            "skill_id": p.skill_id
-        }))
-    })
-}
-
-/// RPC handler to list all locally installed skills.
-fn handle_skills_list_installed(_params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let config = config_rpc::load_config_with_timeout().await?;
-        let installed = registry_ops::skills_list_installed(&config.workspace_dir).await?;
-        serde_json::to_value(installed).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to list all available skills, enriched with installation status.
-fn handle_skills_list_available(_params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let config = config_rpc::load_config_with_timeout().await?;
-        let available = registry_ops::skills_list_available(&config.workspace_dir).await?;
-        serde_json::to_value(available).map_err(|e| e.to_string())
-    })
-}
-
-// --- Runtime handlers ---
-
-/// Parameters for the `skills.call_tool` RPC method.
-#[derive(Deserialize)]
-struct CallToolParams {
-    /// The ID of the skill that owns the tool.
-    skill_id: String,
-    /// The name of the tool to invoke.
-    tool_name: String,
-    /// Arguments to pass to the tool.
-    #[serde(default)]
-    arguments: Option<serde_json::Value>,
-}
-
-/// RPC handler to start (load and initialize) a skill.
-fn handle_skills_start(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-
-        // Refresh the engine's workspace_dir from config every time a skill is
-        // started.  The engine's workspace_dir is set once at bootstrap using
-        // the paths resolved at that moment.  If the user was not yet logged in
-        // at startup the engine ends up with the unscoped legacy workspace path
-        // (`~/.openhuman/workspace`), while `skills_install` writes to the
-        // user-scoped path derived from `config.workspace_dir`.  Without this
-        // sync `start_skill` cannot find the installed manifest and fails with
-        // "Skill '…' not found (no manifest.json)".
-        if let Ok(config) = config_rpc::load_config_with_timeout().await {
-            log::debug!(
-                "[skills_start] syncing engine workspace_dir to {:?}",
-                config.workspace_dir
-            );
-            engine.set_workspace_dir(config.workspace_dir);
-        }
-
-        let snapshot = engine.start_skill(&p.skill_id).await?;
-        serde_json::to_value(&snapshot).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to stop a running skill.
-fn handle_skills_stop(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine.stop_skill(&p.skill_id).await?;
-        Ok(serde_json::json!({
-            "success": true,
-            "skill_id": p.skill_id
-        }))
-    })
-}
-
-/// RPC handler to get the current status and state of a skill.
-fn handle_skills_status(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        let snapshot = if let Some(snap) = engine.get_skill_state(&p.skill_id) {
-            snap
-        } else {
-            // Not loaded in QuickJS (never started, still starting, or failed to start).
-            // Still return persisted prefs — especially `setup_complete` after OAuth —
-            // so the UI is not stuck waiting for a snapshot that would only exist once
-            // the runtime has the skill registered.
-            let setup_complete = engine.preferences().is_setup_complete(&p.skill_id);
-            let status = SkillStatus::Pending;
-            let state = HashMap::new();
-            let connection_status = derive_connection_status(status, setup_complete, &state);
-            SkillSnapshot {
-                skill_id: p.skill_id.clone(),
-                name: p.skill_id.clone(),
-                status,
-                tools: vec![],
-                error: None,
-                state,
-                setup_complete,
-                connection_status,
-            }
-        };
-        serde_json::to_value(&snapshot).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to initiate the setup flow for a skill.
-fn handle_skills_setup_start(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine
-            .rpc(&p.skill_id, "setup/start", serde_json::json!({}))
-            .await
-    })
-}
-
-/// RPC handler to list all tools exposed by a skill.
-fn handle_skills_list_tools(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine
-            .rpc(&p.skill_id, "tools/list", serde_json::json!({}))
-            .await
-    })
-}
-
-/// RPC handler to trigger a sync (tick) for a skill.
-fn handle_skills_sync(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        log::debug!("[skills] handle_skills_sync: skill_id={}", p.skill_id);
-        let engine = require_engine()?;
-        log::debug!(
-            "[skills] handle_skills_sync: dispatching skill/sync to engine for '{}'",
-            p.skill_id
-        );
-        engine
-            .rpc(&p.skill_id, "skill/sync", serde_json::json!({}))
-            .await
-    })
-}
-
-/// RPC handler to call a specific tool on a running skill.
-fn handle_skills_call_tool(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: CallToolParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        let result = engine
-            .call_tool(
-                &p.skill_id,
-                &p.tool_name,
-                p.arguments.unwrap_or(serde_json::json!({})),
-            )
-            .await?;
-        serde_json::to_value(&result).map_err(|e| e.to_string())
-    })
-}
-
-/// Parameters for the arbitrary `skills.rpc` method.
-#[derive(Deserialize)]
-struct SkillRpcParams {
-    /// The target skill ID.
-    skill_id: String,
-    /// The internal RPC method name to call on the skill.
-    method: String,
-    /// Parameters for the internal RPC method.
-    #[serde(default)]
-    params: Option<serde_json::Value>,
-}
-
-/// RPC handler to send an arbitrary RPC method to a running skill.
-fn handle_skills_rpc(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillRpcParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine
-            .rpc(
-                &p.skill_id,
-                &p.method,
-                p.params.unwrap_or(serde_json::json!({})),
-            )
-            .await
-    })
-}
-
-/// RPC handler to discover available skill manifests from the filesystem.
-fn handle_skills_discover(_params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let engine = require_engine()?;
-        let manifests = engine.discover_skills().await?;
-        serde_json::to_value(&manifests).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to list all currently registered skill snapshots.
-fn handle_skills_list(_params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let engine = require_engine()?;
-        let skills = engine.list_skills();
-        serde_json::to_value(&skills).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to read a file from a skill's isolated data directory.
-fn handle_skills_data_read(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let skill_id = params
-            .get("skill_id")
-            .and_then(|v| v.as_str())
-            .ok_or("missing skill_id")?
-            .to_string();
-        let filename = params
-            .get("filename")
-            .and_then(|v| v.as_str())
-            .ok_or("missing filename")?
-            .to_string();
-        let engine = require_engine()?;
-        let content = engine.data_read(&skill_id, &filename)?;
-        Ok(serde_json::json!({ "content": content }))
-    })
-}
-
-/// RPC handler to write a file to a skill's isolated data directory.
-fn handle_skills_data_write(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let skill_id = params
-            .get("skill_id")
-            .and_then(|v| v.as_str())
-            .ok_or("missing skill_id")?
-            .to_string();
-        let filename = params
-            .get("filename")
-            .and_then(|v| v.as_str())
-            .ok_or("missing filename")?
-            .to_string();
-        let content = params
-            .get("content")
-            .and_then(|v| v.as_str())
-            .ok_or("missing content")?
-            .to_string();
-        let engine = require_engine()?;
-        engine.data_write(&skill_id, &filename, &content)?;
-        Ok(serde_json::json!({ "ok": true }))
-    })
-}
-
-/// RPC handler to get the absolute path to a skill's data directory.
-fn handle_skills_data_dir(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        let path = engine.skill_data_dir(&p.skill_id);
-        Ok(serde_json::json!({ "path": path.display().to_string() }))
-    })
-}
-
-/// RPC handler to get storage statistics for a skill's data directory.
-fn handle_skills_data_stats(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        let stats = engine.skill_data_directory_stats(&p.skill_id);
-        serde_json::to_value(&stats).map_err(|e| e.to_string())
-    })
-}
-
-/// RPC handler to enable a skill: marks setup_complete and starts it.
-///
-/// Skills no longer have a separate `enabled` toggle — the only state is
-/// "setup is complete" (driven by oauth/auth completion). This handler exists
-/// as a back-compat shim for the frontend; it sets `setup_complete = true`
-/// and starts the skill in one shot.
-fn handle_skills_enable(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine.preferences().set_setup_complete(&p.skill_id, true);
-        engine.start_skill(&p.skill_id).await?;
-        Ok(serde_json::json!({ "ok": true }))
-    })
-}
-
-/// RPC handler to disable a skill: clears setup_complete and stops it.
-fn handle_skills_disable(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine.preferences().set_setup_complete(&p.skill_id, false);
-        if engine.get_skill_state(&p.skill_id).is_some() {
-            engine.stop_skill(&p.skill_id).await?;
-        }
-        Ok(serde_json::json!({ "ok": true }))
-    })
-}
-
-/// RPC handler to check if a skill should currently be running.
-///
-/// Reports `setup_complete` so the frontend's existing "enabled" UI keeps
-/// working without learning a new term.
-fn handle_skills_is_enabled(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SkillIdParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        let enabled = engine.preferences().is_setup_complete(&p.skill_id);
-        Ok(serde_json::json!({ "enabled": enabled }))
-    })
-}
-
-/// Parameters for the `skills.set_setup_complete` RPC method.
-#[derive(Deserialize)]
-struct SetSetupCompleteParams {
-    /// The skill ID.
-    skill_id: String,
-    /// Whether the setup flow is considered complete.
-    complete: bool,
-}
-
-/// RPC handler to persist the setup completion flag for a skill.
-fn handle_skills_set_setup_complete(params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let p: SetSetupCompleteParams =
-            serde_json::from_value(Value::Object(params)).map_err(|e| e.to_string())?;
-        let engine = require_engine()?;
-        engine
-            .preferences()
-            .set_setup_complete(&p.skill_id, p.complete);
-        Ok(serde_json::json!({
-            "success": true,
-            "skill_id": p.skill_id,
-            "setup_complete": p.complete
-        }))
-    })
-}
-
-/// RPC handler to get all skill snapshots enriched with UI-specific metadata.
-fn handle_skills_get_all_snapshots(_params: Map<String, Value>) -> ControllerFuture {
-    Box::pin(async move {
-        let engine = require_engine()?;
-        let snapshots = engine.list_skills();
-        serde_json::to_value(&snapshots).map_err(|e| e.to_string())
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn all_schemas_have_matching_handlers() {
-        let schemas = all_controller_schemas();
-        let controllers = all_registered_controllers();
-        assert_eq!(
-            schemas.len(),
-            controllers.len(),
-            "schema count must match handler count"
-        );
-        for schema in &schemas {
-            let method = format!("{}.{}", schema.namespace, schema.function);
-            assert!(
-                controllers
-                    .iter()
-                    .any(|c| c.schema.namespace == schema.namespace
-                        && c.schema.function == schema.function),
-                "no handler for schema '{method}'"
-            );
-        }
-    }
-
-    #[test]
-    fn runtime_schemas_exist() {
-        let schemas = all_controller_schemas();
-        let expected = [
-            "start",
-            "stop",
-            "status",
-            "setup_start",
-            "list_tools",
-            "sync",
-            "call_tool",
-        ];
-        for func in &expected {
-            assert!(
-                schemas
-                    .iter()
-                    .any(|s| s.namespace == "skills" && s.function == *func),
-                "missing skills.{func} schema"
-            );
-        }
-    }
-
-    #[test]
-    fn call_tool_schema_has_required_inputs() {
-        let schema = skills_schema("call_tool");
-        let required: Vec<&str> = schema
-            .inputs
-            .iter()
-            .filter(|f| f.required)
-            .map(|f| f.name)
-            .collect();
-        assert!(required.contains(&"skill_id"));
-        assert!(required.contains(&"tool_name"));
-        // arguments is optional
-        let args = schema
-            .inputs
-            .iter()
-            .find(|f| f.name == "arguments")
-            .unwrap();
-        assert!(!args.required);
-    }
-
-    #[tokio::test]
-    async fn runtime_handlers_fail_without_engine() {
-        // When no global engine is set, runtime handlers should return an error
-        let cases = vec![
-            ("start", serde_json::json!({"skill_id": "test"})),
-            ("stop", serde_json::json!({"skill_id": "test"})),
-            ("status", serde_json::json!({"skill_id": "test"})),
-            ("setup_start", serde_json::json!({"skill_id": "test"})),
-            ("list_tools", serde_json::json!({"skill_id": "test"})),
-            ("sync", serde_json::json!({"skill_id": "test"})),
-            (
-                "call_tool",
-                serde_json::json!({"skill_id": "test", "tool_name": "t"}),
-            ),
-        ];
-
-        let controllers = all_registered_controllers();
-        for (func, params) in cases {
-            let controller = controllers
-                .iter()
-                .find(|c| c.schema.namespace == "skills" && c.schema.function == func)
-                .unwrap_or_else(|| panic!("missing controller for skills.{func}"));
-
-            let params_map: Map<String, Value> = params.as_object().unwrap().clone();
-            let result = (controller.handler)(params_map).await;
-            assert!(
-                result.is_err(),
-                "skills.{func} should fail without engine, got: {:?}",
-                result
-            );
-            let err = result.unwrap_err();
-            assert!(
-                err.contains("runtime not initialized"),
-                "skills.{func} error should mention runtime: {err}"
-            );
-        }
-    }
-}
diff --git a/src/openhuman/skills/skill_registry.rs b/src/openhuman/skills/skill_registry.rs
deleted file mode 100644
index fe737d9a6..000000000
--- a/src/openhuman/skills/skill_registry.rs
+++ /dev/null
@@ -1,575 +0,0 @@
-//! SkillRegistry — tracks all registered/running skills and routes messages.
-//!
-//! The registry is the central source of truth for which skills are currently
-//! active in the runtime. It manages the communication channels (senders) to
-//! each skill's event loop and provides methods for interacting with them.
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use parking_lot::RwLock;
-use tokio::sync::{mpsc, oneshot};
-
-use crate::openhuman::skills::qjs_skill_instance::SkillState;
-use crate::openhuman::skills::types::{
-    self, SkillConfig, SkillMessage, SkillSnapshot, SkillStatus, ToolCallOrigin, ToolDefinition,
-    ToolResult,
-};
-
-/// Internal entry in the registry representing a single skill instance.
-struct RegistryEntry {
-    /// Sender to the skill's message loop for asynchronous communication.
-    sender: mpsc::Sender<SkillMessage>,
-    /// Shared state of the skill, readable without going through the message loop.
-    state: Arc<RwLock<SkillState>>,
-    /// Configuration of the skill, derived from its manifest.
-    config: SkillConfig,
-    /// Handle to the spawned Tokio task running the skill's event loop.
-    #[allow(dead_code)]
-    task_handle: Option<tokio::task::JoinHandle<()>>,
-}
-
-/// Central registry of all skills known to the runtime.
-///
-/// This struct provides thread-safe access to all active skills and mediates
-/// message routing, tool calls, and event broadcasting.
-pub struct SkillRegistry {
-    /// Map of skill IDs to their registry entries, protected by a read-write lock.
-    skills: RwLock<HashMap<String, RegistryEntry>>,
-}
-
-impl SkillRegistry {
-    /// Create a new, empty SkillRegistry.
-    pub fn new() -> Self {
-        Self {
-            skills: RwLock::new(HashMap::new()),
-        }
-    }
-
-    /// Register a skill instance after it has been created and spawned.
-    ///
-    /// This makes the skill available for discovery and interaction through the registry.
-    pub fn register(
-        &self,
-        skill_id: &str,
-        config: SkillConfig,
-        sender: mpsc::Sender<SkillMessage>,
-        state: Arc<RwLock<SkillState>>,
-        task_handle: tokio::task::JoinHandle<()>,
-    ) {
-        log::info!("[runtime] registering skill '{}'", skill_id);
-        self.skills.write().insert(
-            skill_id.to_string(),
-            RegistryEntry {
-                sender,
-                state,
-                config,
-                task_handle: Some(task_handle),
-            },
-        );
-    }
-
-    /// Unregister a skill from the registry.
-    ///
-    /// This is typically called after a skill has successfully stopped.
-    pub fn unregister(&self, skill_id: &str) {
-        self.skills.write().remove(skill_id);
-    }
-
-    /// Get a snapshot of all currently registered skills.
-    ///
-    /// Returns a list of `SkillSnapshot` containing the latest state of each skill.
-    pub fn list_skills(&self) -> Vec<SkillSnapshot> {
-        self.skills
-            .read()
-            .iter()
-            .map(|(skill_id, entry)| {
-                let state = entry.state.read();
-                Self::build_snapshot(skill_id, entry, &state)
-            })
-            .collect()
-    }
-
-    /// Get a snapshot of a single skill by its ID.
-    ///
-    /// Returns `None` if the skill is not found in the registry.
-    pub fn get_skill(&self, skill_id: &str) -> Option<SkillSnapshot> {
-        let skills = self.skills.read();
-        skills.get(skill_id).map(|entry| {
-            let state = entry.state.read();
-            Self::build_snapshot(skill_id, entry, &state)
-        })
-    }
-
-    /// Helper function to build a `SkillSnapshot` from a `RegistryEntry` and its current `SkillState`.
-    fn build_snapshot(skill_id: &str, entry: &RegistryEntry, state: &SkillState) -> SkillSnapshot {
-        use crate::openhuman::skills::types::derive_connection_status;
-
-        // setup_complete is populated later by the caller who has access to PreferencesStore
-        let setup_complete = false;
-        let connection_status =
-            derive_connection_status(state.status, setup_complete, &state.published_state);
-
-        SkillSnapshot {
-            skill_id: skill_id.to_string(),
-            name: entry.config.name.clone(),
-            status: state.status,
-            tools: state.tools.clone(),
-            error: state.error.clone(),
-            state: state.published_state.clone(),
-            setup_complete,
-            connection_status,
-        }
-    }
-
-    /// Get the current status of a specific skill.
-    #[allow(dead_code)]
-    pub fn get_status(&self, skill_id: &str) -> Option<SkillStatus> {
-        self.skills
-            .read()
-            .get(skill_id)
-            .map(|e| e.state.read().status)
-    }
-
-    /// Call a tool on a specific skill from an external host surface (e.g., UI, CLI).
-    pub async fn call_tool(
-        &self,
-        skill_id: &str,
-        tool_name: &str,
-        arguments: serde_json::Value,
-    ) -> Result<ToolResult, String> {
-        self.call_tool_scoped(ToolCallOrigin::External, skill_id, tool_name, arguments)
-            .await
-    }
-
-    /// Call a tool with an explicit origin so runtime policy can enforce security boundaries.
-    ///
-    /// Currently, cross-skill tool calls are forbidden to ensure isolation.
-    pub async fn call_tool_scoped(
-        &self,
-        origin: ToolCallOrigin,
-        skill_id: &str,
-        tool_name: &str,
-        arguments: serde_json::Value,
-    ) -> Result<ToolResult, String> {
-        // Enforce isolation: A skill cannot call tools belonging to another skill.
-        if let ToolCallOrigin::SkillSelf {
-            skill_id: caller_skill_id,
-        } = &origin
-        {
-            if caller_skill_id != skill_id {
-                return Err(format!(
-                    "Cross-skill tool calls are forbidden: '{}' cannot call '{}.{}'",
-                    caller_skill_id, skill_id, tool_name
-                ));
-            }
-        }
-
-        log::info!(
-            "[skill:{}] call_tool '{}' — dispatching to event loop",
-            skill_id,
-            tool_name
-        );
-
-        // Retrieve the sender for the target skill's event loop.
-        let sender = {
-            let skills = self.skills.read();
-            let entry = skills
-                .get(skill_id)
-                .ok_or_else(|| format!("Skill '{}' not found", skill_id))?;
-            let status = entry.state.read().status;
-            if status != SkillStatus::Running {
-                log::warn!(
-                    "[skill:{}] call_tool '{}' — skill not running (status: {:?})",
-                    skill_id,
-                    tool_name,
-                    status
-                );
-                return Err(format!(
-                    "Skill '{}' is not running (status: {:?})",
-                    skill_id, status
-                ));
-            }
-            entry.sender.clone()
-        };
-
-        // Create a one-shot channel to receive the tool result from the skill's event loop.
-        let (reply_tx, reply_rx) = oneshot::channel();
-        sender
-            .send(SkillMessage::CallTool {
-                tool_name: tool_name.to_string(),
-                arguments,
-                reply: reply_tx,
-            })
-            .await
-            .map_err(|_| {
-                log::error!(
-                    "[skill:{}] call_tool '{}' — message channel closed",
-                    skill_id,
-                    tool_name
-                );
-                format!("Skill '{}' message channel closed", skill_id)
-            })?;
-
-        log::debug!(
-            "[skill:{}] call_tool '{}' — message sent, waiting for reply",
-            skill_id,
-            tool_name
-        );
-
-        // Wait for the skill to process the tool call and return a result.
-        match reply_rx.await {
-            Ok(result) => {
-                log::info!(
-                    "[skill:{}] call_tool '{}' — got reply (is_err: {})",
-                    skill_id,
-                    tool_name,
-                    result.is_err()
-                );
-                result
-            }
-            Err(_) => {
-                log::error!(
-                    "[skill:{}] call_tool '{}' — reply channel dropped (skill event loop may have crashed or tool timed out)",
-                    skill_id,
-                    tool_name
-                );
-                Err(format!(
-                    "Skill '{}' did not respond to tool call '{}'",
-                    skill_id, tool_name
-                ))
-            }
-        }
-    }
-
-    /// Send a server event to all skills that are currently in the `Running` state.
-    pub async fn broadcast_event(&self, event: &str, data: serde_json::Value) {
-        let senders: Vec<mpsc::Sender<SkillMessage>> = {
-            self.skills
-                .read()
-                .values()
-                .filter(|e| e.state.read().status == SkillStatus::Running)
-                .map(|e| e.sender.clone())
-                .collect()
-        };
-
-        for sender in senders {
-            let _ = sender
-                .send(SkillMessage::ServerEvent {
-                    event: event.to_string(),
-                    data: data.clone(),
-                })
-                .await;
-        }
-    }
-
-    /// Send a cron trigger message to a specific skill.
-    #[allow(dead_code)]
-    pub async fn trigger_cron(&self, skill_id: &str, schedule_id: &str) -> Result<(), String> {
-        let sender = {
-            let skills = self.skills.read();
-            let entry = skills
-                .get(skill_id)
-                .ok_or_else(|| format!("Skill '{}' not found", skill_id))?;
-            entry.sender.clone()
-        };
-
-        sender
-            .send(SkillMessage::CronTrigger {
-                schedule_id: schedule_id.to_string(),
-            })
-            .await
-            .map_err(|_| format!("Skill '{}' message channel closed", skill_id))
-    }
-
-    /// Stop a specific skill gracefully by sending a `Stop` message.
-    ///
-    /// It waits up to 5 seconds for the skill to acknowledge the stop request.
-    pub async fn stop_skill(&self, skill_id: &str) -> Result<(), String> {
-        let sender = {
-            let skills = self.skills.read();
-            let entry = skills
-                .get(skill_id)
-                .ok_or_else(|| format!("Skill '{}' not found", skill_id))?;
-
-            // Transition the skill state to `Stopping`.
-            entry.state.write().status = SkillStatus::Stopping;
-            entry.sender.clone()
-        };
-
-        let (reply_tx, reply_rx) = oneshot::channel();
-        sender
-            .send(SkillMessage::Stop { reply: reply_tx })
-            .await
-            .map_err(|_| format!("Skill '{}' message channel closed", skill_id))?;
-
-        // Wait for the skill to acknowledge stopping, with a 5-second timeout.
-        let _ = tokio::time::timeout(std::time::Duration::from_secs(5), reply_rx).await;
-
-        // Note: The skill is NOT unregistered here. It remains in the registry
-        // with `Stopped` status, allowing it to be restarted without full discovery.
-        Ok(())
-    }
-
-    /// Get all tool definitions across all running skills.
-    ///
-    /// Returns a list of tuples containing the skill ID and the tool definition.
-    pub fn all_tools(&self) -> Vec<(String, ToolDefinition)> {
-        self.skills
-            .read()
-            .iter()
-            .filter(|(_, entry)| entry.state.read().status == SkillStatus::Running)
-            .flat_map(|(skill_id, entry)| {
-                let state = entry.state.read();
-                state
-                    .tools
-                    .iter()
-                    .map(|t| (skill_id.clone(), t.clone()))
-                    .collect::<Vec<_>>()
-            })
-            .collect()
-    }
-
-    /// Check if a skill with the given ID is present in the registry.
-    pub fn has_skill(&self, skill_id: &str) -> bool {
-        self.skills.read().contains_key(skill_id)
-    }
-
-    /// Merge a patch into a running skill's published state and broadcast the change.
-    ///
-    /// This is used by components like the ping scheduler to update health information.
-    pub async fn merge_published_state(
-        &self,
-        skill_id: &str,
-        patch: HashMap<String, serde_json::Value>,
-    ) -> Result<(), String> {
-        {
-            let skills = self.skills.read();
-            let entry = skills
-                .get(skill_id)
-                .ok_or_else(|| format!("Skill '{}' not found", skill_id))?;
-            let mut state = entry.state.write();
-            if state.status != SkillStatus::Running {
-                return Err(format!(
-                    "Skill '{}' is not running (status: {:?})",
-                    skill_id, state.status
-                ));
-            }
-            for (k, v) in patch {
-                state.published_state.insert(k, v);
-            }
-        }
-        // Notify the rest of the system that the skill's state has changed.
-        self.broadcast_event(
-            types::events::SKILL_STATE_CHANGED,
-            serde_json::json!({ "skill_id": skill_id }),
-        )
-        .await;
-        Ok(())
-    }
-
-    /// Send a raw `SkillMessage` to a specific skill's message loop.
-    ///
-    /// This is a non-blocking operation that returns an error if the skill
-    /// is not running or the message channel is full/closed.
-    pub fn send_message(&self, skill_id: &str, msg: SkillMessage) -> Result<(), String> {
-        log::info!("[runtime] sending message to '{}': {:?}", skill_id, msg);
-        let sender = {
-            let skills = self.skills.read();
-            let entry = skills
-                .get(skill_id)
-                .ok_or_else(|| format!("Skill '{}' not found", skill_id))?;
-            let status = entry.state.read().status;
-            if status != SkillStatus::Running {
-                return Err(format!(
-                    "Skill '{}' is not running (status: {:?})",
-                    skill_id, status
-                ));
-            }
-            entry.sender.clone()
-        };
-
-        match sender.try_send(msg) {
-            Ok(()) => {
-                log::info!(
-                    "[runtime] Successfully sent message to skill '{}'",
-                    skill_id
-                );
-                Ok(())
-            }
-            Err(e) => {
-                let error_msg = format!("Failed to send message to skill '{}': {e}", skill_id);
-                log::error!("[runtime] {}", error_msg);
-                Err(error_msg)
-            }
-        }
-    }
-
-    /// Send an incoming webhook request to a specific skill and wait for its response.
-    ///
-    /// This routes a request from an external tunnel to the skill's internal
-    /// webhook handler. It returns the response (status, headers, body) or an error.
-    ///
-    /// The request will time out after 25 seconds if no response is received.
-    pub async fn send_webhook_request(
-        &self,
-        skill_id: &str,
-        correlation_id: String,
-        method: String,
-        path: String,
-        headers: std::collections::HashMap<String, serde_json::Value>,
-        query: std::collections::HashMap<String, String>,
-        body: String,
-        tunnel_id: String,
-        tunnel_name: String,
-    ) -> Result<crate::openhuman::webhooks::WebhookResponseData, String> {
-        let sender = {
-            let skills = self.skills.read();
-            let entry = skills
-                .get(skill_id)
-                .ok_or_else(|| format!("Skill '{}' not found", skill_id))?;
-            let status = entry.state.read().status;
-            if status != SkillStatus::Running {
-                return Err(format!(
-                    "Skill '{}' is not running (status: {:?})",
-                    skill_id, status
-                ));
-            }
-            entry.sender.clone()
-        };
-
-        let (reply_tx, reply_rx) = oneshot::channel();
-
-        sender
-            .send(SkillMessage::WebhookRequest {
-                correlation_id,
-                method,
-                path,
-                headers,
-                query,
-                body,
-                tunnel_id,
-                tunnel_name,
-                reply: reply_tx,
-            })
-            .await
-            .map_err(|_| format!("Skill '{}' message channel closed", skill_id))?;
-
-        // Wait for the skill to respond, with a 25-second timeout.
-        match tokio::time::timeout(std::time::Duration::from_secs(25), reply_rx).await {
-            Ok(Ok(result)) => result,
-            Ok(Err(_)) => Err(format!(
-                "Skill '{}' webhook reply channel dropped",
-                skill_id
-            )),
-            Err(_) => Err(format!(
-                "Skill '{}' webhook handler timed out (25s)",
-                skill_id
-            )),
-        }
-    }
-}
-
-impl Default for SkillRegistry {
-    /// Create a default, empty SkillRegistry.
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::openhuman::skills::types::{SkillConfig, SkillStatus, ToolCallOrigin};
-
-    fn register_running_skill(registry: &SkillRegistry, skill_id: &str) {
-        let (tx, mut rx) = mpsc::channel(8);
-        let state = Arc::new(RwLock::new(SkillState {
-            status: SkillStatus::Running,
-            tools: vec![],
-            error: None,
-            published_state: HashMap::new(),
-        }));
-        let task = tokio::spawn(async move {
-            while let Some(msg) = rx.recv().await {
-                if let SkillMessage::CallTool { reply, .. } = msg {
-                    let _ = reply.send(Ok(ToolResult {
-                        content: vec![],
-                        is_error: false,
-                    }));
-                }
-            }
-        });
-
-        registry.register(
-            skill_id,
-            SkillConfig {
-                skill_id: skill_id.to_string(),
-                name: skill_id.to_string(),
-                entry_point: "index.js".to_string(),
-                memory_limit: 1024,
-                auto_start: false,
-            },
-            tx,
-            state,
-            task,
-        );
-    }
-
-    #[tokio::test]
-    async fn external_origin_can_call_any_skill_tool() {
-        let registry = SkillRegistry::new();
-        register_running_skill(&registry, "alpha");
-
-        let result = registry
-            .call_tool_scoped(
-                ToolCallOrigin::External,
-                "alpha",
-                "echo",
-                serde_json::json!({}),
-            )
-            .await;
-
-        assert!(result.is_ok());
-    }
-
-    #[tokio::test]
-    async fn skill_origin_cannot_call_other_skill_tool() {
-        let registry = SkillRegistry::new();
-        register_running_skill(&registry, "alpha");
-        register_running_skill(&registry, "beta");
-
-        let err = registry
-            .call_tool_scoped(
-                ToolCallOrigin::SkillSelf {
-                    skill_id: "alpha".to_string(),
-                },
-                "beta",
-                "echo",
-                serde_json::json!({}),
-            )
-            .await
-            .expect_err("cross-skill call should be denied");
-
-        assert!(err.contains("Cross-skill tool calls are forbidden"));
-    }
-
-    #[tokio::test]
-    async fn skill_origin_can_call_own_tool() {
-        let registry = SkillRegistry::new();
-        register_running_skill(&registry, "alpha");
-
-        let result = registry
-            .call_tool_scoped(
-                ToolCallOrigin::SkillSelf {
-                    skill_id: "alpha".to_string(),
-                },
-                "alpha",
-                "echo",
-                serde_json::json!({}),
-            )
-            .await;
-
-        assert!(result.is_ok());
-    }
-}
diff --git a/src/openhuman/skills/types.rs b/src/openhuman/skills/types.rs
index d6a93ab3c..7efd38713 100644
--- a/src/openhuman/skills/types.rs
+++ b/src/openhuman/skills/types.rs
@@ -1,190 +1,11 @@
-//! Core type definitions for the QuickJS skill runtime.
-//!
-//! This module defines the essential data structures used throughout the skills system,
-//! including lifecycle statuses, message types for internal communication,
-//! tool definitions, and state snapshots.
+//! Shared tool result types retained after QuickJS runtime removal.
 
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-use crate::openhuman::webhooks::WebhookResponseData;
-
-/// Status of a running skill instance.
-///
-/// Represents the current phase of a skill's lifecycle, from registration
-/// to active execution or error states.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-#[derive(Default)]
-pub enum SkillStatus {
-    /// Skill is registered but its execution has not yet started.
-    #[default]
-    Pending,
-    /// Skill is currently initializing (e.g., loading JS, running `onInit()`).
-    Initializing,
-    /// Skill is actively running and ready to handle tool calls or events.
-    Running,
-    /// Skill is in the process of shutting down gracefully.
-    Stopping,
-    /// Skill has been stopped and its execution loop has terminated.
-    Stopped,
-    /// Skill encountered a fatal error and cannot continue execution.
-    Error,
-}
-
-/// Messages sent to a skill instance's message loop for processing.
-///
-/// This enum covers all possible interactions between the runtime/host
-/// and the skill's JavaScript environment.
-#[derive(Debug)]
-pub enum SkillMessage {
-    /// Request the skill to execute one of its exported tools.
-    CallTool {
-        /// Name of the tool to call.
-        tool_name: String,
-        /// JSON arguments to pass to the tool.
-        arguments: serde_json::Value,
-        /// Channel to send the tool execution result back to the caller.
-        reply: tokio::sync::oneshot::Sender<Result<ToolResult, String>>,
-    },
-    /// Deliver a system-wide or custom server event to the skill.
-    ServerEvent {
-        /// Name of the event.
-        event: String,
-        /// JSON data associated with the event.
-        data: serde_json::Value,
-    },
-    /// Trigger a pre-registered cron job within the skill.
-    CronTrigger {
-        /// Identifier of the schedule that triggered this message.
-        schedule_id: String,
-    },
-    /// Request the skill to stop its execution gracefully.
-    Stop {
-        /// Channel to acknowledge when the skill has finished stopping.
-        reply: tokio::sync::oneshot::Sender<()>,
-    },
-    /// Signal the start of the skill's setup/configuration flow.
-    SetupStart {
-        /// Channel to return the first setup step definition.
-        reply: tokio::sync::oneshot::Sender<Result<serde_json::Value, String>>,
-    },
-    /// Submit user input for a specific setup step.
-    SetupSubmit {
-        /// Identifier of the setup step being submitted.
-        step_id: String,
-        /// JSON values provided by the user.
-        values: serde_json::Value,
-        /// Channel to return the next setup step or a completion signal.
-        reply: tokio::sync::oneshot::Sender<Result<serde_json::Value, String>>,
-    },
-    /// Abort the current setup flow.
-    SetupCancel {
-        /// Channel to acknowledge the cancellation.
-        reply: tokio::sync::oneshot::Sender<Result<(), String>>,
-    },
-    /// Request a list of all runtime-configurable options supported by the skill.
-    ListOptions {
-        /// Channel to return the list of options.
-        reply: tokio::sync::oneshot::Sender<Result<serde_json::Value, String>>,
-    },
-    /// Update the value of a specific skill option.
-    SetOption {
-        /// Name of the option to set.
-        name: String,
-        /// New JSON value for the option.
-        value: serde_json::Value,
-        /// Channel to acknowledge the update.
-        reply: tokio::sync::oneshot::Sender<Result<(), String>>,
-    },
-    /// Notify the skill that a new AI interaction session has started.
-    SessionStart {
-        /// Unique identifier for the session.
-        session_id: String,
-        /// Channel to acknowledge the notification.
-        reply: tokio::sync::oneshot::Sender<Result<(), String>>,
-    },
-    /// Notify the skill that an AI interaction session has ended.
-    SessionEnd {
-        /// Unique identifier for the session.
-        session_id: String,
-        /// Channel to acknowledge the notification.
-        reply: tokio::sync::oneshot::Sender<Result<(), String>>,
-    },
-    /// Trigger a periodic "tick" event for skills that need regular maintenance.
-    Tick {
-        /// Channel to acknowledge processing of the tick.
-        reply: tokio::sync::oneshot::Sender<Result<(), String>>,
-    },
-    /// Deliver an error notification from an asynchronous background operation.
-    Error {
-        /// Category of the error.
-        error_type: String,
-        /// human-readable error message.
-        message: String,
-        /// Optional source identifier where the error originated.
-        source: Option<String>,
-        /// Whether the skill can attempt to recover from this error.
-        recoverable: bool,
-    },
-    /// Route a generic JSON-RPC call to the skill's custom RPC handler.
-    Rpc {
-        /// Method name.
-        method: String,
-        /// JSON parameters for the method.
-        params: serde_json::Value,
-        /// Channel to return the RPC result.
-        reply: tokio::sync::oneshot::Sender<Result<serde_json::Value, String>>,
-    },
-    /// Pass parameters loaded from the frontend to the skill.
-    ///
-    /// Typically used to provide session-specific data like wallet addresses.
-    LoadParams {
-        /// JSON parameters to load.
-        params: serde_json::Value,
-    },
-    /// Deliver a targeted webhook request to the skill.
-    WebhookRequest {
-        /// Unique ID for tracking this specific request/response cycle.
-        correlation_id: String,
-        /// HTTP method (GET, POST, etc.).
-        method: String,
-        /// Request path relative to the skill's endpoint.
-        path: String,
-        /// Map of HTTP headers.
-        headers: HashMap<String, serde_json::Value>,
-        /// Map of query string parameters.
-        query: HashMap<String, String>,
-        /// Raw request body as a string.
-        body: String,
-        /// Identifier of the tunnel through which the request arrived.
-        tunnel_id: String,
-        /// Human-readable name of the tunnel.
-        tunnel_name: String,
-        /// Channel to return the skill's HTTP response.
-        reply: tokio::sync::oneshot::Sender<Result<WebhookResponseData, String>>,
-    },
-}
-
-/// Defines the origin of a tool-call request for security policy enforcement.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ToolCallOrigin {
-    /// Request initiated from outside the skill runtime (e.g., UI, backend, or CLI).
-    External,
-    /// Request initiated from within a skill's own execution environment.
-    SkillSelf {
-        /// ID of the skill making the call.
-        skill_id: String,
-    },
-}
 
 /// Result of executing a tool, containing content blocks and error status.
-///
-/// This is the **unified** tool result type used by both built-in tools and
-/// QuickJS skill tools. Follows the MCP (Model Context Protocol) specification.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ToolResult {
-    /// List of content blocks returned by the tool (follows MCP specification).
+    /// List of content blocks returned by the tool.
     pub content: Vec<ToolContent>,
     /// Indicates if the tool encountered an error during execution.
     #[serde(default)]
@@ -192,7 +13,6 @@ pub struct ToolResult {
 }
 
 impl ToolResult {
-    /// Create a successful result with a single text block.
     pub fn success(text: impl Into<String>) -> Self {
         Self {
             content: vec![ToolContent::Text { text: text.into() }],
@@ -200,7 +20,6 @@ impl ToolResult {
         }
     }
 
-    /// Create an error result with a single text block.
     pub fn error(message: impl Into<String>) -> Self {
         Self {
             content: vec![ToolContent::Text {
@@ -210,7 +29,6 @@ impl ToolResult {
         }
     }
 
-    /// Create a successful result with structured JSON data.
     pub fn json(data: serde_json::Value) -> Self {
         Self {
             content: vec![ToolContent::Json { data }],
@@ -218,19 +36,17 @@ impl ToolResult {
         }
     }
 
-    /// Extract all text content as a single joined string.
     pub fn text(&self) -> String {
         self.content
             .iter()
             .filter_map(|c| match c {
                 ToolContent::Text { text } => Some(text.as_str()),
-                ToolContent::Json { data: _ } => None,
+                ToolContent::Json { .. } => None,
             })
             .collect::<Vec<_>>()
             .join("\n")
     }
 
-    /// Extract all content (text + JSON) as a single string.
     pub fn output(&self) -> String {
         self.content
             .iter()
@@ -249,302 +65,6 @@ impl ToolResult {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum ToolContent {
-    /// plain-text output.
     Text { text: String },
-    /// Structured JSON data output.
     Json { data: serde_json::Value },
 }
-
-/// Metadata defining a tool exported by a skill.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ToolDefinition {
-    /// Unique name of the tool within the scope of the skill.
-    pub name: String,
-    /// Human-readable description of what the tool does.
-    pub description: String,
-    /// JSON Schema defining the expected input parameters for the tool.
-    #[serde(default, rename = "inputSchema")]
-    pub input_schema: serde_json::Value,
-}
-
-/// A comprehensive snapshot of a skill's current state.
-///
-/// This struct is serialized and sent to the frontend to update the UI.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SkillSnapshot {
-    /// Unique identifier for the skill.
-    pub skill_id: String,
-    /// Human-readable display name.
-    pub name: String,
-    /// Current lifecycle status (e.g., Running, Error).
-    pub status: SkillStatus,
-    /// List of tools currently exported by the skill.
-    pub tools: Vec<ToolDefinition>,
-    /// Optional error message if the skill is in an `Error` state.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error: Option<String>,
-    /// Arbitrary key-value state published by the skill for UI consumption.
-    #[serde(default)]
-    pub state: HashMap<String, serde_json::Value>,
-    /// Whether the skill has completed its initial setup/OAuth flow.
-    #[serde(default)]
-    pub setup_complete: bool,
-    /// High-level connection health string derived from status and published state.
-    #[serde(default)]
-    pub connection_status: String,
-}
-
-/// Derive a unified connection status string for UI display.
-///
-/// This function translates internal statuses and skill-reported health
-/// (e.g., auth status) into a set of standard strings consumed by the frontend.
-pub fn derive_connection_status(
-    status: SkillStatus,
-    setup_complete: bool,
-    published_state: &HashMap<String, serde_json::Value>,
-) -> String {
-    match status {
-        SkillStatus::Pending | SkillStatus::Stopped | SkillStatus::Stopping => {
-            return "offline".to_string()
-        }
-        SkillStatus::Error => return "error".to_string(),
-        SkillStatus::Initializing => return "connecting".to_string(),
-        _ => {}
-    }
-
-    let conn = published_state
-        .get("connection_status")
-        .and_then(|v| v.as_str());
-    let auth = published_state.get("auth_status").and_then(|v| v.as_str());
-
-    // No self-reported state — derive from lifecycle + setup
-    if conn.is_none() && auth.is_none() {
-        if setup_complete && matches!(status, SkillStatus::Running) {
-            return "connected".to_string();
-        }
-        if !setup_complete {
-            return "setup_required".to_string();
-        }
-        return "connecting".to_string();
-    }
-
-    if conn == Some("error") || auth == Some("error") {
-        return "error".to_string();
-    }
-    if conn == Some("connecting") || auth == Some("authenticating") {
-        return "connecting".to_string();
-    }
-    if conn == Some("connected") {
-        if auth.is_none() || auth == Some("authenticated") {
-            return "connected".to_string();
-        }
-        if auth == Some("not_authenticated") {
-            return "not_authenticated".to_string();
-        }
-    }
-    if conn == Some("disconnected") {
-        if setup_complete {
-            return "disconnected".to_string();
-        }
-        return "setup_required".to_string();
-    }
-
-    "connecting".to_string()
-}
-
-/// Configuration for a skill instance, derived from its manifest.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SkillConfig {
-    /// Unique identifier for the skill.
-    pub skill_id: String,
-    /// human-readable display name.
-    pub name: String,
-    /// Filename of the JavaScript entry point.
-    pub entry_point: String,
-    /// Maximum memory allowed for the JS runtime in bytes.
-    #[serde(default = "default_memory_limit")]
-    pub memory_limit: usize,
-    /// Whether the skill should be started automatically.
-    #[serde(default)]
-    pub auto_start: bool,
-}
-
-fn default_memory_limit() -> usize {
-    256 * 1024 * 1024 // 256 MB
-}
-
-/// Constants for events emitted from the runtime to the frontend via Tauri.
-pub mod events {
-    /// Emitted when a skill's internal state or status changes.
-    pub const SKILL_STATE_CHANGED: &str = "runtime:skill-state-changed";
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn state_with(entries: &[(&str, &str)]) -> HashMap<String, serde_json::Value> {
-        entries
-            .iter()
-            .map(|(k, v)| (k.to_string(), serde_json::Value::String(v.to_string())))
-            .collect()
-    }
-
-    // --- Status-based early returns ---
-
-    #[test]
-    fn pending_returns_offline() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Pending, true, &HashMap::new()),
-            "offline"
-        );
-    }
-
-    #[test]
-    fn stopped_returns_offline() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Stopped, true, &HashMap::new()),
-            "offline"
-        );
-    }
-
-    #[test]
-    fn stopping_returns_offline() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Stopping, true, &HashMap::new()),
-            "offline"
-        );
-    }
-
-    #[test]
-    fn error_status_returns_error() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Error, true, &HashMap::new()),
-            "error"
-        );
-    }
-
-    #[test]
-    fn initializing_returns_connecting() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Initializing, false, &HashMap::new()),
-            "connecting"
-        );
-    }
-
-    // --- No published state ---
-
-    #[test]
-    fn running_setup_complete_no_state_returns_connected() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &HashMap::new()),
-            "connected"
-        );
-    }
-
-    #[test]
-    fn running_no_setup_no_state_returns_setup_required() {
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, false, &HashMap::new()),
-            "setup_required"
-        );
-    }
-
-    // --- Published connection_status ---
-
-    #[test]
-    fn conn_error_returns_error() {
-        let st = state_with(&[("connection_status", "error")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "error"
-        );
-    }
-
-    #[test]
-    fn auth_error_returns_error() {
-        let st = state_with(&[("auth_status", "error")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "error"
-        );
-    }
-
-    #[test]
-    fn conn_connecting_returns_connecting() {
-        let st = state_with(&[("connection_status", "connecting")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "connecting"
-        );
-    }
-
-    #[test]
-    fn auth_authenticating_returns_connecting() {
-        let st = state_with(&[("auth_status", "authenticating")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "connecting"
-        );
-    }
-
-    #[test]
-    fn conn_connected_no_auth_returns_connected() {
-        let st = state_with(&[("connection_status", "connected")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "connected"
-        );
-    }
-
-    #[test]
-    fn conn_connected_auth_authenticated_returns_connected() {
-        let st = state_with(&[
-            ("connection_status", "connected"),
-            ("auth_status", "authenticated"),
-        ]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "connected"
-        );
-    }
-
-    #[test]
-    fn conn_connected_auth_not_authenticated() {
-        let st = state_with(&[
-            ("connection_status", "connected"),
-            ("auth_status", "not_authenticated"),
-        ]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "not_authenticated"
-        );
-    }
-
-    #[test]
-    fn conn_disconnected_setup_complete_returns_disconnected() {
-        let st = state_with(&[("connection_status", "disconnected")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "disconnected"
-        );
-    }
-
-    #[test]
-    fn conn_disconnected_no_setup_returns_setup_required() {
-        let st = state_with(&[("connection_status", "disconnected")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, false, &st),
-            "setup_required"
-        );
-    }
-
-    #[test]
-    fn unknown_state_falls_through_to_connecting() {
-        let st = state_with(&[("connection_status", "unknown_value")]);
-        assert_eq!(
-            derive_connection_status(SkillStatus::Running, true, &st),
-            "connecting"
-        );
-    }
-}
diff --git a/src/openhuman/skills/utils.rs b/src/openhuman/skills/utils.rs
deleted file mode 100644
index 96e7db85e..000000000
--- a/src/openhuman/skills/utils.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-//! Runtime safety utilities.
-//!
-//! This module provides a collection of safe execution wrappers designed to
-//! prevent common asynchronous pitfalls in Rust, such as attempting to start
-//! multiple Tokio runtimes on the same thread or causing deadlocks when
-//! bridgeing between synchronous and asynchronous code.
-
-use std::future::Future;
-use tokio::runtime::{Handle, Runtime};
-
-/// Safely executes an asynchronous future, automatically detecting the current context.
-///
-/// If an existing Tokio runtime handle is available in the current thread, the future
-/// is spawned onto it, and the result is awaited via a synchronous channel.
-/// If no runtime is active, a new single-threaded runtime is created to execute the future.
-///
-/// This is essential for bridge functions that may be called from both sync and async contexts.
-///
-/// # Errors
-/// Returns an error string if a new runtime cannot be created or if result communication fails.
-pub fn safe_async_execute<F, R>(future: F) -> Result<R, String>
-where
-    F: Future<Output = R> + Send + 'static,
-    R: Send + 'static,
-{
-    // Try to use existing runtime first
-    if let Ok(handle) = Handle::try_current() {
-        // We're in an async context, spawn on the current runtime
-        let (tx, rx) = std::sync::mpsc::sync_channel(1);
-
-        handle.spawn(async move {
-            let result = future.await;
-            let _ = tx.send(result);
-        });
-
-        rx.recv()
-            .map_err(|e| format!("Failed to receive async result: {}", e))
-    } else {
-        // No runtime available, create a new one for this specific task
-        tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .map_err(|e| format!("Failed to create runtime: {}", e))?
-            .block_on(async { Ok(future.await) })
-    }
-}
-
-/// Safely executes an asynchronous future on a dedicated background thread.
-///
-/// This is particularly useful for avoiding deadlocks when executing async logic
-/// from within contexts that block the current thread, such as certain V8 isolate
-/// operations or synchronous bridge calls.
-///
-/// # Errors
-/// Returns an error string if a runtime cannot be initialized on the new thread
-/// or if the operation exceeds the 60-second timeout.
-pub fn safe_async_execute_threaded<F, R>(future: F) -> Result<R, String>
-where
-    F: Future<Output = R> + Send + 'static,
-    R: Send + 'static,
-{
-    let (tx, rx) = std::sync::mpsc::sync_channel(1);
-
-    std::thread::spawn(move || {
-        // Detect if a runtime was somehow inherited or initialized on this new thread
-        if let Ok(handle) = Handle::try_current() {
-            let result = handle.block_on(future);
-            let _ = tx.send(Ok(result));
-            return;
-        }
-
-        // Create a dedicated single-threaded runtime for this background operation
-        let runtime_result = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .map_err(|e| format!("Failed to create runtime: {}", e))
-            .map(|rt| rt.block_on(future));
-
-        let result = match runtime_result {
-            Ok(value) => Ok(value),
-            Err(e) => Err(format!("Runtime creation failed: {}", e)),
-        };
-
-        let _ = tx.send(result);
-    });
-
-    rx.recv_timeout(std::time::Duration::from_secs(60))
-        .map_err(|e| format!("Threaded async execution timed out: {}", e))?
-}
-
-/// Checks if the current thread is already executing within an active Tokio runtime.
-pub fn is_in_runtime() -> bool {
-    Handle::try_current().is_ok()
-}
-
-/// Attempts to create a new single-threaded Tokio runtime.
-///
-/// # Errors
-/// Returns an error if the current thread already has an active runtime,
-/// as Tokio does not support nested runtimes on the same thread.
-pub fn create_runtime() -> Result<Runtime, String> {
-    if is_in_runtime() {
-        return Err("Cannot create runtime: already in async context".to_string());
-    }
-
-    tokio::runtime::Builder::new_current_thread()
-        .enable_all()
-        .build()
-        .map_err(|e| format!("Failed to create runtime: {}", e))
-}
-
-/// Executes a potentially blocking synchronous operation within an asynchronous context.
-///
-/// This offloads the operation to a thread pool managed by Tokio (`spawn_blocking`),
-/// preventing it from stalling the async executor.
-pub async fn safe_blocking<F, R>(f: F) -> Result<R, String>
-where
-    F: FnOnce() -> R + Send + 'static,
-    R: Send + 'static,
-{
-    tokio::task::spawn_blocking(f)
-        .await
-        .map_err(|e| format!("Blocking operation failed: {}", e))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_safe_async_execute_no_runtime() {
-        let result = safe_async_execute(async { "test".to_string() });
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "test");
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_safe_async_execute_with_runtime() {
-        let result = safe_async_execute(async { "test".to_string() });
-        assert!(result.is_ok());
-        assert_eq!(result.unwrap(), "test");
-    }
-
-    #[test]
-    fn test_is_in_runtime() {
-        // Outside async context
-        assert!(!is_in_runtime());
-    }
-
-    #[tokio::test]
-    async fn test_is_in_runtime_async() {
-        // Inside async context
-        assert!(is_in_runtime());
-    }
-}
diff --git a/src/openhuman/skills/working_memory.rs b/src/openhuman/skills/working_memory.rs
deleted file mode 100644
index 13baa5e73..000000000
--- a/src/openhuman/skills/working_memory.rs
+++ /dev/null
@@ -1,649 +0,0 @@
-//! Working-memory extraction for skill sync payloads.
-//!
-//! This module defines what "user working memory" means for skill sync data:
-//! durable, user-scoped facts (preferences, goals, constraints, recurring entities)
-//! extracted from successful integration sync payloads.
-//!
-//! Scope model:
-//! - **Working memory**: persisted in `global` namespace with deterministic keys.
-//! - **Ephemeral chat context**: transient prompt/history data, not persisted here.
-//! - **TTL**: none by default (durable), with bounded growth via fixed keys + caps.
-
-use std::collections::BTreeSet;
-use std::sync::OnceLock;
-
-use regex::Regex;
-use serde_json::Value;
-
-use crate::openhuman::memory::NamespaceDocumentInput;
-
-const GLOBAL_NAMESPACE: &str = "global";
-const MAX_SCALAR_FIELDS: usize = 1200;
-const MAX_ARRAY_ITEMS_PER_NODE: usize = 40;
-const MAX_DOC_ITEMS_PER_BUCKET: usize = 12;
-const MAX_ITEM_CHARS: usize = 180;
-
-const KIND_PREFERENCES: &str = "preferences";
-const KIND_GOALS: &str = "goals";
-const KIND_CONSTRAINTS: &str = "constraints";
-const KIND_ENTITIES: &str = "entities";
-const KIND_SUMMARY: &str = "summary";
-
-/// Metrics describing extraction quality for a sync batch.
-#[derive(Debug, Clone, Default)]
-pub(crate) struct WorkingMemoryExtractionStats {
-    pub scalar_fields_seen: usize,
-    pub sensitive_fields_skipped: usize,
-    pub preferences: usize,
-    pub goals: usize,
-    pub constraints: usize,
-    pub entities: usize,
-    pub documents_generated: usize,
-}
-
-/// Output for a sync batch: deterministic memory documents + extraction stats.
-#[derive(Debug, Clone, Default)]
-pub(crate) struct WorkingMemoryExtractionOutcome {
-    pub documents: Vec<NamespaceDocumentInput>,
-    pub stats: WorkingMemoryExtractionStats,
-}
-
-/// Whether skill-sync working-memory extraction is enabled.
-///
-/// Product-level allow switch (consent/rollout safety):
-/// - `OPENHUMAN_SKILLS_WORKING_MEMORY_ENABLED=0|false|off|no` disables extraction.
-/// - Any other value (or unset) enables extraction.
-pub(crate) fn skills_working_memory_enabled() -> bool {
-    static ENABLED: OnceLock<bool> = OnceLock::new();
-    *ENABLED.get_or_init(|| {
-        std::env::var("OPENHUMAN_SKILLS_WORKING_MEMORY_ENABLED")
-            .map(|raw| {
-                !matches!(
-                    raw.trim().to_ascii_lowercase().as_str(),
-                    "0" | "false" | "off" | "no"
-                )
-            })
-            .unwrap_or(true)
-    })
-}
-
-#[derive(Debug, Default)]
-struct WorkingMemoryBuckets {
-    preferences: BTreeSet<String>,
-    goals: BTreeSet<String>,
-    constraints: BTreeSet<String>,
-    entities: BTreeSet<String>,
-}
-
-/// Build bounded working-memory documents from a skill sync payload.
-///
-/// The generated documents are user-scoped, deterministic, and upsert-friendly.
-/// Keys are fixed per `(skill, kind)` to prevent unbounded growth.
-pub(crate) fn working_memory_documents_from_sync(
-    skill_id: &str,
-    sync_content: &str,
-) -> WorkingMemoryExtractionOutcome {
-    let skill_slug = sanitize_skill_id(skill_id);
-    let source_namespace = format!("skill-{skill_slug}");
-    let mut stats = WorkingMemoryExtractionStats::default();
-
-    let Ok(payload) = serde_json::from_str::<Value>(sync_content) else {
-        log::debug!(
-            "[skills-working-memory] non-JSON sync payload for skill='{}'; skipping extraction",
-            skill_slug
-        );
-        return WorkingMemoryExtractionOutcome {
-            documents: Vec::new(),
-            stats,
-        };
-    };
-
-    let mut scalars = Vec::new();
-    collect_scalar_fields(
-        &payload,
-        "$",
-        &mut scalars,
-        &mut stats.sensitive_fields_skipped,
-    );
-    stats.scalar_fields_seen = scalars.len();
-
-    let mut buckets = WorkingMemoryBuckets::default();
-    for (path, raw_value) in scalars {
-        let normalized = normalize_text(&raw_value);
-        if normalized.len() < 3 {
-            continue;
-        }
-        if is_sensitive_value(&normalized) {
-            stats.sensitive_fields_skipped += 1;
-            continue;
-        }
-
-        // Redact PII on the full normalized text first, then clip, so that a
-        // PII pattern spanning the clip boundary is never partially preserved.
-        let sanitized = redact_common_pii(&normalized);
-        let clipped = clip(&sanitized, MAX_ITEM_CHARS);
-        classify_into_buckets(&path, &clipped, &mut buckets);
-    }
-
-    cap_set(&mut buckets.preferences, MAX_DOC_ITEMS_PER_BUCKET);
-    cap_set(&mut buckets.goals, MAX_DOC_ITEMS_PER_BUCKET);
-    cap_set(&mut buckets.constraints, MAX_DOC_ITEMS_PER_BUCKET);
-    cap_set(&mut buckets.entities, MAX_DOC_ITEMS_PER_BUCKET);
-
-    stats.preferences = buckets.preferences.len();
-    stats.goals = buckets.goals.len();
-    stats.constraints = buckets.constraints.len();
-    stats.entities = buckets.entities.len();
-
-    let mut documents = Vec::new();
-    if !buckets.preferences.is_empty() {
-        documents.push(build_doc(
-            &skill_slug,
-            &source_namespace,
-            KIND_PREFERENCES,
-            "User preferences extracted from skill sync",
-            &render_bucket(&buckets.preferences),
-        ));
-    }
-    if !buckets.goals.is_empty() {
-        documents.push(build_doc(
-            &skill_slug,
-            &source_namespace,
-            KIND_GOALS,
-            "User goals extracted from skill sync",
-            &render_bucket(&buckets.goals),
-        ));
-    }
-    if !buckets.constraints.is_empty() {
-        documents.push(build_doc(
-            &skill_slug,
-            &source_namespace,
-            KIND_CONSTRAINTS,
-            "User constraints extracted from skill sync",
-            &render_bucket(&buckets.constraints),
-        ));
-    }
-    if !buckets.entities.is_empty() {
-        documents.push(build_doc(
-            &skill_slug,
-            &source_namespace,
-            KIND_ENTITIES,
-            "Recurring entities extracted from skill sync",
-            &render_bucket(&buckets.entities),
-        ));
-    }
-
-    if !documents.is_empty() {
-        documents.push(build_doc(
-            &skill_slug,
-            &source_namespace,
-            KIND_SUMMARY,
-            "Working memory summary from skill sync",
-            &render_summary(&buckets),
-        ));
-    }
-
-    stats.documents_generated = documents.len();
-
-    WorkingMemoryExtractionOutcome { documents, stats }
-}
-
-fn collect_scalar_fields(
-    value: &Value,
-    path: &str,
-    out: &mut Vec<(String, String)>,
-    sensitive_skipped: &mut usize,
-) {
-    if out.len() >= MAX_SCALAR_FIELDS {
-        return;
-    }
-
-    match value {
-        Value::Object(map) => {
-            for (key, v) in map {
-                if out.len() >= MAX_SCALAR_FIELDS {
-                    break;
-                }
-                if is_sensitive_key(key) {
-                    *sensitive_skipped += 1;
-                    continue;
-                }
-                let child_path = if path == "$" {
-                    format!("$.{key}")
-                } else {
-                    format!("{path}.{key}")
-                };
-                collect_scalar_fields(v, &child_path, out, sensitive_skipped);
-            }
-        }
-        Value::Array(items) => {
-            for item in items.iter().take(MAX_ARRAY_ITEMS_PER_NODE) {
-                if out.len() >= MAX_SCALAR_FIELDS {
-                    break;
-                }
-                collect_scalar_fields(item, &format!("{path}[]"), out, sensitive_skipped);
-            }
-        }
-        Value::String(s) => out.push((path.to_string(), s.clone())),
-        Value::Bool(b) => out.push((path.to_string(), b.to_string())),
-        Value::Number(n) => out.push((path.to_string(), n.to_string())),
-        Value::Null => {}
-    }
-}
-
-fn classify_into_buckets(path: &str, value: &str, buckets: &mut WorkingMemoryBuckets) {
-    let path_l = path.to_ascii_lowercase();
-    let value_l = value.to_ascii_lowercase();
-
-    if looks_like_preference(&path_l, &value_l) {
-        buckets
-            .preferences
-            .insert(format!("{} ({})", value, summarize_path(&path_l)));
-    }
-    if looks_like_goal(&path_l, &value_l) {
-        buckets
-            .goals
-            .insert(format!("{} ({})", value, summarize_path(&path_l)));
-    }
-    if looks_like_constraint(&path_l, &value_l) {
-        buckets
-            .constraints
-            .insert(format!("{} ({})", value, summarize_path(&path_l)));
-    }
-    if looks_like_entity(&path_l, value) {
-        buckets.entities.insert(value.to_string());
-    }
-}
-
-fn render_bucket(items: &BTreeSet<String>) -> String {
-    items
-        .iter()
-        .map(|item| format!("- {item}"))
-        .collect::<Vec<_>>()
-        .join("\n")
-}
-
-fn render_summary(buckets: &WorkingMemoryBuckets) -> String {
-    let mut sections = Vec::new();
-    if !buckets.preferences.is_empty() {
-        sections.push(format!(
-            "Preferences:\n{}",
-            render_bucket(&buckets.preferences)
-        ));
-    }
-    if !buckets.goals.is_empty() {
-        sections.push(format!("Goals:\n{}", render_bucket(&buckets.goals)));
-    }
-    if !buckets.constraints.is_empty() {
-        sections.push(format!(
-            "Constraints:\n{}",
-            render_bucket(&buckets.constraints)
-        ));
-    }
-    if !buckets.entities.is_empty() {
-        sections.push(format!(
-            "Recurring entities:\n{}",
-            render_bucket(&buckets.entities)
-        ));
-    }
-    sections.join("\n\n")
-}
-
-fn build_doc(
-    skill_slug: &str,
-    source_namespace: &str,
-    kind: &str,
-    title: &str,
-    content: &str,
-) -> NamespaceDocumentInput {
-    NamespaceDocumentInput {
-        namespace: GLOBAL_NAMESPACE.to_string(),
-        key: format!("working.user.{skill_slug}.{kind}"),
-        title: format!("{skill_slug} • {kind}"),
-        content: format!("{title}\n\n{content}"),
-        source_type: "skill_sync_working_memory".to_string(),
-        priority: "high".to_string(),
-        tags: vec![
-            "working-memory".to_string(),
-            "skill-sync".to_string(),
-            skill_slug.to_string(),
-            kind.to_string(),
-        ],
-        metadata: serde_json::json!({
-            "memory_scope": "user_working_memory",
-            "source": "skills.sync",
-            "source_namespace": source_namespace,
-            "skill_id": skill_slug,
-            "kind": kind,
-            "ttl": "none",
-            "version": 1,
-        }),
-        category: "core".to_string(),
-        session_id: None,
-        document_id: None,
-    }
-}
-
-fn sanitize_skill_id(skill_id: &str) -> String {
-    let normalized = skill_id
-        .trim()
-        .to_ascii_lowercase()
-        .chars()
-        .map(|ch| {
-            if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' {
-                ch
-            } else {
-                '-'
-            }
-        })
-        .collect::<String>();
-
-    if normalized.is_empty() {
-        "unknown-skill".to_string()
-    } else {
-        normalized
-    }
-}
-
-fn is_sensitive_key(key: &str) -> bool {
-    let key_l = key.to_ascii_lowercase();
-    [
-        "token",
-        "secret",
-        "password",
-        "credential",
-        "oauth",
-        "auth",
-        "apikey",
-        "api_key",
-        "jwt",
-        "cookie",
-        "bearer",
-        "refresh",
-        "access",
-        "clientkey",
-        "client_key",
-    ]
-    .iter()
-    .any(|needle| key_l.contains(needle))
-}
-
-fn is_sensitive_value(value: &str) -> bool {
-    let value_l = value.to_ascii_lowercase();
-    if value_l.contains("bearer ") || value_l.contains("api_key") {
-        return true;
-    }
-    // Heuristic for opaque secrets/tokens: a whitespace-separated token of
-    // 32+ chars where every character is alphanumeric or a common separator
-    // used in API keys, UUIDs, and similar credentials ('-', '_', '.').
-    for token in value.split_whitespace() {
-        if token.len() < 32 {
-            continue;
-        }
-        if token
-            .chars()
-            .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.'))
-        {
-            return true;
-        }
-        // JWT-like: three dot-delimited segments of base64url-safe characters.
-        let parts: Vec<&str> = token.split('.').collect();
-        if parts.len() == 3
-            && parts.iter().all(|seg| {
-                !seg.is_empty()
-                    && seg
-                        .chars()
-                        .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '='))
-            })
-        {
-            return true;
-        }
-    }
-    false
-}
-
-fn looks_like_preference(path: &str, value: &str) -> bool {
-    [
-        "preference",
-        "pref",
-        "setting",
-        "timezone",
-        "language",
-        "style",
-    ]
-    .iter()
-    .any(|needle| path.contains(needle))
-        || [
-            "prefer", "likes", "favorite", "timezone", "language", "style",
-        ]
-        .iter()
-        .any(|needle| value.contains(needle))
-}
-
-fn looks_like_goal(path: &str, value: &str) -> bool {
-    [
-        "goal",
-        "objective",
-        "target",
-        "milestone",
-        "roadmap",
-        "plan",
-    ]
-    .iter()
-    .any(|needle| path.contains(needle))
-        || [
-            "goal",
-            "objective",
-            "target",
-            "milestone",
-            "plan",
-            "ship",
-            "deliver",
-        ]
-        .iter()
-        .any(|needle| value.contains(needle))
-}
-
-fn looks_like_constraint(path: &str, value: &str) -> bool {
-    [
-        "constraint",
-        "limit",
-        "restriction",
-        "policy",
-        "deadline",
-        "availability",
-    ]
-    .iter()
-    .any(|needle| path.contains(needle))
-        || [
-            "must",
-            "cannot",
-            "can't",
-            "do not",
-            "deadline",
-            "limited",
-            "restriction",
-        ]
-        .iter()
-        .any(|needle| value.contains(needle))
-}
-
-fn looks_like_entity(path: &str, value: &str) -> bool {
-    if value.len() > 80 {
-        return false;
-    }
-    [
-        "name",
-        "title",
-        "project",
-        "workspace",
-        "team",
-        "customer",
-        "account",
-        "label",
-    ]
-    .iter()
-    .any(|needle| path.contains(needle))
-}
-
-fn summarize_path(path: &str) -> String {
-    path.trim_start_matches("$.")
-        .replace("[]", "")
-        .replace('.', " > ")
-}
-
-fn cap_set(set: &mut BTreeSet<String>, max_len: usize) {
-    while set.len() > max_len {
-        let last = set.iter().next_back().cloned();
-        if let Some(value) = last {
-            set.remove(&value);
-        } else {
-            break;
-        }
-    }
-}
-
-fn normalize_text(input: &str) -> String {
-    input.split_whitespace().collect::<Vec<_>>().join(" ")
-}
-
-fn redact_common_pii(input: &str) -> String {
-    static EMAIL_RE: OnceLock<Regex> = OnceLock::new();
-    static PHONE_RE: OnceLock<Regex> = OnceLock::new();
-
-    let email_re = EMAIL_RE.get_or_init(|| {
-        Regex::new(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b")
-            .expect("email regex should compile")
-    });
-    let phone_re = PHONE_RE
-        .get_or_init(|| Regex::new(r"\+?\d[\d\-\s]{8,}\d").expect("phone regex should compile"));
-    let redacted = email_re.replace_all(input, "[redacted-email]");
-    let redacted = phone_re.replace_all(&redacted, "[redacted-phone]");
-    redacted.to_string()
-}
-
-fn clip(input: &str, max_chars: usize) -> String {
-    if input.chars().count() <= max_chars {
-        return input.to_string();
-    }
-    let mut clipped = String::new();
-    for ch in input.chars().take(max_chars) {
-        clipped.push(ch);
-    }
-    clipped
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::sync::Arc;
-
-    use crate::openhuman::memory::{embeddings::NoopEmbedding, UnifiedMemory};
-
-    #[test]
-    fn extracts_preferences_goals_constraints_entities_and_redacts_sensitive_fields() {
-        let payload = serde_json::json!({
-            "user": {
-                "timezone": "America/Los_Angeles",
-                "email": "alice@example.com",
-                "api_key": "super-secret-value"
-            },
-            "preferences": {
-                "writing_style": "prefers concise updates",
-                "language": "English"
-            },
-            "goals": [
-                "Ship onboarding redesign by Friday"
-            ],
-            "constraints": [
-                "No meetings after 3pm"
-            ],
-            "projects": [
-                {"name": "Atlas"},
-                {"name": "Hermes"}
-            ]
-        })
-        .to_string();
-
-        let outcome = working_memory_documents_from_sync("gmail", &payload);
-        assert!(!outcome.documents.is_empty());
-
-        let all_content = outcome
-            .documents
-            .iter()
-            .map(|doc| doc.content.clone())
-            .collect::<Vec<_>>()
-            .join("\n");
-
-        assert!(all_content.contains("prefers concise updates"));
-        assert!(all_content.contains("Ship onboarding redesign by Friday"));
-        assert!(all_content.contains("No meetings after 3pm"));
-        assert!(all_content.contains("Atlas"));
-        assert!(!all_content.contains("super-secret-value"));
-        assert!(!all_content.contains("alice@example.com"));
-        assert!(outcome.stats.sensitive_fields_skipped > 0);
-        assert!(outcome.stats.preferences > 0);
-        assert!(outcome.stats.goals > 0);
-        assert!(outcome.stats.constraints > 0);
-        assert!(outcome.stats.entities > 0);
-    }
-
-    #[tokio::test]
-    async fn generated_working_memory_docs_upsert_without_growth() {
-        let tmp = tempfile::tempdir().unwrap();
-        let memory = UnifiedMemory::new(tmp.path(), Arc::new(NoopEmbedding), None).unwrap();
-
-        let payload_v1 = serde_json::json!({
-            "preferences": {"style": "prefers concise responses"},
-            "goals": ["Ship v1 this week"],
-            "projects": [{"name": "Atlas"}]
-        })
-        .to_string();
-        let payload_v2 = serde_json::json!({
-            "preferences": {"style": "prefers concise responses"},
-            "goals": ["Ship v2 next week"],
-            "projects": [{"name": "Atlas"}, {"name": "Hermes"}]
-        })
-        .to_string();
-
-        let outcome_v1 = working_memory_documents_from_sync("notion", &payload_v1);
-        let expected_max_docs = outcome_v1.documents.len();
-        for doc in outcome_v1.documents {
-            memory.upsert_document(doc).await.unwrap();
-        }
-
-        let outcome_v2 = working_memory_documents_from_sync("notion", &payload_v2);
-        for doc in outcome_v2.documents {
-            memory.upsert_document(doc).await.unwrap();
-        }
-
-        let docs = memory.list_documents(Some("global")).await.unwrap();
-        let working_docs = docs
-            .get("documents")
-            .and_then(Value::as_array)
-            .unwrap()
-            .iter()
-            .filter(|doc| {
-                doc.get("key")
-                    .and_then(Value::as_str)
-                    .is_some_and(|key| key.starts_with("working.user.notion."))
-            })
-            .count();
-
-        assert!(
-            working_docs <= expected_max_docs,
-            "working memory docs should not grow unbounded for repeated syncs"
-        );
-
-        let ranked = memory
-            .query_namespace_ranked("global", "Ship v2 next week", 5)
-            .await
-            .unwrap();
-        assert!(
-            ranked
-                .iter()
-                .any(|hit| hit.content.contains("Ship v2 next week")),
-            "updated goal should be discoverable in global working memory"
-        );
-    }
-}
diff --git a/src/openhuman/subconscious/situation_report.rs b/src/openhuman/subconscious/situation_report.rs
index cd3e01795..c75d7cda4 100644
--- a/src/openhuman/subconscious/situation_report.rs
+++ b/src/openhuman/subconscious/situation_report.rs
@@ -253,70 +253,7 @@ async fn build_graph_section(client: &MemoryClient, last_tick_at: f64) -> String
 }
 
 async fn build_skills_section() -> String {
-    // Call the skills_list RPC internally via the controller registry
-    let params = serde_json::Map::new();
-    let result = crate::core::all::try_invoke_registered_rpc("openhuman.skills_list", params).await;
-
-    let skills_value = match result {
-        Some(Ok(value)) => value,
-        Some(Err(_)) | None => {
-            return "## Skills Runtime\n\nSkill registry unavailable.\n".to_string();
-        }
-    };
-
-    let skills = match skills_value.as_array() {
-        Some(arr) => arr,
-        None => {
-            return "## Skills Runtime\n\nNo skills data.\n".to_string();
-        }
-    };
-
-    if skills.is_empty() {
-        return "## Skills Runtime\n\nNo skills installed.\n".to_string();
-    }
-
-    let mut section = String::from("## Skills Runtime\n\n");
-    for skill in skills {
-        let name = skill
-            .get("skill_id")
-            .or_else(|| skill.get("name"))
-            .and_then(|v| v.as_str())
-            .unwrap_or("?");
-        let status = skill
-            .get("status")
-            .and_then(|v| v.as_str())
-            .unwrap_or("unknown");
-        let setup = skill
-            .get("setup_complete")
-            .and_then(|v| v.as_bool())
-            .map(|b| if b { "ready" } else { "not setup" })
-            .unwrap_or("?");
-        let connection = skill
-            .get("connection_status")
-            .and_then(|v| v.as_str())
-            .unwrap_or("");
-
-        let mut line = format!("- {name}: {status}");
-        if !connection.is_empty() && connection != status {
-            line.push_str(&format!(" ({connection})"));
-        }
-        if setup == "not setup" {
-            line.push_str(" [not setup]");
-        }
-
-        if let Some(err) = skill
-            .get("connection_error")
-            .or_else(|| skill.get("lastError"))
-            .and_then(|v| v.as_str())
-            .filter(|s| !s.is_empty())
-        {
-            let truncated_err = truncate_at_char_boundary(err, 100);
-            line.push_str(&format!(" ERROR: {truncated_err}"));
-        }
-
-        let _ = writeln!(section, "{line}");
-    }
-    section
+    "## Integrations\n\nLocal QuickJS skills have been removed. Use the Composio and channel sections for current integration state.\n".to_string()
 }
 
 fn append_section(report: &mut String, remaining: &mut usize, section: &str) {
diff --git a/src/openhuman/tools/impl/agent/mod.rs b/src/openhuman/tools/impl/agent/mod.rs
index 291a076c2..2eae31061 100644
--- a/src/openhuman/tools/impl/agent/mod.rs
+++ b/src/openhuman/tools/impl/agent/mod.rs
@@ -1,7 +1,6 @@
 mod archetype_delegation;
 mod ask_clarification;
 mod delegate;
-mod skill_delegation;
 mod spawn_subagent;
 
 use crate::core::event_bus::{publish_global, DomainEvent};
@@ -37,7 +36,7 @@ pub(crate) async fn dispatch_subagent(
     agent_id: &str,
     tool_name: &str,
     prompt: &str,
-    skill_filter: Option<&str>,
+    _skill_filter: Option<&str>,
 ) -> anyhow::Result<ToolResult> {
     let registry = match AgentDefinitionRegistry::global() {
         Some(reg) => reg,
@@ -59,12 +58,6 @@ pub(crate) async fn dispatch_subagent(
         }
     };
 
-    if let Some(skill) = skill_filter {
-        if let Err(err) = spawn_subagent::validate_skill_filter_public(skill) {
-            return Ok(ToolResult::error(err));
-        }
-    }
-
     let parent_session = current_parent()
         .map(|p| p.session_id.clone())
         .unwrap_or_else(|| "standalone".into());
@@ -86,7 +79,7 @@ pub(crate) async fn dispatch_subagent(
     );
 
     let options = SubagentRunOptions {
-        skill_filter_override: skill_filter.map(|s| s.to_string()),
+        skill_filter_override: None,
         category_filter_override: None,
         context: None,
         task_id: Some(task_id.clone()),
@@ -124,20 +117,7 @@ pub(crate) async fn dispatch_subagent(
     }
 }
 
-pub(crate) fn skill_description(skill_id: &str) -> String {
-    match skill_id {
-        "notion" => "Interact with Notion: search pages, create and update pages and databases, manage blocks and comments.".into(),
-        "gmail" => "Interact with Gmail: read emails, send messages, search inbox, manage labels.".into(),
-        "slack" => "Interact with Slack: send messages, read channels, manage conversations.".into(),
-        "google-calendar" | "calendar" => "Interact with Google Calendar: view events, create meetings, manage schedules.".into(),
-        "google-drive" | "drive" => "Interact with Google Drive: manage files, folders, and sharing.".into(),
-        "github" => "Interact with GitHub: manage repos, issues, pull requests, and code.".into(),
-        _ => format!("Interact with the {skill_id} integration."),
-    }
-}
-
 pub use archetype_delegation::ArchetypeDelegationTool;
 pub use ask_clarification::AskClarificationTool;
 pub use delegate::DelegateTool;
-pub use skill_delegation::SkillDelegationTool;
-pub use spawn_subagent::{validate_skill_filter_public, SpawnSubagentTool};
+pub use spawn_subagent::SpawnSubagentTool;
diff --git a/src/openhuman/tools/impl/agent/spawn_subagent.rs b/src/openhuman/tools/impl/agent/spawn_subagent.rs
index 73b6cbd1b..d29ddafd6 100644
--- a/src/openhuman/tools/impl/agent/spawn_subagent.rs
+++ b/src/openhuman/tools/impl/agent/spawn_subagent.rs
@@ -18,10 +18,6 @@
 //!   homogeneous task; relies on the inference backend's automatic
 //!   prefix caching for token savings.
 //!
-//! API specialists (Notion, Gmail, …) ride on the built-in `skills_agent`
-//! definition by passing `skill_filter: "<skill_id>"`, which restricts
-//! the resolved tool list to tools whose names start with `{skill}__`.
-
 use crate::core::event_bus::{publish_global, DomainEvent};
 use crate::openhuman::agent::harness::definition::AgentDefinitionRegistry;
 use crate::openhuman::agent::harness::fork_context::current_parent;
@@ -102,14 +98,10 @@ impl Tool for SpawnSubagentTool {
                     "type": "string",
                     "description": "Optional context blob from prior task results. Rendered as a `[Context]` block before the prompt."
                 },
-                "skill_filter": {
-                    "type": "string",
-                    "description": "Optional skill id (e.g. `notion`, `gmail`) — when set, the sub-agent's tool list is restricted to tools named `{skill}__*`. Pair with `agent_id: skills_agent` for an API specialist."
-                },
                 "category_filter": {
                     "type": "string",
                     "enum": ["system", "skill"],
-                    "description": "Optional tool-category restriction. `skill` scopes the sub-agent to QuickJS skill-bridge tools (Notion, Gmail, Telegram, …); `system` scopes it to built-in Rust tools (shell, file_*, memory_*, …). Overrides the definition's `category_filter` for this single spawn."
+                    "description": "Optional tool-category restriction. `skill` scopes the sub-agent to integration tools (for example Composio-backed SaaS actions); `system` scopes it to built-in Rust tools. Overrides the definition's `category_filter` for this single spawn."
                 },
                 "mode": {
                     "type": "string",
@@ -146,11 +138,6 @@ impl Tool for SpawnSubagentTool {
             .and_then(|v| v.as_str())
             .map(|s| s.to_string());
 
-        let skill_filter_override = args
-            .get("skill_filter")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string());
-
         let category_filter_override = match args.get("category_filter").and_then(|v| v.as_str()) {
             Some("system") => Some(ToolCategory::System),
             Some("skill") => Some(ToolCategory::Skill),
@@ -203,13 +190,6 @@ impl Tool for SpawnSubagentTool {
             }
         };
 
-        // ── Validate skill filter against the runtime if set ───────────
-        if let Some(skill) = skill_filter_override.as_deref() {
-            if let Err(err) = validate_skill_filter(skill) {
-                return Ok(ToolResult::error(err));
-            }
-        }
-
         // ── Publish SubagentSpawned event ──────────────────────────────
         let parent_session = current_parent()
             .map(|p| p.session_id.clone())
@@ -226,7 +206,7 @@ impl Tool for SpawnSubagentTool {
 
         // ── Run the sub-agent ──────────────────────────────────────────
         let options = SubagentRunOptions {
-            skill_filter_override,
+            skill_filter_override: None,
             category_filter_override,
             context,
             task_id: Some(task_id.clone()),
@@ -262,40 +242,6 @@ impl Tool for SpawnSubagentTool {
     }
 }
 
-/// Validate that the requested skill_filter matches a currently-loaded
-/// skill in the global skill runtime, if a runtime is available. When
-/// no runtime is available (e.g. tests, CLI), this is a no-op.
-///
-/// Public alias for use by `orchestrator_tools`.
-pub fn validate_skill_filter_public(skill_id: &str) -> Result<(), String> {
-    validate_skill_filter(skill_id)
-}
-
-fn validate_skill_filter(skill_id: &str) -> Result<(), String> {
-    let Some(engine) = crate::openhuman::skills::qjs_engine::global_engine() else {
-        // No runtime registered — skip validation.
-        return Ok(());
-    };
-    // `engine.all_tools()` returns `(skill_id, ToolDefinition)` pairs
-    // where `skill_id` is the skill prefix (e.g. "gmail", "notion")
-    // and `ToolDefinition.name` is the raw tool name (e.g. "get-emails").
-    let mut known: Vec<String> = engine
-        .all_tools()
-        .into_iter()
-        .map(|(skill_id, _)| skill_id)
-        .collect();
-    known.sort();
-    known.dedup();
-    if known.iter().any(|s| s == skill_id) {
-        Ok(())
-    } else {
-        Err(format!(
-            "skill_filter '{skill_id}' does not match any installed skill. Available: {}",
-            known.join(", ")
-        ))
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/openhuman/tools/impl/network/mod.rs b/src/openhuman/tools/impl/network/mod.rs
index ee09176fb..d92d07977 100644
--- a/src/openhuman/tools/impl/network/mod.rs
+++ b/src/openhuman/tools/impl/network/mod.rs
@@ -1,9 +1,7 @@
 mod composio;
 mod http_request;
-mod skill_bridge;
 mod web_search;
 
 pub use composio::{ComposioAction, ComposioTool};
 pub use http_request::HttpRequestTool;
-pub use skill_bridge::{collect_skill_tools, SkillToolBridge};
 pub use web_search::WebSearchTool;
diff --git a/src/openhuman/tools/impl/network/skill_bridge.rs b/src/openhuman/tools/impl/network/skill_bridge.rs
deleted file mode 100644
index f995cbceb..000000000
--- a/src/openhuman/tools/impl/network/skill_bridge.rs
+++ /dev/null
@@ -1,199 +0,0 @@
-//! Bridge between the QuickJS skill runtime and the agent's `Tool` trait registry.
-//!
-//! Each running skill exposes tools via `ToolDefinition`. This module wraps them
-//! as `Tool` trait implementations so the agent loop can discover and execute
-//! skill tools (Notion, Gmail, etc.) alongside built-in tools.
-//!
-//! Both built-in tools and skill tools now use the same unified `ToolResult`
-//! type (MCP content blocks), so no result conversion is needed.
-
-use async_trait::async_trait;
-use std::collections::HashSet;
-use std::sync::Arc;
-
-use crate::openhuman::skills::qjs_engine::RuntimeEngine;
-use crate::openhuman::skills::types::ToolDefinition;
-use crate::openhuman::tools::traits::{PermissionLevel, Tool, ToolCategory, ToolResult};
-
-/// A `Tool` implementation that delegates execution to a running QuickJS skill instance.
-///
-/// The tool name uses the convention `{skill_id}__{tool_name}` so the agent loop
-/// can match tool calls from the LLM to the correct skill and tool.
-pub struct SkillToolBridge {
-    /// Namespaced tool name: `{skill_id}__{tool_name}`.
-    namespaced_name: String,
-    /// Skill identifier (e.g. "notion", "gmail").
-    skill_id: String,
-    /// Original tool name within the skill (e.g. "search-blocks", "send-email").
-    tool_name: String,
-    /// Human-readable description from the skill manifest.
-    description: String,
-    /// JSON Schema for the tool's input parameters.
-    input_schema: serde_json::Value,
-    /// Reference to the runtime engine for executing tool calls.
-    engine: Arc<RuntimeEngine>,
-}
-
-impl SkillToolBridge {
-    fn new(skill_id: String, tool_def: &ToolDefinition, engine: Arc<RuntimeEngine>) -> Self {
-        let namespaced_name = format!("{}__{}", skill_id, tool_def.name);
-        Self {
-            namespaced_name,
-            skill_id,
-            tool_name: tool_def.name.clone(),
-            description: tool_def.description.clone(),
-            input_schema: tool_def.input_schema.clone(),
-            engine,
-        }
-    }
-}
-
-#[async_trait]
-impl Tool for SkillToolBridge {
-    fn name(&self) -> &str {
-        &self.namespaced_name
-    }
-
-    fn description(&self) -> &str {
-        &self.description
-    }
-
-    fn parameters_schema(&self) -> serde_json::Value {
-        if self.input_schema.is_null() || self.input_schema == serde_json::json!({}) {
-            serde_json::json!({ "type": "object", "properties": {} })
-        } else {
-            self.input_schema.clone()
-        }
-    }
-
-    fn permission_level(&self) -> PermissionLevel {
-        // Skill tools interact with external services; treat as write-level.
-        PermissionLevel::Write
-    }
-
-    fn category(&self) -> ToolCategory {
-        // All skill-bridge tools are in the `Skill` category so sub-agent
-        // definitions with `category_filter: Some(Skill)` pick them up.
-        ToolCategory::Skill
-    }
-
-    async fn execute(&self, args: serde_json::Value) -> anyhow::Result<ToolResult> {
-        log::debug!(
-            "[skill-bridge] Executing {}.{} (namespaced: {})",
-            self.skill_id,
-            self.tool_name,
-            self.namespaced_name,
-        );
-
-        // Both the skill runtime and the Tool trait now use the same ToolResult type,
-        // so we just forward the result directly — no conversion needed.
-        match self
-            .engine
-            .call_tool(&self.skill_id, &self.tool_name, args)
-            .await
-        {
-            Ok(result) => {
-                if result.is_error {
-                    log::warn!(
-                        "[skill-bridge] {}.{} returned error: {}",
-                        self.skill_id,
-                        self.tool_name,
-                        result.output()
-                    );
-                } else {
-                    log::debug!(
-                        "[skill-bridge] {}.{} succeeded ({} bytes)",
-                        self.skill_id,
-                        self.tool_name,
-                        result.output().len()
-                    );
-                }
-                Ok(result)
-            }
-            Err(err) => {
-                log::error!(
-                    "[skill-bridge] {}.{} execution failed: {}",
-                    self.skill_id,
-                    self.tool_name,
-                    err
-                );
-                Ok(ToolResult::error(format!(
-                    "Skill tool execution failed: {}__{}",
-                    self.skill_id, self.tool_name
-                )))
-            }
-        }
-    }
-}
-
-/// Collect all tools from running skills and wrap them as `Box<dyn Tool>`.
-///
-/// Returns an empty vec if the runtime engine is not initialized (e.g. CLI mode
-/// without the desktop app running).
-pub fn collect_skill_tools() -> Vec<Box<dyn Tool>> {
-    let engine = match crate::openhuman::skills::global_engine() {
-        Some(e) => e,
-        None => {
-            log::debug!("[skill-bridge] No global engine — skipping skill tools");
-            return Vec::new();
-        }
-    };
-
-    let all = engine.all_tools();
-    log::info!(
-        "[skill-bridge] Discovered {} tool(s) from running skills",
-        all.len()
-    );
-
-    let mut seen = HashSet::new();
-    all.into_iter()
-        .filter_map(|(skill_id, tool_def)| {
-            if skill_id.contains("__") || tool_def.name.contains("__") {
-                log::error!(
-                    "[skill-bridge] Skipping tool with reserved delimiter in name: {} / {}",
-                    skill_id,
-                    tool_def.name
-                );
-                return None;
-            }
-            let namespaced = format!("{}__{}", skill_id, tool_def.name);
-            if !seen.insert(namespaced.clone()) {
-                log::error!(
-                    "[skill-bridge] Skipping duplicate namespaced tool: {}",
-                    namespaced
-                );
-                return None;
-            }
-            log::debug!(
-                "[skill-bridge]   + {} — {}",
-                namespaced,
-                tool_def.description.chars().take(60).collect::<String>()
-            );
-            Some(Box::new(SkillToolBridge::new(
-                skill_id,
-                &tool_def,
-                Arc::clone(&engine),
-            )) as Box<dyn Tool>)
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn namespaced_name_format() {
-        let skill_id = "notion";
-        let tool_name = "search-blocks";
-        let expected = format!("{}__{}", skill_id, tool_name);
-        assert_eq!(expected, "notion__search-blocks");
-    }
-
-    #[test]
-    fn collect_returns_empty_without_engine() {
-        // Global engine is not set in test context, so should return empty.
-        let tools = collect_skill_tools();
-        assert!(tools.is_empty());
-    }
-}
diff --git a/src/openhuman/tools/mod.rs b/src/openhuman/tools/mod.rs
index 810417b2f..67b1765ba 100644
--- a/src/openhuman/tools/mod.rs
+++ b/src/openhuman/tools/mod.rs
@@ -8,7 +8,7 @@ pub mod traits;
 #[path = "impl/mod.rs"]
 mod implementations;
 
-pub(crate) use implementations::agent::{skill_description, ARCHETYPE_TOOLS};
+pub(crate) use implementations::agent::ARCHETYPE_TOOLS;
 pub use implementations::*;
 pub use ops::*;
 #[allow(unused_imports)]
diff --git a/src/openhuman/tools/orchestrator_tools.rs b/src/openhuman/tools/orchestrator_tools.rs
index 64baa7404..6137e9071 100644
--- a/src/openhuman/tools/orchestrator_tools.rs
+++ b/src/openhuman/tools/orchestrator_tools.rs
@@ -1,22 +1,15 @@
 //! Dynamic orchestrator tool generation.
 //!
 //! Instead of a single `spawn_subagent` mega-tool, this module generates
-//! one tool per subagent archetype + one tool per installed skill. The
-//! orchestrator's function-calling schema becomes a flat list of
-//! well-named tools:
+//! one tool per subagent archetype. The orchestrator's function-calling
+//! schema becomes a flat list of well-named tools:
 //!
-//!   `notion`, `gmail`, `research`, `run_code`, `review_code`, `plan`
+//!   `research`, `run_code`, `review_code`, `plan`
 //!
 //! Each tool's `execute()` internally calls `run_subagent` with the
-//! correct definition + skill_filter. The LLM just picks the right tool
-//! by name — no `agent_id` or `skill_filter` to remember.
+//! correct definition. The LLM just picks the right tool by name.
 
-use std::collections::HashSet;
-
-use super::{
-    skill_description, ArchetypeDelegationTool, SkillDelegationTool, SpawnSubagentTool, Tool,
-    ARCHETYPE_TOOLS,
-};
+use super::{ArchetypeDelegationTool, SpawnSubagentTool, Tool, ARCHETYPE_TOOLS};
 
 /// Build the orchestrator's tool list: one tool per installed skill +
 /// one tool per archetype. Also includes `spawn_subagent` as a fallback
@@ -26,37 +19,6 @@ use super::{
 /// (i.e. the main agent is an orchestrator).
 pub fn collect_orchestrator_tools() -> Vec<Box<dyn Tool>> {
     let mut tools: Vec<Box<dyn Tool>> = Vec::new();
-    let mut seen_names: HashSet<String> = HashSet::new();
-
-    // ── Skill-based tools (dynamic, from running skills) ──────────────
-    if let Some(engine) = crate::openhuman::skills::global_engine() {
-        let all_skill_tools = engine.all_tools();
-        // Extract unique skill ids from tool names like "notion__search"
-        let mut skill_ids: Vec<String> = all_skill_tools
-            .iter()
-            .filter_map(|(skill_id, _)| {
-                if seen_names.insert(skill_id.clone()) {
-                    Some(skill_id.clone())
-                } else {
-                    None
-                }
-            })
-            .collect();
-        skill_ids.sort();
-        skill_ids.dedup();
-
-        for skill_id in &skill_ids {
-            log::info!(
-                "[orchestrator_tools] registering skill delegation tool: {}",
-                skill_id
-            );
-            tools.push(Box::new(SkillDelegationTool {
-                tool_name: skill_id.clone(),
-                skill_id: skill_id.clone(),
-                tool_description: skill_description(skill_id),
-            }));
-        }
-    }
 
     // ── Archetype-based tools (static) ────────────────────────────────
     for (tool_name, agent_id, description) in ARCHETYPE_TOOLS {
@@ -73,7 +35,6 @@ pub fn collect_orchestrator_tools() -> Vec<Box<dyn Tool>> {
     }
 
     // ── spawn_subagent as fallback for advanced use ────────────────────
-    // Fork mode, custom agent_ids, explicit skill_filter, etc.
     tools.push(Box::new(SpawnSubagentTool::new()));
 
     log::info!(
diff --git a/src/openhuman/tools/traits.rs b/src/openhuman/tools/traits.rs
index 9103be31a..ddca4014a 100644
--- a/src/openhuman/tools/traits.rs
+++ b/src/openhuman/tools/traits.rs
@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 
-// Re-export the unified ToolResult from the skills module so all tools use one type.
+// Re-export the unified ToolResult from the lightweight skills types module so all tools use one type.
 pub use crate::openhuman::skills::types::{ToolContent, ToolResult};
 
 /// Controls where a tool is available.
@@ -24,10 +24,8 @@ pub enum ToolScope {
 /// - **System tools** are built-in Rust implementations (shell, file_read,
 ///   file_write, cron_*, memory_*, …) that run inside the core process
 ///   with direct host access.
-/// - **Skill tools** are QuickJS skill exports bridged through
-///   [`crate::openhuman::tools::SkillToolBridge`]. They
-///   talk to external services (Notion, Gmail, Telegram, …) via
-///   user-installed skill packages.
+/// - **Skill tools** are integration-facing tools that talk to external
+///   services (for example Composio-backed SaaS actions).
 ///
 /// The orchestrator uses this category to spawn dedicated tool-execution
 /// sub-agents: one scoped to `Skill` for service integrations (running
@@ -39,7 +37,7 @@ pub enum ToolCategory {
     /// Built-in Rust tools with direct host access.
     #[default]
     System,
-    /// QuickJS skill tools bridged from the runtime engine.
+    /// Integration-facing tools that reach external services.
     Skill,
 }
 
@@ -92,7 +90,7 @@ pub struct ToolSpec {
     pub parameters: serde_json::Value,
 }
 
-/// Core tool trait — implement for any capability (built-in or skill-based).
+/// Core tool trait — implement for any capability (built-in or integration-based).
 #[async_trait]
 pub trait Tool: Send + Sync {
     /// Tool name (used in LLM function calling)
@@ -122,12 +120,7 @@ pub trait Tool: Send + Sync {
     }
 
     /// Category of this tool — `System` for built-in Rust tools (default)
-    /// or `Skill` for tools bridged from the QuickJS skill runtime.
-    ///
-    /// The sub-agent runner uses this to filter the parent's tool
-    /// registry when a sub-agent definition sets `category_filter`.
-    /// Skill-bridged tools override this to return
-    /// [`ToolCategory::Skill`].
+    /// or `Skill` for integration-facing tools.
     fn category(&self) -> ToolCategory {
         ToolCategory::System
     }
diff --git a/src/openhuman/webhooks/bus.rs b/src/openhuman/webhooks/bus.rs
index a3597809d..d5d283f1b 100644
--- a/src/openhuman/webhooks/bus.rs
+++ b/src/openhuman/webhooks/bus.rs
@@ -74,126 +74,19 @@ impl EventHandler for WebhookRequestSubscriber {
             correlation_id,
         );
 
-        // Get the webhook router from the skill engine
-        let router = crate::openhuman::skills::global_engine().map(|e| e.webhook_router());
-
-        let registration = router.as_ref().and_then(|r| r.registration(&tunnel_uuid));
-        let skill_id = registration
-            .as_ref()
-            .and_then(|reg| (reg.target_kind == "skill").then(|| reg.skill_id.clone()));
-        if let Some(ref router) = router {
-            router.record_request(request, skill_id.clone());
-        }
-
-        let (response, resolved_skill_id, response_error) = match registration.as_ref() {
-            Some(reg) if reg.target_kind == "echo" => (
-                crate::openhuman::webhooks::ops::build_echo_response(request),
-                Some("echo".to_string()),
-                None,
-            ),
-            Some(reg) if reg.target_kind == "channel" => (
-                crate::openhuman::webhooks::WebhookResponseData {
-                    correlation_id: correlation_id.clone(),
-                    status_code: 501,
-                    headers: std::collections::HashMap::new(),
-                    body: error_body(&format!(
-                        "channel webhook target '{}' is not implemented in this runtime yet",
-                        reg.skill_id
-                    )),
-                },
-                Some(reg.skill_id.clone()),
-                Some("channel webhook target not implemented".to_string()),
-            ),
-            Some(reg) if reg.target_kind == "skill" => {
-                let sid = reg.skill_id.clone();
-                tracing::debug!("[webhook] request routed to skill '{}'", sid);
-
-                let registry = crate::openhuman::skills::global_engine().map(|e| e.registry());
-                match registry {
-                    Some(registry) => {
-                        let result = registry
-                            .send_webhook_request(
-                                &sid,
-                                correlation_id.clone(),
-                                request.method.clone(),
-                                request.path.clone(),
-                                request.headers.clone(),
-                                request.query.clone(),
-                                request.body.clone(),
-                                request.tunnel_id.clone(),
-                                request.tunnel_name.clone(),
-                            )
-                            .await;
-
-                        match result {
-                            Ok(resp) => (resp, Some(sid), None),
-                            Err(e) => {
-                                tracing::warn!("[webhook] skill handler error: {}", e);
-                                (
-                                    crate::openhuman::webhooks::WebhookResponseData {
-                                        correlation_id: correlation_id.clone(),
-                                        status_code: 500,
-                                        headers: std::collections::HashMap::new(),
-                                        body: error_body(&format!("Skill handler error: {}", e)),
-                                    },
-                                    Some(sid),
-                                    Some(e),
-                                )
-                            }
-                        }
-                    }
-                    None => {
-                        tracing::warn!("[webhook] no skill registry available");
-                        (
-                            crate::openhuman::webhooks::WebhookResponseData {
-                                correlation_id: correlation_id.clone(),
-                                status_code: 503,
-                                headers: std::collections::HashMap::new(),
-                                body: error_body("Runtime not ready"),
-                            },
-                            None,
-                            Some("runtime not ready".to_string()),
-                        )
-                    }
-                }
-            }
-            Some(reg) => (
-                crate::openhuman::webhooks::WebhookResponseData {
-                    correlation_id: correlation_id.clone(),
-                    status_code: 400,
-                    headers: std::collections::HashMap::new(),
-                    body: error_body(&format!(
-                        "unknown webhook target kind '{}'",
-                        reg.target_kind
-                    )),
-                },
-                Some(reg.skill_id.clone()),
-                Some("unknown webhook target kind".to_string()),
-            ),
-            None => {
-                tracing::debug!("[webhook] no handler registered for tunnel {}", tunnel_uuid,);
-                (
-                    crate::openhuman::webhooks::WebhookResponseData {
-                        correlation_id: correlation_id.clone(),
-                        status_code: 404,
-                        headers: std::collections::HashMap::new(),
-                        body: error_body("No handler registered for this tunnel"),
-                    },
-                    None,
-                    Some("no handler registered for this tunnel".to_string()),
-                )
-            }
+        tracing::debug!(
+            "[webhook] skill runtime removed; rejecting tunnel {} ({})",
+            tunnel_uuid,
+            tunnel_name
+        );
+        let response = crate::openhuman::webhooks::WebhookResponseData {
+            correlation_id: correlation_id.clone(),
+            status_code: 410,
+            headers: std::collections::HashMap::new(),
+            body: error_body("Webhook skill runtime has been removed"),
         };
-
-        // Record in debug log
-        if let Some(ref router) = router {
-            router.record_response(
-                request,
-                &response,
-                resolved_skill_id.clone(),
-                response_error.clone(),
-            );
-        }
+        let resolved_skill_id: Option<String> = None;
+        let response_error = Some("webhook skill runtime removed".to_string());
 
         // Publish notification events
         if let Some(ref sid) = resolved_skill_id {
diff --git a/src/openhuman/webhooks/ops.rs b/src/openhuman/webhooks/ops.rs
index 8932cd385..67f181093 100644
--- a/src/openhuman/webhooks/ops.rs
+++ b/src/openhuman/webhooks/ops.rs
@@ -2,7 +2,6 @@ use crate::api::config::effective_api_url;
 use crate::api::jwt::get_session_token;
 use crate::api::BackendOAuthClient;
 use crate::openhuman::config::Config;
-use crate::openhuman::skills::global_engine;
 use crate::openhuman::webhooks::{
     WebhookDebugLogListResult, WebhookDebugLogsClearedResult, WebhookDebugRegistrationsResult,
     WebhookRequest, WebhookResponseData,
@@ -42,9 +41,8 @@ async fn get_authed_value(
 }
 
 pub async fn list_registrations() -> Result<RpcOutcome<WebhookDebugRegistrationsResult>, String> {
-    let engine = global_engine().ok_or_else(|| "skill runtime not initialized".to_string())?;
-    let registrations = engine.webhook_router().list_all();
-    let count = registrations.len();
+    let registrations = Vec::new();
+    let count = 0usize;
 
     Ok(RpcOutcome::single_log(
         WebhookDebugRegistrationsResult { registrations },
@@ -55,9 +53,9 @@ pub async fn list_registrations() -> Result<RpcOutcome<WebhookDebugRegistrations
 pub async fn list_logs(
     limit: Option<usize>,
 ) -> Result<RpcOutcome<WebhookDebugLogListResult>, String> {
-    let engine = global_engine().ok_or_else(|| "skill runtime not initialized".to_string())?;
-    let logs = engine.webhook_router().list_logs(limit);
-    let count = logs.len();
+    let _ = limit;
+    let logs = Vec::new();
+    let count = 0usize;
 
     Ok(RpcOutcome::single_log(
         WebhookDebugLogListResult { logs },
@@ -66,8 +64,7 @@ pub async fn list_logs(
 }
 
 pub async fn clear_logs() -> Result<RpcOutcome<WebhookDebugLogsClearedResult>, String> {
-    let engine = global_engine().ok_or_else(|| "skill runtime not initialized".to_string())?;
-    let cleared = engine.webhook_router().clear_logs();
+    let cleared = 0usize;
 
     Ok(RpcOutcome::single_log(
         WebhookDebugLogsClearedResult { cleared },
@@ -80,10 +77,8 @@ pub async fn register_echo(
     tunnel_name: Option<String>,
     backend_tunnel_id: Option<String>,
 ) -> Result<RpcOutcome<WebhookDebugRegistrationsResult>, String> {
-    let engine = global_engine().ok_or_else(|| "skill runtime not initialized".to_string())?;
-    let router = engine.webhook_router();
-    router.register_echo(tunnel_uuid, tunnel_name, backend_tunnel_id)?;
-    let registrations = router.list_all();
+    let _ = (tunnel_name, backend_tunnel_id);
+    let registrations = Vec::new();
 
     Ok(RpcOutcome::single_log(
         WebhookDebugRegistrationsResult { registrations },
@@ -94,10 +89,7 @@ pub async fn register_echo(
 pub async fn unregister_echo(
     tunnel_uuid: &str,
 ) -> Result<RpcOutcome<WebhookDebugRegistrationsResult>, String> {
-    let engine = global_engine().ok_or_else(|| "skill runtime not initialized".to_string())?;
-    let router = engine.webhook_router();
-    router.unregister(tunnel_uuid, "echo")?;
-    let registrations = router.list_all();
+    let registrations = Vec::new();
 
     Ok(RpcOutcome::single_log(
         WebhookDebugRegistrationsResult { registrations },
diff --git a/tests/json_rpc_e2e.rs b/tests/json_rpc_e2e.rs
index ee0b76740..1f663a119 100644
--- a/tests/json_rpc_e2e.rs
+++ b/tests/json_rpc_e2e.rs
@@ -13,12 +13,9 @@ use axum::routing::{get, post};
 use axum::{Json, Router};
 use futures_util::StreamExt;
 use serde_json::{json, Value};
-use sha2::{Digest, Sha256};
 use tempfile::tempdir;
 
 use openhuman_core::core::jsonrpc::build_core_http_router;
-use openhuman_core::openhuman::skills::qjs_engine::RuntimeEngine;
-use openhuman_core::openhuman::skills::set_global_engine;
 
 struct EnvVarGuard {
     key: &'static str,
@@ -495,33 +492,6 @@ fn assert_no_jsonrpc_error<'a>(v: &'a Value, context: &str) -> &'a Value {
         .unwrap_or_else(|| panic!("{context}: missing result: {v}"))
 }
 
-/// Poll `openhuman.skills_status` until lifecycle `status` is `"running"` or timeout.
-async fn wait_for_skill_status_running(rpc_base: &str, skill_id: &str, mut next_id: i64) -> i64 {
-    let deadline = tokio::time::Instant::now() + Duration::from_secs(10);
-    loop {
-        let status = post_json_rpc(
-            rpc_base,
-            next_id,
-            "openhuman.skills_status",
-            json!({"skill_id": skill_id}),
-        )
-        .await;
-        next_id += 1;
-        let st = assert_no_jsonrpc_error(&status, "skills_status (wait for running)");
-        let s = st.get("status").and_then(Value::as_str).unwrap_or("");
-        if s == "running" {
-            return next_id;
-        }
-        if s == "error" {
-            panic!("skill {skill_id} entered error while waiting for running: {st}");
-        }
-        if tokio::time::Instant::now() >= deadline {
-            panic!("timed out waiting for skill {skill_id} to reach running, last: {st}");
-        }
-        tokio::time::sleep(Duration::from_millis(100)).await;
-    }
-}
-
 fn extract_string_outcome(result: &Value) -> String {
     if let Some(s) = result.as_str() {
         return s.to_string();
@@ -1281,693 +1251,6 @@ async fn json_rpc_autocomplete_runtime_settings_and_logs_flow() {
     rpc_join.abort();
 }
 
-// ---------------------------------------------------------------------------
-// Skills registry E2E: fetch, search, install, list, uninstall
-// ---------------------------------------------------------------------------
-
-fn mock_skills_registry_router() -> Router {
-    let manifest_json = json!({
-        "id": "test-skill",
-        "name": "Test Skill",
-        "version": "1.0.0",
-        "description": "A test skill for E2E",
-        "runtime": "quickjs",
-        "entry": "index.js"
-    });
-    let js_content = "function init() { console.log('test-skill'); }";
-
-    // Compute checksum for the JS content
-    let mut hasher = Sha256::new();
-    hasher.update(js_content.as_bytes());
-    let checksum = format!("{:x}", hasher.finalize());
-
-    let registry = json!({
-        "version": 1,
-        "generated_at": "2026-03-30T12:00:00Z",
-        "skills": {
-            "core": [{
-                "id": "test-skill",
-                "name": "Test Skill",
-                "version": "1.0.0",
-                "description": "A test skill for E2E",
-                "runtime": "quickjs",
-                "entry": "index.js",
-                "auto_start": false,
-                "download_url": "__BASE__/skills/test-skill/index.js",
-                "manifest_url": "__BASE__/skills/test-skill/manifest.json",
-                "checksum_sha256": checksum
-            }, {
-                "id": "another-skill",
-                "name": "Another Skill",
-                "version": "2.0.0",
-                "description": "Another skill for search testing",
-                "runtime": "quickjs",
-                "entry": "index.js",
-                "download_url": "__BASE__/skills/another-skill/index.js",
-                "manifest_url": "__BASE__/skills/another-skill/manifest.json"
-            }],
-            "third_party": []
-        }
-    });
-
-    Router::new()
-        .route(
-            "/registry.json",
-            get(move || {
-                let r = registry.clone();
-                async move { Json(r) }
-            }),
-        )
-        .route(
-            "/skills/test-skill/manifest.json",
-            get(move || {
-                let m = manifest_json.clone();
-                async move { Json(m) }
-            }),
-        )
-        .route(
-            "/skills/test-skill/index.js",
-            get(move || async move { js_content }),
-        )
-}
-
-#[tokio::test]
-async fn json_rpc_skills_registry_install_uninstall() {
-    let _env_lock = json_rpc_e2e_env_lock();
-    // 1. Setup: temp workspace, mock skills server, RPC server
-    let tmp = tempdir().expect("tempdir");
-    let home = tmp.path();
-    let openhuman_home = home.join(".openhuman");
-    let workspace = openhuman_home.join("workspace");
-    std::fs::create_dir_all(workspace.join("skills")).expect("create skills dir");
-
-    let _home_guard = EnvVarGuard::set_to_path("HOME", home);
-    let _workspace_guard = EnvVarGuard::set_to_path("OPENHUMAN_WORKSPACE", &workspace);
-
-    // Start mock skills server
-    let (skills_addr, skills_join) = serve_on_ephemeral(mock_skills_registry_router()).await;
-    let skills_base = format!("http://{}", skills_addr);
-
-    // Point registry URL at mock server and fix the __BASE__ placeholder
-    let registry_url = format!("{}/registry.json", skills_base);
-    let _registry_url_guard =
-        EnvVarGuard::set_to_path("SKILLS_REGISTRY_URL", Path::new(&registry_url));
-
-    // Also need a mock upstream for config loading
-    let (mock_addr, mock_join) = serve_on_ephemeral(mock_upstream_router()).await;
-    let mock_origin = format!("http://{}", mock_addr);
-    write_min_config(&openhuman_home, &mock_origin);
-
-    // Start core RPC server
-    let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
-    let rpc_base = format!("http://{}", rpc_addr);
-    tokio::time::sleep(Duration::from_millis(100)).await;
-
-    // Sanity check
-    let ping = post_json_rpc(&rpc_base, 1, "core.ping", json!({})).await;
-    assert_no_jsonrpc_error(&ping, "core.ping");
-
-    // Pre-populate the registry cache with correct URLs pointing at mock server.
-    let cache_dir = workspace.join("skills");
-    let now_rfc3339 = chrono::Utc::now().to_rfc3339();
-    let js_content_bytes = b"function init() { console.log('test-skill'); }";
-    let mut h = Sha256::new();
-    h.update(js_content_bytes);
-    let js_checksum = format!("{:x}", h.finalize());
-    let dl_url = format!("{}/skills/test-skill/index.js", skills_base);
-    let mf_url = format!("{}/skills/test-skill/manifest.json", skills_base);
-    let dl_url2 = format!("{}/skills/another-skill/index.js", skills_base);
-    let mf_url2 = format!("{}/skills/another-skill/manifest.json", skills_base);
-
-    let registry_with_urls = json!({
-        "fetched_at": now_rfc3339,
-        "registry": {
-            "version": 1,
-            "generated_at": "2026-03-30T12:00:00Z",
-            "skills": {
-                "core": [{
-                    "id": "test-skill",
-                    "name": "Test Skill",
-                    "version": "1.0.0",
-                    "description": "A test skill for E2E",
-                    "runtime": "quickjs",
-                    "entry": "index.js",
-                    "auto_start": false,
-                    "download_url": dl_url,
-                    "manifest_url": mf_url,
-                    "checksum_sha256": js_checksum
-                }, {
-                    "id": "another-skill",
-                    "name": "Another Skill",
-                    "version": "2.0.0",
-                    "description": "Another skill for search testing",
-                    "runtime": "quickjs",
-                    "entry": "index.js",
-                    "download_url": dl_url2,
-                    "manifest_url": mf_url2
-                }],
-                "third_party": []
-            }
-        }
-    });
-    std::fs::write(
-        cache_dir.join(".registry-cache.json"),
-        serde_json::to_string_pretty(&registry_with_urls).unwrap(),
-    )
-    .expect("write cache");
-
-    // 2. skills_list_installed — should be empty initially
-    let list = post_json_rpc(&rpc_base, 10, "openhuman.skills_list_installed", json!({})).await;
-    let list_result = assert_no_jsonrpc_error(&list, "list_installed");
-    assert!(
-        list_result.as_array().unwrap().is_empty(),
-        "expected empty installed list"
-    );
-
-    // 3. skills_search — find "test-skill"
-    let search = post_json_rpc(
-        &rpc_base,
-        11,
-        "openhuman.skills_search",
-        json!({"query": "test"}),
-    )
-    .await;
-    let search_result = assert_no_jsonrpc_error(&search, "search");
-    let search_arr = search_result.as_array().expect("search result is array");
-    assert!(
-        search_arr.iter().any(|e| e["id"] == "test-skill"),
-        "expected test-skill in search results: {search_result}"
-    );
-
-    // 4. skills_install — install test-skill
-    let install = post_json_rpc(
-        &rpc_base,
-        12,
-        "openhuman.skills_install",
-        json!({"skill_id": "test-skill"}),
-    )
-    .await;
-    let install_result = assert_no_jsonrpc_error(&install, "install");
-    assert_eq!(install_result["success"], true);
-    assert_eq!(install_result["skill_id"], "test-skill");
-
-    // 5. Verify files exist on disk
-    let installed_manifest = workspace.join("skills/test-skill/manifest.json");
-    let installed_js = workspace.join("skills/test-skill/index.js");
-    assert!(
-        installed_manifest.exists(),
-        "manifest.json should exist after install"
-    );
-    assert!(installed_js.exists(), "index.js should exist after install");
-
-    // 6. skills_list_installed — should now show test-skill
-    let list2 = post_json_rpc(&rpc_base, 13, "openhuman.skills_list_installed", json!({})).await;
-    let list2_result = assert_no_jsonrpc_error(&list2, "list_installed_after");
-    let list2_arr = list2_result.as_array().expect("list result is array");
-    assert_eq!(list2_arr.len(), 1);
-    assert_eq!(list2_arr[0]["id"], "test-skill");
-
-    // 7. skills_list_available — test-skill should show installed=true
-    let available =
-        post_json_rpc(&rpc_base, 14, "openhuman.skills_list_available", json!({})).await;
-    let available_result = assert_no_jsonrpc_error(&available, "list_available");
-    let available_arr = available_result
-        .as_array()
-        .expect("available result is array");
-    let test_entry = available_arr
-        .iter()
-        .find(|e| e["id"] == "test-skill")
-        .expect("test-skill should be in available list");
-    assert_eq!(test_entry["installed"], true);
-    assert_eq!(test_entry["update_available"], false);
-
-    // 8. skills_uninstall — remove test-skill
-    let uninstall = post_json_rpc(
-        &rpc_base,
-        15,
-        "openhuman.skills_uninstall",
-        json!({"skill_id": "test-skill"}),
-    )
-    .await;
-    let uninstall_result = assert_no_jsonrpc_error(&uninstall, "uninstall");
-    assert_eq!(uninstall_result["success"], true);
-
-    // 9. Verify directory removed
-    assert!(
-        !installed_manifest.exists(),
-        "manifest should be gone after uninstall"
-    );
-    assert!(
-        !installed_js.exists(),
-        "index.js should be gone after uninstall"
-    );
-
-    // 10. skills_list_installed — should be empty again
-    let list3 = post_json_rpc(&rpc_base, 16, "openhuman.skills_list_installed", json!({})).await;
-    let list3_result = assert_no_jsonrpc_error(&list3, "list_installed_final");
-    assert!(
-        list3_result.as_array().unwrap().is_empty(),
-        "should be empty after uninstall"
-    );
-
-    skills_join.abort();
-    mock_join.abort();
-    rpc_join.abort();
-}
-
-// ---------------------------------------------------------------------------
-// Skills runtime E2E: start, list_tools, call_tool, sync, stop
-// ---------------------------------------------------------------------------
-
-/// Create a minimal QuickJS skill on disk with one tool.
-fn write_test_skill(workspace: &Path, skill_id: &str) {
-    let skill_dir = workspace.join("skills").join(skill_id);
-    std::fs::create_dir_all(&skill_dir).expect("create skill dir");
-
-    let manifest = json!({
-        "id": skill_id,
-        "name": "E2E Runtime Skill",
-        "version": "1.0.0",
-        "description": "Minimal skill for runtime E2E tests",
-        "runtime": "quickjs",
-        "entry": "index.js",
-        "auto_start": false
-    });
-    std::fs::write(
-        skill_dir.join("manifest.json"),
-        serde_json::to_string_pretty(&manifest).unwrap(),
-    )
-    .expect("write manifest");
-
-    // Minimal JS skill that exports one tool: "echo" and a deterministic onSync
-    // payload so we can assert sync → working-memory extraction end to end.
-    let js = r#"
-        globalThis.__skill = {
-            name: "E2E Runtime Skill",
-            tools: [
-                {
-                    name: "echo",
-                    description: "Echoes back the input message",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            message: { type: "string", description: "Message to echo" }
-                        },
-                        required: ["message"]
-                    },
-                    execute(args) {
-                        return { type: "text", text: "echo: " + (args.message || "empty") };
-                    }
-                }
-            ]
-        };
-
-        function init() {
-            if (globalThis.__ops && globalThis.__ops.log) {
-                globalThis.__ops.log("info", "e2e-runtime-skill initialized");
-            }
-        }
-
-        async function onSync() {
-            if (globalThis.state && typeof globalThis.state.set === "function") {
-                globalThis.state.set("sync_payload", {
-                    preferences: { writing_style: "prefers concise updates", language: "English" },
-                    goals: ["Ship e2e integration"],
-                    constraints: ["No meetings after 3pm"],
-                    projects: [{ name: "Atlas" }]
-                });
-            }
-            return { status: "ok", synced: true };
-        }
-
-        /** Required by `oauth/complete` — runtime calls `start({ oauth, auth, validate: true })`. */
-        function start(_args) {
-            return { status: "complete" };
-        }
-
-        init();
-    "#;
-    std::fs::write(skill_dir.join("index.js"), js).expect("write index.js");
-}
-
-#[tokio::test]
-async fn json_rpc_skills_runtime_start_tools_call_stop() {
-    let _env_lock = json_rpc_e2e_env_lock();
-    let tmp = tempdir().expect("tempdir");
-    let home = tmp.path();
-    let openhuman_home = home.join(".openhuman");
-    let workspace = openhuman_home.join("workspace");
-    std::fs::create_dir_all(workspace.join("skills")).expect("create skills dir");
-
-    let _home_guard = EnvVarGuard::set_to_path("HOME", home);
-    let _workspace_guard = EnvVarGuard::set_to_path("OPENHUMAN_WORKSPACE", &workspace);
-    // Ensure working-memory extraction is not disabled by an ambient env var so
-    // the assertions below are deterministic regardless of the host environment.
-    let _wm_guard = EnvVarGuard::unset("OPENHUMAN_SKILLS_WORKING_MEMORY_ENABLED");
-
-    // Write a minimal skill to the workspace
-    write_test_skill(&workspace, "e2e-runtime");
-
-    // Mock upstream for config loading
-    let (mock_addr, mock_join) = serve_on_ephemeral(mock_upstream_router()).await;
-    let mock_origin = format!("http://{}", mock_addr);
-    write_min_config(&openhuman_home, &mock_origin);
-
-    // Initialize and set the global RuntimeEngine
-    let skills_data_dir = workspace.join("skills_data");
-    std::fs::create_dir_all(&skills_data_dir).expect("create skills_data dir");
-    let engine =
-        std::sync::Arc::new(RuntimeEngine::new(skills_data_dir).expect("create RuntimeEngine"));
-    engine.set_workspace_dir(workspace.clone());
-    set_global_engine(engine);
-
-    // Start RPC server
-    let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
-    let rpc_base = format!("http://{}", rpc_addr);
-    tokio::time::sleep(Duration::from_millis(100)).await;
-
-    // Sanity check
-    let ping = post_json_rpc(&rpc_base, 1, "core.ping", json!({})).await;
-    assert_no_jsonrpc_error(&ping, "core.ping");
-
-    // 1. Start the skill
-    let start = post_json_rpc(
-        &rpc_base,
-        20,
-        "openhuman.skills_start",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let start_result = assert_no_jsonrpc_error(&start, "skills_start");
-    assert_eq!(
-        start_result.get("skill_id").and_then(Value::as_str),
-        Some("e2e-runtime"),
-        "start should return correct skill_id: {start_result}"
-    );
-    let status_str = start_result
-        .get("status")
-        .and_then(Value::as_str)
-        .unwrap_or("");
-    assert!(
-        status_str == "running" || status_str == "initializing",
-        "skill should be running or initializing after start, got: {status_str}"
-    );
-
-    // Give the skill a moment to finish initializing
-    tokio::time::sleep(Duration::from_millis(500)).await;
-
-    // 2. Get skill status
-    let status = post_json_rpc(
-        &rpc_base,
-        21,
-        "openhuman.skills_status",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let status_result = assert_no_jsonrpc_error(&status, "skills_status");
-    assert_eq!(
-        status_result.get("skill_id").and_then(Value::as_str),
-        Some("e2e-runtime")
-    );
-
-    let data_stats = post_json_rpc(
-        &rpc_base,
-        211,
-        "openhuman.skills_data_stats",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let ds = assert_no_jsonrpc_error(&data_stats, "skills_data_stats");
-    assert_eq!(ds.get("exists"), Some(&json!(true)));
-    assert!(ds.get("path").and_then(Value::as_str).is_some());
-    assert!(ds.get("total_bytes").and_then(Value::as_u64).is_some());
-    assert!(ds.get("file_count").and_then(Value::as_u64).is_some());
-
-    // 3. List tools
-    let tools = post_json_rpc(
-        &rpc_base,
-        22,
-        "openhuman.skills_list_tools",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let tools_result = assert_no_jsonrpc_error(&tools, "skills_list_tools");
-    let tools_arr = tools_result
-        .get("tools")
-        .and_then(Value::as_array)
-        .expect("tools should be an array");
-    assert!(
-        !tools_arr.is_empty(),
-        "skill should expose at least one tool: {tools_result}"
-    );
-    let has_echo = tools_arr
-        .iter()
-        .any(|t| t.get("name").and_then(Value::as_str) == Some("echo"));
-    assert!(has_echo, "should have 'echo' tool: {tools_result}");
-
-    // 4. Call the echo tool
-    let call = post_json_rpc(
-        &rpc_base,
-        23,
-        "openhuman.skills_call_tool",
-        json!({
-            "skill_id": "e2e-runtime",
-            "tool_name": "echo",
-            "arguments": { "message": "hello from e2e" }
-        }),
-    )
-    .await;
-    let call_result = assert_no_jsonrpc_error(&call, "skills_call_tool");
-    // Tool result has content array with text blocks
-    let empty = vec![];
-    let content = call_result
-        .get("content")
-        .and_then(Value::as_array)
-        .unwrap_or(&empty);
-    let has_echo_text = content.iter().any(|c| {
-        c.get("text")
-            .and_then(Value::as_str)
-            .map(|t| t.contains("hello from e2e"))
-            .unwrap_or(false)
-    });
-    assert!(
-        has_echo_text,
-        "echo tool should return the message: {call_result}"
-    );
-
-    // 5. Trigger sync (routes to onSync via skill/sync RPC)
-    let sync = post_json_rpc(
-        &rpc_base,
-        24,
-        "openhuman.skills_sync",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let _sync_result = assert_no_jsonrpc_error(&sync, "skills_sync");
-
-    // 5a. Poll until the async memory worker has written working-memory docs into
-    // the global namespace, instead of relying on a fixed sleep.
-    let poll_deadline = tokio::time::Instant::now() + Duration::from_secs(10);
-    let (docs_result, docs_arr) = loop {
-        let docs = post_json_rpc(
-            &rpc_base,
-            241,
-            "openhuman.memory_list_documents",
-            json!({"namespace":"global"}),
-        )
-        .await;
-        let arr = {
-            let result = assert_no_jsonrpc_error(&docs, "memory_list_documents");
-            result
-                .get("documents")
-                .or_else(|| result.get("data").and_then(|d| d.get("documents")))
-                .and_then(Value::as_array)
-                .cloned()
-                .unwrap_or_default()
-        };
-        let has_summary = arr.iter().any(|doc| {
-            doc.get("key").and_then(Value::as_str) == Some("working.user.e2e-runtime.summary")
-        });
-        if has_summary {
-            break (docs, arr);
-        }
-        assert!(
-            tokio::time::Instant::now() < poll_deadline,
-            "Timeout waiting for working.user.e2e-runtime.summary to appear. docs={docs}"
-        );
-        tokio::time::sleep(Duration::from_millis(200)).await;
-    };
-
-    let wm_keys: Vec<String> = docs_arr
-        .iter()
-        .filter_map(|doc| doc.get("key").and_then(Value::as_str))
-        .filter(|key| key.starts_with("working.user.e2e-runtime."))
-        .map(ToString::to_string)
-        .collect();
-
-    assert!(
-        !wm_keys.is_empty(),
-        "Expected working memory docs after skills_sync, found none. docs={docs_result}"
-    );
-    assert!(
-        wm_keys
-            .iter()
-            .any(|key| key == "working.user.e2e-runtime.summary"),
-        "Expected summary working-memory key. keys={wm_keys:?}"
-    );
-
-    // 6. Stop the skill
-    let stop = post_json_rpc(
-        &rpc_base,
-        25,
-        "openhuman.skills_stop",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let stop_result = assert_no_jsonrpc_error(&stop, "skills_stop");
-    assert_eq!(stop_result.get("success"), Some(&json!(true)));
-
-    mock_join.abort();
-    rpc_join.abort();
-}
-
-/// After `skills_set_setup_complete`, `skills_status` must succeed even when the skill was never
-/// started — the same persisted flag OAuth uses before QuickJS has registered the instance.
-#[tokio::test]
-async fn json_rpc_skills_status_reflects_setup_complete_without_runtime() {
-    let _env_lock = json_rpc_e2e_env_lock();
-    let tmp = tempdir().expect("tempdir");
-    let home = tmp.path();
-    let openhuman_home = home.join(".openhuman");
-    let workspace = openhuman_home.join("workspace");
-    std::fs::create_dir_all(workspace.join("skills")).expect("create skills dir");
-
-    let _home_guard = EnvVarGuard::set_to_path("HOME", home);
-    let _workspace_guard = EnvVarGuard::set_to_path("OPENHUMAN_WORKSPACE", &workspace);
-    let _wm_guard = EnvVarGuard::unset("OPENHUMAN_SKILLS_WORKING_MEMORY_ENABLED");
-
-    write_test_skill(&workspace, "e2e-runtime");
-
-    let (mock_addr, mock_join) = serve_on_ephemeral(mock_upstream_router()).await;
-    let mock_origin = format!("http://{}", mock_addr);
-    write_min_config(&openhuman_home, &mock_origin);
-
-    let skills_data_dir = workspace.join("skills_data");
-    std::fs::create_dir_all(&skills_data_dir).expect("create skills_data dir");
-    let engine =
-        std::sync::Arc::new(RuntimeEngine::new(skills_data_dir).expect("create RuntimeEngine"));
-    engine.set_workspace_dir(workspace.clone());
-    set_global_engine(engine);
-
-    let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
-    let rpc_base = format!("http://{}", rpc_addr);
-    tokio::time::sleep(Duration::from_millis(100)).await;
-
-    let set_done = post_json_rpc(
-        &rpc_base,
-        500,
-        "openhuman.skills_set_setup_complete",
-        json!({"skill_id": "e2e-runtime", "complete": true}),
-    )
-    .await;
-    let set_result = assert_no_jsonrpc_error(&set_done, "skills_set_setup_complete");
-    assert_eq!(set_result.get("success"), Some(&json!(true)));
-
-    let status = post_json_rpc(
-        &rpc_base,
-        501,
-        "openhuman.skills_status",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let st = assert_no_jsonrpc_error(&status, "skills_status");
-    assert_eq!(
-        st.get("setup_complete").and_then(Value::as_bool),
-        Some(true),
-        "status should surface persisted setup_complete without skills_start: {st}"
-    );
-
-    mock_join.abort();
-    rpc_join.abort();
-}
-
-/// `oauth/complete` is delivered via `openhuman.skills_rpc` after `skills_start` (browser OAuth →
-/// deep link / host uses the same RPC in production).
-#[tokio::test]
-async fn json_rpc_skills_oauth_complete_after_start() {
-    let _env_lock = json_rpc_e2e_env_lock();
-    let tmp = tempdir().expect("tempdir");
-    let home = tmp.path();
-    let openhuman_home = home.join(".openhuman");
-    let workspace = openhuman_home.join("workspace");
-    std::fs::create_dir_all(workspace.join("skills")).expect("create skills dir");
-
-    let _home_guard = EnvVarGuard::set_to_path("HOME", home);
-    let _workspace_guard = EnvVarGuard::set_to_path("OPENHUMAN_WORKSPACE", &workspace);
-    let _wm_guard = EnvVarGuard::unset("OPENHUMAN_SKILLS_WORKING_MEMORY_ENABLED");
-
-    write_test_skill(&workspace, "e2e-runtime");
-
-    let (mock_addr, mock_join) = serve_on_ephemeral(mock_upstream_router()).await;
-    let mock_origin = format!("http://{}", mock_addr);
-    write_min_config(&openhuman_home, &mock_origin);
-
-    let skills_data_dir = workspace.join("skills_data");
-    std::fs::create_dir_all(&skills_data_dir).expect("create skills_data dir");
-    let engine =
-        std::sync::Arc::new(RuntimeEngine::new(skills_data_dir).expect("create RuntimeEngine"));
-    engine.set_workspace_dir(workspace.clone());
-    set_global_engine(engine);
-
-    let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
-    let rpc_base = format!("http://{}", rpc_addr);
-    tokio::time::sleep(Duration::from_millis(100)).await;
-
-    let start = post_json_rpc(
-        &rpc_base,
-        600,
-        "openhuman.skills_start",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let _ = assert_no_jsonrpc_error(&start, "skills_start");
-    let next_after_running = wait_for_skill_status_running(&rpc_base, "e2e-runtime", 6001).await;
-
-    let oauth = post_json_rpc(
-        &rpc_base,
-        next_after_running,
-        "openhuman.skills_rpc",
-        json!({
-            "skill_id": "e2e-runtime",
-            "method": "oauth/complete",
-            "params": {
-                "credentialId": "e2e-oauth-integration-id",
-                "provider": "google",
-                "grantedScopes": []
-            }
-        }),
-    )
-    .await;
-    let oauth_result = assert_no_jsonrpc_error(&oauth, "skills_rpc oauth/complete");
-    assert_eq!(
-        oauth_result.get("status").and_then(Value::as_str),
-        Some("complete"),
-        "oauth/complete should return start() validation result: {oauth_result}"
-    );
-
-    let stop = post_json_rpc(
-        &rpc_base,
-        next_after_running + 1,
-        "openhuman.skills_stop",
-        json!({"skill_id": "e2e-runtime"}),
-    )
-    .await;
-    let _ = assert_no_jsonrpc_error(&stop, "skills_stop");
-
-    mock_join.abort();
-    rpc_join.abort();
-}
-
 // ---------------------------------------------------------------------------
 // Local AI device profile, presets, and apply preset
 // ---------------------------------------------------------------------------
diff --git a/tests/skills_debug_e2e.rs b/tests/skills_debug_e2e.rs
deleted file mode 100644
index 642bc9d6c..000000000
--- a/tests/skills_debug_e2e.rs
+++ /dev/null
@@ -1,777 +0,0 @@
-//! Skills runtime debug / integration tests.
-//!
-//! Exercises the full skill lifecycle through the RuntimeEngine:
-//!   discover → start → list tools → call tool → setup flow → tick/sync → stop
-//!
-//! By default uses a preferred skill from the checked-out openhuman-skills repo.
-//! Override with env vars:
-//!   SKILL_DEBUG_ID        — skill ID to test
-//!   SKILL_DEBUG_DIR       — path to skills directory containing skill folders
-//!   SKILL_DEBUG_TOOL      — specific tool name to call (default: first tool found)
-//!   SKILL_DEBUG_TOOL_ARGS — JSON args for the tool call (default: "{}")
-//!   SKILL_DEBUG_VERBOSE   — set to "1" for extra output
-//!
-//! Run:
-//!   cargo test --test skills_debug_e2e -- --nocapture
-//!   # or via the wrapper script:
-//!   bash scripts/debug-skill.sh [skill-id] [skills-dir]
-
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::time::Duration;
-
-use serde_json::{json, Value};
-use tempfile::tempdir;
-
-use openhuman_core::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-fn env_or(key: &str, default: &str) -> String {
-    std::env::var(key).unwrap_or_else(|_| default.to_string())
-}
-
-fn is_verbose() -> bool {
-    std::env::var("SKILL_DEBUG_VERBOSE")
-        .map(|v| v == "1" || v == "true")
-        .unwrap_or(false)
-}
-
-fn manifests_in_dir(skills_dir: &Path) -> Vec<String> {
-    let mut ids = Vec::new();
-    let Ok(entries) = std::fs::read_dir(skills_dir) else {
-        return ids;
-    };
-
-    for entry in entries.flatten() {
-        let path = entry.path();
-        if !path.is_dir() || !path.join("manifest.json").exists() {
-            continue;
-        }
-        if let Some(name) = path.file_name().and_then(|name| name.to_str()) {
-            ids.push(name.to_string());
-        }
-    }
-
-    ids.sort();
-    ids
-}
-
-fn select_skill_id(skills_dir: &Path, env_key: &str, preferred: &[&str]) -> String {
-    if let Ok(skill_id) = std::env::var(env_key) {
-        if !skill_id.trim().is_empty() {
-            return skill_id;
-        }
-    }
-
-    let available = manifests_in_dir(skills_dir);
-    for candidate in preferred {
-        if available.iter().any(|id| id == candidate) {
-            return (*candidate).to_string();
-        }
-    }
-
-    available
-        .into_iter()
-        .next()
-        .unwrap_or_else(|| "example-skill".to_string())
-}
-
-fn banner(label: &str) {
-    let sep = "=".repeat(60);
-    eprintln!("\n{sep}");
-    eprintln!("  {label}");
-    eprintln!("{sep}");
-}
-
-fn step(label: &str) {
-    eprintln!("\n--- {label} ---");
-}
-
-fn ok(msg: &str) {
-    eprintln!("  ✓ {msg}");
-}
-
-fn fail(msg: &str) {
-    eprintln!("  ✗ {msg}");
-}
-
-fn info(msg: &str) {
-    eprintln!("  · {msg}");
-}
-
-/// Find the skills source directory. Returns None when not available (e.g. CI).
-///
-/// Priority:
-/// 1. SKILL_DEBUG_DIR env var
-/// 2. SKILLS_LOCAL_DIR env var (shared with runtime)
-/// 3. ../openhuman-skills/skills (sibling repo)
-/// 4. openhuman-skills/skills (subdir)
-/// 5. Broader search in parent workspace
-fn try_find_skills_dir() -> Option<PathBuf> {
-    if let Ok(dir) = std::env::var("SKILL_DEBUG_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-        eprintln!("SKILL_DEBUG_DIR={dir} does not exist");
-        return None;
-    }
-
-    if let Ok(dir) = std::env::var("SKILLS_LOCAL_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-        eprintln!("SKILLS_LOCAL_DIR={dir} does not exist");
-    }
-
-    let cwd = std::env::current_dir().expect("cwd");
-
-    let candidates = [
-        cwd.join("../openhuman-skills/skills"),
-        cwd.join("openhuman-skills/skills"),
-        cwd.join("../alphahuman/skills/skills"),
-    ];
-
-    for candidate in &candidates {
-        if candidate.exists() {
-            return Some(candidate.canonicalize().unwrap());
-        }
-    }
-
-    // Search parent workspace
-    if let Some(parent) = cwd.parent() {
-        for entry in std::fs::read_dir(parent).into_iter().flatten().flatten() {
-            let candidate = entry.path().join("skills/skills");
-            if candidate.exists() && candidate.read_dir().is_ok() {
-                return Some(candidate.canonicalize().unwrap());
-            }
-        }
-    }
-
-    None
-}
-
-/// Convenience wrapper that skips the test when no skills directory is found.
-macro_rules! require_skills_dir {
-    () => {
-        match try_find_skills_dir() {
-            Some(dir) => dir,
-            None => {
-                eprintln!("SKIPPED: no skills directory available (set SKILL_DEBUG_DIR for CI)");
-                return;
-            }
-        }
-    };
-}
-
-/// Create a RuntimeEngine with the given skills source dir and a temp data dir.
-async fn create_engine(skills_dir: &Path, data_dir: &Path) -> Arc<RuntimeEngine> {
-    let engine =
-        RuntimeEngine::new(data_dir.to_path_buf()).expect("RuntimeEngine::new should succeed");
-    let engine = Arc::new(engine);
-
-    // Set the skills source directory
-    engine.set_skills_source_dir(skills_dir.to_path_buf());
-
-    // Set as global so RPC handlers can find it
-    set_global_engine(engine.clone());
-
-    engine
-}
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-/// Full lifecycle test: discover → start → tools → call → setup → tick → stop
-#[tokio::test]
-async fn skill_full_lifecycle() {
-    let _ = env_logger::builder()
-        .filter_level(if is_verbose() {
-            log::LevelFilter::Debug
-        } else {
-            log::LevelFilter::Info
-        })
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let skill_id = select_skill_id(
-        &skills_dir,
-        "SKILL_DEBUG_ID",
-        &["server-ping", "gmail", "notion"],
-    );
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    std::fs::create_dir_all(&data_dir).expect("create data_dir");
-
-    banner(&format!("Skills Debug E2E — skill: {skill_id}"));
-    info(&format!("Skills dir: {}", skills_dir.display()));
-    info(&format!("Data dir:   {}", data_dir.display()));
-
-    let engine = create_engine(&skills_dir, &data_dir).await;
-
-    // ── 1. Discover ──
-    step("DISCOVER SKILLS");
-    let manifests = engine.discover_skills().await;
-    match &manifests {
-        Ok(m) => {
-            ok(&format!("Found {} skill(s)", m.len()));
-            for manifest in m {
-                info(&format!(
-                    "  {} — {} (runtime: {}, auto_start: {})",
-                    manifest.id, manifest.name, manifest.runtime, manifest.auto_start
-                ));
-            }
-
-            // Verify target skill exists
-            let found = m.iter().any(|m| m.id == skill_id);
-            if found {
-                ok(&format!("Target skill '{skill_id}' found in discovery"));
-            } else {
-                fail(&format!(
-                    "Target skill '{skill_id}' NOT found. Available: {}",
-                    m.iter()
-                        .map(|m| m.id.as_str())
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                ));
-                panic!("Target skill not found in discovered skills");
-            }
-        }
-        Err(e) => {
-            fail(&format!("Discovery failed: {e}"));
-            panic!("Skill discovery failed: {e}");
-        }
-    }
-
-    // ── 2. Start ──
-    step(&format!("START SKILL '{skill_id}'"));
-    let start_result = engine.start_skill(&skill_id).await;
-    match &start_result {
-        Ok(snapshot) => {
-            ok(&format!("Skill started — status: {:?}", snapshot.status));
-            info(&format!("  Name: {}", snapshot.name));
-            info(&format!("  Tools: {} registered", snapshot.tools.len()));
-            for tool in &snapshot.tools {
-                info(&format!("    - {} : {}", tool.name, tool.description));
-            }
-            if let Some(err) = &snapshot.error {
-                fail(&format!("  Error: {err}"));
-            }
-            info(&format!(
-                "  Published state keys: {:?}",
-                snapshot.state.keys().collect::<Vec<_>>()
-            ));
-        }
-        Err(e) => {
-            fail(&format!("Start failed: {e}"));
-            panic!("Skill start failed: {e}");
-        }
-    }
-
-    let snapshot = start_result.unwrap();
-
-    // ── 3. List tools via RPC ──
-    step("LIST TOOLS (via RPC)");
-    let tools_result = engine.rpc(&skill_id, "tools/list", json!({})).await;
-    match &tools_result {
-        Ok(val) => {
-            let tools = val.get("tools").and_then(|t| t.as_array());
-            if let Some(tools) = tools {
-                ok(&format!("{} tool(s) via RPC", tools.len()));
-                for tool in tools {
-                    let name = tool.get("name").and_then(|n| n.as_str()).unwrap_or("?");
-                    info(&format!("  - {name}"));
-                }
-            } else {
-                ok(&format!("RPC result: {val}"));
-            }
-        }
-        Err(e) => {
-            fail(&format!("tools/list RPC failed: {e}"));
-        }
-    }
-
-    // ── 4. Call a tool ──
-    step("CALL TOOL");
-    let tool_name = env_or(
-        "SKILL_DEBUG_TOOL",
-        snapshot
-            .tools
-            .first()
-            .map(|t| t.name.as_str())
-            .unwrap_or("get-status"),
-    );
-    let tool_args: Value = std::env::var("SKILL_DEBUG_TOOL_ARGS")
-        .ok()
-        .and_then(|s| serde_json::from_str(&s).ok())
-        .unwrap_or_else(|| json!({}));
-
-    info(&format!(
-        "Calling tool '{tool_name}' with args: {tool_args}"
-    ));
-
-    let call_result = tokio::time::timeout(
-        Duration::from_secs(30),
-        engine.call_tool(&skill_id, &tool_name, tool_args.clone()),
-    )
-    .await;
-
-    match call_result {
-        Ok(Ok(result)) => {
-            ok(&format!(
-                "Tool call succeeded (is_error: {})",
-                result.is_error
-            ));
-            for content in &result.content {
-                match content {
-                    openhuman_core::openhuman::skills::types::ToolContent::Text { text } => {
-                        info(&format!("  Text: {text}"));
-                    }
-                    openhuman_core::openhuman::skills::types::ToolContent::Json { data } => {
-                        info(&format!("  JSON: {data}"));
-                    }
-                }
-            }
-            if result.is_error {
-                fail("Tool returned is_error=true");
-            }
-        }
-        Ok(Err(e)) => {
-            fail(&format!("Tool call error: {e}"));
-        }
-        Err(_) => {
-            fail("Tool call TIMED OUT (30s)");
-            panic!("Tool call timed out");
-        }
-    }
-
-    // ── 4b. Call tool via RPC path (tools/call) ──
-    step("CALL TOOL (via RPC)");
-    let rpc_call_result = tokio::time::timeout(
-        Duration::from_secs(30),
-        engine.rpc(
-            &skill_id,
-            "tools/call",
-            json!({ "name": tool_name, "arguments": tool_args }),
-        ),
-    )
-    .await;
-
-    match rpc_call_result {
-        Ok(Ok(val)) => {
-            ok(&format!("RPC tools/call succeeded: {val}"));
-        }
-        Ok(Err(e)) => {
-            fail(&format!("RPC tools/call error: {e}"));
-        }
-        Err(_) => {
-            fail("RPC tools/call TIMED OUT (30s)");
-        }
-    }
-
-    // ── 5. Setup flow ──
-    step("SETUP FLOW");
-    let setup_result = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc(&skill_id, "setup/start", json!({})),
-    )
-    .await;
-
-    match setup_result {
-        Ok(Ok(val)) => {
-            ok(&format!("setup/start returned: {val}"));
-
-            // If there's a step with fields, try a submit with empty values
-            if let Some(step_id) = val.get("stepId").and_then(|s| s.as_str()) {
-                info(&format!("Got setup step: {step_id}"));
-
-                if let Some(fields) = val.get("fields").and_then(|f| f.as_array()) {
-                    info(&format!(
-                        "  Fields: {}",
-                        fields
-                            .iter()
-                            .filter_map(|f| f.get("name").and_then(|n| n.as_str()))
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    ));
-                }
-
-                // Cancel setup (don't actually submit — we don't have valid creds)
-                let cancel = engine.rpc(&skill_id, "setup/cancel", json!({})).await;
-                match cancel {
-                    Ok(val) => ok(&format!("setup/cancel: {val}")),
-                    Err(e) => info(&format!("setup/cancel: {e} (may be fine)")),
-                }
-            }
-        }
-        Ok(Err(e)) => {
-            info(&format!(
-                "setup/start returned error: {e} (expected if no setup handler)"
-            ));
-        }
-        Err(_) => {
-            fail("setup/start TIMED OUT (10s)");
-        }
-    }
-
-    // ── 6a. Tick ──
-    step("TICK");
-    let tick_result = tokio::time::timeout(
-        Duration::from_secs(15),
-        engine.rpc(&skill_id, "skill/tick", json!({})),
-    )
-    .await;
-
-    match tick_result {
-        Ok(Ok(val)) => {
-            ok(&format!("skill/tick returned: {val}"));
-        }
-        Ok(Err(e)) => {
-            info(&format!("skill/tick error: {e} (may be expected)"));
-        }
-        Err(_) => {
-            fail("skill/tick TIMED OUT (15s)");
-        }
-    }
-
-    // ── 6b. Sync (calls onSync, not onTick) ──
-    step("SYNC (skill/sync → onSync)");
-    let sync_result = tokio::time::timeout(
-        Duration::from_secs(15),
-        engine.rpc(&skill_id, "skill/sync", json!({})),
-    )
-    .await;
-
-    match sync_result {
-        Ok(Ok(val)) => {
-            ok(&format!("skill/sync returned: {val}"));
-        }
-        Ok(Err(e)) => {
-            info(&format!(
-                "skill/sync error: {e} (expected if skill has no onSync handler)"
-            ));
-        }
-        Err(_) => {
-            fail("skill/sync TIMED OUT (15s)");
-        }
-    }
-
-    // ── 7. Session lifecycle ──
-    step("SESSION LIFECYCLE");
-    let session_id = "debug-session-1";
-
-    let session_start = engine
-        .rpc(
-            &skill_id,
-            "skill/sessionStart",
-            json!({ "sessionId": session_id }),
-        )
-        .await;
-    match session_start {
-        Ok(val) => ok(&format!("sessionStart: {val}")),
-        Err(e) => info(&format!("sessionStart: {e} (may be expected)")),
-    }
-
-    let session_end = engine
-        .rpc(
-            &skill_id,
-            "skill/sessionEnd",
-            json!({ "sessionId": session_id }),
-        )
-        .await;
-    match session_end {
-        Ok(val) => ok(&format!("sessionEnd: {val}")),
-        Err(e) => info(&format!("sessionEnd: {e} (may be expected)")),
-    }
-
-    // ── 8. Skill state check ──
-    step("SKILL STATE CHECK");
-    let state = engine.get_skill_state(&skill_id);
-    match state {
-        Some(snap) => {
-            ok(&format!("Status: {:?}", snap.status));
-            info(&format!("Tools: {}", snap.tools.len()));
-            info(&format!("Published state: {} key(s)", snap.state.len()));
-            if is_verbose() {
-                for (k, v) in &snap.state {
-                    info(&format!("  {k} = {v}"));
-                }
-            }
-        }
-        None => {
-            fail("Skill not found in registry after start");
-        }
-    }
-
-    // ── 9. List all tools (cross-skill) ──
-    step("ALL TOOLS (cross-skill)");
-    let all_tools = engine.all_tools();
-    ok(&format!("{} tool(s) across all skills", all_tools.len()));
-    for (skill, tool) in &all_tools {
-        info(&format!("  {skill} :: {}", tool.name));
-    }
-
-    // ── 10. Stop ──
-    step(&format!("STOP SKILL '{skill_id}'"));
-    let stop_result =
-        tokio::time::timeout(Duration::from_secs(10), engine.stop_skill(&skill_id)).await;
-
-    match stop_result {
-        Ok(Ok(())) => {
-            ok("Skill stopped cleanly");
-        }
-        Ok(Err(e)) => {
-            fail(&format!("Stop failed: {e}"));
-        }
-        Err(_) => {
-            fail("Stop TIMED OUT (10s)");
-        }
-    }
-
-    // Verify stopped
-    let post_stop = engine.get_skill_state(&skill_id);
-    match post_stop {
-        Some(snap) => {
-            info(&format!("Post-stop status: {:?}", snap.status));
-        }
-        None => {
-            ok("Skill unregistered after stop");
-        }
-    }
-
-    // ── 11. List skills (should show stopped/unregistered) ──
-    step("LIST ALL SKILLS (post-stop)");
-    let all = engine.list_skills();
-    ok(&format!("{} skill(s) still registered", all.len()));
-    for s in &all {
-        info(&format!("  {} — {:?}", s.skill_id, s.status));
-    }
-
-    banner("ALL CHECKS COMPLETE");
-}
-
-/// Test that calling a tool on a non-existent skill gives a clear error.
-#[tokio::test]
-async fn skill_not_found_gives_clear_error() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Warn)
-        .is_test(true)
-        .try_init();
-
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    std::fs::create_dir_all(&data_dir).unwrap();
-
-    let engine = RuntimeEngine::new(data_dir).expect("engine");
-    let engine = Arc::new(engine);
-    set_global_engine(engine.clone());
-
-    let result = engine
-        .call_tool("nonexistent-skill", "some-tool", json!({}))
-        .await;
-    assert!(result.is_err(), "Expected error for non-existent skill");
-    let err = result.unwrap_err();
-    eprintln!("  Expected error: {err}");
-    assert!(
-        err.contains("not found") || err.contains("not registered") || err.contains("No skill"),
-        "Error message should mention not found: {err}"
-    );
-}
-
-/// Test that discovering skills from an empty directory returns an empty list.
-#[tokio::test]
-async fn discover_empty_dir() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Warn)
-        .is_test(true)
-        .try_init();
-
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("data");
-    let skills_dir = tmp.path().join("skills");
-    std::fs::create_dir_all(&data_dir).unwrap();
-    std::fs::create_dir_all(&skills_dir).unwrap();
-
-    let engine = RuntimeEngine::new(data_dir).expect("engine");
-    let engine = Arc::new(engine);
-    engine.set_skills_source_dir(skills_dir);
-
-    let manifests = engine.discover_skills().await.expect("discover");
-    assert!(
-        manifests.is_empty(),
-        "Expected empty list from empty skills dir, got {} manifests",
-        manifests.len()
-    );
-}
-
-/// Stress test: start and stop the same skill rapidly.
-#[tokio::test]
-async fn skill_rapid_start_stop() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Warn)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let skill_id = select_skill_id(
-        &skills_dir,
-        "SKILL_DEBUG_ID",
-        &["server-ping", "gmail", "notion"],
-    );
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    std::fs::create_dir_all(&data_dir).unwrap();
-
-    let engine = create_engine(&skills_dir, &data_dir).await;
-
-    for i in 0..3 {
-        eprintln!("  Round {}/3: start", i + 1);
-        let start = engine.start_skill(&skill_id).await;
-        match &start {
-            Ok(snap) => {
-                eprintln!("    Started: {:?}, {} tools", snap.status, snap.tools.len());
-            }
-            Err(e) => {
-                eprintln!("    Start failed: {e}");
-                // Don't panic — this tests resilience
-            }
-        }
-
-        // Small delay to let the event loop spin
-        tokio::time::sleep(Duration::from_millis(200)).await;
-
-        eprintln!("  Round {}/3: stop", i + 1);
-        let _ = engine.stop_skill(&skill_id).await;
-        tokio::time::sleep(Duration::from_millis(100)).await;
-    }
-
-    eprintln!("  Rapid start/stop completed without panic");
-}
-
-/// Test disconnect flow: stop → oauth/revoked → verify credential cleaned up.
-/// Mirrors what the frontend *should* do when a user clicks "Disconnect".
-#[tokio::test]
-async fn skill_disconnect_flow() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Info)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let skill_id = select_skill_id(&skills_dir, "SKILL_DEBUG_ID", &["gmail", "notion"]);
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    std::fs::create_dir_all(&data_dir).unwrap();
-
-    let engine = create_engine(&skills_dir, &data_dir).await;
-
-    // ── Start skill ──
-    eprintln!("\n--- DISCONNECT TEST ---");
-    eprintln!("  Starting skill '{skill_id}'...");
-    let snap = engine.start_skill(&skill_id).await.expect("start");
-    assert_eq!(
-        snap.status,
-        openhuman_core::openhuman::skills::types::SkillStatus::Running
-    );
-    eprintln!("  ✓ Running, {} tools", snap.tools.len());
-
-    // ── Write a fake OAuth credential ──
-    let skill_data_dir = data_dir.join(&skill_id);
-    std::fs::create_dir_all(&skill_data_dir).unwrap();
-    let cred_path = skill_data_dir.join("oauth_credential.json");
-    std::fs::write(
-        &cred_path,
-        r#"{"credentialId":"test-cred-123","provider":"test","grantedScopes":[]}"#,
-    )
-    .unwrap();
-    assert!(
-        cred_path.exists(),
-        "Credential file should exist before disconnect"
-    );
-    eprintln!("  ✓ Wrote fake oauth_credential.json");
-
-    // ── Simulate frontend disconnect: stop + set_setup_complete(false) ──
-    eprintln!("  Simulating frontend disconnectSkill()...");
-
-    // Step 1: Stop (what frontend does)
-    engine.stop_skill(&skill_id).await.expect("stop");
-    eprintln!("  ✓ Skill stopped");
-
-    // Step 2: Reset setup_complete (what frontend does)
-    engine.preferences().set_setup_complete(&skill_id, false);
-    assert!(!engine.preferences().is_setup_complete(&skill_id));
-    eprintln!("  ✓ setup_complete = false");
-
-    // ── Verify credential file still exists (BUG: disconnect doesn't clean it) ──
-    let cred_still_exists = cred_path.exists();
-    if cred_still_exists {
-        eprintln!("  ⚠ oauth_credential.json still exists after disconnect (expected gap)");
-        eprintln!("    → Frontend disconnect does NOT call oauth/revoked");
-        eprintln!("    → On restart, the old credential will be restored");
-    } else {
-        eprintln!("  ✓ oauth_credential.json cleaned up");
-    }
-
-    // ── Now test the proper flow: start + send oauth/revoked ──
-    eprintln!("\n  Testing proper disconnect (with oauth/revoked)...");
-    // Re-write credential for the proper test
-    std::fs::write(
-        &cred_path,
-        r#"{"credentialId":"test-cred-456","provider":"test","grantedScopes":[]}"#,
-    )
-    .unwrap();
-
-    let snap2 = engine.start_skill(&skill_id).await.expect("restart");
-    assert_eq!(
-        snap2.status,
-        openhuman_core::openhuman::skills::types::SkillStatus::Running
-    );
-    eprintln!("  ✓ Restarted skill");
-
-    // Send oauth/revoked RPC (what disconnect SHOULD do)
-    let revoke_result = engine
-        .rpc(
-            &skill_id,
-            "oauth/revoked",
-            json!({"integrationId": "test-cred-456"}),
-        )
-        .await;
-    match &revoke_result {
-        Ok(val) => eprintln!("  ✓ oauth/revoked returned: {val}"),
-        Err(e) => eprintln!("  · oauth/revoked: {e} (may be expected for non-OAuth skills)"),
-    }
-
-    // Now stop
-    engine.stop_skill(&skill_id).await.expect("stop");
-    engine.preferences().set_setup_complete(&skill_id, false);
-    eprintln!("  ✓ Stopped + setup_complete = false");
-
-    // Verify credential file is gone after oauth/revoked
-    assert!(
-        !cred_path.exists(),
-        "oauth_credential.json should be deleted after oauth/revoked but still exists at {}",
-        cred_path.display()
-    );
-    eprintln!("  ✓ oauth_credential.json deleted after oauth/revoked");
-
-    // ── Verify restart after disconnect shows clean state ──
-    eprintln!("\n  Verifying clean restart after proper disconnect...");
-    let snap3 = engine
-        .start_skill(&skill_id)
-        .await
-        .expect("restart after disconnect");
-    eprintln!(
-        "  ✓ Restarted: {:?}, {} tools",
-        snap3.status,
-        snap3.tools.len()
-    );
-    eprintln!(
-        "  setup_complete: {}",
-        engine.preferences().is_setup_complete(&skill_id)
-    );
-
-    engine.stop_skill(&skill_id).await.expect("final stop");
-    eprintln!("\n  ✓ Disconnect flow test complete");
-}
diff --git a/tests/skills_gmail_e2e.rs b/tests/skills_gmail_e2e.rs
deleted file mode 100644
index 5cf32aa17..000000000
--- a/tests/skills_gmail_e2e.rs
+++ /dev/null
@@ -1,941 +0,0 @@
-//! Gmail skill end-to-end test.
-//!
-//! Exercises the full Gmail skill lifecycle through the RuntimeEngine:
-//!   discover → start → OAuth complete → profile → list emails →
-//!   search → get email → labels → mark email → sync → oauth/revoked → stop
-//!
-//! Two modes:
-//!
-//! 1. **Lifecycle-only** (no env vars required):
-//!    Verifies that the skill starts, registers tools, responds to setup
-//!    and ping, then stops cleanly. OAuth-dependent tools are exercised
-//!    structurally (called, errors tolerated) so the event loop is
-//!    validated without real credentials.
-//!
-//! 2. **Live** (`RUN_LIVE_GMAIL=1` + credentials):
-//!    Uses a real `oauth_credential.json` in SKILLS_DATA_DIR and an
-//!    OAuth proxy routed through the backend. All Gmail API tools are
-//!    called against real data.
-//!
-//! Required env vars for live mode:
-//!   RUN_LIVE_GMAIL=1
-//!   BACKEND_URL       — e.g. https://staging-api.alphahuman.xyz
-//!   JWT_TOKEN         — bearer token for the OAuth proxy
-//!   CREDENTIAL_ID     — ID stored in oauth_credential.json
-//!   SKILLS_DATA_DIR   — path to the skills_data root (contains gmail/ subdir)
-//!
-//! Optional:
-//!   SKILL_DEBUG_DIR   — override skills source directory
-//!   SKILLS_LOCAL_DIR  — shared env var used by the runtime
-//!   GMAIL_TEST_EMAIL_ID  — a real message ID to fetch with get-email
-//!   SKILL_DEBUG_VERBOSE  — set to "1" for extra output
-//!
-//! Run lifecycle-only:
-//!   cargo test --test skills_gmail_e2e -- --nocapture
-//!
-//! Run live:
-//!   BACKEND_URL=https://staging-api.alphahuman.xyz \
-//!   JWT_TOKEN=<jwt> \
-//!   CREDENTIAL_ID=<id> \
-//!   SKILLS_DATA_DIR=~/.openhuman/skills_data \
-//!   RUN_LIVE_GMAIL=1 \
-//!   cargo test --test skills_gmail_e2e -- --nocapture
-
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::time::Duration;
-
-use serde_json::{json, Value};
-use tempfile::tempdir;
-
-use openhuman_core::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
-use openhuman_core::openhuman::skills::types::SkillStatus;
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-fn is_verbose() -> bool {
-    std::env::var("SKILL_DEBUG_VERBOSE")
-        .map(|v| v == "1" || v == "true")
-        .unwrap_or(false)
-}
-
-fn is_live() -> bool {
-    std::env::var("RUN_LIVE_GMAIL")
-        .map(|v| v == "1" || v == "true")
-        .unwrap_or(false)
-}
-
-fn banner(label: &str) {
-    let sep = "=".repeat(60);
-    eprintln!("\n{sep}");
-    eprintln!("  {label}");
-    eprintln!("{sep}");
-}
-
-fn step(label: &str) {
-    eprintln!("\n--- {label} ---");
-}
-
-fn ok(msg: &str) {
-    eprintln!("  ✓ {msg}");
-}
-
-fn warn(msg: &str) {
-    eprintln!("  ⚠ {msg}");
-}
-
-fn fail(msg: &str) {
-    eprintln!("  ✗ {msg}");
-}
-
-fn info(msg: &str) {
-    eprintln!("  · {msg}");
-}
-
-fn truncate(s: &str, max: usize) -> &str {
-    if s.len() <= max {
-        return s;
-    }
-    let mut end = max;
-    while end > 0 && !s.is_char_boundary(end) {
-        end -= 1;
-    }
-    &s[..end]
-}
-
-/// Find the skills source directory.
-///
-/// Priority:
-/// 1. SKILL_DEBUG_DIR env var
-/// 2. SKILLS_LOCAL_DIR env var
-/// 3. ../openhuman-skills/skills (sibling repo)
-/// 4. openhuman-skills/skills (subdir)
-/// 5. Broader parent-workspace search
-fn try_find_skills_dir() -> Option<PathBuf> {
-    if let Ok(dir) = std::env::var("SKILL_DEBUG_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-        eprintln!("SKILL_DEBUG_DIR={dir} does not exist");
-        return None;
-    }
-
-    if let Ok(dir) = std::env::var("SKILLS_LOCAL_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-        eprintln!("SKILLS_LOCAL_DIR={dir} does not exist");
-    }
-
-    let cwd = std::env::current_dir().expect("cwd");
-
-    for candidate in &[
-        cwd.join("../openhuman-skills/skills"),
-        cwd.join("openhuman-skills/skills"),
-        cwd.join("../alphahuman/skills/skills"),
-    ] {
-        if candidate.exists() {
-            return Some(candidate.canonicalize().unwrap());
-        }
-    }
-
-    if let Some(parent) = cwd.parent() {
-        for entry in std::fs::read_dir(parent).into_iter().flatten().flatten() {
-            let c = entry.path().join("skills/skills");
-            if c.exists() && c.join("gmail/manifest.json").exists() {
-                return Some(c.canonicalize().unwrap());
-            }
-        }
-    }
-
-    None
-}
-
-macro_rules! require_skills_dir {
-    () => {
-        match try_find_skills_dir() {
-            Some(dir) => dir,
-            None => {
-                eprintln!("SKIPPED: no skills directory available (set SKILL_DEBUG_DIR)");
-                return;
-            }
-        }
-    };
-}
-
-/// Print a tool call result without logging raw credential content.
-fn print_tool_result(
-    result: &openhuman_core::openhuman::skills::types::ToolResult,
-    max_bytes: usize,
-) {
-    use openhuman_core::openhuman::skills::types::ToolContent;
-    eprintln!("    is_error: {}", result.is_error);
-    for content in &result.content {
-        match content {
-            ToolContent::Text { text } => {
-                eprintln!("    text: {}", truncate(text, max_bytes));
-            }
-            ToolContent::Json { data } => {
-                let s = data.to_string();
-                eprintln!("    json: {}", truncate(&s, max_bytes));
-            }
-        }
-    }
-}
-
-/// Call a tool with a timeout; log the result; return whether it succeeded.
-async fn call_tool_logged(
-    engine: &RuntimeEngine,
-    skill_id: &str,
-    tool: &str,
-    args: Value,
-    timeout_secs: u64,
-) -> bool {
-    let result = tokio::time::timeout(
-        Duration::from_secs(timeout_secs),
-        engine.call_tool(skill_id, tool, args),
-    )
-    .await;
-
-    match result {
-        Ok(Ok(r)) => {
-            let success = !r.is_error;
-            if success {
-                ok(&format!("{tool} succeeded"));
-            } else {
-                warn(&format!("{tool} returned is_error=true"));
-            }
-            if is_verbose() {
-                print_tool_result(&r, 800);
-            } else {
-                print_tool_result(&r, 300);
-            }
-            success
-        }
-        Ok(Err(e)) => {
-            fail(&format!("{tool} error: {e}"));
-            false
-        }
-        Err(_) => {
-            fail(&format!("{tool} TIMED OUT ({timeout_secs}s)"));
-            false
-        }
-    }
-}
-
-/// Create a RuntimeEngine backed by the given data directory.
-async fn create_engine(skills_dir: &Path, data_dir: &Path) -> Arc<RuntimeEngine> {
-    let engine =
-        RuntimeEngine::new(data_dir.to_path_buf()).expect("RuntimeEngine::new should succeed");
-    let engine = Arc::new(engine);
-    engine.set_skills_source_dir(skills_dir.to_path_buf());
-    set_global_engine(engine.clone());
-    engine
-}
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-/// Lifecycle-only test: start → tools → setup → ping → oauth stubs → stop.
-///
-/// Does not require credentials. OAuth-dependent tool calls are expected to
-/// fail or return errors — the test validates the event-loop plumbing and
-/// tool registration, not real Gmail API behavior.
-#[tokio::test]
-async fn gmail_lifecycle_no_credentials() {
-    let _ = env_logger::builder()
-        .filter_level(if is_verbose() {
-            log::LevelFilter::Debug
-        } else {
-            log::LevelFilter::Info
-        })
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    std::fs::create_dir_all(&data_dir).expect("create data_dir");
-
-    banner("Gmail Skill — Lifecycle (no credentials)");
-    info(&format!("Skills dir: {}", skills_dir.display()));
-    info(&format!("Data dir:   {}", data_dir.display()));
-
-    let engine = create_engine(&skills_dir, &data_dir).await;
-
-    // ── 1. Start ──
-    step("START SKILL 'gmail'");
-    let snap = engine
-        .start_skill("gmail")
-        .await
-        .expect("start gmail skill");
-    assert_eq!(
-        snap.status,
-        SkillStatus::Running,
-        "expected Running after start"
-    );
-    ok(&format!("Status: {:?}", snap.status));
-    info(&format!("Tools registered: {}", snap.tools.len()));
-    for tool in &snap.tools {
-        info(&format!("  - {}: {}", tool.name, tool.description));
-    }
-
-    let expected_tools = [
-        "get-email",
-        "get-emails",
-        "get-labels",
-        "get-profile",
-        "mark-email",
-        "search-emails",
-        "send-email",
-    ];
-    for name in &expected_tools {
-        let found = snap.tools.iter().any(|t| t.name == *name);
-        if found {
-            ok(&format!("tool '{name}' registered"));
-        } else {
-            warn(&format!(
-                "tool '{name}' not found — may be expected if skill filters tools before OAuth"
-            ));
-        }
-    }
-
-    // ── 2. tools/list via RPC ──
-    step("TOOLS/LIST (via RPC)");
-    match engine.rpc("gmail", "tools/list", json!({})).await {
-        Ok(val) => {
-            let tools = val.get("tools").and_then(|t| t.as_array());
-            if let Some(tools) = tools {
-                ok(&format!("{} tool(s) via tools/list RPC", tools.len()));
-            } else {
-                ok(&format!("tools/list returned: {val}"));
-            }
-        }
-        Err(e) => fail(&format!("tools/list RPC failed: {e}")),
-    }
-
-    // ── 3. setup/start ──
-    step("SETUP/START");
-    let setup = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc("gmail", "setup/start", json!({})),
-    )
-    .await;
-    match setup {
-        Ok(Ok(val)) => ok(&format!("setup/start returned: {val}")),
-        Ok(Err(e)) => info(&format!("setup/start error: {e} (expected — OAuth skill)")),
-        Err(_) => fail("setup/start TIMED OUT (10s)"),
-    }
-
-    // ── 4. Ping ──
-    step("PING");
-    let ping = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc("gmail", "skill/ping", json!({})),
-    )
-    .await;
-    match ping {
-        Ok(Ok(val)) => ok(&format!("ping returned: {val}")),
-        Ok(Err(e)) => info(&format!("ping: {e} (may be expected without credentials)")),
-        Err(_) => fail("ping TIMED OUT (10s)"),
-    }
-
-    // ── 5. Simulate oauth/complete with a fake credential ──
-    step("SIMULATE OAUTH/COMPLETE (fake credential)");
-    let fake_cred = json!({
-        "credentialId": "fake-cred-lifecycle-test",
-        "provider": "gmail",
-        "grantedScopes": [
-            "https://www.googleapis.com/auth/gmail.readonly",
-            "https://www.googleapis.com/auth/gmail.send"
-        ]
-    });
-    let oauth_complete = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc("gmail", "oauth/complete", fake_cred.clone()),
-    )
-    .await;
-    match oauth_complete {
-        Ok(Ok(val)) => ok(&format!("oauth/complete acknowledged: {val}")),
-        Ok(Err(e)) => info(&format!("oauth/complete: {e}")),
-        Err(_) => fail("oauth/complete TIMED OUT (10s)"),
-    }
-
-    // Credential file should now exist on disk
-    let cred_path = data_dir.join("gmail").join("oauth_credential.json");
-    if cred_path.exists() {
-        ok("oauth_credential.json persisted to disk");
-    } else {
-        warn("oauth_credential.json was NOT written to disk");
-    }
-
-    // Verify snapshot reflects credential in published state
-    tokio::time::sleep(Duration::from_millis(200)).await;
-    if let Some(snap) = engine.get_skill_state("gmail") {
-        let has_cred = snap.state.get("__oauth_credential").is_some();
-        if has_cred {
-            ok("__oauth_credential present in published state");
-        } else {
-            warn("__oauth_credential not yet in published state (event loop may not have synced)");
-        }
-    }
-
-    // ── 6. Unauthenticated tool calls — expect errors, not panics ──
-    step("TOOL CALLS (expect auth errors without real credentials)");
-
-    info("get-profile");
-    call_tool_logged(&engine, "gmail", "get-profile", json!({}), 20).await;
-
-    info("get-emails");
-    call_tool_logged(
-        &engine,
-        "gmail",
-        "get-emails",
-        json!({ "maxResults": 3 }),
-        20,
-    )
-    .await;
-
-    info("search-emails");
-    call_tool_logged(
-        &engine,
-        "gmail",
-        "search-emails",
-        json!({ "query": "is:unread", "maxResults": 3 }),
-        20,
-    )
-    .await;
-
-    info("get-labels");
-    call_tool_logged(&engine, "gmail", "get-labels", json!({}), 20).await;
-
-    // ── 7. skill/sync ──
-    step("SYNC");
-    let sync = tokio::time::timeout(
-        Duration::from_secs(20),
-        engine.rpc("gmail", "skill/sync", json!({})),
-    )
-    .await;
-    match sync {
-        Ok(Ok(val)) => ok(&format!("skill/sync: {val}")),
-        Ok(Err(e)) => info(&format!("skill/sync: {e} (expected without credentials)")),
-        Err(_) => fail("skill/sync TIMED OUT (20s)"),
-    }
-
-    // ── 8. oauth/revoked ──
-    step("OAUTH/REVOKED");
-    let revoked = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc(
-            "gmail",
-            "oauth/revoked",
-            json!({ "integrationId": "fake-cred-lifecycle-test" }),
-        ),
-    )
-    .await;
-    match revoked {
-        Ok(Ok(val)) => ok(&format!("oauth/revoked: {val}")),
-        Ok(Err(e)) => info(&format!("oauth/revoked: {e}")),
-        Err(_) => fail("oauth/revoked TIMED OUT (10s)"),
-    }
-
-    // Credential file should be gone
-    if !cred_path.exists() {
-        ok("oauth_credential.json deleted after oauth/revoked");
-    } else {
-        warn("oauth_credential.json still exists after oauth/revoked");
-    }
-
-    // ── 9. Stop ──
-    step("STOP");
-    let stop = tokio::time::timeout(Duration::from_secs(10), engine.stop_skill("gmail")).await;
-    match stop {
-        Ok(Ok(())) => ok("Skill stopped cleanly"),
-        Ok(Err(e)) => fail(&format!("Stop error: {e}")),
-        Err(_) => fail("Stop TIMED OUT (10s)"),
-    }
-
-    // Verify registry state post-stop
-    let post_stop = engine.get_skill_state("gmail");
-    match post_stop {
-        Some(snap) => info(&format!("Post-stop status: {:?}", snap.status)),
-        None => ok("Skill unregistered from registry after stop"),
-    }
-
-    banner("LIFECYCLE TEST COMPLETE");
-}
-
-/// Live integration test: exercises all Gmail tools against the real API.
-///
-/// Requires RUN_LIVE_GMAIL=1 and all env vars listed at the top of the file.
-#[tokio::test]
-async fn gmail_live_with_real_credentials() {
-    if !is_live() {
-        eprintln!("SKIPPED: set RUN_LIVE_GMAIL=1 to run this live integration test");
-        return;
-    }
-
-    let _ = env_logger::builder()
-        .filter_level(if is_verbose() {
-            log::LevelFilter::Debug
-        } else {
-            log::LevelFilter::Info
-        })
-        .is_test(true)
-        .try_init();
-
-    let backend_url =
-        std::env::var("BACKEND_URL").expect("BACKEND_URL must be set for live Gmail test");
-    let jwt_token = std::env::var("JWT_TOKEN").expect("JWT_TOKEN must be set for live Gmail test");
-    let credential_id =
-        std::env::var("CREDENTIAL_ID").expect("CREDENTIAL_ID must be set for live Gmail test");
-    let skills_data_dir = PathBuf::from(
-        std::env::var("SKILLS_DATA_DIR").expect("SKILLS_DATA_DIR must be set for live Gmail test"),
-    );
-    let skills_dir = require_skills_dir!();
-
-    // Optional: specific message ID to fetch
-    let test_email_id = std::env::var("GMAIL_TEST_EMAIL_ID").ok();
-
-    banner("Gmail Skill — Live Integration Test");
-    info(&format!("Backend:       {backend_url}"));
-    info(&format!(
-        "JWT:           <redacted, {} bytes>",
-        jwt_token.len()
-    ));
-    info(&format!("Credential ID: {credential_id}"));
-    info(&format!("Skills dir:    {}", skills_dir.display()));
-    info(&format!("Data dir:      {}", skills_data_dir.display()));
-    if let Some(ref id) = test_email_id {
-        info(&format!("Test email ID: {id}"));
-    }
-
-    // Verify oauth_credential.json exists (don't log contents)
-    let cred_path = skills_data_dir.join("gmail").join("oauth_credential.json");
-    if cred_path.exists() {
-        let size = std::fs::metadata(&cred_path).map(|m| m.len()).unwrap_or(0);
-        ok(&format!("oauth_credential.json present ({size} bytes)"));
-    } else {
-        warn(&format!(
-            "oauth_credential.json NOT found at {} — tools will fail without OAuth",
-            cred_path.display()
-        ));
-    }
-
-    // ── Step 1: Backend health ──
-    step("Step 1: Backend Health");
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(10))
-        .build()
-        .unwrap();
-
-    match client
-        .get(format!("{backend_url}/settings"))
-        .header("Authorization", format!("Bearer {jwt_token}"))
-        .send()
-        .await
-    {
-        Ok(resp) => {
-            let status = resp.status();
-            let body = resp.text().await.unwrap_or_default();
-            if status.is_success() {
-                ok(&format!("Backend reachable (HTTP {status})"));
-                if is_verbose() {
-                    info(&format!("  Body: {}...", truncate(&body, 300)));
-                }
-            } else {
-                warn(&format!(
-                    "Backend returned HTTP {status} — OAuth proxy may be unavailable"
-                ));
-                info(&format!("  Body: {}...", truncate(&body, 200)));
-            }
-        }
-        Err(e) => warn(&format!("Backend unreachable: {e} — continuing anyway")),
-    }
-
-    // ── Step 2: OAuth proxy smoke test ──
-    step("Step 2: OAuth Proxy Check (Gmail API via proxy)");
-    let proxy_url = format!("{backend_url}/proxy/by-id/{credential_id}/gmail/v1/users/me/profile");
-    info(&format!("GET {proxy_url}"));
-
-    match client
-        .get(&proxy_url)
-        .header("Authorization", format!("Bearer {jwt_token}"))
-        .header("Content-Type", "application/json")
-        .send()
-        .await
-    {
-        Ok(resp) => {
-            let status = resp.status();
-            let body = resp.text().await.unwrap_or_default();
-            if status.is_success() {
-                ok(&format!("Gmail API accessible via proxy (HTTP {status})"));
-                if is_verbose() {
-                    info(&format!("  Profile: {}...", truncate(&body, 300)));
-                }
-            } else {
-                warn(&format!(
-                    "Proxy returned HTTP {status}: {}...",
-                    truncate(&body, 200)
-                ));
-            }
-        }
-        Err(e) => warn(&format!("Proxy request failed: {e}")),
-    }
-
-    // ── Step 3: Start skill ──
-    step("Step 3: Start Gmail Skill (real data dir)");
-    let engine = RuntimeEngine::new(skills_data_dir.clone()).expect("engine");
-    let engine = Arc::new(engine);
-    engine.set_skills_source_dir(skills_dir.clone());
-    set_global_engine(engine.clone());
-
-    let snap = engine
-        .start_skill("gmail")
-        .await
-        .expect("start gmail skill");
-    assert_eq!(
-        snap.status,
-        SkillStatus::Running,
-        "expected Running after start"
-    );
-    ok(&format!("Status: {:?}", snap.status));
-    info(&format!("Tools: {}", snap.tools.len()));
-
-    // Print state keys relevant to connection status
-    for (k, v) in &snap.state {
-        if k.contains("status")
-            || k.contains("error")
-            || k.contains("auth")
-            || k.contains("email")
-            || k == "syncEnabled"
-            || k == "is_initialized"
-        {
-            info(&format!("  {k} = {}", truncate(&v.to_string(), 120)));
-        }
-    }
-
-    // Confirm OAuth credential restored into JS state
-    tokio::time::sleep(Duration::from_millis(300)).await;
-    if let Some(snap) = engine.get_skill_state("gmail") {
-        let has_cred = snap.state.get("__oauth_credential").is_some();
-        if has_cred {
-            ok("OAuth credential restored into published state");
-        } else {
-            warn(
-                "__oauth_credential not in published state — OAuth may not have been restored yet",
-            );
-        }
-    }
-
-    // ── Step 4: get-profile ──
-    step("Step 4: get-profile");
-    call_tool_logged(&engine, "gmail", "get-profile", json!({}), 30).await;
-
-    // ── Step 5: get-emails (inbox, recent) ──
-    step("Step 5: get-emails (inbox, last 5)");
-    let emails_result = tokio::time::timeout(
-        Duration::from_secs(30),
-        engine.call_tool(
-            "gmail",
-            "get-emails",
-            json!({ "maxResults": 5, "labelIds": ["INBOX"] }),
-        ),
-    )
-    .await;
-
-    // Capture a message ID for later steps
-    let mut sample_message_id: Option<String> = test_email_id.clone();
-    match &emails_result {
-        Ok(Ok(r)) => {
-            ok(&format!("get-emails succeeded (is_error={})", r.is_error));
-            if is_verbose() {
-                print_tool_result(r, 600);
-            } else {
-                print_tool_result(r, 300);
-            }
-            // Try to extract a message ID from the result for subsequent steps
-            if sample_message_id.is_none() {
-                for content in &r.content {
-                    use openhuman_core::openhuman::skills::types::ToolContent;
-                    let text = match content {
-                        ToolContent::Text { text } => text.clone(),
-                        ToolContent::Json { data } => data.to_string(),
-                    };
-                    if let Ok(parsed) = serde_json::from_str::<Value>(&text) {
-                        // Look for a message ID in the response
-                        let id = parsed
-                            .get("messages")
-                            .and_then(|m| m.as_array())
-                            .and_then(|arr| arr.first())
-                            .and_then(|msg| msg.get("id"))
-                            .and_then(|id| id.as_str())
-                            .map(String::from);
-                        if let Some(id) = id {
-                            info(&format!("Captured sample message ID: {id}"));
-                            sample_message_id = Some(id);
-                        }
-                    }
-                }
-            }
-        }
-        Ok(Err(e)) => fail(&format!("get-emails error: {e}")),
-        Err(_) => fail("get-emails TIMED OUT (30s)"),
-    }
-
-    // ── Step 6: search-emails ──
-    step("Step 6: search-emails (is:unread)");
-    call_tool_logged(
-        &engine,
-        "gmail",
-        "search-emails",
-        json!({ "query": "is:unread", "maxResults": 5 }),
-        30,
-    )
-    .await;
-
-    // ── Step 7: get-email (single message) ──
-    step("Step 7: get-email (single message)");
-    if let Some(ref msg_id) = sample_message_id {
-        info(&format!("Using message ID: {msg_id}"));
-        call_tool_logged(&engine, "gmail", "get-email", json!({ "id": msg_id }), 30).await;
-    } else {
-        warn("No message ID available — skipping get-email (set GMAIL_TEST_EMAIL_ID or run get-emails first)");
-    }
-
-    // ── Step 8: get-labels ──
-    step("Step 8: get-labels");
-    call_tool_logged(&engine, "gmail", "get-labels", json!({}), 20).await;
-
-    // ── Step 9: mark-email (read, non-destructive) ──
-    step("Step 9: mark-email (mark as read)");
-    if let Some(ref msg_id) = sample_message_id {
-        info(&format!("Marking message {msg_id} as read"));
-        call_tool_logged(
-            &engine,
-            "gmail",
-            "mark-email",
-            json!({
-                "id": msg_id,
-                "action": "markAsRead"
-            }),
-            20,
-        )
-        .await;
-    } else {
-        warn("No message ID available — skipping mark-email");
-    }
-
-    // ── Step 10: send-email (dry-run check — only in verbose/explicit mode) ──
-    // We deliberately skip actually sending unless an explicit recipient is provided,
-    // to avoid unexpected side effects in shared test environments.
-    step("Step 10: send-email (skipped — would cause real side effects)");
-    info("send-email requires an explicit recipient. Not called in automated tests.");
-    info("To test manually: set GMAIL_SEND_TO=<addr> and invoke send-email with engine.call_tool");
-
-    // ── Step 11: skill/sync ──
-    step("Step 11: Sync (skill/sync → onSync)");
-    info("Calling skill/sync to trigger onSync() and memory persistence...");
-    let sync = tokio::time::timeout(
-        Duration::from_secs(60),
-        engine.rpc("gmail", "skill/sync", json!({})),
-    )
-    .await;
-    match sync {
-        Ok(Ok(val)) => ok(&format!("skill/sync: {val}")),
-        Ok(Err(e)) => info(&format!(
-            "skill/sync: {e} (expected if no onSync handler or no data)"
-        )),
-        Err(_) => fail("skill/sync TIMED OUT (60s)"),
-    }
-
-    // Wait for background memory persistence
-    info("Waiting 3s for async memory persistence...");
-    tokio::time::sleep(Duration::from_secs(3)).await;
-
-    // ── Step 12: memory verification ──
-    step("Step 12: Memory Verification");
-    match openhuman_core::openhuman::memory::MemoryClient::new_local() {
-        Ok(memory_client) => {
-            let namespace = "skill-gmail";
-            match memory_client.list_documents(Some(namespace)).await {
-                Ok(docs) => {
-                    let doc_array = docs
-                        .get("documents")
-                        .and_then(|d| d.as_array())
-                        .cloned()
-                        .unwrap_or_default();
-                    info(&format!("Documents in '{namespace}': {}", doc_array.len()));
-                    for doc in &doc_array {
-                        let title = doc
-                            .get("title")
-                            .and_then(|t| t.as_str())
-                            .unwrap_or("(no title)");
-                        let len = doc
-                            .get("content")
-                            .and_then(|c| c.as_str())
-                            .map(|c| c.len())
-                            .unwrap_or(0);
-                        info(&format!("  - {title} ({len} bytes)"));
-                    }
-                    if !doc_array.is_empty() {
-                        ok("Memory documents created after sync");
-                    } else {
-                        warn("No memory documents found after sync");
-                    }
-                }
-                Err(e) => warn(&format!("list_documents failed: {e}")),
-            }
-        }
-        Err(e) => warn(&format!("Could not create MemoryClient: {e}")),
-    }
-
-    // ── Step 13: Ping (health check after API calls) ──
-    step("Step 13: Ping (post-sync health check)");
-    let ping = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc("gmail", "skill/ping", json!({})),
-    )
-    .await;
-    match ping {
-        Ok(Ok(val)) => ok(&format!("ping: {val}")),
-        Ok(Err(e)) => info(&format!("ping: {e}")),
-        Err(_) => fail("ping TIMED OUT (10s)"),
-    }
-
-    // ── Step 14: Final skill state ──
-    step("Step 14: Final Skill State");
-    if let Some(snap) = engine.get_skill_state("gmail") {
-        ok(&format!("Status: {:?}", snap.status));
-        info(&format!("Tools:  {}", snap.tools.len()));
-        info(&format!(
-            "Published state keys: {}",
-            snap.state.keys().cloned().collect::<Vec<_>>().join(", ")
-        ));
-        for (k, v) in &snap.state {
-            if k.contains("status")
-                || k.contains("error")
-                || k.contains("email")
-                || k.contains("sync")
-                || k == "syncEnabled"
-            {
-                info(&format!("  {k} = {}", truncate(&v.to_string(), 120)));
-            }
-        }
-    } else {
-        warn("Skill not found in registry");
-    }
-
-    // ── Step 15: Stop ──
-    step("Step 15: Stop");
-    match tokio::time::timeout(Duration::from_secs(10), engine.stop_skill("gmail")).await {
-        Ok(Ok(())) => ok("Skill stopped cleanly"),
-        Ok(Err(e)) => fail(&format!("Stop error: {e}")),
-        Err(_) => fail("Stop TIMED OUT (10s)"),
-    }
-
-    banner("LIVE INTEGRATION TEST COMPLETE");
-}
-
-/// Disconnect flow test: verifies credential cleanup after oauth/revoked.
-///
-/// Uses a fake credential written directly to disk (no real OAuth needed).
-/// Mirrors what the frontend's disconnectSkill() should do.
-#[tokio::test]
-async fn gmail_disconnect_flow() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Info)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    std::fs::create_dir_all(&data_dir).expect("create data_dir");
-
-    banner("Gmail Skill — Disconnect Flow");
-
-    let engine = create_engine(&skills_dir, &data_dir).await;
-
-    // Start skill
-    let snap = engine.start_skill("gmail").await.expect("start");
-    assert_eq!(snap.status, SkillStatus::Running);
-    ok(&format!("Started — {} tools", snap.tools.len()));
-
-    // Write a fake OAuth credential directly to disk
-    let cred_dir = data_dir.join("gmail");
-    std::fs::create_dir_all(&cred_dir).unwrap();
-    let cred_path = cred_dir.join("oauth_credential.json");
-    let fake_cred_json = r#"{"credentialId":"gmail-cred-disconnect-test","provider":"gmail","grantedScopes":["https://www.googleapis.com/auth/gmail.readonly"]}"#;
-    std::fs::write(&cred_path, fake_cred_json).unwrap();
-    assert!(
-        cred_path.exists(),
-        "credential should exist before disconnect"
-    );
-    ok("Wrote fake oauth_credential.json");
-
-    // ── Send oauth/revoked (the proper disconnect path) ──
-    step("Send oauth/revoked");
-    let revoked = tokio::time::timeout(
-        Duration::from_secs(10),
-        engine.rpc(
-            "gmail",
-            "oauth/revoked",
-            json!({ "integrationId": "gmail-cred-disconnect-test" }),
-        ),
-    )
-    .await;
-    match &revoked {
-        Ok(Ok(val)) => ok(&format!("oauth/revoked: {val}")),
-        Ok(Err(e)) => info(&format!(
-            "oauth/revoked: {e} (may be expected if skill has no onOAuthRevoked handler)"
-        )),
-        Err(_) => fail("oauth/revoked TIMED OUT"),
-    }
-
-    // Credential file must be deleted regardless of whether onOAuthRevoked succeeds
-    assert!(
-        !cred_path.exists(),
-        "oauth_credential.json should be deleted after oauth/revoked but still exists at {}",
-        cred_path.display()
-    );
-    ok("oauth_credential.json deleted by oauth/revoked");
-
-    // Stop and reset
-    engine.stop_skill("gmail").await.expect("stop");
-    engine.preferences().set_setup_complete("gmail", false);
-    assert!(!engine.preferences().is_setup_complete("gmail"));
-    ok("Stopped + setup_complete=false");
-
-    // ── Verify clean restart: no credential, no stale state ──
-    step("Clean Restart (no credential)");
-    let snap2 = engine.start_skill("gmail").await.expect("restart");
-    assert_eq!(snap2.status, SkillStatus::Running);
-    ok(&format!("Restarted — {:?}", snap2.status));
-
-    // After restart without credential: __oauth_credential should be absent or empty
-    tokio::time::sleep(Duration::from_millis(300)).await;
-    if let Some(snap) = engine.get_skill_state("gmail") {
-        let cred_val = snap.state.get("__oauth_credential");
-        match cred_val {
-            None => ok("__oauth_credential absent from state (clean)"),
-            Some(v) if v.as_str() == Some("") || v == &json!("") || v == &json!(null) => {
-                ok("__oauth_credential is empty/null in state (clean)")
-            }
-            Some(v) => {
-                warn(&format!(
-                    "__oauth_credential still present after clean restart: {v}"
-                ));
-            }
-        }
-    }
-    info(&format!(
-        "setup_complete: {}",
-        engine.preferences().is_setup_complete("gmail")
-    ));
-
-    engine.stop_skill("gmail").await.expect("final stop");
-
-    banner("DISCONNECT FLOW COMPLETE");
-}
diff --git a/tests/skills_gmail_oauth_proxy_rpc_e2e.rs b/tests/skills_gmail_oauth_proxy_rpc_e2e.rs
deleted file mode 100644
index 4e4060323..000000000
--- a/tests/skills_gmail_oauth_proxy_rpc_e2e.rs
+++ /dev/null
@@ -1,405 +0,0 @@
-//! Gmail OAuth proxy E2E over HTTP JSON-RPC.
-//!
-//! Verifies the full flow:
-//! 1. Start runtime + Gmail skill through HTTP JSON-RPC
-//! 2. Send `oauth/complete` with `credentialId` + `clientKeyShare`
-//! 3. Call `get-profile` via `openhuman.skills_call_tool`
-//! 4. Assert tool call succeeds against the staging backend.
-
-use std::net::SocketAddr;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-
-use axum::Router;
-use serde_json::{json, Value};
-use tempfile::tempdir;
-
-use openhuman_core::core::jsonrpc::build_core_http_router;
-use openhuman_core::openhuman::memory::MemoryClient;
-use openhuman_core::openhuman::skills::qjs_engine::{replace_global_engine, RuntimeEngine};
-use std::ffi::OsString;
-
-fn try_find_skills_dir() -> Option<PathBuf> {
-    if let Ok(dir) = std::env::var("SKILL_DEBUG_DIR") {
-        let p = PathBuf::from(&dir);
-        return if p.exists() { Some(p) } else { None };
-    }
-    if let Ok(dir) = std::env::var("SKILLS_LOCAL_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-    }
-    let cwd = std::env::current_dir().expect("cwd");
-    for candidate in &[
-        cwd.join("../openhuman-skills/skills"),
-        cwd.join("openhuman-skills/skills"),
-        cwd.join("../alphahuman/skills/skills"),
-    ] {
-        if candidate.exists() {
-            return Some(candidate.canonicalize().unwrap());
-        }
-    }
-    None
-}
-
-macro_rules! require_skills_dir {
-    () => {
-        match try_find_skills_dir() {
-            Some(dir) => dir,
-            None => {
-                eprintln!("SKIPPED: no skills directory available (set SKILL_DEBUG_DIR)");
-                return;
-            }
-        }
-    };
-}
-
-async fn serve_on_ephemeral(
-    app: Router,
-) -> (
-    SocketAddr,
-    tokio::task::JoinHandle<Result<(), std::io::Error>>,
-) {
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
-        .await
-        .expect("bind");
-    let addr = listener.local_addr().expect("addr");
-    let handle = tokio::spawn(async move { axum::serve(listener, app).await });
-    (addr, handle)
-}
-
-async fn rpc_call(base: &str, id: i64, method: &str, params: Value) -> Value {
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(60))
-        .build()
-        .expect("client");
-    let body = json!({
-        "jsonrpc": "2.0",
-        "id": id,
-        "method": method,
-        "params": params,
-    });
-    let url = format!("{}/rpc", base.trim_end_matches('/'));
-    let resp = client
-        .post(&url)
-        .json(&body)
-        .send()
-        .await
-        .unwrap_or_else(|e| panic!("POST {url}: {e}"));
-    assert!(
-        resp.status().is_success(),
-        "HTTP error {} for {}",
-        resp.status(),
-        method
-    );
-    resp.json::<Value>()
-        .await
-        .unwrap_or_else(|e| panic!("json for {method}: {e}"))
-}
-
-fn assert_rpc_ok(resp: &Value, context: &str) -> Value {
-    if let Some(err) = resp.get("error") {
-        panic!("{context}: unexpected JSON-RPC error: {err}");
-    }
-    resp.get("result")
-        .cloned()
-        .unwrap_or_else(|| panic!("{context}: missing result field: {resp}"))
-}
-
-/// Restores prior process environment for keys we mutate in this test (runs on panic too).
-struct ProcessEnvGuard {
-    home: Option<OsString>,
-    backend_url: Option<OsString>,
-    jwt_token: Option<OsString>,
-    openhuman_workspace: Option<OsString>,
-    vite_backend_url: Option<OsString>,
-}
-
-impl ProcessEnvGuard {
-    fn apply(
-        home: &std::path::Path,
-        workspace_dir: &std::path::Path,
-        backend_url: &str,
-        jwt: &str,
-    ) -> Self {
-        let guard = Self {
-            home: std::env::var_os("HOME"),
-            backend_url: std::env::var_os("BACKEND_URL"),
-            jwt_token: std::env::var_os("JWT_TOKEN"),
-            openhuman_workspace: std::env::var_os("OPENHUMAN_WORKSPACE"),
-            vite_backend_url: std::env::var_os("VITE_BACKEND_URL"),
-        };
-        unsafe {
-            std::env::set_var("HOME", home.as_os_str());
-            std::env::set_var("BACKEND_URL", backend_url);
-            std::env::set_var("JWT_TOKEN", jwt);
-            std::env::set_var("OPENHUMAN_WORKSPACE", workspace_dir.as_os_str());
-            std::env::remove_var("VITE_BACKEND_URL");
-        }
-        guard
-    }
-}
-
-impl Drop for ProcessEnvGuard {
-    fn drop(&mut self) {
-        unsafe {
-            match self.home.take() {
-                Some(v) => std::env::set_var("HOME", v),
-                None => std::env::remove_var("HOME"),
-            }
-            match self.backend_url.take() {
-                Some(v) => std::env::set_var("BACKEND_URL", v),
-                None => std::env::remove_var("BACKEND_URL"),
-            }
-            match self.jwt_token.take() {
-                Some(v) => std::env::set_var("JWT_TOKEN", v),
-                None => std::env::remove_var("JWT_TOKEN"),
-            }
-            match self.openhuman_workspace.take() {
-                Some(v) => std::env::set_var("OPENHUMAN_WORKSPACE", v),
-                None => std::env::remove_var("OPENHUMAN_WORKSPACE"),
-            }
-            match self.vite_backend_url.take() {
-                Some(v) => std::env::set_var("VITE_BACKEND_URL", v),
-                None => std::env::remove_var("VITE_BACKEND_URL"),
-            }
-        }
-    }
-}
-
-struct GlobalEngineGuard {
-    previous: Option<Arc<RuntimeEngine>>,
-}
-
-impl GlobalEngineGuard {
-    fn install(engine: Arc<RuntimeEngine>) -> Self {
-        let previous = replace_global_engine(Some(engine));
-        Self { previous }
-    }
-}
-
-impl Drop for GlobalEngineGuard {
-    fn drop(&mut self) {
-        let _ = replace_global_engine(self.previous.take());
-    }
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn gmail_tool_call_sends_encrypted_oauth_proxy_headers() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Info)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let tmp = tempdir().expect("tempdir");
-    let home = tmp.path();
-    let data_dir = home.join("skills_data");
-    let workspace_dir = home.join("workspace");
-    std::fs::create_dir_all(&data_dir).expect("create data dir");
-    std::fs::create_dir_all(&workspace_dir).expect("create workspace dir");
-    let backend_url = "https://staging-api.alphahuman.xyz";
-
-    // Isolated HOME + env for JWT and backend routing used by oauth.fetch.
-    let openhuman_dir = home.join(".openhuman");
-    std::fs::create_dir_all(&openhuman_dir).expect("create .openhuman");
-    std::fs::write(
-        openhuman_dir.join("config.toml"),
-        r#"api_url = "http://127.0.0.1:1"
-default_model = "test"
-[secrets]
-encrypt = false
-"#,
-    )
-    .expect("write config");
-
-    let test_jwt = match std::env::var("JWT_TOKEN") {
-        Ok(v) if !v.trim().is_empty() => v,
-        _ => {
-            eprintln!("`SKIPPED`: set JWT_TOKEN to run staging OAuth proxy E2E");
-            return;
-        }
-    };
-    let credential_id = match std::env::var("CREDENTIAL_ID") {
-        Ok(v) if !v.trim().is_empty() => v,
-        _ => {
-            eprintln!("SKIPPED: set CREDENTIAL_ID to run staging OAuth proxy E2E");
-            return;
-        }
-    };
-    let client_key_share = match std::env::var("CLIENT_KEY_SHARE") {
-        Ok(v) if !v.trim().is_empty() => v,
-        _ => {
-            eprintln!("SKIPPED: set CLIENT_KEY_SHARE to run staging OAuth proxy E2E");
-            return;
-        }
-    };
-    eprintln!("[gmail-oauth-proxy-e2e] JWT_TOKEN loaded");
-    eprintln!("[gmail-oauth-proxy-e2e] CREDENTIAL_ID loaded");
-    eprintln!("[gmail-oauth-proxy-e2e] CLIENT_KEY_SHARE loaded");
-
-    // Quick staging reachability check.
-    let health = reqwest::Client::new()
-        .get(format!("{backend_url}/settings"))
-        .header("Authorization", format!("Bearer {test_jwt}"))
-        .send()
-        .await;
-    match health {
-        Ok(resp) => eprintln!(
-            "[gmail-oauth-proxy-e2e] staging /settings -> {}",
-            resp.status()
-        ),
-        Err(err) => panic!("failed to reach staging backend {backend_url}: {err}"),
-    }
-
-    // Isolated env + global engine so parallel tests do not leak state.
-    let _env_guard = ProcessEnvGuard::apply(home, &workspace_dir, backend_url, &test_jwt);
-    let engine = Arc::new(RuntimeEngine::new(data_dir).expect("engine"));
-    engine.set_skills_source_dir(skills_dir);
-    let _engine_guard = GlobalEngineGuard::install(engine.clone());
-
-    // Start HTTP JSON-RPC server.
-    let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
-    let rpc_base = format!("http://{}", rpc_addr);
-    tokio::time::sleep(Duration::from_millis(50)).await;
-
-    // 1) Start skill
-    let start = rpc_call(
-        &rpc_base,
-        1,
-        "openhuman.skills_start",
-        json!({ "skill_id": "gmail" }),
-    )
-    .await;
-    let _ = assert_rpc_ok(&start, "skills_start");
-
-    // 2) Inject OAuth credential + client key share
-    let oauth_complete = rpc_call(
-        &rpc_base,
-        2,
-        "openhuman.skills_rpc",
-        json!({
-            "skill_id": "gmail",
-            "method": "oauth/complete",
-            "params": {
-                "credentialId": credential_id,
-                "provider": "gmail",
-                "grantedScopes": ["https://www.googleapis.com/auth/gmail.readonly"],
-                "clientKeyShare": client_key_share
-            }
-        }),
-    )
-    .await;
-    let _ = assert_rpc_ok(&oauth_complete, "skills_rpc oauth/complete");
-
-    // 3) Call get-profile tool via runtime JSON-RPC
-    let call_tool = rpc_call(
-        &rpc_base,
-        3,
-        "openhuman.skills_call_tool",
-        json!({
-            "skill_id": "gmail",
-            "tool_name": "get-profile",
-            "arguments": {}
-        }),
-    )
-    .await;
-    eprintln!(
-        "[gmail-oauth-proxy-e2e] skills_call_tool completed (has_error={})",
-        call_tool.get("error").is_some()
-    );
-    let tool_result = assert_rpc_ok(&call_tool, "skills_call_tool get-profile");
-    eprintln!(
-        "[gmail-oauth-proxy-e2e] get-profile tool result keys: {:?}",
-        tool_result
-            .as_object()
-            .map(|m| m.keys().collect::<Vec<_>>())
-    );
-    assert_eq!(
-        tool_result.get("is_error").and_then(|v| v.as_bool()),
-        Some(false),
-        "expected get-profile tool call to succeed"
-    );
-
-    // 4) Validate tool payload shape from real staging response
-    let content_text = tool_result
-        .get("content")
-        .and_then(|v| v.as_array())
-        .and_then(|arr| arr.first())
-        .and_then(|item| item.get("text"))
-        .and_then(|v| v.as_str())
-        .unwrap_or("");
-    assert!(
-        !content_text.is_empty(),
-        "expected text payload in tool result content"
-    );
-    let parsed: Value = serde_json::from_str(content_text)
-        .unwrap_or_else(|e| panic!("tool text payload should be JSON: {e}; got {content_text}"));
-    assert_eq!(parsed.get("success").and_then(|v| v.as_bool()), Some(true));
-    eprintln!("[gmail-oauth-proxy-e2e] get-profile JSON: success flag present");
-
-    // 5) Trigger sync via controller RPC (routes to skill/sync)
-    let sync = rpc_call(
-        &rpc_base,
-        4,
-        "openhuman.skills_sync",
-        json!({ "skill_id": "gmail" }),
-    )
-    .await;
-    eprintln!(
-        "[gmail-oauth-proxy-e2e] skills_sync RPC completed (has_error={})",
-        sync.get("error").is_some()
-    );
-    let sync_result = assert_rpc_ok(&sync, "openhuman.skills_sync");
-    eprintln!(
-        "[gmail-oauth-proxy-e2e] skills_sync result keys: {:?}",
-        sync_result
-            .as_object()
-            .map(|m| m.keys().collect::<Vec<_>>())
-    );
-
-    // 6) Verify memory persistence in skill-gmail namespace (async)
-    let memory_client = MemoryClient::from_workspace_dir(workspace_dir.clone())
-        .expect("MemoryClient::from_workspace_dir");
-    let namespace = "skill-gmail";
-    let mut docs_count = 0usize;
-    let mut last_docs_payload = json!({});
-    for _ in 0..10 {
-        let docs = memory_client
-            .list_documents(Some(namespace))
-            .await
-            .unwrap_or_else(|e| panic!("list_documents({namespace}) failed: {e}"));
-        docs_count = docs
-            .get("documents")
-            .and_then(|d| d.as_array())
-            .map(|arr| arr.len())
-            .unwrap_or(0);
-        last_docs_payload = docs;
-        if docs_count > 0 {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(500)).await;
-    }
-    assert!(
-        docs_count > 0,
-        "expected memory docs in namespace '{namespace}' after skills_sync; workspace={}, last_payload={}",
-        workspace_dir.display(),
-        serde_json::to_string(&last_docs_payload).unwrap_or_else(|_| last_docs_payload.to_string())
-    );
-    eprintln!(
-        "[gmail-oauth-proxy-e2e] memory docs in {}: {}",
-        namespace, docs_count
-    );
-
-    // Cleanup
-    let _ = rpc_call(
-        &rpc_base,
-        5,
-        "openhuman.skills_stop",
-        json!({ "skill_id": "gmail" }),
-    )
-    .await;
-    rpc_join.abort();
-}
diff --git a/tests/skills_notion_live.rs b/tests/skills_notion_live.rs
deleted file mode 100644
index 112e94737..000000000
--- a/tests/skills_notion_live.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-//! Notion skill live debug test — uses real data directory and backend.
-//!
-//! This test uses:
-//!   - The real ~/.openhuman/skills_data/notion/ directory (with oauth_credential.json)
-//!   - BACKEND_URL env var for the OAuth proxy
-//!   - JWT_TOKEN env var for authentication
-//!
-//! Run:
-//!   BACKEND_URL=https://staging-api.alphahuman.xyz \
-//!   JWT_TOKEN=<jwt> \
-//!   cargo test --test skills_notion_live -- --nocapture
-
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-
-use serde_json::{json, Value};
-
-use openhuman_core::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
-
-/// Truncate a string to at most `max_bytes` without panicking on multi-byte
-/// char boundaries.  Falls back to the nearest char boundary at or before
-/// `max_bytes`.
-fn truncate_str(s: &str, max_bytes: usize) -> &str {
-    if s.len() <= max_bytes {
-        return s;
-    }
-    let mut end = max_bytes;
-    while end > 0 && !s.is_char_boundary(end) {
-        end -= 1;
-    }
-    &s[..end]
-}
-
-fn try_find_skills_dir() -> Option<PathBuf> {
-    if let Ok(dir) = std::env::var("SKILL_DEBUG_DIR") {
-        let p = PathBuf::from(&dir);
-        return if p.exists() { Some(p) } else { None };
-    }
-    if let Ok(dir) = std::env::var("SKILLS_LOCAL_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-    }
-    let cwd = std::env::current_dir().expect("cwd");
-    for candidate in &[
-        "../openhuman-skills/skills",
-        "openhuman-skills/skills",
-        "../alphahuman/skills/skills",
-    ] {
-        let p = cwd.join(candidate);
-        if p.exists() {
-            return Some(p.canonicalize().unwrap());
-        }
-    }
-    if let Some(parent) = cwd.parent() {
-        for entry in std::fs::read_dir(parent).into_iter().flatten().flatten() {
-            let c = entry.path().join("skills/skills");
-            if c.join("notion/manifest.json").exists() {
-                return Some(c.canonicalize().unwrap());
-            }
-        }
-    }
-    None
-}
-
-macro_rules! require_skills_dir {
-    () => {
-        match try_find_skills_dir() {
-            Some(dir) => dir,
-            None => {
-                eprintln!("SKIPPED: no skills directory available");
-                return;
-            }
-        }
-    };
-}
-
-#[tokio::test]
-async fn notion_live_with_real_data() {
-    // Opt-in: only runs when RUN_LIVE_NOTION=1 is set explicitly.
-    if std::env::var("RUN_LIVE_NOTION").unwrap_or_default() != "1" {
-        eprintln!("SKIPPED: set RUN_LIVE_NOTION=1 to run this live integration test");
-        return;
-    }
-
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Info)
-        .is_test(true)
-        .try_init();
-
-    let backend_url =
-        std::env::var("BACKEND_URL").expect("BACKEND_URL must be set for live Notion test");
-    let jwt_token = std::env::var("JWT_TOKEN").expect("JWT_TOKEN must be set for live Notion test");
-    let credential_id =
-        std::env::var("CREDENTIAL_ID").expect("CREDENTIAL_ID must be set for live Notion test");
-    let skills_dir = require_skills_dir!();
-
-    let real_data_dir = PathBuf::from(
-        std::env::var("SKILLS_DATA_DIR").expect("SKILLS_DATA_DIR must be set for live Notion test"),
-    );
-
-    let sep = "=".repeat(60);
-    eprintln!("\n{sep}");
-    eprintln!("  Notion Live Debug (real data dir)");
-    eprintln!("{sep}");
-    eprintln!("  Backend:       {backend_url}");
-    eprintln!("  JWT:           <redacted, {} bytes>", jwt_token.len());
-    eprintln!("  Credential ID: {credential_id}");
-    eprintln!("  Skills dir:    {}", skills_dir.display());
-    eprintln!("  Data dir:      {}", real_data_dir.display());
-
-    // Check oauth_credential.json exists (don't log contents — may contain secrets)
-    let cred_path = real_data_dir.join("notion/oauth_credential.json");
-    if cred_path.exists() {
-        let size = std::fs::metadata(&cred_path).map(|m| m.len()).unwrap_or(0);
-        eprintln!("  OAuth cred:    present ({size} bytes)");
-    } else {
-        eprintln!("  OAuth cred:    NOT FOUND at {}", cred_path.display());
-        eprintln!("  (Skill will start without OAuth — tools that need API access will fail)");
-    }
-
-    // ── Step 1: Raw backend check ──
-    eprintln!("\n--- Step 1: Backend Health ---");
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(10))
-        .build()
-        .unwrap();
-
-    let health = client
-        .get(format!("{backend_url}/auth/me"))
-        .header("Authorization", format!("Bearer {jwt_token}"))
-        .send()
-        .await;
-
-    match health {
-        Ok(resp) => {
-            let status = resp.status();
-            let body = resp.text().await.unwrap_or_default();
-            eprintln!("  GET /auth/me → HTTP {status}");
-            if status.is_success() {
-                eprintln!("  ✓ Backend reachable, JWT valid");
-                eprintln!("  Body: {}...", truncate_str(&body, 200));
-            } else if status.as_u16() == 502 {
-                eprintln!("  ✗ Backend DOWN (502 Bad Gateway)");
-                eprintln!("  The staging server is unreachable. OAuth proxy will fail.");
-                eprintln!("  Continuing to test skill lifecycle anyway...");
-            } else {
-                eprintln!("  ⚠ HTTP {status}: {body}");
-            }
-        }
-        Err(e) => {
-            eprintln!("  ✗ Connection failed: {e}");
-        }
-    }
-
-    // ── Step 2: Raw proxy check ──
-    eprintln!("\n--- Step 2: OAuth Proxy Check ---");
-    let proxy_url = format!("{backend_url}/proxy/by-id/{credential_id}/v1/users?page_size=1");
-    eprintln!("  GET {proxy_url}");
-
-    let proxy = client
-        .get(&proxy_url)
-        .header("Authorization", format!("Bearer {jwt_token}"))
-        .header("Content-Type", "application/json")
-        .send()
-        .await;
-
-    match proxy {
-        Ok(resp) => {
-            let status = resp.status();
-            let body = resp.text().await.unwrap_or_default();
-            eprintln!("  HTTP {status}");
-            if status.is_success() {
-                eprintln!("  ✓ Notion API accessible via proxy");
-                eprintln!("  Body: {}...", truncate_str(&body, 300));
-            } else {
-                eprintln!(
-                    "  ✗ Proxy returned {status}: {}...",
-                    truncate_str(&body, 200)
-                );
-            }
-        }
-        Err(e) => {
-            eprintln!("  ✗ Proxy request failed: {e}");
-        }
-    }
-
-    // ── Step 3: Start skill with real data dir ──
-    eprintln!("\n--- Step 3: Start Notion Skill (real data dir) ---");
-    let engine = RuntimeEngine::new(real_data_dir.clone()).expect("engine");
-    let engine = Arc::new(engine);
-    engine.set_skills_source_dir(skills_dir.clone());
-    set_global_engine(engine.clone());
-
-    let start = engine.start_skill("notion").await;
-    match &start {
-        Ok(snap) => {
-            eprintln!("  ✓ Started — status: {:?}", snap.status);
-            eprintln!("  Tools: {}", snap.tools.len());
-            eprintln!("  Published state:");
-            for (k, v) in &snap.state {
-                if k.contains("status")
-                    || k.contains("error")
-                    || k.contains("auth")
-                    || k == "workspaceName"
-                    || k == "is_initialized"
-                {
-                    eprintln!("    {k} = {v}");
-                }
-            }
-        }
-        Err(e) => {
-            eprintln!("  ✗ Start failed: {e}");
-            panic!("Skill start failed");
-        }
-    }
-
-    // ── Step 4: sync-status tool ──
-    eprintln!("\n--- Step 4: sync-status tool ---");
-    let sync_status = tokio::time::timeout(
-        Duration::from_secs(15),
-        engine.call_tool("notion", "sync-status", json!({})),
-    )
-    .await;
-
-    match sync_status {
-        Ok(Ok(result)) => {
-            for content in &result.content {
-                match content {
-                    openhuman_core::openhuman::skills::types::ToolContent::Text { text } => {
-                        // Parse and pretty-print
-                        if let Ok(v) = serde_json::from_str::<Value>(text) {
-                            eprintln!("  ✓ sync-status:");
-                            eprintln!(
-                                "    connected:       {}",
-                                v.get("connected").unwrap_or(&json!(null))
-                            );
-                            eprintln!(
-                                "    workspace:       {}",
-                                v.get("workspace_name").unwrap_or(&json!(null))
-                            );
-                            eprintln!(
-                                "    last_sync:       {}",
-                                v.get("last_sync_time").unwrap_or(&json!(null))
-                            );
-                            eprintln!(
-                                "    last_sync_error: {}",
-                                v.get("last_sync_error").unwrap_or(&json!(null))
-                            );
-                            if let Some(totals) = v.get("totals") {
-                                eprintln!("    totals: {totals}");
-                            }
-                        } else {
-                            eprintln!("  ✓ Raw: {text}");
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-        Ok(Err(e)) => eprintln!("  ✗ Error: {e}"),
-        Err(_) => eprintln!("  ✗ TIMED OUT"),
-    }
-
-    // ── Step 5: search tool (needs OAuth) ──
-    eprintln!("\n--- Step 5: search tool (needs OAuth proxy) ---");
-    let search = tokio::time::timeout(
-        Duration::from_secs(30),
-        engine.call_tool("notion", "search", json!({"query": "test", "page_size": 3})),
-    )
-    .await;
-
-    match search {
-        Ok(Ok(result)) => {
-            eprintln!("  is_error: {}", result.is_error);
-            for content in &result.content {
-                match content {
-                    openhuman_core::openhuman::skills::types::ToolContent::Text { text } => {
-                        eprintln!("  Result: {}...", truncate_str(text, 500));
-                    }
-                    _ => {}
-                }
-            }
-        }
-        Ok(Err(e)) => eprintln!("  ✗ Error: {e}"),
-        Err(_) => eprintln!("  ✗ TIMED OUT"),
-    }
-
-    // ── Step 6: list-all-pages tool (needs OAuth) ──
-    eprintln!("\n--- Step 6: list-all-pages (needs OAuth proxy) ---");
-    let pages = tokio::time::timeout(
-        Duration::from_secs(30),
-        engine.call_tool("notion", "list-all-pages", json!({"page_size": 3})),
-    )
-    .await;
-
-    match pages {
-        Ok(Ok(result)) => {
-            eprintln!("  is_error: {}", result.is_error);
-            for content in &result.content {
-                match content {
-                    openhuman_core::openhuman::skills::types::ToolContent::Text { text } => {
-                        eprintln!("  Result: {}...", truncate_str(text, 500));
-                    }
-                    _ => {}
-                }
-            }
-        }
-        Ok(Err(e)) => eprintln!("  ✗ Error: {e}"),
-        Err(_) => eprintln!("  ✗ TIMED OUT"),
-    }
-
-    // ── Step 7: Sync + Memory Persistence ──
-    eprintln!("\n--- Step 7: Sync + Memory Verification ---");
-    eprintln!("  Calling skill/sync to trigger onSync() + memory persistence...");
-
-    let sync_result = tokio::time::timeout(
-        Duration::from_secs(60),
-        engine.rpc("notion", "skill/sync", json!({})),
-    )
-    .await;
-
-    match &sync_result {
-        Ok(Ok(val)) => eprintln!("  skill/sync returned: {val}"),
-        Ok(Err(e)) => eprintln!("  skill/sync error: {e}"),
-        Err(_) => eprintln!("  skill/sync TIMED OUT (60s)"),
-    }
-
-    // Wait for fire-and-forget memory persistence to complete
-    eprintln!("  Waiting 3s for async memory persistence...");
-    tokio::time::sleep(Duration::from_secs(3)).await;
-
-    // Verify memory documents were created.
-    // The RuntimeEngine initializes its MemoryClient via new_local() which
-    // uses ~/.openhuman/workspace, so we check there.
-    eprintln!("  Checking local memory store (~/.openhuman/workspace)...");
-    match openhuman_core::openhuman::memory::MemoryClient::new_local() {
-        Ok(memory_client) => {
-            let namespace = "skill-notion";
-            match memory_client.list_documents(Some(namespace)).await {
-                Ok(docs) => {
-                    let doc_array = docs
-                        .get("documents")
-                        .and_then(|d| d.as_array())
-                        .cloned()
-                        .unwrap_or_default();
-                    eprintln!("  Documents in '{namespace}': {}", doc_array.len());
-                    for doc in &doc_array {
-                        let title = doc.get("title").and_then(|t| t.as_str()).unwrap_or("?");
-                        let content_len = doc
-                            .get("content")
-                            .and_then(|c| c.as_str())
-                            .map(|c| c.len())
-                            .unwrap_or(0);
-                        eprintln!("    - {title} ({content_len} bytes)");
-                    }
-                    if doc_array.is_empty() {
-                        eprintln!("  WARNING: No memory documents found after sync");
-                        eprintln!("  This could mean:");
-                        eprintln!("    1. onSync() didn't publish any state via state.set()");
-                        eprintln!("    2. The memory client wasn't wired into the engine");
-                        eprintln!("    3. store_skill_sync failed silently");
-                    } else {
-                        eprintln!("  PASS: Memory documents created after sync");
-                    }
-                }
-                Err(e) => eprintln!("  Failed to list documents: {e}"),
-            }
-
-            match memory_client.list_namespaces().await {
-                Ok(namespaces) => {
-                    eprintln!("  All namespaces: {:?}", namespaces);
-                }
-                Err(e) => eprintln!("  Failed to list namespaces: {e}"),
-            }
-        }
-        Err(e) => {
-            eprintln!("  Could not create MemoryClient: {e}");
-        }
-    }
-
-    // ── Step 8: Final state ──
-    eprintln!("\n--- Step 8: Final Skill State ---");
-    if let Some(snap) = engine.get_skill_state("notion") {
-        eprintln!("  Status: {:?}", snap.status);
-        for (k, v) in &snap.state {
-            if k.contains("status")
-                || k.contains("error")
-                || k.contains("auth")
-                || k == "workspaceName"
-            {
-                eprintln!("  {k} = {v}");
-            }
-        }
-    }
-
-    // ── Cleanup ──
-    eprintln!("\n--- Stop ---");
-    let _ = engine.stop_skill("notion").await;
-    eprintln!("  Done");
-
-    let sep = "=".repeat(60);
-    eprintln!("\n{sep}");
-    eprintln!("  COMPLETE");
-    eprintln!("{sep}\n");
-}
diff --git a/tests/skills_rpc_e2e.rs b/tests/skills_rpc_e2e.rs
deleted file mode 100644
index 7c19bf52a..000000000
--- a/tests/skills_rpc_e2e.rs
+++ /dev/null
@@ -1,361 +0,0 @@
-//! Skills RPC E2E test — exercises skill operations over HTTP JSON-RPC.
-//!
-//! Tests the full stack: HTTP request → JSON-RPC dispatch → RuntimeEngine → QuickJS.
-//!
-//! Environment variables (same as skills_debug_e2e.rs):
-//!   SKILL_DEBUG_ID        — skill ID (default: "example-skill")
-//!   SKILL_DEBUG_DIR       — path to skills directory
-//!   SKILL_DEBUG_TOOL      — tool name to call
-//!   SKILL_DEBUG_TOOL_ARGS — JSON args for tool call
-//!
-//! Run:
-//!   cargo test --test skills_rpc_e2e -- --nocapture
-
-use std::net::SocketAddr;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::time::Duration;
-
-use axum::Router;
-use serde_json::{json, Value};
-use tempfile::tempdir;
-
-use openhuman_core::core::jsonrpc::build_core_http_router;
-use openhuman_core::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-fn manifests_in_dir(skills_dir: &Path) -> Vec<String> {
-    let mut ids = Vec::new();
-    let Ok(entries) = std::fs::read_dir(skills_dir) else {
-        return ids;
-    };
-
-    for entry in entries.flatten() {
-        let path = entry.path();
-        if !path.is_dir() || !path.join("manifest.json").exists() {
-            continue;
-        }
-        if let Some(name) = path.file_name().and_then(|name| name.to_str()) {
-            ids.push(name.to_string());
-        }
-    }
-
-    ids.sort();
-    ids
-}
-
-fn select_skill_id(skills_dir: &Path, env_key: &str, preferred: &[&str]) -> String {
-    if let Ok(skill_id) = std::env::var(env_key) {
-        if !skill_id.trim().is_empty() {
-            return skill_id;
-        }
-    }
-
-    let available = manifests_in_dir(skills_dir);
-    for candidate in preferred {
-        if available.iter().any(|id| id == candidate) {
-            return (*candidate).to_string();
-        }
-    }
-
-    available
-        .into_iter()
-        .next()
-        .unwrap_or_else(|| "example-skill".to_string())
-}
-
-fn try_find_skills_dir() -> Option<PathBuf> {
-    if let Ok(dir) = std::env::var("SKILL_DEBUG_DIR") {
-        let p = PathBuf::from(&dir);
-        return if p.exists() { Some(p) } else { None };
-    }
-    if let Ok(dir) = std::env::var("SKILLS_LOCAL_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-    }
-    let cwd = std::env::current_dir().expect("cwd");
-    for candidate in &[
-        "../openhuman-skills/skills",
-        "openhuman-skills/skills",
-        "../alphahuman/skills/skills",
-    ] {
-        let p = cwd.join(candidate);
-        if p.exists() {
-            return Some(p.canonicalize().unwrap());
-        }
-    }
-    if let Some(parent) = cwd.parent() {
-        for entry in std::fs::read_dir(parent).into_iter().flatten().flatten() {
-            let c = entry.path().join("skills/skills");
-            if c.exists() && c.read_dir().is_ok() {
-                return Some(c.canonicalize().unwrap());
-            }
-        }
-    }
-    None
-}
-
-macro_rules! require_skills_dir {
-    () => {
-        match try_find_skills_dir() {
-            Some(dir) => dir,
-            None => {
-                eprintln!("SKIPPED: no skills directory available");
-                return;
-            }
-        }
-    };
-}
-
-async fn serve_on_ephemeral(
-    app: Router,
-) -> (
-    SocketAddr,
-    tokio::task::JoinHandle<Result<(), std::io::Error>>,
-) {
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
-        .await
-        .expect("bind");
-    let addr = listener.local_addr().expect("addr");
-    let handle = tokio::spawn(async move { axum::serve(listener, app).await });
-    (addr, handle)
-}
-
-async fn rpc_call(base: &str, id: i64, method: &str, params: Value) -> Value {
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(60))
-        .build()
-        .expect("client");
-    let body = json!({
-        "jsonrpc": "2.0",
-        "id": id,
-        "method": method,
-        "params": params,
-    });
-    let url = format!("{}/rpc", base.trim_end_matches('/'));
-    let resp = client
-        .post(&url)
-        .json(&body)
-        .send()
-        .await
-        .unwrap_or_else(|e| panic!("POST {url}: {e}"));
-    assert!(
-        resp.status().is_success(),
-        "HTTP error {} for {}",
-        resp.status(),
-        method
-    );
-    resp.json::<Value>()
-        .await
-        .unwrap_or_else(|e| panic!("json for {method}: {e}"))
-}
-
-fn assert_rpc_ok(resp: &Value, context: &str) -> Value {
-    if let Some(err) = resp.get("error") {
-        panic!("{context}: unexpected JSON-RPC error: {err}");
-    }
-    resp.get("result")
-        .cloned()
-        .unwrap_or_else(|| panic!("{context}: missing 'result' field in response: {resp}"))
-}
-
-// ── Test ─────────────────────────────────────────────────────────────────────
-
-#[tokio::test]
-async fn skills_over_http_rpc() {
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Info)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let skill_id = select_skill_id(
-        &skills_dir,
-        "SKILL_DEBUG_ID",
-        &["server-ping", "gmail", "notion"],
-    );
-    let tmp = tempdir().expect("tempdir");
-    let home = tmp.path();
-    let data_dir = home.join("skills_data");
-    std::fs::create_dir_all(&data_dir).unwrap();
-
-    // Set up env for isolated config
-    let openhuman_dir = home.join(".openhuman");
-    std::fs::create_dir_all(&openhuman_dir).unwrap();
-    std::fs::write(
-        openhuman_dir.join("config.toml"),
-        r#"api_url = "http://127.0.0.1:1"
-default_model = "test"
-[secrets]
-encrypt = false
-"#,
-    )
-    .unwrap();
-
-    // Unsafe env overrides (tests are serialized)
-    unsafe {
-        std::env::set_var("HOME", home.as_os_str());
-        std::env::remove_var("OPENHUMAN_WORKSPACE");
-        std::env::remove_var("BACKEND_URL");
-        std::env::remove_var("VITE_BACKEND_URL");
-    }
-
-    // Create and register engine
-    let engine = Arc::new(RuntimeEngine::new(data_dir).expect("engine"));
-    engine.set_skills_source_dir(skills_dir.clone());
-    set_global_engine(engine.clone());
-
-    // Start the HTTP RPC server
-    let (rpc_addr, rpc_join) = serve_on_ephemeral(build_core_http_router(false)).await;
-    let base = format!("http://{}", rpc_addr);
-    tokio::time::sleep(Duration::from_millis(50)).await;
-
-    eprintln!("\n=== Skills HTTP RPC E2E ===");
-    eprintln!("  Skill:  {skill_id}");
-    eprintln!("  RPC:    {base}");
-    eprintln!("  Skills: {}", skills_dir.display());
-
-    // 1. core.ping
-    eprintln!("\n--- core.ping ---");
-    let ping = rpc_call(&base, 1, "core.ping", json!({})).await;
-    let r = assert_rpc_ok(&ping, "core.ping");
-    assert_eq!(r.get("ok"), Some(&json!(true)));
-    eprintln!("  OK");
-
-    // 2. openhuman.skills_discover
-    eprintln!("\n--- openhuman.skills_discover ---");
-    let discover = rpc_call(&base, 2, "openhuman.skills_discover", json!({})).await;
-    let r = assert_rpc_ok(&discover, "skills_discover");
-    eprintln!(
-        "  Result: {} skills",
-        r.as_array().map(|a| a.len()).unwrap_or(0)
-    );
-
-    // 3. openhuman.skills_start
-    eprintln!("\n--- openhuman.skills_start ---");
-    let start = rpc_call(
-        &base,
-        3,
-        "openhuman.skills_start",
-        json!({ "skill_id": skill_id }),
-    )
-    .await;
-    let r = assert_rpc_ok(&start, "skills_start");
-    eprintln!("  Status: {:?}", r.get("status"));
-    eprintln!(
-        "  Tools: {}",
-        r.get("tools")
-            .and_then(|t| t.as_array())
-            .map(|a| a.len())
-            .unwrap_or(0)
-    );
-
-    // 4. openhuman.skills_list_tools
-    eprintln!("\n--- openhuman.skills_list_tools ---");
-    let tools = rpc_call(
-        &base,
-        4,
-        "openhuman.skills_list_tools",
-        json!({ "skill_id": skill_id }),
-    )
-    .await;
-    let r = assert_rpc_ok(&tools, "skills_list_tools");
-    let tool_list = r.get("tools").and_then(|t| t.as_array());
-    if let Some(tools) = tool_list {
-        eprintln!("  {} tools:", tools.len());
-        for t in tools.iter().take(5) {
-            eprintln!(
-                "    - {}",
-                t.get("name").and_then(|n| n.as_str()).unwrap_or("?")
-            );
-        }
-        if tools.len() > 5 {
-            eprintln!("    ... and {} more", tools.len() - 5);
-        }
-    }
-
-    // 5. openhuman.skills_call_tool
-    eprintln!("\n--- openhuman.skills_call_tool ---");
-    let tool_name = std::env::var("SKILL_DEBUG_TOOL")
-        .ok()
-        .filter(|s| !s.trim().is_empty())
-        .or_else(|| {
-            tool_list.and_then(|tools| {
-                tools
-                    .first()
-                    .and_then(|tool| tool.get("name"))
-                    .and_then(Value::as_str)
-                    .map(ToString::to_string)
-            })
-        })
-        .unwrap_or_else(|| "get-status".to_string());
-    let tool_args: Value = std::env::var("SKILL_DEBUG_TOOL_ARGS")
-        .ok()
-        .and_then(|s| serde_json::from_str(&s).ok())
-        .unwrap_or_else(|| json!({}));
-    let call = rpc_call(
-        &base,
-        5,
-        "openhuman.skills_call_tool",
-        json!({ "skill_id": skill_id, "tool_name": tool_name, "arguments": tool_args }),
-    )
-    .await;
-    let r = assert_rpc_ok(&call, "skills_call_tool");
-    eprintln!("  Result: {r}");
-
-    // 6. openhuman.skills_sync (tick)
-    eprintln!("\n--- openhuman.skills_sync ---");
-    let sync = rpc_call(
-        &base,
-        6,
-        "openhuman.skills_sync",
-        json!({ "skill_id": skill_id }),
-    )
-    .await;
-    let r = assert_rpc_ok(&sync, "skills_sync");
-    eprintln!("  Result: {r}");
-
-    // 7. openhuman.skills_status
-    eprintln!("\n--- openhuman.skills_status ---");
-    let status = rpc_call(
-        &base,
-        7,
-        "openhuman.skills_status",
-        json!({ "skill_id": skill_id }),
-    )
-    .await;
-    let r = assert_rpc_ok(&status, "skills_status");
-    eprintln!("  Status: {:?}", r.get("status"));
-    eprintln!(
-        "  Published state keys: {:?}",
-        r.get("state")
-            .and_then(|s| s.as_object())
-            .map(|o| o.keys().collect::<Vec<_>>())
-    );
-
-    // 8. openhuman.skills_stop
-    eprintln!("\n--- openhuman.skills_stop ---");
-    let stop = rpc_call(
-        &base,
-        8,
-        "openhuman.skills_stop",
-        json!({ "skill_id": skill_id }),
-    )
-    .await;
-    let r = assert_rpc_ok(&stop, "skills_stop");
-    eprintln!("  Result: {r}");
-
-    // 9. openhuman.skills_list (post-stop)
-    eprintln!("\n--- openhuman.skills_list (post-stop) ---");
-    let list = rpc_call(&base, 9, "openhuman.skills_list", json!({})).await;
-    let r = assert_rpc_ok(&list, "skills_list");
-    let skills = r.as_array();
-    eprintln!("  {} skill(s)", skills.map(|a| a.len()).unwrap_or(0));
-
-    eprintln!("\n=== Skills HTTP RPC E2E COMPLETE ===\n");
-
-    rpc_join.abort();
-}
diff --git a/tests/skills_sync_memory_test.rs b/tests/skills_sync_memory_test.rs
deleted file mode 100644
index e4375de5c..000000000
--- a/tests/skills_sync_memory_test.rs
+++ /dev/null
@@ -1,418 +0,0 @@
-//! Integration test: skill sync → memory persistence.
-//!
-//! Verifies that calling `skill/sync` via RPC:
-//! 1. Invokes the skill's `onSync()` JS handler
-//! 2. Persists published state to the local memory store
-//!
-//! Also tests that cron-triggered syncs and tick persist to memory.
-//!
-//! Run:
-//!   cargo test --test skills_sync_memory_test -- --nocapture
-
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex, OnceLock};
-use std::time::Duration;
-
-use serde_json::json;
-use tempfile::tempdir;
-
-use openhuman_core::core::all::try_invoke_registered_rpc;
-use openhuman_core::openhuman::memory::MemoryClient;
-use openhuman_core::openhuman::skills::qjs_engine::{set_global_engine, RuntimeEngine};
-
-/// Serializes tests in this binary: `set_global_engine` mutates the process-wide
-/// GLOBAL_ENGINE, so parallel tests would cross-wire engine instances.
-static ENV_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-
-fn env_lock() -> std::sync::MutexGuard<'static, ()> {
-    ENV_LOCK
-        .get_or_init(|| Mutex::new(()))
-        .lock()
-        .expect("skills_sync_memory_test env lock poisoned")
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-fn try_find_skills_dir() -> Option<PathBuf> {
-    if let Ok(dir) = std::env::var("SKILL_DEBUG_DIR") {
-        let p = PathBuf::from(&dir);
-        return if p.exists() { Some(p) } else { None };
-    }
-    if let Ok(dir) = std::env::var("SKILLS_LOCAL_DIR") {
-        let p = PathBuf::from(&dir);
-        if p.exists() {
-            return Some(p);
-        }
-    }
-    let cwd = std::env::current_dir().expect("cwd");
-    for candidate in &[
-        "../openhuman-skills/skills",
-        "openhuman-skills/skills",
-        "../alphahuman/skills/skills",
-    ] {
-        let p = cwd.join(candidate);
-        if p.exists() {
-            return Some(p.canonicalize().unwrap());
-        }
-    }
-    if let Some(parent) = cwd.parent() {
-        for entry in std::fs::read_dir(parent).into_iter().flatten().flatten() {
-            let c = entry.path().join("skills/skills");
-            if c.join("example-skill/manifest.json").exists() {
-                return Some(c.canonicalize().unwrap());
-            }
-        }
-    }
-    None
-}
-
-macro_rules! require_skills_dir {
-    () => {
-        match try_find_skills_dir() {
-            Some(dir) => dir,
-            None => {
-                eprintln!("SKIPPED: no skills directory available (set SKILL_DEBUG_DIR for CI)");
-                return;
-            }
-        }
-    };
-}
-
-/// Pick a skill that actually exists in the skills directory.
-fn select_skill_id(skills_dir: &Path) -> String {
-    if let Ok(id) = std::env::var("SKILL_DEBUG_ID") {
-        if !id.trim().is_empty() {
-            return id;
-        }
-    }
-    // Preferred order: simple skills first.
-    for candidate in &["server-ping", "example-skill", "gmail", "notion"] {
-        if skills_dir.join(candidate).join("manifest.json").exists() {
-            return (*candidate).to_string();
-        }
-    }
-    // Fallback: first directory with a manifest.json.
-    if let Ok(entries) = std::fs::read_dir(skills_dir) {
-        for entry in entries.flatten() {
-            let p = entry.path();
-            if p.is_dir() && p.join("manifest.json").exists() {
-                if let Some(name) = p.file_name().and_then(|n| n.to_str()) {
-                    return name.to_string();
-                }
-            }
-        }
-    }
-    "example-skill".to_string()
-}
-
-async fn create_engine_with_memory(
-    skills_dir: &Path,
-    data_dir: &Path,
-    workspace_dir: &Path,
-) -> (Arc<RuntimeEngine>, Arc<MemoryClient>) {
-    let engine =
-        RuntimeEngine::new(data_dir.to_path_buf()).expect("RuntimeEngine::new should succeed");
-    let engine = Arc::new(engine);
-    engine.set_skills_source_dir(skills_dir.to_path_buf());
-
-    // Create a MemoryClient pointing at the temp workspace
-    let memory_client =
-        MemoryClient::from_workspace_dir(workspace_dir.to_path_buf()).expect("MemoryClient");
-    let memory_client = Arc::new(memory_client);
-
-    // Wire the memory client into the engine so event_loop can use it
-    engine.set_memory_client(memory_client.clone());
-
-    // Set as global so RPC handlers can find it
-    set_global_engine(engine.clone());
-
-    (engine, memory_client)
-}
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-/// Test that `skill/sync` RPC triggers `onSync()` and persists state to memory.
-#[tokio::test]
-async fn sync_rpc_persists_to_memory() {
-    let _lock = env_lock();
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Debug)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    let workspace_dir = tmp.path().join("workspace");
-    std::fs::create_dir_all(&data_dir).unwrap();
-    std::fs::create_dir_all(&workspace_dir).unwrap();
-
-    let skill_id = &select_skill_id(&skills_dir);
-
-    eprintln!("\n=== sync_rpc_persists_to_memory ===");
-    eprintln!("  Skill ID:      {skill_id}");
-    eprintln!("  Skills dir:    {}", skills_dir.display());
-    eprintln!("  Data dir:      {}", data_dir.display());
-    eprintln!("  Workspace dir: {}", workspace_dir.display());
-
-    let (engine, memory_client) =
-        create_engine_with_memory(&skills_dir, &data_dir, &workspace_dir).await;
-
-    // ── Start skill ──
-    eprintln!("\n--- Start skill '{skill_id}' ---");
-    let snap = engine.start_skill(skill_id).await.expect("start");
-    eprintln!("  Status: {:?}, tools: {}", snap.status, snap.tools.len());
-    eprintln!(
-        "  Published state keys: {:?}",
-        snap.state.keys().collect::<Vec<_>>()
-    );
-
-    // ── Verify no memory documents exist yet ──
-    eprintln!("\n--- Check memory before sync ---");
-    let namespace = format!("skill-{}", skill_id);
-    let before = memory_client
-        .list_documents(Some(&namespace))
-        .await
-        .expect("list_documents");
-    let before_count = before
-        .get("documents")
-        .and_then(|d| d.as_array())
-        .map(|a| a.len())
-        .unwrap_or(0);
-    eprintln!("  Documents in '{namespace}' before sync: {before_count}");
-
-    // ── Call skill/sync via RPC ──
-    eprintln!("\n--- Call skill/sync RPC ---");
-    let sync_result = tokio::time::timeout(
-        Duration::from_secs(30),
-        engine.rpc(skill_id, "skill/sync", json!({})),
-    )
-    .await;
-
-    match &sync_result {
-        Ok(Ok(val)) => eprintln!("  skill/sync returned: {val}"),
-        Ok(Err(e)) => eprintln!("  skill/sync error: {e} (may be expected for example-skill)"),
-        Err(_) => panic!("skill/sync TIMED OUT"),
-    }
-
-    // ── Wait for fire-and-forget memory persistence ──
-    eprintln!("\n--- Waiting for memory persistence (2s) ---");
-    tokio::time::sleep(Duration::from_secs(2)).await;
-
-    // ── Verify documents were created ──
-    eprintln!("\n--- Check memory after sync ---");
-    let after = memory_client
-        .list_documents(Some(&namespace))
-        .await
-        .expect("list_documents");
-    let after_docs = after
-        .get("documents")
-        .and_then(|d| d.as_array())
-        .cloned()
-        .unwrap_or_default();
-    eprintln!(
-        "  Documents in '{namespace}' after sync: {}",
-        after_docs.len()
-    );
-
-    for doc in &after_docs {
-        let title = doc.get("title").and_then(|t| t.as_str()).unwrap_or("?");
-        let doc_id = doc
-            .get("documentId")
-            .and_then(|d| d.as_str())
-            .unwrap_or("?");
-        eprintln!("    - title: {title}, doc_id: {doc_id}");
-    }
-
-    // The example-skill may or may not publish state during onSync.
-    // If it does, we should see at least one document.
-    // If it doesn't (no state.set calls in onSync), the snapshot will be empty
-    // and no document is created — that's correct behavior.
-    //
-    // We check published_state to know what to expect.
-    let final_state = engine.get_skill_state(skill_id);
-    let has_published_state = final_state
-        .as_ref()
-        .map(|s| !s.state.is_empty())
-        .unwrap_or(false);
-    eprintln!(
-        "  Skill has published state: {} ({} keys)",
-        has_published_state,
-        final_state.as_ref().map(|s| s.state.len()).unwrap_or(0)
-    );
-
-    if has_published_state {
-        assert!(
-            after_docs.len() > before_count,
-            "Expected at least one new document in namespace '{namespace}' after sync, \
-             but found {} (before: {before_count}). Published state is non-empty, \
-             so store_skill_sync should have been called.",
-            after_docs.len()
-        );
-        eprintln!("  PASS: Memory document created after sync");
-    } else {
-        eprintln!("  NOTE: Skill has no published state — no memory write expected");
-        eprintln!("  (This is correct behavior; persist_state_to_memory skips empty state)");
-    }
-
-    // ── Cleanup ──
-    let _ = engine.stop_skill(skill_id).await;
-    eprintln!("\n=== sync_rpc_persists_to_memory COMPLETE ===\n");
-}
-
-/// Test that `skill/tick` also persists state to memory.
-#[tokio::test]
-async fn tick_persists_to_memory() {
-    let _lock = env_lock();
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Debug)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    let workspace_dir = tmp.path().join("workspace");
-    std::fs::create_dir_all(&data_dir).unwrap();
-    std::fs::create_dir_all(&workspace_dir).unwrap();
-
-    let skill_id = &select_skill_id(&skills_dir);
-
-    eprintln!("\n=== tick_persists_to_memory ===");
-    eprintln!("  Skill ID: {skill_id}");
-
-    let (engine, memory_client) =
-        create_engine_with_memory(&skills_dir, &data_dir, &workspace_dir).await;
-
-    // Start skill
-    let snap = engine.start_skill(skill_id).await.expect("start");
-    eprintln!("  Started: {:?}", snap.status);
-
-    // Call skill/tick
-    let tick_result = tokio::time::timeout(
-        Duration::from_secs(15),
-        engine.rpc(skill_id, "skill/tick", json!({})),
-    )
-    .await;
-
-    match &tick_result {
-        Ok(Ok(val)) => eprintln!("  skill/tick returned: {val}"),
-        Ok(Err(e)) => eprintln!("  skill/tick error: {e}"),
-        Err(_) => panic!("skill/tick TIMED OUT"),
-    }
-
-    // Wait for persistence
-    tokio::time::sleep(Duration::from_secs(2)).await;
-
-    // Check memory
-    let namespace = format!("skill-{}", skill_id);
-    let docs = memory_client
-        .list_documents(Some(&namespace))
-        .await
-        .expect("list_documents");
-    let doc_count = docs
-        .get("documents")
-        .and_then(|d| d.as_array())
-        .map(|a| a.len())
-        .unwrap_or(0);
-    eprintln!("  Documents in '{namespace}' after tick: {doc_count}");
-
-    let has_published_state = engine
-        .get_skill_state(skill_id)
-        .map(|s| !s.state.is_empty())
-        .unwrap_or(false);
-
-    if has_published_state {
-        assert!(
-            doc_count > 0,
-            "Expected memory documents after tick with published state"
-        );
-        eprintln!("  PASS: Memory persisted after tick");
-    } else {
-        eprintln!("  NOTE: No published state — no memory write expected");
-    }
-
-    let _ = engine.stop_skill(skill_id).await;
-    eprintln!("=== tick_persists_to_memory COMPLETE ===\n");
-}
-
-/// Verify that the `skills_sync` RPC schema routes to `skill/sync` (not `skill/tick`).
-/// This is a regression test for the routing bug where `handle_skills_sync` sent
-/// `"skill/tick"` instead of `"skill/sync"`.
-#[tokio::test]
-async fn skills_sync_rpc_calls_on_sync_not_on_tick() {
-    let _lock = env_lock();
-    let _ = env_logger::builder()
-        .filter_level(log::LevelFilter::Debug)
-        .is_test(true)
-        .try_init();
-
-    let skills_dir = require_skills_dir!();
-    let tmp = tempdir().expect("tempdir");
-    let data_dir = tmp.path().join("skills_data");
-    let workspace_dir = tmp.path().join("workspace");
-    std::fs::create_dir_all(&data_dir).unwrap();
-    std::fs::create_dir_all(&workspace_dir).unwrap();
-
-    let skill_id = &select_skill_id(&skills_dir);
-
-    eprintln!("\n=== skills_sync_rpc_calls_on_sync_not_on_tick ===");
-    eprintln!("  Skill ID: {skill_id}");
-
-    let (engine, memory_client) =
-        create_engine_with_memory(&skills_dir, &data_dir, &workspace_dir).await;
-
-    let snap = engine.start_skill(skill_id).await.expect("start");
-    eprintln!("  Started: {:?}", snap.status);
-
-    // Exercise the full controller path via try_invoke_registered_rpc so we
-    // verify handle_skills_sync routes to "skill/sync" (not "skill/tick").
-    // This catches regressions in the controller layer that engine.rpc() would bypass.
-    let rpc_params: serde_json::Map<String, serde_json::Value> =
-        serde_json::from_value(json!({"skill_id": skill_id})).unwrap();
-    let sync_result = tokio::time::timeout(
-        Duration::from_secs(15),
-        try_invoke_registered_rpc("openhuman.skills_sync", rpc_params),
-    )
-    .await;
-
-    match &sync_result {
-        Ok(Some(Ok(val))) => {
-            eprintln!("  openhuman.skills_sync returned: {val}");
-            // The result comes from handle_js_call("onSync") which returns the
-            // JS value (typically null/undefined).  The old buggy path returned
-            // {"ok": true} from handle_js_void_call("onTick").
-        }
-        Ok(Some(Err(e))) => {
-            eprintln!("  openhuman.skills_sync error: {e}");
-            // An error from onSync not being defined is still acceptable —
-            // the important thing is it tried onSync, not onTick.
-        }
-        Ok(None) => {
-            panic!("openhuman.skills_sync not found in registered controllers");
-        }
-        Err(_) => panic!("openhuman.skills_sync TIMED OUT"),
-    }
-
-    // Also verify the namespace gets a title with "periodic sync" (not "tick sync")
-    tokio::time::sleep(Duration::from_secs(2)).await;
-
-    let namespace = format!("skill-{}", skill_id);
-    let docs = memory_client
-        .list_documents(Some(&namespace))
-        .await
-        .expect("list_documents");
-    if let Some(doc_array) = docs.get("documents").and_then(|d| d.as_array()) {
-        for doc in doc_array {
-            let title = doc.get("title").and_then(|t| t.as_str()).unwrap_or("?");
-            eprintln!("  Memory doc title: {title}");
-            assert!(
-                title.contains("periodic sync"),
-                "Expected title to contain 'periodic sync' (from skill/sync handler), got: {title}"
-            );
-        }
-    }
-
-    let _ = engine.stop_skill(skill_id).await;
-    eprintln!("=== skills_sync_rpc_calls_on_sync_not_on_tick COMPLETE ===\n");
-}