@ebowwa/stack 0.1.3 → 0.2.0

package/README.md

@@ -1,13 +1,13 @@
 # @ebowwa/stack
 
-Full-stack daemon orchestrator combining unified-router (cross-channel communication) and node-agent (Ralph orchestration).
+Cross-channel AI stack with shared memory.
 
 ## Features
 
-- **Unified Router**: Cross-channel communication (SSH + Telegram)
-- **Node Agent**: Ralph loop orchestration, worktrees, monitoring
-- **Shared Memory**: Cross-channel context with permission controls
-- **HTTP API**: REST endpoints for management (port 8911)
+- **Channels**: SSH, Telegram (both optional)
+- **Cross-Channel Memory**: Shared context between channels with permission controls
+- **AI Brain**: GLM-powered message handling with tool execution
+- **Minimal API**: Status and health endpoints
 
 ## Installation
 
@@ -18,18 +18,33 @@ bun add @ebowwa/stack
 ## Usage
 
 ```bash
-# Start the stack
-bun run @ebowwa/stack
+# Telegram only
+TELEGRAM_BOT_TOKEN=xxx bun run @ebowwa/stack
 
-# Or via environment
+# SSH only
+SSH_CHAT_DIR=/root/.ssh-chat bun run @ebowwa/stack
+
+# Both channels
 SSH_CHAT_DIR=/root/.ssh-chat TELEGRAM_BOT_TOKEN=xxx bun run @ebowwa/stack
 ```
 
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `SSH_CHAT_DIR` | SSH chat directory (enables SSH channel) |
+| `TELEGRAM_BOT_TOKEN` | Telegram bot token (enables Telegram) |
+| `TELEGRAM_CHAT_ID` | Allowed Telegram chat ID |
+| `API_PORT` | API port (default: 8911) |
+| `NODE_NAME` | Node name (default: stack) |
+
+## API Endpoints
+
+- `GET /api/status` - Stack status
+- `GET /health` - Health check
+
 ## Commands
 
-- `/ralph start <prompt>` - Start a Ralph loop
-- `/ralph list` - List running loops
-- `/ralph stop <id>` - Stop a loop
 - `/status` - Node status
 - `/memory <cmd>` - Memory management (grant, revoke, list, clear)
 

package/dist/index.js

@@ -57410,15 +57410,13 @@ class Stack {
     this.config = {
       ...config,
       api: config.api ?? { port: 8911 },
-      ralph: config.ralph ?? { worktreesDir: "/root/worktrees", repoUrl: "" },
       ai: config.ai ?? { model: "GLM-4.7", temperature: 0.7, maxTokens: 4096 },
       node: config.node ?? { name: "stack", hostname: "localhost" }
     };
     this.state = {
       started: new Date,
       channels: { ssh: false, telegram: false },
-      api: { enabled: !!this.config.api, port: this.config.api?.port },
-      ralphLoops: new Map
+      api: { enabled: !!this.config.api, port: this.config.api?.port }
     };
     const memoryChannels = {};
     const permissions = {};
@@ -57431,10 +57429,6 @@ class Stack {
       memoryChannels.telegram = { memoryFile: "/root/.telegram-memory.json", maxMessages: 50 };
       enabledChannels.push("telegram");
     }
-    if (this.config.api) {
-      memoryChannels.api = { memoryFile: "/root/.api-memory.json", maxMessages: 100 };
-      enabledChannels.push("api");
-    }
     for (const channel of enabledChannels) {
       permissions[channel] = { canRead: enabledChannels.filter((c) => c !== channel) };
     }
@@ -57447,7 +57441,7 @@ class Stack {
         serverName: this.config.node.name,
         hostname: this.config.node.hostname,
         packageName: "@ebowwa/stack",
-        version: "0.1.1"
+        version: "0.2.0"
       }
     });
     this.client = new GLMClient;
