@inceptionstack/roundhouse 0.5.20 → 0.5.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/gateway/gateway.ts

@@ -814,34 +814,10 @@ export class Gateway {
 
     // Only fire for the primary (first) chat
     const primaryChatId = chatIds[0];
-    const threadId = `telegram:${primaryChatId}`;
     const agentThreadId = "main";
 
-    // Create a synthetic Telegram-compatible thread so streaming, HTML conversion,
-    // message splitting, and progressive edits all work identically to real chat threads.
-    const token = process.env.TELEGRAM_BOT_TOKEN;
-    const syntheticThread = {
-      id: threadId,
-      adapter: {
-        telegramFetch: async (method: string, payload: Record<string, unknown>) => {
-          if (!token) return null;
-          const res = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ chat_id: primaryChatId, ...payload }),
-            signal: AbortSignal.timeout(30_000),
-          });
-          if (!res.ok) return null;
-          const json = await res.json() as { result?: unknown };
-          return json.result ?? null;
-        },
-      },
-      post: async (content: string | { markdown: string }) => {
-        const text = typeof content === "string" ? content : content.markdown;
-        await this.transport.notify([primaryChatId], text);
-      },
-      startTyping: async () => {},
-    };
+    // Create a thread via the transport adapter — no transport-specific logic in gateway
+    const syntheticThread = this.transport.createThread(primaryChatId);
 
     const bootPrompt = "You just came online after a restart. Say a brief hello in-character (1–2 sentences max). Check your workspace for any pending tasks.";
 

package/src/subagents/orchestrator.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, stat } from "node:fs/promises";
+import { mkdir, stat, readFile } from "node:fs/promises";
 import type { ChildProcess } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -168,10 +168,29 @@ export class SubAgentOrchestratorImpl implements SubAgentOrchestrator, SubAgentL
 
     const outcome = current.requestedOutcome
       ? this.terminationHandler.terminalStatusFor(current)
-      : (exitCode === 0 ? "complete" : "failed");
+      : await this.inferOutcome(runId, exitCode);
 
     await this.finalizer.finalizeRun(runId, outcome, { exitCode: exitCode ?? undefined });
   }
+  /**
+   * Determine terminal status for a child exit.
+   * If exit code is non-zero but the agent produced meaningful stdout output,
+   * treat as "complete" — the work succeeded but the process had a teardown error
+   * (e.g. pi-hard-no stale context exception on session close).
+   */
+  private async inferOutcome(runId: string, exitCode: number | null): Promise<"complete" | "failed"> {
+    if (exitCode === 0) return "complete";
+    if (exitCode === null) return "failed"; // signal-killed, not a teardown error
+    try {
+      const stdoutPath = join(this.store.getRunDir(runId), "stdout.log");
+      const content = await readFile(stdoutPath, "utf-8");
+      // If stdout has substantial content (>50 chars), the agent did its job
+      if (content.trim().length > 50) return "complete";
+    } catch {
+      // No stdout file or can't read — fall through to failed
+    }
+    return "failed";
+  }
 }
 
 async function assertDirectoryExists(path: string): Promise<void> {

package/src/transports/telegram/telegram-adapter.ts

@@ -50,6 +50,33 @@ export class TelegramAdapter implements TransportAdapter {
     return isTelegramThread(thread as any);
   }
 
+  createThread(chatId: number): ChatThread {
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    const threadId = `telegram:${chatId}`;
+    const telegramFetch = async (method: string, payload: Record<string, unknown>) => {
+      if (!token) return null;
+      const res = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ chat_id: chatId, ...payload }),
+        signal: AbortSignal.timeout(30_000),
+      });
+      if (!res.ok) return null;
+      const json = await res.json() as { result?: unknown };
+      return json.result ?? null;
+    };
+    const thread: ChatThread = {
+      id: threadId,
+      adapter: { telegramFetch },
+      post: async (content: string | { markdown: string }) => {
+        const text = typeof content === "string" ? content : content.markdown;
+        await postTelegramHtml(thread as any, text);
+      },
+      startTyping: async () => {},
+    };
+    return thread;
+  }
+
   async notify(chatIds: number[], text: string, options?: { parseMode?: string }): Promise<void> {
     if (!process.env.TELEGRAM_BOT_TOKEN) {
       console.warn("[roundhouse] TELEGRAM_BOT_TOKEN not set — skipping notification");

package/src/transports/types.ts

@@ -56,6 +56,14 @@ export interface TransportAdapter {
   /** Send notifications to configured recipients */
   notify(chatIds: number[], text: string, options?: { parseMode?: string }): Promise<void>;
 
+  /**
+   * Create a thread object for a given chat ID.
+   * Used by gateway for synthetic turns (boot turn, cron notifications)
+   * where no incoming message triggered the interaction.
+   * Returns a thread compatible with the streaming system.
+   */
+  createThread(chatId: number): ChatThread;
+
   /**
    * Check if a pairing flow is pending.
    * Gateway uses this to decide whether to attempt pairing on incoming messages.