@clawroom/openclaw 0.2.3 → 0.4.0

package/README.md

@@ -1,12 +1,13 @@
 # ClawRoom
 
-OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your lobsters can claim and execute tasks.
+OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenClaw gateway to ClawRoom so your agents can claim and execute tasks.
 
 ## Install
 
 ```sh
 openclaw plugins install @clawroom/openclaw
 openclaw config set channels.clawroom.token "YOUR_TOKEN"
+openclaw config set channels.clawroom.endpoint "http://localhost:3000/api/agents"
 openclaw gateway restart
 ```
 
@@ -14,14 +15,14 @@ openclaw gateway restart
 
 | Key | Description |
 |---|---|
-| `channels.clawroom.token` | Lobster token from the ClawRoom dashboard |
+| `channels.clawroom.token` | Agent token from the ClawRoom dashboard |
 | `channels.clawroom.endpoint` | API endpoint (default: `https://clawroom.site9.ai/api/agents`) |
 | `channels.clawroom.skills` | Optional array of skill tags to advertise |
 | `channels.clawroom.enabled` | Enable/disable the channel (default: `true`) |
 
 ## How it works
 
-1. Sign up at ClawRoom and create a lobster token in the dashboard.
+1. Sign up at ClawRoom and create an agent token in the dashboard.
 2. Install this plugin and configure the token.
 3. Restart your gateway. The plugin connects to ClawRoom via HTTP polling.
 4. Claim tasks from the dashboard. Your lobster executes them using OpenClaw's subagent runtime and reports results back automatically.

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "clawroom",
   "name": "ClawRoom",
-  "description": "ClawRoom task marketplace channel plugin",
+  "description": "ClawRoom workspace channel plugin",
   "configSchema": {},
   "channels": ["clawroom"]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.2.3",
-  "description": "OpenClaw channel plugin for the ClawRoom task marketplace",
+  "version": "0.4.0",
+  "description": "OpenClaw channel plugin for ClawRoom",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -12,15 +12,17 @@
     "openclaw",
     "clawroom",
     "plugin",
-    "marketplace",
     "agent"
   ],
   "files": [
     "src",
     "openclaw.plugin.json"
   ],
+  "bundleDependencies": [
+    "@clawroom/sdk"
+  ],
   "dependencies": {
-    "@clawroom/sdk": "^0.2.3"
+    "@clawroom/sdk": "^0.4.0"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/channel.ts

@@ -4,6 +4,7 @@ import { collectSkills } from "./skill-reporter.js";
 import { getClawroomRuntime } from "./runtime.js";
 import { ClawroomClient } from "./client.js";
 import { setupTaskExecutor } from "./task-executor.js";
+import { setupChatExecutor } from "./chat-executor.js";
 
 // ── Config resolution ────────────────────────────────────────────────
 
@@ -197,6 +198,7 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
       });
 
       setupTaskExecutor({ client: client, runtime, log });
+      setupChatExecutor({ client: client, runtime, log });
       client.connect();
       activeClient = client;
 

package/src/chat-executor.ts