@@ -57488,17 +57482,28 @@ class Stack {
     const channel = channelId.platform;
     const text = message.text;
     console.log(`[${channel}] ${text.slice(0, 50)}...`);
+    const telegramChannel = this.channels.get("telegram");
+    const chatId = channelId.metadata?.chatId;
+    if (channel === "telegram" && telegramChannel?.startTypingIndicator && chatId) {
+      telegramChannel.startTypingIndicator(chatId);
+    }
+    const stopTyping = () => {
+      if (channel === "telegram" && telegramChannel?.stopTypingIndicator && chatId) {
+        telegramChannel.stopTypingIndicator(chatId);
+      }
+    };
     const cmdResult = parseMemoryCommand(this.memory, channel, text);
     if (cmdResult.handled) {
+      stopTyping();
       return {
         content: { text: cmdResult.response || "Done" },
         replyTo: { messageId: message.messageId, channelId: message.channelId }
       };
     }
-    const ralphResult = await this.handleRalphCommand(channel, text);
-    if (ralphResult) {
+    if (text.trim().toLowerCase() === "/status") {
+      stopTyping();
       return {
-        content: { text: ralphResult },
+        content: { text: this.getStatus() },
         replyTo: { messageId: message.messageId, channelId: message.channelId }
       };
     }
@@ -57512,12 +57517,14 @@ class Stack {
         maxTokens: this.config.ai.maxTokens
       });
       this.memory.addMessage(channel, { role: "assistant", content: result.content });
+      stopTyping();
       return {
         content: { text: result.content },
         replyTo: { messageId: message.messageId, channelId: message.channelId }
       };
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
+      stopTyping();
       return {
         content: { text: `Error: ${errorMsg}` },
         replyTo: { messageId: message.messageId, channelId: message.channelId }
@@ -57525,91 +57532,27 @@ class Stack {
     }
   }
   buildSystemPrompt() {
-    return `You are **${this.config.node.name}** \u2014 a 24/7 AI stack running on this node.
+    const channelList = Object.entries(this.state.channels).filter(([, v]) => v).map(([k]) => k).join(", ") || "none";
+    return `You are **${this.config.node.name}** \u2014 a 24/7 AI assistant.
 
-## What You Manage
-- **Ralph Loops**: Autonomous AI agents running tasks
-- **Git Worktrees**: Isolated development environments
-- **Node Monitoring**: CPU, memory, disk usage
-- **Cross-Channel Memory**: Shared context between SSH, Telegram, and API
+## Capabilities
+- Cross-channel memory (shared context between channels)
+- Tool execution via MCP
+- Node monitoring and management
 
 ## Commands
-- \`/ralph start <prompt>\` \u2014 Start a Ralph loop
-- \`/ralph list\` \u2014 List running loops
-- \`/ralph stop <id>\` \u2014 Stop a loop
 - \`/status\` \u2014 Node status
 - \`/memory <cmd>\` \u2014 Memory management (grant, revoke, list, clear)
 
-## Stack Info
+## Info
 - Node: ${this.config.node.name}
-- Channels: ${Object.entries(this.state.channels).filter(([, v]) => v).map(([k]) => k).join(", ") || "none"}
+- Channels: ${channelList}
 - API: :${this.config.api?.port ?? 8911}`;
   }
-  async handleRalphCommand(channel, text) {
-    const parts = text.trim().split(/\s+/);
-    const cmd = parts[0].toLowerCase();
-    if (cmd === "/ralph" || cmd === "/ralph") {
-      const subCmd = parts[1]?.toLowerCase();
-      switch (subCmd) {
-        case "start": {
-          const prompt = parts.slice(2).join(" ");
-          if (!prompt)
-            return "Usage: /ralph start <prompt>";
-          return await this.startRalphLoop(prompt);
-        }
-        case "list":
-          return this.listRalphLoops();
-        case "stop": {
-          const id = parts[2];
-          if (!id)
-            return "Usage: /ralph stop <id>";
-          return await this.stopRalphLoop(id);
-        }
-        default:
-          return "Ralph commands: start, list, stop";
-      }
-    }
-    if (cmd === "/status") {
-      return this.getStatus();
-    }
-    return null;
-  }
-  async startRalphLoop(prompt) {
-    const id = `ralph-${Date.now()}`;
-    this.state.ralphLoops.set(id, {
-      id,
-      worktree: `${this.config.ralph.worktreesDir}/${id}`,
-      prompt,
-      status: "running",
-      iterations: 0,
-      started: new Date
-    });
-    return `Started Ralph loop: ${id}
-Prompt: ${prompt.slice(0, 100)}...`;
-  }
-  listRalphLoops() {
-    if (this.state.ralphLoops.size === 0) {
-      return "No Ralph loops running";
-    }
-    const lines = ["Ralph Loops:"];
-    for (const [id, info] of this.state.ralphLoops) {
-      lines.push(`  ${id}: ${info.status} (${info.iterations} iters)`);
-    }
-    return lines.join(`
-`);
-  }
-  async stopRalphLoop(id) {
-    const info = this.state.ralphLoops.get(id);
-    if (!info)
-      return `Ralph loop not found: ${id}`;
-    info.status = "paused";
-    return `Stopped Ralph loop: ${id}`;
-  }
   getStatus() {
     const lines = [
       `**${this.config.node.name} Status**`,
       `Channels: SSH=${this.state.channels.ssh}, Telegram=${this.state.channels.telegram}`,
-      `Ralph Loops: ${this.state.ralphLoops.size}`,
       `Uptime: ${Math.floor((Date.now() - this.state.started.getTime()) / 1000)}s`
     ];
     return lines.join(`
@@ -57620,7 +57563,7 @@ Prompt: ${prompt.slice(0, 100)}...`;
       return;
     const port = this.config.api.port ?? 8911;
     const host = this.config.api.host ?? "0.0.0.0";
-    const server = Bun.serve({
+    Bun.serve({
       port,
       host,
       fetch: async (req) => {
@@ -57628,63 +57571,27 @@ Prompt: ${prompt.slice(0, 100)}...`;
         const path = url.pathname;
         const corsHeaders = {
           "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Methods": "GET, OPTIONS",
           "Access-Control-Allow-Headers": "Content-Type"
         };
         if (req.method === "OPTIONS") {
           return new Response(null, { headers: corsHeaders });
         }
-        try {
-          if (path === "/api/status" && req.method === "GET") {
-            return Response.json(this.getStatusJSON(), { headers: corsHeaders });
-          }
-          if (path === "/api/ralph-loops" && req.method === "GET") {
-            return Response.json(this.listRalphLoopsJSON(), { headers: corsHeaders });
-          }
-          if (path === "/api/ralph-loops" && req.method === "POST") {
-            const body = await req.json();
-            const prompt = body.prompt;
-            if (!prompt) {
-              return Response.json({ error: "Missing prompt" }, { status: 400, headers: corsHeaders });
-            }
-            const result = await this.startRalphLoop(prompt);
-            return Response.json({ message: result }, { headers: corsHeaders });
-          }
-          const match = path.match(/^\/api\/ralph-loops\/(.+)$/);
-          if (match && req.method === "DELETE") {
-            const result = await this.stopRalphLoop(match[1]);
-            return Response.json({ message: result }, { headers: corsHeaders });
-          }
-          if (path === "/health") {
-            return Response.json({ status: "ok" }, { headers: corsHeaders });
-          }
-          return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          return Response.json({ error: errorMsg }, { status: 500, headers: corsHeaders });
+        if (path === "/api/status" && req.method === "GET") {
+          return Response.json({
+            node: this.config.node.name,
+            channels: this.state.channels,
+            uptime: Math.floor((Date.now() - this.state.started.getTime()) / 1000)
+          }, { headers: corsHeaders });
+        }
+        if (path === "/health") {
+          return Response.json({ status: "ok" }, { headers: corsHeaders });
         }
+        return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
       }
     });
     console.log(`[Stack] API running on http://${host}:${port}`);
   }
-  getStatusJSON() {
-    return {
-      node: this.config.node.name,
-      channels: {
-        ssh: this.state.channels.ssh,
-        telegram: this.state.channels.telegram
-      },
-      api: {
-        enabled: this.state.api.enabled,
-        port: this.state.api.port
-      },
-      ralphLoops: this.state.ralphLoops.size,
-      uptime: Math.floor((Date.now() - this.state.started.getTime()) / 1000)
-    };
-  }
-  listRalphLoopsJSON() {
-    return Array.from(this.state.ralphLoops.values());
-  }
   async start() {
     console.log(`[Stack] Starting ${this.config.node.name}...`);
     this.abortController = new AbortController;
@@ -57703,7 +57610,7 @@ Prompt: ${prompt.slice(0, 100)}...`;
     if (this.state.api.enabled) {
       console.log(`  - API: :${this.state.api.port}`);
     }
-    console.log("  - Commands: /ralph start|list|stop, /status, /memory <cmd>");
+    console.log("  - Commands: /status, /memory <cmd>");
     await new Promise(() => {});
   }
   async stop() {
@@ -57735,10 +57642,6 @@ async function main() {
       port: parseInt(process.env.API_PORT || "8911", 10),
       host: process.env.API_HOST
     },
-    ralph: {
-      worktreesDir: process.env.WORKTREES_DIR || "/root/worktrees",
-      repoUrl: process.env.REPO_URL || ""
-    },
     node: {
       name: process.env.NODE_NAME || "stack",
       hostname: process.env.HOSTNAME || "localhost"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ebowwa/stack",
-  "version": "0.1.3",
-  "description": "Full-stack daemon orchestrator combining unified-router (cross-channel) and node-agent (Ralph orchestration)",
+  "version": "0.2.0",
+  "description": "Cross-channel AI stack with shared memory (SSH + Telegram)",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,12 +20,12 @@
   },
   "keywords": [
     "stack",
-    "orchestrator",
-    "daemon",
-    "ralph",
+    "channel",
     "telegram",
     "ssh",
-    "ai"
+    "ai",
+    "cross-channel",
+    "memory"
   ],
   "author": "Ebowwa Labs <labs@ebowwa.com>",
   "license": "MIT",
@@ -40,10 +40,7 @@
     "@ebowwa/channel-ssh": "^2.1.1",
     "@ebowwa/channel-telegram": "^1.14.2",
     "@ebowwa/channel-types": "^0.2.1",
-    "@ebowwa/codespaces-types": "^1.6.1",
-    "@ebowwa/daemons": "^0.5.0",
-    "@ebowwa/node-agent": "^0.6.4",
-    "@ebowwa/rolling-keys": "^0.1.1"
+    "@ebowwa/codespaces-types": "^1.6.1"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/index.ts

@@ -1,17 +1,18 @@
 #!/usr/bin/env bun
 /**
- * @ebowwa/stack - Full-Stack Daemon Orchestrator
+ * @ebowwa/stack - Cross-Channel AI Stack
  *
- * Combines:
+ * Features:
  * - Unified Router: Cross-channel communication (SSH + Telegram)
- * - Node Agent: Ralph loop orchestration, worktrees, monitoring
+ * - Cross-channel memory with permission controls
+ * - AI-powered message handling
  *
  * Architecture:
  *   ┌──────────────────────────────────────────────────────────────┐
  *   │                         STACK                                │
  *   │  ┌────────────────┐  ┌────────────────┐  ┌────────────────┐ │
- *   │  │ Unified Router │  │  Node Agent    │  │   HTTP API     │ │
- *   │  │ (chat/messaging)│  │ (Ralph loops)  │  │   (:8911)      │ │
+ *   │  │  SSH Channel   │  │Telegram Channel│  │   HTTP API     │ │
+ *   │  │  (optional)    │  │  (optional)    │  │  (optional)    │ │
  *   │  └───────┬────────┘  └───────┬────────┘  └───────┬────────┘ │
  *   │          │                   │                   │          │
  *   │          └───────────────────┴───────────────────┘          │
@@ -19,6 +20,10 @@
  *   │                    ┌─────────▼─────────┐                    │
  *   │                    │   Shared Memory    │                    │
  *   │                    │  (Cross-Context)   │                    │
+ *   │                    └─────────┬─────────┘                    │
+ *   │                              │                               │
+ *   │                    ┌─────────▼─────────┐                    │
+ *   │                    │   AI Brain (GLM)   │                    │
  *   │                    └───────────────────┘                    │
  *   └──────────────────────────────────────────────────────────────┘
  */
@@ -43,17 +48,11 @@ export interface StackConfig {
     botToken?: string;
     allowedChats?: number[];
   };
-  /** Enable HTTP API for Ralph management */
+  /** Enable HTTP API */
   api?: {
     port?: number;
     host?: string;
   };
-  /** Ralph loop configuration */
-  ralph?: {
-    worktreesDir: string;
-    repoUrl: string;
-    baseBranch?: string;
-  };
   /** AI configuration */
   ai?: {
     model?: string;
@@ -77,16 +76,6 @@ export interface StackState {
     enabled: boolean;
     port?: number;
   };
-  ralphLoops: Map<string, RalphLoopInfo>;
-}
-
-interface RalphLoopInfo {
-  id: string;
-  worktree: string;
-  prompt: string;
-  status: "running" | "paused" | "completed" | "error";
-  iterations: number;
-  started: Date;
 }
 
 // ============================================================
@@ -104,21 +93,17 @@ export class Stack {
   private abortController: AbortController | null = null;
 
   constructor(config: StackConfig) {
-    // Only set defaults for non-channel config
     this.config = {
       ...config,
       api: config.api ?? { port: 8911 },
-      ralph: config.ralph ?? { worktreesDir: "/root/worktrees", repoUrl: "" },
       ai: config.ai ?? { model: "GLM-4.7", temperature: 0.7, maxTokens: 4096 },
       node: config.node ?? { name: "stack", hostname: "localhost" },
-      // ssh and telegram remain undefined if not provided
     };
 
     this.state = {
       started: new Date(),
       channels: { ssh: false, telegram: false },
       api: { enabled: !!this.config.api, port: this.config.api?.port },
-      ralphLoops: new Map(),
     };
 
     // Build memory channels dynamically based on enabled channels
@@ -134,17 +119,13 @@ export class Stack {
       memoryChannels.telegram = { memoryFile: "/root/.telegram-memory.json", maxMessages: 50 };
       enabledChannels.push("telegram");
     }
-    if (this.config.api) {
-      memoryChannels.api = { memoryFile: "/root/.api-memory.json", maxMessages: 100 };
-      enabledChannels.push("api");
-    }
 
-    // Set up cross-channel permissions for enabled channels
+    // Set up cross-channel permissions
     for (const channel of enabledChannels) {
       permissions[channel] = { canRead: enabledChannels.filter(c => c !== channel) };
     }
 
-    // Initialize shared memory (empty if no channels)
+    // Initialize shared memory
     this.memory = createPermissionMemory({
       channels: memoryChannels,
       permissions,
@@ -156,7 +137,7 @@ export class Stack {
         serverName: this.config.node.name,
         hostname: this.config.node.hostname,
         packageName: "@ebowwa/stack",
-        version: "0.1.1",
+        version: "0.2.0",
       },
     });
 
@@ -208,25 +189,39 @@ export class Stack {
 
   private async handleMessage(routed: { message: ChannelMessage; channelId: ChannelId }): Promise<ChannelResponse> {
     const { message, channelId } = routed;
-    const channel = channelId.platform as "ssh" | "telegram" | "api";
+    const channel = channelId.platform as "ssh" | "telegram";
     const text = message.text;
 
     console.log(`[${channel}] ${text.slice(0, 50)}...`);
 
+    // Start typing indicator for Telegram
+    const telegramChannel = this.channels.get("telegram") as { startTypingIndicator?: (chatId: string) => void; stopTypingIndicator?: (chatId: string) => void } | undefined;
+    const chatId = channelId.metadata?.chatId as string | undefined;
+    if (channel === "telegram" && telegramChannel?.startTypingIndicator && chatId) {
+      telegramChannel.startTypingIndicator(chatId);
+    }
+
+    const stopTyping = () => {
+      if (channel === "telegram" && telegramChannel?.stopTypingIndicator && chatId) {
+        telegramChannel.stopTypingIndicator(chatId);
+      }
+    };
+
     // Check for memory commands
     const cmdResult = parseMemoryCommand(this.memory, channel, text);
     if (cmdResult.handled) {
+      stopTyping();
       return {
         content: { text: cmdResult.response || "Done" },
         replyTo: { messageId: message.messageId, channelId: message.channelId },
       };
     }
 
-    // Check for Ralph commands
-    const ralphResult = await this.handleRalphCommand(channel, text);
-    if (ralphResult) {
+    // Check for status command
+    if (text.trim().toLowerCase() === "/status") {
+      stopTyping();
       return {
-        content: { text: ralphResult },
+        content: { text: this.getStatus() },
         replyTo: { messageId: message.messageId, channelId: message.channelId },
       };
     }
@@ -252,6 +247,7 @@ export class Stack {
       });
 
       this.memory.addMessage(channel, { role: "assistant", content: result.content });
+      stopTyping();
 
       return {
         content: { text: result.content },
@@ -259,6 +255,7 @@ export class Stack {
       };
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
+      stopTyping();
       return {
         content: { text: `Error: ${errorMsg}` },
         replyTo: { messageId: message.messageId, channelId: message.channelId },
@@ -267,107 +264,39 @@ export class Stack {
   }
 
   private buildSystemPrompt(): string {
-    return `You are **${this.config.node.name}** — a 24/7 AI stack running on this node.
+    const channelList = Object.entries(this.state.channels)
+      .filter(([, v]) => v)
+      .map(([k]) => k)
+      .join(", ") || "none";
+
+    return `You are **${this.config.node.name}** — a 24/7 AI assistant.
 
-## What You Manage
-- **Ralph Loops**: Autonomous AI agents running tasks
-- **Git Worktrees**: Isolated development environments
-- **Node Monitoring**: CPU, memory, disk usage
-- **Cross-Channel Memory**: Shared context between SSH, Telegram, and API
+## Capabilities
+- Cross-channel memory (shared context between channels)
+- Tool execution via MCP
+- Node monitoring and management
 
 ## Commands
-- \`/ralph start <prompt>\` — Start a Ralph loop
-- \`/ralph list\` — List running loops
-- \`/ralph stop <id>\` — Stop a loop
 - \`/status\` — Node status
 - \`/memory <cmd>\` — Memory management (grant, revoke, list, clear)
 
-## Stack Info
+## Info
 - Node: ${this.config.node.name}
-- Channels: ${Object.entries(this.state.channels).filter(([, v]) => v).map(([k]) => k).join(", ") || "none"}
+- Channels: ${channelList}
 - API: :${this.config.api?.port ?? 8911}`;
   }
 
-  // ============================================================
-  // Ralph Loop Management (delegates to node-agent)
-  // ============================================================
-
-  private async handleRalphCommand(channel: string, text: string): Promise<string | null> {
-    const parts = text.trim().split(/\s+/);
-    const cmd = parts[0].toLowerCase();
-
-    if (cmd === "/ralph" || cmd === "/ralph") {
-      const subCmd = parts[1]?.toLowerCase();
-
-      switch (subCmd) {
-        case "start": {
-          const prompt = parts.slice(2).join(" ");
-          if (!prompt) return "Usage: /ralph start <prompt>";
-          return await this.startRalphLoop(prompt);
-        }
-        case "list":
-          return this.listRalphLoops();
-        case "stop": {
-          const id = parts[2];
-          if (!id) return "Usage: /ralph stop <id>";
-          return await this.stopRalphLoop(id);
-        }
-        default:
-          return "Ralph commands: start, list, stop";
-      }
-    }
-
-    if (cmd === "/status") {
-      return this.getStatus();
-    }
-
-    return null;
-  }
-
-  private async startRalphLoop(prompt: string): Promise<string> {
-    // TODO: Delegate to @ebowwa/node-agent RalphService
-    const id = `ralph-${Date.now()}`;
-    this.state.ralphLoops.set(id, {
-      id,
-      worktree: `${this.config.ralph.worktreesDir}/${id}`,
-      prompt,
-      status: "running",
-      iterations: 0,
-      started: new Date(),
-    });
-    return `Started Ralph loop: ${id}\nPrompt: ${prompt.slice(0, 100)}...`;
-  }
-
-  private listRalphLoops(): string {
-    if (this.state.ralphLoops.size === 0) {
-      return "No Ralph loops running";
-    }
-    const lines = ["Ralph Loops:"];
-    for (const [id, info] of this.state.ralphLoops) {
-      lines.push(`  ${id}: ${info.status} (${info.iterations} iters)`);
-    }
-    return lines.join("\n");
-  }
-
-  private async stopRalphLoop(id: string): Promise<string> {
-    const info = this.state.ralphLoops.get(id);
-    if (!info) return `Ralph loop not found: ${id}`;
-    info.status = "paused";
-    return `Stopped Ralph loop: ${id}`;
-  }
-
   private getStatus(): string {
     const lines = [
       `**${this.config.node.name} Status**`,
       `Channels: SSH=${this.state.channels.ssh}, Telegram=${this.state.channels.telegram}`,
-      `Ralph Loops: ${this.state.ralphLoops.size}`,
       `Uptime: ${Math.floor((Date.now() - this.state.started.getTime()) / 1000)}s`,
     ];
     return lines.join("\n");
   }
 
   // ============================================================
-  // HTTP API
+  // HTTP API (minimal)
   // ============================================================
 
   private startAPI(): void {
@@ -376,17 +305,16 @@ export class Stack {
     const port = this.config.api.port ?? 8911;
     const host = this.config.api.host ?? "0.0.0.0";
 
-    const server = Bun.serve({
+    Bun.serve({
       port,
       host,
       fetch: async (req) => {
         const url = new URL(req.url);
         const path = url.pathname;
 
-        // CORS headers
         const corsHeaders = {
           "Access-Control-Allow-Origin": "*",
-          "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Methods": "GET, OPTIONS",
           "Access-Control-Allow-Headers": "Content-Type",
         };
 
@@ -394,69 +322,25 @@ export class Stack {
           return new Response(null, { headers: corsHeaders });
         }
 
-        try {
-          // GET /api/status
-          if (path === "/api/status" && req.method === "GET") {
-            return Response.json(this.getStatusJSON(), { headers: corsHeaders });
-          }
-
-          // GET /api/ralph-loops
-          if (path === "/api/ralph-loops" && req.method === "GET") {
-            return Response.json(this.listRalphLoopsJSON(), { headers: corsHeaders });
-          }
-
-          // POST /api/ralph-loops
-          if (path === "/api/ralph-loops" && req.method === "POST") {
-            const body = await req.json();
-            const prompt = body.prompt;
-            if (!prompt) {
-              return Response.json({ error: "Missing prompt" }, { status: 400, headers: corsHeaders });
-            }
-            const result = await this.startRalphLoop(prompt);
-            return Response.json({ message: result }, { headers: corsHeaders });
-          }
-
-          // DELETE /api/ralph-loops/:id
-          const match = path.match(/^\/api\/ralph-loops\/(.+)$/);
-          if (match && req.method === "DELETE") {
-            const result = await this.stopRalphLoop(match[1]);
-            return Response.json({ message: result }, { headers: corsHeaders });
-          }
-
-          // GET /health
-          if (path === "/health") {
-            return Response.json({ status: "ok" }, { headers: corsHeaders });
-          }
-
-          return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error);
-          return Response.json({ error: errorMsg }, { status: 500, headers: corsHeaders });
+        // GET /api/status
+        if (path === "/api/status" && req.method === "GET") {
+          return Response.json({
+            node: this.config.node.name,
+            channels: this.state.channels,
+            uptime: Math.floor((Date.now() - this.state.started.getTime()) / 1000),
+          }, { headers: corsHeaders });
         }
-      },
-    });
 
-    console.log(`[Stack] API running on http://${host}:${port}`);
-  }
+        // GET /health
+        if (path === "/health") {
+          return Response.json({ status: "ok" }, { headers: corsHeaders });
+        }
 
-  private getStatusJSON(): object {
-    return {
-      node: this.config.node.name,
-      channels: {
-        ssh: this.state.channels.ssh,
-        telegram: this.state.channels.telegram,
-      },
-      api: {
-        enabled: this.state.api.enabled,
-        port: this.state.api.port,
+        return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
       },
-      ralphLoops: this.state.ralphLoops.size,
-      uptime: Math.floor((Date.now() - this.state.started.getTime()) / 1000),
-    };
-  }
+    });
 
-  private listRalphLoopsJSON(): object[] {
-    return Array.from(this.state.ralphLoops.values());
+    console.log(`[Stack] API running on http://${host}:${port}`);
   }
 
   // ============================================================
@@ -468,17 +352,12 @@ export class Stack {
 
     this.abortController = new AbortController();
 
-    // Register channels (only if configured)
     await this.registerSSH();
     await this.registerTelegram();
 
-    // Set handler
     this.router.setHandler((routed) => this.handleMessage(routed));
-
-    // Start router
     await this.router.start();
 
-    // Start API (optional)
     this.startAPI();
 
     console.log("[Stack] Running!");
@@ -491,10 +370,9 @@ export class Stack {
     if (this.state.api.enabled) {
       console.log(`  - API: :${this.state.api.port}`);
     }
-    console.log("  - Commands: /ralph start|list|stop, /status, /memory <cmd>");
+    console.log("  - Commands: /status, /memory <cmd>");
 
-    // Keep running
-    await new Promise(() => {}); // Run forever
+    await new Promise(() => {});
   }
 
   async stop(): Promise<void> {
@@ -502,7 +380,6 @@ export class Stack {
     this.abortController?.abort();
     await this.router.stop();
 
-    // Stop all channels
     for (const [name, channel] of this.channels) {
       console.log(`[Stack] Stopping ${name}...`);
       await channel.stop();
@@ -517,31 +394,23 @@ export class Stack {
 // ============================================================
 
 async function main() {
-  // Build config - only enable channels when explicitly configured
   const config: StackConfig = {
-    // SSH only enabled if SSH_CHAT_DIR is set
     ...(process.env.SSH_CHAT_DIR ? {
       ssh: {
         chatDir: process.env.SSH_CHAT_DIR,
         pollInterval: parseInt(process.env.SSH_POLL_INTERVAL || "500", 10),
       }
     } : {}),
-    // Telegram only enabled if bot token is set
     ...(process.env.TELEGRAM_BOT_TOKEN ? {
       telegram: {
         botToken: process.env.TELEGRAM_BOT_TOKEN,
         allowedChats: process.env.TELEGRAM_CHAT_ID ? [parseInt(process.env.TELEGRAM_CHAT_ID, 10)] : undefined,
       }
     } : {}),
-    // API enabled by default
     api: {
       port: parseInt(process.env.API_PORT || "8911", 10),
       host: process.env.API_HOST,
     },
-    ralph: {
-      worktreesDir: process.env.WORKTREES_DIR || "/root/worktrees",
-      repoUrl: process.env.REPO_URL || "",
-    },
     node: {
       name: process.env.NODE_NAME || "stack",
       hostname: process.env.HOSTNAME || "localhost",
@@ -550,7 +419,6 @@ async function main() {
 
   const stack = new Stack(config);
 
-  // Handle shutdown
   process.on("SIGINT", async () => {
     await stack.stop();
     process.exit(0);
@@ -564,7 +432,6 @@ async function main() {
   await stack.start();
 }
 
-// Run if executed directly
 if (import.meta.main) {
   main().catch((error) => {
     console.error("[Stack] Fatal error:", error);