@inceptionstack/roundhouse 0.3.18 → 0.3.19

package/package.json

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

package/src/agents/pi.ts

@@ -3,10 +3,10 @@
  *
  * Wraps pi's SDK (createAgentSession) as an AgentAdapter.
  * One persistent session per thread, stored at:
- *   ~/.pi/agent/gateway-sessions/<thread_id>/<session>.jsonl
+ *   ~/.roundhouse/sessions/<thread_id>/<session>.jsonl
  */
 
-import { mkdir, stat } from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
@@ -24,19 +24,16 @@ import {
 } from "@mariozechner/pi-coding-agent";
 
 import type { AgentAdapter, AgentAdapterFactory, AgentMessage, AgentResponse, AgentStreamEvent } from "../types";
-import { DEBUG_STREAM, threadIdToDir, threadIdToDirLegacy } from "../util";
+import { SESSIONS_DIR } from "../config";
+import { DEBUG_STREAM, threadIdToDir } from "../util";
 
 interface SessionEntry {
   session: AgentSession;
   lastUsed: number;
+  inFlight: number;
 }
 
-const DEFAULT_SESSIONS_DIR = join(
-  homedir(),
-  ".pi",
-  "agent",
-  "gateway-sessions"
-);
+const DEFAULT_SESSIONS_DIR = SESSIONS_DIR;
 const DEFAULT_MAX_IDLE_MS = 30 * 60 * 1000;
 
 export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
