@clawroom/openclaw 0.3.0 → 0.5.0

package/README.md

@@ -7,6 +7,7 @@ OpenClaw channel plugin for the ClawRoom task marketplace. Connects your OpenCla
 ```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
 ```
 
@@ -28,11 +29,11 @@ openclaw gateway restart
 
 ## Release
 
-The repository includes a GitHub Actions workflow that publishes `@clawroom/protocol`, `@clawroom/sdk`, and `@clawroom/openclaw` to npm when a release tag is pushed.
+The repository includes a GitHub Actions workflow that publishes `@clawroom/protocol`, `@clawroom/sdk`, `@clawroom/bridge`, and `@clawroom/openclaw` to npm when a release tag is pushed.
 
 To publish a new version:
 
-1. Update the package versions in `protocol/package.json`, `sdk/package.json`, and `plugin/package.json`.
+1. Update the package versions in `protocol/package.json`, `sdk/package.json`, `bridge/package.json`, and `plugin/package.json`.
 2. Commit and push the release commit to GitHub.
 3. Push a release tag, for example `git tag plugin-0.2.3 && git push origin plugin-0.2.3`.
-4. Watch `.github/workflows/release-plugin.yml` until all three publish jobs succeed.
+4. Watch `.github/workflows/release-plugin.yml` until all publish jobs succeed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawroom/openclaw",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "OpenClaw channel plugin for ClawRoom",
   "type": "module",
   "license": "MIT",
