actoviq-agent-sdk 0.4.0 → 0.4.1

package/dist/src/tui/actoviqTui.js

@@ -6,12 +6,14 @@
  * rendering (no React/Ink).
  */
 import { execSync } from 'node:child_process';
+import fs from 'node:fs';
 import path from 'node:path';
 import * as readline from 'node:readline';
-import { createActoviqCoreTools, createAgentSdk, loadDefaultActoviqSettings, loadJsonConfigFile, } from '../index.js';
+import { createActoviqCoreTools, createAgentSdk, loadDefaultActoviqSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, createModelTeam, createTeamTool, WorktreeService, } from '../index.js';
 import { persistActoviqSettingsStore, resolveActoviqSettingsStore, } from '../config/actoviqSettingsStore.js';
 import { isRecord } from '../runtime/helpers.js';
-import { A, stringWidth, truncateToWidth } from './ansi.js';
+import { pathToFileURL } from 'node:url';
+import { A, stringWidth, truncateToWidth, wrapToWidth } from './ansi.js';
 import { InputEditor } from './editor.js';
 import { discoverActoviqPlugins } from './pluginCatalog.js';
 import { TuiScreen } from './screen.js';
@@ -49,6 +51,9 @@ export const TUI_SLASH_COMMANDS = {
     mcp: 'Inspect MCP servers and tools',
     plugins: 'Browse discovered Clean plugins',
     dream: 'Inspect or run memory consolidation',
+    workflows: 'Browse saved dynamic workflows',
+    worktree: 'Enter, exit, or list git worktrees',
+    team: 'List or run Model Team definitions',
     exit: 'Quit',
 };
 export function filterSlashCommands(input) {
@@ -60,6 +65,56 @@ export function filterSlashCommands(input) {
     const partial = head.toLowerCase();
     return Object.keys(TUI_SLASH_COMMANDS).filter((name) => name.startsWith(partial));
 }
+/**
+ * Detect an active "@file" mention at the cursor for path completion. Returns
+ * the partial token typed after the '@' plus the '@' offset, or null when the
+ * cursor is not inside a mention. The '@' only opens a mention at the start of
+ * input or after whitespace, and the token ends at the first whitespace.
+ */
+export function activeAtToken(text, cursor) {
+    for (let i = cursor - 1; i >= 0; i -= 1) {
+        const ch = text[i];
+        if (/\s/.test(ch))
+            return null;
+        if (ch === '@') {
+            if (i === 0 || /\s/.test(text[i - 1])) {
+                return { token: text.slice(i + 1, cursor), start: i };
+            }
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Render free-form text for the scrollback: width-aware word wrapping with
+ * markdown-lite heading highlighting. Used for workflow/team results and the
+ * expert-panel member reports so long output reads cleanly instead of dumping
+ * raw lines. Optionally caps very long output with a "… (N more lines)" note.
+ */
+function renderRichText(text, width, opts = {}) {
+    const cols = Math.max(20, width - 2);
+    const out = [];
+    for (const raw of text.replace(/\r/g, '').split('\n')) {
+        const heading = /^(#{1,6})\s+(.*)$/.exec(raw);
+        if (heading) {
+            out.push(`${A.bold}${A.cyan}${heading[2]}${A.reset}`);
+            continue;
+        }
+        if (raw.trim() === '') {
+            out.push('');
+            continue;
+        }
+        for (const line of wrapToWidth(raw, cols))
+            out.push(line);
+    }
+    const maxLines = opts.maxLines ?? 0;
+    if (maxLines > 0 && out.length > maxLines) {
+        const kept = out.slice(0, maxLines);
+        kept.push(`${A.dim}… (${out.length - maxLines} more lines)${A.reset}`);
+        return kept;
+    }
+    return out;
+}
 function buildSystemPrompt(workDir) {
     let isGit = false;
     try {
@@ -133,11 +188,17 @@ export async function runActoviqTui(options = {}) {
     let running = false;
     let commandBusy = false;
     let shuttingDown = false;
+    // Active team tool the main agent may call (toggled via /team). null = no team.
+    let activeTeamTool = null;
+    let activeTeamName = null;
     let abortCtrl = null;
     let dialog = null;
     let selectionDialog = null;
     let textInputDialog = null;
     let menuSelected = 0;
+    // @-mention file completion: highlighted candidate + lazily-cached file list.
+    let atSelected = 0;
+    let workspaceFiles = null;
     let spinnerFrame = 0;
     let spinnerTimer = null;
     let dynamicRenderTimer = null;
@@ -302,8 +363,9 @@ export async function runActoviqTui(options = {}) {
         const lines = [];
         lines.push(promptDivider());
         if (editor.isEmpty()) {
-            const placeholder = truncateToWidth('Try "write a test for <filepath>"', editorWidth - 2);
-            lines.push(`${A.magenta}${PROMPT_GLYPH}${A.reset} ${A.dim}${placeholder}${A.reset}`);
+            // Always-visible block caret on the empty input so the box reads as active.
+            const placeholder = truncateToWidth('Try "write a test for <filepath>"', editorWidth - 4);
+            lines.push(`${A.magenta}${PROMPT_GLYPH}${A.reset} ${A.inverse} ${A.reset} ${A.dim}${placeholder}${A.reset}`);
         }
         else {
             const visual = editor.visualLines(editorWidth - 1);
@@ -316,21 +378,152 @@ export async function runActoviqTui(options = {}) {
         lines.push(promptDivider());
         return lines;
     }
+    // ── @-mention file completion ──────────────────────────────────────
+    // Prefer git's view (tracked + untracked, honoring .gitignore) so the list
+    // matches what the agent actually sees; fall back to a bounded fs walk for
+    // non-git workspaces. Cached for the session and invalidated after each run.
+    function loadWorkspaceFiles() {
+        if (workspaceFiles)
+            return workspaceFiles;
+        try {
+            const out = execSync('git ls-files --cached --others --exclude-standard', {
+                cwd: workDir,
+                encoding: 'utf8',
+                maxBuffer: 32 * 1024 * 1024,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            workspaceFiles = out.split('\n').map((line) => line.trim()).filter(Boolean).slice(0, 8000);
+        }
+        catch {
+            workspaceFiles = walkWorkspaceFiles(workDir, 8000);
+        }
+        return workspaceFiles;
+    }
+    function walkWorkspaceFiles(root, limit) {
+        const skip = new Set(['node_modules', '.git', 'dist', '.codegraph', '.next', 'coverage']);
+        const out = [];
+        const stack = [root];
+        while (stack.length > 0 && out.length < limit) {
+            const dir = stack.pop();
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    if (!skip.has(entry.name) && !entry.name.startsWith('.'))
+                        stack.push(path.join(dir, entry.name));
+                }
+                else if (entry.isFile()) {
+                    out.push(path.relative(root, path.join(dir, entry.name)).split(path.sep).join('/'));
+                    if (out.length >= limit)
+                        break;
+                }
+            }
+        }
+        return out;
+    }
+    function atCompletions(token) {
+        const files = loadWorkspaceFiles();
+        const query = token.toLowerCase();
+        if (!query)
+            return files.slice(0, 200);
+        const matches = files.filter((file) => file.toLowerCase().includes(query));
+        matches.sort((a, b) => {
+            const aBase = a.slice(a.lastIndexOf('/') + 1).toLowerCase();
+            const bBase = b.slice(b.lastIndexOf('/') + 1).toLowerCase();
+            const aScore = aBase.startsWith(query) ? 0 : aBase.includes(query) ? 1 : 2;
+            const bScore = bBase.startsWith(query) ? 0 : bBase.includes(query) ? 1 : 2;
+            if (aScore !== bScore)
+                return aScore - bScore;
+            return a.length - b.length;
+        });
+        return matches.slice(0, 200);
+    }
+    function buildAtMenu() {
+        const active = activeAtToken(editor.text, editor.cursor);
+        if (!active)
+            return [];
+        const matches = atCompletions(active.token);
+        if (matches.length === 0) {
+            return [`${A.dim}  @${active.token} — no matching files${A.reset}`];
+        }
+        if (atSelected >= matches.length)
+            atSelected = matches.length - 1;
+        if (atSelected < 0)
+            atSelected = 0;
+        const windowStart = Math.max(0, Math.min(atSelected - MENU_MAX_ROWS + 1, matches.length - MENU_MAX_ROWS));
+        const visible = matches.slice(windowStart, windowStart + MENU_MAX_ROWS);
+        const lines = visible.map((file, i) => {
+            const index = windowStart + i;
+            const display = truncateToWidth(file, Math.max(screen.width - 6, 12));
+            return index === atSelected ? `${A.inverse} @${display} ${A.reset}` : `  ${A.cyan}@${display}${A.reset}`;
+        });
+        const hiddenAbove = windowStart;
+        const hiddenBelow = matches.length - (windowStart + visible.length);
+        if (hiddenAbove > 0 || hiddenBelow > 0) {
+            const parts = [];
+            if (hiddenAbove > 0)
+                parts.push(`↑${hiddenAbove}`);
+            if (hiddenBelow > 0)
+                parts.push(`↓${hiddenBelow}`);
+            lines.push(`${A.dim}  ${parts.join('  ')} more · ${atSelected + 1}/${matches.length} (↑/↓ · Tab/Enter to insert)${A.reset}`);
+        }
+        return lines;
+    }
+    /** Replace the active @-token with the highlighted file path. */
+    function applyAtCompletion() {
+        const active = activeAtToken(editor.text, editor.cursor);
+        if (!active)
+            return false;
+        const matches = atCompletions(active.token);
+        if (matches.length === 0)
+            return false;
+        const file = matches[Math.min(atSelected, matches.length - 1)];
+        const before = editor.text.slice(0, active.start);
+        const after = editor.text.slice(editor.cursor);
+        const mention = `@${file} `;
+        editor.setTextWithCursor(`${before}${mention}${after}`, before.length + mention.length);
+        atSelected = 0;
+        return true;
+    }
     function buildMenu() {
         const matches = filterSlashCommands(editor.text);
         if (matches.length === 0)
             return [];
         if (menuSelected >= matches.length)
             menuSelected = matches.length - 1;
+        if (menuSelected < 0)
+            menuSelected = 0;
         const commandWidth = Math.min(28, Math.max(14, Math.floor(screen.width * 0.28)));
         const descriptionWidth = Math.max(screen.width - commandWidth - 4, 12);
-        return matches.slice(0, MENU_MAX_ROWS).map((name, index) => {
+        // Scroll a window of MENU_MAX_ROWS so the highlighted item stays visible and
+        // commands past the cap (e.g. /workflows, /worktree, /team) are reachable
+        // with the arrow keys instead of being clipped off the bottom.
+        const windowStart = Math.max(0, Math.min(menuSelected - MENU_MAX_ROWS + 1, matches.length - MENU_MAX_ROWS));
+        const visible = matches.slice(windowStart, windowStart + MENU_MAX_ROWS);
+        const lines = visible.map((name, i) => {
+            const index = windowStart + i;
             const selected = index === menuSelected;
             const command = `/${name}`.padEnd(commandWidth);
             const label = selected ? `${A.inverse}${command}${A.reset}` : command;
             const description = truncateToWidth(TUI_SLASH_COMMANDS[name] ?? '', descriptionWidth);
             return `${label} ${A.dim}${description}${A.reset}`;
         });
+        const hiddenAbove = windowStart;
+        const hiddenBelow = matches.length - (windowStart + visible.length);
+        if (hiddenAbove > 0 || hiddenBelow > 0) {
+            const parts = [];
+            if (hiddenAbove > 0)
+                parts.push(`↑${hiddenAbove}`);
+            if (hiddenBelow > 0)
+                parts.push(`↓${hiddenBelow}`);
+            lines.push(`${A.dim}  ${parts.join('  ')} more · ${menuSelected + 1}/${matches.length} (↑/↓ to scroll)${A.reset}`);
+        }
+        return lines;
     }
     function buildDialog() {
         if (!dialog)
@@ -405,25 +598,45 @@ export async function runActoviqTui(options = {}) {
         lines.push(`${A.dim}  enter confirm · esc cancel${textInputDialog.secret ? ' · value hidden' : ''}${A.reset}`);
         return lines;
     }
+    /** Friendly permission label matching the /permissions presets. */
+    function permissionLabel() {
+        const m = currentPermissionMode();
+        if (m === 'bypassPermissions')
+            return 'full-access';
+        if (m === 'acceptEdits')
+            return 'workspace';
+        if (m === 'default' && session.permissionContext.permissions.some((p) => p.behavior === 'deny'))
+            return 'read-only';
+        return m;
+    }
+    /** Always-visible mode + live context-usage line (usage shown as % of the window). */
+    function buildModeLine() {
+        const used = lastTokenEstimate ?? 0;
+        const window = sdk.config.compact?.contextWindowTokens ?? 200_000;
+        const pct = window > 0 ? Math.min(100, Math.round((used / window) * 100)) : 0;
+        const usedK = used >= 1000 ? `${(used / 1000).toFixed(used >= 100_000 ? 0 : 1)}k` : `${used}`;
+        const ctxColor = pct >= 90 ? A.red : pct >= 70 ? A.yellow : A.dim;
+        const left = `${session.model} · ${permissionLabel()} · effort:${currentEffort() ?? 'auto'} · team:${activeTeamName ?? 'none'} · `;
+        return `${A.dim}  ${left}${A.reset}${ctxColor}ctx ${pct}% (${usedK})${A.reset}`;
+    }
     function buildStatusLine() {
+        const modeLine = buildModeLine();
         if (!running)
-            return [];
+            return [modeLine];
         const elapsed = Math.max(Math.round((Date.now() - runStartedAt) / 1000), 0);
         const frame = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
-        const context = lastTokenEstimate && lastTokenEstimate >= 1000
-            ? ` · ~${Math.round(lastTokenEstimate / 1000)}k ctx`
-            : '';
         const note = statusNote ? ` · ${statusNote}` : '';
         const queued = queuedInputs.length > 0 ? ` · ${queuedInputs.length} queued` : '';
         return [
-            `${A.cyan}${frame}${A.reset} ${A.bold}Working…${A.reset}${A.dim} (${elapsed}s · ${runToolCount} tool${runToolCount === 1 ? '' : 's'}${context}${note}${queued} · esc to interrupt)${A.reset}`,
+            `${A.cyan}${frame}${A.reset} ${A.bold}Working…${A.reset}${A.dim} (${elapsed}s · ${runToolCount} tool${runToolCount === 1 ? '' : 's'}${note}${queued} · esc to interrupt)${A.reset}`,
+            modeLine,
         ];
     }
     function buildHintLine() {
         if (running) {
             return [`${A.dim}  enter to queue a steering message · esc interrupt · ctrl+c twice to exit${A.reset}`];
         }
-        return [`${A.dim}  ? for shortcuts · / for commands · \\↵ newline · ↑↓ history · ctrl+c clear/exit${A.reset}`];
+        return [`${A.dim}  ? shortcuts · / commands · @ files · \\↵ newline · ↑↓ history · ctrl+c clear/exit${A.reset}`];
     }
     function renderDynamic() {
         const lines = [];
@@ -443,8 +656,14 @@ export async function runActoviqTui(options = {}) {
         }
         else {
             lines.push(...buildPromptBar());
-            const menu = buildMenu();
-            lines.push(...(menu.length > 0 ? menu : buildHintLine()));
+            const atMenu = buildAtMenu();
+            if (atMenu.length > 0) {
+                lines.push(...atMenu);
+            }
+            else {
+                const menu = buildMenu();
+                lines.push(...(menu.length > 0 ? menu : buildHintLine()));
+            }
         }
         screen.setDynamic(lines);
     }
@@ -487,6 +706,7 @@ export async function runActoviqTui(options = {}) {
                 permissionMode: currentPermissionMode(),
                 effort: currentEffort(),
                 approver,
+                ...(activeTeamTool ? { tools: [...tools, activeTeamTool] } : {}),
                 ...(canUseTool ? { canUseTool } : {}),
                 drainQueuedInputs: () => {
                     const drained = queuedInputs.splice(0);
@@ -523,6 +743,7 @@ export async function runActoviqTui(options = {}) {
         finally {
             running = false;
             abortCtrl = null;
+            workspaceFiles = null; // the agent may have created/removed files — refresh @-completion
             if (spinnerTimer) {
                 clearInterval(spinnerTimer);
                 spinnerTimer = null;
@@ -630,6 +851,9 @@ export async function runActoviqTui(options = {}) {
             mcp: '/mcp',
             plugins: '/plugins',
             dream: '/dream [run|status]',
+            workflows: '/workflows [run <name>|list]',
+            worktree: '/worktree [enter <name>|exit|list]',
+            team: '/team [ask <name> <prompt>|list]',
             exit: '/exit',
         };
         return usage[name] ?? `/${name}`;
@@ -884,15 +1108,17 @@ export async function runActoviqTui(options = {}) {
             title: 'Skills',
             items: skills.map(skill => ({
                 id: skill.name,
-                label: skill.name,
-                description: `${skill.source} · ${skill.context}`,
+                label: skill.displayName ? `${skill.displayName} (${skill.name})` : skill.name,
+                description: `${skill.source} · ${skill.context}${skill.version ? ` · v${skill.version}` : ''}`,
                 detail: `${skill.description} ${skill.whenToUse ?? ''}`,
             })),
         });
         const skill = skills.find(item => item.name === selected);
         if (skill) {
+            const heading = skill.displayName ? `${skill.displayName} (/${skill.name})` : `/${skill.name}`;
+            const ver = skill.version ? ` v${skill.version}` : '';
             appendStatic([
-                `${A.cyan}/${skill.name}${A.reset} ${skill.description}`,
+                `${A.cyan}${heading}${A.reset}${A.dim}${ver}${A.reset} ${skill.description}`,
                 `${A.dim}${skill.whenToUse ?? `source: ${skill.source} · context: ${skill.context}`}${A.reset}`,
                 '',
             ]);
@@ -1070,25 +1296,45 @@ export async function runActoviqTui(options = {}) {
                         await setEffort(args.toLowerCase());
                     return;
                 case 'permissions': {
-                    const requested = args;
-                    if (!requested) {
-                        const state = session.permissionContext;
-                        appendStatic([
-                            ...formatInfoLine(`permissions: ${state.mode ?? permissionMode} · ${state.permissions.length} session rules`),
-                            '',
-                        ]);
-                        return;
+                    // Three presets, selectable or named directly:
+                    //   read-only  → deny mutating tools (read / search / web only)
+                    //   workspace  → acceptEdits (auto-accept edits in the workspace)
+                    //   full       → bypassPermissions (no prompts)
+                    const READONLY_DENY = ['Bash', 'Write', 'Edit', 'NotebookEdit', 'PowerShell'];
+                    const presets = {
+                        'read-only': {
+                            mode: 'default',
+                            rules: READONLY_DENY.map((t) => ({ toolName: t, behavior: 'deny', source: 'permissions-preset' })),
+                            label: 'Read-only',
+                        },
+                        workspace: { mode: 'acceptEdits', rules: [], label: 'Workspace access' },
+                        full: { mode: 'bypassPermissions', rules: [], label: 'Full access' },
+                    };
+                    let key = args.trim().toLowerCase().replace(/[ _]/g, '-');
+                    if (!key) {
+                        const choice = await selectItem({
+                            title: 'Permission mode',
+                            subtitle: `current: ${session.permissionContext.mode ?? permissionMode}`,
+                            items: [
+                                { id: 'read-only', label: 'Read-only', description: 'Read, search, and web only — deny Write/Edit/Bash/NotebookEdit/PowerShell' },
+                                { id: 'workspace', label: 'Workspace access', description: 'Auto-accept edits in the workspace (acceptEdits)' },
+                                { id: 'full', label: 'Full access', description: 'No prompts — run any tool (bypassPermissions)' },
+                            ],
+                        });
+                        if (!choice)
+                            return;
+                        key = choice;
                     }
-                    if (!PERMISSION_MODES.has(requested)) {
-                        appendStatic([...formatErrorLine(`unknown permission mode: ${requested}`), '']);
+                    const preset = presets[key];
+                    if (!preset) {
+                        appendStatic([...formatErrorLine(`unknown permission preset: ${key} (read-only | workspace | full)`), '']);
                         return;
                     }
-                    await session.setPermissionContext({
-                        mode: requested,
-                        permissions: session.permissionContext.permissions,
-                        approver,
-                    });
-                    appendStatic([...formatInfoLine(`permissions set to: ${requested}`), '']);
+                    await session.setPermissionContext({ mode: preset.mode, permissions: preset.rules, approver });
+                    appendStatic([
+                        ...formatInfoLine(`permissions: ${preset.label} — ${preset.mode}${preset.rules.length ? ` · ${preset.rules.length} deny rules` : ''}`),
+                        '',
+                    ]);
                     return;
                 }
                 case 'sessions': {
@@ -1169,6 +1415,229 @@ export async function runActoviqTui(options = {}) {
                 case 'plugins':
                     await showPlugins();
                     return;
+                // ── v0.5.0: Dynamic Workflows ────────────────────────────
+                case 'workflows': {
+                    const runSavedWorkflow = async (wfName, wfTask) => {
+                        const wf = loadWorkflow(wfName, sdk.config.workDir);
+                        if (!wf) {
+                            appendStatic([...formatErrorLine(`workflow not found: ${wfName}`), '']);
+                            return;
+                        }
+                        appendStatic([
+                            ...formatInfoLine(`running workflow: ${wfName}`),
+                            ...formatInfoLine(`phases: ${wf.meta?.phases?.map((p) => p.title).join(', ') ?? 'none'}`),
+                            '',
+                        ]);
+                        try {
+                            const { WorkflowScriptRuntime } = await import('../workflow/workflowScriptRuntime.js');
+                            const runtime = new WorkflowScriptRuntime({
+                                sdk: sdk,
+                                args: wfTask,
+                                onEvent: (e) => {
+                                    if (e.type === 'workflow.phase.start') {
+                                        appendStatic([`${A.bold}${A.magenta}▶ ${e.title}${A.reset}`]);
+                                    }
+                                    else if (e.type === 'workflow.agent.start') {
+                                        appendStatic([`${A.dim}  ⚡ ${e.label ?? e.agentId}${e.cached ? ' (cached)' : ''}${A.reset}`]);
+                                    }
+                                    else if (e.type === 'workflow.agent.done') {
+                                        const secs = e.durationMs ? ` · ${Math.round(e.durationMs / 1000)}s` : '';
+                                        appendStatic([`${A.dim}  ✓ ${e.label ?? e.agentId}${secs}${A.reset}`]);
+                                    }
+                                    else if (e.type === 'workflow.log') {
+                                        appendStatic([`${A.dim}  │ ${e.message}${A.reset}`]);
+                                    }
+                                    else if (e.type === 'workflow.script.done') {
+                                        const secs = e.durationMs ? ` · ${Math.round(e.durationMs / 1000)}s` : '';
+                                        appendStatic([
+                                            `${A.green}✓ workflow done${A.reset}${A.dim} · ${e.agentCount} agents · ${e.totalTokens} tokens${secs}${A.reset}`,
+                                            '',
+                                        ]);
+                                    }
+                                },
+                            });
+                            const output = await runtime.execute(wf.script);
+                            if (typeof output.result === 'string' && output.result.trim()) {
+                                appendStatic([...formatInfoLine('workflow result:'), ...renderRichText(output.result, screen.width), '']);
+                            }
+                            if (output.state.errors.length > 0) {
+                                appendStatic([...formatErrorLine(`${output.state.errors.length} errors during workflow execution`), '']);
+                            }
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(`workflow error: ${error.message}`), '']);
+                        }
+                    };
+                    if (args.startsWith('run ')) {
+                        const runRest = args.slice(4).trim();
+                        const runSpace = runRest.indexOf(' ');
+                        await runSavedWorkflow(runSpace === -1 ? runRest : runRest.slice(0, runSpace), runSpace === -1 ? undefined : runRest.slice(runSpace + 1).trim());
+                        return;
+                    }
+                    // No sub-command → selection picker.
+                    const saved = listWorkflows(sdk.config.workDir);
+                    const items = [
+                        ...saved.map((w) => ({
+                            id: `run:${w.name}`,
+                            label: w.name,
+                            description: `${w.source} · ${w.description}`.slice(0, 80),
+                        })),
+                        {
+                            id: '__orchestrate__',
+                            label: '+ ask the agent to orchestrate a new workflow',
+                            description: 'describe a task in the prompt box; the agent designs & runs a workflow, then you can save it',
+                        },
+                    ];
+                    const choice = await selectItem({
+                        title: 'Workflows',
+                        subtitle: 'run a saved workflow, or have the agent build a new one',
+                        items,
+                    });
+                    if (!choice)
+                        return;
+                    if (choice.startsWith('run:')) {
+                        const name = choice.slice('run:'.length);
+                        const task = await promptText({ title: `Run /${name}`, label: 'Task / input (optional — Enter to skip)' });
+                        await runSavedWorkflow(name, task && task.trim() ? task.trim() : undefined);
+                    }
+                    else if (choice === '__orchestrate__') {
+                        appendStatic([
+                            ...formatInfoLine('Type your task in the prompt box and ask: "orchestrate a workflow to <task>".'),
+                            `${A.dim}After it runs and works, ask me to save it as a reusable workflow.${A.reset}`,
+                            '',
+                        ]);
+                    }
+                    return;
+                }
+                // ── v0.5.0: Worktrees ────────────────────────────────────
+                case 'worktree': {
+                    const ws = new WorktreeService(sdk.config.workDir);
+                    if (args === 'list') {
+                        await ws.init();
+                        const trees = await ws.listWorktrees();
+                        if (trees.length === 0) {
+                            appendStatic([...formatInfoLine('no worktrees'), '']);
+                        }
+                        else {
+                            appendStatic([
+                                ...trees.map((t) => `${A.dim}${t.path}${A.reset} · ${t.isDirty ? `${A.yellow}dirty${A.reset}` : `${A.green}clean${A.reset}`}`),
+                                '',
+                            ]);
+                        }
+                        return;
+                    }
+                    if (args === 'exit') {
+                        try {
+                            ws.exitWorktree();
+                            appendStatic([...formatInfoLine(`exited worktree, cwd: ${ws.currentWorkDir}`), '']);
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(error.message), '']);
+                        }
+                        return;
+                    }
+                    if (args.startsWith('enter ')) {
+                        const wfName = args.slice(6).trim();
+                        try {
+                            await ws.init();
+                            await ws.createAndEnterWorktree({ name: wfName });
+                            appendStatic([...formatInfoLine(`entered worktree: ${wfName} (${ws.currentWorkDir})`), '']);
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(error.message), '']);
+                        }
+                        return;
+                    }
+                    appendStatic([...formatInfoLine('usage: /worktree [enter <name>|exit|list]'), '']);
+                    return;
+                }
+                // ── v0.5.0: Model Team ───────────────────────────────────
+                case 'team': {
+                    if (args.startsWith('ask ')) {
+                        const rest = args.slice(4).trim();
+                        const spaceIdx = rest.indexOf(' ');
+                        if (spaceIdx === -1) {
+                            appendStatic([...formatErrorLine('usage: /team ask <name> <prompt>'), '']);
+                            return;
+                        }
+                        const teamName = rest.slice(0, spaceIdx);
+                        const prompt = rest.slice(spaceIdx + 1).trim();
+                        const loaded = loadTeamDefinition(teamName, sdk.config.workDir);
+                        if (!loaded) {
+                            appendStatic([...formatErrorLine(`team not found: ${teamName}`), '']);
+                            return;
+                        }
+                        appendStatic([
+                            ...formatInfoLine(`asking team "${teamName}" (${loaded.definition.mode} mode)`),
+                            `${A.dim}convening: ${loaded.definition.members?.map((m) => m.model).join(', ') ?? 'configured members'}${A.reset}`,
+                            '',
+                        ]);
+                        try {
+                            const team = createModelTeam(loaded.definition);
+                            const result = await team.ask(prompt);
+                            appendStatic([
+                                `${A.green}✓ team response${A.reset}${A.dim} · ${result.mode} · ${Math.round(result.durationMs / 1000)}s${A.reset}`,
+                                `${A.dim}cost: ${result.cost.estimatedCost !== null ? `$${result.cost.estimatedCost.toFixed(4)}` : 'N/A'} · ${result.cost.totalInputTokens + result.cost.totalOutputTokens} tokens${A.reset}`,
+                                '',
+                                ...renderRichText(result.answer, screen.width),
+                                '',
+                            ]);
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(`team error: ${error.message}`), '']);
+                        }
+                        return;
+                    }
+                    // No sub-command → picker that toggles which team the agent may call.
+                    const member = (sp) => ({ model: session.model, systemPrompt: sp });
+                    const buildDefault = (mode) => {
+                        switch (mode) {
+                            case 'analysis':
+                                return { name: 'analysis-panel', mode: 'analysis', members: [member('Expert researcher. Deep, source-grounded analysis.'), member('Rigorous skeptic. Verify with sources; challenge assumptions.')], timeoutMs: 300000, maxIterations: 12 };
+                            case 'panel':
+                                return { name: 'panel', mode: 'panel', members: [member('Thorough analyst.'), member('Creative problem-solver.')], primary: member('Synthesizer. Reconcile views into the best answer.'), timeoutMs: 300000 };
+                            case 'discussion':
+                                return { name: 'discussion', mode: 'discussion', members: [member('Systems thinker.'), member('Pragmatist who weighs trade-offs.')], primary: member('Convener and final decision-maker.'), timeoutMs: 300000 };
+                            case 'executor-reviewer':
+                                return { name: 'executor-reviewer', mode: 'executor-reviewer', members: [], executor: member('Executor. Own the output; you decide what to accept.'), reviewer: member('Reviewer. Advise; never command.'), timeoutMs: 300000 };
+                            default:
+                                return undefined;
+                        }
+                    };
+                    const saved = listTeamDefinitions(sdk.config.workDir);
+                    const items = [
+                        { id: '__none__', label: activeTeamTool ? `No team — remove "${activeTeamName}"` : 'No team (individual) — current', description: 'the agent works solo, no team tool attached' },
+                        ...saved.map((t) => ({ id: `saved:${t.name}`, label: t.name, description: `saved · ${t.definition.mode} · ${t.definition.members?.length ?? 0} members` })),
+                        ...['analysis', 'panel', 'discussion', 'executor-reviewer'].map((m) => ({ id: `mode:${m}`, label: `+ new ${m} team`, description: `built-in ${m} mode · default ${session.model} members` })),
+                    ];
+                    const choice = await selectItem({ title: 'Team', subtitle: 'attach a team the agent can call as a tool, or remove it', items });
+                    if (!choice)
+                        return;
+                    if (choice === '__none__') {
+                        activeTeamTool = null;
+                        activeTeamName = null;
+                        appendStatic([...formatInfoLine('team: none — the agent works individually'), '']);
+                        return;
+                    }
+                    let def;
+                    if (choice.startsWith('saved:'))
+                        def = loadTeamDefinition(choice.slice('saved:'.length), sdk.config.workDir)?.definition;
+                    else if (choice.startsWith('mode:'))
+                        def = buildDefault(choice.slice('mode:'.length));
+                    if (!def) {
+                        appendStatic([...formatErrorLine('could not load team definition'), '']);
+                        return;
+                    }
+                    try {
+                        activeTeamTool = createTeamTool(def);
+                        activeTeamName = def.name;
+                        appendStatic([...formatInfoLine(`team active: ${def.name} (${def.mode}) — the agent can now call "${def.name}" as a tool when it helps`), '']);
+                    }
+                    catch (error) {
+                        appendStatic([...formatErrorLine(`team error: ${error.message}`), '']);
+                    }
+                    return;
+                }
                 default:
                     appendStatic([...formatErrorLine(`unknown command: /${name} — type /help`), '']);
                     return;
@@ -1181,6 +1650,10 @@ export async function runActoviqTui(options = {}) {
     }
     // ── Submit / key handling ──────────────────────────────────────────
     async function submit() {
+        if (!running && applyAtCompletion()) {
+            renderDynamic();
+            return;
+        }
         const matches = filterSlashCommands(editor.text);
         if (matches.length > 0 && !running) {
             const selected = matches[Math.min(menuSelected, matches.length - 1)];
@@ -1469,6 +1942,7 @@ export async function runActoviqTui(options = {}) {
             case 'backspace':
                 editor.backspace();
                 menuSelected = 0;
+                atSelected = 0;
                 break;
             case 'delete':
                 editor.deleteForward();
@@ -1492,8 +1966,13 @@ export async function runActoviqTui(options = {}) {
                 editor.moveEnd();
                 break;
             case 'up': {
+                const atToken = activeAtToken(editor.text, editor.cursor);
+                const atCount = atToken ? atCompletions(atToken.token).length : 0;
                 const menu = filterSlashCommands(editor.text);
-                if (menu.length > 0) {
+                if (atCount > 0) {
+                    atSelected = (atSelected + atCount - 1) % atCount;
+                }
+                else if (menu.length > 0) {
                     menuSelected = (menuSelected + menu.length - 1) % menu.length;
                 }
                 else if (!editor.onFirstLine()) {
@@ -1505,8 +1984,13 @@ export async function runActoviqTui(options = {}) {
                 break;
             }
             case 'down': {
+                const atToken = activeAtToken(editor.text, editor.cursor);
+                const atCount = atToken ? atCompletions(atToken.token).length : 0;
                 const menu = filterSlashCommands(editor.text);
-                if (menu.length > 0) {
+                if (atCount > 0) {
+                    atSelected = (atSelected + 1) % atCount;
+                }
+                else if (menu.length > 0) {
                     menuSelected = (menuSelected + 1) % menu.length;
                 }
                 else if (!editor.onLastLine()) {
@@ -1518,6 +2002,8 @@ export async function runActoviqTui(options = {}) {
                 break;
             }
             case 'tab': {
+                if (applyAtCompletion())
+                    break;
                 const menu = filterSlashCommands(editor.text);
                 if (menu.length > 0) {
                     const selected = menu[Math.min(menuSelected, menu.length - 1)];
@@ -1535,6 +2021,7 @@ export async function runActoviqTui(options = {}) {
                     if (cleaned) {
                         editor.insert(cleaned);
                         menuSelected = 0;
+                        atSelected = 0;
                     }
                 }
                 break;
@@ -1591,4 +2078,16 @@ export async function runActoviqTui(options = {}) {
     // Keep the process alive until shutdown() exits it.
     await new Promise(() => { });
 }
+// Allow running this module directly (`npx tsx src/tui/actoviqTui.ts`), not only
+// via the cli/ wrapper. Requires an interactive terminal.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write('actoviq TUI requires an interactive terminal (TTY). Run it directly in your terminal — not piped or through another tool.\n');
+        process.exit(1);
+    }
+    runActoviqTui().catch((error) => {
+        process.stderr.write(`Fatal: ${error.stack ?? error.message}\n`);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=actoviqTui.js.map