@aion0/forge 0.10.77 → 0.10.78

package/RELEASE_NOTES.md

@@ -1,12 +1,14 @@
-# Forge v0.10.77
+# Forge v0.10.78
 
-Released: 2026-06-12
+Released: 2026-06-13
 
-## Changes since v0.10.76
+## Changes since v0.10.77
 
 ### Other
-- fix(ui): route idpManualUrls open through openPortal too
-- feat(ui): Open-portal buttons route through container Chromium when present
+- fix(projects): prefer ANY local checkout over clone when project is empty
+- feat(chat): live pipeline + task runtime chips in web chat
+- feat(mobile): default to Forge chat agent, toggle to terminal sessions
+- feat(telegram): full chat mode — /chat picks session, all messages route to agent, /endchat exits
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.76...v0.10.77
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.77...v0.10.78

package/app/chat/page.tsx

@@ -65,6 +65,13 @@ export default function ChatPage() {
   // Background-watch progress chips (watch_id → {text, ts}). Ambient,
   // updated in place; pruned when stale. Not part of the message thread.
   const [watchChips, setWatchChips] = useState<Record<string, { text: string; ts: number }>>({});
+  // Live pipeline + task runtime (polled from /api/activity/summary). Shows
+  // what the chat-triggered trigger_pipeline / dispatch_task — or anything
+  // else — has in flight, without leaving the chat.
+  const [running, setRunning] = useState<{
+    pipelines: Array<{ id: string; workflowName: string; currentNode: string | null; progress: { done: number; total: number } }>;
+    tasks: Array<{ id: string; project: string; prompt_preview: string; status: string }>;
+  }>({ pipelines: [], tasks: [] });
   const [input, setInput] = useState('');
   const [streaming, setStreaming] = useState(false);
   // True from Stop-click → next iteration boundary on the backend. Drives
@@ -258,6 +265,31 @@ export default function ChatPage() {
     return () => clearInterval(t);
   }, []);
 
