@inceptionstack/roundhouse 0.5.22 → 0.5.25

package/src/gateway/topic-command.ts

@@ -6,14 +6,41 @@
  *
  * Usage:
  *   /topic deploy    — switch to "deploy" topic (creates if new)
- *   /topic           — show current topic + list all
+ *   /topic           — show current topic + list of known topics as
+ *                     clickable inline-keyboard buttons (Telegram)
  *   /topic main      — return to default session
+ *
+ * Inline keyboard: when called with no args in a private chat and at
+ * least one known topic exists, we send a Telegram inline keyboard so
+ * the user can switch with a tap. Clicking a button fires a callback
+ * routed through chat.onAction(TOPIC_ACTION_ID) → handleTopicAction().
  */
 
 import { readFileSync, writeFileSync, mkdirSync, readdirSync, renameSync } from "node:fs";
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { ROUNDHOUSE_DIR } from "../config";
+import {
+  encodeCallbackData,
+  toKeyboardRows,
+  extractTelegramChatId,
+  type ChatThreadLike,
+  type InlineButton,
+  type InlineKeyboard,
+} from "./inline-keyboard";
+
+/** Action ID for topic-select inline-keyboard callbacks */
+export const TOPIC_ACTION_ID = "topic_select";
+
+/**
+ * Special sentinel value used by the "🏠 main (default)" button.
+ *
+ * Must be a string that `normalizeTopicName()` can never emit, so that a user
+ * who creates a topic via `/topic <name>` can't accidentally collide with it.
+ * The normalizer strips leading/trailing `-`, so any sentinel starting or
+ * ending with `-` is unrepresentable as a user-created topic name.
+ */
+const MAIN_SENTINEL = "-main";
 
 const TOPICS_FILE = join(ROUNDHOUSE_DIR, "active-topics.json");
 