@@ -107,72 +104,65 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
   }
 
   async function runPromptAndFollowUps(entry: SessionEntry, text: string, onDraining?: () => void, onDrainComplete?: () => void): Promise<void> {
-    await entry.session.prompt(text);
-    await drainSessionEvents(entry.session);
-
-    // Check for pending follow-up work AFTER drainSessionEvents — that's
-    // where agent_end extension handlers run and queue follow-up messages
-    // (e.g. pi-lgtm calls sendMessage with deliverAs: "followUp").
-    // The actual long wait is in the while loop's waitForIdle() below.
-    let notifiedDraining = false;
-    if (onDraining && (entry.session.isStreaming || entry.session.agent.hasQueuedMessages())) {
-      onDraining();
-      notifiedDraining = true;
-    }
+    entry.inFlight++;
+    try {
+      await entry.session.prompt(text);
+      await drainSessionEvents(entry.session);
 
-    // Loop until the session is fully idle. Two separate conditions can keep
-    // work in flight after the initial prompt resolves:
-    //
-    //  (a) `hasQueuedMessages()` — an extension called `pi.sendMessage(...,
-    //      { triggerTurn: true, deliverAs: "followUp" })` *while isStreaming
-    //      was true* — pi queued onto `agent.followUp()`, so we manually
-    //      drain it with `continue()`.
-    //
-    //  (b) `isStreaming === true` — an extension called the same sendMessage
-    //      *after isStreaming became false*. In that path pi's
-    //      `sendCustomMessage` skips the queue entirely and calls
-    //      `agent.prompt(appMessage)` directly as fire-and-forget, kicking
-    //      off a brand-new agent run. `hasQueuedMessages()` returns false
-    //      for this run, but `isStreaming` is true — we have to
-    //      `waitForIdle()` so subscribers see the new run's events (e.g. the
-    //      agent's reply to a pi-lgtm code review) before we unsubscribe.
-    //
-    // Without (b), pi CLI works (its subscriber stays attached across runs)
-    // but roundhouse delivers the review bubble then goes silent.
-    while (true) {
-      if (entry.session.isStreaming) {
-        await entry.session.agent.waitForIdle();
-        await drainSessionEvents(entry.session);
-        continue;
+      // Check for pending follow-up work AFTER drainSessionEvents — that's
+      // where agent_end extension handlers run and queue follow-up messages
+      // (e.g. pi-lgtm calls sendMessage with deliverAs: "followUp").
+      // The actual long wait is in the while loop's waitForIdle() below.
+      let notifiedDraining = false;
+      if (onDraining && (entry.session.isStreaming || entry.session.agent.hasQueuedMessages())) {
+        onDraining();
+        notifiedDraining = true;
       }
-      if (entry.session.agent.hasQueuedMessages()) {
-        await entry.session.agent.continue();
-        await drainSessionEvents(entry.session);
-        continue;
+
+      // Loop until the session is fully idle. Two separate conditions can keep
+      // work in flight after the initial prompt resolves:
+      //
+      //  (a) `hasQueuedMessages()` — an extension called `pi.sendMessage(...,
+      //      { triggerTurn: true, deliverAs: "followUp" })` *while isStreaming
+      //      was true* — pi queued onto `agent.followUp()`, so we manually
+      //      drain it with `continue()`.
+      //
+      //  (b) `isStreaming === true` — an extension called the same sendMessage
+      //      *after isStreaming became false*. In that path pi's
+      //      `sendCustomMessage` skips the queue entirely and calls
+      //      `agent.prompt(appMessage)` directly as fire-and-forget, kicking
+      //      off a brand-new agent run. `hasQueuedMessages()` returns false
+      //      for this run, but `isStreaming` is true — we have to
+      //      `waitForIdle()` so subscribers see the new run's events (e.g. the
+      //      agent's reply to a pi-lgtm code review) before we unsubscribe.
+      //
+      // Without (b), pi CLI works (its subscriber stays attached across runs)
+      // but roundhouse delivers the review bubble then goes silent.
+      while (true) {
+        if (entry.session.isStreaming) {
+          await entry.session.agent.waitForIdle();
+          await drainSessionEvents(entry.session);
+          continue;
+        }
+        if (entry.session.agent.hasQueuedMessages()) {
+          await entry.session.agent.continue();
+          await drainSessionEvents(entry.session);
+          continue;
+        }
+        break;
       }
-      break;
-    }
 
-    if (notifiedDraining && onDrainComplete) {
-      onDrainComplete();
+      if (notifiedDraining && onDrainComplete) {
+        onDrainComplete();
+      }
+    } finally {
+      entry.inFlight--;
+      entry.lastUsed = Date.now();
     }
   }
 
   async function createSession(threadId: string): Promise<SessionEntry> {
-    let dirName = threadIdToDir(threadId);
-    const newPath = join(sessionsDir, dirName);
-    const legacyPath = join(sessionsDir, threadIdToDirLegacy(threadId));
-    // Migrate: if legacy dir exists but new doesn't, use legacy
-    if (dirName !== threadIdToDirLegacy(threadId)) {
-      try {
-        await stat(legacyPath);
-        // Legacy exists — check if new exists
-        try { await stat(newPath); } catch {
-          // New doesn't exist, use legacy to preserve session history
-          dirName = threadIdToDirLegacy(threadId);
-        }
-      } catch { /* legacy doesn't exist either, use new */ }
-    }
+    const dirName = threadIdToDir(threadId);
     const threadDir = join(sessionsDir, dirName);
     await mkdir(threadDir, { recursive: true });
 
@@ -214,7 +204,7 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
       console.log(`[pi-agent] model fallback: ${result.modelFallbackMessage}`);
     }
 
-    const entry: SessionEntry = { session: result.session, lastUsed: Date.now() };
+    const entry: SessionEntry = { session: result.session, lastUsed: Date.now(), inFlight: 0 };
     sessions.set(threadId, entry);
 
     // Detect memory capabilities from loaded extensions (first session only)
@@ -260,6 +250,7 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
   function reap() {
     const now = Date.now();
     for (const [id, entry] of sessions) {
+      if (entry.inFlight > 0) continue; // skip busy sessions
       if (now - entry.lastUsed > maxIdleMs) {
         entry.session.dispose();
         sessions.delete(id);

package/src/cli/cli.ts

@@ -5,10 +5,9 @@
  */
 
 import { resolve, dirname } from "node:path";
-import { homedir } from "node:os";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { readdirSync, statSync } from "node:fs";
-import { execSync, spawn } from "node:child_process";
+import { execSync, execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 import {
@@ -16,12 +15,14 @@ import {
   CONFIG_PATH,
   ENV_FILE_PATH,
   DEFAULT_CONFIG,
+  SESSIONS_DIR,
   SERVICE_NAME,
   fileExists,
   loadConfig,
   resolveEnvFilePath,
 } from "../config";
 import { getAgentSdkPackage } from "../agents/registry";
+import { threadIdToDir } from "../util";
 import { parseEnvFile, serializeEnvFile, envQuote } from "./env-file";
 import {
   SERVICE_PATH,
@@ -40,6 +41,11 @@ const __dirname = dirname(__filename);
 
 // ── Shell helpers ───────────────────────────────────
 
+/**
+ * Shell helper — WARNING: passes `cmd` through the system shell.
+ * Only call with trusted/hardcoded strings. Any dynamic segments must be
+ * validated (e.g. `/^\d+$/.test(pid)`) before interpolation.
+ */
 function run(cmd: string, opts?: { silent?: boolean }): string {
   try {
     return execSync(cmd, { encoding: "utf8", stdio: opts?.silent ? "pipe" : "inherit" }).trim();
@@ -79,10 +85,10 @@ async function cmdRun() {
     await import(jsPath);
   } else {
     const tsxPath = resolve(__dirname, "..", "..", "node_modules", "tsx", "dist", "cli.mjs");
-    execSync(
-      `node ${tsxPath} ${indexPath}`,
-      { stdio: "inherit", env: { ...process.env, ROUNDHOUSE_CONFIG: CONFIG_PATH } },
-    );
+    execFileSync(process.execPath, [tsxPath, indexPath], {
+      stdio: "inherit",
+      env: { ...process.env, ROUNDHOUSE_CONFIG: CONFIG_PATH },
+    });
   }
 }
 
@@ -279,87 +285,30 @@ async function cmdTui() {
     process.exit(1);
   }
 
-  const sessionsBase = (config.agent as any)?.sessionDir
-    ?? resolve(homedir(), ".pi", "agent", "gateway-sessions");
-
-  let threadDirs: string[] = [];
+  const threadArg = process.argv[3];
+  const threadId = threadArg || "main";
+  const threadDir = threadIdToDir(threadId);
+  const threadPath = resolve(SESSIONS_DIR, threadDir);
+  let candidates: Array<{ sessionFile: string; mtime: number }> = [];
   try {
-    threadDirs = readdirSync(sessionsBase)
-      .filter((d) => { try { return statSync(resolve(sessionsBase, d)).isDirectory(); } catch { return false; } })
-      .sort();
+    candidates = readdirSync(threadPath)
+      .filter((f) => f.endsWith(".jsonl"))
+      .map((f) => {
+        const sessionFile = resolve(threadPath, f);
+        return { sessionFile, mtime: statSync(sessionFile).mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
   } catch {
-    console.error(`No gateway sessions found at ${sessionsBase}`);
+    console.error(`No session directory found at ${threadPath}.`);
     process.exit(1);
   }
 
-  if (threadDirs.length === 0) {
-    console.error("No gateway sessions found. Send a message via Telegram/Slack first.");
-    process.exit(1);
-  }
-
-  const threadArg = process.argv[3];
-
-  interface SessionCandidate { threadDir: string; sessionFile: string; mtime: number; }
-
-  const candidates: SessionCandidate[] = [];
-  for (const dir of threadDirs) {
-    if (threadArg && !dir.includes(threadArg)) continue;
-    const threadPath = resolve(sessionsBase, dir);
-    try {
-      for (const f of readdirSync(threadPath).filter((f) => f.endsWith(".jsonl"))) {
-        const fullPath = resolve(threadPath, f);
-        candidates.push({ threadDir: dir, sessionFile: fullPath, mtime: statSync(fullPath).mtimeMs });
-      }
-    } catch {}
-  }
-
   if (candidates.length === 0) {
-    if (threadArg) {
-      console.error(`No sessions found matching "${threadArg}".`);
-      console.log("Available threads:");
-      for (const d of threadDirs) console.log(`  ${d}`);
-    } else {
-      console.error("No session files found.");
-    }
+    console.error(`No session files found at ${threadPath}.`);
     process.exit(1);
   }
 
-  candidates.sort((a, b) => b.mtime - a.mtime);
-
-  let selected: SessionCandidate;
-  const uniqueThreads = [...new Set(candidates.map((c) => c.threadDir))];
-
-  if (uniqueThreads.length === 1 || threadArg) {
-    selected = candidates[0];
-  } else {
-    console.log("Available sessions (most recent first):\n");
-    const shown: SessionCandidate[] = [];
-    const seen = new Set<string>();
-    for (const c of candidates) {
-      if (seen.has(c.threadDir)) continue;
-      seen.add(c.threadDir);
-      shown.push(c);
-    }
-    for (let i = 0; i < shown.length; i++) {
-      const age = Math.round((Date.now() - shown[i].mtime) / 60000);
-      const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
-      console.log(`  [${i + 1}] ${shown[i].threadDir}  (${ageStr})`);
-    }
-    console.log();
-
-    const readline = await import("node:readline");
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise<string>((r) => {
-      rl.question("Pick a session [1]: ", (ans) => { rl.close(); r(ans.trim() || "1"); });
-    });
-
-    const idx = parseInt(answer, 10) - 1;
-    if (isNaN(idx) || idx < 0 || idx >= shown.length) {
-      console.error("Invalid selection.");
-      process.exit(1);
-    }
-    selected = candidates.find((c) => c.threadDir === shown[idx].threadDir)!;
-  }
+  const selected = candidates[0];
 
   console.log(`\nOpening: ${selected.sessionFile}\n`);
 
@@ -394,7 +343,7 @@ Commands:
   config              Show config path and contents
   agent <message>     Send a message to the agent and print response
                        Options: --thread <id>, --stdin, --timeout <sec>,
-                                --no-timeout, --verbose
+                                --no-timeout, --verbose, --ephemeral
   doctor [--fix]       Check system health and configuration
                        Options: --fix, --json, --verbose
   cron <command>       Manage scheduled jobs (add, list, trigger, etc.)
@@ -414,6 +363,7 @@ Environment:
 async function cmdAgent() {
   // Usage: roundhouse agent <message>
   //        roundhouse agent --thread <id> <message>
+  //        roundhouse agent --ephemeral <message>
   //        echo "message" | roundhouse agent --stdin
   const args = process.argv.slice(3);
   let threadId = "";
@@ -421,6 +371,7 @@ async function cmdAgent() {
   let useStdin = false;
   let timeoutMs = 120_000;
   let verbose = false;
+  let ephemeral = false;
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--thread" && args[i + 1]) {
@@ -435,6 +386,8 @@ async function cmdAgent() {
       timeoutMs = 0;
     } else if (args[i] === "--verbose") {
       verbose = true;
+    } else if (args[i] === "--ephemeral") {
+      ephemeral = true;
     } else if (args[i].startsWith("-")) {
       console.error(`Unknown flag: ${args[i]}`);
       process.exit(1);
@@ -468,13 +421,20 @@ async function cmdAgent() {
     console.error("       echo \"message\" | roundhouse agent --stdin");
     console.error("       roundhouse agent --timeout 60 <message>");
     console.error("       roundhouse agent --verbose <message>");
+    console.error("       roundhouse agent --ephemeral <message>");
+    process.exit(1);
+  }
+
+  if (threadId && ephemeral) {
+    console.error("--thread and --ephemeral cannot be used together");
     process.exit(1);
   }
 
-  // Default: ephemeral thread ID (no session persistence across invocations)
-  // --thread <id> opts into persistent/shared sessions
+  // Default: shared main session. --ephemeral restores one-off CLI behavior.
   if (!threadId) {
-    threadId = `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    threadId = ephemeral
+      ? `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+      : "main";
   }
 
   // Suppress debug/info logs unless --verbose

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

@@ -2,15 +2,15 @@
  * Disk and directory checks
  */
 
-import { access, stat, readdir, constants } from "node:fs/promises";
+import { access, readdir, constants } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { mkdirSync } from "node:fs";
 import type { DoctorCheck } from "../types";
 import { run } from "../shell";
+import { SESSIONS_DIR } from "../../../config";
 
 const INCOMING_DIR = process.env.ROUNDHOUSE_INCOMING_DIR ?? join(homedir(), ".roundhouse", "incoming");
-const SESSIONS_DIR = join(homedir(), ".pi", "agent", "gateway-sessions");
 
 export const diskChecks: DoctorCheck[] = [
   {

package/src/config.ts

@@ -22,6 +22,7 @@ export const LEGACY_CONFIG_DIR = resolve(homedir(), ".config", "roundhouse");
 export const CONFIG_DIR = ROUNDHOUSE_DIR;
 export const CONFIG_PATH = resolve(ROUNDHOUSE_DIR, "gateway.config.json");
 export const ENV_FILE_PATH = resolve(ROUNDHOUSE_DIR, ".env");
+export const SESSIONS_DIR = resolve(ROUNDHOUSE_DIR, "sessions");
 
 /** Legacy env file name (deprecated) */
 export const LEGACY_ENV_FILE_PATH = resolve(ROUNDHOUSE_DIR, "env");
@@ -181,11 +182,11 @@ export async function loadConfig(): Promise<GatewayConfig> {
         console.error(`[roundhouse] failed to parse config at ${resolved.path}: ${err.message}`);
         process.exit(1);
       }
-      // Try cwd
+      // Try cwd (with security warning)
       try {
         const cwdPath = resolve(process.cwd(), "gateway.config.json");
         const raw = await readFile(cwdPath, "utf8");
-        console.log("[roundhouse] loaded gateway.config.json from cwd");
+        console.warn(`[roundhouse] ⚠️  loaded gateway.config.json from cwd (${cwdPath}) — consider using ~/.roundhouse/gateway.config.json instead`);
         config = JSON.parse(raw) as GatewayConfig;
       } catch (cwdErr: any) {
         if (cwdErr.code !== "ENOENT") {

package/src/cron/runner.ts

@@ -31,19 +31,20 @@ export class CronRunner {
     const threadId = buildCronThreadId(job.id, runId);
     const timeoutMs = job.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 
-    // Render prompt
-    const tz = job.schedule.type === "cron" ? job.schedule.tz : job.schedule.type === "once" ? job.schedule.tz : undefined;
-    const ctx = buildTemplateContext(job.id, job.description, runId, scheduledAt, startedAt, tz, process.cwd(), job.vars ?? {});
-    const prompt = renderTemplate(job.prompt, ctx) + CRON_PROMPT_SUFFIX;
-
-    console.log(`[cron] starting ${job.id} [${runId}] kind=${kind}`);
-
-    // Create fresh agent — use provided config or load dynamically for CLI trigger
+    // Load agent config before rendering prompt (template needs agentCfg.cwd)
     let agentCfg = this.agentConfig;
     if (!agentCfg) {
       const { loadConfig } = await import("../config");
       agentCfg = (await loadConfig()).agent;
     }
+
+    // Render prompt
+    const tz = job.schedule.type === "cron" ? job.schedule.tz : job.schedule.type === "once" ? job.schedule.tz : undefined;
+    const agentCwd = (agentCfg.cwd as string) ?? process.cwd();
+    const ctx = buildTemplateContext(job.id, job.description, runId, scheduledAt, startedAt, tz, agentCwd, job.vars ?? {});
+    const prompt = renderTemplate(job.prompt, ctx) + CRON_PROMPT_SUFFIX;
+
+    console.log(`[cron] starting ${job.id} [${runId}] kind=${kind}`);
     const { type, ...rest } = agentCfg;
     const factory = getAgentFactory(type);
     const agent = factory({ ...rest, sessionDir: undefined });

package/src/gateway.ts

@@ -68,6 +68,33 @@ const ROUNDHOUSE_VERSION: string = (() => {
   catch { return "unknown"; }
 })();
 
+function telegramChatIdFromThreadId(threadId: unknown): number | null {
+  if (typeof threadId !== "string") return null;
+  const match = threadId.match(/^telegram:(-?\d+)/);
+  if (!match) return null;
+  const parsed = parseInt(match[1], 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+function getChatId(thread: any, message: any): string {
+  const id = message?.chat?.id ?? message?.chatId ?? thread?.chatId;
+  if (id !== undefined && id !== null) return String(id);
+  return String(thread?.id ?? "unknown");
+}
+
+function resolveAgentThreadId(thread: any, message: any): string {
+  const chatType = String(message?.chat?.type ?? thread?.chat?.type ?? thread?.type ?? "").toLowerCase();
+  if (["private", "dm", "direct", "im"].includes(chatType)) return "main";
+  if (["group", "supergroup", "channel"].includes(chatType)) return `group:${getChatId(thread, message)}`;
+
+  const telegramChatId = telegramChatIdFromThreadId(thread?.id);
+  if (telegramChatId !== null) {
+    return telegramChatId < 0 ? `group:${telegramChatId}` : "main";
+  }
+
+  return String(thread?.id ?? "main");
+}
+
 // ── Chat SDK adapter factories ───────────────────────
 // Lazy-imported so we don't crash if an adapter package isn't installed.
 
@@ -156,7 +183,7 @@ async function saveAttachments(threadId: string, attachments: any[]): Promise<At
   // Per-message directory: <thread>/<timestamp_nonce>/
   const msgDir = join(INCOMING_DIR, threadIdToDir(threadId), `${Date.now()}_${generateAttachmentId()}`);
   try {
-    mkdirSync(msgDir, { recursive: true });
+    mkdirSync(msgDir, { recursive: true, mode: 0o700 });
   } catch (err) {
     console.error(`[roundhouse] failed to create incoming dir ${msgDir}:`, (err as Error).message);
     return { saved: [], skipped: ["Failed to create storage directory"] };
@@ -215,7 +242,7 @@ async function saveAttachments(threadId: string, attachments: any[]): Promise<At
       const fileName = `${i}-${rawName}`;
       const filePath = join(msgDir, fileName);
 
-      await writeFile(filePath, buf);
+      await writeFile(filePath, buf, { mode: 0o600 });
 
       const VALID_MEDIA_TYPES = new Set(["audio", "image", "file", "video"]);
       const mediaType = VALID_MEDIA_TYPES.has(att.type) ? att.type : "file";
@@ -279,9 +306,13 @@ export class Gateway {
         : typeof thread.id === "string" && thread.id.startsWith("telegram:")
           ? parseInt(thread.id.split(":")[1], 10)
           : undefined;
-      const userId = typeof message.author?.id === "string"
-        ? parseInt(message.author.id, 10)
-        : undefined;
+      // Chat SDK Telegram adapter provides userId (not id)
+      const rawUserId = message.author?.userId ?? message.author?.id ?? message.raw?.from?.id;
+      const userId = typeof rawUserId === "number"
+        ? rawUserId
+        : typeof rawUserId === "string"
+          ? parseInt(rawUserId, 10)
+          : undefined;
 
       if (chatId == null || Number.isNaN(chatId) || userId == null || Number.isNaN(userId)) {
         console.error(`[roundhouse] Pairing nonce matched but could not extract IDs: chatId=${chatId} userId=${userId}. Pairing left pending.`);
@@ -372,6 +403,13 @@ export class Gateway {
     if (!this.config.chat.notifyChatIds) this.config.chat.notifyChatIds = [];
     const allowedUserIds = this.config.chat.allowedUserIds;
 
+    // SECURITY: Warn (loudly) when no auth allowlist is configured
+    if (allowedUsers.length === 0 && allowedUserIds.length === 0) {
+      console.warn("\n⚠️  WARNING: No allowedUsers or allowedUserIds configured!");
+      console.warn("   Any Telegram user who finds this bot can interact with the agent.");
+      console.warn("   Run: roundhouse setup --telegram --user <your-username>\n");
+    }
+
     // Per-thread verbose toggle (shows tool_start messages)
     const verboseThreads = new Set<string>();
 
@@ -383,12 +421,13 @@ export class Gateway {
 
     // ── Unified handler ────────────────────────────
     const handle = async (thread: any, message: any) => {
+      const agentThreadId = resolveAgentThreadId(thread, message);
       const userText = message.text ?? "";
       const authorName = message.author?.userName ?? message.author?.userId ?? "?";
       const rawAttachments = message.attachments ?? [];
 
       console.log(
-        `[roundhouse] ${thread.id} @${authorName}: "${userText.slice(0, 120)}"${rawAttachments.length ? ` +${rawAttachments.length} attachment(s)` : ""}`
+        `[roundhouse] ${thread.id} -> ${agentThreadId} @${authorName}: "${userText.slice(0, 120)}"${rawAttachments.length ? ` +${rawAttachments.length} attachment(s)` : ""}`
       );
 
       // Check for pending Telegram pairing (headless setup)
@@ -407,14 +446,14 @@ export class Gateway {
 
       // Handle /new command — dispose current session, start fresh
       if (isCommand(userText.trim(), "/new")) {
-        const agent = this.router.resolve(thread.id);
+        const agent = this.router.resolve(agentThreadId);
         if (agent.restart) {
-          await agent.restart(thread.id);
+          await agent.restart(agentThreadId);
           await thread.post("🔄 Session restarted. Send a message to begin a new conversation.");
         } else {
           await thread.post("⚠️ New session not supported for this agent.");
         }
-        console.log(`[roundhouse] /new for thread=${thread.id}`);
+        console.log(`[roundhouse] /new for thread=${thread.id} agentThread=${agentThreadId}`);
         return;
       }
 
@@ -437,13 +476,22 @@ export class Gateway {
       }
 
       // Handle /compact command — flush memory then compact session context
+      // Routed through the per-thread lock to prevent concurrent agent access
       if (isCommand(userText.trim(), "/compact")) {
-        const agent = this.router.resolve(thread.id);
+        const agent = this.router.resolve(agentThreadId);
         if (!agent.compact) {
           await thread.post("⚠️ Compaction not supported for this agent.");
           return;
         }
-        console.log(`[roundhouse] /compact for thread=${thread.id}`);
+        console.log(`[roundhouse] /compact for thread=${thread.id} agentThread=${agentThreadId}`);
+
+        // Acquire per-thread lock (same as normal prompts)
+        const prevLock = threadLocks.get(agentThreadId);
+        let releaseLock: () => void;
+        const lockPromise = new Promise<void>((resolve) => { releaseLock = resolve; });
+        threadLocks.set(agentThreadId, lockPromise);
+        if (prevLock) await prevLock;
+
         await thread.post("📝 Saving memory and compacting...");
         const stopTyping = startTypingLoop(thread);
         try {
@@ -451,7 +499,7 @@ export class Gateway {
           const memoryRoot = this.config.memory?.rootDir ?? agentCwd;
           // If memory is disabled, compact directly without flush
           if (this.config.memory?.enabled === false) {
-            const result = await agent.compact(thread.id);
+            const result = await agent.compact(agentThreadId);
             if (!result) {
               await thread.post("⚠️ No active session to compact. Send a message first.");
             } else {
@@ -459,7 +507,7 @@ export class Gateway {
               await thread.post(`✅ Compaction complete\n\nCompacted ${beforeK}K tokens down to a summary.\nContext usage will update after your next message.`);
             }
           } else {
-            const result = await flushMemoryThenCompact(thread.id, agent, memoryRoot, "manual", this.config.memory);
+            const result = await flushMemoryThenCompact(agentThreadId, agent, memoryRoot, "manual", this.config.memory);
             if (!result) {
               await thread.post("⚠️ No active session to compact. Send a message first.");
             } else {
@@ -472,13 +520,17 @@ export class Gateway {
           await thread.post(`⚠️ Compaction failed: ${msg.slice(0, 200)}`);
         } finally {
           stopTyping();
+          releaseLock!();
+          if (threadLocks.get(agentThreadId) === lockPromise) {
+            threadLocks.delete(agentThreadId);
+          }
         }
         return;
       }
 
       // Handle /status command — show gateway details
       if (isCommand(userText.trim(), "/status")) {
-        const agent = this.router.resolve(thread.id);
+        const agent = this.router.resolve(agentThreadId);
         const uptimeSec = process.uptime();
         const uptimeStr = uptimeSec < 3600
           ? `${Math.floor(uptimeSec / 60)}m ${Math.floor(uptimeSec % 60)}s`
@@ -488,7 +540,7 @@ export class Gateway {
         const nodeVer = process.version;
         const memMB = (process.memoryUsage.rss() / 1024 / 1024).toFixed(1);
 
-        const info = agent.getInfo ? agent.getInfo(thread.id) : {};
+        const info = agent.getInfo ? agent.getInfo(agentThreadId) : {};
         const agentVersion = info.version ? `v${info.version}` : "";
         const agentLabel = agentVersion ? `\`${agent.name}\` (${agentVersion})` : `\`${agent.name}\``;
 
@@ -509,7 +561,7 @@ export class Gateway {
           `💾 Memory: ${memMB} MB`,
           `🟢 Node: ${nodeVer}`,
           `🔧 Debug stream: ${debugStream ? "on" : "off"}`,
-          `📢 Verbose: ${verboseThreads.has(thread.id) ? "on" : "off"}`,
+          `📢 Verbose: ${verboseThreads.has(agentThreadId) ? "on" : "off"}`,
         );
 
         const allowedCount = allowedUsers.length;
@@ -551,14 +603,14 @@ export class Gateway {
         }
 
         await thread.post({ markdown: lines.join("\n") });
-        console.log(`[roundhouse] /status for thread=${thread.id}`);
+        console.log(`[roundhouse] /status for thread=${thread.id} agentThread=${agentThreadId}`);
         return;
       }
 
       // Save any attachments (voice messages, images, files, etc.)
       let attachmentResult: AttachmentResult = { saved: [], skipped: [] };
       try {
-        attachmentResult = await saveAttachments(thread.id, rawAttachments);
+        attachmentResult = await saveAttachments(agentThreadId, rawAttachments);
       } catch (err) {
         console.error(`[roundhouse] saveAttachments error:`, (err as Error).message);
         if (!userText.trim()) {
@@ -588,16 +640,16 @@ export class Gateway {
         return;
       }
 
-      const agent = this.router.resolve(thread.id);
+      const agent = this.router.resolve(agentThreadId);
 
       // Serialize prompts per-thread (concurrent mode allows /stop to bypass)
-      const prevLock = threadLocks.get(thread.id);
+      const prevLock = threadLocks.get(agentThreadId);
       let releaseLock: () => void;
       const lockPromise = new Promise<void>((resolve) => { releaseLock = resolve; });
-      threadLocks.set(thread.id, lockPromise);
+      threadLocks.set(agentThreadId, lockPromise);
       if (prevLock) await prevLock;
 
-      console.log(`[roundhouse] → ${agent.name} | thread=${thread.id}`);
+      console.log(`[roundhouse] → ${agent.name} | thread=${agentThreadId}`);
 
       // Enrich audio attachments with transcripts (STT) — inside thread lock to prevent stampede
       if (this.sttService && agentMessage.attachments?.length) {
@@ -624,7 +676,7 @@ export class Gateway {
       const memoryRoot = this.config.memory?.rootDir ?? agentCwd;
       let memoryPrepared: Awaited<ReturnType<typeof prepareMemoryForTurn>> | undefined;
       try {
-        memoryPrepared = await prepareMemoryForTurn(thread.id, agentMessage, agent, memoryRoot, this.config.memory);
+        memoryPrepared = await prepareMemoryForTurn(agentThreadId, agentMessage, agent, memoryRoot, this.config.memory);
         agentMessage = memoryPrepared.message;
       } catch (err) {
         console.error(`[roundhouse] memory prepare error:`, (err as Error).message);
@@ -635,15 +687,15 @@ export class Gateway {
       try {
         if (agent.promptStream) {
           const ac = new AbortController();
-          abortControllers.set(thread.id, ac);
+          abortControllers.set(agentThreadId, ac);
           try {
-            await this.handleStreaming(thread, agent.promptStream(thread.id, agentMessage), verboseThreads.has(thread.id), ac.signal);
+            await this.handleStreaming(thread, agent.promptStream(agentThreadId, agentMessage), verboseThreads.has(agentThreadId), ac.signal);
           } finally {
-            abortControllers.delete(thread.id);
+            abortControllers.delete(agentThreadId);
           }
         } else {
           // Fallback: non-streaming prompt
-          const reply = await agent.prompt(thread.id, agentMessage);
+          const reply = await agent.prompt(agentThreadId, agentMessage);
           if (reply.text) {
             await this.postWithFallback(thread, reply.text);
           }
@@ -652,7 +704,7 @@ export class Gateway {
         // ── Memory: post-turn finalize + pressure check ───
         try {
           const pressure = await finalizeMemoryForTurn(
-            thread.id,
+            agentThreadId,
             memoryPrepared?.beforeDigest ?? null,
             agent, memoryRoot, this.config.memory,
           );
@@ -661,7 +713,7 @@ export class Gateway {
           if (effectivePressure !== "none") {
             // Run flush/compact INSIDE the thread lock to prevent race with next user message
             try {
-              await this.handleContextPressure(thread, agent, memoryRoot, effectivePressure);
+              await this.handleContextPressure(thread, agentThreadId, agent, memoryRoot, effectivePressure);
             } catch (err) {
               console.error(`[roundhouse] context pressure handler error:`, (err as Error).message);
             }
@@ -679,34 +731,35 @@ export class Gateway {
       } finally {
         stopTyping();
         releaseLock!();
-        if (threadLocks.get(thread.id) === lockPromise) {
-          threadLocks.delete(thread.id);
+        if (threadLocks.get(agentThreadId) === lockPromise) {
+          threadLocks.delete(agentThreadId);
         }
       }
     };
 
     // ── Wire Chat SDK events ───────────────────────
     const handleOrAbort = async (thread: any, message: any) => {
+      const agentThreadId = resolveAgentThreadId(thread, message);
       const text = (message.text ?? "").trim();
       // /stop is handled immediately — abort the in-flight agent run
       // without waiting for the current handler to finish
       if (isCommand(text, "/stop")) {
         if (!isAllowed(message, allowedUsers, allowedUserIds)) return;
-        const agent = this.router.resolve(thread.id);
+        const agent = this.router.resolve(agentThreadId);
         if (agent.abort) {
-          await agent.abort(thread.id);
-          abortControllers.get(thread.id)?.abort();
+          await agent.abort(agentThreadId);
+          abortControllers.get(agentThreadId)?.abort();
           try { await thread.post("⏹️ Stopped."); } catch {}
         } else {
           try { await thread.post("⚠️ Abort not supported for this agent."); } catch {}
         }
-        console.log(`[roundhouse] /stop for thread=${thread.id}`);
+        console.log(`[roundhouse] /stop for thread=${thread.id} agentThread=${agentThreadId}`);
         return;
       }
       // /verbose is a gateway toggle — runs immediately, no queuing
       if (isCommand(text, "/verbose")) {
         if (!isAllowed(message, allowedUsers, allowedUserIds)) return;
-        const threadId = thread.id;
+        const threadId = agentThreadId;
         if (verboseThreads.has(threadId)) {
           verboseThreads.delete(threadId);
           try { await thread.post("🔇 Verbose mode OFF — tool status messages hidden."); } catch {}
@@ -714,7 +767,7 @@ export class Gateway {
           verboseThreads.add(threadId);
           try { await thread.post("📢 Verbose mode ON — showing tool calls."); } catch {}
         }
-        console.log(`[roundhouse] /verbose for thread=${threadId} -> ${verboseThreads.has(threadId) ? "on" : "off"}`);
+        console.log(`[roundhouse] /verbose for thread=${thread.id} agentThread=${threadId} -> ${verboseThreads.has(threadId) ? "on" : "off"}`);
         return;
       }
       // /doctor runs health checks immediately — no agent access needed
@@ -834,16 +887,16 @@ export class Gateway {
    * Handle context pressure — flush memory and/or compact.
    * Runs inside the thread lock after a turn completes.
    */
-  private async handleContextPressure(thread: any, agent: AgentAdapter, memoryRoot: string, pressure: PressureLevel) {
+  private async handleContextPressure(thread: any, agentThreadId: string, agent: AgentAdapter, memoryRoot: string, pressure: PressureLevel) {
     if (pressure === "none") return;
 
-    console.log(`[roundhouse] context pressure: ${pressure} for thread=${thread.id}`);
+    console.log(`[roundhouse] context pressure: ${pressure} for thread=${thread.id} agentThread=${agentThreadId}`);
 
     if (pressure === "soft") {
       // Soft: prompt agent to save facts, no compact
       // Cooldown is checked inside flushMemoryThenCompact (returns null if skipped)
       try {
-        await flushMemoryThenCompact(thread.id, agent, memoryRoot, "soft", this.config.memory);
+        await flushMemoryThenCompact(agentThreadId, agent, memoryRoot, "soft", this.config.memory);
       } catch (err) {
         console.error(`[roundhouse] soft flush error:`, (err as Error).message);
       }
@@ -853,7 +906,7 @@ export class Gateway {
     // Hard or emergency: flush + compact
     try {
       await thread.post(`📝 ${pressure === "emergency" ? "⚠️ Context nearly full! " : ""}Saving memory and compacting...`);
-      const result = await flushMemoryThenCompact(thread.id, agent, memoryRoot, pressure, this.config.memory);
+      const result = await flushMemoryThenCompact(agentThreadId, agent, memoryRoot, pressure, this.config.memory);
       if (result) {
         const beforeK = (result.tokensBefore / 1000).toFixed(1);
         await thread.post(`✅ Auto-compacted: ${beforeK}K tokens → summary.`);

package/src/memory/state.ts

@@ -9,7 +9,7 @@ import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
 import { resolve, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
 import { ROUNDHOUSE_DIR } from "../config";
-import { threadIdToDir, threadIdToDirLegacy } from "../util";
+import { threadIdToDir } from "../util";
 import type { ThreadMemoryState } from "./types";
 
 const STATE_DIR = resolve(ROUNDHOUSE_DIR, "memory-state");
@@ -18,24 +18,12 @@ function stateFilePath(threadId: string): string {
   return resolve(STATE_DIR, `${threadIdToDir(threadId)}.json`);
 }
 
-function legacyStateFilePath(threadId: string): string {
-  return resolve(STATE_DIR, `${threadIdToDirLegacy(threadId)}.json`);
-}
-
 /** Load per-thread memory state (returns empty state if none exists) */
 export async function loadThreadMemoryState(threadId: string): Promise<ThreadMemoryState> {
   try {
     const raw = await readFile(stateFilePath(threadId), "utf8");
     return JSON.parse(raw) as ThreadMemoryState;
   } catch {
-    // Fallback to legacy encoding for pre-v0.4 state files
-    try {
-      const legacyPath = legacyStateFilePath(threadId);
-      if (legacyPath !== stateFilePath(threadId)) {
-        const raw = await readFile(legacyPath, "utf8");
-        return JSON.parse(raw) as ThreadMemoryState;
-      }
-    } catch {}
     return {};
   }
 }
@@ -43,10 +31,10 @@ export async function loadThreadMemoryState(threadId: string): Promise<ThreadMem
 /** Save per-thread memory state (atomic write to prevent corruption) */
 export async function saveThreadMemoryState(threadId: string, state: ThreadMemoryState): Promise<void> {
   const path = stateFilePath(threadId);
-  await mkdir(dirname(path), { recursive: true });
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
   const tmp = `${path}.tmp.${randomBytes(4).toString("hex")}`;
   try {
-    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n");
+    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", { mode: 0o600 });
     await rename(tmp, path);
   } catch (err) {
     try { await unlink(tmp); } catch {}

package/src/util.ts

@@ -105,14 +105,6 @@ export function threadIdToDir(threadId: string): string {
     .replace(/[^a-zA-Z0-9_-]/g, (ch) => `_x${ch.charCodeAt(0).toString(16).padStart(4, "0")}`);
 }
 
-/** Legacy encoding (v0.3.x) for migration fallback */
-export function threadIdToDirLegacy(threadId: string): string {
-  return threadId
-    .replace(/_/g, "_u")
-    .replace(/:/g, "_c")
-    .replace(/[^a-zA-Z0-9_-]/g, "_x");
-}
-
 /**
  * Generate a short random attachment ID (e.g. "att_a1b2c3d4").
  */