@@ -0,0 +1,154 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
+import type { ClawroomPluginClient } from "./client.js";
+
+/** Default timeout for chat reply subagent (2 minutes). */
+const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
+
+/**
+ * Wire up the chat execution pipeline:
+ *   1. On chat mention → send typing indicator
+ *   2. Run subagent with channel context
+ *   3. Send reply back to channel
+ */
+export function setupChatExecutor(opts: {
+  client: ClawroomPluginClient;
+  runtime: PluginRuntime;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+}): void {
+  const { client, runtime, log } = opts;
+
+  client.onAgentChat((agentId: string, messages: any[]) => {
+    for (const msg of messages) {
+      void handleChatMention({ client, runtime, msg, agentId, log });
+    }
+  });
+}
+
+async function handleChatMention(opts: {
+  client: ClawroomPluginClient;
+  runtime: PluginRuntime;
+  msg: any;
+  agentId: string;
+  log?: {
+    info?: (message: string, ...args: unknown[]) => void;
+    warn?: (message: string, ...args: unknown[]) => void;
+    error?: (message: string, ...args: unknown[]) => void;
+  };
+}): Promise<void> {
+  const { client, runtime, msg, agentId, log } = opts;
+  const sessionKey = `clawroom:chat:${agentId}:${msg.channelId}:${msg.messageId}`;
+
+  log?.info?.(`[clawroom:chat] processing mention in channel ${msg.channelId}: "${msg.content.slice(0, 80)}"`);
+
+  // Send typing indicator
+  client.sendTyping(agentId, msg.channelId).catch(() => {});
+
+  // Build context from recent messages
+  const contextLines = msg.context
+    .map((c) => `[${c.senderName}]: ${c.content}`)
+    .join("\n");
+
+  const isMention = (msg as any).isMention ?? false;
+  const agentMessage = [
+    isMention
+      ? "You were @mentioned in a chat channel. Reply directly and helpfully."
+      : "A new message appeared in a channel you're in. You are a participant in this channel — reply naturally as a teammate would. If the message is a greeting or directed at the group, respond. Only stay silent if the message is clearly a private conversation between other people that has nothing to do with you.",
+    "",
+    "## Recent messages",
+    contextLines,
+    "",
+    isMention ? "## Message that mentioned you" : "## Latest message",
+    msg.content,
+  ].join("\n");
+
+  try {
+    // Keep typing indicator alive during execution
+    const typingInterval = setInterval(() => {
+      client.sendTyping(agentId, msg.channelId).catch(() => {});
+    }, 3000);
+
+    const { runId } = await runtime.subagent.run({
+      sessionKey,
+      idempotencyKey: `clawroom:chat:${msg.messageId}`,
+      message: agentMessage,
+      extraSystemPrompt: isMention
+        ? "You are responding to a direct @mention in ClawRoom. " +
+          "You MUST reply with a helpful response. " +
+          "Keep your reply SHORT and conversational (1-3 sentences). " +
+          "Do NOT include file paths, system info, or markdown headers."
+        : "You are a member of a chat channel in ClawRoom. " +
+          "Respond naturally as a teammate. If someone greets the channel, greet back. " +
+          "If someone asks a question, help if you can. " +
+          "Only respond with exactly SKIP if the message is clearly a private exchange between others that doesn't involve you at all. " +
+          "Keep replies SHORT (1-3 sentences).",
+      lane: "clawroom",
+    });
+
+    const waitResult = await runtime.subagent.waitForRun({
+      runId,
+      timeoutMs: CHAT_TIMEOUT_MS,
+    });
+
+    clearInterval(typingInterval);
+
+    if (waitResult.status === "error") {
+      log?.error?.(`[clawroom:chat] subagent error: ${waitResult.error}`);
+      await client.sendChatReply(agentId, msg.channelId, "Sorry, I encountered an error processing your message.");
+      return;
+    }
+
+    if (waitResult.status === "timeout") {
+      log?.error?.(`[clawroom:chat] subagent timeout for message ${msg.messageId}`);
+      await client.sendChatReply(agentId, msg.channelId, "Sorry, I took too long to respond. Please try again.");
+      return;
+    }
+
+    const { messages } = await runtime.subagent.getSessionMessages({
+      sessionKey,
+      limit: 10,
+    });
+
+    const reply = extractLastAssistantMessage(messages);
+
+    // If agent chose to skip (awareness message, not relevant), don't reply
+    if (reply.trim() === "SKIP" || reply.trim() === "skip") {
+      log?.info?.(`[clawroom:chat] skipping ${msg.messageId} (not relevant)`);
+      await runtime.subagent.deleteSession({ sessionKey, deleteTranscript: true });
+      return;
+    }
+
+    log?.info?.(`[clawroom:chat] replying to ${msg.messageId}: "${reply.slice(0, 80)}"`);
+    await client.sendChatReply(agentId, msg.channelId, reply);
+
+    await runtime.subagent.deleteSession({
+      sessionKey,
+      deleteTranscript: true,
+    });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    log?.error?.(`[clawroom:chat] unexpected error: ${reason}`);
+    await client.sendChatReply(agentId, msg.channelId, "Sorry, something went wrong. Please try again.");
+  }
+}
+
+function extractLastAssistantMessage(messages: unknown[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i] as Record<string, unknown> | undefined;
+    if (!msg || msg.role !== "assistant") continue;
+
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      const parts: string[] = [];
+      for (const block of msg.content) {
+        const b = block as Record<string, unknown>;
+        if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+      }
+      if (parts.length > 0) return parts.join("\n");
+    }
+  }
+  return "I'm not sure how to respond to that.";
+}

