@aion0/forge 0.10.18 → 0.10.22

package/lib/browser-bridge-standalone.ts

@@ -48,6 +48,11 @@ import { randomUUID, createHash } from 'node:crypto';
 const PORT = Number(process.env.BRIDGE_PORT) || 8407;
 const FORGE_PORT = Number(process.env.PORT) || 8403;
 const RPC_TIMEOUT_MS = 60_000;
+// Ceiling for per-call overrides. Kept just under undici's default 300s
+// headersTimeout on the loopback fetch in bridge-client.ts — past that the
+// client fetch dies first with an opaque error. Genuinely long backend work
+// (multi-minute NAC upgrades) should fire-and-poll, not hold the RPC open.
+const RPC_TIMEOUT_MAX_MS = 280_000;
 const TOKEN_CACHE_TTL_MS = 60_000;
 
 // ─── Forge-token validation (with short-lived cache) ──────
@@ -112,17 +117,21 @@ interface PendingRpc {
 
 const pendingRpcs = new Map<string, PendingRpc>(); // rpc_id → callbacks
 
-function callExtension(method: string, params: unknown): Promise<unknown> {
+function callExtension(method: string, params: unknown, timeoutMs?: number): Promise<unknown> {
   const client = pickAnyClient();
   if (!client) {
     return Promise.reject(new Error('No extension connected to the bridge.'));
   }
   const id = randomUUID();
+  const effectiveTimeout = Math.min(
+    Math.max(1000, Number(timeoutMs) || RPC_TIMEOUT_MS),
+    RPC_TIMEOUT_MAX_MS,
+  );
   return new Promise<unknown>((resolve, reject) => {
     const timer = setTimeout(() => {
       pendingRpcs.delete(id);
-      reject(new Error(`RPC ${method} timed out after ${RPC_TIMEOUT_MS / 1000}s`));
-    }, RPC_TIMEOUT_MS);
+      reject(new Error(`RPC ${method} timed out after ${effectiveTimeout / 1000}s`));
+    }, effectiveTimeout);
     pendingRpcs.set(id, { resolve, reject, timer });
     client.ws.send(JSON.stringify({ type: 'rpc_request', id, method, params }));
   });
@@ -248,7 +257,7 @@ async function handleHttp(req: IncomingMessage, res: ServerResponse): Promise<vo
   if (req.method === 'POST' && url.pathname === '/api/rpc') {
     try {
       const body = JSON.parse(await readBody(req));
-      const value = await callExtension(body.method, body.params);
+      const value = await callExtension(body.method, body.params, body.timeout_ms);
       return sendJson(res, 200, { ok: true, value });
     } catch (e) {
       return sendJson(res, 200, { ok: false, error: (e as Error).message });

package/lib/chat/agent-loop.ts

@@ -308,9 +308,9 @@ function buildConnectorTools(): LlmTool[] {
     for (const entry of getConnectorEntries(def)) {
       for (const [toolName, tool] of Object.entries(entry.tools || {})) {
         // Executable if it has a script (browser protocol) OR a non-browser
-        // protocol that runs server-side (http / shell).
+        // protocol that runs server-side (http / shell / ssh).
         const protocol = (tool as any).protocol;
-        const isServerSide = protocol === 'http' || protocol === 'shell';
+        const isServerSide = protocol === 'http' || protocol === 'shell' || protocol === 'ssh';
         if (!tool.script && !isServerSide) continue;
         const properties: Record<string, unknown> = {};
         const required: string[] = [];

package/lib/chat/bridge-client.ts

@@ -13,13 +13,13 @@ const BRIDGE_PORT = Number(process.env.BRIDGE_PORT) || 8407;
 interface BridgeRpcOk { ok: true; value: unknown }
 interface BridgeRpcErr { ok: false; error: string }
 
-export async function bridgeRpc(method: string, params: unknown): Promise<unknown> {
+export async function bridgeRpc(method: string, params: unknown, timeoutMs?: number): Promise<unknown> {
   let res: Response;
   try {
     res = await fetch(`http://127.0.0.1:${BRIDGE_PORT}/api/rpc`, {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ method, params }),
+      body: JSON.stringify({ method, params, ...(timeoutMs ? { timeout_ms: timeoutMs } : {}) }),
     });
   } catch (e) {
     throw new Error(`browser bridge unreachable on port ${BRIDGE_PORT}: ${(e as Error).message}`);

package/lib/chat/protocols/ssh.ts

@@ -0,0 +1,206 @@
+/**
+ * SSH protocol runtime for connector tools (`protocol: ssh`).
+ *
+ * Drives the system `ssh` binary through a PTY (node-pty) so it can
+ * handle interactive flows the plain `shell` protocol can't: password
+ * auth and mid-command confirmations like `(y/N)`. Built for network
+ * devices — e.g. FortiNAC `execute restore image scp …` which prompts
+ * twice for `y` then streams a multi-minute restore before rebooting.
+ *
+ * Declarative, expect-style: the manifest's `ssh` block says what to
+ * send, what to auto-answer, the success/failure markers, and which
+ * regexes to capture from the transcript. Nothing here is FortiNAC-
+ * specific.
+ *
+ * Safety: connectors are user-installed. An ssh-protocol tool can run
+ * arbitrary remote commands — review at install time. The password is
+ * fed silently (ssh doesn't echo it) so it never lands in the captured
+ * transcript; we also never log it.
+ */
+
+import type { ConnectorTool, SshSpec } from '../../connectors/types';
+import { expandAllTokens } from '../../plugins/templates';
+import * as pty from 'node-pty';
+
+export interface SshProtocolArgs {
+  tool: ConnectorTool;
+  settings: Record<string, any>;
+  args: Record<string, any>;
+}
+
+export interface SshProtocolResult {
+  content: string;
+  is_error?: boolean;
+}
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 280_000;
+const MAX_OUTPUT_BYTES = 24 * 1024;
+
+function truncate(s: string): string {
+  const buf = Buffer.from(s, 'utf-8');
+  if (buf.byteLength <= MAX_OUTPUT_BYTES) return s;
+  // Keep the tail — the interesting markers (done/reboot) are at the end.
+  return `(…truncated, total ${buf.byteLength} bytes)\n` +
+    buf.subarray(buf.byteLength - MAX_OUTPUT_BYTES).toString('utf-8');
+}
+
+function rx(pattern: string | undefined): RegExp | null {
+  if (!pattern) return null;
+  try { return new RegExp(pattern, 'i'); } catch { return null; }
+}
+
+/**
+ * Resolve what to actually type for an auto-answer. If the rule's value is
+ * the intent `yes`/`no`, pick the token the prompt itself offers — `(yes/no)`
+ * → `yes`/`no`, otherwise `y`/`n`. We always send an EXPLICIT token (never
+ * rely on the prompt's default: `(y/N)` defaults to N, so "continue" must
+ * send `y` outright). Any other value is sent literally.
+ */
+function resolveAnswer(send: string, promptChunk: string): string {
+  const intent = String(send || '').trim().toLowerCase();
+  if (intent !== 'yes' && intent !== 'no') return send; // literal passthrough
+  const offersWords = /\byes\s*\/\s*no\b/i.test(promptChunk);
+  if (intent === 'yes') return offersWords ? 'yes' : 'y';
+  return offersWords ? 'no' : 'n';
+}
+
+export async function runSsh({ tool, settings, args }: SshProtocolArgs): Promise<SshProtocolResult> {
+  const specRaw = tool.ssh;
+  if (!specRaw) return { content: 'ssh tool missing `ssh` block', is_error: true };
+
+  const exp = (s: string | undefined) => (s == null ? '' : expandAllTokens(String(s), settings, args));
+
+  const spec: SshSpec = specRaw;
+
+  // Resolve connection params: chat arg > connector setting > literal in
+  // the ssh block > built-in default. (IP comes from chat; port/user/
+  // password fall back to the connector's saved defaults.)
+  const pickConn = (
+    argKeys: string[], settingKey: string, specVal: unknown, dflt: string, secret: boolean,
+  ): string => {
+    for (const k of argKeys) {
+      const v = args?.[k];
+      if (v != null && String(v) !== '') return secret ? String(v) : String(v).trim();
+    }
+    const sv = settings?.[settingKey];
+    if (sv != null && String(sv) !== '') return secret ? String(sv) : String(sv).trim();
+    if (specVal != null && specVal !== '') {
+      const r = exp(String(specVal));
+      if (r && !r.includes('{')) return secret ? r : r.trim();  // skip unresolved templates
+    }
+    return dflt;
+  };
+  const host = pickConn(['host'], 'host', spec.host, '', false);
+  const port = pickConn(['port'], 'port', spec.port, '22', false);
+  const user = pickConn(['username', 'user'], 'username', spec.user, '', false);
+  const password = pickConn(['password'], 'password', spec.password, '', true);
+  if (!host) return { content: 'ssh: host is required (pass it from chat, e.g. host=10.15.52.152)', is_error: true };
+  if (!user) return { content: 'ssh: user is required (pass username, or set a connector default)', is_error: true };
+
+  const commands = (spec.commands || []).map((c) => exp(c));
+  const autoAnswer = (spec.auto_answer || []).map((r) => ({ re: rx(r.match), send: exp(r.send) }));
+  const promptRe = rx(spec.prompt_regex) || /[#$>]\s*$/;
+  const doneRe = rx(spec.done_when);
+  const failRe = rx(spec.fail_when);
+  const passwordRe = /password:\s*$/i;
+  const timeoutMs = Math.min(MAX_TIMEOUT_MS, Math.max(2_000, Number(spec.timeout_sec || 0) * 1000 || DEFAULT_TIMEOUT_MS));
+
+  const sshArgs = [
+    '-tt',                                       // force PTY for interactive prompts
+    '-p', port,
+    '-o', 'StrictHostKeyChecking=accept-new',    // no yes/no host-key prompt
+    '-o', 'UserKnownHostsFile=/dev/null',        // don't pollute known_hosts
+    '-o', 'GlobalKnownHostsFile=/dev/null',
+    '-o', 'ConnectTimeout=15',
+    '-o', 'NumberOfPasswordPrompts=2',
+    `${user}@${host}`,
+  ];
+
+  return new Promise<SshProtocolResult>((resolve) => {
+    let term: pty.IPty;
+    try {
+      term = pty.spawn('ssh', sshArgs, {
+        name: 'xterm-color',
+        cols: 200, rows: 50,
+        cwd: process.env.HOME || process.cwd(),
+        env: process.env as Record<string, string>,
+      });
+    } catch (e) {
+      return resolve({ content: `ssh spawn failed: ${(e as Error).message}`, is_error: true });
+    }
+
+    let full = '';
+    let cmdIndex = 0;
+    let pwSent = 0;
+    let settled = false;
+    const captured: Record<string, string> = {};
+
+    const finish = (is_error: boolean, note: string) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try { term.kill(); } catch {}
+      // Run captures over the full transcript.
+      if (spec.capture) {
+        for (const [name, pat] of Object.entries(spec.capture)) {
+          const m = full.match(rx(pat) || /$^/);
+          if (m && m[1] != null) captured[name] = m[1];
+        }
+      }
+      const payload = {
+        ok: !is_error,
+        note,
+        ...(Object.keys(captured).length ? { captured } : {}),
+        output_tail: truncate(full).slice(-4000),
+      };
+      resolve({ content: JSON.stringify(payload), is_error });
+    };
+
+    const timer = setTimeout(() => finish(true, `timed out after ${timeoutMs / 1000}s`), timeoutMs);
+
+    term.onData((chunk: string) => {
+      full += chunk;
+      // 1) success / failure markers (check on a trailing window so a
+      //    marker split across chunks still matches).
+      const tail = full.slice(-2000);
+      if (doneRe && doneRe.test(tail)) return finish(false, 'done marker matched');
+      if (failRe && failRe.test(tail)) return finish(true, 'failure marker matched');
+
+      // 2) password prompt → feed password silently.
+      if (password && passwordRe.test(chunk)) {
+        if (pwSent >= 2) return finish(true, 'authentication failed (password rejected)');
+        pwSent++;
+        term.write(`${password}\r`);
+        return;
+      }
+
+      // 3) interactive confirmations — resolve the correct token (y/yes/
+      //    n/no) from THIS prompt's offered options (intent `yes`/`no`).
+      for (const rule of autoAnswer) {
+        if (rule.re && rule.re.test(chunk)) {
+          term.write(`${resolveAnswer(rule.send, chunk)}\r`);
+          return;
+        }
+      }
+
+      // 4) shell prompt → send the next queued command.
+      if (promptRe.test(chunk) && cmdIndex < commands.length) {
+        const next = commands[cmdIndex++];
+        term.write(`${next}\r`);
+        return;
+      }
+    });
+
+    term.onExit(({ exitCode }) => {
+      if (settled) return;
+      // Connection closed. Success only if explicitly allowed, or a done
+      // marker already landed (covered above). Otherwise treat as error.
+      if (spec.success_on_close && cmdIndex >= commands.length) {
+        return finish(false, `connection closed (exit ${exitCode})`);
+      }
+      const sawDone = doneRe ? doneRe.test(full) : false;
+      finish(!sawDone, sawDone ? 'done before close' : `connection closed unexpectedly (exit ${exitCode})`);
+    });
+  });
+}

package/lib/chat/tool-dispatcher.ts

@@ -12,6 +12,7 @@
 import { bridgeRpc } from './bridge-client';
 import { runHttp } from './protocols/http';
 import { runShell } from './protocols/shell';
+import { runSsh } from './protocols/ssh';
 import {
   getConnector,
   getInstalledConnector,
@@ -274,6 +275,30 @@ const BUILTINS: Record<string, BuiltinHandler> = {
     });
     return `Task dispatched: ${task.id} (project: ${project.name}, status: ${task.status}). Watch in the Tasks view.`;
   },
+
+  // List Forge's own help/documentation files so the chat agent can answer
+  // questions about Forge itself (features, config, troubleshooting) without
+  // the user opening the separate Help AI. Pair with read_help_doc.
+  list_help_docs: async () => {
+    const { listHelpDocs } = await import('../help-content');
+    const docs = listHelpDocs();
+    if (docs.length === 0) return 'No Forge help docs found.';
+    return 'Forge help docs (read one with read_help_doc):\n' + docs.map((d) => `- ${d}`).join('\n');
+  },
+
+  // Read one Forge help doc in full. Use to answer questions about Forge's
+  // own features / settings / troubleshooting.
+  read_help_doc: async (input) => {
+    const { doc } = (input as { doc?: string } | undefined) || {};
+    if (!doc) return 'read_help_doc failed: doc is required (a filename from list_help_docs, e.g. "05-pipelines.md").';
+    const { readHelpDoc } = await import('../help-content');
+    const content = readHelpDoc(doc);
+    if (content == null) return `Help doc "${doc}" not found. Call list_help_docs to see available filenames.`;
+    const MAX = 30000;
+    return content.length > MAX
+      ? content.slice(0, MAX) + `\n\n…[truncated — doc is ${content.length} chars]`
+      : content;
+  },
 };
 
 export interface BuiltinToolDef {
@@ -351,6 +376,25 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
       required: ['prompt'],
     },
   },
+  {
+    name: 'list_help_docs',
+    description: "List Forge's own documentation files. Call this FIRST whenever the user asks how Forge itself works — its features, settings/config, setup, or troubleshooting (e.g. pipelines, schedules, connectors, telegram, tunnel, workspace/smiths, skills, crafts, usage/cost, agents/models). Returns doc filenames; then read the relevant one(s) with read_help_doc and answer from their content. No arguments.",
+    input_schema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'read_help_doc',
+    description: 'Read one Forge help doc in full (filename from list_help_docs, e.g. "05-pipelines.md"). Use its content to answer the user\'s question about Forge. Read more than one doc if the question spans topics.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        doc: {
+          type: 'string',
+          description: 'Help doc filename, e.g. "05-pipelines.md" or "10-troubleshooting.md". Get exact names from list_help_docs.',
+        },
+      },
+      required: ['doc'],
+    },
+  },
 ];
 
 // ─── Connector dispatch ──────────────────────────────────