+  // ─── Poll live pipeline + task runtime ────────────────────
+  useEffect(() => {
+    let alive = true;
+    const tick = async () => {
+      try {
+        const r = await fetch('/api/activity/summary');
+        if (!r.ok) return;
+        const j = await r.json();
+        if (!alive) return;
+        setRunning({
+          pipelines: (j.running || []).map((p: any) => ({
+            id: p.id, workflowName: p.workflowName, currentNode: p.currentNode,
+            progress: p.progress || { done: 0, total: 0 },
+          })),
+          tasks: (j.running_tasks || []).map((t: any) => ({
+            id: t.id, project: t.project, prompt_preview: t.prompt_preview, status: t.status,
+          })),
+        });
+      } catch { /* keep last */ }
+    };
+    tick();
+    const iv = setInterval(tick, 5000);
+    return () => { alive = false; clearInterval(iv); };
+  }, []);
+
   // ─── Auto-resize composer ─────────────────────────────────
   useEffect(() => {
     const el = composerRef.current;
@@ -740,7 +772,7 @@ export default function ChatPage() {
         )}
         </div>
 
-        {Object.keys(watchChips).length > 0 && (
+        {(Object.keys(watchChips).length > 0 || running.pipelines.length > 0 || running.tasks.length > 0) && (
           <div className="px-6 pt-2">
             <div className="max-w-3xl mx-auto flex flex-wrap gap-2">
               {Object.entries(watchChips).map(([id, w]) => (
@@ -753,6 +785,26 @@ export default function ChatPage() {
                   {w.text}
                 </span>
               ))}
+              {running.pipelines.map((p) => (
+                <span
+                  key={p.id}
+                  title={`pipeline ${p.id}${p.currentNode ? ` — ${p.currentNode}` : ''}`}
+                  className="inline-flex items-center gap-1.5 text-xs rounded-full border border-[var(--border)] bg-[var(--bg-secondary)] px-3 py-1 text-[var(--text-secondary)]"
+                >
+                  <span className="inline-block h-1.5 w-1.5 rounded-full bg-sky-400 animate-pulse" />
+                  ⛓ {p.workflowName} {p.progress.total > 0 ? `${p.progress.done}/${p.progress.total}` : ''}{p.currentNode ? ` · ${p.currentNode}` : ''}
+                </span>
+              ))}
+              {running.tasks.map((t) => (
+                <span
+                  key={t.id}
+                  title={`task ${t.id} (${t.project})`}
+                  className="inline-flex items-center gap-1.5 text-xs rounded-full border border-[var(--border)] bg-[var(--bg-secondary)] px-3 py-1 text-[var(--text-secondary)]"
+                >
+                  <span className="inline-block h-1.5 w-1.5 rounded-full bg-emerald-400 animate-pulse" />
+                  ⚙ {t.project}: {t.prompt_preview.slice(0, 30)}
+                </span>
+              ))}
             </div>
           </div>
         )}

package/components/MobileChat.tsx

@@ -0,0 +1,225 @@
+'use client';
+
+/**
+ * Mobile chat view — talks to chat-standalone via /api/chat-proxy, the same
+ * backend as the web /chat and the Telegram chat bridge. Self-contained:
+ * session picker (+ new), message history, streaming SSE. Rendered by
+ * MobileView when viewMode === 'chat' (the default).
+ */
+
+import { useState, useEffect, useRef, useCallback } from 'react';
+
+const PROXY = '/api/chat-proxy';
+
+interface ChatSession { id: string; title?: string; updated_at?: string }
+interface Block { type: string; text?: string; name?: string }
+interface ChatMsg { id?: string; role: string; blocks?: Block[]; content?: string; error?: string }
+
+function msgText(m: ChatMsg): string {
+  if (typeof m.content === 'string' && m.content) return m.content;
+  if (Array.isArray(m.blocks)) {
+    return m.blocks
+      .map((b) => (b.type === 'text' ? (b.text || '') : b.type === 'tool_use' ? `⚙ ${b.name || 'tool'}` : ''))
+      .filter(Boolean)
+      .join('\n');
+  }
+  return '';
+}
+
+export default function MobileChat() {
+  const [sessions, setSessions] = useState<ChatSession[]>([]);
+  const [activeId, setActiveId] = useState<string>('');
+  const [messages, setMessages] = useState<ChatMsg[]>([]);
+  const [input, setInput] = useState('');
+  const [streaming, setStreaming] = useState(false);
+  const [partial, setPartial] = useState('');
+  const [showPicker, setShowPicker] = useState(false);
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const srcRef = useRef<EventSource | null>(null);
+
+  const refreshSessions = useCallback(async () => {
+    try {
+      const r = await fetch(`${PROXY}/sessions?limit=50`);
+      const j = await r.json();
+      setSessions(Array.isArray(j?.sessions) ? j.sessions : []);
+    } catch { /* keep */ }
+  }, []);
+
+  const loadMessages = useCallback(async (id: string) => {
+    try {
+      const r = await fetch(`${PROXY}/sessions/${encodeURIComponent(id)}?limit=500`);
+      const j = await r.json();
+      setMessages(Array.isArray(j?.messages) ? j.messages : []);
+    } catch { /* keep */ }
+  }, []);
+
+  // First load: pick the main session (or the most recent / a fresh one).
+  useEffect(() => {
+    (async () => {
+      await refreshSessions();
+      try {
+        const r = await fetch(`${PROXY}/sessions/main`);
+        if (r.ok) {
+          const j = await r.json();
+          const id = j?.session?.id || j?.id;
+          if (id) { setActiveId(id); return; }
+        }
+      } catch { /* fall through */ }
+      try {
+        const r = await fetch(`${PROXY}/sessions?limit=1`);
+        const j = await r.json();
+        const id = j?.sessions?.[0]?.id;
+        if (id) setActiveId(id);
+      } catch { /* none */ }
+    })();
+  }, [refreshSessions]);
+
+  useEffect(() => { if (activeId) loadMessages(activeId); }, [activeId, loadMessages]);
+
+  // Auto-scroll
+  useEffect(() => {
+    if (scrollRef.current) scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+  }, [messages, partial]);
+
+  // SSE subscription per active session.
+  useEffect(() => {
+    if (!activeId) return;
+    srcRef.current?.close();
+    const src = new EventSource(`${PROXY}/sessions/${encodeURIComponent(activeId)}/events`);
+    srcRef.current = src;
+    src.onmessage = (ev) => {
+      let p: { type?: string; data?: any };
+      try { p = JSON.parse(ev.data); } catch { return; }
+      const data = p.data || {};
+      if (p.type === 'text_delta') {
+        setPartial((s) => s + (data.delta || ''));
+      } else if (p.type === 'message_saved') {
+        loadMessages(activeId);
+        setPartial('');
+      } else if (p.type === 'turn_done') {
+        setStreaming(false);
+        setPartial('');
+        loadMessages(activeId);
+        refreshSessions();
+      } else if (p.type === 'error') {
+        setStreaming(false);
+        setPartial('');
+        setMessages((m) => [...m, { role: 'system', content: `Error: ${data.error || 'unknown'}` }]);
+      }
+    };
+    return () => { src.close(); };
+  }, [activeId, loadMessages, refreshSessions]);
+
+  const send = async () => {
+    const text = input.trim();
+    if (!text || !activeId || streaming) return;
+    setInput('');
+    setStreaming(true);
+    // Optimistic user bubble; turn_done reloads the real thread from DB.
+    setMessages((m) => [...m, { role: 'user', content: text }]);
+    try {
+      await fetch(`${PROXY}/sessions/${encodeURIComponent(activeId)}/messages`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ text }),
+      });
+    } catch (e) {
+      setStreaming(false);
+      setMessages((m) => [...m, { role: 'system', content: `Send failed: ${(e as Error).message}` }]);
+    }
+  };
+
+  const newSession = async () => {
+    try {
+      const r = await fetch(`${PROXY}/sessions`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ title: 'Mobile chat' }),
+      });
+      const j = await r.json();
+      const id = j?.session?.id || j?.id;
+      if (id) { setActiveId(id); setMessages([]); setShowPicker(false); await refreshSessions(); }
+    } catch { /* ignore */ }
+  };
+
+  const pickSession = (id: string) => { setActiveId(id); setMessages([]); setShowPicker(false); };
+
+  const activeTitle = sessions.find((s) => s.id === activeId)?.title || (activeId ? activeId.slice(0, 8) : 'No session');
+
+  return (
+    <div className="flex-1 flex flex-col min-h-0">
+      {/* Session bar */}
+      <div className="shrink-0 flex items-center gap-2 px-3 py-1.5 bg-[#161b22] border-b border-[#30363d]">
+        <button
+          onClick={() => { setShowPicker((v) => !v); if (!showPicker) refreshSessions(); }}
+          className="flex-1 text-left text-xs text-[#e6edf3] truncate active:opacity-70"
+        >💬 {activeTitle} ▾</button>
+        <button onClick={newSession} className="text-xs px-2 py-1 border border-[#30363d] rounded text-[#8b949e] active:bg-[#30363d]">+ New</button>
+      </div>
+
+      {showPicker && (
+        <div className="shrink-0 max-h-[40vh] overflow-y-auto bg-[#161b22] border-b border-[#30363d]">
+          {sessions.length === 0 ? (
+            <div className="px-3 py-4 text-xs text-[#8b949e] text-center">No sessions</div>
+          ) : sessions.map((s) => (
+            <button
+              key={s.id}
+              onClick={() => pickSession(s.id)}
+              className={`w-full text-left px-3 py-2 border-b border-[#30363d]/50 text-xs active:bg-[#1c2128] ${s.id === activeId ? 'text-[#7c5bf0]' : 'text-[#e6edf3]'}`}
+            >
+              <span className="truncate">{s.title || s.id.slice(0, 12)}</span>
+            </button>
+          ))}
+        </div>
+      )}
+
+      {/* Messages */}
+      <div ref={scrollRef} className="flex-1 overflow-y-auto px-3 py-2 min-h-0 space-y-3">
+        {messages.length === 0 && !partial ? (
+          <div className="h-full flex items-center justify-center text-sm text-[#8b949e]">Send a message to start.</div>
+        ) : messages.map((m, i) => {
+          const t = msgText(m);
+          if (!t) return null;
+          return (
+            <div key={m.id || i} className={`flex ${m.role === 'user' ? 'justify-end' : 'justify-start'}`}>
+              <div className={`max-w-[85%] rounded-2xl px-3 py-2 text-sm whitespace-pre-wrap break-words ${
+                m.role === 'user' ? 'bg-[#7c5bf0] text-white rounded-br-sm'
+                  : m.role === 'system' ? 'bg-red-900/30 text-red-300 rounded-bl-sm'
+                  : 'bg-[#1c2128] text-[#e6edf3] rounded-bl-sm'
+              }`}>{t}</div>
+            </div>
+          );
+        })}
+        {partial && (
+          <div className="flex justify-start">
+            <div className="max-w-[85%] rounded-2xl rounded-bl-sm px-3 py-2 text-sm whitespace-pre-wrap break-words bg-[#1c2128] text-[#e6edf3]">{partial}</div>
+          </div>
+        )}
+        {streaming && !partial && (
+          <div className="flex justify-start">
+            <div className="bg-[#1c2128] rounded-2xl rounded-bl-sm px-3 py-2 text-sm text-[#8b949e]">Thinking…</div>
+          </div>
+        )}
+      </div>
+
+      {/* Input */}
+      <div className="shrink-0 flex items-center gap-2 px-3 py-2 bg-[#161b22] border-t border-[#30363d]">
+        <input
+          type="text"
+          value={input}
+          onChange={(e) => setInput(e.target.value)}
+          onKeyDown={(e) => { if (e.key === 'Enter' && !streaming) send(); }}
+          placeholder={activeId ? 'Type a message…' : 'No session'}
+          disabled={!activeId}
+          className="flex-1 bg-[#0d1117] border border-[#30363d] rounded-lg px-3 py-2 text-sm text-[#e6edf3] focus:outline-none focus:border-[#7c5bf0] disabled:opacity-50 min-w-0"
+          autoComplete="off" autoCorrect="off"
+        />
+        <button
+          onClick={send}
+          disabled={!activeId || !input.trim() || streaming}
+          className="px-4 py-2 bg-[#7c5bf0] text-white rounded-lg text-sm font-medium disabled:opacity-50 shrink-0"
+        >Send</button>
+      </div>
+    </div>
+  );
+}

