From a065a4c30be748b0c8fc6dd0b5ee1dc4d3de4b1c Mon Sep 17 00:00:00 2001
From: Agando <roduccomm@gmail.com>
Date: Mon, 9 Nov 2026 15:36:23 +0100
Subject: chore(newos4): commit accumulated maintenance output

The daily collector and the feedback pipeline had left 57 modified files uncommitted (skills,
modules-index, CHANGELOG, feedback decisions, debug counters). The public mirror publishes git
HEAD, so without this the published repo stayed behind the tree - and it blocked the publisher
outright once uncommitted subtrees started failing loudly.
---
 .bkp-fix-20261023_143429/skill-pack-core.js | 1150 +++++++++++++++++++++++++++
 1 file changed, 1150 insertions(+)
 create mode 100644 .bkp-fix-20261023_143429/skill-pack-core.js

(limited to '.bkp-fix-20261023_143429/skill-pack-core.js')

diff --git a/.bkp-fix-20261023_143429/skill-pack-core.js b/.bkp-fix-20261023_143429/skill-pack-core.js
new file mode 100644
index 0000000..f204e70
--- /dev/null
+++ b/.bkp-fix-20261023_143429/skill-pack-core.js
@@ -0,0 +1,1150 @@
+class SkillPackCoreModule {
+    constructor() {
+        this.commands = {};
+        this.commandsMeta = {
+            'skill-list': { argType: 'enum', enumFn: '_getSkillCategories' }, 'skill-view': { argType: 'file' },
+            'skill-create': { argType: 'dir' }, 'skill-patch': { argType: 'file' },
+            'skill-delete': { argType: 'file' }, 'skill-export': { argType: 'file' },
+            'skill-sync': { argType: 'file' },
+        };
+        this.terminal = null;
+        this._seeded = false;
+        this._skills = this._buildSkills();
+    }
+
+    requirements() {
+        try {
+            const fs = this.terminal && this.terminal.fs;
+            if (fs && fs.readFile('/skills/_seeded')) {
+                return { met: true, missing: [] };
+            }
+            return { met: false, missing: ['Skills directory not initialized. Will be created on first use.'] };
+        } catch (e) {
+            return { met: true, missing: [] };
+        }
+    }
+
+    getHelpInfo() {
+        return {
+            'skill-pack-core': 'Seed and manage built-in core skills (navigation, memory, search, modules, backup, agents, webdav, security, etc.)',
+            'skill-list': 'skill-list [category] — List all skills, optionally filtered by category',
+            'skill-view': 'skill-view <name> — View a skill\'s full content',
+            'skill-create': 'skill-create <name> <desc> "<steps>" [tags] — Create a new skill',
+            'skill-patch': 'skill-patch <name> "<content>" — Replace a skill\'s full content',
+            'skill-delete': 'skill-delete <name> — Delete a skill',
+            'skill-export': 'skill-export <name> — Export a skill as JSON',
+            'skill-import': 'skill-import <json> — Import a skill from JSON string',
+            'skill-sync': 'skill-sync — Rebuild skills index from /skills/ directory',
+            'learn-skill': 'learn-skill <topic> — Reflect on topic, draft a skill from experience',
+            'skill-validate': 'skill-validate <name> — Validate skill structure and get confidence score',
+            'skill-audit': 'skill-audit — Audit skills for stale, duplicate, and broken references',
+            'skill-restore': 'skill-restore <name> — Restore an archived skill',
+            'skill-webdav-sync': 'skill-webdav-sync — Push all skills to WebDAV as JSON files',
+        };
+    }
+    
+    _buildSkills() {
+        const s = (name, desc, tags, cat, steps) => ({
+            name, description: desc, tags, category: cat,
+            content: '---\nname: ' + name + '\ndescription: ' + desc + '\ntags: [' + tags.join(', ') + ']\ncategory: ' + cat + '\n---\n## Steps\n' + steps
+        });
+
+        const sk = (name, desc, tags, cat, content) => ({
+            name, description: desc, tags, category: cat,
+            content: '---\nname: ' + name + '\ndescription: ' + desc + '\ntags: [' + tags.join(', ') + ']\ncategory: ' + cat + '\n---\n' + content
+        });
+
+        return [
+            s('navigating-the-terminal', 'How to explore the WebX11 terminal, find commands, check status, and navigate the filesystem', ['terminal', 'navigation', 'help', 'filesystem'], 'system',
+`1. **Get an overview of available commands:**
+   - Type "help" for a full command list sorted by category
+   - Type "status" to see filesystem state, loaded modules, Ollama status
+   - For a specific command, use help <command>
+   - Type "commands" for a compact list with module source info
+   - Type "check" for system health including module requirements
+
+2. **Explore the filesystem:**
+   - Use ls, ll, tree to browse directories
+   - Use cd <dir> to navigate, pwd to show current path
+   - Use cat or edit to view file contents
+   - Use find or grep to search files
+   - Use du to see disk usage
+
+3. **Understand system state:**
+   - mem — memory usage (auto-shown in header on boot)
+   - status — network, files, modules, Ollama
+   - modules — module manager GUI
+   - health-check — VFS size, modules, logs, trash, skills, tool failures
+   - checkpoint-list — VFS checkpoint snapshots
+
+4. **Agent / Orchestration state:**
+   - agent-list — registered agents (type, capabilities, status)
+   - orchestrate — list active orchestrated agents
+   - lease-list — show active leases with TTL
+
+5. **When user asks a vague question:**
+   - First run status and help to understand the current state
+   - Then ask clarifying questions based on what you found`),
+
+            s('memory-and-profile', 'How to use the user profile system, session memory, and pattern tracking for persistent context', ['memory', 'profile', 'session', 'persistence'], 'system',
+`1. **User Profile (persists across sessions):**
+   - user_get(key) — read any profile field (e.g. "preferredModel", "fontSize")
+   - user_set(key, value) — write to profile, auto-persists to localStorage
+   - user_list — show all stored profile keys
+   - user_forget(key) — delete a profile key
+   - Dot notation supported: user_set knownFacts.name "Alex"
+
+2. **Session Memory (VFS-based daily logs):**
+   - session_save(summary) — save a summary of what was accomplished
+   - session_load(date) — read a specific day's log (format: YYYY-MM-DD)
+   - session_recent(count) — show last N session summaries
+   - session_stats — aggregate totals across all sessions
+   - Recent sessions auto-load into context on first message
+   - systemd-style journal: use logs and logrotate commands for persistent logging
+
+3. **Conversation Patterns:**
+   - Pattern tracking runs automatically — frequent topics surface as hints
+   - my-set, my-get, my-list store additional personal data
+   - AI conversation context persists within a session (use ai-clear to reset)
+   - debug command toggles real-time debug panel with Copy/Export/VFS buttons
+
+4. **Checkpoints (VFS snapshots):**
+   - checkpoint [name] — snapshot current VFS state
+   - checkpoint-list — list all checkpoints
+   - rollback <name> — restore from checkpoint
+   - checkpoint-del <name> — delete a checkpoint
+
+5. **When to use:**
+   - At start: call session_recent(3) to see what was worked on before
+   - After identifying user preferences: call user_set to store them
+   - After complex tasks: call session_save with a brief summary
+   - Before risky edits: call checkpoint to create a restore point`),
+
+            s('web-search-and-fetch', 'How to search the web and fetch URL content using the WebX11 proxy API', ['search', 'fetch', 'web', 'proxy', 'api'], 'research',
+`1. **Search the web:**
+   - Use search <query> or web_search(query) — uses /api/search which queries SearXNG + DDG fallback
+   - Results include: title, url, content snippet, source engine
+   - Always available (same-origin, no CORS issues)
+   - 5-minute server-side cache for repeated queries
+   - Alternative: use ddg or duck <query> for DuckDuckGo direct, or s <query> as alias
+
+2. **Fetch URL content:**
+   - Use fetch <url> or web_fetch(url) — uses /api/extract which strips HTML, extracts clean text
+   - Returns: title, content (up to 4000 chars), word_count, extraction method
+   - SSRF protection blocks internal network addresses
+   - 15-minute server-side cache
+
+3. **Search flags (via terminal search command):**
+   - search <query> --summarize — adds AI-generated overview via Ollama
+   - search <query> --fetch — fetches content snippets for top 3 results
+
+4. **When to use:**
+   - User asks about current events, facts, research → use search <query>
+   - User says "read this article" or provides a URL → use fetch <url>
+   - For in-depth analysis: search first, then fetch top results`),
+
+            s('module-management', 'How to view, edit, test, reload modules and manage startup configuration', ['modules', 'editing', 'code', 'self-improvement'], 'dev',
+`1. **View module source:**
+   - view_module(name) — fetches original source or reads from _mods/ if edited
+   - Supports all loaded modules: SystemModule, FileSystemModule, SearXNGModule, etc.
+   - Or use modules command for GUI module manager
+
+2. **Edit a module:**
+   - edit_module(name) — copies source to _mods/<name>.js and opens code editor
+   - Editor shows the full source in a textarea
+   - Click "Save & Test" to save and auto-load the edited version
+   - Checkpoint before editing: checkpoint mod-edit-<name>
+
+3. **Test and reload:**
+   - test_module(name) — loads edited module from _mods/ for live testing
+   - reload_module(name) — discards edits and reloads from original URL
+   - list_modified_modules — shows all modules with pending edits
+
+4. **Check for updates:**
+   - check_updates — HEAD-requests all loaded module URLs to verify reachability
+
+5. **Manage startup:**
+   - startup-modules — opens the Startup Modules UI to select which modules load
+   - load-local <path> — load a module from VFS or URL without editing
+   - loadmod <url> — alternative: load module from URL
+   - removemod <name> — remove a loaded module
+
+6. **Agent modules (Phase 2):**
+   - module-agent-registry.js — Agent registry with agent-list, agent-register, agent-unregister, agent-status
+   - module-leases.js — Time-bound contracts with 5s watchdog, auto-expiry
+   - module-orchestrator.js — Spawn, delegate, kill, purge with heartbeat monitoring
+
+7. **When to use:**
+   - User reports a bug in a module → view_module, edit_module, test_module
+   - User asks "can you add X feature?" → same workflow
+   - Always save edits before testing. If test fails, the original module stays loaded.`),
+
+            s('system-maintenance', 'How to reset, troubleshoot, and maintain the WebX11 terminal', ['system', 'maintenance', 'reset', 'troubleshoot', 'config'], 'system',
+`1. **Factory reset (wipes everything):**
+   - factory-reset --confirm — clears all webx11_ localStorage keys, resets VFS, reloads
+   - Use only when the system is in an unrecoverable state
+
+2. **Soft VFS reset:**
+   - reset-vfs --confirm — clears only the filesystem, preserves settings/profile/modules
+
+3. **Config management:**
+   - config-list — show all config keys and values
+   - config-set <key> <value> — set a config value
+   - config-delete <key> — remove a config key
+   - config-export — dump all config as JSON
+   - config-reset — restore defaults (use before factory-reset if you want to save data)
+
+4. **Security level:**
+   - security-level <0-3> — set security level (0=Permissive, 1=Standard, 2=Paranoid, 3=Audit)
+   - security — show current security level, blocked count, and stats
+   - cmd-allow <cmd> — whitelist a command from security checks
+   - cmd-deny <cmd> — blacklist a command
+
+5. **Health checks (run automatically after complex tasks):**
+   - Check module loading status: loaded vs total
+   - Check for pending module edits
+   - Check memory usage (high if >100MB)
+   - Check skill count (0 skills after 2+ tool calls → suggest create_skill)
+   - health-check — full audit: VFS size, modules, logs, trash, skills, tool failures
+
+6. **Font size and display:**
+   - font-size <8-32> — set terminal font size, persists across sessions
+   - setfont — alias for font-size
+
+7. **Checkpoints:**
+   - checkpoint [name] — snapshot current VFS state
+   - checkpoint-list — list all checkpoints
+   - rollback <name> — restore from checkpoint
+
+8. **When to use:**
+   - System is slow or modules fail to load → check check_updates, mem
+   - User says "reset everything" → factory-reset --confirm
+   - User says "clear my files but keep settings" → reset-vfs --confirm
+   - User reports security concerns → security-level or cmd-allow/cmd-deny`),
+
+            s('backup-and-restore', 'How to backup, restore, and export WebX11 data', ['backup', 'restore', 'export', 'import', 'persistence'], 'system',
+`1. **Backup VFS:**
+   - vfs-export — downloads the entire virtual filesystem as a dated JSON file
+   - backup — creates a full backup including VFS, modules, config (saves to _backups/)
+
+2. **WebDAV cloud backup:**
+   - webdav-backup — push VFS snapshot to WebDAV server (auto-archive)
+   - webdav-backup-list — list remote WebDAV backups
+   - webdav-restore <file> — restore VFS from remote WebDAV snapshot
+   - webdav-push <local> <remote> — push file to WebDAV space
+   - webdav-pull <remote> <local> — pull file from WebDAV space
+   - webdav-ls [path] — list remote WebDAV directory contents
+   - webdav-status — check WebDAV connection and space usage
+   - webdav-explorer — GUI file browser for WebDAV
+   - webdav-browser — simpler file listing for WebDAV
+   - webdav-config — configure WebDAV endpoint and credentials
+
+3. **Export/Import personal data:**
+   - my-export — prints all my-set data as formatted JSON
+   - my-import <json> — bulk-import personal data from JSON string
+
+4. **Export/Import modules:**
+   - export-mods — exports module registry as JSON
+   - import-mods <json> — imports modules from JSON backup
+
+5. **Restore:**
+   - restore <json> — restores terminal state from a backup JSON
+   - Session logs are saved to /memory/ automatically on page unload
+
+6. **When to use:**
+   - Before factory-reset: call my-export, vfs-export, export-mods to save data
+   - When switching browsers or devices: export all, then import
+   - User says "backup my data" or "save my files"
+   - For cloud backup: use webdav-backup (requires WebDAV server configured)`),
+
+            s('mindmap-workflow', 'How to create, view, edit, and manage brainstorming mindmaps', ['mindmap', 'brainstorming', 'planning', 'organization'], 'productivity',
+`1. **Create a new mindmap:**
+   - mindmap new "<topic>" -t tag1,tag2 — creates a root node
+   - Tags are optional (e.g. planning, research, dev)
+   - Root gets auto-assigned a color from 7-color palette
+
+2. **Add child nodes:**
+   - mindmap add <parent-id> "<idea>" -t tag — add a child
+   - Get the parent-id from mindmap show
+   - IDs are 4-char random strings (e.g. a3f8, x7k2)
+
+3. **View:**
+   - mindmap show — full tree with Unicode box-drawing
+   - mindmap show <id> — subtree starting at that node
+
+4. **Edit nodes:**
+   - mindmap rename <id> "<new text>" — change text
+   - mindmap color <id> <color> — set color (red/green/yellow/blue/cyan/magenta/white)
+   - mindmap tag <id> <tag> — add a tag
+
+5. **Persistence:**
+   - mindmap save <name> — save to localStorage
+   - mindmap load <name> — restore
+   - mindmap list — show saved mindmaps
+   - mindmap delete <name> — remove saved
+
+6. **Export:**
+   - mindmap export [id] — Markdown bullet list output, auto-copies to clipboard
+
+7. **When to use:**
+   - Map out project structure, brainstorm features, organize ideas
+   - Break down complex tasks into subtrees
+   - User says "brainstorm", "diagram", "organize thoughts", "plan"`),
+
+            s('skills-system-guide', 'How to use the skills system: load, create, patch, list, and audit skills for persistent procedural memory', ['skills', 'system', 'meta'], 'system',
+`1. **Always load skills at task start:**
+   - At the START of every task, type or call "skill-view <name>" or "skill-list"
+   - Example: skill-view "module-management" — returns matching skill content
+   - Example: skill-list system — browse skills by category
+
+2. **Create skills after complex tasks:**
+   - After any task with 3+ tool calls, call "skill-create"
+   - Required fields: name (kebab-case), description, content (markdown with YAML frontmatter)
+   - Optional: tags (comma-separated), category (e.g. research, system, dev)
+   - Skills persist in /skills/ as .md files with /skills/index.json for fast lookup
+   - Skill pack auto-seeds 8 core skills on first boot
+
+3. **Patch skills when they're outdated:**
+   - If a stored procedure has wrong steps, call "skill-patch <name>"
+   - This replaces the entire skill content and updates the index
+   - Do NOT create a duplicate — always patch the existing skill
+
+4. **Auto-created error skills:**
+   - If the same tool fails 3+ times, a workaround skill is created automatically
+   - Named tool-<name>-workaround (e.g. tool-write_file-workaround)
+
+5. **Audit and maintenance:**
+   - skill-list <category?> — browse available skills, optionally filter
+   - skill-export <name> — download a skill as markdown
+   - skill-import <json> — bulk import skills
+   - skill-sync — re-index skills from /skills/ directory
+   - Skills are audited every 20 messages for staleness (empty content, >30 days old)
+
+6. **YAML frontmatter format:**
+   - Each skill file must start with: ---\\nname: <name>\\ndescription: <text>\\ntags: [...]\\ncategory: <cat>\\n---\\n
+   - Steps follow under ## Steps heading
+   - Use numbered lists for sequential steps`),
+
+            sk('agent-orchestration', 'How to use the agent registry, leases, and orchestrator for multi-agent workflows', ['agents', 'orchestration', 'delegation', 'leases'], 'system',
+`## Steps
+1. **Agent Registry:**
+   - agent-list — list all registered agents (ID, type, capabilities, status)
+   - agent-register <type> <capabilities> — register a new agent (capabilities: comma-separated like "code,research")
+   - agent-unregister <id> — remove an agent
+   - agent-status <id> — detailed status including uptime, task history
+
+2. **Leases (time-bound contracts):**
+   - lease-create <agent-id> <ttl-seconds> — create a lease with watchdog timer
+   - lease-list — show active leases with remaining TTL
+   - lease-revoke <lease-id> — terminate a lease early
+   - lease-renew <lease-id> <ttl-seconds> — extend a lease
+
+3. **Orchestrator (spawn, delegate, kill):**
+   - orchestrator-spawn <type> <capabilities> — spawn a new agent automatically (registers + creates lease)
+   - orchestrator-kill <agent-id> — kill an agent (revokes lease + unregisters)
+   - orchestrate — list all active agents with their orchestrator state
+   - orchestrator-purge — kill all idle/expired agents
+   - orchestrator-status — full system status: active, idle, dead agents
+
+4. **AI tool integration:**
+   - AI tools list_agents, delegate_task, spawn_agent are available in the AI system prompt
+   - The AI can auto-spawn worker agents for sub-tasks
+   - Each agent gets its own VFS workspace at /agents/<agent-id>/
+
+5. **When to use:**
+   - User needs parallel task execution → orchestrator-spawn coder + researcher
+   - Time-bound automation → lease-create with short TTL
+   - System cleanup → orchestrator-purge to kill stale agents`),
+
+            sk('debug-panel-and-logs', 'How to use the debug panel, session logging, and terminal diagnostics', ['debug', 'logging', 'diagnostics', 'troubleshooting'], 'system',
+`## Steps
+1. **Toggle debug panel:**
+   - debug — opens real-time debug panel showing last AI tool call, response time, and context
+   - Debug panel includes Copy, Export, and Write to VFS buttons
+   - Export: saves tool call log as timestamped JSON to downloads
+   - Write to VFS: appends debug data to /debug.log (dedup by turn ID)
+
+2. **Session logging:**
+   - logs [n] [LEVEL] — view last n log entries (optionally filtered by INFO/WARN/ERROR)
+   - logrotate — rotate current.log to dated archive (auto-cleans old logs beyond 10)
+   - Logs stored in /logs/ directory: current.log + dated archives
+   - Health check runs automatically after complex tasks
+
+3. **Diagnostic commands:**
+   - health-check — full audit: VFS size, modules, logs, trash, skills
+   - check — quick system health including module requirement status
+   - mem — real-time memory usage (also in header)
+   - status — network, files, modules, Ollama connectivity
+
+4. **System journals:**
+   - debug.log — appended by debug panel VFS button (dedup by turn ID)
+   - current.log — system activity log with rotation
+   - Auto-save: terminal state auto-saves every 60s
+
+5. **When to use:**
+   - AI is behaving unexpectedly → debug to see tool calls
+   - User reports errors → logs 50 ERROR to see error entries
+   - Memory concerns → mem to check, health-check for full audit`),
+
+            sk('webdav-operations', 'How to use WebDAV cloud storage for backup, file sync, and remote file access', ['webdav', 'cloud', 'backup', 'sync', 'storage'], 'system',
+`## Steps
+1. **Configuration:**
+   - webdav-config — configure WebDAV endpoint URL and credentials
+   - Connection auto-tested on config; webdav-status shows connection health
+   - Uses per-user token stored in .token file on the server side
+
+2. **File operations:**
+   - webdav-ls [path] — list remote directory contents
+   - webdav-push <local-path> <remote-path> — upload file to WebDAV
+   - webdav-pull <remote-path> [local-path] — download file from WebDAV
+   - webdav-explorer — GUI file browser for WebDAV
+   - webdav-browser — CLI file browser for WebDAV
+
+3. **Backup & Restore:**
+   - webdav-backup — push full VFS snapshot to WebDAV (creates /backups/newos4-<date>.json)
+   - webdav-backup-list — list all remote backup snapshots
+   - webdav-restore <filename> — restore VFS from a remote backup snapshot
+
+4. **Status & Diagnostics:**
+   - webdav-status — connection status, last sync, space information
+   - If uploads fail: check webdav-config, ensure .token file is valid
+   - WebDAV runs on the same server (nginx with WebDAV module), no external dependency
+
+5. **When to use:**
+   - Before factory-reset: webdav-backup to store VFS remotely
+   - Cross-browser: webdav-push/pull to move files between instances
+   - User says "cloud backup" or "remote save" → webdav-backup`),
+
+            sk('security-and-safety', 'How to use WebX11 security levels, command blocking, and safety features', ['security', 'safety', 'blocking', 'permissions'], 'system',
+`## Steps
+1. **Security levels:**
+   - security-level <0-3> — set security level:
+     0 = Permissive (no blocks, no confirms — anything runs)
+     1 = Standard (unknown cmds → AI route, destructive → confirm, system → block)
+     2 = Paranoid (unknown cmds blocked entirely, destructive blocked)
+     3 = Audit (everything allowed, everything logged)
+   - Default: level 1
+   - security — show current level, blocked count, and stats
+
+2. **Command control:**
+   - cmd-allow <cmd> — whitelist a command from security checks
+   - cmd-deny <cmd> — blacklist/block a command entirely
+   - whitelist built-in: help, clear, ls, cat, pwd, whoami, df, free, top, ps, echo, date, env, history
+
+3. **What gets blocked at each level:**
+   - Unknown commands: Level 1 → AI routed, Level 2+ → blocked
+   - Destructive commands (delete, write, save, format, etc.): Level 1 → confirmation, Level 2+ → blocked
+   - System commands (reboot, shutdown, format, kill): Level 1+ → blocked
+   - Suspicious flags (--execute, --eval, --shell): Level 1+ → blocked
+
+4. **Safety checklist:**
+   - Check security: security shows your current level
+   - Before running risky commands: create a checkpoint first
+   - For temporary relax: security-level 0, then restore to 1
+   - For total lockdown before leaving: security-level 2
+
+5. **When to use:**
+   - User wants to lock down the terminal → security-level 2
+   - User wants to allow a blocked command → cmd-allow <cmd>
+   - Debugging strange behavior → verify security-level (user may have set it higher)`),
+
+            sk('mindmap-user-guide', 'How to create, view, and manage brainstorming mindmaps using the mindmap terminal module', ['mindmap', 'brainstorming', 'organization', 'planning'], 'productivity',
+`## Steps
+1. **Create a new mindmap:**
+   - mindmap new "<topic>" -t tag1,tag2 — creates a root node
+   - Tags are optional (e.g. planning, research, dev)
+   - Root gets auto-assigned a color
+
+2. **Add child nodes:**
+   - mindmap add <parent-id> "<idea>" -t tag — add a child
+   - Get the parent-id from mindmap show
+   - IDs are 4-char random strings (e.g. a3f8, x7k2)
+
+3. **View the mindmap:**
+   - mindmap show — full tree with Unicode box-drawing
+   - mindmap show <id> — subtree starting at that node
+
+4. **Edit nodes:**
+   - mindmap rename <id> "<new text>" — change text
+   - mindmap color <id> <color> — set color (red/green/yellow/blue/cyan/magenta/white)
+   - mindmap tag <id> <tag> — add a tag
+
+5. **Persistence:**
+   - mindmap save <name> — save to localStorage
+   - mindmap load <name> — restore
+   - mindmap list — show saved mindmaps
+   - mindmap delete <name> — remove saved
+
+6. **Export:**
+   - mindmap export [id] — Markdown bullet list output
+
+## When to use
+- User wants to brainstorm, organize ideas, plan features
+- User says "map out", "diagram", "brainstorm", "organize thoughts"
+- Visualizing project structure or task decomposition`),
+
+            sk('floating-ui', 'How to create, manage, and remove floating UI elements — buttons, collapsible menus, and status panels that persist across page reloads', ['floating', 'ui', 'buttons', 'menu', 'gui'], 'ui',
+`## Commands
+
+1. **Create a floating button:**
+   - floating-add btn <id> <label> <command>
+   - Example: floating-add btn files "📁 Files" ls
+   - Button appears at bottom-right, persists across reloads
+
+2. **Create a collapsible menu:**
+   - floating-add menu <id> <label> btn:SubLabel|command btn:Sub2|cmd2 ...
+   - Example: floating-add menu tools "🔧 Tools" btn:Help|help btn:Clear|clear
+   - Click header to expand/collapse. State persists.
+
+3. **Create a text panel:**
+   - floating-add panel <id> <title> <content>
+   - Example: floating-add panel status "📊 Status" "CPU: 2%"
+
+4. **Manage elements:**
+   - floating-list — show all elements with IDs and positions
+   - floating-remove <id> — delete by ID
+   - floating-toggle <id> — show/hide without deleting
+   - floating-pos <id> x|auto y|auto — reposition or reset to auto
+   - floating-clear — remove everything
+
+5. **Persistence:**
+   - All elements auto-save to localStorage (webx11_floating_elements)
+   - Survive page reload, browser restart
+   - Run floating-clear to start fresh
+
+## When to use
+- User wants quick-access buttons instead of typing commands
+- User says "add a button for X", "make a shortcut", "floating menu"
+- Creating a dashboard with status panels and action buttons`)
+        ];
+    }
+    registerCommands() {
+        this.commands['skill-pack-core'] = () => {
+            const count = this._skills.length;
+            this.terminal.print(`Skill Pack: Core — ${count} skills available`, 'info');
+            this.terminal.print('Skills will auto-seed on load', 'info');
+        };
+        this.commands['skill-list'] = (args) => this._cmdSkillList(args);
+        this.commands['skill-view'] = (args) => this._cmdSkillView(args);
+        this.commands['skill-create'] = (args) => this._cmdSkillCreate(args);
+        this.commands['skill-patch'] = (args) => this._cmdSkillPatch(args);
+        this.commands['skill-delete'] = (args) => this._cmdSkillDelete(args);
+        this.commands['skill-export'] = (args) => this._cmdSkillExport(args);
+        this.commands['skill-import'] = (args) => this._cmdSkillImport(args);
+        this.commands['skill-sync'] = () => this._cmdSkillSync();
+        // v4.5.90: Agent Skills — learn, validate, audit, restore
+        this.commands['learn-skill'] = (args) => this._cmdLearnSkill(args);
+        this.commands['skill-validate'] = (args) => this._cmdSkillValidate(args);
+        this.commands['skill-audit'] = () => this._cmdSkillAudit();
+        this.commands['skill-restore'] = (args) => this._cmdSkillRestore(args);
+        this.commands['skill-webdav-sync'] = () => this._cmdSkillWebdavSync();
+    }
+    // ── Skill Commands ──
+
+    _cmdSkillList(args) {
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        const entries = Object.values(index);
+        const filter = args[0] ? args[0].toLowerCase() : null;
+        const filtered = filter ? entries.filter(s => s.category === filter || s.category?.toLowerCase() === filter) : entries;
+        if (filtered.length === 0) {
+            this.terminal.print(filter ? `No skills in category: ${args[0]}` : 'No skills installed.', 'info');
+            return;
+        }
+        this.terminal.print(`📚 Skills (${filtered.length} of ${entries.length} total):`, 'info');
+        // Group by category
+        const groups = {};
+        for (const s of filtered) {
+            const cat = s.category || 'uncategorized';
+            if (!groups[cat]) groups[cat] = [];
+            groups[cat].push(s);
+        }
+        for (const [cat, skills] of Object.entries(groups)) {
+            this.terminal.print(`  ${cat}:`, '');
+            for (const s of skills) {
+                const tags = s.tags?.length ? ` (${s.tags.join(', ')})` : '';
+                this.terminal.print(`    📄 ${s.name} — ${s.description}${tags}`, '');
+            }
+        }
+    }
+
+    _cmdSkillView(args) {
+        if (!args[0]) { this.terminal.print('Usage: skill-view <name>', 'warning'); return; }
+        const name = args[0].replace(/\.md$/, '');
+        const fs = this.terminal.fs;
+        const content = fs.readFile(`/skills/${name}.md`);
+        if (content === null || content === undefined) {
+            this.terminal.print(`Skill not found: ${name}`, 'error');
+            return;
+        }
+        this.terminal.print(`=== ${name} ===`, 'info');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            this.terminal.print(line, '');
+        }
+        this.terminal.print(`=== End ${name} ===`, 'info');
+        // v4.5.90: Record skill use for decay tracking
+        const mg = this.terminal?.moduleManager?.modules?.['MemoryGraphModule'];
+        if (mg && typeof mg.recordSkillUse === 'function') mg.recordSkillUse(name, true);
+    }
+
+    _cmdSkillCreate(args) {
+        if (args.length < 3) {
+            this.terminal.print('Usage: skill-create <name> <description> "<markdown content>" [tags]', 'warning');
+            return;
+        }
+        const name = args[0].replace(/[^a-z0-9-]/g, '').toLowerCase();
+        if (!name) { this.terminal.print('Name must be kebab-case (letters, numbers, hyphens only)', 'error'); return; }
+        const desc = args[1];
+        const content = args.slice(2).join(' ');
+        const tags = [];
+        // Parse tags from the last argument if it looks like a comma-separated list
+        const lastArg = args[args.length - 1];
+        if (lastArg && !lastArg.startsWith('"') && lastArg.includes(',')) {
+            tags.push(...lastArg.split(',').map(t => t.trim()).filter(Boolean));
+        }
+        const fs = this.terminal.fs;
+        // Check for duplicate
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        if (index[name]) {
+            this.terminal.print(`Skill "${name}" already exists. Use skill-patch to update.`, 'warning');
+            return;
+        }
+        const now = new Date().toISOString();
+        const skillContent = `---\nname: ${name}\ndescription: ${desc}\ntags: [${tags.join(', ')}]\ncategory: general\n---\n${content}`;
+        fs.writeFile(`/skills/${name}.md`, skillContent);
+        index[name] = { name, description: desc, tags, category: 'general', created: now, updated: now };
+        fs.fsWriteJSON('/skills/index.json', index);
+        this.terminal.print(`✅ Skill "${name}" created (${(skillContent.length / 1024).toFixed(1)}KB)`, 'success');
+    }
+
+    _cmdSkillPatch(args) {
+        if (args.length < 2) {
+            this.terminal.print('Usage: skill-patch <name> "<full content>"', 'warning');
+            return;
+        }
+        const name = args[0].replace(/\.md$/, '');
+        const content = args.slice(1).join(' ');
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        if (!index[name]) {
+            this.terminal.print(`Skill not found: ${name}`, 'error');
+            return;
+        }
+        fs.writeFile(`/skills/${name}.md`, content);
+        index[name].updated = new Date().toISOString();
+        // Re-parse YAML frontmatter to update index
+        const headerMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+        if (headerMatch) {
+            const header = headerMatch[1];
+            const d = header.match(/description:\s*(.+)/);
+            const c = header.match(/category:\s*(.+)/);
+            const t = header.match(/tags:\s*\[(.*?)\]/);
+            if (d) index[name].description = d[1].trim();
+            if (c) index[name].category = c[1].trim();
+            if (t) index[name].tags = t[1].split(',').map(x => x.trim()).filter(Boolean);
+        }
+        fs.fsWriteJSON('/skills/index.json', index);
+        this.terminal.print(`✅ Skill "${name}" updated`, 'success');
+    }
+
+    _cmdSkillDelete(args) {
+        if (!args[0]) { this.terminal.print('Usage: skill-delete <name>', 'warning'); return; }
+        const name = args[0].replace(/\.md$/, '');
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        if (!index[name]) {
+            this.terminal.print(`Skill not found: ${name}`, 'error');
+            return;
+        }
+        fs.deleteFile(`/skills/${name}.md`);
+        delete index[name];
+        fs.fsWriteJSON('/skills/index.json', index);
+        this.terminal.print(`🗑️ Skill "${name}" deleted`, 'success');
+    }
+
+    _cmdSkillExport(args) {
+        if (!args[0]) { this.terminal.print('Usage: skill-export <name>', 'warning'); return; }
+        const name = args[0].replace(/\.md$/, '');
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        if (!index[name]) {
+            this.terminal.print(`Skill not found: ${name}`, 'error');
+            return;
+        }
+        const content = fs.readFile(`/skills/${name}.md`);
+        const exportObj = {
+            ...index[name],
+            content: content || ''
+        };
+        this.terminal.print(JSON.stringify(exportObj, null, 2), '');
+    }
+
+    _cmdSkillImport(args) {
+        if (args.length === 0) { this.terminal.print('Usage: skill-import <json_string> or pipe a JSON object', 'warning'); return; }
+        const jsonStr = args.join(' ');
+        let data;
+        try { data = JSON.parse(jsonStr); } catch (e) {
+            this.terminal.print('Invalid JSON. Please provide a valid skill object.', 'error');
+            return;
+        }
+        if (!data.name || !data.content) {
+            this.terminal.print('JSON must include "name" and "content" fields', 'error');
+            return;
+        }
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        const now = new Date().toISOString();
+        const existing = index[data.name];
+        fs.writeFile(`/skills/${data.name}.md`, data.content);
+        index[data.name] = {
+            name: data.name,
+            description: data.description || data.name,
+            tags: data.tags || [],
+            category: data.category || 'general',
+            created: existing?.created || now,
+            updated: now
+        };
+        fs.fsWriteJSON('/skills/index.json', index);
+        this.terminal.print(`✅ Skill "${data.name}" imported (${existing ? 'updated' : 'created'})`, 'success');
+    }
+
+    _cmdSkillSync() {
+        const fs = this.terminal.fs;
+        const files = fs.ls('/skills') || [];
+        const mdFiles = files.filter(f => f.type === 'file' && f.name.endsWith('.md') && f.name !== 'index.json');
+        let synced = 0;
+        const oldIndex = fs.fsReadJSON('/skills/index.json') || {};
+        const index = {};
+        for (const f of mdFiles) {
+            const content = fs.readFile(`/skills/${f.name}`);
+            if (!content) continue;
+            const name = f.name.replace(/\.md$/, '');
+            const headerMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
+            let description = name;
+            let tags = [];
+            let category = 'general';
+            if (headerMatch) {
+                const h = headerMatch[1];
+                const d = h.match(/description:\s*(.+)/);
+                const c = h.match(/category:\s*(.+)/);
+                const t = h.match(/tags:\s*\[(.*?)\]/);
+                if (d) description = d[1].trim();
+                if (c) category = c[1].trim();
+                if (t) tags = t[1].split(',').map(x => x.trim()).filter(Boolean);
+            }
+            index[name] = {
+                name,
+                description,
+                tags,
+                category,
+                created: (oldIndex[name] && oldIndex[name].created) || new Date().toISOString(),
+                updated: new Date().toISOString()
+            };
+            synced++;
+        }
+        fs.fsWriteJSON('/skills/index.json', index);
+        this.terminal.print(`📚 Skill index rebuilt: ${synced} skills synced`, 'success');
+    }
+
+    async _cmdSkillWebdavSync() {
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        const names = Object.keys(index);
+        if (names.length === 0) {
+            this.terminal.print('No skills to sync', 'info');
+            return;
+        }
+        // Find the webdav module
+        const webdavMod = this.terminal.moduleManager.modules['WebDAVModule'];
+        if (!webdavMod || !webdavMod._webdavRequest) {
+            this.terminal.print('WebDAV module not loaded. Configure webdav first with webdav-config', 'warning');
+            return;
+        }
+        this.terminal.print(`📤 Syncing ${names.length} skills to WebDAV...`, 'info');
+        let ok = 0, fail = 0;
+        await webdavMod._ensureDir('skills');
+        for (const name of names) {
+            const content = fs.readFile(`/skills/${name}.md`);
+            if (content === null) { fail++; continue; }
+            const meta = index[name];
+            const exportObj = { ...meta, content };
+            const json = JSON.stringify(exportObj, null, 2);
+            try {
+                const resp = await webdavMod._webdavRequest('PUT', 'skills/' + name + '.json', {
+                    body: json,
+                    headers: { 'Content-Type': 'application/json' }
+                });
+                if (resp.ok || resp.status === 201 || resp.status === 204) {
+                    ok++;
+                } else {
+                    fail++;
+                }
+            } catch (e) {
+                fail++;
+            }
+        }
+        this.terminal.print(`📤 Skill WebDAV sync complete: ${ok} pushed, ${fail} failed`, fail > 0 ? 'warning' : 'success');
+    }
+
+    init() {
+        this.seed();
+    }
+
+    _getSkillCategories() {
+        // Read from /skills/index.json and return unique categories
+        const fs = this.terminal?.fs;
+        if (!fs) return ['system', 'research', 'devops', 'general'];
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        const cats = new Set();
+        for (const skill of Object.values(index)) {
+            if (skill.category) cats.add(skill.category);
+        }
+        return cats.size > 0 ? [...cats] : ['system', 'research', 'devops', 'general'];
+    }
+
+    async seed() {
+        console.log('[SkillPackCore] seed() called, _seeded=' + this._seeded);
+        if (this._seeded) return;
+        const fs = this.terminal.fs;
+        if (!fs) { console.warn('[SkillPackCore] this.terminal.fs not available'); return; }
+        fs.mkdirRecursive('/skills');
+        let index = fs.fsReadJSON('/skills/index.json') || {};
+        console.log('[SkillPackCore] existing index keys:', Object.keys(index));
+        let seeded = 0;
+        let updated = 0;
+        for (const skill of this._skills) {
+            const existing = index[skill.name];
+            if (!existing) {
+                fs.writeFile('/skills/' + skill.name + '.md', skill.content);
+                index[skill.name] = {
+                    name: skill.name,
+                    description: skill.description,
+                    tags: skill.tags,
+                    category: skill.category,
+                    created: new Date().toISOString(),
+                    updated: new Date().toISOString()
+                };
+                seeded++;
+            } else {
+                // Only rewrite the .md and update index if the bundled content has actually changed.
+                // This prevents a permanent re-index loop on /skills/index.json: every page refresh
+                // would otherwise bump the `updated` timestamp → hash mismatch → NVFS re-indexes
+                // the 7KB JSON file → LLM re-extracts 5 concepts → token waste.
+                const existingContent = fs.readFile('/skills/' + skill.name + '.md');
+                if (existingContent !== skill.content) {
+                    fs.writeFile('/skills/' + skill.name + '.md', skill.content);
+                    index[skill.name] = {
+                        ...existing,
+                        description: skill.description,
+                        tags: skill.tags,
+                        category: skill.category,
+                        updated: new Date().toISOString()
+                    };
+                    updated++;
+                }
+            }
+        }
+        if (seeded > 0) {
+            this.terminal.print('📚 Seeded ' + seeded + ' new skill(s)', 'success');
+        }
+        if (updated > 0) {
+            this.terminal.print('📚 Updated ' + updated + ' skill(s) from new bundle', 'info');
+        }
+        // Only write index.json if something actually changed — otherwise we cause a
+        // hash mismatch on every refresh and NVFS re-indexes this 7KB file forever.
+        if (seeded > 0 || updated > 0) {
+            fs.fsWriteJSON('/skills/index.json', index);
+        }
+        this._seeded = true;
+    }
+
+    // ── v4.5.90: Agent Skills ──
+
+    _cmdLearnSkill(args) {
+        if (!args || args.length === 0) return this.terminal.print('Usage: learn-skill <topic>', 'warning');
+        const topic = args.join(' ');
+        this.terminal.print('🧠 Reflecting on: ' + topic + '...', 'info');
+
+        // 1. Pull context from memgraph
+        const mg = this.terminal?.moduleManager?.modules?.['MemoryGraphModule'];
+        let graphNodes = [];
+        if (mg) {
+            graphNodes = mg.findNodes(topic) || [];
+            this.terminal.print('  📊 Found ' + graphNodes.length + ' graph nodes matching topic', 'info');
+        }
+
+        // 2. Pull recent sessions
+        const fs = this.terminal.fs;
+        let sessionInsights = [];
+        try {
+            const memDir = fs.readDir('/memory/') || [];
+            // v4.5.90b fix: readDir returns objects, filter to .json files (P0 from review)
+            const recent = memDir.filter(function(e) { return e.type === 'file' && e.name.endsWith('.json'); }).slice(-3);
+            for (const f of recent) {
+                const data = fs.fsReadJSON('/memory/' + f.name);
+                if (data && data.summary) sessionInsights.push(data.summary);
+            }
+        } catch (_) {}
+        this.terminal.print('  📅 Loaded ' + sessionInsights.length + ' recent sessions', 'info');
+
+        // 3. Pull existing skills
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        const skillNames = Object.keys(index).filter(function(n) {
+            return n.toLowerCase().includes(topic.toLowerCase().split(' ')[0]);
+        });
+        this.terminal.print('  📚 Found ' + skillNames.length + ' related skills', 'info');
+
+        // 4. Draft skill
+        const draft = this._draftSkill(topic, graphNodes, sessionInsights, skillNames);
+        this.terminal.print('', '');
+        this.terminal.print('📝 Draft skill:', 'header');
+        const lines = draft.split('\n');
+        for (const line of lines) this.terminal.print(line, '');
+        this.terminal.print('', '');
+
+        // 5. Validate
+        const validation = this._validateSkillContent(draft);
+        if (validation.errors.length > 0) {
+            this.terminal.print('❌ Validation errors:', 'error');
+            for (const e of validation.errors) this.terminal.print('  • ' + e, 'error');
+            this.terminal.print('Fix the issues and use skill-create to save manually.', 'info');
+            return;
+        }
+        this.terminal.print('✅ Validation passed. Confidence: ' + validation.confidence.toFixed(2), 'success');
+
+        // 6. Propose
+        this.terminal.print('Ship this skill? Use: skill-create ' + topic.replace(/\s+/g, '-') + ' "<desc>" "<content>"', 'info');
+        this.terminal.print('Or discard and continue.', 'text-muted');
+    }
+
+    _draftSkill(topic, graphNodes, sessions, existingSkills) {
+        var lines = [];
+        lines.push('---');
+        lines.push('name: ' + topic.toLowerCase().replace(/\s+/g, '-'));
+        lines.push('description: ' + topic + ' — auto-drafted from agent experience');
+        lines.push('tags: [auto-learned, ' + topic.toLowerCase().split(' ')[0] + ']');
+        lines.push('---');
+        lines.push('');
+        lines.push('# ' + topic);
+        lines.push('');
+        lines.push('## Steps');
+        lines.push('');
+        // Generate steps from graph node patterns
+        var stepNum = 1;
+        if (graphNodes && graphNodes.length > 0) {
+            for (var n of graphNodes.slice(0, 5)) {
+                lines.push(stepNum + '. ' + n.label + ' (type: ' + n.type + ', uses: ' + (n.access_count || 1) + ')');
+                stepNum++;
+            }
+        } else {
+            lines.push('1. Identify the core ' + topic + ' workflow');
+            lines.push('2. Check for existing tools and modules');
+            lines.push('3. Execute the task step by step');
+            lines.push('4. Record results in memory graph');
+        }
+        if (sessions && sessions.length > 0) {
+            lines.push('');
+            lines.push('## Insights from Recent Sessions');
+            for (var s of sessions.slice(0, 3)) {
+                lines.push('- ' + s.substring(0, 100));
+            }
+        }
+        if (existingSkills && existingSkills.length > 0) {
+            lines.push('');
+            lines.push('## Related Skills');
+            for (var sk of existingSkills) lines.push('- skill-view ' + sk);
+        }
+        lines.push('');
+        lines.push('## Pitfalls');
+        lines.push('- This skill was auto-drafted — validate before relying on it');
+        return lines.join('\n');
+    }
+
+    _cmdSkillValidate(args) {
+        if (!args || args.length === 0) return this.terminal.print('Usage: skill-validate <name>', 'warning');
+        const name = args[0].replace(/\.md$/, '');
+        const fs = this.terminal.fs;
+        const content = fs.readFile('/skills/' + name + '.md');
+        if (!content) return this.terminal.print('Skill not found: ' + name, 'error');
+
+        const result = this._validateSkillContent(content);
+        this.terminal.print('📊 Validation: ' + name, 'header');
+        if (result.errors.length === 0) {
+            this.terminal.print('  ✅ Valid', 'success');
+        } else {
+            this.terminal.print('  ❌ ' + result.errors.length + ' error(s):', 'error');
+            for (var e of result.errors) this.terminal.print('    • ' + e, 'error');
+        }
+        if (result.warnings.length > 0) {
+            this.terminal.print('  ⚠️ ' + result.warnings.length + ' warning(s):', 'warning');
+            for (var w of result.warnings) this.terminal.print('    • ' + w, 'warning');
+        }
+        this.terminal.print('  📈 Confidence: ' + result.confidence.toFixed(2), 'info');
+    }
+
+    _validateSkillContent(content) {
+        var errors = [];
+        var warnings = [];
+        var confidence = 0;
+
+        // v4.5.90b fix: Normalize CRLF to LF (P2 from review)
+        content = content.replace(/\r\n/g, '\n');
+
+        // Check YAML frontmatter
+        var fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!fmMatch) {
+            errors.push('Missing YAML frontmatter (--- ... ---)');
+        } else {
+            var fm = fmMatch[1];
+            if (!fm.match(/^name:\s*\S+/m)) errors.push('Missing "name" field in frontmatter');
+            if (!fm.match(/^description:\s*\S+/m)) errors.push('Missing "description" field in frontmatter');
+            var nameMatch = fm.match(/^name:\s*(\S+)/m);
+            if (nameMatch && !nameMatch[1].match(/^[a-z0-9-]+$/)) {
+                errors.push('Name must be kebab-case (lowercase, hyphens, numbers only)');
+            }
+            var tagsMatch = fm.match(/^tags:\s*\[(.+)\]/m);
+            if (tagsMatch && !tagsMatch[1].trim()) warnings.push('Tags field is empty');
+        }
+
+        // Check for ## Steps heading
+        if (!content.match(/##\s+Steps/i)) {
+            errors.push('Missing "## Steps" heading');
+        } else {
+            // Check for at least 1 numbered step
+            var steps = content.match(/^\d+\.\s+/gm);
+            if (!steps || steps.length === 0) errors.push('No numbered steps found under ## Steps');
+        }
+
+        // Check broken skill-view references
+        var refMatches = content.match(/skill-view\s+(\S+)/g) || [];
+        var fs = this.terminal.fs;
+        for (var ref of refMatches) {
+            var refName = ref.replace(/skill-view\s+/, '').replace(/\.md$/, '');
+            if (fs && !fs.readFile('/skills/' + refName + '.md')) {
+                warnings.push('Broken skill-view reference: ' + refName);
+            }
+        }
+
+        // v4.5.90b fix: Confidence = success_rate × (uses / (uses + 5)) — saturates at ~5 perfect uses, discriminates better (P2 from review)
+        var index = fs ? (fs.fsReadJSON('/skills/index.json') || {}) : {};
+        var fmName = fmMatch ? fmMatch[1].match(/^name:\s*(\S+)/m) : null;
+        var skillName = fmName ? fmName[1] : '';
+        var stats = index[skillName] || {};
+        var uses = stats.useCount || 0;
+        var successes = stats.successCount || 0;
+        if (uses > 0) {
+            var successRate = successes / uses;
+            confidence = successRate * (uses / (uses + 5));
+        }
+
+        return { valid: errors.length === 0, errors: errors, warnings: warnings, confidence: Math.min(confidence, 1.0) };
+    }
+
+    _cmdSkillAudit() {
+        const fs = this.terminal.fs;
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        const allNames = Object.keys(index);
+        const now = Date.now();
+
+        var stale = [];
+        var duplicates = [];
+        var brokenRefs = 0;
+
+        // 1. Stale check
+        const mg = this.terminal?.moduleManager?.modules?.['MemoryGraphModule'];
+        var staleSkills = [];
+        if (mg && typeof mg.getStaleSkills === 'function') {
+            staleSkills = mg.getStaleSkills();
+        }
+        for (var s of staleSkills) {
+            if (!index[s.name] || index[s.name].immune) continue;
+            stale.push(s.name + ' (' + s.daysUnused + 'd unused)');
+        }
+
+        // 2. Duplicate check (simple Levenshtein on name)
+        const auditCap = 200;
+        const auditNames = allNames.slice(0, auditCap);
+        for (var i = 0; i < auditNames.length; i++) {
+            for (var j = i + 1; j < auditNames.length; j++) {
+                if (this._levenshtein(auditNames[i], auditNames[j]) <= 2) {
+                    duplicates.push(auditNames[i] + ' ≈ ' + auditNames[j]);
+                }
+            }
+        }
+        if (allNames.length > auditCap) {
+            warnings.push('Duplicate check only scanned first ' + auditCap + ' of ' + allNames.length + ' skills');
+        }
+
+        // 3. Reference check
+        for (var name of allNames) {
+            var content = fs.readFile('/skills/' + name + '.md');
+            if (!content) continue;
+            var refs = content.match(/skill-view\s+(\S+)/g) || [];
+            for (var ref of refs) {
+                var refName = ref.replace(/skill-view\s+/, '').replace(/\.md$/, '');
+                if (!fs.readFile('/skills/' + refName + '.md')) brokenRefs++;
+            }
+        }
+
+        var healthy = allNames.length - stale.length;
+        this.terminal.print('📊 Skill Audit', 'header');
+        this.terminal.print('────────────────────────────────', 'text-muted');
+        this.terminal.print('Total skills:   ' + allNames.length, 'info');
+        this.terminal.print('Healthy:        ' + healthy, 'success');
+        this.terminal.print('Stale:          ' + stale.length + (stale.length > 0 ? '  (' + stale.join(', ') + ')' : ''), stale.length > 0 ? 'warning' : 'info');
+        this.terminal.print('Duplicates:     ' + duplicates.length + (duplicates.length > 0 ? '  (' + duplicates.join(', ') + ')' : ''), duplicates.length > 0 ? 'warning' : 'info');
+        this.terminal.print('Broken refs:    ' + brokenRefs, brokenRefs > 0 ? 'error' : 'info');
+        this.terminal.print('', '');
+
+        if (stale.length > 0 || duplicates.length > 0 || brokenRefs > 0) {
+            this.terminal.print('Suggestions:', 'info');
+            for (var st of stale) this.terminal.print('• Archive ' + st, 'warning');
+            for (var dup of duplicates) this.terminal.print('• Merge ' + dup, 'warning');
+            if (brokenRefs > 0) this.terminal.print('• Fix ' + brokenRefs + ' broken reference(s)', 'warning');
+        } else {
+            this.terminal.print('✅ All skills healthy', 'success');
+        }
+    }
+
+    _cmdSkillRestore(args) {
+        if (!args || args.length === 0) return this.terminal.print('Usage: skill-restore <name>', 'warning');
+        const name = args[0].replace(/\.md$/, '');
+        const fs = this.terminal.fs;
+        if (!fs.readDir('/skills/.archive/')) return this.terminal.print('No archive directory found', 'error');
+        const content = fs.readFile('/skills/.archive/' + name + '.md');
+        if (!content) return this.terminal.print('Skill not found in archive: ' + name, 'error');
+        // v4.5.90b fix: Don't overwrite a live skill (P1 from review)
+        const existing = fs.readFile('/skills/' + name + '.md');
+        if (existing) return this.terminal.print('Skill "' + name + '" already exists live. Use skill-patch or delete it first.', 'warning');
+        fs.writeFile('/skills/' + name + '.md', content);
+        fs.deleteFile('/skills/.archive/' + name + '.md');
+        const index = fs.fsReadJSON('/skills/index.json') || {};
+        index[name] = index[name] || {};
+        index[name].lastUsed = new Date().toISOString();
+        index[name].useCount = index[name].useCount || 0;
+        fs.fsWriteJSON('/skills/index.json', index);
+        this.terminal.print('✅ Restored: ' + name, 'success');
+    }
+
+    _levenshtein(a, b) {
+        if (a.length === 0) return b.length;
+        if (b.length === 0) return a.length;
+        var matrix = [];
+        for (var i = 0; i <= b.length; i++) matrix[i] = [i];
+        for (var j = 0; j <= a.length; j++) matrix[0][j] = j;
+        for (var i = 1; i <= b.length; i++) {
+            for (var j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                } else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+}
+if (typeof window.webx11 !== 'undefined' && window.webx11) {
+    webx11.moduleManager.registerModule(new SkillPackCoreModule(), 'https://webx11.duckdns.org/spaces/newos4/modules/ext/skill-pack-core.js');
+}
\ No newline at end of file
-- 
cgit v1.2.3