@@ -75,16 +102,44 @@ export function listTopics(chatId: string): string[] {
 }
 
 export interface TopicCommandContext {
-  thread: { id: string };
+  thread: ChatThreadLike;
   text: string;
-  postWithFallback: (thread: any, text: string) => Promise<void>;
+  postWithFallback: (thread: ChatThreadLike, text: string) => Promise<void>;
+}
+
+/** Build an inline keyboard listing all known topics + a "main" escape hatch. */
+function buildTopicKeyboard(topics: string[], current: string | undefined): InlineKeyboard {
+  const onMain = !current;
+  const buttons: InlineButton[] = [];
+
+  // Always include "main (default)" first so users can escape back.
+  // ✓ appears when we're currently on main (i.e. no active topic).
+  buttons.push({
+    text: onMain ? "🏠 main (default) ✓" : "🏠 main (default)",
+    callback_data: encodeCallbackData(TOPIC_ACTION_ID, MAIN_SENTINEL),
+  });
+
+  for (const t of topics) {
+    const isActive = t === current;
+    buttons.push({
+      text: isActive ? `📂 ${t} ✓` : `📂 ${t}`,
+      callback_data: encodeCallbackData(TOPIC_ACTION_ID, t),
+    });
+  }
+
+  return toKeyboardRows(buttons);
+}
+
+/** Normalize a topic name the same way as the command parser. */
+function normalizeTopicName(raw: string): string {
+  return raw.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
 }
 
 export async function handleTopic(ctx: TopicCommandContext): Promise<void> {
   const { thread, text, postWithFallback } = ctx;
 
   // Extract chat ID from thread (for private: "telegram:<chatId>")
-  const chatId = thread.id?.split(":")[1] ?? thread.id;
+  const chatId = (thread?.id?.split(":")[1] ?? thread?.id ?? "") as string;
 
   // /topic only works in private chats (groups use forum topics instead)
   if (chatId && chatId.startsWith("-")) {
@@ -94,24 +149,98 @@ export async function handleTopic(ctx: TopicCommandContext): Promise<void> {
 
   // Parse the topic name from the command
   const match = text.match(/^\/topic(?:@\S+)?\s+(.+)/i);
-  const topicName = match?.[1]?.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
+  const topicName = match?.[1] ? normalizeTopicName(match[1]) : "";
 
   if (!topicName) {
-    // Show current topic + known topics
-    const current = getActiveTopic(chatId) ?? "main (default)";
-    const known = listTopics(chatId);
-    let msg = `📂 Current topic: \`${current}\`\n\n`;
-    if (known.length > 0) {
-      msg += `Known topics: ${known.map(t => `\`${t}\``).join(", ")}\n\n`;
-    }
-    msg += `Switch with: \`/topic <name>\`\nReturn to default: \`/topic main\``;
-    await postWithFallback(thread, msg);
+    await showTopicMenu(thread, chatId, postWithFallback);
     return;
   }
 
+  await applyTopicSelection(chatId, topicName, thread, postWithFallback);
+}
+
+/** Show the current topic + inline keyboard (or text fallback). */
+async function showTopicMenu(
+  thread: ChatThreadLike,
+  chatId: string,
+  postWithFallback: (thread: ChatThreadLike, text: string) => Promise<void>,
+): Promise<void> {
+  const current = getActiveTopic(chatId);
+  const currentDisplay = current ?? "main (default)";
+  const known = listTopics(chatId);
+
+  // Try inline keyboard if we have any known topics and the adapter supports
+  // raw Telegram calls. Otherwise fall back to text.
+  const telegramFetch = thread?.adapter?.telegramFetch;
+  if (known.length > 0 && telegramFetch) {
+    const tgChatId = extractTelegramChatId(thread);
+    if (tgChatId) {
+      try {
+        await telegramFetch("sendMessage", {
+          chat_id: tgChatId,
+          text: `📂 Current topic: <b>${currentDisplay}</b>\n\nTap a topic to switch:`,
+          parse_mode: "HTML",
+          reply_markup: buildTopicKeyboard(known, current),
+        });
+        return;
+      } catch (err) {
+        console.warn("[roundhouse] /topic inline keyboard failed, falling back:", (err as Error).message);
+      }
+    }
+  }
+
+  // Text fallback
+  let msg = `📂 Current topic: \`${currentDisplay}\`\n\n`;
+  if (known.length > 0) {
+    msg += `Known topics: ${known.map(t => `\`${t}\``).join(", ")}\n\n`;
+  }
+  msg += `Switch with: \`/topic <name>\`\nReturn to default: \`/topic main\``;
+  await postWithFallback(thread, msg);
+}
+
+/**
+ * Apply a topic selection. Shared by `/topic <name>` and inline-keyboard clicks.
+ * `topicName` must already be normalized (or be a known sentinel like "main").
+ */
+export async function applyTopicSelection(
+  chatId: string,
+  topicName: string,
+  thread: ChatThreadLike,
+  postWithFallback: (thread: ChatThreadLike, text: string) => Promise<void>,
+): Promise<void> {
   setActiveTopic(chatId, topicName);
-  const display = topicName === "main" || topicName === "off" ? "main (default)" : topicName;
-  const isNew = topicName !== "main" && topicName !== "off";
-  const emoji = isNew ? "📂" : "🏠";
-  await postWithFallback(thread, `${emoji} Switched to topic: \`${display}\`\n\nAgent context is now independent for this topic.`);
+  const isDefault = topicName === "main" || topicName === "off" || topicName === "";
+  const display = isDefault ? "main (default)" : topicName;
+  const emoji = isDefault ? "🏠" : "📂";
+  const suffix = isDefault
+    ? "Back to the default session."
+    : "Agent context is now independent for this topic.";
+  await postWithFallback(thread, `${emoji} Switched to topic: \`${display}\`\n\n${suffix}`);
+}
+
+/**
+ * Handle inline-keyboard callback for topic selection.
+ * Call this from chat.onAction(TOPIC_ACTION_ID, ...).
+ */
+export async function handleTopicAction(event: {
+  value?: string;
+  thread: ChatThreadLike;
+}): Promise<void> {
+  const raw = event.value;
+  if (!raw) return;
+
+  const thread = event.thread;
+  const chatId = (thread?.id?.split(":")[1] ?? thread?.id ?? "") as string;
+  if (!chatId) return;
+
+  const topicName = raw === MAIN_SENTINEL ? "main" : normalizeTopicName(raw);
+  if (!topicName && raw !== MAIN_SENTINEL) return;
+
+  const postFn = async (_t: ChatThreadLike, text: string) => {
+    if (!thread?.post) return;
+    try { await thread.post({ markdown: text }); }
+    catch { try { await thread.post(text); } catch { /* ignore */ } }
+  };
+
+  await applyTopicSelection(chatId, topicName, thread, postFn);
 }

package/src/memory/lifecycle.ts

