@inceptionstack/roundhouse 0.5.10 → 0.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",
@@ -40,7 +40,7 @@
   "dependencies": {
     "@chat-adapter/state-memory": "^4.26.0",
     "@chat-adapter/telegram": "^4.26.0",
-    "@mariozechner/pi-coding-agent": "^0.69.0",
+    "@earendil-works/pi-coding-agent": "^0.74.0",
     "chat": "^4.26.0",
     "croner": "^10.0.1",
     "p-queue": "^9.2.0",

package/pi/extensions/web-search.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 
 export default function (pi: ExtensionAPI) {

package/src/agents/pi/message-format.ts

@@ -6,7 +6,7 @@
  */
 
 import type { AgentMessage } from "../../types";
-import type { AgentSessionEvent } from "@mariozechner/pi-coding-agent";
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 
 /**
  * Convert custom message content (string or array of parts) to plain text.

package/src/agents/pi/pi-adapter.ts

@@ -24,7 +24,7 @@ import {
   SessionManager,
   type AgentSession,
   type AgentSessionEvent,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 
 import type { AgentAdapter, AgentAdapterFactory, AgentMessage, AgentResponse, AgentStreamEvent, MessageContext } from "../../types";
 import { formatMessage, extractCustomMessage, customContentToText } from "./message-format";
@@ -66,7 +66,7 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
     //
     // WARNING: _agentEventQueue is a private field of AgentSession (not part
     // of the public pi-coding-agent API). Tested against
-    // @mariozechner/pi-coding-agent version bundled via `latest` in
+    // @earendil-works/pi-coding-agent version bundled via `latest` in
     // package.json at the time of this commit. If upstream renames or changes
     // this field, extension custom messages (e.g. pi-lgtm review bubbles)
     // will stop reaching Telegram. The `if (queue)` check fails silently
@@ -558,7 +558,7 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
       // Read agent version
       let version = "unknown";
       try {
-        const piPkgPath = join(__piAdapterDir, "..", "..", "..", "node_modules", "@mariozechner", "pi-coding-agent", "package.json");
+        const piPkgPath = join(__piAdapterDir, "..", "..", "..", "node_modules", "@earendil-works", "pi-coding-agent", "package.json");
         version = JSON.parse(readFileSync(piPkgPath, "utf8")).version;
       } catch {}
 

package/src/agents/registry.ts

@@ -69,12 +69,12 @@ const piDefinition: AgentDefinition = {
   packages: [
     {
       name: "Pi coding agent",
-      packageName: "@mariozechner/pi-coding-agent",
+      packageName: "@earendil-works/pi-coding-agent",
       install: "global",
       binary: "pi",
     },
   ],
-  sdkPackage: "@mariozechner/pi-coding-agent",
+  sdkPackage: "@earendil-works/pi-coding-agent",
   configDefaults: {},
   configDirs: [resolve(homedir(), ".pi", "agent")],
   // configure and installExtension are set by setup.ts since they need

package/src/cli/doctor/checks/agent.ts

@@ -12,7 +12,7 @@ export const agentChecks: DoctorCheck[] = [
   {
     id: "pi-sdk", category: "agent", name: "Pi SDK",
     async run() {
-      const PI_PKG = join("@mariozechner", "pi-coding-agent", "package.json");
+      const PI_PKG = join("@earendil-works", "pi-coding-agent", "package.json");
       const searchPaths = [
         join(process.cwd(), "node_modules", PI_PKG),
       ];
@@ -31,8 +31,8 @@ export const agentChecks: DoctorCheck[] = [
       }
       return {
           id: "pi-sdk", category: "agent", name: "Pi SDK", status: "fail" as const, summary: "not found",
-          details: ["@mariozechner/pi-coding-agent not installed"],
-          fix: { description: "Install pi SDK", command: "npm install @mariozechner/pi-coding-agent" },
+          details: ["@earendil-works/pi-coding-agent not installed"],
+          fix: { description: "Install pi SDK", command: "npm install -g @earendil-works/pi-coding-agent" },
         };
     },
   },

package/src/cli/update.ts

@@ -26,16 +26,84 @@ export interface UpdateResult {
   error?: string;
 }
 
+export async function updateExtensions(progress: UpdateProgress): Promise<void> {
+  for (const extensionPackage of GLOBAL_PI_EXTENSION_PACKAGES) {
+    try {
+      // Check if already at latest
+      const installed = execSync(`npm list -g ${extensionPackage} --json 2>/dev/null`, {
+        timeout: 10_000,
+        encoding: "utf8",
+      });
+      const installedVersion = JSON.parse(installed)?.dependencies?.[extensionPackage]?.version ?? "";
+      const latestExtVersion = execSync(`npm view ${extensionPackage} version 2>/dev/null`, {
+        timeout: 10_000,
+        encoding: "utf8",
+      }).trim();
+
+      if (installedVersion && installedVersion === latestExtVersion) {
+        await progress.update(`✅ ${extensionPackage} already at v${installedVersion}`);
+        continue;
+      }
+      await progress.update(`📦 Updating ${extensionPackage} v${installedVersion || "?"} → v${latestExtVersion}...`);
+    } catch {
+      await progress.update(`📦 Updating extension: ${extensionPackage}...`);
+    }
+
+    try {
+      execSync(`npm install -g ${extensionPackage}@latest 2>&1`, {
+        timeout: 60_000,
+        encoding: "utf8",
+      });
+      await progress.update(`✅ ${extensionPackage} updated`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      console.warn(`[roundhouse] failed to update extension ${extensionPackage}:`, msg);
+      await progress.update(`⚠️ Failed to update ${extensionPackage}: ${msg.slice(0, 150)}`);
+    }
+  }
+}
+
+export async function updateSelf(
+  progress: UpdateProgress,
+  currentVersion: string,
+  latestVersion: string,
+): Promise<string | undefined> {
+  await progress.update(`📦 Updating v${currentVersion} → v${latestVersion}...`);
+
+  try {
+    execSync("npm install -g @inceptionstack/roundhouse@latest 2>&1", {
+      timeout: 120_000,
+      encoding: "utf8",
+    });
+    return undefined;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.warn("[roundhouse] self-update failed:", msg);
+    return `Self-update failed: ${msg}`;
+  }
+}
+
+export function patchPiSettings(): void {
+  try {
+    const settingsPath = `${homedir()}/.pi/agent/settings.json`;
+    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    const selfPkg = "npm:@inceptionstack/roundhouse";
+    if (!Array.isArray(settings.packages)) settings.packages = [];
+    if (!settings.packages.includes(selfPkg)) {
+      settings.packages.push(selfPkg);
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    }
+  } catch { /* settings.json may not exist yet — fine, setup will create it */ }
+}
+
 /**
  * Check for updates, install if newer, provision bundle, patch settings.
  * Returns the result — caller decides how to present it and whether to restart.
  */
 export async function performUpdate(progress: UpdateProgress): Promise<UpdateResult> {
-  // Get current version
   const pkg = await import("../../package.json", { with: { type: "json" } });
   const currentVersion = pkg.default?.version ?? "unknown";
 
-  // Check latest version on npm
   let latestVersion: string;
   try {
     latestVersion = execSync("npm view @inceptionstack/roundhouse version 2>/dev/null", {
@@ -48,25 +116,10 @@ export async function performUpdate(progress: UpdateProgress): Promise<UpdateRes
     console.warn("[roundhouse] npm view failed:", e instanceof Error ? e.message : e);
   }
 
-  // Always update extensions (even if roundhouse is already latest)
   if (!latestVersion) {
     await progress.update(`⚠️ Version check failed — updating extensions only`);
   }
-  for (const extensionPackage of GLOBAL_PI_EXTENSION_PACKAGES) {
-    await progress.update(`📦 Updating extension: ${extensionPackage}...`);
-
-    try {
-      execSync(`npm install -g ${extensionPackage}@latest 2>&1`, {
-        timeout: 60_000,
-        encoding: "utf8",
-      });
-      await progress.update(`✅ ${extensionPackage} updated`);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      console.warn(`[roundhouse] failed to update extension ${extensionPackage}:`, msg);
-      await progress.update(`⚠️ Failed to update ${extensionPackage}: ${msg.slice(0, 150)}`);
-    }
-  }
+  await updateExtensions(progress);
 
   if (!latestVersion) {
     return { action: "error", currentVersion, error: "Version check failed (extensions updated)" };
@@ -75,37 +128,18 @@ export async function performUpdate(progress: UpdateProgress): Promise<UpdateRes
     return { action: "already-latest", currentVersion };
   }
 
-  await progress.update(`📦 Updating v${currentVersion} → v${latestVersion}...`);
-
-  try {
-    execSync("npm install -g @inceptionstack/roundhouse@latest 2>&1", {
-      timeout: 120_000,
-      encoding: "utf8",
-    });
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    console.warn("[roundhouse] self-update failed:", msg);
-    return { action: "error", currentVersion, error: `Self-update failed: ${msg}` };
+  const updateError = await updateSelf(progress, currentVersion, latestVersion);
+  if (updateError) {
+    return { action: "error", currentVersion, error: updateError };
   }
 
-  // Provision bundle (skills sync + CLI tools + config)
   try {
     provisionBundle();
   } catch (e) {
     console.warn("[roundhouse] bundle provisioning failed:", e instanceof Error ? e.message : e);
   }
 
-  // Ensure settings.json includes roundhouse package (for pre-bundle upgrades)
-  try {
-    const settingsPath = `${homedir()}/.pi/agent/settings.json`;
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-    const selfPkg = "npm:@inceptionstack/roundhouse";
-    if (!Array.isArray(settings.packages)) settings.packages = [];
-    if (!settings.packages.includes(selfPkg)) {
-      settings.packages.push(selfPkg);
-      writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
-    }
-  } catch { /* settings.json may not exist yet — fine, setup will create it */ }
+  patchPiSettings();
 
   return { action: "updated", currentVersion, latestVersion };
 }

package/src/cron/runner.ts

@@ -6,7 +6,6 @@
  */
 
 import { getAgentFactory } from "../agents/registry";
-import { sendTelegramToMany } from "../transports/telegram/notify";
 import { sendIpc } from "../ipc";
 import { CronStore, generateRunId } from "./store";
 import { buildTemplateContext, renderTemplate } from "./template";
@@ -20,7 +19,8 @@ export class CronRunner {
   constructor(
     private store: CronStore,
     private agentConfig?: GatewayConfig["agent"],
-    private notifyFn?: (text: string) => Promise<void>,
+    private defaultChatIds?: number[],
+    private notifyFn?: (chatIds: number[], text: string) => Promise<void>,
   ) {}
 
   async runJob(
@@ -145,16 +145,21 @@ export class CronRunner {
       body = `${header}\nError: ${record.error.slice(0, NOTIFY_MAX_ERROR_CHARS)}`;
     }
 
+    const notify = this.notifyFn;
+
     // Route 1: Explicit Telegram chat IDs configured on the job
     if (tg?.chatIds?.length) {
-      await sendTelegramToMany(tg.chatIds, body);
-      return;
+      if (notify) {
+        await notify(tg.chatIds, body);
+        return;
+      }
     }
 
     // Route 2: Direct callback from gateway (no loopback socket)
-    if (this.notifyFn) {
+    const defaultChatIds = this.defaultChatIds ?? [];
+    if (notify && defaultChatIds.length > 0) {
       try {
-        await this.notifyFn(body);
+        await notify(defaultChatIds, body);
       } catch (err) {
         console.warn(`[cron] ${job.id} notify callback failed:`, (err as Error).message);
       }

package/src/cron/scheduler.ts

@@ -41,9 +41,9 @@ export class CronSchedulerService {
   private lastHeartbeatAt = 0; // 0 = fires on first tick after startup (intentional catch-up)
   private tickMs: number;
 
-  constructor(private opts?: { tickMs?: number; agentConfig?: GatewayConfig["agent"]; notifyChatIds?: number[]; notifyFn?: (text: string) => Promise<void> }) {
+  constructor(private opts?: { tickMs?: number; agentConfig?: GatewayConfig["agent"]; notifyChatIds?: number[]; notifyFn?: (chatIds: number[], text: string) => Promise<void> }) {
     this.store = new CronStore();
-    this.runner = new CronRunner(this.store, this.opts?.agentConfig, this.opts?.notifyFn);
+    this.runner = new CronRunner(this.store, this.opts?.agentConfig, this.opts?.notifyChatIds, this.opts?.notifyFn);
     this.queue = new PQueue({ concurrency: 1 });
     this.tickMs = this.opts?.tickMs ?? TICK_MS;
   }

package/src/gateway/gateway.ts

@@ -13,7 +13,7 @@ import { SttService, enrichAttachmentsWithTranscripts, DEFAULT_STT_CONFIG } from
 import { runDoctor, formatDoctorTelegram, createDoctorContext } from "../cli/doctor/runner";
 import { ROUNDHOUSE_DIR, ROUNDHOUSE_VERSION } from "../config";
 import { CronSchedulerService } from "../cron/scheduler";
-import { IpcServer, type IpcRequest } from "../ipc";
+import { IpcServer, createIpcHandler } from "../ipc";
 import { prepareMemoryForTurn, finalizeMemoryForTurn, flushMemoryThenCompact } from "../memory/lifecycle";
 import { maxPressure } from "../memory/policy";
 import type { PressureLevel } from "../memory/types";
@@ -23,6 +23,8 @@ import { isCommand as _isCmd, isCommandWithArgs as _isCmdArgs, resolveAgentThrea
 import { saveAttachments as _saveAttachments, type AttachmentResult } from "./attachments";
 import { handleStreaming as _handleStream } from "./streaming";
 import { handleNew, handleRestart, handleUpdate, handleCompact, handleStatus, handleStop, handleVerbose, handleDoctor, handleCrons, type CommandContext } from "./commands";
+import { handleModel, handleModelAction, MODEL_ACTION_ID } from "./model-command";
+import { handleLater } from "./later-command";
 import { TelegramAdapter } from "../transports";
 import type { TransportAdapter } from "../transports";
 import { hostname } from "node:os";
@@ -264,6 +266,18 @@ export class Gateway {
         return;
       }
 
+      // Handle /model command
+      if (isCommandWithArgs(userText.trim(), "/model") || isCommand(userText.trim(), "/model")) {
+        await handleModel({ thread, text: userText.trim(), postWithFallback: (t, txt) => this.postWithFallback(t, txt) });
+        return;
+      }
+
+      // Handle /later command
+      if (isCommandWithArgs(userText.trim(), "/later") || isCommand(userText.trim(), "/later")) {
+        await handleLater({ thread, text: userText.trim(), postWithFallback: (t, txt) => this.postWithFallback(t, txt) });
+        return;
+      }
+
       // Dispatch to agent turn handler
       await this.handleAgentTurn(thread, agentThreadId, userText, rawAttachments, verboseThreads, threadLocks, abortControllers);
     };
@@ -313,6 +327,11 @@ export class Gateway {
       await handleOrAbort(thread, message);
     });
 
+    // ── Handle inline keyboard callbacks ───
+    this.chat.onAction(MODEL_ACTION_ID, async (event: any) => {
+      await handleModelAction({ value: event.value, thread: event.thread });
+    });
+
     await this.chat.initialize();
 
     const platforms = Object.keys(this.config.chat.adapters).join(", ");
@@ -325,9 +344,8 @@ export class Gateway {
     this.cronScheduler = new CronSchedulerService({
       agentConfig: this.config.agent,
       notifyChatIds: this.config.chat.notifyChatIds,
-      notifyFn: async (text: string) => {
-        const chatIds = this.config.chat.notifyChatIds;
-        if (chatIds?.length && this.transport) {
+      notifyFn: async (chatIds: number[], text: string) => {
+        if (chatIds.length && this.transport) {
           await this.transport.notify(chatIds, text);
         }
       },
@@ -339,34 +357,7 @@ export class Gateway {
     }
 
     // Start IPC server for CLI → gateway communication
-    this.ipcServer = new IpcServer(async (req: IpcRequest) => {
-      if (req.type === "ping") return { ok: true };
-      if (req.type === "notify") {
-        const allChatIds = this.config.chat.notifyChatIds ?? [];
-        if (allChatIds.length === 0) return { ok: false, error: "No notifyChatIds configured" };
-
-        // Session routing:
-        //   "main" = first notifyChatId (primary user chat)
-        //   numeric string = that specific chat ID
-        //   anything else / undefined = broadcast to all notifyChatIds
-        let targetIds: number[];
-        if (req.session === "main") {
-          targetIds = [allChatIds[0]];
-        } else if (req.session && /^-?\d+$/.test(req.session)) {
-          targetIds = [Number(req.session)];
-        } else {
-          targetIds = allChatIds; // broadcast to all
-        }
-
-        try {
-          await this.transport.notify(targetIds, req.text);
-          return { ok: true };
-        } catch (e: any) {
-          return { ok: false, error: e.message };
-        }
-      }
-      return { ok: false, error: "Unknown request type" };
-    });
+    this.ipcServer = new IpcServer(createIpcHandler(this.transport, () => this.config));
     try {
       await this.ipcServer.start();
     } catch (err) {

package/src/gateway/later-command.ts

@@ -0,0 +1,57 @@
+/**
+ * gateway/later-command.ts — Handle the /later command
+ *
+ * Quickly capture ideas/notes to ~/.roundhouse/workspace/later.md
+ * without interrupting the current conversation flow.
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { appendFileSync, mkdirSync, existsSync, readFileSync } from "node:fs";
+
+const WORKSPACE_DIR = join(homedir(), ".roundhouse", "workspace");
+const LATER_PATH = join(WORKSPACE_DIR, "later.md");
+
+export interface LaterCommandContext {
+  thread: any;
+  text: string;
+  postWithFallback: (thread: any, text: string) => Promise<void>;
+}
+
+function ensureWorkspace(): void {
+  if (!existsSync(WORKSPACE_DIR)) {
+    mkdirSync(WORKSPACE_DIR, { recursive: true });
+  }
+}
+
+function ensureLaterFile(): void {
+  ensureWorkspace();
+  if (!existsSync(LATER_PATH)) {
+    appendFileSync(LATER_PATH, "# Later\n\nIdeas, reminders, and things to get back to.\n\n");
+  }
+}
+
+export async function handleLater(ctx: LaterCommandContext): Promise<void> {
+  const { thread, text, postWithFallback } = ctx;
+  const idea = text.replace(/^\/later\s*/i, "").trim();
+
+  // No argument: show contents
+  if (!idea) {
+    ensureLaterFile();
+    const contents = readFileSync(LATER_PATH, "utf8").trim();
+    const lines = contents.split("\n").filter(l => l.startsWith("- "));
+    if (lines.length === 0) {
+      await postWithFallback(thread, "📋 *Later list is empty.*\n\n_Usage:_ `/later buy more coffee`");
+    } else {
+      await postWithFallback(thread, `📋 *Later* (${lines.length} items):\n\n${lines.join("\n")}\n\n_File:_ \`~/.roundhouse/workspace/later.md\``);
+    }
+    return;
+  }
+
+  // Append the idea
+  ensureLaterFile();
+  const timestamp = new Date().toISOString().slice(0, 10);
+  appendFileSync(LATER_PATH, `- ${idea} _(${timestamp})_\n`);
+
+  await postWithFallback(thread, `✅ Saved: "${idea}"`);
+}

package/src/gateway/model-command.ts

@@ -0,0 +1,186 @@
+/**
+ * gateway/model-command.ts — Handle the /model command
+ *
+ * Allows switching the default AI model from Telegram.
+ * Reads/writes ~/.pi/agent/settings.json (defaultProvider + defaultModel).
+ *
+ * When called without arguments, shows an inline keyboard with model buttons.
+ * When a button is clicked, the onAction handler applies the selection.
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+
+/** Known model aliases → Bedrock model IDs */
+export const MODEL_ALIASES: Record<string, { provider: string; model: string; label: string }> = {
+  // Anthropic Claude
+  "opus-4.7": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-7", label: "Claude Opus 4.7" },
+  "opus": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-6", label: "Claude Opus 4.6" },
+  "sonnet": { provider: "amazon-bedrock", model: "us.anthropic.claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+  "haiku": { provider: "amazon-bedrock", model: "us.anthropic.claude-haiku-4-5", label: "Claude Haiku 4.5" },
+  // DeepSeek
+  "deepseek": { provider: "amazon-bedrock", model: "us.deepseek.r1-v1:0", label: "DeepSeek R1" },
+  // Meta Llama
+  "llama": { provider: "amazon-bedrock", model: "us.meta.llama4-maverick-17b-instruct-v1:0", label: "Llama 4 Maverick" },
+  // Amazon Nova
+  "nova-pro": { provider: "amazon-bedrock", model: "us.amazon.nova-pro-v1:0", label: "Amazon Nova Pro" },
+  // Mistral
+  "mistral": { provider: "amazon-bedrock", model: "us.mistral.mistral-large-2411-v1:0", label: "Mistral Large" },
+};
+
+/** Models shown in the inline keyboard (max 8, ordered by preference) */
+const KEYBOARD_MODELS = [
+  "opus-4.7", "opus", "sonnet", "haiku",
+  "deepseek", "llama", "nova-pro", "mistral",
+] as const;
+
+/** Action ID for model selection callbacks */
+export const MODEL_ACTION_ID = "model_select";
+
+const SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
+
+/** Callback data prefix used by @chat-adapter/telegram (coupled: if adapter changes this, buttons break) */
+const CALLBACK_PREFIX = "chat:";
+
+export interface ModelCommandContext {
+  thread: any;
+  text: string;
+  postWithFallback: (thread: any, text: string) => Promise<void>;
+}
+
+function readSettings(): Record<string, any> {
+  try {
+    return JSON.parse(readFileSync(SETTINGS_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeSettings(settings: Record<string, any>): void {
+  writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+}
+
+function getCurrentModel(settings: Record<string, any>): string {
+  const provider = settings.defaultProvider ?? "unknown";
+  const model = settings.defaultModel ?? "unknown";
+  for (const [alias, info] of Object.entries(MODEL_ALIASES)) {
+    if (info.provider === provider && info.model === model) return `${info.label}`;
+  }
+  return `${model}`;
+}
+
+function encodeCallbackData(actionId: string, value: string): string {
+  return `${CALLBACK_PREFIX}${JSON.stringify({ a: actionId, v: value })}`;
+}
+
+function buildInlineKeyboard(): { inline_keyboard: Array<Array<{ text: string; callback_data: string }>> } {
+  // Layout: 2 buttons per row for compact display
+  const buttons = KEYBOARD_MODELS.map(alias => {
+    const info = MODEL_ALIASES[alias];
+    return {
+      text: info.label,
+      callback_data: encodeCallbackData(MODEL_ACTION_ID, alias),
+    };
+  });
+  const rows: Array<Array<{ text: string; callback_data: string }>> = [];
+  for (let i = 0; i < buttons.length; i += 2) {
+    rows.push(buttons.slice(i, i + 2));
+  }
+  return { inline_keyboard: rows };
+}
+
+export async function handleModel(ctx: ModelCommandContext): Promise<void> {
+  const { thread, text, postWithFallback } = ctx;
+  const parts = text.split(/\s+/).slice(1);
+  const target = parts[0]?.toLowerCase();
+
+  const settings = readSettings();
+
+  // No argument: show inline keyboard
+  if (!target) {
+    const current = getCurrentModel(settings);
+    const msgText = `🤖 Current model: <b>${current}</b>\n\nSelect a model:`;
+
+    // Try to send with inline keyboard via telegramFetch
+    const adapter = thread?.adapter;
+    if (adapter?.telegramFetch) {
+      const chatId = thread?.platformThreadId?.split(":")?.[1] ?? thread?.id?.split(":")?.[1];
+      if (chatId) {
+        try {
+          await adapter.telegramFetch("sendMessage", {
+            chat_id: chatId,
+            text: msgText,
+            parse_mode: "HTML",
+            reply_markup: buildInlineKeyboard(),
+          });
+          return;
+        } catch (err) {
+          console.warn("[roundhouse] /model inline keyboard failed, falling back:", (err as Error).message);
+        }
+      }
+    }
+
+    // Fallback: plain text
+    const aliases = KEYBOARD_MODELS.map(a => `  \`${a}\` → ${MODEL_ALIASES[a].label}`).join("\n");
+    await postWithFallback(thread, `🤖 *Current model:* ${current}\n\n*Available:*\n${aliases}\n\n_Usage:_ \`/model sonnet\``);
+    return;
+  }
+
+  // Resolve alias
+  await applyModelSelection(target, settings, thread, postWithFallback);
+}
+
+/**
+ * Apply a model selection (used by both /model <arg> and inline keyboard callback).
+ */
+export async function applyModelSelection(
+  target: string,
+  settings: Record<string, any> | null,
+  thread: any,
+  postWithFallback: (thread: any, text: string) => Promise<void>,
+): Promise<void> {
+  if (!settings) settings = readSettings();
+
+  const resolved = MODEL_ALIASES[target];
+  if (!resolved) {
+    if (target.includes(".") || target.includes("/")) {
+      const provider = settings.defaultProvider ?? "amazon-bedrock";
+      settings.defaultModel = target;
+      settings.defaultProvider = provider;
+      writeSettings(settings);
+      await postWithFallback(thread, `✅ Model set to: \`${provider}/${target}\``);
+    } else {
+      const aliases = Object.keys(MODEL_ALIASES).join(", ");
+      await postWithFallback(thread, `❌ Unknown model: \`${target}\`\n\nAvailable: ${aliases}`);
+    }
+    return;
+  }
+
+  settings.defaultProvider = resolved.provider;
+  settings.defaultModel = resolved.model;
+  writeSettings(settings);
+
+  await postWithFallback(thread, `✅ Switched to *${resolved.label}*`);
+  console.log(`[roundhouse] /model: switched to ${resolved.provider}/${resolved.model}`);
+}
+
+/**
+ * Handle inline keyboard callback for model selection.
+ * Call this from chat.onAction(MODEL_ACTION_ID, ...).
+ */
+export async function handleModelAction(event: {
+  value?: string;
+  thread: any;
+}): Promise<void> {
+  const alias = event.value;
+  if (!alias || !MODEL_ALIASES[alias]) return;
+
+  const postFn = async (_t: any, text: string) => {
+    if (!event.thread) return;
+    try { await event.thread.post({ markdown: text }); }
+    catch { try { await event.thread.post(text); } catch {} }
+  };
+
+  await applyModelSelection(alias, null, event.thread, postFn);
+}

package/src/gateway/tools.md

@@ -2,6 +2,14 @@
 
 Available tools that can be invoked via shell commands during agent turns.
 
+## Workspace Directory
+
+**All new files, scratch work, downloads, and artifacts you create go under `~/.roundhouse/workspace/`.**
+Do NOT create files directly in `~/` or pollute the home directory. Use subdirectories as needed:
+- `~/.roundhouse/workspace/` — default working directory for any task output
+- `~/.roundhouse/workspace/later.md` — ideas saved via `/later`
+- `~/.roundhouse/workspace/<project>/` — project-specific files if needed
+
 ## roundhouse cron add
 
 Schedule recurring or one-shot jobs. The user may ask you to "remind me", "check every X", "do Y later", or "schedule Z".

package/src/ipc/handler.ts

@@ -0,0 +1,39 @@
+/**
+ * ipc/handler.ts — Gateway IPC request handler factory
+ */
+
+import type { GatewayConfig } from "../types";
+import type { TransportAdapter } from "../transports";
+import type { IpcRequest, IpcResponse } from "./types";
+
+export function createIpcHandler(
+  transport: TransportAdapter,
+  getConfig: () => GatewayConfig,
+): (req: IpcRequest) => Promise<IpcResponse> {
+  return async (req: IpcRequest): Promise<IpcResponse> => {
+    if (req.type === "ping") return { ok: true };
+
+    if (req.type === "notify") {
+      const allChatIds = getConfig().chat.notifyChatIds ?? [];
+      if (allChatIds.length === 0) return { ok: false, error: "No notifyChatIds configured" };
+
+      let targetIds: number[];
+      if (req.session === "main") {
+        targetIds = [allChatIds[0]];
+      } else if (req.session && /^-?\d+$/.test(req.session)) {
+        targetIds = [Number(req.session)];
+      } else {
+        targetIds = allChatIds;
+      }
+
+      try {
+        await transport.notify(targetIds, req.text);
+        return { ok: true };
+      } catch (e: any) {
+        return { ok: false, error: e.message };
+      }
+    }
+
+    return { ok: false, error: "Unknown request type" };
+  };
+}

package/src/ipc/index.ts

@@ -1,3 +1,4 @@
 export { IpcServer, SOCKET_PATH } from "./server";
 export { sendIpc } from "./client";
+export { createIpcHandler } from "./handler";
 export type { IpcRequest, IpcResponse } from "./types";

package/src/transports/telegram/bot-commands.ts

@@ -13,6 +13,8 @@ export interface BotCommand {
 export const BOT_COMMANDS: BotCommand[] = [
   { command: "new", description: "Start a fresh conversation" },
   { command: "compact", description: "Compact context window" },
+  { command: "model", description: "Show or switch AI model" },
+  { command: "later", description: "Save an idea for later" },
   { command: "verbose", description: "Toggle verbose tool output" },
   { command: "stop", description: "Stop the current agent run" },
   { command: "restart", description: "Restart agent process" },