@inceptionstack/roundhouse 0.5.9 → 0.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "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,6 +19,8 @@ export class CronRunner {
   constructor(
     private store: CronStore,
     private agentConfig?: GatewayConfig["agent"],
+    private defaultChatIds?: number[],
+    private notifyFn?: (chatIds: number[], text: string) => Promise<void>,
   ) {}
 
   async runJob(
@@ -127,6 +128,10 @@ export class CronRunner {
   }
 
   private async notify(job: CronJobConfig, record: CronRunRecord): Promise<void> {
+    // Apply onlyOn filter if configured (for both routes)
+    const tg = job.notify?.telegram;
+    if (tg?.onlyOn && !shouldNotify(tg.onlyOn, record.status)) return;
+
     const icon = runStatusIcon(record.status);
     const dur = `${(record.durationMs / 1000).toFixed(1)}s`;
     const header = `${icon} Cron: ${job.id}\nStatus: ${record.status} (${dur})`;
@@ -140,19 +145,31 @@ 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
-    const tg = job.notify?.telegram;
     if (tg?.chatIds?.length) {
-      if (!shouldNotify(tg.onlyOn, record.status)) return;
-      await sendTelegramToMany(tg.chatIds, body);
+      if (notify) {
+        await notify(tg.chatIds, body);
+        return;
+      }
+    }
+
+    // Route 2: Direct callback from gateway (no loopback socket)
+    const defaultChatIds = this.defaultChatIds ?? [];
+    if (notify && defaultChatIds.length > 0) {
+      try {
+        await notify(defaultChatIds, body);
+      } catch (err) {
+        console.warn(`[cron] ${job.id} notify callback failed:`, (err as Error).message);
+      }
       return;
     }
 
-    // Route 2: Broadcast via IPC to all active transports (default)
+    // Route 3: Fallback to IPC (for CLI-triggered runs outside gateway)
     try {
       await sendIpc({ type: "notify", text: body });
     } catch {
-      // Gateway not running or IPC unavailable — log and continue
       console.warn(`[cron] ${job.id} IPC notify failed (gateway not running?)`);
     }
   }

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[] }) {
+  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.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 } 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);
     };
@@ -325,6 +339,11 @@ export class Gateway {
     this.cronScheduler = new CronSchedulerService({
       agentConfig: this.config.agent,
       notifyChatIds: this.config.chat.notifyChatIds,
+      notifyFn: async (chatIds: number[], text: string) => {
+        if (chatIds.length && this.transport) {
+          await this.transport.notify(chatIds, text);
+        }
+      },
     });
     try {
       await this.cronScheduler.start();
@@ -333,34 +352,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,96 @@
+/**
+ * gateway/model-command.ts — Handle the /model command
+ *
+ * Allows switching the default AI model from Telegram.
+ * Reads/writes ~/.pi/agent/settings.json (defaultProvider + defaultModel).
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+
+/** Known model aliases → Bedrock model IDs */
+const MODEL_ALIASES: Record<string, { provider: string; model: string; label: string }> = {
+  "opus": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-6", label: "Claude Opus 4.6" },
+  "opus-4.6": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-6", label: "Claude Opus 4.6" },
+  "opus-4.7": { provider: "amazon-bedrock", model: "us.anthropic.claude-opus-4-7", label: "Claude Opus 4.7" },
+  "sonnet": { provider: "amazon-bedrock", model: "us.anthropic.claude-sonnet-4-6", label: "Claude Sonnet 4.6" },
+  "sonnet-4.6": { 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" },
+  "haiku-4.5": { provider: "amazon-bedrock", model: "us.anthropic.claude-haiku-4-5", label: "Claude Haiku 4.5" },
+};
+
+const SETTINGS_PATH = join(homedir(), ".pi", "agent", "settings.json");
+
+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";
+  // Try to find a friendly label
+  for (const [alias, info] of Object.entries(MODEL_ALIASES)) {
+    if (info.provider === provider && info.model === model) return `${info.label} (${alias})`;
+  }
+  return `${provider}/${model}`;
+}
+
+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 current model + available options
+  if (!target) {
+    const current = getCurrentModel(settings);
+    const aliases = Object.entries(MODEL_ALIASES)
+      .filter(([alias]) => !alias.includes(".")) // Show short aliases only
+      .map(([alias, info]) => `  \`${alias}\` → ${info.label}`)
+      .join("\n");
+
+    await postWithFallback(thread, `🤖 *Current model:* ${current}\n\n*Available:*\n${aliases}\n\n_Usage:_ \`/model sonnet\``);
+    return;
+  }
+
+  // Resolve alias or use as raw model ID
+  const resolved = MODEL_ALIASES[target];
+  if (!resolved) {
+    // Check if it looks like a full model ID (contains a dot or slash)
+    if (target.includes(".") || target.includes("/")) {
+      // Use as-is with current provider
+      const provider = settings.defaultProvider ?? "amazon-bedrock";
+      settings.defaultModel = target;
+      settings.defaultProvider = provider;
+      writeSettings(settings);
+      await postWithFallback(thread, `✅ Model set to: \`${provider}/${target}\`\n\n⚠️ Restart needed: \`/restart\``);
+    } else {
+      const aliases = Object.keys(MODEL_ALIASES).filter(a => !a.includes(".")).join(", ");
+      await postWithFallback(thread, `❌ Unknown model: \`${target}\`\n\nAvailable: ${aliases}`);
+    }
+    return;
+  }
+
+  settings.defaultProvider = resolved.provider;
+  settings.defaultModel = resolved.model;
+  writeSettings(settings);
+
+  await postWithFallback(thread, `✅ Model switched to: *${resolved.label}*\n\n⚠️ Takes effect on next agent turn (new sessions use new model).`);
+  console.log(`[roundhouse] /model: switched to ${resolved.provider}/${resolved.model}`);
+}

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" },