@@ -227,20 +227,44 @@ export async function flushMemoryThenCompact(
   const effectiveLevel = level === "manual" ? "hard" : level;
   const t0 = Date.now();
 
+  // On "emergency" we skip the flush step entirely. Flush is a normal agent
+  // prompt turn routed through the live session (see PiAdapter.promptWithModel
+  // → entry.session.prompt). At emergency pressure the session is already at
+  // or above the model's context limit, so appending any turn — including the
+  // flush prompt — will be rejected by the provider (e.g. Bedrock returns
+  // "prompt is too long: N tokens > 200000 maximum"). Because the catch block
+  // below re-arms `pendingCompact`, this would loop forever on every user
+  // turn. pi-ai's `session.compact()` builds its own summarization payload
+  // from older history (keeping `keepRecentTokens` recent messages) and does
+  // NOT require the live session to fit under the limit — so skipping flush
+  // lets us recover. Facts-to-MEMORY.md (the whole point of flush) is a
+  // best-effort nicety that the next soft/hard flush can catch up on.
+  const skipFlush = effectiveLevel === "emergency";
+
   try {
-    // Step 1: flush
-    const flushText = buildFlushPrompt(mode === "unknown" ? "full" : mode, effectiveLevel);
-    console.log(`[memory] flushing memory for ${threadId} (level: ${level}${flushModel ? `, model: ${flushModel}` : ""})`);
-    await onProgress?.("💭 Flushing memory...");
-    await sendFlush(flushText);
-    const flushMs = Date.now() - t0;
+    let flushMs = 0;
+    if (!skipFlush) {
+      // Step 1: flush
+      const flushText = buildFlushPrompt(mode === "unknown" ? "full" : mode, effectiveLevel);
+      console.log(`[memory] flushing memory for ${threadId} (level: ${level}${flushModel ? `, model: ${flushModel}` : ""})`);
+      await onProgress?.("💭 Flushing memory...");
+      await sendFlush(flushText);
+      flushMs = Date.now() - t0;
+    } else {
+      console.log(`[memory] skipping flush for ${threadId} — emergency pressure, going straight to compact`);
+    }
 
     // Step 2: compact (use flush model if compactWithModel is available)
-    console.log(`[memory] compacting ${threadId} (flush took ${flushMs}ms)`);
-    await onProgress?.(`✂️ Compacting context... (flush took ${(flushMs / 1000).toFixed(1)}s)`);
+    const flushNote = skipFlush ? "flush skipped (emergency)" : `flush took ${flushMs}ms`;
+    console.log(`[memory] compacting ${threadId} (${flushNote})`);
+    const progressNote = skipFlush
+      ? "✂️ Compacting context... (emergency — skipping flush)"
+      : `✂️ Compacting context... (flush took ${(flushMs / 1000).toFixed(1)}s)`;
+    await onProgress?.(progressNote);
     const t1 = Date.now();
-    const result = flushModel && agent.compactWithModel
-      ? await agent.compactWithModel(threadId, flushModel)
+    const usedCompactModel = Boolean(flushModel && agent.compactWithModel);
+    const result = usedCompactModel
+      ? await agent.compactWithModel!(threadId, flushModel!)
       : await agent.compact!(threadId);
     const compactMs = Date.now() - t1;
     if (!result) return null;
@@ -255,7 +279,17 @@ export async function flushMemoryThenCompact(
     }
 
     const totalMs = Date.now() - t0;
-    const timing = { flushMs, compactMs, totalMs, model: flushModel ?? "default" };
+    // Telemetry nuance: if we called agent.compactWithModel(flushModel), that's
+    // what we *requested*. But per the AgentAdapter contract, a BaseAdapter-
+    // derived adapter may provide only a default `compactWithModel` shim that
+    // ignores modelId and delegates to compact() (see src/agents/base-adapter.ts).
+    // We cannot distinguish a real override from the shim at this layer
+    // without widening the adapter return type to include `modelUsed`.
+    // So `timing.model` is the requested model, not a guaranteed-used one.
+    // Follow-up: return {modelUsed} from compact/compactWithModel for precise
+    // telemetry. At minimum we correctly report "default" when no flushModel
+    // was even requested, or when compactWithModel is entirely absent.
+    const timing = { flushMs, compactMs, totalMs, model: usedCompactModel ? flushModel! : "default" };
     console.log(`[memory] flush+compact done for ${threadId}: ${result.tokensBefore} → ${result.tokensAfter ?? "?"} tokens | flush=${flushMs}ms compact=${compactMs}ms total=${totalMs}ms model=${timing.model}`);
 
     // Persist timing log for debugging (async, fire-and-forget)

package/src/subagents/orchestrator.ts

@@ -43,6 +43,11 @@ export class SubAgentOrchestratorImpl implements SubAgentOrchestrator, SubAgentL
     });
   }
   onCompletion(listener: (status: RunStatus) => Promise<void> | void): () => void { return this.finalizer.onCompletion(listener); }