package/components/MobileView.tsx

@@ -1,6 +1,7 @@
 'use client';
 
 import { useState, useEffect, useRef, useCallback } from 'react';
+import MobileChat from './MobileChat';
 
 interface Project { name: string; path: string }
 interface SessionInfo { sessionId: string; summary?: string; firstPrompt?: string; modified?: string }
@@ -24,6 +25,9 @@ export default function MobileView() {
   const scrollRef = useRef<HTMLDivElement>(null);
   const inputRef = useRef<HTMLInputElement>(null);
   const abortRef = useRef<AbortController | null>(null);
+  // Default to the Forge chat agent (same backend as web /chat + Telegram);
+  // Terminal tab keeps the original claude-session browse/continue view.
+  const [viewMode, setViewMode] = useState<'chat' | 'terminal'>('chat');
 
   // Fetch projects
   useEffect(() => {
@@ -225,9 +229,24 @@ export default function MobileView() {
 
   return (
     <div className="h-[100dvh] flex flex-col bg-[#0d1117] text-[#e6edf3]">
+      {/* Mode toggle — Chat (Forge agent) vs Terminal (claude sessions) */}
+      <div className="shrink-0 flex items-center gap-1.5 px-2 py-1.5 bg-[#161b22] border-b border-[#30363d]">
+        <span className="text-xs font-bold text-[#7c5bf0] mr-1">Forge</span>
+        <button
+          onClick={() => setViewMode('chat')}
+          className={`text-xs px-2.5 py-1 rounded ${viewMode === 'chat' ? 'bg-[#7c5bf0] text-white' : 'border border-[#30363d] text-[#8b949e] active:bg-[#30363d]'}`}
+        >💬 Chat</button>
+        <button
+          onClick={() => setViewMode('terminal')}
+          className={`text-xs px-2.5 py-1 rounded ${viewMode === 'terminal' ? 'bg-[#7c5bf0] text-white' : 'border border-[#30363d] text-[#8b949e] active:bg-[#30363d]'}`}
+        >⌨ Terminal</button>
+        <a href="/?force=desktop" className="ml-auto text-[9px] px-1.5 py-1 border border-[#30363d] rounded text-[#8b949e] active:bg-[#30363d]" title="Switch to desktop view">PC</a>
+      </div>
+
+      {viewMode === 'chat' ? <MobileChat /> : (
+      <>
       {/* Header */}
       <header className="shrink-0 flex items-center gap-1.5 px-2 py-2 bg-[#161b22] border-b border-[#30363d]">
-        <span className="text-xs font-bold text-[#7c5bf0]">Forge</span>
         <select
           value={selectedProject?.path || ''}
           onChange={e => {
@@ -273,7 +292,6 @@ export default function MobileView() {
         {tunnelUrl && (
           <button onClick={closeTunnel} className="text-xs px-1.5 py-1 border border-green-700 rounded text-green-400" title={tunnelUrl}>●</button>
         )}
-        <a href="/?force=desktop" className="text-[9px] px-1.5 py-1 border border-[#30363d] rounded text-[#8b949e] active:bg-[#30363d]" title="Switch to desktop view">PC</a>
       </header>
 
       {/* Session list */}
@@ -380,6 +398,8 @@ export default function MobileView() {
           </div>
         )}
       </div>
+      </>
+      )}
     </div>
   );
 }

package/lib/chat/telegram-bridge.ts

@@ -104,6 +104,21 @@ async function ensureSession(telegramChatId: number): Promise<string> {
   return id;
 }
 
+/** List recent chat sessions (for the /chat picker). Best-effort: [] on error. */
+export async function listChatSessions(limit = 20): Promise<Array<{ id: string; title: string; updated_at?: string }>> {
+  try {
+    const r = await fetch(`${BASE}/api/sessions?limit=${limit}`);
+    if (!r.ok) return [];
+    const j = await r.json();
+    return Array.isArray(j?.sessions) ? j.sessions : [];
+  } catch { return []; }
+}
+
+/** Create a fresh chat session, returns its id (null on failure). */
+export async function newChatSession(title: string): Promise<string | null> {
+  try { return await createSession(title); } catch { return null; }
+}
+
 async function openSse(sessionId: string): Promise<ReadableStreamDefaultReader<Uint8Array>> {
   const res = await fetch(`${BASE}/api/sessions/${encodeURIComponent(sessionId)}/events`, {
     headers: { accept: 'text/event-stream' },

package/lib/help-docs/00-overview.md

@@ -83,3 +83,5 @@ Next to the **Automation** tab in the left-side nav sits a small **Activity** su
 - **User menu (▾)** — `⚙ Settings` + `💬 Chat (web) ↗` at the top (Chat opens in a new tab so the dashboard isn't replaced); then a divider, then the periodic-check screens `📊 Monitor` (background watches, processes, queues), `🔐 Login Status` (connector creds), `💰 Usage` (token/cost analytics), `📜 Logs`, `📱 Mobile View ↗`; then `⏻ Logout`.
 
 Periodic-check screens (Monitor / Login Status / Usage) live inside the user menu so the top bar only shows things worth glancing at.
+
+**Mobile View** (`/mobile`, opened from the user menu or auto on phones) defaults to a **💬 Chat** tab — the Forge chat agent, same backend as the web `/chat` and the Telegram chat. Pick or start a session and talk; replies stream live. Toggle to the **⌨ Terminal** tab to browse/continue Claude Code sessions per project (the original mobile view). `PC` switches to the desktop layout.

package/lib/help-docs/02-telegram.md

@@ -24,6 +24,8 @@
 | `/peek <project>` | Preview running session |
 | `/cancel <id>` | Cancel a task |
 | `/retry <id>` | Retry a failed task |
+| `/chat` | Enter chat mode — pick an existing chat session or start a new one, then every message goes to the Forge chat agent (same as the web `/chat`) |
+| `/endchat` | Leave chat mode |
 | `/tunnel_start <password>` | Start Cloudflare Tunnel (returns URL + code) |
 | `/tunnel_stop` | Stop tunnel |
 | `/tunnel_code <password>` | Get session code for remote login |
@@ -33,6 +35,7 @@
 - Reply to a task message to interact with it
 - Send `"project: instructions"` to quick-create a task
 - Numbered lists — reply with a number to select
+- **Chat mode**: `/chat` → reply with a number to pick a session (`0` = new) → talk normally; the agent streams replies just like the web `/chat`. `/endchat` exits. Other slash-commands still work while in chat mode.
 
 ## Troubleshooting
 

package/lib/projects.ts

@@ -400,11 +400,21 @@ export function resolveOrCloneProject(name: string | undefined): ResolveResult {
       const projects = scanProjects();
       const want = normalizeRepoPath(targetPath) || targetPath.toLowerCase().replace(/^\/+|\/+$/g, '');
       const wantBase = want.split('/').pop()!;
-      const byRepo = projects.filter((p) => p.repo && p.repo === want);
-      if (byRepo.length === 1) return { project: byRepo[0], source: 'existing' };
-      const byRepoBase = projects.filter((p) => p.repo && p.repo.split('/').pop() === wantBase);
-      if (byRepoBase.length === 1) return { project: byRepoBase[0], source: 'existing' };
-
+      // Prefer ANY local checkout — pipelines run in a worktree, so picking
+      // either of several same-repo checkouts (e.g. FortiNAC vs FortiNAC-v3,
+      // both origin fortinac/fortinac) is safe and never touches the user's
+      // branch. Order: exact origin path → origin basename → project name.
+      // Taking the first match (not requiring a unique one) is what keeps a
+      // clone — which fails when the GitLab host is behind a VPN the server
+      // can't reach — from being attempted at all when a local copy exists.
+      const localHit =
+        projects.find((p) => p.repo && p.repo === want) ||
+        projects.find((p) => p.repo && p.repo.split('/').pop() === wantBase) ||
+        projects.find((p) => p.name.toLowerCase() === wantBase.toLowerCase());
+      if (localHit) return { project: localHit, source: 'existing' };
+
+      // No local checkout at all — clone (may fail if host unreachable, then
+      // scratch below).
       const cloned = tryGitlabClone(targetPath);
       if (cloned) return { project: cloned, source: 'gitlab-cloned', clone_url: `${gl.base_url}/${targetPath.replace(/^\/+|\/+$/g, '')}.git` };
     }

package/lib/telegram-bot.ts

@@ -32,7 +32,11 @@ const chatNumberedTasks = new Map<number, Map<number, string>>();
 const chatNumberedSessions = new Map<number, Map<number, { projectName: string; sessionId: string }>>();
 const chatNumberedProjects = new Map<number, Map<number, string>>();
 // Track what the last numbered list was for
-const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions' | 'task-create' | 'peek' | 'inject-pick' | 'inject-typing'>();
+const chatListMode = new Map<number, 'tasks' | 'projects' | 'sessions' | 'task-create' | 'peek' | 'inject-pick' | 'inject-typing' | 'chat-pick'>();
+// Chat mode: once entered (/chat → pick session), every non-command message
+// goes to the Forge chat agent — same as the local /chat — until /endchat.
+const chatActiveMode = new Set<number>();                                   // chatIds currently in chat mode
+const chatNumberedChatSessions = new Map<number, Map<number, string>>();    // num → chat session id (0 = new)
 // Inject mode state — picked tmux session per chat
 const chatNumberedTmux = new Map<number, Map<number, string>>(); // num → tmux session name
 const chatInjectTarget = new Map<number, string>(); // chatId → tmux session name (currently selected)
@@ -147,11 +151,27 @@ async function handleMessage(msg: any) {
     return;
   }
 
+  // Chat mode: every non-command message (including bare numbers) goes to the
+  // chat agent until /endchat. Must run BEFORE numbered selection so digits are
+  // treated as chat content, not list picks. Commands fall through.
+  if (chatActiveMode.has(chatId) && !text.startsWith('/')) {
+    await handleChat(chatId, text);
+    return;
+  }
+
   // Quick number selection (1-10) → context-dependent
   if (/^\d{1,2}$/.test(text)) {
     const num = parseInt(text);
     const mode = chatListMode.get(chatId);
 
+    if (mode === 'chat-pick') {
+      const sessMap = chatNumberedChatSessions.get(chatId);
+      if (num === 0 || sessMap?.has(num)) {
+        await pickChatSession(chatId, num);
+        return;
+      }
+    }
+
     if (mode === 'task-create') {
       const projMap = chatNumberedProjects.get(chatId);
       if (projMap?.has(num)) {
@@ -298,17 +318,10 @@ async function handleMessage(msg: any) {
       }
       case '/chat':
       case '/c':
-        if (args.length === 0) {
-          await send(chatId, 'Usage: /chat <message>\n/chat_new to start a fresh session\n/chat_session to show the active session id');
-        } else {
-          await handleChat(chatId, args.join(' '));
-        }
-        break;
-      case '/chat_new':
-        await handleChatReset(chatId);
+        await enterChatMode(chatId);
         break;
-      case '/chat_session':
-        await handleChatStatus(chatId);
+      case '/endchat':
+        await exitChatMode(chatId);
         break;
       case '/tunnel':
         await handleTunnelStatus(chatId);
@@ -368,9 +381,8 @@ async function sendHelp(chatId: number) {
     `🔧 /cancel <id>  /retry <id>\n` +
     `/projects — list projects\n` +
     `🤖 /agents — list available agents\n\n` +
-    `💬 /chat <msg> — chat with Forge agent\n` +
-    `/chat_new — start a fresh chat session\n` +
-    `/chat_session — show active session id\n\n` +
+    `💬 /chat — enter chat mode (pick/new session)\n` +
+    `/endchat — leave chat mode\n\n` +
     `🌐 /tunnel — status\n` +
     `/tunnel_start / /tunnel_stop\n` +
     `/tunnel_code <admin_pw> — get session code\n\n` +
@@ -396,20 +408,56 @@ async function handleChat(chatId: number, userText: string) {
   }
 }
 
-async function handleChatReset(chatId: number) {
-  const { clearTelegramSession } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
-  clearTelegramSession(chatId);
-  await send(chatId, '✓ Chat session cleared. The next /chat starts fresh.');
+// Enter chat mode: show a numbered session picker (0 = new). Once the user
+// picks, every plain message goes to the chat agent until /endchat.
+async function enterChatMode(chatId: number) {
+  // Leave any active chat first so digits in the picker are read as choices,
+  // not chat content.
+  chatActiveMode.delete(chatId);
+  try {
+    const { listChatSessions } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
+    const sessions = await listChatSessions(15);
+    const numMap = new Map<number, string>();
+    const lines = ['💬 Chat mode — pick a session:', '', '0. ➕ New session'];
+    sessions.forEach((s, i) => {
+      const n = i + 1;
+      numMap.set(n, s.id);
+      const title = (s.title || s.id.slice(0, 8)).slice(0, 40);
+      lines.push(`${n}. ${title}`);
+    });
+    chatNumberedChatSessions.set(chatId, numMap);
+    chatListMode.set(chatId, 'chat-pick');
+    lines.push('', 'Reply with a number. /endchat to cancel.');
+    await send(chatId, lines.join('\n'));
+  } catch (err) {
+    await send(chatId, `✗ chat error: ${(err as Error).message}`);
+  }
 }
 
-async function handleChatStatus(chatId: number) {
-  const { getTelegramSession } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
-  const id = getTelegramSession(chatId);
-  if (!id) {
-    await send(chatId, 'No active chat session. /chat <message> creates one.');
-    return;
-  }
-  await send(chatId, `Active session: ${id}\n/chat_new to start fresh`);
+// Pick a session (0 = new) → bind it and switch to chat-active mode.
+async function pickChatSession(chatId: number, num: number) {
+  const { setTelegramSession, newChatSession } = require('./chat/telegram-bridge') as typeof import('./chat/telegram-bridge');
+  let sessionId: string | null;
+  if (num === 0) {
+    sessionId = await newChatSession(`Telegram chat ${chatId}`);
+    if (!sessionId) { await send(chatId, '✗ could not create a new session'); return; }
+  } else {
+    sessionId = chatNumberedChatSessions.get(chatId)?.get(num) || null;
+    if (!sessionId) { await send(chatId, 'Invalid choice. /chat to list again.'); return; }
+  }
+  setTelegramSession(chatId, sessionId);
+  chatListMode.delete(chatId);
+  chatNumberedChatSessions.delete(chatId);
+  chatActiveMode.add(chatId);
+  await send(chatId, `✅ Chat started${num === 0 ? ' (new session)' : ''}. Send messages normally — every message goes to the Forge agent.\n\n/endchat to leave.`);
+}
+
+// Leave chat mode. Keeps the session binding so /chat can resume it later.
+async function exitChatMode(chatId: number) {
+  const wasActive = chatActiveMode.delete(chatId);
+  chatListMode.delete(chatId);
+  chatNumberedChatSessions.delete(chatId);
+  await send(chatId, wasActive ? '👋 Left chat mode.' : 'Not in chat mode.');
 }
 
 async function sendAgentList(chatId: number) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.77",
+  "version": "0.10.78",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {