@jellyos/agent 0.1.1

package/README.md

@@ -0,0 +1,375 @@
+# @jellyos/agent
+
+<div align="center">
+
+<pre>
+     ██╗███████╗██╗     ██╗  ██╗   ██╗  ██████╗ ███████╗
+     ██║██╔════╝██║     ██║  ╚██╗ ██╔╝ ██╔═══██╗██╔════╝
+     ██║█████╗  ██║     ██║   ╚████╔╝  ██║   ██║███████╗
+██   ██║██╔══╝  ██║     ██║    ╚██╔╝   ██║   ██║╚════██║
+╚█████╔╝███████╗███████╗███████╗██║    ╚██████╔╝███████║
+ ╚════╝ ╚══════╝╚══════╝╚══════╝╚═╝     ╚═════╝ ╚══════╝
+</pre>
+
+**Standalone AI trading agent. Runs 100% locally. No server. No inbound ports. No cloud dependency.**
+
+[![npm](https://img.shields.io/npm/v/@jellyos/agent?color=14b8a6&style=flat-square)](https://www.npmjs.com/package/@jellyos/agent)
+[![Node](https://img.shields.io/badge/node-%3E%3D20-brightgreen?style=flat-square)](https://nodejs.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-yellow?style=flat-square)](LICENSE)
+
+[Website](http://jelly-os.xyz/) • [Telegram](https://t.me/jellyxchain) • [X / Twitter](https://x.com/agentz010) • [API](https://jellychain.fun)
+
+</div>
+
+---
+
+## What is JellyOS?
+
+JellyOS is an AI trading agent that runs entirely in your terminal. It connects to AI model providers and blockchain data APIs through outbound HTTP calls only — nothing is hosted, nothing listens for inbound connections, and your keys never leave your machine.
+
+```
+Your machine
+├── jellyos (CLI)
+│   ├── Ink TUI             ← streaming terminal UI
+│   ├── AgentRunner         ← model loop + tool dispatcher
+│   ├── SwarmRouter         ← parallel sub-agent orchestration
+│   ├── FeedManager         ← 21 live data sources (background)
+│   ├── SignalEngine        ← cross-feed trading signals
+│   ├── WalletManager       ← EVM / Solana / Cosmos keypairs
+│   ├── VaultManager        ← AES-256-GCM encrypted profit vault
+│   └── DashboardServer     ← optional local WebSocket dashboard
+│
+├── ~/.jellyos/
+│   ├── .env                ← your API keys
+│   ├── wallets/            ← local keypairs (never synced)
+│   ├── vault/              ← encrypted vault file
+│   └── context.json        ← session state, watchlist, positions
+│
+└── Outbound only:
+    ├── openrouter.ai           ← AI model gateway (your key)
+    ├── api.coingecko.com       ← prices, trending
+    ├── api.binance.com         ← 24h tickers
+    ├── api.llama.fi            ← DeFi TVL
+    ├── alchemy.com             ← on-chain data (optional key)
+    ├── mempool.space           ← BTC mempool
+    ├── etherscan.io            ← ETH gas
+    └── ... 15 more sources
+```
+
+---
+
+## Install
+
+```bash
+npm install -g @jellyos/agent
+```
+
+## Quick Start
+
+```bash
+# 1. Create config directory and set your API key
+mkdir -p ~/.jellyos
+echo "OPENROUTER_API_KEY=sk-or-..." > ~/.jellyos/.env
+
+# 2. Launch
+jellyos
+```
+
+The terminal boots with an ASCII header and drops you into the `jell>` prompt.
+
+---
+
+## Using the Full JellyOS Stack
+
+For wallets, vault, live feeds, and all 28 trading tools:
+
+```bash
+# Clone the full project
+git clone https://github.com/jelly-chain/JellyOS.git
+cd JellyOS
+
+# Install dependencies
+npm install
+
+# Run one-command setup (generates wallets, vault ceremony, writes ~/.jellyos/.env)
+bash setup.sh      # macOS / Linux
+# or
+powershell -ExecutionPolicy Bypass -File setup.ps1   # Windows
+
+# Launch — auto-detects extensions/jellyos.ts
+jellyos
+```
+
+---
+
+## Configuration
+
+All config lives in `~/.jellyos/.env`. The setup wizard creates this for you, or create it manually:
+
+```bash
+cp .env.example ~/.jellyos/.env
+nano ~/.jellyos/.env
+```
+
+### AI Model Provider (pick one)
+
+| Variable | Provider | Example models |
+|----------|----------|----------------|
+| `OPENROUTER_API_KEY` | OpenRouter (recommended) | `anthropic/claude-sonnet-4-5` |
+| `ANTHROPIC_API_KEY` | Anthropic direct | `claude-sonnet-4-5-20251101` |
+| `OPENAI_API_KEY` | OpenAI | `gpt-4o` |
+| `OPENAI_BASE_URL` | Local (Ollama / LM Studio) | `http://localhost:11434/v1` |
+
+### Model Pool (optional — up to 5 models)
+
+Configure a named pool. JellyOS rotates through them automatically on rate-limits or errors:
+
+```env
+JELLY_MODEL_1=anthropic/claude-sonnet-4-5    # primary
+JELLY_MODEL_2=openai/gpt-4o-mini             # secondary
+JELLY_MODEL_3=google/gemini-flash-1.5        # tertiary
+JELLY_MODEL_4=meta-llama/llama-3-8b-instruct:free  # budget / eco
+JELLY_MODEL_5=deepseek/deepseek-chat         # swarm fallback
+```
+
+If not set, JellyOS uses built-in defaults for your provider.
+
+### Data & Chain APIs (optional)
+
+| Variable | Description |
+|----------|-------------|
+| `ALCHEMY_KEY` | On-chain balances, gas, whale scanning across 16 EVM chains |
+| `COINGLASS_API_KEY` | Funding rates + open interest (broader exchange coverage) |
+| `DUNE_API_KEY` | Dune Analytics whale wallet tracking |
+| `GLASSNODE_API_KEY` | On-chain metrics (active addresses, SOPR) |
+| `POLYMARKET_API_KEY` | Prediction market data and trading |
+
+### Vault & Agent Behaviour
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `JELLY_EFFECT_LEVEL` | `normal` | Default power level: `eco` / `normal` / `turbo` / `max` |
+| `AUTO_VAULT_THRESHOLD` | `500` | Auto-sweep P&L to vault when this USD amount is exceeded |
+| `JELLY_DASHBOARD_PORT` | `4320` | WebSocket port for the local dashboard |
+| `JELLY_MAX_AGENTS` | `5` | Max parallel sub-agents in swarm mode |
+
+---
+
+## Effect Levels
+
+Switch at any time with `/effect <level>`. Takes effect immediately on your next message.
+
+| Level | Power | Swarm | Best For |
+|-------|-------|-------|----------|
+| `eco` | 30% | Off | Quick balance checks, simple questions |
+| `normal` | 50% | Off | Default — most everyday tasks |
+| `turbo` | 70% | 2 agents | Analysis + signal generation in parallel |
+| `max` | 100% | 5 agents | Multi-chain deep research, complex strategies |
+
+**How swarm works (`turbo` / `max`):**
+Complex prompts are automatically scored using a conjunction + action-verb heuristic. When the score crosses the threshold, the prompt is decomposed into 2–5 focused sub-tasks. Sub-tasks run in groups of 3 (parallel within each group, groups run sequentially). A reviewer model then synthesises all results into a single coherent answer.
+
+---
+
+## Live Data Feeds
+
+JellyOS polls 21 sources in the background and injects relevant data into every agent turn:
+
+| Source | Interval | Data |
+|--------|----------|------|
+| CoinGecko prices | 5 min | Top asset prices + 24h change |
+| Binance tickers | 2 min | Top 8 USDT pairs by volume |
+| CoinGecko trending | 30 min | 7 trending coins |
+| Fear & Greed Index | 1 hr | Alternative.me sentiment score |
+| DeFiLlama TVL | 1 hr | Total TVL by chain |
+| DeFiLlama protocols | 1 hr | Top TVL movers |
+| Global market cap | 1 hr | BTC dominance, total cap, 24h change |
+| Messari RSS | 10 min | Latest news headlines |
+| CoinTelegraph RSS | 10 min | Latest news headlines |
+| Coinglass funding rates | 15 min | BTC funding rates across exchanges |
+| Coinglass open interest | 15 min | BTC OI aggregate |
+| Etherscan gas | 1 min | ETH base / fast / slow gas |
+| Reddit sentiment | 30 min | r/CryptoCurrency hot posts |
+| Solana TPS | 5 min | Network transactions per second |
+| BTC mempool | 3 min | Pending txs + fee rates |
+| Polymarket trends | 30 min | Trending prediction markets |
+| Whale watch | 10 min | Large on-chain movements (Alchemy) |
+| Dune Analytics | 1 hr | Whale wallet tracker (API key required) |
+| Glassnode | 1 hr | BTC active addresses (API key required) |
+| CryptoCompare social | 2 hr | Twitter / Reddit social stats |
+| Kalshi markets | 30 min | Prediction market odds |
+
+---
+
+## REPL Commands
+
+```
+/help                   List all available commands
+/effect [level]         Set effect level: eco | normal | turbo | max
+/vault                  Show encrypted vault balance
+/unlock <passphrase>    Unlock the vault for sweeps
+/lock                   Lock the vault immediately
+/agents                 Show live swarm routing status
+/feeds                  Show feed statistics (last fetch, item count)
+/wallets                Show all wallet addresses (EVM / Solana / Cosmos)
+/signals                Request current trading signals from signal engine
+/status                 Full system health check (feeds, vault, model, wallets)
+/clear                  Clear conversation history
+/panic                  Emergency stop — closes all positions, sweeps vault, locks, halts feeds
+/exit                   Quit JellyOS
+```
+
+---
+
+## Tools Reference
+
+The AI calls these tools automatically. You can also ask for them in plain language.
+
+| Tool | Description |
+|------|-------------|
+| `get_balance` | Wallet balance on any supported chain |
+| `get_wallet_addresses` | All generated wallet addresses |
+| `sign_transaction` | Sign a tx hex in-memory (key never broadcast) |
+| `vault_status` | Vault balance + lock state + entry count |
+| `vault_sweep` | Move profits from trading account into vault |
+| `vault_history` | Last 50 vault entries |
+| `get_live_feeds` | Latest items from all active feed sources |
+| `get_signals` | Active directional signals from the signal engine |
+| `get_fear_greed` | Crypto Fear & Greed Index (current + 7d history) |
+| `get_funding_rates` | Perpetual funding rates across exchanges |
+| `get_market_data` | Prices + 24h change for up to 10 assets |
+| `get_defi_tvl` | DeFiLlama TVL by chain or protocol |
+| `get_gas_prices` | Gas prices across EVM chains |
+| `scan_chain` | Scan recent blocks for large whale transactions |
+| `get_polymarket` | Trending prediction markets + current odds |
+| `predict_market` | AI-generated price prediction for an asset |
+| `execute_trade` | Submit a swap (requires explicit user confirmation) |
+| `get_positions` | List all open positions |
+| `get_portfolio` | Full portfolio summary with P&L |
+| `calculate_risk` | Risk/reward ratio + recommended position size |
+| `set_stop_loss` | Update a stop-loss level |
+| `execute_skill` | Run a saved trading strategy |
+| `list_skills` | Show available strategy skills |
+| `get_system_status` | Health check for all agent subsystems |
+| `get_context` | Read persistent session context |
+| `set_context` | Write persistent session context |
+| `get_news` | Latest crypto news headlines |
+| `get_chain_list` | All supported chains with IDs |
+
+---
+
+## Supported Chains
+
+Ethereum, BSC, Arbitrum, Base, Polygon, Avalanche, Optimism, Scroll, Linea, zkSync Era, Mantle, Blast, Solana, Cosmos, and more via Alchemy and public RPCs.
+
+---
+
+## Local Dashboard
+
+An optional React dashboard connects to the agent over WebSocket and shows live data:
+
+```bash
+cd dashboard
+npm install
+npm run dev
+# Open http://localhost:4321
+```
+
+Real-time events pushed from the agent:
+
+| Event | Description |
+|-------|-------------|
+| `feed_item` | New item from any live feed |
+| `log_entry` | Agent / tool conversation messages |
+| `trade_executed` | A trade was submitted |
+| `vault_sweep` | Auto-vault swept profits |
+| `swarm_update` | Sub-agent start / complete events |
+| `signal_update` | New trading signal generated |
+| `vault_update` | Vault balance changed |
+| `panic` | Emergency stop triggered |
+
+---
+
+## Extension API
+
+Build your own tools, commands, and hooks that run inside the JellyOS agent loop:
+
+```typescript
+import { Type } from "@jellyos/agent";
+import type { ExtensionAPI } from "@jellyos/agent";
+
+export default function (agent: ExtensionAPI) {
+  // Set the AI's system prompt
+  agent.setSystemPrompt("You are a DeFi yield optimizer.");
+
+  // Register a slash command
+  agent.registerCommand("yields", {
+    description: "Show top yield opportunities",
+    async handler(_args, ctx) {
+      ctx.ui.notify("Fetching yields...");
+    },
+  });
+
+  // Register a tool the AI can call automatically
+  agent.registerTool({
+    name:        "get_apy",
+    label:       "Get APY",
+    description: "Fetch current APY for a DeFi protocol",
+    parameters:  Type.Object({
+      protocol: Type.String({ description: "Protocol name, e.g. aave" }),
+    }),
+    async execute(_id, { protocol }) {
+      const res  = await fetch(`https://api.llama.fi/protocol/${protocol}`);
+      const data = await res.json() as any;
+      return {
+        content: [{ type: "text", text: `APY data for ${protocol}: ${JSON.stringify(data.apy)}` }],
+        details: {},
+      };
+    },
+  });
+
+  // Lifecycle hooks
+  agent.on("session_start", async (ctx) => {
+    ctx.ui.setStatus("yields", "ready");
+    ctx.ui.notify("Yield optimizer loaded.");
+  });
+
+  agent.on("session_end", async () => {
+    // cleanup
+  });
+}
+```
+
+Load your extension at startup:
+
+```bash
+jellyos --extension ./my-extension.ts
+```
+
+---
+
+## CLI Reference
+
+```bash
+jellyos                               # interactive TUI (auto-loads extensions/)
+jellyos --extension /path/to/ext.ts   # load a specific extension file
+jellyos --prompt /path/to/system.md   # override system prompt from file
+jellyos config                        # show current config (keys masked)
+jellyos setup                         # run the setup wizard
+```
+
+---
+
+## Security
+
+- **Keys stay local** — API keys are read from `~/.jellyos/.env` at startup and never logged or transmitted beyond outbound API calls
+- **Private keys never leave the process** — signing happens in memory; only the resulting signature is returned
+- **Vault encryption** — AES-256-GCM with a key derived from your passphrase using scrypt (memory-hard KDF) + random per-vault salt; the key itself is never persisted
+- **Auto-lock** — vault locks automatically on `/panic` and on process exit
+- **Wallet storage** — keypairs are written to `~/.jellyos/wallets/` which is in `.gitignore` and never included in any sync or backup by the agent
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE)

package/bin/jellyagent

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * jellyagent / jellyos — CLI entry point.
+ * Uses tsx for transparent TypeScript support at runtime.
+ * No compilation step needed when running from source.
+ */
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join }  from "path";
+import { existsSync }     from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require   = createRequire(import.meta.url);
+
+// Prefer pre-built dist/ if available, otherwise run TypeScript source via tsx
+const distEntry = join(__dirname, "..", "dist", "cli.js");
+const srcEntry  = join(__dirname, "..", "src",  "cli.ts");
+
+if (existsSync(distEntry)) {
+  // Built package — just run the compiled JS
+  await import(distEntry);
+} else if (existsSync(srcEntry)) {
+  // Development / source install — run via tsx
+  const { register } = await import("tsx/esm");
+  // tsx registers TypeScript support on the module system
+  await import(srcEntry);
+} else {
+  console.error("JellyOS: could not find dist/cli.js or src/cli.ts");
+  console.error("Run: npm run build  or  pnpm build");
+  process.exit(1);
+}

package/dist/api/ExtensionAPI.d.ts

@@ -0,0 +1,92 @@
+/**
+ * ExtensionAPI — the interface exposed to extension files (e.g. extensions/jellyos.ts).
+ *
+ * Drop-in replacement for Pi's ExtensionAPI. Extension files that ran under Pi
+ * work without changes — all Pi methods and calling conventions are preserved:
+ *   - ui.setStatus, ui.setTheme, ui.setHeader
+ *   - ctx.hasUI
+ *   - pi.on("session_start",       async (_event, ctx) => { ... })  ← Pi convention
+ *   - pi.on("session_shutdown",    async () => { ... })
+ *   - pi.on("before_agent_start",  async (_event, ctx) => { ... })
+ */
+import { type Static, type TObject, type TSchema } from "@sinclair/typebox";
+export type { Static, TObject, TSchema };
+export interface ToolContent {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    details: Record<string, unknown>;
+}
+export declare function text(t: string): ToolContent;
+export interface ToolDef<P extends TSchema = TSchema> {
+    name: string;
+    label: string;
+    description: string;
+    parameters: P;
+    execute(id: string, params: Static<P>): Promise<ToolContent>;
+}
+export interface TuiHeader {
+    render(width: number): string[];
+    invalidate(): void;
+}
+export type HeaderFactory = (tui: unknown, theme: ThemeContext) => TuiHeader;
+export interface ThemeContext {
+    /** Apply a named colour to text. Colours: accent, error, warn, muted, success, border, dim */
+    fg(color: string, text: string): string;
+}
+export interface UIContext {
+    /** Show a bordered notification in the REPL panel */
+    notify(message: string): void;
+    /**
+     * Set a named status badge in the status bar.
+     * Pi compat — multiple badges can be shown simultaneously.
+     * @param key   Badge slot name (e.g. "vault", "jelly", "chain")
+     * @param value Themed text to display
+     */
+    setStatus(key: string, value: string): void;
+    /**
+     * Activate a named theme. Pi compat — engine uses jelly theme by default.
+     */
+    setTheme(name: string): void;
+    /**
+     * Replace the TUI header with a custom rendering factory.
+     * Pi compat — accepted but engine renders its own Ink header.
+     */
+    setHeader(factory: HeaderFactory): void;
+    theme: ThemeContext;
+}
+export interface CommandContext {
+    ui: UIContext;
+}
+export interface CommandDef {
+    description: string;
+    handler(args: string, ctx: CommandContext): Promise<void>;
+}
+export interface SkillDef {
+    name: string;
+    content: string;
+}
+export type SessionEvent = "session_start" | "session_end" | "session_shutdown" | "before_agent_start";
+export interface SessionContext {
+    ui: UIContext;
+    /** True when running inside an interactive TUI (always true for @jellychain/agent) */
+    hasUI: boolean;
+    config: Record<string, string | undefined>;
+}
+export interface ExtensionAPI {
+    registerCommand(name: string, def: CommandDef): void;
+    registerTool<P extends TSchema>(def: ToolDef<P>): void;
+    registerSkill(def: SkillDef): void;
+    /**
+     * Subscribe to a lifecycle event.
+     * Pi calling convention: handler receives (event, ctx).
+     * Handlers may use any arity: (event, ctx) | (ctx) | () — all are safe.
+     */
+    on(event: SessionEvent, handler: (...args: any[]) => Promise<void>): void;
+    setSystemPrompt(prompt: string): void;
+    /** Direct UI access available at any time */
+    ui: UIContext;
+}
+export type ExtensionModule = (api: ExtensionAPI) => void | Promise<void>;
+//# sourceMappingURL=ExtensionAPI.d.ts.map

package/dist/api/ExtensionAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionAPI.d.ts","sourceRoot":"","sources":["../../src/api/ExtensionAPI.ts"],"names":[],"mappings":"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"}

package/dist/api/ExtensionAPI.js

@@ -0,0 +1,15 @@
+/**
+ * ExtensionAPI — the interface exposed to extension files (e.g. extensions/jellyos.ts).
+ *
+ * Drop-in replacement for Pi's ExtensionAPI. Extension files that ran under Pi
+ * work without changes — all Pi methods and calling conventions are preserved:
+ *   - ui.setStatus, ui.setTheme, ui.setHeader
+ *   - ctx.hasUI
+ *   - pi.on("session_start",       async (_event, ctx) => { ... })  ← Pi convention
+ *   - pi.on("session_shutdown",    async () => { ... })
+ *   - pi.on("before_agent_start",  async (_event, ctx) => { ... })
+ */
+export function text(t) {
+    return { content: [{ type: "text", text: t }], details: {} };
+}
+//# sourceMappingURL=ExtensionAPI.js.map

package/dist/api/ExtensionAPI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionAPI.js","sourceRoot":"","sources":["../../src/api/ExtensionAPI.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAaH,MAAM,UAAU,IAAI,CAAC,CAAS;IAC5B,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;AAC/D,CAAC"}

package/dist/api/Registry.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Registry — stores all commands, tools, and skills registered by extension files.
+ *
+ * Pi calling convention for lifecycle hooks:
+ *   session_start / session_end / session_shutdown: handler(event, ctx)
+ *   before_agent_start:                             handler(event, ctx)
+ *
+ * We always call hooks as handler(undefined, ctx) — handlers that expect only
+ * one argument (ctx) will receive it as the first positional parameter only if
+ * they follow Pi's two-arg (event, ctx) convention; handlers with no args are
+ * also safe. This matches Pi's actual calling convention exactly.
+ */
+import type { CommandDef, ToolDef, SkillDef, SessionEvent, SessionContext } from "./ExtensionAPI.js";
+import type { TSchema } from "@sinclair/typebox";
+export declare class Registry {
+    private commands;
+    private tools;
+    private skills;
+    private hooks;
+    private _systemPrompt;
+    addCommand(name: string, def: CommandDef): void;
+    addTool<P extends TSchema>(def: ToolDef<P>): void;
+    addSkill(def: SkillDef): void;
+    addHook(event: SessionEvent, handler: (...args: any[]) => Promise<void>): void;
+    setSystemPrompt(prompt: string): void;
+    getCommand(name: string): CommandDef | undefined;
+    listCommands(): Array<[string, CommandDef]>;
+    listTools(): Array<ToolDef<TSchema>>;
+    getTool(name: string): ToolDef<TSchema> | undefined;
+    listSkills(): SkillDef[];
+    getSystemPrompt(): string;
+    /**
+     * Fire hooks for a lifecycle event.
+     *
+     * Supports all handler arities so Pi-compat and simplified extensions both work:
+     *   h.length === 0 : async () => { ... }          → called with no args
+     *   h.length === 1 : async (ctx) => { ... }        → called with ctx as first arg
+     *   h.length >= 2  : async (event, ctx) => { ... } → Pi convention: (undefined, ctx)
+     *
+     * Using Function.length (declared parameter count) lets us detect intent without
+     * runtime type checks, avoiding the bug where h(undefined, ctx) puts `undefined`
+     * into the `ctx` parameter of a single-argument handler.
+     */
+    fireHook(event: string, ctx: SessionContext): Promise<void>;
+    toOpenAITools(): Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: unknown;
+        };
+    }>;
+}
+//# sourceMappingURL=Registry.d.ts.map

package/dist/api/Registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../../src/api/Registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,UAAU,EAAE,OAAO,EAAE,QAAQ,EAC7B,YAAY,EAAE,cAAc,EAC7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAMjD,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,KAAK,CAA0C;IACvD,OAAO,CAAC,MAAM,CAAmB;IAEjC,OAAO,CAAC,KAAK,CAAgC;IAE7C,OAAO,CAAC,aAAa,CAAM;IAI3B,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,IAAI;IAI/C,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;IAIjD,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IAI7B,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAQ9E,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMrC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIhD,YAAY,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAI3C,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAIpC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS;IAInD,UAAU,IAAI,QAAQ,EAAE;IAIxB,eAAe,IAAI,MAAM;IAMzB;;;;;;;;;;;OAWG;IACG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBjE,aAAa,IAAI,KAAK,CAAC;QACrB,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,OAAO,CAAA;SAAE,CAAC;KACtE,CAAC;CAUH"}

package/dist/api/Registry.js

@@ -0,0 +1,101 @@
+/**
+ * Registry — stores all commands, tools, and skills registered by extension files.
+ *
+ * Pi calling convention for lifecycle hooks:
+ *   session_start / session_end / session_shutdown: handler(event, ctx)
+ *   before_agent_start:                             handler(event, ctx)
+ *
+ * We always call hooks as handler(undefined, ctx) — handlers that expect only
+ * one argument (ctx) will receive it as the first positional parameter only if
+ * they follow Pi's two-arg (event, ctx) convention; handlers with no args are
+ * also safe. This matches Pi's actual calling convention exactly.
+ */
+export class Registry {
+    commands = new Map();
+    tools = new Map();
+    skills = [];
+    hooks = new Map();
+    _systemPrompt = "";
+    // ── Registration ────────────────────────────────────────────────────────
+    addCommand(name, def) {
+        this.commands.set(name.toLowerCase(), def);
+    }
+    addTool(def) {
+        this.tools.set(def.name, def);
+    }
+    addSkill(def) {
+        this.skills.push(def);
+    }
+    addHook(event, handler) {
+        // Normalize aliases: session_shutdown → session_end
+        const key = event === "session_shutdown" ? "session_end" : event;
+        const list = this.hooks.get(key) ?? [];
+        list.push(handler);
+        this.hooks.set(key, list);
+    }
+    setSystemPrompt(prompt) {
+        this._systemPrompt = prompt;
+    }
+    // ── Reads ────────────────────────────────────────────────────────────────
+    getCommand(name) {
+        return this.commands.get(name.toLowerCase());
+    }
+    listCommands() {
+        return [...this.commands.entries()];
+    }
+    listTools() {
+        return [...this.tools.values()];
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    listSkills() {
+        return this.skills;
+    }
+    getSystemPrompt() {
+        return this._systemPrompt;
+    }
+    // ── Hook dispatch ────────────────────────────────────────────────────────
+    /**
+     * Fire hooks for a lifecycle event.
+     *
+     * Supports all handler arities so Pi-compat and simplified extensions both work:
+     *   h.length === 0 : async () => { ... }          → called with no args
+     *   h.length === 1 : async (ctx) => { ... }        → called with ctx as first arg
+     *   h.length >= 2  : async (event, ctx) => { ... } → Pi convention: (undefined, ctx)
+     *
+     * Using Function.length (declared parameter count) lets us detect intent without
+     * runtime type checks, avoiding the bug where h(undefined, ctx) puts `undefined`
+     * into the `ctx` parameter of a single-argument handler.
+     */
+    async fireHook(event, ctx) {
+        const key = event === "session_shutdown" ? "session_end" : event;
+        const handlers = this.hooks.get(key) ?? [];
+        for (const h of handlers) {
+            try {
+                if (h.length === 0) {
+                    await h(); // () => {...}
+                }
+                else if (h.length === 1) {
+                    await h(ctx); // (ctx) => {...}
+                }
+                else {
+                    await h(undefined, ctx); // (_event, ctx) => {...}  — Pi convention
+                }
+            }
+            catch { /* hooks must not crash the session */ }
+        }
+    }
+    // ── OpenAI tool schema ───────────────────────────────────────────────────
+    toOpenAITools() {
+        return [...this.tools.values()].map(t => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+}
+//# sourceMappingURL=Registry.js.map