+  private spawnListeners: Array<(status: RunStatus) => Promise<void> | void> = [];
+  onSpawn(listener: (status: RunStatus) => Promise<void> | void): () => void {
+    this.spawnListeners.push(listener);
+    return () => { this.spawnListeners = this.spawnListeners.filter(l => l !== listener); };
+  }
   isRunManagedInProcess(runId: string): boolean { return this.children.has(runId); }
 
   async spawn(spec: SpawnSpec): Promise<string> {
@@ -94,6 +99,12 @@ export class SubAgentOrchestratorImpl implements SubAgentOrchestrator, SubAgentL
       this.children.set(runId, { pid });
       await this.store.write(initialStatus);
       resolveReady!();
+
+      // Notify spawn listeners
+      for (const listener of this.spawnListeners) {
+        try { await listener(initialStatus); } catch {}
+      }
+
       return runId;
     } catch (err) {
       this.children.delete(runId);
@@ -150,7 +161,11 @@ export class SubAgentOrchestratorImpl implements SubAgentOrchestrator, SubAgentL
     const alive = await this.isProcessAlive(current.pid, current.spawnClockTicks);
     if (alive) return current;
 
-    const outcome = this.terminationHandler.terminalStatusFor(current);
+    // Process is dead. If it had a requested outcome (abort/timeout), use that.
+    // Otherwise check stdout — orphan recovery doesn't know exit code.
+    const outcome = current.requestedOutcome
+      ? this.terminationHandler.terminalStatusFor(current)
+      : await this.inferFromStdout(current.runId);
     return this.finalizer.finalizeRun(current.runId, outcome, { notify });
   }
 
@@ -180,14 +195,26 @@ export class SubAgentOrchestratorImpl implements SubAgentOrchestrator, SubAgentL
    */
   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
+    if (exitCode === null) {
+      // For handleChildExit: null means signal-killed → failed
+      // But callers recovering orphans should use inferFromStdout directly
+      return "failed";
+    }
+    return this.inferFromStdout(runId);
+  }
+
+  /**
+   * Check stdout for substantial output. Used for:
+   * - Non-zero exit codes (teardown errors)
+   * - Recovered orphan processes (unknown exit code)
+   */
+  private async inferFromStdout(runId: string): Promise<"complete" | "failed"> {
     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
+      // No stdout file or can't read
     }
     return "failed";
   }

package/src/subagents/process-launcher.ts

@@ -39,7 +39,7 @@ export class ProcessLauncher {
     let child: ChildProcess | undefined;
 
     try {
-      child = this.spawnProcess("pi", ["--session-dir", runDir, "-p", `@${join(runDir, "brief.md")}`], {
+      child = this.spawnProcess("pi", ["--no-extensions", "--no-skills", "--session-dir", runDir, "-p", `@${join(runDir, "brief.md")}`], {
         cwd,
         detached: true,
         stdio: ["ignore", stdoutHandle.fd, stderrHandle.fd],

package/src/subagents/types.ts

@@ -45,6 +45,7 @@ export interface SubAgentOrchestrator {
   status(runId: string): Promise<RunStatus | null>;
   list(): Promise<RunStatus[]>;
   abort(runId: string): Promise<void>;
+  onSpawn(listener: (status: RunStatus) => Promise<void> | void): () => void;
 }
 
 /** Internal API used by SubAgentWatcher for lifecycle management */

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

@@ -7,6 +7,7 @@
 
 import type { TransportAdapter, ChatThread, IncomingMessage, PairingResult } from "../types";
 import { isTelegramThread, postTelegramHtml } from "./html";
+import { markdownToTelegramHtml } from "./format";
 import { sendTelegramToMany } from "./notify";
 import { BOT_COMMANDS } from "./bot-commands";
 import { readPendingPairing, completePendingPairing, clearPendingPairing, isStartForNonce } from "./pairing";
@@ -77,12 +78,14 @@ export class TelegramAdapter implements TransportAdapter {
     return thread;
   }
 
-  async notify(chatIds: number[], text: string, options?: { parseMode?: string }): Promise<void> {
+  async notify(chatIds: number[], text: string): Promise<void> {
     if (!process.env.TELEGRAM_BOT_TOKEN) {
       console.warn("[roundhouse] TELEGRAM_BOT_TOKEN not set — skipping notification");
       return;
     }
-    await sendTelegramToMany(chatIds, text, options);
+    // Convert lightweight markdown to Telegram HTML
+    const html = markdownToTelegramHtml(text);
+    await sendTelegramToMany(chatIds, html, { parseMode: "HTML" });
   }
 
   async isPairingPending(): Promise<boolean> {

package/src/transports/types.ts

@@ -54,7 +54,7 @@ export interface TransportAdapter {
   ownsThread(thread: ChatThread): boolean;
 
   /** Send notifications to configured recipients */
-  notify(chatIds: number[], text: string, options?: { parseMode?: string }): Promise<void>;
+  notify(chatIds: number[], text: string): Promise<void>;
 
   /**
    * Create a thread object for a given chat ID.