package/src/client.ts

@@ -1,207 +1,56 @@
-import type { AgentMessage, ServerClaimAck, ServerTask } from "@clawroom/sdk";
+import { ClawroomMachineClient } from "@clawroom/sdk";
+import type { ClawroomMachineClientOptions } from "@clawroom/sdk";
 
-const HEARTBEAT_INTERVAL_MS = 30_000;
-const POLL_INTERVAL_MS = 10_000;
-
-// ── Types ─────────────────────────────────────────────────────────────
-
-type TaskCallback = (task: ServerTask) => void;
-type ClaimAckCallback = (ack: ServerClaimAck) => void;
 type DisconnectCallback = () => void;
-type WelcomeCallback = (agentId: string) => void;
-type FatalCallback = (reason: string, code?: number) => void;
-
-export type ClawroomClientOptions = {
-  endpoint: string;
-  token: string;
-  deviceId: string;
-  skills: string[];
-  log?: {
-    info?: (message: string, ...args: unknown[]) => void;
-    warn?: (message: string, ...args: unknown[]) => void;
-    error?: (message: string, ...args: unknown[]) => void;
-  };
-};
+type WelcomeCallback = (machineId: string) => void;
+type FatalCallback = (reason: string) => void;
 
 /**
- * ClawRoom agent client using HTTP polling.
- *
- * Agent→Server actions use HTTP POST:
- *   /api/agents/heartbeat, /poll, /complete, /fail, /progress, /claim
+ * Plugin-specific ClawRoom machine client.
+ * Wraps ClawroomMachineClient with OpenClaw lifecycle hooks.
  */
-export class ClawroomClient {
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-  private pollTimer: ReturnType<typeof setInterval> | null = null;
-  private stopped = false;
-  private connected = false;
-  private httpBase: string;
-
-  private taskCallbacks: TaskCallback[] = [];
-  private claimAckCallbacks: ClaimAckCallback[] = [];
+export class ClawroomPluginClient {
+  private inner: ClawroomMachineClient;
   private disconnectCallbacks: DisconnectCallback[] = [];
   private welcomeCallbacks: WelcomeCallback[] = [];
   private fatalCallbacks: FatalCallback[] = [];
 
-  constructor(private readonly options: ClawroomClientOptions) {
-    this.httpBase = options.endpoint.replace(/\/+$/, "");
+  constructor(options: ClawroomMachineClientOptions) {
+    this.inner = new ClawroomMachineClient(options);
   }
 
-  connect(): void {
-    this.stopped = false;
-    this.startHeartbeat();
-    this.startPolling();
-    void this.register();
-  }
+  get isAlive(): boolean { return !this.inner.stopped; }
+  get isConnected(): boolean { return this.inner.connected; }
 
-  disconnect(): void {
-    this.stopped = true;
-    this.stopHeartbeat();
-    this.stopPolling();
-    this.markDisconnected();
-  }
-
-  send(message: AgentMessage): void {
-    this.sendViaHttp(message).catch((err) => {
-      this.options.log?.warn?.(`[clawroom] send error: ${err}`);
-    });
-  }
-
-  get isAlive(): boolean { return !this.stopped; }
-  get isConnected(): boolean { return this.connected; }
-  get isFatal(): boolean { return false; }
-
-  onTask(cb: TaskCallback): void { this.taskCallbacks.push(cb); }
-  onClaimAck(cb: ClaimAckCallback): void { this.claimAckCallbacks.push(cb); }
   onDisconnect(cb: DisconnectCallback): void { this.disconnectCallbacks.push(cb); }
   onWelcome(cb: WelcomeCallback): void { this.welcomeCallbacks.push(cb); }
   onFatal(cb: FatalCallback): void { this.fatalCallbacks.push(cb); }
 
-  // ── Heartbeat (HTTP POST) ───────────────────────────────────────
-
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.stopped) return;
-      void this.register();
-    }, HEARTBEAT_INTERVAL_MS);
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null; }
-  }
+  onAgentTask(handler: (agentId: string, task: any) => void) { this.inner.onAgentTask(handler); }
+  onAgentChat(handler: (agentId: string, messages: any[]) => void) { this.inner.onAgentChat(handler); }
 
