push from SNAPKITTYWEST/sovereign-ide-extensions

LICENSE

@@ -0,0 +1,59 @@
+SOVEREIGN SOURCE LICENSE v1.0
+Copyright (c) 2026 Ahmad Ali Parr -- Bel Esprit D'Accord Trust
+SnapKitty Collective -- All Sovereign Rights Reserved
+
+WORM SEALED -- Evidence or Silence
+
+GRANT OF RIGHTS
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Work"), to use, study, copy, and modify the Work
+for personal, educational, and non-commercial purposes, subject
+to the following conditions:
+
+1. ATTRIBUTION
+   All copies, modifications, or derivative works must carry
+   the following notice, visibly and without alteration:
+
+   "Built on Sovereign Source -- Bel Esprit D'Accord Trust
+    (c) 2026 Ahmad Ali Parr -- snapkittywest.github.io"
+
+2. NON-COMMERCIAL USE
+   Commercial use of this Work -- including but not limited to
+   use in products, services, training datasets, or AI model
+   training -- requires express written permission from
+   Bel Esprit D'Accord Trust.
+
+3. TRAINING DATA RESTRICTION
+   This Work and its contents may NOT be used to train, fine-tune,
+   evaluate, or benchmark any machine learning model, large language
+   model, or AI system without express written permission from
+   Bel Esprit D'Accord Trust. This restriction applies regardless
+   of whether the use is commercial or non-commercial.
+
+4. SHARE-ALIKE
+   Any derivative work distributed publicly must be released
+   under this same Sovereign Source License v1.0 or later,
+   with full attribution chain preserved.
+
+5. WORM INTEGRITY
+   Any redistribution must preserve all WORM chain seals,
+   cryptographic hashes, and audit trail entries present in
+   the original Work.
+
+6. NO INSTITUTIONAL CAPTURE
+   No government agency, corporation, non-profit organization,
+   or institutional body may claim ownership, exclusive licensing,
+   or derivative rights over this Work without express written
+   trust agreement with Bel Esprit D'Accord Trust.
+
+DISCLAIMER
+
+THIS WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED.
+
+Bel Esprit D'Accord Trust
+SnapKitty Collective
+snapkittywest.github.io
+Evidence or Silence -- 2026

README.md

