@aion0/forge 0.10.78 → 0.10.80

package/RELEASE_NOTES.md

@@ -1,14 +1,15 @@
-# Forge v0.10.78
+# Forge v0.10.80
 
-Released: 2026-06-13
+Released: 2026-06-14
 
-## Changes since v0.10.77
+## Changes since v0.10.79
 
 ### Other
-- 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
+- feat(chat): read_project_file + full task output + anti-fabrication guidance
+- feat(pipeline): per-run tmux/headless backend selection
+- feat(tasks): tmux backend — reliable completion detection + interactive session view
+- feat(tasks): show backend + agent badges in TaskDetail header
+- feat(tasks): tmux backend — interactive claude via Stop hook completion detection
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.77...v0.10.78
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.79...v0.10.80

package/app/api/code/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from 'next/server';
 import { readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { join, relative, extname } from 'node:path';
+import { join, relative, extname, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import { loadSettings } from '@/lib/settings';
@@ -10,6 +10,13 @@ interface FileNode {
   path: string;
   type: 'file' | 'dir';
   children?: FileNode[];
+  hasChildren?: boolean;
+}
+
+interface TreeListing {
+  tree: FileNode[];
+  truncated: boolean;
+  count: number;
 }
 
 const IGNORE = new Set([
@@ -17,27 +24,19 @@ const IGNORE = new Set([
   '.DS_Store', 'coverage', '__pycache__', '.cache', '.output', 'target',
 ]);
 
-const CODE_EXTS = new Set([
-  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-  '.py', '.go', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h',
-  '.css', '.scss', '.html', '.json', '.yaml', '.yml', '.toml',
-  '.md', '.txt', '.sh', '.bash', '.zsh', '.fish',
-  '.sql', '.graphql', '.proto', '.env', '.gitignore',
-  '.xml', '.csv', '.lock', '.properties', '.gradle', '.groovy',
-  '.scala', '.clj', '.cljs', '.jsp', '.erb', '.vue', '.svelte',
-]);
+const MAX_TREE_ENTRIES = 1000;
+const MAX_FILE_INDEX_ENTRIES = 10000;
+// Per-directory file cap for the search index, so one huge directory can't
+// consume the whole budget and starve files in sibling directories.
+const MAX_INDEX_FILES_PER_DIR = 1000;
 
-const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.ico', '.avif']);
-
-function isCodeFile(name: string): boolean {
-  if (name.startsWith('.') && !name.startsWith('.env') && !name.startsWith('.git')) return false;
-  const ext = extname(name);
-  if (!ext) return !name.includes('.'); // files like Makefile, Dockerfile
-  return CODE_EXTS.has(ext) || IMAGE_EXTS.has(ext);
+function isInside(parent: string, child: string): boolean {
+  const normalizedParent = resolve(parent);
+  const normalizedChild = resolve(child);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(normalizedParent + sep);
 }
 
-function scanDir(dir: string, base: string, depth: number = 0): FileNode[] {
-  if (depth > 10) return [];
+function scanDir(dir: string, base: string, maxEntries = MAX_TREE_ENTRIES): TreeListing {
   try {
     const entries = readdirSync(dir, { withFileTypes: true });
     const nodes: FileNode[] = [];
@@ -50,23 +49,92 @@ function scanDir(dir: string, base: string, depth: number = 0): FileNode[] {
         return a.name.localeCompare(b.name);
       });
 
-    for (const entry of sorted) {
+    for (const entry of sorted.slice(0, maxEntries)) {
       const fullPath = join(dir, entry.name);
       const relPath = relative(base, fullPath);
 
       if (entry.isDirectory()) {
-        const children = scanDir(fullPath, base, depth + 1);
-        nodes.push({ name: entry.name, path: relPath, type: 'dir', children });
+        nodes.push({ name: entry.name, path: relPath, type: 'dir', hasChildren: true });
       } else {
         nodes.push({ name: entry.name, path: relPath, type: 'file' });
       }
     }
-    return nodes;
+    return { tree: nodes, truncated: sorted.length > maxEntries, count: sorted.length };
   } catch {
-    return [];
+    return { tree: [], truncated: false, count: 0 };
   }
 }
 
+interface PathIndex {
+  files: FileNode[];
+  dirs: FileNode[];
+  truncated: boolean;
+}
+
+// Flat index of the whole tree, computed once server-side so clients can search
+// without ever holding the recursive structure.
+//
+// Breadth-first with a per-directory file cap: BFS so shallow source dirs are
+// indexed before deep generated/vendor noise, and the per-dir cap so a single
+// huge directory (e.g. a 150k-file build output) can't consume the whole budget
+// and starve real files. `truncated` is set when either cap drops entries, so
+// the client can tell the user search is partial.
+function scanIndex(root: string, base: string, maxEntries = MAX_FILE_INDEX_ENTRIES, perDir = MAX_INDEX_FILES_PER_DIR): PathIndex {
+  const files: FileNode[] = [];
+  const dirs: FileNode[] = [];
+  let truncated = false;
+  const queue: string[] = [root];
+
+  while (queue.length > 0 && !(files.length >= maxEntries && dirs.length >= maxEntries)) {
+    const dir = queue.shift()!;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+        .filter(e => !IGNORE.has(e.name))
+        .sort((a, b) => {
+          if (a.isDirectory() && !b.isDirectory()) return -1;
+          if (!a.isDirectory() && b.isDirectory()) return 1;
+          return a.name.localeCompare(b.name);
+        });
+    } catch { continue; }
+
+    let dirFiles = 0;
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (dirs.length < maxEntries) dirs.push({ name: entry.name, path: relative(base, fullPath), type: 'dir' });
+        else truncated = true;
+        queue.push(fullPath);
+      } else if (files.length >= maxEntries) {
+        truncated = true;
+      } else if (dirFiles >= perDir) {
+        truncated = true; // this directory has more files than we index per dir
+      } else {
+        files.push({ name: entry.name, path: relative(base, fullPath), type: 'file' });
+        dirFiles++;
+      }
+    }
+  }
+
+  return { files, dirs, truncated };
+}
+
+// Return one directory level, but recurse into the directories named in
+// `expandSet` (the ancestor chain of a target file). Lets the client reveal a
+// deep file in one request. Bounded: at most one directory per level is
+// expanded, each level capped at maxEntries.
+function scanDirExpand(dir: string, base: string, expandSet: Set<string>, maxEntries = MAX_TREE_ENTRIES): FileNode[] {
+  const { tree } = scanDir(dir, base, maxEntries);
+  for (const node of tree) {
+    if (node.type === 'dir' && expandSet.has(node.path)) {
+      const children = scanDirExpand(join(dir, node.name), base, expandSet, maxEntries);
+      node.children = children;
+      node.hasChildren = children.length > 0;
+    }
+  }
+  return tree;
+}
+
 // GET /api/code?dir=<absolute-path>&file=<relative-path>
 //   dir mode: returns file tree for the given directory
 //   file mode: returns file content
@@ -74,17 +142,18 @@ export async function GET(req: Request) {
   const { searchParams } = new URL(req.url);
   const dir = searchParams.get('dir');
   const filePath = searchParams.get('file');
+  const treePath = searchParams.get('treePath') || '';
 
   if (!dir) {
     return NextResponse.json({ tree: [], dirName: '' });
   }
 
-  const resolvedDir = dir.replace(/^~/, homedir());
+  const resolvedDir = resolve(dir.replace(/^~/, homedir()));
 
   // Security: dir must be under a projectRoot
   const settings = loadSettings();
-  const projectRoots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
-  const allowed = projectRoots.some(root => resolvedDir.startsWith(root) || resolvedDir === root);
+  const projectRoots = (settings.projectRoots || []).map(r => resolve(r.replace(/^~/, homedir())));
+  const allowed = projectRoots.some(root => isInside(root, resolvedDir));
   if (!allowed) {
     return NextResponse.json({ error: 'Directory not under any project root' }, { status: 403 });
   }
@@ -120,8 +189,8 @@ export async function GET(req: Request) {
   // Git diff for a specific file
   const diffFile = searchParams.get('diff');
   if (diffFile) {
-    const fullPath = join(resolvedDir, diffFile);
-    if (!fullPath.startsWith(resolvedDir)) {
+    const fullPath = resolve(resolvedDir, diffFile);
+    if (!isInside(resolvedDir, fullPath)) {
       return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
     }
     try {
@@ -146,8 +215,8 @@ export async function GET(req: Request) {
 
   // Read file content
   if (filePath) {
-    const fullPath = join(resolvedDir, filePath);
-    if (!fullPath.startsWith(resolvedDir)) {
+    const fullPath = resolve(resolvedDir, filePath);
+    if (!isInside(resolvedDir, fullPath)) {
       return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
     }
     try {
@@ -201,9 +270,40 @@ export async function GET(req: Request) {
     }
   }
 
-  // Return file tree
-  const tree = scanDir(resolvedDir, resolvedDir);
+  // Expand-to-path: return the tree pre-expanded along a target's ancestor
+  // chain so the client can reveal a deep file in a single request. The walk is
+  // bounded by path depth × MAX_TREE_ENTRIES, so it never materializes the
+  // whole tree.
+  const expandTo = searchParams.get('expandTo');
+  if (expandTo) {
+    const target = resolve(resolvedDir, expandTo);
+    if (!isInside(resolvedDir, target)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+    }
+    const expandSet = new Set<string>();
+    let rel = relative(resolvedDir, target);
+    if (rel && rel !== '.') expandSet.add(rel); // expand the target itself if it is a dir
+    while (rel && rel !== '.') {
+      rel = rel.split(sep).slice(0, -1).join(sep); // parent
+      if (rel) expandSet.add(rel);
+    }
+    return NextResponse.json({ tree: scanDirExpand(resolvedDir, resolvedDir, expandSet), expandTo });
+  }
+
+  // Return one directory level. Children are loaded on demand with treePath.
+  const listingDir = resolve(resolvedDir, treePath);
+  if (!isInside(resolvedDir, listingDir)) {
+    return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
+  }
+  const { tree, truncated, count } = scanDir(listingDir, resolvedDir);
   const dirName = resolvedDir.split('/').pop() || resolvedDir;
+  const includeGit = treePath === '';
+  // One traversal builds both the file index (search) and the directory index
+  // (watch-path picker), so the client never walks the tree itself.
+  const index = includeGit ? scanIndex(resolvedDir, resolvedDir) : undefined;
+  const fileIndex = index?.files;
+  const dirIndex = index?.dirs;
+  const indexTruncated = index?.truncated ?? false;
 
   // Git status: scan for git repos (could be root dir or subdirectories)
   interface GitRepo {
@@ -237,29 +337,46 @@ export async function GET(req: Request) {
     } catch {}
   }
 
-  // Check if root is a git repo
-  try {
-    execSync('git rev-parse --git-dir', { cwd: resolvedDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] });
-    scanGitStatus(resolvedDir, '.', '');
-  } catch {
-    // Root is not a git repo — scan subdirectories
+  if (includeGit) {
+    // Check if root is a git repo
     try {
-      for (const entry of readdirSync(resolvedDir, { withFileTypes: true })) {
-        if (!entry.isDirectory() || entry.name.startsWith('.') || IGNORE.has(entry.name)) continue;
-        const subDir = join(resolvedDir, entry.name);
-        try {
-          execSync('git rev-parse --git-dir', { cwd: subDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] });
-          scanGitStatus(subDir, entry.name, entry.name);
-        } catch {}
-      }
-    } catch {}
+      execSync('git rev-parse --git-dir', { cwd: resolvedDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] });
+      scanGitStatus(resolvedDir, '.', '');
+    } catch {
+      // Root is not a git repo — scan subdirectories
+      try {
+        for (const entry of readdirSync(resolvedDir, { withFileTypes: true })) {
+          if (!entry.isDirectory() || entry.name.startsWith('.') || IGNORE.has(entry.name)) continue;
+          const subDir = join(resolvedDir, entry.name);
+          try {
+            execSync('git rev-parse --git-dir', { cwd: subDir, encoding: 'utf-8', timeout: 2000, stdio: ['pipe', 'pipe', 'pipe'] });
+            scanGitStatus(subDir, entry.name, entry.name);
+          } catch {}
+        }
+      } catch {}
+    }
   }
 
   // Flatten for backward compat
   const gitChanges = gitRepos.flatMap(r => r.changes);
   const gitBranch = gitRepos.length === 1 ? gitRepos[0].branch : '';
 
-  return NextResponse.json({ tree, dirName, dirPath: resolvedDir, gitBranch, gitChanges, gitRepos });
+  return NextResponse.json({
+    tree,
+    dirName,
+    dirPath: resolvedDir,
+    treePath,
+    truncated,
+    count,
+    limit: MAX_TREE_ENTRIES,
+    fileIndex,
+    dirIndex,
+    indexTruncated,
+    fileIndexLimit: MAX_FILE_INDEX_ENTRIES,
+    gitBranch,
+    gitChanges,
+    gitRepos,
+  });
 }
 
 // PUT /api/code — save file content
@@ -274,18 +391,18 @@ export async function PUT(req: Request) {
     return NextResponse.json({ error: 'Invalid request' }, { status: 400 });
   }
 
-  const resolvedDir = dir.replace(/^~/, homedir());
-  const fullPath = join(resolvedDir, file);
+  const resolvedDir = resolve(dir.replace(/^~/, homedir()));
+  const fullPath = resolve(resolvedDir, file);
 
   // Security: ensure path is within the directory
-  if (!fullPath.startsWith(resolvedDir)) {
+  if (!isInside(resolvedDir, fullPath)) {
     return NextResponse.json({ error: 'Invalid path' }, { status: 400 });
   }
 
   // Verify dir is under a configured project root
   const settings = loadSettings();
-  const roots = (settings.projectRoots || []).map(r => r.replace(/^~/, homedir()));
-  const allowed = roots.some(r => resolvedDir.startsWith(r));
+  const roots = (settings.projectRoots || []).map(r => resolve(r.replace(/^~/, homedir())));
+  const allowed = roots.some(r => isInside(r, resolvedDir));
   if (!allowed) {
     return NextResponse.json({ error: 'Directory not in project roots' }, { status: 403 });
   }

package/app/api/onboarding/route.ts

@@ -34,6 +34,8 @@ import { installFromMarketplace, listMarketplace } from '@/lib/workflow-marketpl
 import { installFromRegistry } from '@/lib/connectors/sync';
 import { resolveWizardTemplate } from '@/lib/connectors/wizard-template';
 import { decryptDeep } from '@/lib/enterprise-secret';
+import { encryptSecret } from '@/lib/crypto';
+import { existsSync, readFileSync } from 'fs';
 import { provisionTemperUser } from '@/lib/memory/temper-provision';
 import type { AgentEntry, ApiProfile } from '@/lib/settings';
 import bundledTemplate from '@/templates/connector-config-template.json';
@@ -59,6 +61,10 @@ interface OnboardingPayload {
     tool: 'claude' | 'codex' | 'aider' | 'opencode';
     path?: string;
     setAsDefault?: boolean;
+    /** Extra env merged into the agent (e.g. CLAUDE_CODE_OAUTH_TOKEN for
+     *  container deployments where `claude login` can't reach the keychain).
+     *  Values are encrypted at rest (enc:…). */
+    env?: Record<string, string>;
   };
   connectorValues?: Record<string, string>;     // template ${key} → value
   /** Subset of template connector ids to install. Missing/empty = install
@@ -294,18 +300,43 @@ function applyApiProfile(p: OnboardingPayload['apiProfile']): string | null {
   return null;
 }
 
+/** Best-effort deployment-shape detection. Container deploys can't run
+ *  `claude login` (no libsecret/keychain) so the wizard guides a pasted
+ *  CLAUDE_CODE_OAUTH_TOKEN instead. Signals (any → container): explicit
+ *  FORGE_CONTAINER env, Docker's /.dockerenv, or a containerized cgroup. */
+function detectDeployment(): 'container' | 'host' {
+  if (process.env.FORGE_CONTAINER === '1') return 'container';
+  try { if (existsSync('/.dockerenv')) return 'container'; } catch {}
+  try {
+    const cg = readFileSync('/proc/1/cgroup', 'utf-8');
+    if (/docker|containerd|kubepods|lxc/i.test(cg)) return 'container';
+  } catch {}
+  return 'host';
+}
+
 function applyCliAgent(a: OnboardingPayload['cliAgent']): string | null {
   if (!a) return null;
   if (!a.id || !a.tool) return 'cli agent id and tool required';
   const settings = loadSettings();
   settings.agents = settings.agents || {};
   const existing = settings.agents[a.id] || {};
+  // Merge extra env (e.g. CLAUDE_CODE_OAUTH_TOKEN), encrypting each value at
+  // rest. resolveTerminalLaunch decrypts on the way out. Skip blank values so
+  // re-running the wizard without re-pasting keeps the existing token.
+  let mergedEnv = (existing as any).env as Record<string, string> | undefined;
+  if (a.env && Object.keys(a.env).length) {
+    mergedEnv = { ...(mergedEnv || {}) };
+    for (const [k, v] of Object.entries(a.env)) {
+      if (typeof v === 'string' && v.trim()) mergedEnv[k] = encryptSecret(v.trim());
+    }
+  }
   settings.agents[a.id] = {
     ...existing,
     tool: a.tool,
     name: existing.name || a.id,
     enabled: true,
     ...(a.path ? { path: a.path } : {}),
+    ...(mergedEnv ? { env: mergedEnv } : {}),
   };
   if (a.setAsDefault) settings.defaultAgent = a.id;
   // Terminal launch (lib/claude-process.ts) reads settings.claudePath,
@@ -1244,6 +1275,7 @@ export async function GET(req: Request) {
       projectRoots: settings.projectRoots || [],
     },
     detected_cli: detected,
+    deployment: detectDeployment(),
     template_connectors: templateConnectors,
     template_prompts: template._prompts || {},
     template_agents_preview: agentsPreview.length ? agentsPreview : undefined,

package/app/api/skills/local/route.ts

@@ -13,8 +13,7 @@ function md5(content: string): string {
 }
 
 /** Recursively list files in a directory */
-function listFiles(dir: string, prefix = ''): { path: string; size: number }[] {
-  const files: { path: string; size: number }[] = [];
+function listFiles(dir: string, prefix = '', files: { path: string; size: number }[] = []): { path: string; size: number }[] {
   if (!existsSync(dir)) return files;
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -22,7 +21,7 @@ function listFiles(dir: string, prefix = ''): { path: string; size: number }[] {
     if (entry.isFile()) {
       files.push({ path: relPath, size: statSync(fullPath).size });
     } else if (entry.isDirectory()) {
-      files.push(...listFiles(fullPath, relPath));
+      listFiles(fullPath, relPath, files);
     }
   }
   return files;
@@ -148,7 +147,9 @@ export async function GET(req: Request) {
       }
       // Directory contents
       if (existsSync(dirPath) && statSync(dirPath).isDirectory()) {
-        files.push(...listFiles(dirPath).map(f => ({ path: `${name}/${f.path}`, size: f.size })));
+        for (const file of listFiles(dirPath)) {
+          files.push({ path: `${name}/${file.path}`, size: file.size });
+        }
       }
       return NextResponse.json({ files });
     }

package/app/api/tasks/[id]/hook/stop/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from 'next/server';
+import { fireTmuxHook, completeStaleTmuxTask } from '@/lib/task-tmux-backend';
+
+// Called by the Claude Code Stop hook when a tmux-backend task turn completes.
+// The hook script (installed in ~/.claude/settings.json) reads task-context.json
+// from the project dir and POSTs here. We resolve the awaited promise in executeTmuxTask.
+// If no waiter exists (server restart mid-task), fall back to directly completing the task.
+export async function POST(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const handled = fireTmuxHook(id);
+  if (!handled) {
+    completeStaleTmuxTask(id);
+  }
+  return NextResponse.json({ ok: true });
+}

package/app/api/tasks/route.ts

@@ -14,7 +14,7 @@ export async function GET(req: Request) {
 
 // Create a new task
 export async function POST(req: Request) {
-  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig, agent } = await req.json();
+  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig, agent, backend } = await req.json();
 
   if (!projectName || !prompt) {
     return NextResponse.json({ error: 'projectName and prompt are required' }, { status: 400 });
@@ -38,6 +38,7 @@ export async function POST(req: Request) {
     mode: mode || 'prompt',
     watchConfig: watchConfig || undefined,
     agent: agent || undefined,
+    backend: backend === 'tmux' ? 'tmux' : undefined,
   });
 
   return NextResponse.json(task);

package/cli/mw.mjs

@@ -1352,7 +1352,7 @@ var init_clean = __esm({
 
 // cli/mw.ts
 var _cliPort = process.argv.find((a, i) => i > 0 && process.argv[i - 1] === "--port");
-var BASE2 = process.env.MW_URL || `http://localhost:${_cliPort || "3000"}`;
+var BASE2 = process.env.MW_URL || `http://localhost:${_cliPort || "8403"}`;
 var [, , cmd, ...args] = process.argv;
 async function checkForUpdate() {
   try {
@@ -1463,19 +1463,21 @@ async function main() {
     case "task":
     case "t": {
       const newSession = args.includes("--new");
-      const filtered = args.filter((a) => a !== "--new");
+      const useTmux = args.includes("--tmux");
+      const filtered = args.filter((a) => a !== "--new" && a !== "--tmux");
       const project = filtered[0];
       const prompt = filtered.slice(1).join(" ");
       if (!project || !prompt) {
-        console.log("Usage: mw task <project> <prompt> [--new]");
-        console.log("  --new    Start a fresh session (ignore previous context)");
+        console.log("Usage: mw task <project> <prompt> [--new] [--tmux]");
+        console.log("  --new     Start a fresh session (ignore previous context)");
+        console.log("  --tmux    Run via tmux backend (interactive mode, subscription billing)");
         console.log('Example: mw task my-app "Fix the login bug"');
         process.exit(1);
       }
       const task = await api3("/api/tasks", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ projectName: project, prompt, newSession })
+        body: JSON.stringify({ projectName: project, prompt, newSession, ...useTmux ? { backend: "tmux" } : {} })
       });
       const session = task.conversationId ? "(continuing session)" : "(new session)";
       console.log(`\u2713 Task ${task.id} created ${session}`);

package/cli/mw.ts

@@ -16,7 +16,7 @@
  */
 
 const _cliPort = process.argv.find((a, i) => i > 0 && process.argv[i - 1] === '--port');
-const BASE = process.env.MW_URL || `http://localhost:${_cliPort || '3000'}`;
+const BASE = process.env.MW_URL || `http://localhost:${_cliPort || '8403'}`;
 
 const [, , cmd, ...args] = process.argv;
 
@@ -149,21 +149,23 @@ async function main() {
 
     case 'task':
     case 't': {
-      // Parse --new flag to force a fresh session
+      // Parse --new and --tmux flags
       const newSession = args.includes('--new');
-      const filtered = args.filter(a => a !== '--new');
+      const useTmux = args.includes('--tmux');
+      const filtered = args.filter(a => a !== '--new' && a !== '--tmux');
       const project = filtered[0];
       const prompt = filtered.slice(1).join(' ');
       if (!project || !prompt) {
-        console.log('Usage: mw task <project> <prompt> [--new]');
-        console.log('  --new    Start a fresh session (ignore previous context)');
+        console.log('Usage: mw task <project> <prompt> [--new] [--tmux]');
+        console.log('  --new     Start a fresh session (ignore previous context)');
+        console.log('  --tmux    Run via tmux backend (interactive mode, subscription billing)');
         console.log('Example: mw task my-app "Fix the login bug"');
         process.exit(1);
       }
       const task = await api('/api/tasks', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ projectName: project, prompt, newSession }),
+        body: JSON.stringify({ projectName: project, prompt, newSession, ...(useTmux ? { backend: 'tmux' } : {}) }),
       });
       const session = task.conversationId ? '(continuing session)' : '(new session)';
       console.log(`✓ Task ${task.id} created ${session}`);