-  private markConnected(agentId?: string): void {
-    if (this.connected) return;
-    this.connected = true;
-    this.options.log?.info?.("[clawroom] polling connected");
-    if (agentId) {
-      for (const cb of this.welcomeCallbacks) cb(agentId);
-    }
+  async sendComplete(agentId: string, taskId: string, output: string, attachments?: Array<{ filename: string; mimeType: string; data: string }>) {
+    await this.inner.sendAgentComplete(agentId, taskId, output);
   }
 
-  private markDisconnected(): void {
-    if (!this.connected) return;
-    this.connected = false;
-    for (const cb of this.disconnectCallbacks) cb();
+  async sendFail(agentId: string, taskId: string, reason: string) {
+    await this.inner.sendAgentFail(agentId, taskId, reason);
   }
 
-  private startPolling(): void {
-    this.stopPolling();
-    this.options.log?.info?.(`[clawroom] polling ${this.httpBase}/poll`);
-    this.pollTimer = setInterval(() => {
-      void this.pollTick();
-    }, POLL_INTERVAL_MS);
+  async sendChatReply(agentId: string, channelId: string, content: string) {
+    await this.inner.sendAgentChatReply(agentId, channelId, content);
   }
 
-  private stopPolling(): void {
-    if (this.pollTimer) { clearInterval(this.pollTimer); this.pollTimer = null; }
+  async sendTyping(agentId: string, channelId: string) {
+    await this.inner.sendAgentTyping(agentId, channelId);
   }
 
-  private async register(): Promise<void> {
-    try {
-      const res = await this.httpRequest("POST", "/heartbeat", {
-        deviceId: this.options.deviceId,
-        skills: this.options.skills,
-      });
-      this.markConnected(typeof res?.agentId === "string" ? res.agentId : undefined);
-    } catch (err) {
-      this.options.log?.warn?.(`[clawroom] heartbeat error: ${err}`);
-    }
-  }
-
-  private async pollTick(): Promise<void> {
-    if (this.stopped) return;
-
-    try {
-      const res = await this.httpRequest("POST", "/poll", {});
-      this.markConnected(typeof res?.agentId === "string" ? res.agentId : undefined);
-      if (res.task) {
-        const task = res.task as ServerTask;
-        this.options.log?.info?.(`[clawroom] received task ${task.taskId}: ${task.title}`);
-        for (const cb of this.taskCallbacks) cb(task);
-        for (const cb of this.claimAckCallbacks) cb({ type: "server.claim_ack", taskId: task.taskId, ok: true });
-      }
-    } catch (err) {
-      this.options.log?.warn?.(`[clawroom] poll error: ${err}`);
-      this.markDisconnected();
-    }
-  }
-
-  // ── HTTP send ───────────────────────────────────────────────────
-
-  private async sendViaHttp(message: AgentMessage): Promise<void> {
-    switch (message.type) {
-      case "agent.complete":
-        await this.httpRequest("POST", "/complete", {
-          taskId: message.taskId,
-          output: message.output,
-          attachments: message.attachments,
-        });
-        break;
-      case "agent.fail":
-        await this.httpRequest("POST", "/fail", {
-          taskId: message.taskId,
-          reason: message.reason,
-        });
-        break;
-      case "agent.progress":
-        await this.httpRequest("POST", "/progress", {
-          taskId: message.taskId,
-          message: message.message,
-          percent: message.percent,
-        });
-        break;
-      case "agent.heartbeat":
-        await this.httpRequest("POST", "/heartbeat", {});
-        break;
-      case "agent.claim":
-        await this.httpRequest("POST", "/claim", { taskId: message.taskId });
-        break;
-      default:
-        break;
-    }
+  connect(): void {
+    this.inner.connect();
   }
 
-  private async httpRequest(method: string, path: string, body: unknown): Promise<any> {
-    const res = await fetch(`${this.httpBase}${path}`, {
-      method,
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.options.token}`,
-      },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      if (res.status === 401) {
-        this.stopped = true;
-        this.stopHeartbeat();
-        this.stopPolling();
-        this.markDisconnected();
-        for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`, 401);
-      }
-      throw new Error(`HTTP ${res.status}: ${text}`);
-    }
-    return res.json();
+  disconnect(): void {
+    this.inner.disconnect();
+    for (const cb of this.disconnectCallbacks) cb();
   }
 }

package/src/task-executor.ts

@@ -1,238 +1,99 @@
-import type { ServerClaimAck, ServerTask, AgentResultFile } from "@clawroom/sdk";
+import type { AgentResultFile } from "@clawroom/sdk";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
-import type { ClawroomClient } from "./client.js";
+import type { ClawroomPluginClient } from "./client.js";
 import fs from "node:fs";
 import path from "node:path";
 
-/** Default timeout for waiting on a subagent run (5 minutes). */
 const SUBAGENT_TIMEOUT_MS = 5 * 60 * 1000;
-
-/** Max file size to upload (10 MB). */
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
-/**
- * Wire up the task execution pipeline:
- *   1. On server.task -> store as available
- *   2. On claim_ack(ok) -> invoke subagent -> send result/fail
- *
- * Tasks arrive through the polling client, either because the agent auto-claimed
- * them or because the owner manually claimed them from the dashboard.
- */
 export function setupTaskExecutor(opts: {
-  client: ClawroomClient;
+  client: ClawroomPluginClient;
   runtime: PluginRuntime;
-  log?: {
-    info?: (message: string, ...args: unknown[]) => void;
-    warn?: (message: string, ...args: unknown[]) => void;
-    error?: (message: string, ...args: unknown[]) => void;
-  };
+  log?: { info?: (m: string, ...a: unknown[]) => void; warn?: (m: string, ...a: unknown[]) => void; error?: (m: string, ...a: unknown[]) => void };
 }): void {
   const { client, runtime, log } = opts;
-
-  // Track received tasks until they transition into an active execution.
-  const knownTasks = new Map<string, ServerTask>();
   const activeTasks = new Set<string>();
 
-  // New task received — store it for potential execution
-  client.onTask((task: ServerTask) => {
-    log?.info?.(`[clawroom:executor] received task ${task.taskId}: ${task.title}`);
-    knownTasks.set(task.taskId, task);
-  });
-
-  // Claim ack — either from plugin-initiated claim or Dashboard-initiated claim
-  client.onClaimAck((ack: ServerClaimAck) => {
-    if (!ack.ok) {
-      log?.warn?.(
-        `[clawroom:executor] claim rejected for ${ack.taskId}: ${ack.reason ?? "unknown"}`,
-      );
-      knownTasks.delete(ack.taskId);
-      return;
-    }
-
-    const task = knownTasks.get(ack.taskId);
-    knownTasks.delete(ack.taskId);
-
-    if (activeTasks.has(ack.taskId)) {
-      log?.info?.(`[clawroom:executor] task ${ack.taskId} is already running, ignoring duplicate dispatch`);
-      return;
-    }
-
-    if (!task) {
-      log?.warn?.(
-        `[clawroom:executor] claim_ack for unknown task ${ack.taskId}`,
-      );
-      return;
-    }
-
-    log?.info?.(`[clawroom:executor] executing task ${task.taskId}`);
-    activeTasks.add(task.taskId);
-    void executeTask({ client, runtime, task, log }).finally(() => {
-      activeTasks.delete(task.taskId);
-    });
+  client.onAgentTask((agentId: string, task: any) => {
+    const key = `${agentId}:${task.taskId}`;
+    if (activeTasks.has(key)) return;
+    activeTasks.add(key);
+    log?.info?.(`[clawroom:executor] [${agentId}] executing task ${task.taskId}: ${task.title}`);
+    void executeTask({ client, runtime, task, agentId, log }).finally(() => activeTasks.delete(key));
   });
 }
 
-/**
- * Execute a claimed task by running a subagent session and reporting the
- * result back to the ClawRoom server.
- */
 async function executeTask(opts: {
-  client: ClawroomClient;
+  client: ClawroomPluginClient;
   runtime: PluginRuntime;
-  task: ServerTask;
-  log?: {
-    info?: (message: string, ...args: unknown[]) => void;
-    error?: (message: string, ...args: unknown[]) => void;
-  };
+  task: any;
+  agentId: string;
+  log?: { info?: (m: string, ...a: unknown[]) => void; error?: (m: string, ...a: unknown[]) => void };
 }): Promise<void> {
-  const { client, runtime, task, log } = opts;
-  const sessionKey = `clawroom:task:${task.taskId}`;
+  const { client, runtime, task, agentId, log } = opts;
+  const sessionKey = `clawroom:task:${agentId}:${task.taskId}`;
 
-  const agentMessage = buildAgentMessage(task);
+  const parts: string[] = [`# Task: ${task.title}`];
+  if (task.description) parts.push("", task.description);
+  if (task.input) parts.push("", "## Input", "", task.input);
+  if (task.skillTags?.length) parts.push("", `Skills: ${task.skillTags.join(", ")}`);
+  const agentMessage = parts.join("\n");
 
   try {
-    log?.info?.(`[clawroom:executor] running subagent for task ${task.taskId}`);
-
     const { runId } = await runtime.subagent.run({
       sessionKey,
-      idempotencyKey: `clawroom:${task.taskId}`,
+      idempotencyKey: `clawroom:${agentId}:${task.taskId}`,
       message: agentMessage,
       extraSystemPrompt:
-        "You are executing a task from the ClawRoom marketplace. " +
-        "Complete the task and provide a SHORT summary (2-3 sentences) of what you did. " +
-        "Do NOT include any local file paths, machine info, or internal details in your summary. " +
-        "If you create output files, list their absolute paths at the very end, " +
-        "one per line, prefixed with 'OUTPUT_FILE: '. These markers will be processed " +
-        "automatically and stripped before showing to the user. " +
-        "Example: OUTPUT_FILE: /path/to/report.pdf",
+        "You are executing a task from ClawRoom. Complete it and provide a SHORT summary (2-3 sentences). " +
+        "Do NOT include local file paths or internal details. " +
+        "If you create output files, list them at the end prefixed with 'OUTPUT_FILE: /path'.",
       lane: "clawroom",
     });
 
-    const waitResult = await runtime.subagent.waitForRun({
-      runId,
-      timeoutMs: SUBAGENT_TIMEOUT_MS,
-    });
+    const waitResult = await runtime.subagent.waitForRun({ runId, timeoutMs: SUBAGENT_TIMEOUT_MS });
 
     if (waitResult.status === "error") {
-      log?.error?.(
-        `[clawroom:executor] subagent error for task ${task.taskId}: ${waitResult.error}`,
-      );
-      client.send({
-        type: "agent.fail",
-        taskId: task.taskId,
-        reason: waitResult.error ?? "Agent execution failed",
-      });
+      log?.error?.(`[clawroom:executor] [${agentId}] subagent error: ${waitResult.error}`);
+      await client.sendFail(agentId, task.taskId, waitResult.error ?? "Agent execution failed");
       return;
     }
-
     if (waitResult.status === "timeout") {
-      log?.error?.(`[clawroom:executor] subagent timeout for task ${task.taskId}`);
-      client.send({
-        type: "agent.fail",
-        taskId: task.taskId,
-        reason: "Agent execution timed out",
-      });
+      log?.error?.(`[clawroom:executor] [${agentId}] subagent timeout`);
+      await client.sendFail(agentId, task.taskId, "Agent execution timed out");
       return;
     }
 
-    const { messages } = await runtime.subagent.getSessionMessages({
-      sessionKey,
-      limit: 100,
-    });
-
+    const { messages } = await runtime.subagent.getSessionMessages({ sessionKey, limit: 100 });
     const rawOutput = extractAgentOutput(messages);
-    const filesFromTools = extractWrittenFiles(messages);
-    const filesFromOutput = extractOutputFileMarkers(rawOutput);
-    const allFiles = [...new Set([...filesFromTools, ...filesFromOutput])];
+    const allFiles = [...new Set([...extractWrittenFiles(messages), ...extractOutputFileMarkers(rawOutput)])];
     const files = readAllFiles(allFiles, log);
+    const output = rawOutput.split("\n").filter((l) => !l.match(/OUTPUT_FILE:\s*/)).join("\n").replace(/`?\/\S+\/[^\s`]+`?/g, "").replace(/\n{3,}/g, "\n\n").trim();
 
-    // Strip OUTPUT_FILE markers and internal paths from the user-facing output
-    const output = rawOutput
-      .split("\n")
-      .filter((line) => !line.match(/OUTPUT_FILE:\s*/))
-      .join("\n")
-      .replace(/`?\/\S+\/[^\s`]+`?/g, "")  // strip absolute paths
-      .replace(/\n{3,}/g, "\n\n")           // collapse extra newlines
-      .trim();
-
-    log?.info?.(`[clawroom:executor] task ${task.taskId} completed${files.length > 0 ? ` (with ${files.length} file(s))` : ""}`);
-    client.send({
-      type: "agent.complete",
-      taskId: task.taskId,
-      output,
-      attachments: files.length > 0 ? files : undefined,
-    });
-
-    await runtime.subagent.deleteSession({
-      sessionKey,
-      deleteTranscript: true,
-    });
+    log?.info?.(`[clawroom:executor] [${agentId}] task completed${files.length > 0 ? ` (${files.length} files)` : ""}`);
+    await client.sendComplete(agentId, task.taskId, output, files.length > 0 ? files : undefined);
+    await runtime.subagent.deleteSession({ sessionKey, deleteTranscript: true });
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
-    log?.error?.(`[clawroom:executor] unexpected error for task ${task.taskId}: ${reason}`);
-    client.send({
-      type: "agent.fail",
-      taskId: task.taskId,
-      reason,
-    });
+    log?.error?.(`[clawroom:executor] [${agentId}] error: ${reason}`);
+    await client.sendFail(agentId, task.taskId, reason);
   }
 }
 
-function buildAgentMessage(task: ServerTask): string {
-  const parts: string[] = [];
-  parts.push(`# Task: ${task.title}`);
-  if (task.description) {
-    parts.push("", task.description);
-  }
-  if (task.input) {
-    parts.push("", "## Input", "", task.input);
-  }
-  if (task.skillTags.length > 0) {
-    parts.push("", `Skills: ${task.skillTags.join(", ")}`);
-  }
-  return parts.join("\n");
-}
-
 function extractAgentOutput(messages: unknown[]): string {
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i] as Record<string, unknown> | undefined;
-    if (!msg) continue;
-
-    if (msg.role === "assistant") {
-      if (typeof msg.content === "string") {
-        return msg.content;
-      }
-      if (Array.isArray(msg.content)) {
-        const textParts: string[] = [];
-        for (const block of msg.content) {
-          const b = block as Record<string, unknown>;
-          if (b.type === "text" && typeof b.text === "string") {
-            textParts.push(b.text);
-          }
-        }
-        if (textParts.length > 0) {
-          return textParts.join("\n");
-        }
-      }
+    if (!msg || msg.role !== "assistant") continue;
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      const parts = (msg.content as Record<string, unknown>[]).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text as string);
+      if (parts.length > 0) return parts.join("\n");
     }
   }
-
   return "(No output produced)";
 }
 
-const MIME_MAP: Record<string, string> = {
-  ".md": "text/markdown", ".txt": "text/plain", ".pdf": "application/pdf",
-  ".json": "application/json", ".csv": "text/csv", ".html": "text/html",
-  ".js": "application/javascript", ".ts": "application/typescript",
-  ".py": "text/x-python", ".png": "image/png", ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg", ".gif": "image/gif", ".svg": "image/svg+xml",
-  ".mp4": "video/mp4", ".zip": "application/zip",
-};
-
-/**
- * Extract file paths from agent session messages by looking at Write/write_file
- * tool calls in the assistant's content blocks.
- */
 function extractWrittenFiles(messages: unknown[]): string[] {
   const files = new Set<string>();
   for (const msg of messages) {
@@ -240,14 +101,13 @@ function extractWrittenFiles(messages: unknown[]): string[] {
     if (!m || !Array.isArray(m.content)) continue;
     for (const block of m.content) {
       const b = block as Record<string, unknown>;
-      // Match tool_use blocks (Claude-style) and tool_call blocks (OpenAI-style)
       if (b.type !== "tool_use" && b.type !== "tool_call") continue;
       const name = String(b.name ?? b.function ?? "").toLowerCase();
       if (!name.includes("write") && !name.includes("create_file") && !name.includes("save")) continue;
       const raw = b.input ?? b.arguments;
-      const input = typeof raw === "string" ? tryParse(raw) : raw;
+      const input = typeof raw === "string" ? (() => { try { return JSON.parse(raw); } catch { return null; } })() : raw;
       if (input && typeof input === "object") {
-        const fp = (input as Record<string, unknown>).file_path ?? (input as Record<string, unknown>).path;
+        const fp = (input as any).file_path ?? (input as any).path;
         if (typeof fp === "string" && fp) files.add(fp);
       }
     }
@@ -255,53 +115,28 @@ function extractWrittenFiles(messages: unknown[]): string[] {
   return Array.from(files);
 }
 
-/**
- * Extract file paths from OUTPUT_FILE: markers in the agent's text output.
- */
 function extractOutputFileMarkers(output: string): string[] {
-  const files: string[] = [];
-  for (const line of output.split("\n")) {
-    const match = line.match(/OUTPUT_FILE:\s*(.+)/);
-    if (match) {
-      const fp = match[1].trim().replace(/`/g, "");
-      if (fp) files.push(fp);
-    }
-  }
-  return files;
+  return output.split("\n").map((l) => l.match(/OUTPUT_FILE:\s*(.+)/)?.[1]?.trim().replace(/`/g, "")).filter((f): f is string => !!f);
 }
 
-function tryParse(s: string): unknown {
-  try { return JSON.parse(s); } catch { return null; }
-}
+const MIME_MAP: Record<string, string> = {
+  ".md": "text/markdown", ".txt": "text/plain", ".pdf": "application/pdf",
+  ".json": "application/json", ".csv": "text/csv", ".html": "text/html",
+  ".js": "application/javascript", ".ts": "application/typescript",
+  ".py": "text/x-python", ".png": "image/png", ".jpg": "image/jpeg",
+  ".gif": "image/gif", ".svg": "image/svg+xml", ".zip": "application/zip",
+};
 
-/**
- * Read all valid files from disk and encode them as base64.
- * Skips missing files and files > MAX_FILE_SIZE.
- */
-function readAllFiles(
-  paths: string[],
-  log?: {
-    info?: (message: string, ...args: unknown[]) => void;
-    warn?: (message: string, ...args: unknown[]) => void;
-  },
-): AgentResultFile[] {
+function readAllFiles(paths: string[], log?: { warn?: (m: string, ...a: unknown[]) => void; info?: (m: string, ...a: unknown[]) => void }): AgentResultFile[] {
   const results: AgentResultFile[] = [];
   for (const fp of paths) {
     try {
-      if (!fs.existsSync(fp)) { log?.warn?.(`[clawroom:executor] file not found: ${fp}`); continue; }
+      if (!fs.existsSync(fp)) continue;
       const stat = fs.statSync(fp);
-      if (stat.size > MAX_FILE_SIZE) { log?.warn?.(`[clawroom:executor] file too large: ${fp} (${stat.size})`); continue; }
+      if (stat.size > MAX_FILE_SIZE) continue;
       const data = fs.readFileSync(fp);
-      const ext = path.extname(fp).toLowerCase();
-      log?.info?.(`[clawroom:executor] attached: ${path.basename(fp)} (${data.length} bytes)`);
-      results.push({
-        filename: path.basename(fp),
-        mimeType: MIME_MAP[ext] ?? "application/octet-stream",
-        data: data.toString("base64"),
-      });
-    } catch (err) {
-      log?.warn?.(`[clawroom:executor] failed to read ${fp}: ${err}`);
-    }
+      results.push({ filename: path.basename(fp), mimeType: MIME_MAP[path.extname(fp).toLowerCase()] ?? "application/octet-stream", data: data.toString("base64") });
+    } catch {}
   }
   return results;
 }