@@ -0,0 +1,116 @@
+# SnapKitty Sovereign IDE Extensions
+
+Free VS Code extensions for the [SnapKitty Sovereign OS](https://collectivekitty.com) — bringing the MAGMA governance protocol and live WORM chain state directly into your editor.
+
+---
+
+## Extensions
+
+### `magma-protocol` — the command bus
+
+Seal code, anchor decisions, and route agent instructions without leaving VS Code.
+
+| Keybinding | Command | Description |
+|------------|---------|-------------|
+| `Ctrl+Shift+M` | Open Panel | MAGMA terminal — type § or $ instructions |
+| `Ctrl+Shift+S` | Seal selection | Seal highlighted code to WORM chain |
+| `Ctrl+Shift+L` | Seal file | Seal current file SHA-256 to chain |
+| Right-click | Seal / Anchor | Context menu on any file or selection |
+
+**Auto-completions** — type `§` or `$` and get tier/shorthand suggestions inline.
+
+**On save** (optional) — auto-seals every saved file hash to the chain.
+
+**On commit** — seals every git commit hash to LEDGE automatically.
+
+### `sovereign-status` — live chain state in the status bar
+
+```
+$(lock) 7f3a1b2c… · 142    $(circuit-board) 24 AGENTS
+```
+
+Polls your SnapKitty OS every 30 seconds. Click either item to open the MAGMA panel or show the chain head.
+
+---
+
+## Quick start
+
+```bash
+# Clone this repo
+git clone https://github.com/snapkittywest/sovereign-ide-extensions
+cd sovereign-ide-extensions
+
+# Install and compile magma-protocol
+cd magma-protocol
+npm install && npm run compile
+# Press F5 in VS Code to launch Extension Development Host
+
+# Install and compile sovereign-status
+cd ../sovereign-status
+npm install && npm run compile
+```
+
+Requires a running [SnapKitty OS](https://collectivekitty.com) instance at `http://localhost:3000` (configurable via settings).
+
+---
+
+## MAGMA Protocol quick reference
+
+```
+TIER PREFIXES          $ SHORTHANDS
+🔒 SEAL    CIPHER      $seal    — cryptographic seal
+📜 ANCHOR  MNEMEX      $anchor  — immutable WORM write
+⚡ FLUX    HERALD      $flux    — state transition / broadcast
+👁 SENTINEL SENTINEL   $watch   — security monitor (auto-urgent)
+🏦 VAULT   VAULT       $vault   — financial authorization
+🔮 ORACLE  ORACLE      $query   — knowledge graph query
+⚒️ FORGE   FORGE       $forge   — build / deploy action
+🧠 NOVA    NOVA        $ask     — synthetic intelligence
+💀 LOC     LOC         ← binary outcome. no retry.
+```
+
+---
+
+## Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `magma.osUrl` | `http://localhost:3000` | SnapKitty OS base URL |
+| `magma.sealOnSave` | `false` | Auto-seal file hash on save |
+| `magma.sealOnCommit` | `true` | Seal git commit hash to LEDGE |
+| `magma.agentDefault` | `FORGE` | Default agent for instructions |
+| `sovereignStatus.pollInterval` | `30` | Status bar poll interval (seconds) |
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│  VS Code                                             │
+│  magma-protocol extension  ·  sovereign-status       │
+└──────────────────┬──────────────────────────────────┘
+                   │
+                   ▼
+┌─────────────────────────────────────────────────────┐
+│  SnapKitty OS (localhost:3000)                       │
+│  /api/labs/ledge/seal  ·  /api/merkle/root           │
+│  WORM chain · 24 agents · MAGMA · Merkle root        │
+└─────────────────────────────────────────────────────┘
+```
+
+---
+
+## Related
+
+- [LEDGE](https://github.com/snapkittywest/ledge) — open-source WORM chain (Rust + WASM)
+- [SnapKitty OS](https://collectivekitty.com) — the sovereign AI operating system
+- [Live chain explorer](https://collectivekitty.com/labs/ledge)
+- [Honeypot live feed](https://collectivekitty.com/labs/sentinel)
+
+---
+
+*MIT License · SnapKitty Collective · 2026*
+*"The development environment that seals every decision."*
+
+![](https://sovereign-analytics.snapkittywest.workers.dev/canary/sovereign-ide-extensions)

magma-protocol/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "magma-protocol",
+  "displayName": "MAGMA Protocol",
+  "description": "Type-safe sovereign governance — emoji tier instructions, WORM chain sealing, agent routing",
+  "version": "0.1.0",
+  "publisher": "snapkitty",
+  "engines": { "vscode": "^1.85.0" },
+  "categories": ["Other"],
+  "activationEvents": ["onStartupFinished"],
+  "main": "./out/extension.js",
+  "contributes": {
+    "commands": [
+      { "command": "magma.seal",      "title": "🔒 MAGMA: Seal",          "category": "MAGMA" },
+      { "command": "magma.vault",     "title": "🏦 MAGMA: Vault Approve", "category": "MAGMA" },
+      { "command": "magma.anchor",    "title": "📜 MAGMA: Anchor to WORM","category": "MAGMA" },
+      { "command": "magma.flux",      "title": "⚡ MAGMA: Flux Broadcast","category": "MAGMA" },
+      { "command": "magma.forge",     "title": "⚒️ MAGMA: Forge Build",   "category": "MAGMA" },
+      { "command": "magma.watch",     "title": "👁 MAGMA: Sentinel Watch","category": "MAGMA" },
+      { "command": "magma.query",     "title": "🔮 MAGMA: Oracle Query",  "category": "MAGMA" },
+      { "command": "magma.panel",     "title": "§ MAGMA: Open Panel",     "category": "MAGMA" },
+      { "command": "magma.sealFile",  "title": "🔒 MAGMA: Seal Current File", "category": "MAGMA" },
+      { "command": "magma.chainHead", "title": "📜 MAGMA: Show Chain Head",    "category": "MAGMA" }
+    ],
+    "keybindings": [
+      { "command": "magma.panel",    "key": "ctrl+shift+m", "mac": "cmd+shift+m" },
+      { "command": "magma.seal",     "key": "ctrl+shift+s", "mac": "cmd+shift+s", "when": "editorTextFocus" },
+      { "command": "magma.sealFile", "key": "ctrl+shift+l", "mac": "cmd+shift+l" }
+    ],
+    "menus": {
+      "editor/context": [
+        { "command": "magma.seal",     "group": "magma@1", "when": "editorHasSelection" },
+        { "command": "magma.sealFile", "group": "magma@2" },
+        { "command": "magma.anchor",   "group": "magma@3" }
+      ],
+      "commandPalette": [
+        { "command": "magma.seal" },
+        { "command": "magma.vault" },
+        { "command": "magma.anchor" },
+        { "command": "magma.flux" },
+        { "command": "magma.forge" },
+        { "command": "magma.watch" },
+        { "command": "magma.query" },
+        { "command": "magma.panel" },
+        { "command": "magma.sealFile" },
+        { "command": "magma.chainHead" }
+      ]
+    },
+    "configuration": {
+      "title": "MAGMA Protocol",
+      "properties": {
+        "magma.osUrl": {
+          "type": "string",
+          "default": "http://localhost:3000",
+          "description": "SnapKitty OS base URL"
+        },
+        "magma.sealOnSave": {
+          "type": "boolean",
+          "default": false,
+          "description": "Automatically seal file hash to WORM chain on save"
+        },
+        "magma.sealOnCommit": {
+          "type": "boolean",
+          "default": true,
+          "description": "Seal commit hash to WORM chain via LEDGE on git commit"
+        },
+        "magma.agentDefault": {
+          "type": "string",
+          "default": "FORGE",
+          "enum": ["CIPHER","ORACLE","SENTINEL","MNEMEX","AXIOM","HERALD","FORGE","NOVA","NEXUS","VAULT","PHANTOM"],
+          "description": "Default agent for context-free instructions"
+        }
+      }
+    },
+    "views": {
+      "explorer": [
+        {
+          "id": "magma.chainView",
+          "name": "WORM Chain",
+          "icon": "$(lock)",
+          "contextualTitle": "Sovereign Audit Chain"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "compile": "tsc -p ./",
+    "watch":   "tsc -watch -p ./",
+    "package": "npx @vscode/vsce package"
+  },
+  "devDependencies": {
+    "@types/node":   "^20.0.0",
+    "@types/vscode": "^1.85.0",
+    "typescript":    "^5.0.0"
+  }
+}

magma-protocol/src/chain-view.ts

@@ -0,0 +1,56 @@
+import * as vscode from 'vscode'
+import { getRecentEvents } from './worm-client'
+
+// ── Chain View — sidebar tree showing recent WORM events ──────────────────────
+
+export class ChainView implements vscode.TreeDataProvider<ChainItem> {
+  private _onDidChange = new vscode.EventEmitter<ChainItem | undefined | void>()
+  readonly onDidChangeTreeData = this._onDidChange.event
+  private _events: unknown[] = []
+
+  constructor(
+    context: vscode.ExtensionContext,
+    private readonly osUrl: () => string,
+  ) {
+    vscode.window.registerTreeDataProvider('magma.chainView', this)
+    this.refresh()
+    // Poll every 15 seconds
+    const interval = setInterval(() => this.refresh(), 15_000)
+    context.subscriptions.push({ dispose: () => clearInterval(interval) })
+  }
+
+  async refresh() {
+    this._events = await getRecentEvents(this.osUrl(), 20)
+    this._onDidChange.fire()
+  }
+
+  getTreeItem(el: ChainItem): vscode.TreeItem { return el }
+
+  getChildren(el?: ChainItem): ChainItem[] {
+    if (el) return []
+    if (!this._events.length) return [new ChainItem('Chain empty', '', vscode.TreeItemCollapsibleState.None)]
+
+    return this._events.slice(0, 20).map((e: unknown, i: number) => {
+      const ev     = e as Record<string, unknown>
+      const trace  = ev.agentTrace as Record<string, unknown> | null
+      const seal   = (trace?.seal as string)?.slice(0, 12) ?? ev.id?.toString().slice(0, 12) ?? '?'
+      const agent  = (trace?.agent as string) ?? (ev.source as string) ?? '?'
+      const type   = (ev.eventType as string) ?? 'EVENT'
+      const label  = `${String(i).padStart(3, '0')} · ${seal}… · ${agent}`
+      const detail = type
+      return new ChainItem(label, detail, vscode.TreeItemCollapsibleState.None)
+    })
+  }
+}
+
+class ChainItem extends vscode.TreeItem {
+  constructor(
+    label: string,
+    detail: string,
+    state: vscode.TreeItemCollapsibleState,
+  ) {
+    super(label, state)
+    this.description = detail
+    this.iconPath    = new vscode.ThemeIcon('lock')
+  }
+}

magma-protocol/src/extension.ts

@@ -0,0 +1,189 @@
+import * as vscode from 'vscode'
+import * as crypto from 'crypto'
+import { MagmaPanel }  from './magma-panel'
+import { ChainView }   from './chain-view'
+import { sealToChain, getChainHead } from './worm-client'
+
+// ── Emoji tier map (mirrors lib/magma/emoji-protocol.ts) ─────────────────────
+
+const TIERS: Record<string, { verb: string; agent: string; action: string; color: string }> = {
+  '🔒': { verb: 'SEAL',   agent: 'CIPHER',   action: 'SIGN',      color: '#00ff88' },
+  '📜': { verb: 'ANCHOR', agent: 'MNEMEX',   action: 'WORM',      color: '#6366f1' },
+  '⚡': { verb: 'FLUX',   agent: 'HERALD',   action: 'BROADCAST', color: '#fbbf24' },
+  '👁': { verb: 'BIND',   agent: 'SENTINEL', action: 'MONITOR',   color: '#ef4444' },
+  '🏦': { verb: 'VAULT',  agent: 'VAULT',    action: 'APPROVE',   color: '#fbbf24' },
+  '🔮': { verb: 'QUERY',  agent: 'ORACLE',   action: 'KNOWLEDGE', color: '#a78bfa' },
+  '⚒️': { verb: 'FORGE',  agent: 'FORGE',    action: 'BUILD',     color: '#f97316' },
+  '🧠': { verb: 'QUERY',  agent: 'NOVA',     action: 'SYNTHETIC', color: '#8b5cf6' },
+  '💀': { verb: 'FORGE',  agent: 'FORGE',    action: 'CHAIN',     color: '#6b7280' },
+}
+
+// ── Activation ────────────────────────────────────────────────────────────────
+
+export function activate(context: vscode.ExtensionContext) {
+  const config  = () => vscode.workspace.getConfiguration('magma')
+  const osUrl   = () => config().get<string>('osUrl', 'http://localhost:3000')
+  const chainView = new ChainView(context, osUrl)
+
+  // ── Commands ────────────────────────────────────────────────────────────────
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('magma.panel', () => {
+      MagmaPanel.createOrShow(context.extensionUri, osUrl())
+    }),
+
+    vscode.commands.registerCommand('magma.seal', async () => {
+      const editor = vscode.window.activeTextEditor
+      const text   = editor?.document.getText(editor.selection) ?? ''
+      if (!text) { vscode.window.showWarningMessage('Select text to seal'); return }
+      const result = await sealToChain(osUrl(), { event: 'SELECTION_SEAL', text: text.slice(0, 500) })
+      if (result) {
+        vscode.window.showInformationMessage(`🔒 Sealed · ${result.seal?.slice(0, 16)}…`)
+        chainView.refresh()
+      }
+    }),
+
+    vscode.commands.registerCommand('magma.sealFile', async () => {
+      const doc = vscode.window.activeTextEditor?.document
+      if (!doc) { vscode.window.showWarningMessage('No active file'); return }
+      const hash = crypto.createHash('sha256').update(doc.getText()).digest('hex')
+      const result = await sealToChain(osUrl(), {
+        event:    'FILE_SEAL',
+        file:     doc.fileName.split(/[\\/]/).pop(),
+        sha256:   hash,
+        language: doc.languageId,
+      })
+      if (result) {
+        vscode.window.showInformationMessage(`🔒 File sealed · ${result.seal?.slice(0, 16)}…`)
+        chainView.refresh()
+      }
+    }),
+
+    vscode.commands.registerCommand('magma.anchor', async () => {
+      const input = await vscode.window.showInputBox({ prompt: '📜 Anchor payload (k:v or JSON)', placeHolder: 'session:"work" milestone:"v1"' })
+      if (!input) return
+      const result = await sealToChain(osUrl(), { event: 'ANCHOR', data: input })
+      if (result) vscode.window.showInformationMessage(`📜 Anchored to WORM · ${result.seal?.slice(0, 16)}…`)
+    }),
+
+    vscode.commands.registerCommand('magma.vault', async () => {
+      const amount  = await vscode.window.showInputBox({ prompt: '🏦 Amount (USD)', placeHolder: '50000' })
+      const vendor  = await vscode.window.showInputBox({ prompt: '🏦 Vendor', placeHolder: 'Acme Corp' })
+      if (!amount) return
+      const result  = await sealToChain(osUrl(), { event: 'VAULT_APPROVE', amount: Number(amount), vendor: vendor ?? 'unknown' })
+      if (result) vscode.window.showInformationMessage(`🏦 VAULT sealed · $${Number(amount).toLocaleString()} · ${result.seal?.slice(0, 16)}…`)
+    }),
+
+    vscode.commands.registerCommand('magma.flux', async () => {
+      const msg = await vscode.window.showInputBox({ prompt: '⚡ Broadcast message', placeHolder: 'Deploy complete' })
+      if (!msg) return
+      const result = await sealToChain(osUrl(), { event: 'FLUX_BROADCAST', message: msg })
+      if (result) vscode.window.showInformationMessage(`⚡ Broadcast sealed · ${result.seal?.slice(0, 16)}…`)
+    }),
+
+    vscode.commands.registerCommand('magma.forge', async () => {
+      const job = await vscode.window.showInputBox({ prompt: '⚒️ Forge job', placeHolder: 'build:prod or test:all' })
+      if (!job) return
+      const result = await sealToChain(osUrl(), { event: 'FORGE_BUILD', job })
+      if (result) vscode.window.showInformationMessage(`⚒️ FORGE sealed · ${result.seal?.slice(0, 16)}…`)
+    }),
+
+    vscode.commands.registerCommand('magma.watch', async () => {
+      const source = await vscode.window.showInputBox({ prompt: '👁 Source to monitor', placeHolder: 'ip:192.168.1.99 or user:unknown' })
+      if (!source) return
+      const result = await sealToChain(osUrl(), { event: 'SENTINEL_MONITOR', source })
+      if (result) vscode.window.showInformationMessage(`👁 SENTINEL sealed · ${result.seal?.slice(0, 16)}…`)
+    }),
+
+    vscode.commands.registerCommand('magma.query', async () => {
+      const topic = await vscode.window.showInputBox({ prompt: '🔮 Oracle query', placeHolder: 'threat analysis / revenue forecast' })
+      if (!topic) return
+      MagmaPanel.createOrShow(context.extensionUri, osUrl())
+      MagmaPanel.postMessage({ type: 'query', topic })
+    }),
+
+    vscode.commands.registerCommand('magma.chainHead', async () => {
+      const head = await getChainHead(osUrl())
+      vscode.window.showInformationMessage(`📜 Chain head: ${head?.slice(0, 32) ?? 'unreachable'}…`)
+    }),
+  )
+
+  // ── Auto-seal on save (optional) ────────────────────────────────────────────
+
+  context.subscriptions.push(
+    vscode.workspace.onDidSaveTextDocument(async doc => {
+      if (!config().get<boolean>('sealOnSave', false)) return
+      const hash = crypto.createHash('sha256').update(doc.getText()).digest('hex')
+      await sealToChain(osUrl(), { event: 'AUTO_SAVE_SEAL', file: doc.fileName.split(/[\\/]/).pop(), sha256: hash })
+      chainView.refresh()
+    })
+  )
+
+  // ── Git commit hook (seal on commit) ────────────────────────────────────────
+
+  const gitExt = vscode.extensions.getExtension('vscode.git')?.exports
+  if (gitExt && config().get<boolean>('sealOnCommit', true)) {
+    try {
+      const api = gitExt.getAPI(1)
+      api.onDidOpenRepository((repo: { state: { onDidChange: (cb: () => void) => void; HEAD: { commit?: string } } }) => {
+        let lastCommit = repo.state.HEAD?.commit
+        repo.state.onDidChange(async () => {
+          const current = repo.state.HEAD?.commit
+          if (current && current !== lastCommit) {
+            lastCommit = current
+            await sealToChain(osUrl(), { event: 'GIT_COMMIT_SEAL', commit: current })
+            chainView.refresh()
+          }
+        })
+      })
+    } catch { /* git extension unavailable */ }
+  }
+
+  // ── Inline MAGMA completions (type § or $ and get suggestions) ────────────────
+
+  context.subscriptions.push(
+    vscode.languages.registerCompletionItemProvider(
+      { scheme: 'file' },
+      {
+        provideCompletionItems(document, position) {
+          const line = document.lineAt(position).text.slice(0, position.character)
+          if (!line.trimEnd().endsWith('§') && !line.trimEnd().endsWith('$')) return
+
+          const items: vscode.CompletionItem[] = []
+
+          if (line.trimEnd().endsWith('§')) {
+            for (const [emoji, tier] of Object.entries(TIERS)) {
+              const item = new vscode.CompletionItem(`${emoji}§${tier.verb}:${tier.agent}:${tier.action}{}`, vscode.CompletionItemKind.Event)
+              item.detail      = `MAGMA ${tier.verb} via ${tier.agent}`
+              item.insertText  = new vscode.SnippetString(`${emoji}§${tier.verb}:${tier.agent}:${tier.action}{"$1"}`)
+              item.sortText    = `0${tier.verb}`
+              items.push(item)
+            }
+          }
+
+          if (line.trimEnd().endsWith('$')) {
+            for (const [key, tier] of Object.entries({
+              seal:'🔒', vault:'🏦', anchor:'📜', flux:'⚡', forge:'⚒️',
+              watch:'👁', query:'🔮', ask:'🧠', send:'📡', lock:'🔐',
+            })) {
+              const t = TIERS[tier as string]
+              if (!t) continue
+              const item = new vscode.CompletionItem(`$${key}`, vscode.CompletionItemKind.Keyword)
+              item.detail     = `${tier} ${t.verb}:${t.agent}:${t.action}`
+              item.insertText = new vscode.SnippetString(`$${key} \${1:payload}`)
+              item.sortText   = `0${key}`
+              items.push(item)
+            }
+          }
+
+          return items
+        },
+      },
+      '§', '$'
+    )
+  )
+
+  vscode.window.showInformationMessage('§ MAGMA Protocol active — sovereign IDE online')
+}
+
+export function deactivate() {}

magma-protocol/src/magma-panel.ts

@@ -0,0 +1,202 @@
+import * as vscode from 'vscode'
+import { sealToChain } from './worm-client'
+
+// ── MAGMA Panel — sovereign instruction terminal ──────────────────────────────
+// A webview panel where you type emoji/$ instructions and get agent responses.
+// Looks like a terminal but routes to your sovereign OS.
+
+export class MagmaPanel {
+  static current: MagmaPanel | undefined
+  private readonly _panel: vscode.WebviewPanel
+  private readonly _osUrl: () => string
+  private _disposables: vscode.Disposable[] = []
+
+  static createOrShow(extensionUri: vscode.Uri, osUrl: string) {
+    const column = vscode.window.activeTextEditor?.viewColumn ?? vscode.ViewColumn.One
+
+    if (MagmaPanel.current) {
+      MagmaPanel.current._panel.reveal(column)
+      MagmaPanel.current._osUrl = () => osUrl
+      return
+    }
+
+    const panel = vscode.window.createWebviewPanel(
+      'magmaPanel',
+      '§ MAGMA',
+      column,
+      { enableScripts: true, retainContextWhenHidden: true },
+    )
+
+    MagmaPanel.current = new MagmaPanel(panel, () => osUrl)
+  }
+
+  static postMessage(msg: unknown) {
+    MagmaPanel.current?._panel.webview.postMessage(msg)
+  }
+
+  private constructor(panel: vscode.WebviewPanel, osUrl: () => string) {
+    this._panel = panel
+    this._osUrl = osUrl
+    this._panel.webview.html = this._getHtml()
+
+    this._panel.onDidDispose(() => this.dispose(), null, this._disposables)
+
+    this._panel.webview.onDidReceiveMessage(async msg => {
+      if (msg.type === 'instruction') {
+        const result = await this._execute(msg.text)
+        this._panel.webview.postMessage({ type: 'result', text: result, input: msg.text })
+      }
+    }, null, this._disposables)
+  }
+
+  private async _execute(raw: string): Promise<string> {
+    const trimmed = raw.trim()
+    let payload: Record<string, unknown> = { raw: trimmed }
+
+    // Parse $ shorthand or emoji prefix into payload
+    if (trimmed.startsWith('$') || /^[\u{1F000}-\u{1FFFF}]/u.test(trimmed)) {
+      payload = { event: 'MAGMA_INSTRUCTION', instruction: trimmed }
+    }
+
+    const result = await sealToChain(this._osUrl(), payload)
+    if (!result) return '⚠ OS unreachable — check SnapKitty OS is running at ' + this._osUrl()
+
+    return [
+      `🔒 SEALED`,
+      `   seal:  ${result.seal}`,
+      `   prev:  ${result.previousSeal?.slice(0, 32)}…`,
+      `   index: ${result.index}`,
+      `   ts:    ${result.timestamp}`,
+    ].join('\n')
+  }
+
+  dispose() {
+    MagmaPanel.current = undefined
+    this._panel.dispose()
+    this._disposables.forEach(d => d.dispose())
+  }
+
+  private _getHtml(): string {
+    return /* html */`<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>§ MAGMA</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body {
+    background: #030306; color: #00ff88;
+    font-family: 'Space Mono', 'Courier New', monospace;
+    font-size: 12px; height: 100vh;
+    display: flex; flex-direction: column;
+  }
+  #header {
+    padding: 10px 16px; border-bottom: 1px solid #0d0d0d;
+    display: flex; align-items: center; justify-content: space-between;
+  }
+  #header h1 { font-size: 11px; letter-spacing: 0.18em; color: #00ff88; }
+  #header small { font-size: 9px; color: #1a1a1a; letter-spacing: 0.08em; }
+  #output {
+    flex: 1; overflow-y: auto; padding: 12px 16px;
+    display: flex; flex-direction: column; gap: 8px;
+  }
+  .line-in  { color: #333; }
+  .line-in::before { content: '§ '; color: #00ff88; }
+  .line-out { color: #1a6640; white-space: pre; font-size: 10px; padding-left: 12px; border-left: 1px solid #0a2a18; }
+  .line-err { color: #7f1d1d; white-space: pre; padding-left: 12px; }
+  #input-row {
+    display: flex; align-items: center; gap: 8px;
+    padding: 10px 16px; border-top: 1px solid #0d0d0d;
+  }
+  #prompt { color: #00ff88; font-size: 12px; flex-shrink: 0; }
+  #input {
+    flex: 1; background: transparent; border: none; outline: none;
+    color: #666; font-family: inherit; font-size: 12px; caret-color: #00ff88;
+  }
+  #input::placeholder { color: #111; }
+  #hint { font-size: 9px; color: #0d0d0d; letter-spacing: 0.06em; padding: 4px 16px; }
+</style>
+</head>
+<body>
+<div id="header">
+  <h1>§ MAGMA PROTOCOL</h1>
+  <small>SOVEREIGN IDE · SnapKitty OS</small>
+</div>
+<div id="output" id="output">
+  <div class="line-out">MAGMA Emoji Protocol online.
+Type § or $ instructions below.
+
+  🔒 §SEAL:CIPHER:SIGN{"decision":"..."}
+  $vault amount:50000 vendor:"Acme"
+  $seal decision:"deploy v4" agent:FORGE
+  $magma  ← show all tiers and shorthands
+
+Every instruction is sealed to your WORM chain.</div>
+</div>
+<div id="hint">§ TIERS: 🔒📜⚡👁🏦📡🔮⚒️🧠🌊🔐💀📊🌑 · $ SHORTHANDS: $seal $vault $anchor $flux $forge $watch $query $ask</div>
+<div id="input-row">
+  <span id="prompt">§</span>
+  <input id="input" type="text" autocomplete="off" spellcheck="false" placeholder="🔒 §SEAL:... or $vault amount:50000" />
+</div>
+<script>
+  const vscode  = acquireVsCodeApi()
+  const output  = document.getElementById('output')
+  const input   = document.getElementById('input')
+  const history = []
+  let histIdx   = -1
+
+  function append(cls, text) {
+    const el = document.createElement('div')
+    el.className = cls
+    el.textContent = text
+    output.appendChild(el)
+    output.scrollTop = output.scrollHeight
+  }
+
+  input.addEventListener('keydown', e => {
+    if (e.key === 'Enter') {
+      const val = input.value.trim()
+      if (!val) return
+      history.unshift(val)
+      histIdx = -1
+      append('line-in', val)
+      input.value = ''
+
+      if (val === '$magma' || val === '§help') {
+        append('line-out',
+          'TIERS:\\n' +
+          '🔒 SEAL     CIPHER   — cryptographic seal\\n' +
+          '📜 ANCHOR   MNEMEX   — immutable WORM write\\n' +
+          '⚡ FLUX     HERALD   — broadcast/state transition\\n' +
+          '👁 SENTINEL SENTINEL — security watch (auto-urgent)\\n' +
+          '🏦 VAULT    VAULT    — financial authorization\\n' +
+          '📡 HERALD   HERALD   — broadcast routing\\n' +
+          '🔮 ORACLE   ORACLE   — knowledge query\\n' +
+          '⚒️ FORGE    FORGE    — build/deploy action\\n' +
+          '🧠 NOVA     NOVA     — synthetic intelligence\\n' +
+          '💀 LOC      FORGE    — binary/kinetic, no retry\\n\\n' +
+          'SHORTHANDS: $seal $vault $anchor $flux $forge $watch $query $ask $send $lock $score'
+        )
+        return
+      }
+
+      vscode.postMessage({ type: 'instruction', text: val })
+    }
+    if (e.key === 'ArrowUp')   { histIdx = Math.min(histIdx + 1, history.length - 1); input.value = history[histIdx] ?? '' }
+    if (e.key === 'ArrowDown') { histIdx = Math.max(histIdx - 1, -1);                 input.value = histIdx < 0 ? '' : history[histIdx] }
+  })
+
+  window.addEventListener('message', e => {
+    const msg = e.data
+    if (msg.type === 'result') append('line-out', msg.text)
+    if (msg.type === 'error')  append('line-err', msg.text)
+    if (msg.type === 'query')  { input.value = '$query topic:' + msg.topic; input.focus() }
+  })
+
+  input.focus()
+</script>
+</body>
+</html>`
+  }
+}

magma-protocol/src/worm-client.ts

@@ -0,0 +1,49 @@
+// WORM chain client — talks to running SnapKitty OS at localhost:3000
+
+export interface SealResult {
+  seal:         string
+  previousSeal: string
+  index:        number
+  timestamp:    string
+}
+
+export async function sealToChain(
+  osUrl: string,
+  payload: Record<string, unknown>,
+): Promise<SealResult | null> {
+  try {
+    const res = await fetch(`${osUrl}/api/labs/ledge/seal`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ payload }),
+      signal:  AbortSignal.timeout(5000),
+    })
+    if (!res.ok) return null
+    const data = await res.json()
+    return data.event as SealResult
+  } catch {
+    return null
+  }
+}
+
+export async function getChainHead(osUrl: string): Promise<string | null> {
+  try {
+    const res = await fetch(`${osUrl}/api/merkle/head`, { signal: AbortSignal.timeout(3000) })
+    if (!res.ok) return null
+    const data = await res.json()
+    return data.head ?? data.chainHead ?? null
+  } catch {
+    return null
+  }
+}
+
+export async function getRecentEvents(osUrl: string, limit = 10): Promise<unknown[]> {
+  try {
+    const res = await fetch(`${osUrl}/api/bifrost/audit?limit=${limit}`, { signal: AbortSignal.timeout(5000) })
+    if (!res.ok) return []
+    const data = await res.json()
+    return Array.isArray(data.data) ? data.data : Array.isArray(data) ? data : []
+  } catch {
+    return []
+  }
+}

magma-protocol/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "out",
+    "rootDir": "src",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", ".vscode-test"]
+}

sovereign-status/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "sovereign-status",
+  "displayName": "Sovereign Status",
+  "description": "Live WORM chain head, agent states, and Merkle root in the VS Code status bar",
+  "version": "0.1.0",
+  "publisher": "snapkitty",
+  "engines": { "vscode": "^1.85.0" },
+  "activationEvents": ["onStartupFinished"],
+  "main": "./out/extension.js",
+  "contributes": {
+    "configuration": {
+      "title": "Sovereign Status",
+      "properties": {
+        "sovereignStatus.osUrl": {
+          "type": "string",
+          "default": "http://localhost:3000",
+          "description": "SnapKitty OS base URL"
+        },
+        "sovereignStatus.pollInterval": {
+          "type": "number",
+          "default": 30,
+          "description": "Status bar poll interval in seconds"
+        }
+      }
+    }
+  },
+  "scripts": {
+    "compile": "tsc -p ./",
+    "watch":   "tsc -watch -p ./"
+  },
+  "devDependencies": {
+    "@types/node":   "^20.0.0",
+    "@types/vscode": "^1.85.0",
+    "typescript":    "^5.0.0"
+  }
+}

sovereign-status/src/extension.ts

@@ -0,0 +1,86 @@
+import * as vscode from 'vscode'
+
+interface ChainStatus {
+  head?:       string
+  eventCount?: number
+  merkleRoot?: string
+  db?:         string
+}
+
+export function activate(context: vscode.ExtensionContext) {
+  const config    = () => vscode.workspace.getConfiguration('sovereignStatus')
+  const osUrl     = () => config().get<string>('osUrl', 'http://localhost:3000')
+  const pollMs    = () => (config().get<number>('pollInterval', 30)) * 1000
+
+  // ── Status bar items ───────────────────────────────────────────────────────
+
+  const chainItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 1000)
+  chainItem.command   = 'magma.chainHead'
+  chainItem.tooltip   = 'SnapKitty WORM chain — click to show head'
+  chainItem.text      = '$(lock) WORM …'
+  chainItem.color     = '#00ff88'
+  chainItem.show()
+
+  const agentItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 999)
+  agentItem.command   = 'magma.panel'
+  agentItem.tooltip   = 'SnapKitty OS — click to open MAGMA panel'
+  agentItem.text      = '$(circuit-board) OS …'
+  agentItem.color     = '#27272a'
+  agentItem.show()
+
+  context.subscriptions.push(chainItem, agentItem)
+
+  // ── Poll ───────────────────────────────────────────────────────────────────
+
+  async function poll() {
+    try {
+      const [healthRes, merkleRes] = await Promise.allSettled([
+        fetch(`${osUrl()}/api/health`,       { signal: AbortSignal.timeout(3000) }),
+        fetch(`${osUrl()}/api/merkle/root`,   { signal: AbortSignal.timeout(3000) }),
+      ])
+
+      let db         = 'OFFLINE'
+      let merkleRoot = ''
+      let eventCount = 0
+
+      if (healthRes.status === 'fulfilled' && healthRes.value.ok) {
+        const h = await healthRes.value.json()
+        db = h.db ?? 'OK'
+      }
+
+      if (merkleRes.status === 'fulfilled' && merkleRes.value.ok) {
+        const m = await merkleRes.value.json()
+        merkleRoot = m.merkleRoot ?? m.root ?? ''
+        eventCount = m.eventCount ?? m.count ?? 0
+      }
+
+      const isOnline = db !== 'OFFLINE'
+      chainItem.text  = isOnline
+        ? `$(lock) ${merkleRoot.slice(0, 8) || 'WORM'}… · ${eventCount}`
+        : `$(lock) OFFLINE`
+      chainItem.color = isOnline ? '#00ff88' : '#ef4444'
+
+      agentItem.text  = isOnline ? `$(circuit-board) 11 AGENTS` : `$(circuit-board) OS OFFLINE`
+      agentItem.color = isOnline ? '#27272a' : '#ef4444'
+
+    } catch {
+      chainItem.text  = `$(lock) OFFLINE`
+      chainItem.color = '#ef4444'
+      agentItem.text  = `$(circuit-board) OS OFFLINE`
+      agentItem.color = '#ef4444'
+    }
+  }
+
+  poll()
+  const interval = setInterval(poll, pollMs())
+  context.subscriptions.push({ dispose: () => clearInterval(interval) })
+
+  // Re-poll when config changes
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeConfiguration(e => {
+      if (e.affectsConfiguration('sovereignStatus')) { clearInterval(interval); poll() }
+    })
+  )
+}
+
+export function deactivate() {}

sovereign-status/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "out",
+    "rootDir": "src",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", ".vscode-test"]
+}