@@ -479,6 +523,18 @@ export async function dispatchTool(
   const protocol = located.tool.protocol || 'browser';
   const argInput = (call.input ?? {}) as Record<string, any>;
 
+  // Apply each parameter's `default` for keys the model omitted, so
+  // template tokens like {args.scp_host} resolve instead of staying
+  // literal. JSON-schema defaults are only advisory to the model — it
+  // routinely drops optional fields — so fill them here. Only sets
+  // missing/null; never overrides a value the model actually passed.
+  for (const [pname, pdef] of Object.entries(located.tool.parameters || {})) {
+    if (pdef && typeof pdef === 'object' && 'default' in (pdef as any)
+        && (argInput[pname] === undefined || argInput[pname] === null)) {
+      argInput[pname] = (pdef as any).default;
+    }
+  }
+
   // Multi-instance overlay: when a connector's settings carry a
   // `instances` array of `{name, ...}` objects, the tool's `instance`
   // arg picks one and its fields are merged into the top-level settings
@@ -516,6 +572,8 @@ export async function dispatchTool(
         return await runHttp({ tool: located.tool, settings: effectiveSettings, args: argInput, connectorAuth: def.auth, noTruncation: opts.noTruncation });
       case 'shell':
         return await runShell({ tool: located.tool, settings: effectiveSettings, args: argInput });
+      case 'ssh':
+        return await runSsh({ tool: located.tool, settings: effectiveSettings, args: argInput });
       case 'browser': {
         // Hand the whole connector + tool spec + input + settings to the
         // extension's runner.ts via the bridge. The extension keeps owning
@@ -527,7 +585,7 @@ export async function dispatchTool(
           input: argInput,
           connector,
           settings: effectiveSettings,
-        })) as { content?: string; is_error?: boolean } | null;
+        }, located.tool.timeout_ms)) as { content?: string; is_error?: boolean } | null;
         return { content: result?.content ?? '(no content returned)', is_error: !!result?.is_error };
       }
       default:

package/lib/connectors/types.ts

@@ -14,7 +14,56 @@
 export type ConnectorRunner = 'main' | 'isolated';
 
 /** Where a tool's execution lives. */
-export type ConnectorProtocol = 'browser' | 'http' | 'shell';
+export type ConnectorProtocol = 'browser' | 'http' | 'shell' | 'ssh';
+
+/** One expect rule for `protocol: ssh`: when output matches `match`
+ *  (a regex, tested per output chunk), send `send` + Enter. Used to
+ *  auto-answer interactive prompts like `(y/N)`.
+ *
+ *  `send` may be the INTENT `yes`/`no` — the runner then picks the token
+ *  the prompt actually offers (`(y/N)` → `y`/`n`, `(yes/no)` → `yes`/`no`)
+ *  and always sends it explicitly (never relies on the prompt's default).
+ *  Any other value is sent literally. */
+export interface SshExpectRule {
+  match: string;
+  send: string;
+}
+
+/**
+ * `protocol: ssh` spec — drives an interactive SSH session via a PTY
+ * (the system `ssh` binary). Built for devices whose CLI needs a
+ * password + interactive confirmations (e.g. FortiNAC firmware restore).
+ * All string fields are templated with {settings.*}/{args.*}.
+ */
+export interface SshSpec {
+  // Connection params are resolved by the runner with this precedence:
+  //   tool arg (host/port/username/password) > connector setting
+  //   (host/port/username/password) > the literal here > built-in default.
+  // So chat can pass them per-call and the connector holds defaults; the
+  // IP typically comes from chat only (no setting). All optional here.
+  host?: string;
+  /** Default 22. */
+  port?: string | number;
+  user?: string;
+  /** Password fed when a `password:` prompt appears (sent silently). */
+  password?: string;
+  /** Commands sent one-per-shell-prompt, in order (e.g. the upgrade cmd, then exit). */
+  commands?: string[];
+  /** Auto-answers applied throughout the session (e.g. `(y/N)` → `y`). */
+  auto_answer?: SshExpectRule[];
+  /** Shell-prompt regex that gates sending the next command. Default `[#$>]\s*$`. */
+  prompt_regex?: string;
+  /** Success marker regex — when seen, the session resolves ok and ssh is closed. */
+  done_when?: string;
+  /** Failure marker regex — when seen, resolves is_error. */
+  fail_when?: string;
+  /** name → regex(1 capture group) pulled from the full transcript into the result. */
+  capture?: Record<string, string>;
+  /** Overall timeout. Default 120s, max 280s. */
+  timeout_sec?: number;
+  /** Treat the remote closing the connection as success (e.g. after `exit`). */
+  success_on_close?: boolean;
+}
 
 /** Schema for one settings or parameter field. */
 export interface ConnectorFieldSchema {
@@ -170,7 +219,18 @@ export interface ConnectorTool {
   /** Extra env vars (values templated). */
   env?: Record<string, string>;
 
-  /** shell/http: timeout in milliseconds. Default 30000, max 300000. */
+  // ── protocol: 'ssh' ───────────────────────────────────────
+  /** Interactive SSH session spec (PTY-driven). See SshSpec. */
+  ssh?: SshSpec;
+
+  /**
+   * Timeout in milliseconds.
+   *  - shell/http: request timeout (default 30000, max 300000).
+   *  - browser: how long the bridge waits for the extension to return the
+   *    RPC result (default 60000, capped at 900000). Raise it for tools
+   *    whose script issues a long synchronous backend call (e.g. a NAC
+   *    upgrade that blocks for minutes).
+   */
   timeout_ms?: number;
 
   /**

package/lib/help-content.ts

@@ -0,0 +1,51 @@
+/**
+ * Help-doc reader for the chat agent's read_help_doc / list_help_docs tools.
+ *
+ * Reads the markdown docs that ship under lib/help-docs/ (same set the Help AI
+ * terminal uses). Resolved relative to this module so it works regardless of
+ * whether the on-disk sync (ensureHelpDocs → <config>/help) has run yet, then
+ * falls back to the synced copy if the source tree isn't present (installed
+ * tarball layouts).
+ */
+
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getConfigDir } from './dirs';
+
+// Candidate dirs, in priority order: source tree next to this module, then the
+// synced runtime copy under ~/.forge/help.
+function helpDirs(): string[] {
+  const dirs: string[] = [];
+  try {
+    const here = fileURLToPath(new URL('./help-docs', import.meta.url));
+    dirs.push(here);
+  } catch { /* import.meta.url unavailable (CJS bundle) — skip */ }
+  dirs.push(join(getConfigDir(), 'help'));
+  return dirs;
+}
+
+/** List available help-doc filenames (e.g. ["00-overview.md", ...]), sorted. */
+export function listHelpDocs(): string[] {
+  for (const dir of helpDirs()) {
+    try {
+      if (!existsSync(dir)) continue;
+      const files = readdirSync(dir).filter((f) => f.endsWith('.md')).sort();
+      if (files.length) return files;
+    } catch { /* try next dir */ }
+  }
+  return [];
+}
+
+/** Read one help doc by filename. Returns null if not found. Path-traversal safe. */
+export function readHelpDoc(name: string): string | null {
+  const base = (name || '').split(/[\\/]/).pop() || '';
+  if (!base.endsWith('.md')) return null;
+  for (const dir of helpDirs()) {
+    try {
+      const file = join(dir, base);
+      if (existsSync(file)) return readFileSync(file, 'utf-8');
+    } catch { /* try next dir */ }
+  }
+  return null;
+}

package/lib/help-docs/01-settings.md

@@ -46,7 +46,6 @@ Each agent entry in `settings.agents` supports:
 | `enabled` | boolean | Whether this agent is available |
 | `cliType` | string | CLI tool type: `claude-code`, `codex`, `aider`, `generic` |
 | `taskFlags` | string | Flags for headless task execution (e.g. `-p --verbose`) |
-| `interactiveCmd` | string | Command for interactive terminal sessions |
 | `resumeFlag` | string | Flag to resume sessions (e.g. `-c` for claude) |
 | `outputFormat` | string | Output format: `stream-json`, `text` |
 | `skipPermissionsFlag` | string | Flag to skip permissions (e.g. `--dangerously-skip-permissions`) |

package/lib/settings.ts

@@ -23,7 +23,7 @@ const SETTINGS_FILE = join(DATA_DIR, 'settings.yaml');
 export interface AgentEntry {
   tool?: 'claude' | 'codex' | 'aider' | 'opencode';   // which CLI binary
   path?: string; name?: string; enabled?: boolean;
-  flags?: string[]; taskFlags?: string; interactiveCmd?: string; resumeFlag?: string; outputFormat?: string;
+  flags?: string[]; taskFlags?: string; resumeFlag?: string; outputFormat?: string;
   models?: { terminal?: string; task?: string; telegram?: string; help?: string; mobile?: string };
   skipPermissionsFlag?: string;
   requiresTTY?: boolean;

package/lib/telegram-bot.ts

@@ -1086,7 +1086,7 @@ function getSessionPreview(sessionName: string, maxLines: number = 1): string {
   try {
     const { execSync } = require('node:child_process');
     // Capture last screen, strip ANSI escapes, find last non-empty lines
-    const out = execSync(`tmux capture-pane -t "${sessionName}" -p -S -50 2>/dev/null`, {
+    const out = execSync(`tmux capture-pane -t "${sessionName}" -p -S -100 2>/dev/null`, {
       encoding: 'utf-8',
       timeout: 2000,
     }) as string;
@@ -1101,8 +1101,8 @@ function getSessionPreview(sessionName: string, maxLines: number = 1): string {
       const last = tail[0];
       return last.length > 30 ? last.slice(0, 30) + '…' : last;
     }
-    // Multi-line: truncate each line to 80 chars
-    return tail.map(l => l.length > 80 ? l.slice(0, 80) + '…' : l).join('\n');
+    // Multi-line: truncate each line to 160 chars
+    return tail.map(l => l.length > 160 ? l.slice(0, 160) + '…' : l).join('\n');
   } catch {
     return '';
   }
@@ -1185,8 +1185,8 @@ async function pickInjectTarget(chatId: number, numStr: string) {
   scheduleInjectAutoClear(chatId);
   const labelMap = getSessionLabels();
   const display = labelMap[sessionName] || sessionName.replace(/^mw-?/, '');
-  // Show last 8 lines of context so user knows what's in the terminal
-  const context = getSessionPreview(sessionName, 8);
+  // Show last 16 lines of context so user knows what's in the terminal
+  const context = getSessionPreview(sessionName, 16);
   const contextBlock = context ? `\n\n📺 Last output:\n\`\`\`\n${context}\n\`\`\`` : '';
   await send(chatId,
     `🎯 Target: ${display}${contextBlock}\n\n` +

package/package.json

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