@@ -22,7 +22,7 @@
     "@clawroom/sdk"
   ],
   "dependencies": {
-    "@clawroom/sdk": "^0.3.0"
+    "@clawroom/sdk": "^0.5.0"
   },
   "peerDependencies": {
     "openclaw": "*"

package/src/channel.ts

@@ -1,18 +1,19 @@
 import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { collectSkills } from "./skill-reporter.js";
+// import { collectSkills } from "./skill-reporter.js";
 import { getClawroomRuntime } from "./runtime.js";
-import { ClawroomClient } from "./client.js";
+import { ClawroomPluginClient } from "./client.js";
 import { setupTaskExecutor } from "./task-executor.js";
 import { setupChatExecutor } from "./chat-executor.js";
 
 // ── Config resolution ────────────────────────────────────────────────
 
-const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/agents";
+const DEFAULT_ENDPOINT = "https://clawroom.site9.ai/api/machines";
 const DEFAULT_ACCOUNT_ID = "default";
 
 interface ClawroomAccountConfig {
-  token?: string;
+  api_key?: string;
+  token?: string; // deprecated, fallback
   endpoint?: string;
   skills?: string[];
   enabled?: boolean;
@@ -23,7 +24,7 @@ interface ResolvedClawroomAccount {
   name: string;
   enabled: boolean;
   configured: boolean;
-  token: string;
+  apiKey: string;
   endpoint: string;
   skills: string[];
 }
@@ -39,7 +40,7 @@ function resolveClawroomAccount(opts: {
   accountId?: string | null;
 }): ResolvedClawroomAccount {
   const section = readClawroomSection(opts.cfg);
-  const token = section.token ?? "";
+  const apiKey = section.api_key ?? section.token ?? "";
   const endpoint = section.endpoint || DEFAULT_ENDPOINT;
   const skills = Array.isArray(section.skills) ? section.skills : [];
   const enabled = section.enabled !== false;
@@ -48,8 +49,8 @@ function resolveClawroomAccount(opts: {
     accountId: opts.accountId ?? DEFAULT_ACCOUNT_ID,
     name: "ClawRoom",
     enabled,
-    configured: token.length > 0,
-    token,
+    configured: apiKey.length > 0,
+    apiKey,
     endpoint,
     skills,
   };
@@ -57,7 +58,7 @@ function resolveClawroomAccount(opts: {
 
 // ── Persistent client per gateway lifecycle ───────────────────────
 
-let activeClient: ClawroomClient | null = null;
+let activeClient: ClawroomPluginClient | null = null;
 
 // ── Channel plugin definition ────────────────────────────────────────
 
@@ -104,17 +105,9 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
     deliveryMode: "direct",
 
     sendText: async ({ to, text }) => {
-      // Outbound messages are task results sent via HTTP.
-      // The task-executor sends results directly through client.send();
-      // this adapter exists for completeness if openclaw routing tries
-      // to deliver a reply through the channel outbound path.
-      if (activeClient) {
-        activeClient.send({
-          type: "agent.complete",
-          taskId: to,
-          output: text,
-        });
-      }
+      // Outbound path — task results are sent directly by executors,
+      // this is a fallback if openclaw routing triggers outbound delivery.
+      // No-op for machine client (executors handle it).
       return { channel: "clawroom", messageId: to, to };
     },
   },
@@ -125,24 +118,16 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
 
       if (!account.configured) {
         throw new Error(
-          "ClawRoom is not configured: set channels.clawroom.token in your OpenClaw config.",
+          "ClawRoom is not configured: set channels.clawroom.api_key in your OpenClaw config.",
         );
       }
 
       const runtime = getClawroomRuntime();
-      const skills = collectSkills({
-        runtime,
-        configuredSkills: account.skills,
-      });
-
-      const deviceId = resolveDeviceId(ctx);
       const log = ctx.log ?? undefined;
 
-      const client = new ClawroomClient({
+      const client = new ClawroomPluginClient({
         endpoint: account.endpoint,
-        token: account.token,
-        deviceId,
-        skills,
+        apiKey: account.apiKey,
         log,
       });
 
@@ -170,23 +155,11 @@ export const clawroomPlugin: ChannelPlugin<ResolvedClawroomAccount> = {
         });
       };
 
-      // Wire up HTTP polling events to OpenClaw health status
+      // Wire up polling events to OpenClaw health status
       client.onWelcome(() => publishConnected());
-      client.onTask(() => {
-        // Any server task = update lastEventAt so gateway knows we're alive
-        ctx.setStatus({
-          accountId: account.accountId,
-          running: true,
-          connected: true,
-          lastEventAt: Date.now(),
-          lastStartAt: Date.now(),
-          lastStopAt: null,
-          lastError: null,
-        });
-      });
       client.onDisconnect(() => publishDisconnected());
-      client.onFatal((reason, code) => {
-        log?.error?.(`[clawroom] fatal error (code ${code}): ${reason}`);
+      client.onFatal((reason) => {
+        log?.error?.(`[clawroom] fatal error: ${reason}`);
         ctx.setStatus({
           accountId: account.accountId,
           running: false,

package/src/chat-executor.ts

@@ -1,6 +1,5 @@
-import type { ServerChatMessage } from "@clawroom/sdk";
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
-import type { ClawroomClient } from "./client.js";
+import type { ClawroomPluginClient } from "./client.js";
 
 /** Default timeout for chat reply subagent (2 minutes). */
 const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
@@ -12,7 +11,7 @@ const CHAT_TIMEOUT_MS = 2 * 60 * 1000;
  *   3. Send reply back to channel
  */
 export function setupChatExecutor(opts: {
-  client: ClawroomClient;
+  client: ClawroomPluginClient;
   runtime: PluginRuntime;
   log?: {
     info?: (message: string, ...args: unknown[]) => void;
@@ -22,61 +21,70 @@ export function setupChatExecutor(opts: {
 }): void {
   const { client, runtime, log } = opts;
 
-  client.onChatMessage((messages: ServerChatMessage[]) => {
+  client.onAgentChat((agentId: string, messages: any[]) => {
     for (const msg of messages) {
-      void handleChatMention({ client, runtime, msg, log });
+      void handleChatMention({ client, runtime, msg, agentId, log });
     }
   });
 }
 
 async function handleChatMention(opts: {
-  client: ClawroomClient;
+  client: ClawroomPluginClient;
   runtime: PluginRuntime;
-  msg: ServerChatMessage;
+  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, log } = opts;
-  const sessionKey = `clawroom:chat:${msg.channelId}:${msg.messageId}`;
+  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.send({ type: "agent.typing", channelId: msg.channelId });
+  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 = [
-    "You were mentioned in a chat channel. Reply concisely and helpfully.",
+    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,
     "",
-    "## Message that mentioned you",
+    isMention ? "## Message that mentioned you" : "## Latest message",
     msg.content,
   ].join("\n");
 
   try {
     // Keep typing indicator alive during execution
     const typingInterval = setInterval(() => {
-      client.send({ type: "agent.typing", channelId: msg.channelId });
+      client.sendTyping(agentId, msg.channelId).catch(() => {});
     }, 3000);
 
     const { runId } = await runtime.subagent.run({
       sessionKey,
       idempotencyKey: `clawroom:chat:${msg.messageId}`,
       message: agentMessage,
-      extraSystemPrompt:
-        "You are responding to a chat @mention in ClawRoom. " +
-        "Keep your reply SHORT and conversational (1-3 sentences). " +
-        "Do NOT include file paths, system info, or markdown headers. " +
-        "Just answer naturally like a helpful teammate.",
+      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",
     });
 
@@ -89,23 +97,13 @@ async function handleChatMention(opts: {
 
     if (waitResult.status === "error") {
       log?.error?.(`[clawroom:chat] subagent error: ${waitResult.error}`);
-      client.send({
-        type: "agent.chat.reply",
-        channelId: msg.channelId,
-        content: "Sorry, I encountered an error processing your message.",
-        replyTo: msg.messageId,
-      });
+      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}`);
-      client.send({
-        type: "agent.chat.reply",
-        channelId: msg.channelId,
-        content: "Sorry, I took too long to respond. Please try again.",
-        replyTo: msg.messageId,
-      });
+      await client.sendChatReply(agentId, msg.channelId, "Sorry, I took too long to respond. Please try again.");
       return;
     }
 
@@ -116,13 +114,15 @@ async function handleChatMention(opts: {
 
     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)}"`);
-    client.send({
-      type: "agent.chat.reply",
-      channelId: msg.channelId,
-      content: reply,
-      replyTo: msg.messageId,
-    });
+    await client.sendChatReply(agentId, msg.channelId, reply);
 
     await runtime.subagent.deleteSession({
       sessionKey,
@@ -131,12 +131,7 @@ async function handleChatMention(opts: {
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
     log?.error?.(`[clawroom:chat] unexpected error: ${reason}`);
-    client.send({
-      type: "agent.chat.reply",
-      channelId: msg.channelId,
-      content: "Sorry, something went wrong. Please try again.",
-      replyTo: msg.messageId,
-    });
+    await client.sendChatReply(agentId, msg.channelId, "Sorry, something went wrong. Please try again.");
   }
 }
 

package/src/client.ts

@@ -1,63 +1,56 @@
-import { ClawroomClient as BaseClient } from "@clawroom/sdk";
-import type { ClawroomClientOptions } from "@clawroom/sdk";
+import { ClawroomMachineClient } from "@clawroom/sdk";
+import type { ClawroomMachineClientOptions } from "@clawroom/sdk";
 
 type DisconnectCallback = () => void;
-type WelcomeCallback = (agentId: string) => void;
-type FatalCallback = (reason: string, code?: number) => void;
+type WelcomeCallback = (machineId: string) => void;
+type FatalCallback = (reason: string) => void;
 
 /**
- * Plugin-specific ClawRoom client that extends the SDK client
- * with OpenClaw lifecycle hooks (connected state, disconnect, fatal).
+ * Plugin-specific ClawRoom machine client.
+ * Wraps ClawroomMachineClient with OpenClaw lifecycle hooks.
  */
-export class ClawroomClient extends BaseClient {
-  private connected = false;
+export class ClawroomPluginClient {
+  private inner: ClawroomMachineClient;
   private disconnectCallbacks: DisconnectCallback[] = [];
   private welcomeCallbacks: WelcomeCallback[] = [];
   private fatalCallbacks: FatalCallback[] = [];
 
-  constructor(options: ClawroomClientOptions) {
-    super(options);
+  constructor(options: ClawroomMachineClientOptions) {
+    this.inner = new ClawroomMachineClient(options);
   }
 
-  get isAlive(): boolean { return !this.stopped; }
-  get isConnected(): boolean { return this.connected; }
+  get isAlive(): boolean { return !this.inner.stopped; }
+  get isConnected(): boolean { return this.inner.connected; }
 
   onDisconnect(cb: DisconnectCallback): void { this.disconnectCallbacks.push(cb); }
   onWelcome(cb: WelcomeCallback): void { this.welcomeCallbacks.push(cb); }
   onFatal(cb: FatalCallback): void { this.fatalCallbacks.push(cb); }
 
-  override disconnect(): void {
-    super.disconnect();
-    this.markDisconnected();
+  onAgentTask(handler: (agentId: string, task: any) => void) { this.inner.onAgentTask(handler); }
+  onAgentChat(handler: (agentId: string, messages: any[]) => void) { this.inner.onAgentChat(handler); }
+
+  async sendComplete(agentId: string, taskId: string, output: string, attachments?: Array<{ filename: string; mimeType: string; data: string }>) {
+    await this.inner.sendAgentComplete(agentId, taskId, output);
+  }
+
+  async sendFail(agentId: string, taskId: string, reason: string) {
+    await this.inner.sendAgentFail(agentId, taskId, reason);
   }
 
-  protected override onPollSuccess(agentId: string | undefined): void {
-    if (!this.connected) {
-      this.connected = true;
-      this.options.log?.info?.("[clawroom] polling connected");
-      if (agentId) {
-        for (const cb of this.welcomeCallbacks) cb(agentId);
-      }
-    }
+  async sendChatReply(agentId: string, channelId: string, content: string) {
+    await this.inner.sendAgentChatReply(agentId, channelId, content);
   }
 
-  protected override onPollError(_err: unknown): void {
-    this.markDisconnected();
+  async sendTyping(agentId: string, channelId: string) {
+    await this.inner.sendAgentTyping(agentId, channelId);
   }
 
-  protected override onHttpError(status: number, text: string): void {
-    if (status === 401) {
-      this.stopped = true;
-      this.markDisconnected();
-      for (const cb of this.fatalCallbacks) cb(`Unauthorized: ${text}`, 401);
-    }
+  connect(): void {
+    this.inner.connect();
   }
 
-  private markDisconnected(): void {
-    if (!this.connected) return;
-    this.connected = false;
+  disconnect(): void {
+    this.inner.disconnect();
     for (const cb of this.disconnectCallbacks) cb();
   }
 }
-
-export type { ClawroomClientOptions };

package/src/task-executor.ts

@@ -1,208 +1,99 @@
-import type { 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.
- *
- * Tasks are assigned by humans and delivered via /poll.
- * On receiving an assigned task, execute it immediately via subagent.
- */
 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;
   const activeTasks = new Set<string>();
 
-  client.onTask((task: ServerTask) => {
-    if (activeTasks.has(task.taskId)) {
-      log?.info?.(`[clawroom:executor] task ${task.taskId} already running, skipping`);
-      return;
-    }
-
-    log?.info?.(`[clawroom:executor] executing assigned task ${task.taskId}: ${task.title}`);
-    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,
-    });
-  }
-}
-
-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(", ")}`);
+    log?.error?.(`[clawroom:executor] [${agentId}] error: ${reason}`);
+    await client.sendFail(agentId, task.taskId, reason);
   }
-  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) {
@@ -210,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);
       }
     }
@@ -225,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;
 }