actoviq-agent-sdk 0.4.6 → 0.4.7

package/dist/src/tui/actoviqTui.js

@@ -7,10 +7,10 @@
  */
 import { execSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import * as readline from 'node:readline';
-import { createActoviqCoreTools, createAgentSdk, detectBridgeProviders, loadDefaultActoviqSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, createModelTeam, createTeamTool, listRouterProfiles, loadRouterProfile, resolveRoutedRun, WorktreeService, } from '../index.js';
+import { createActoviqCoreTools, createAgentSdk, detectBridgeProviders, loadDefaultActoviqSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, cloneTeamDefinition, instantiateTeamDefinition, listTeamAgentLabels, countTeamAgents, createModelTeam, createTeamTool, readTeamPreferences, createManagerTools, buildManagerSystemPrompt, buildUpdateProgressPrompt, formatManagerUpdatePreview, resolveGitHubDigestForUpdate, readManagerConfig, writeManagerConfig, readProjectPlanFile, readProgressFile, managerProgressPath, createProjectIssue, executeProjectIssue, isIssueStatus, isIssueStorageMode, listProjectIssues, listScheduledAutomationTasks, resolveActoviqHome, listRouterProfiles, loadRouterProfile, resolveRoutedRun, transitionProjectIssue, WorktreeService, } from '../index.js';
+import { readProjectMeta } from '../gui/projectMeta.js';
 import { persistActoviqSettingsStore, resolveActoviqSettingsStore, } from '../config/actoviqSettingsStore.js';
 import { createPreToolUseHookClassifier, readPreToolUseHooks, readPostToolUseHooks, runPostToolUseHooks, readSessionStartHooks, runSessionStartHooks } from '../hooks/userHooks.js';
 import { isRecord } from '../runtime/helpers.js';
@@ -20,9 +20,11 @@ import { buildRouteModelApi } from '../router/modelRouter.js';
 import { addMcpServer, readMcpServerConfig, removeMcpServer } from '../mcp/mcpServerConfig.js';
 import { isReadOnlyBashCommand } from '../runtime/bashClassification.js';
 import { estimateCost } from '../team/pricing.js';
+import { applyTeamRunEvent, createTeamRunViewState, formatTeamRunTreeLines } from '../team/teamRunView.js';
 import { applyOutputStyle, OUTPUT_STYLES } from '../prompts/outputStyles.js';
 import { planFilePath, readPlanFile } from '../tools/planMode/PlanModeTools.js';
 import { loadProjectContext } from '../memory/projectContext.js';
+import { LegacySurfaceEventPipeline, } from '../surfaces/index.js';
 import { pathToFileURL } from 'node:url';
 import { ACTOVIQ_INTERACTIVE_COMMANDS, SUBCOMMAND_DESCRIPTIONS, filterInteractiveCommands, } from '../ui/commandSurface.js';
 import { A, stringWidth, truncateToWidth, wrapToWidth } from './ansi.js';
@@ -165,7 +167,7 @@ function buildSystemPrompt(workDir) {
         `- NEVER create documentation files (*.md) unless explicitly requested.\n` +
         `- When in doubt, use TodoWrite to track progress.`) + projectSection;
 }
-// First-run onboarding: guides the user through creating ~/.actoviq/settings.json
+// First-run onboarding: guides the user through creating the Actoviq settings file
 // when no credential is found. Uses plain readline (no TTY required beyond stdin).
 async function onboardCredentials(configPath) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -179,8 +181,7 @@ async function onboardCredentials(configPath) {
     const resolvedProvider = provider.trim() || 'anthropic';
     const resolvedBaseURL = baseURL.trim() || 'https://api.deepseek.com';
     const resolvedModel = model.trim() || 'deepseek-chat';
-    const home = os.homedir();
-    const dir = path.join(home, '.actoviq');
+    const dir = resolveActoviqHome();
     const file = configPath ?? path.join(dir, 'settings.json');
     fs.mkdirSync(dir, { recursive: true });
     const env = {
@@ -209,7 +210,14 @@ export async function runActoviqTui(options = {}) {
     catch {
         // Missing local config is fine; env vars may carry credentials.
     }
-    const tools = createActoviqCoreTools({ cwd: workDir });
+    let applyPlanPermission = null;
+    const tools = createActoviqCoreTools({
+        cwd: workDir,
+        onPlanModeChange: async (mode) => {
+            if (mode === 'plan')
+                await applyPlanPermission?.();
+        },
+    });
     const createCleanSdk = () => createAgentSdk({
         workDir,
         tools,
@@ -288,8 +296,28 @@ export async function runActoviqTui(options = {}) {
     let commandBusy = false;
     let shuttingDown = false;
     // Active team tool the main agent may call (toggled via /team). null = no team.
+    // The tool is only injected into runs when preferences.team.autoInvoke is on;
+    // otherwise attach is a selection and /team ask stays the manual path.
+    const teamPrefs = readTeamPreferences(getLoadedJsonConfig()?.raw);
     let activeTeamTool = null;
     let activeTeamName = null;
+    let lastTeamRunSummary = null;
+    const attachTeamByName = (name) => {
+        const loaded = loadTeamDefinition(name, sdk.config.workDir);
+        if (!loaded)
+            return null;
+        const definition = instantiateTeamDefinition(loaded.definition, session.model);
+        activeTeamTool = createTeamTool(definition);
+        activeTeamName = definition.name;
+        return definition;
+    };
+    if (teamPrefs.defaultAttached) {
+        // Unresolvable default names are ignored; /team status surfaces the hint.
+        try {
+            attachTeamByName(teamPrefs.defaultAttached);
+        }
+        catch { /* ignore */ }
+    }
     // /model router: when set, each user turn is classified and routed to a model.
     let activeRouter = null;
     let routedModelLabel = null;
@@ -307,6 +335,33 @@ export async function runActoviqTui(options = {}) {
     // Display labels (model is set from the config on activation).
     let bridgeModelLabel = null;
     let abortCtrl = null;
+    // Persistent Manager session (kind: 'manager') — reused across /manager
+    // update/chat turns so the Manager keeps its own conversation context.
+    let managerTuiSession = null;
+    async function resolveManagerTuiSession() {
+        if (managerTuiSession)
+            return managerTuiSession;
+        const managers = (await sdk.sessions.list()).filter(item => item.kind === 'manager');
+        managers.sort((a, b) => {
+            if (b.messageCount !== a.messageCount)
+                return b.messageCount - a.messageCount;
+            return (b.updatedAt || '').localeCompare(a.updatedAt || '');
+        });
+        for (const dup of managers.slice(1)) {
+            await sdk.sessions.delete(dup.id).catch(() => undefined);
+        }
+        const existing = managers[0];
+        if (existing) {
+            managerTuiSession = await sdk.resumeSession(existing.id, { permissionMode: 'bypassPermissions' });
+            return managerTuiSession;
+        }
+        managerTuiSession = await sdk.createSession({
+            title: 'Manager',
+            metadata: { __actoviqKind: 'manager' },
+            permissionMode: 'bypassPermissions',
+        });
+        return managerTuiSession;
+    }
     let dialog = null;
     let selectionDialog = null;
     let textInputDialog = null;
@@ -356,13 +411,13 @@ export async function runActoviqTui(options = {}) {
     let ctrlCCount = 0;
     let ctrlCTimer = null;
     let streamedTextSeen = false;
+    let streamedThinkingSeen = false;
     // Track tool names by callId for PostToolUse hook context.
     const toolCallNames = new Map();
     // Live todo list (captured from TodoWrite tool calls). Rendered as a
     // persistent panel in the dynamic region so the user can see what the agent
     // is working on / what remains — Claude Code's main progress affordance.
     let currentTodos = [];
-    const queuedInputs = [];
     const currentPermissionMode = () => session.permissionContext.mode ?? permissionMode;
     const currentEffort = () => {
         const stored = session.metadata[SESSION_EFFORT_KEY];
@@ -454,6 +509,9 @@ export async function runActoviqTui(options = {}) {
             ? { behavior: 'allow', reason: 'Approved in TUI.' }
             : { behavior: 'deny', reason: 'Denied in TUI permission dialog.' };
     };
+    applyPlanPermission = async () => {
+        await session.setPermissionContext({ mode: 'plan', permissions: [], approver });
+    };
     const canUseTool = permissionMode === 'default'
         ? (context) => {
             if (context.publicName === 'Bash') {
@@ -810,7 +868,10 @@ export async function runActoviqTui(options = {}) {
         const bridgeTag = bridgeMode && activeBridgeConfig
             ? ` · bridge:${activeBridgeConfig.name}${bridgeModelLabel ? ` · ${bridgeModelLabel}` : ''}`
             : '';
-        const left = `${modelLabel} · ${permissionLabel()} · effort:${currentEffort() ?? 'auto'} · team:${activeTeamName ?? 'none'}${bridgeTag}${goalContextLine()} · `;
+        const teamLabel = activeTeamName
+            ? `team:${activeTeamName}${teamPrefs.autoInvoke ? '' : ' (manual)'}`
+            : 'team:none';
+        const left = `${modelLabel} · ${permissionLabel()} · effort:${currentEffort() ?? 'auto'} · ${teamLabel}${bridgeTag}${goalContextLine()} · `;
         return `${A.dim}  ${left}${A.reset}${ctxColor}ctx ${pct}% (${usedK})${A.reset}`;
     }
     function buildStatusLine() {
@@ -820,7 +881,7 @@ export async function runActoviqTui(options = {}) {
         const elapsed = Math.max(Math.round((Date.now() - runStartedAt) / 1000), 0);
         const frame = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
         const note = statusNote ? ` · ${statusNote}` : '';
-        const queued = queuedInputs.length > 0 ? ` · ${queuedInputs.length} queued` : '';
+        const queued = session.pendingInputCount > 0 ? ` · ${session.pendingInputCount} queued` : '';
         return [
             `${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,
@@ -1075,9 +1136,8 @@ export async function runActoviqTui(options = {}) {
             // Branch the event source. Bridge mode spawns the configured runtime CLI
             // and adapts its events into the same AgentEvent stream the rest of this
             // loop consumes — so a bridge run reuses the spinner, tool cards, Esc
-            // interrupt, steering queue, and history exactly like a normal run. The
-            // bridge stream has no mid-run drain, so steering typed during a bridge
-            // run queues and becomes the next turn (handled by the tail below).
+            // interrupt, first-class session steering, and history exactly like a
+            // normal run.
             let eventStream;
             let resultPromise;
             if (bridgeMode && activeBridgeModelApi) {
@@ -1096,12 +1156,8 @@ export async function runActoviqTui(options = {}) {
                     classifier: preToolUseHookClassifier,
                     model: activeBridgeModelApi.model,
                     modelApi: activeBridgeModelApi.modelApi,
-                    ...(activeTeamTool ? { tools: [...tools, activeTeamTool] } : {}),
+                    ...(activeTeamTool && teamPrefs.autoInvoke ? { tools: [...tools, activeTeamTool] } : {}),
                     ...(canUseTool ? { canUseTool } : {}),
-                    drainQueuedInputs: () => {
-                        const drained = queuedInputs.splice(0);
-                        return drained;
-                    },
                 });
                 eventStream = stream;
                 resultPromise = stream.result;
@@ -1115,18 +1171,17 @@ export async function runActoviqTui(options = {}) {
                     approver,
                     classifier: preToolUseHookClassifier,
                     ...(routed ? { model: routed.model, modelApi: routed.modelApi } : {}),
-                    ...(activeTeamTool ? { tools: [...tools, activeTeamTool] } : {}),
+                    ...(activeTeamTool && teamPrefs.autoInvoke ? { tools: [...tools, activeTeamTool] } : {}),
                     ...(canUseTool ? { canUseTool } : {}),
-                    drainQueuedInputs: () => {
-                        const drained = queuedInputs.splice(0);
-                        return drained;
-                    },
                 });
                 eventStream = stream;
                 resultPromise = stream.result;
             }
+            const surfaceEvents = new LegacySurfaceEventPipeline();
             for await (const event of eventStream) {
-                handleAgentEvent(event);
+                for (const surfaceEvent of surfaceEvents.projectFor(event, 'tui')) {
+                    handleSurfaceEvent(surfaceEvent);
+                }
             }
             const result = await resultPromise;
             // Accumulate token + USD usage for /cost and /usage. The model is the
@@ -1166,26 +1221,25 @@ export async function runActoviqTui(options = {}) {
             cancelScheduledDynamicRender();
             renderDynamic();
         }
-        // Steering messages typed too late to drain mid-run become the next turn.
-        if (queuedInputs.length > 0 && !shuttingDown) {
-            const next = queuedInputs.splice(0).join('\n');
-            await startRun(next);
-        }
     }
     function runHadNoStreamedText() {
         return !streamedTextSeen;
     }
-    function handleAgentEvent(event) {
+    function handleSurfaceEvent(event) {
+        const data = event.data;
         switch (event.type) {
             case 'run.started':
                 streamedTextSeen = false;
+                streamedThinkingSeen = false;
                 return;
             case 'request.started':
-                lastTokenEstimate = event.requestTokenEstimate;
+                lastTokenEstimate = typeof data.requestTokenEstimate === 'number'
+                    ? data.requestTokenEstimate
+                    : undefined;
                 renderDynamic();
                 return;
-            case 'response.text.delta': {
-                const delta = typeof event.delta === 'string' ? event.delta : '';
+            case 'text.delta': {
+                const delta = typeof data.delta === 'string' ? data.delta : '';
                 if (!delta)
                     return;
                 streamedTextSeen = true;
@@ -1195,29 +1249,58 @@ export async function runActoviqTui(options = {}) {
                 scheduleDynamicRender();
                 return;
             }
-            case 'response.content':
-                if (event.content.type === 'thinking') {
-                    const thinking = event.content.thinking ?? '';
+            case 'reasoning.delta': {
+                const delta = typeof data.delta === 'string' ? data.delta : '';
+                if (!delta)
+                    return;
+                const lines = formatThinking(delta, screen.width);
+                if (lines.length > 0)
+                    appendStatic(lines);
+                streamedThinkingSeen = true;
+                scheduleDynamicRender();
+                return;
+            }
+            case 'tool.input.delta': {
+                const name = typeof data.name === 'string' && data.name ? data.name : 'tool';
+                const snapshot = typeof data.snapshot === 'string'
+                    ? data.snapshot.trim().replace(/\s+/g, ' ')
+                    : '';
+                const preview = snapshot.length > 72 ? `${snapshot.slice(0, 69)}...` : snapshot;
+                statusNote = preview ? `preparing ${name}: ${preview}` : `preparing ${name}`;
+                scheduleDynamicRender();
+                return;
+            }
+            case 'model.content': {
+                const content = isRecord(data.content) ? data.content : undefined;
+                if (data.kind === 'content' && content?.type === 'thinking' && !streamedThinkingSeen) {
+                    const thinking = typeof content.thinking === 'string' ? content.thinking : '';
                     const lines = formatThinking(thinking, screen.width);
                     if (lines.length > 0)
                         appendStatic(lines);
                 }
                 return;
-            case 'tool.call': {
+            }
+            case 'tool.started': {
+                const callId = typeof data.callId === 'string' ? data.callId : '';
+                const publicName = typeof data.publicName === 'string'
+                    ? data.publicName
+                    : typeof data.name === 'string' ? data.name : 'tool';
+                const input = data.input;
                 const pending = flusher.drain();
                 if (pending.length > 0)
                     appendStatic(pending);
                 runToolCount += 1;
-                statusNote = event.call.publicName;
-                toolCallNames.set(event.call.id, event.call.publicName);
+                statusNote = publicName;
+                if (callId)
+                    toolCallNames.set(callId, publicName);
                 // Render Edit calls as a colored old→new diff instead of a one-liner.
-                appendStatic(event.call.publicName === 'Edit'
-                    ? formatEditCall(event.call.input, screen.width)
-                    : formatToolCall(event.call.publicName, event.call.input, screen.width));
+                appendStatic(publicName === 'Edit'
+                    ? formatEditCall(input, screen.width)
+                    : formatToolCall(publicName, input, screen.width));
                 // Capture the live todo list from TodoWrite calls so the persistent
                 // panel (renderDynamic) reflects the agent's current plan + progress.
-                if (event.call.publicName === 'TodoWrite') {
-                    const todos = event.call.input?.todos;
+                if (publicName === 'TodoWrite') {
+                    const todos = (isRecord(input) ? input.todos : undefined);
                     if (Array.isArray(todos)) {
                         currentTodos = todos
                             .filter((t) => typeof t === 'object' && t !== null)
@@ -1233,40 +1316,45 @@ export async function runActoviqTui(options = {}) {
                 return;
             }
             case 'tool.progress': {
-                const data = event.data;
-                if (data?.message) {
-                    statusNote = data.message;
+                const progress = isRecord(data.progress) ? data.progress : undefined;
+                const message = typeof data.message === 'string'
+                    ? data.message
+                    : typeof progress?.message === 'string' ? progress.message : undefined;
+                if (message) {
+                    statusNote = message;
                     scheduleDynamicRender();
                 }
                 return;
             }
-            case 'tool.result':
+            case 'tool.completed':
+            case 'tool.failed':
+            case 'tool.rejected': {
+                const callId = typeof data.callId === 'string' ? data.callId : '';
+                const outputText = typeof data.outputText === 'string' ? data.outputText : '';
                 statusNote = '';
                 appendStatic(formatToolResult({
-                    isError: event.result.isError,
-                    durationMs: event.result.durationMs,
-                    outputText: event.result.outputText,
+                    isError: data.isError === true,
+                    durationMs: typeof data.durationMs === 'number' ? data.durationMs : 0,
+                    outputText,
                 }, screen.width));
                 // Run matching PostToolUse hooks (fire-and-forget, never block).
-                const toolName = toolCallNames.get(event.result.id);
+                const toolName = callId ? toolCallNames.get(callId) : undefined;
                 if (toolName) {
-                    runPostToolUseHooks(() => readPostToolUseHooks(getLoadedJsonConfig()?.raw), toolName, null, event.result.outputText ?? '', sdk.config.workDir);
+                    runPostToolUseHooks(() => readPostToolUseHooks(getLoadedJsonConfig()?.raw), toolName, null, outputText, sdk.config.workDir);
                 }
                 renderDynamic();
                 return;
-            case 'conversation.compacted':
-                appendStatic(formatCompactNotice(event.trigger ?? 'auto', event.tokenEstimateBefore, event.tokenEstimateAfter));
-                return;
-            case 'session.compacted':
-                appendStatic(formatCompactNotice(event.trigger));
+            }
+            case 'compaction.completed':
+                appendStatic(formatCompactNotice(typeof data.trigger === 'string' ? data.trigger : 'auto', typeof data.tokenEstimateBefore === 'number' ? data.tokenEstimateBefore : undefined, typeof data.tokenEstimateAfter === 'number' ? data.tokenEstimateAfter : undefined));
                 return;
             case 'tool.permission':
-                if (event.decision.behavior === 'deny') {
-                    appendStatic(formatInfoLine(`permission denied: ${event.decision.publicName} — ${event.decision.reason}`));
+                if (isRecord(data.decision) && data.decision.behavior === 'deny') {
+                    appendStatic(formatInfoLine(`permission denied: ${String(data.decision.publicName ?? 'tool')} — ${String(data.decision.reason ?? '')}`));
                 }
                 return;
             case 'error':
-                appendStatic(formatErrorLine(event.error.message));
+                appendStatic(formatErrorLine(typeof data.message === 'string' ? data.message : 'run failed'));
                 return;
             default:
                 return;
@@ -1307,11 +1395,18 @@ export async function runActoviqTui(options = {}) {
             workflows: '/workflows [run <name>|list]',
             worktree: '/worktree [enter <name>|exit|list]',
             team: '/team [ask <name> <prompt>|list]',
+            issues: '/issues [list|show <id>|create <title>|start <id> [agent-profile]|review <id>|done <id>|block <id>]',
             exit: '/exit',
         };
         return usage[name] ?? `/${name}`;
     }
     async function resumeSession(sessionId) {
+        const listed = await sdk.sessions.list();
+        const target = listed.find(item => item.id === sessionId);
+        if (target?.kind === 'manager') {
+            appendStatic([...formatErrorLine('Manager sessions live in the Project Manager panel only.'), '']);
+            return;
+        }
         session = await sdk.resumeSession(sessionId);
         appendStatic([
             ...formatInfoLine(`resumed: ${session.id} · ${session.title} · ${session.model}`),
@@ -1319,7 +1414,7 @@ export async function runActoviqTui(options = {}) {
         ]);
     }
     async function chooseSessionToResume() {
-        const sessions = (await sdk.sessions.list()).filter(item => item.id !== session.id);
+        const sessions = (await sdk.sessions.list()).filter(item => item.id !== session.id && item.kind !== 'manager');
         if (sessions.length === 0) {
             appendStatic([...formatInfoLine('no other project sessions to resume'), '']);
             return;
@@ -2490,7 +2585,7 @@ export async function runActoviqTui(options = {}) {
                     return;
                 }
                 case 'sessions': {
-                    const sessions = await sdk.sessions.list();
+                    const sessions = (await sdk.sessions.list()).filter(item => item.kind !== 'manager');
                     appendStatic([
                         ...(sessions.length > 0
                             ? sessions.map(item => `${item.id === session.id ? A.green : A.dim}${item.id}${A.reset} ${item.title} · ${item.model} · ${item.status}`)
@@ -2844,6 +2939,7 @@ export async function runActoviqTui(options = {}) {
                             const { WorkflowScriptRuntime } = await import('../workflow/workflowScriptRuntime.js');
                             const runtime = new WorkflowScriptRuntime({
                                 sdk: sdk,
+                                trust: 'trusted',
                                 args: wfTask,
                                 onEvent: (e) => {
                                     if (e.type === 'workflow.phase.start') {
@@ -3008,6 +3104,61 @@ export async function runActoviqTui(options = {}) {
                 }
                 // ── v0.5.0: Model Team ───────────────────────────────────
                 case 'team': {
+                    if (args === 'status') {
+                        appendStatic([
+                            `${A.bold}Team status${A.reset}`,
+                            `${A.dim}attached: ${activeTeamName ?? 'none'}${A.reset}`,
+                            `${A.dim}autoInvoke: ${teamPrefs.autoInvoke ? 'on — the main agent can call the team as a tool' : 'off — manual /team ask only'}${A.reset}`,
+                            `${A.dim}defaultAttached: ${teamPrefs.defaultAttached ?? 'none'}${teamPrefs.defaultAttached && !activeTeamName ? ' (not found)' : ''}${A.reset}`,
+                            `${A.dim}last run: ${lastTeamRunSummary ?? 'none'}${A.reset}`,
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args === 'off') {
+                        activeTeamTool = null;
+                        activeTeamName = null;
+                        appendStatic([...formatInfoLine('team: none — the agent works individually'), '']);
+                        return;
+                    }
+                    if (args === 'list') {
+                        const teams = listTeamDefinitions(sdk.config.workDir);
+                        appendStatic([
+                            `${A.bold}Teams${A.reset}`,
+                            ...teams.map((t) => `${t.name === activeTeamName ? `${A.green}*${A.reset}` : ' '}${A.cyan}${t.name}${A.reset}${A.dim} · ${t.definition.mode} · ${t.source} · ${countTeamAgents(t.definition)} agents${A.reset}`),
+                            `${A.dim}/team attach <name> · /team ask <name> <prompt> · /team off · /team status${A.reset}`,
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args.startsWith('attach ')) {
+                        const teamName = args.slice(7).trim();
+                        const definition = attachTeamByName(teamName);
+                        if (!definition) {
+                            appendStatic([...formatErrorLine(`team not found: ${teamName}`), '']);
+                            return;
+                        }
+                        appendStatic([
+                            ...formatInfoLine(`team attached: ${definition.name} (${definition.mode}) · autoInvoke ${teamPrefs.autoInvoke ? 'on' : 'off — run /team ask <name> <prompt> to use it'}`),
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args.startsWith('clone ')) {
+                        const parts = args.slice(6).trim().split(/\s+/);
+                        if (parts.length !== 2) {
+                            appendStatic([...formatErrorLine('usage: /team clone <source> <new-name>'), '']);
+                            return;
+                        }
+                        try {
+                            const clone = await cloneTeamDefinition(parts[0], parts[1], { projectDir: sdk.config.workDir });
+                            appendStatic([...formatInfoLine(`team cloned: ${parts[0]} → ${clone.name} (${clone.filePath})`), '']);
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(`clone failed: ${error.message}`), '']);
+                        }
+                        return;
+                    }
                     if (args.startsWith('ask ')) {
                         const rest = args.slice(4).trim();
                         const spaceIdx = rest.indexOf(' ');
@@ -3022,14 +3173,50 @@ export async function runActoviqTui(options = {}) {
                             appendStatic([...formatErrorLine(`team not found: ${teamName}`), '']);
                             return;
                         }
+                        const definition = instantiateTeamDefinition(loaded.definition, session.model);
+                        const memberModels = listTeamAgentLabels(definition);
+                        if (teamPrefs.confirmBeforeRun) {
+                            const go = await selectItem({
+                                title: `Run team "${definition.name}"?`,
+                                subtitle: `${definition.mode} · members: ${memberModels.join(', ') || '(none)'}`,
+                                items: [
+                                    { id: 'run', label: 'Run', description: 'convene the team now' },
+                                    { id: 'cancel', label: 'Cancel', description: 'do nothing' },
+                                ],
+                            });
+                            if (go !== 'run')
+                                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}`,
+                            ...formatInfoLine(`asking team "${teamName}" (${definition.mode} mode)`),
+                            `${A.dim}convening: ${memberModels.join(', ') || 'configured members'}${A.reset}`,
                             '',
                         ]);
                         try {
-                            const team = createModelTeam(loaded.definition);
-                            const result = await team.ask(prompt);
+                            const team = createModelTeam(definition);
+                            const teamRunView = createTeamRunViewState(definition.name);
+                            const printTeamRunTree = () => {
+                                const lines = formatTeamRunTreeLines(teamRunView);
+                                if (!lines.length)
+                                    return;
+                                appendStatic([...lines.map((line) => `${A.dim}${line}${A.reset}`), '']);
+                            };
+                            const result = await team.ask(prompt, undefined, {
+                                workDir: sdk.config.workDir,
+                                onEvent: (e) => {
+                                    applyTeamRunEvent(teamRunView, e);
+                                    if (e.type === 'team.synthesis') {
+                                        appendStatic([`${A.dim}  ◈ synthesis round ${e.round}: ${e.decision}${A.reset}`]);
+                                    }
+                                    else if (e.type === 'team.started'
+                                        || e.type === 'team.member.completed'
+                                        || e.type === 'team.edge.triggered'
+                                        || e.type === 'team.completed') {
+                                        printTeamRunTree();
+                                    }
+                                },
+                            });
+                            lastTeamRunSummary = `${teamName} · ${result.mode} · ${Math.round(result.durationMs / 1000)}s`;
                             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}`,
@@ -3044,26 +3231,16 @@ export async function runActoviqTui(options = {}) {
                         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 'panel-analysis':
-                                return { name: 'panel-analysis', mode: 'panel-analysis', members: [member('Expert researcher. Investigate with read-only tools; cite sources.'), member('Rigorous skeptic. Verify with sources; challenge assumptions.')], primary: member('Synthesizer. Reconcile the panel findings into the best answer and decide when they suffice.'), timeoutMs: 300000, maxIterations: 12 };
-                            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 'reviewer':
-                                return { name: 'reviewer', mode: 'reviewer', members: [], reviewer: member('Meticulous reviewer. Surface only genuine, verifiable issues with file:line evidence; never speculate.'), timeoutMs: 300000, maxIterations: 16 };
-                            default:
-                                return undefined;
-                        }
-                    };
-                    const saved = listTeamDefinitions(sdk.config.workDir);
+                    const teams = 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` })),
-                        ...['panel-analysis', 'analysis', 'reviewer'].map((m) => ({ id: `mode:${m}`, label: `+ new ${m} team`, description: `built-in ${m} mode · default ${session.model} members` })),
+                        { id: '__none__', label: activeTeamTool ? `No team — remove "${activeTeamName}"` : 'No team (individual) — current', description: 'the agent works solo, no team attached' },
+                        ...teams.map((t) => ({
+                            id: `team:${t.name}`,
+                            label: `${t.name}${t.name === activeTeamName ? ' — attached' : ''}`,
+                            description: `${t.source} · ${t.definition.mode} · ${countTeamAgents(t.definition)} agents`,
+                        })),
                     ];
-                    const choice = await selectItem({ title: 'Team', subtitle: 'attach a team the agent can call as a tool, or remove it', items });
+                    const choice = await selectItem({ title: 'Team', subtitle: `attach a team (autoInvoke ${teamPrefs.autoInvoke ? 'on' : 'off'} — settings preferences.team)`, items });
                     if (!choice)
                         return;
                     if (choice === '__none__') {
@@ -3072,25 +3249,273 @@ export async function runActoviqTui(options = {}) {
                         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`), '']);
+                        const definition = attachTeamByName(choice.slice('team:'.length));
+                        if (!definition) {
+                            appendStatic([...formatErrorLine('could not load team definition'), '']);
+                            return;
+                        }
+                        appendStatic([
+                            ...formatInfoLine(teamPrefs.autoInvoke
+                                ? `team active: ${definition.name} (${definition.mode}) — the agent can now call "${definition.name}" as a tool when it helps`
+                                : `team attached: ${definition.name} (${definition.mode}) — run /team ask ${definition.name} <prompt> (autoInvoke off)`),
+                            '',
+                        ]);
                     }
                     catch (error) {
                         appendStatic([...formatErrorLine(`team error: ${error.message}`), '']);
                     }
                     return;
                 }
+                // ── Project Manager ──────────────────────────────────────
+                case 'issues': {
+                    const homeDir = sdk.config.homeDir;
+                    const meta = await readProjectMeta(sdk.config.workDir, homeDir);
+                    const storage = isIssueStorageMode(meta.issueStorage) ? meta.issueStorage : 'home';
+                    if (!args || args === 'list') {
+                        const issues = await listProjectIssues(sdk.config.workDir, homeDir, storage);
+                        if (issues.length === 0) {
+                            appendStatic([...formatInfoLine('no issues yet; use /issues create <title>'), '']);
+                            return;
+                        }
+                        appendStatic([
+                            `${A.cyan}Issues (${storage})${A.reset}`,
+                            ...issues.map(issue => `#${issue.number} ${issue.title} ${A.dim}${issue.status} · ${issue.priority}${A.reset}`),
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args.startsWith('create ')) {
+                        const title = args.slice(7).trim();
+                        if (!title) {
+                            appendStatic([...formatErrorLine('usage: /issues create <title>'), '']);
+                            return;
+                        }
+                        const issue = await createProjectIssue(sdk.config.workDir, homeDir, { title }, storage);
+                        appendStatic([...formatInfoLine(`issue created: #${issue.number} ${issue.title}`), '']);
+                        return;
+                    }
+                    if (args.startsWith('show ')) {
+                        const rawId = args.slice(5).trim().replace(/^#/, '');
+                        const issues = await listProjectIssues(sdk.config.workDir, homeDir, storage);
+                        const issue = issues.find(candidate => candidate.id === rawId ||
+                            String(candidate.number) === rawId ||
+                            `ISS-${candidate.number}` === rawId.toUpperCase());
+                        if (!issue) {
+                            appendStatic([...formatErrorLine(`issue not found: ${rawId}`), '']);
+                            return;
+                        }
+                        appendStatic([
+                            `${A.bold}ISS-${issue.number} ${issue.title}${A.reset}`,
+                            `${A.dim}${issue.status} · ${issue.priority}${A.reset}`,
+                            issue.description || '(no description)',
+                            ...(issue.acceptanceCriteria.length
+                                ? ['', 'Acceptance criteria:', ...issue.acceptanceCriteria.map(item => `- ${item}`)]
+                                : []),
+                            ...(issue.brief ? ['', 'Manager brief:', issue.brief] : []),
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args.startsWith('start ')) {
+                        const [, rawId, agentProfile] = args.split(/\s+/, 3);
+                        const id = rawId?.replace(/^#/, '');
+                        const issues = await listProjectIssues(sdk.config.workDir, homeDir, storage);
+                        const issue = issues.find(candidate => candidate.id === id ||
+                            String(candidate.number) === id ||
+                            `ISS-${candidate.number}` === id?.toUpperCase());
+                        if (!issue) {
+                            appendStatic([...formatErrorLine(`issue not found: ${rawId ?? ''}`), '']);
+                            return;
+                        }
+                        appendStatic([...formatInfoLine(`decomposing and dispatching ISS-${issue.number}...`), '']);
+                        const dispatched = await executeProjectIssue({
+                            sdk,
+                            managerSession: await resolveManagerTuiSession(),
+                            workDir: sdk.config.workDir,
+                            homeDir,
+                            storageMode: storage,
+                            issue,
+                            agentProfile,
+                            defaultModel: session.model,
+                            permissionMode: currentPermissionMode(),
+                            systemPrompt,
+                        });
+                        session = dispatched.session;
+                        appendStatic([
+                            ...formatInfoLine(`ISS-${dispatched.issue.number}: ${dispatched.issue.status} · session ${session.id}`),
+                            ...(dispatched.result.text ? [dispatched.result.text] : []),
+                            '',
+                        ]);
+                        return;
+                    }
+                    const transitions = {
+                        review: 'in_review',
+                        done: 'done',
+                        block: 'blocked',
+                    };
+                    const [verb, rawId] = args.split(/\s+/, 2);
+                    const nextStatus = transitions[verb ?? ''];
+                    if (nextStatus && isIssueStatus(nextStatus) && rawId) {
+                        const issue = await transitionProjectIssue(sdk.config.workDir, homeDir, rawId.replace(/^#/, ''), nextStatus, 'user', storage);
+                        if (!issue)
+                            appendStatic([...formatErrorLine(`issue not found: ${rawId}`), '']);
+                        else
+                            appendStatic([...formatInfoLine(`issue #${issue.number}: ${issue.status}`), '']);
+                        return;
+                    }
+                    appendStatic([...formatErrorLine('usage: /issues [list|show <id>|create <title>|start <id> [agent-profile]|review <id>|done <id>|block <id>]'), '']);
+                    return;
+                }
+                case 'manager': {
+                    const homeDir = sdk.config.homeDir;
+                    if (!args || args === 'status') {
+                        const cfg = await readManagerConfig(sdk.config.workDir, homeDir);
+                        const plan = await readProjectPlanFile(sdk.config.workDir, homeDir);
+                        const progress = await readProgressFile(sdk.config.workDir, homeDir);
+                        appendStatic([
+                            `${A.bold}Manager${A.reset}`,
+                            `${A.dim}model: ${cfg.model ?? `${session.model} (session default)`}${A.reset}`,
+                            `${A.dim}readScope: ${cfg.readScope}${A.reset}`,
+                            `${A.dim}mirror to workspace: ${cfg.mirrorProgressToWorkspace ? 'on' : 'off'}${A.reset}`,
+                            `${A.dim}plan.json: ${plan.milestones.length} milestones · ${plan.today.length} today · ${plan.upcoming.length} upcoming${A.reset}`,
+                            `${A.dim}PROGRESS.md: ${progress ? `${progress.length} chars` : '(none yet — /manager update)'}${A.reset}`,
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args === 'config') {
+                        const cfg = await readManagerConfig(sdk.config.workDir, homeDir);
+                        appendStatic([
+                            ...JSON.stringify(cfg, null, 2).split('\n').map((l) => `${A.dim}${l}${A.reset}`),
+                            `${A.dim}Set: /manager config set <model|bridgeConfig|readScope|mirror|allow> <value>${A.reset}`,
+                            `${A.dim}The Manager always runs read-only regardless of model.${A.reset}`,
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (args.startsWith('config set ')) {
+                        const rest = args.slice('config set '.length).trim();
+                        const spIdx = rest.indexOf(' ');
+                        const key = spIdx === -1 ? rest : rest.slice(0, spIdx);
+                        const value = spIdx === -1 ? '' : rest.slice(spIdx + 1).trim();
+                        const cfg = await readManagerConfig(sdk.config.workDir, homeDir);
+                        if (key === 'model')
+                            cfg.model = value || undefined;
+                        else if (key === 'bridgeConfig' || key === 'config')
+                            cfg.bridgeConfig = value || undefined;
+                        else if (key === 'readScope') {
+                            if (value !== 'workspace-only' && value !== 'workspace+docs' && value !== 'explicit-allowlist' && value !== 'full-access') {
+                                appendStatic([...formatErrorLine('readScope must be workspace-only | workspace+docs | explicit-allowlist | full-access'), '']);
+                                return;
+                            }
+                            cfg.readScope = value;
+                        }
+                        else if (key === 'mirror')
+                            cfg.mirrorProgressToWorkspace = value === 'on' || value === 'true';
+                        else if (key === 'allow')
+                            cfg.allowedReadPaths = value ? value.split(',').map((p) => p.trim()).filter(Boolean) : [];
+                        else {
+                            appendStatic([...formatErrorLine('usage: /manager config set <model|bridgeConfig|readScope|mirror|allow> <value>'), '']);
+                            return;
+                        }
+                        await writeManagerConfig(sdk.config.workDir, homeDir, cfg);
+                        appendStatic([...formatInfoLine(`Manager config updated: ${key}`), '']);
+                        return;
+                    }
+                    if (args === 'schedule') {
+                        const tasks = (await listScheduledAutomationTasks(sdk.config.workDir)).filter((task) => task.kind === 'manager');
+                        appendStatic([
+                            `${A.bold}Manager schedules${A.reset}`,
+                            ...(tasks.length === 0
+                                ? [`${A.dim}none — add kind:"manager" tasks to .actoviq/scheduled-tasks.json${A.reset}`]
+                                : tasks.map((task) => `${A.cyan}${task.name}${A.reset}${A.dim} · ${task.cron} · ${task.enabled ? 'enabled' : 'paused'}${A.reset}`)),
+                            '',
+                        ]);
+                        return;
+                    }
+                    const isUpdate = args === 'update' || args.startsWith('update ');
+                    const isChat = args === 'chat' || args.startsWith('chat ');
+                    if (isUpdate || isChat) {
+                        const arg = isUpdate
+                            ? (args === 'update' ? '' : args.slice('update'.length).trim())
+                            : args.slice('chat'.length).trim();
+                        if (isChat && !arg) {
+                            appendStatic([...formatErrorLine('usage: /manager chat <message>'), '']);
+                            return;
+                        }
+                        if (isUpdate)
+                            appendStatic([...formatInfoLine('Manager: updating progress documents…'), '']);
+                        try {
+                            const cfg = await readManagerConfig(sdk.config.workDir, homeDir);
+                            const managerTools = await createManagerTools({ workDir: sdk.config.workDir, homeDir, config: cfg });
+                            let prompt;
+                            if (isUpdate) {
+                                // Host-collected context — the Manager itself has no shell.
+                                let gitSummary = '';
+                                try {
+                                    const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: sdk.config.workDir, encoding: 'utf8' }).trim();
+                                    const dirty = execSync('git status --porcelain', { cwd: sdk.config.workDir, encoding: 'utf8' }).trim();
+                                    const log = execSync('git log --oneline -10', { cwd: sdk.config.workDir, encoding: 'utf8' }).trim();
+                                    gitSummary = `branch: ${branch}\ndirty files: ${dirty ? dirty.split('\n').length : 0}\nrecent commits:\n${log}`;
+                                }
+                                catch { /* not a git repo */ }
+                                const stored = await sdk.sessions.list();
+                                const conversationSummaries = stored
+                                    .filter((s) => s.kind !== 'manager')
+                                    .slice(0, 20)
+                                    .map((s) => `- [${s.updatedAt.slice(0, 10)}] ${s.title} (${s.messageCount} msgs): ${s.preview}`)
+                                    .join('\n');
+                                const plan = await readProjectPlanFile(sdk.config.workDir, homeDir);
+                                const progress = await readProgressFile(sdk.config.workDir, homeDir);
+                                appendStatic([...formatInfoLine(formatManagerUpdatePreview(plan, progress).split('\n').slice(0, 2).join(' · ')), '']);
+                                const githubDigest = await resolveGitHubDigestForUpdate(sdk.config.workDir, arg || undefined);
+                                prompt = buildUpdateProgressPrompt({
+                                    instruction: arg || undefined,
+                                    gitSummary,
+                                    conversationSummaries,
+                                    githubDigest,
+                                    currentPlanJson: JSON.stringify(plan, null, 2),
+                                    currentProgress: progress ?? undefined,
+                                });
+                            }
+                            else {
+                                prompt = arg;
+                            }
+                            managerTuiSession = await resolveManagerTuiSession();
+                            try {
+                                const compactResult = await managerTuiSession.compact({});
+                                if (compactResult.compacted) {
+                                    appendStatic([...formatInfoLine(`manager compacted ${compactResult.messagesRemoved ?? '?'} older messages`), '']);
+                                }
+                            }
+                            catch { /* auto-compact is best-effort */ }
+                            const runOptions = {
+                                systemPrompt: buildManagerSystemPrompt(sdk.config.workDir, cfg),
+                                tools: managerTools,
+                                ...(cfg.model ? { model: cfg.model } : {}),
+                                __actoviqUseDefaultTools: false,
+                                __actoviqAllowedTools: managerTools.map((tool) => tool.name),
+                            };
+                            const stream = managerTuiSession.stream(prompt, runOptions);
+                            for await (const event of stream) {
+                                if (event.type === 'tool.call')
+                                    appendStatic([`${A.dim}  ⚡ ${event.call.name}${A.reset}`]);
+                            }
+                            const result = await stream.result;
+                            if (result.text)
+                                appendStatic([...renderRichText(result.text, screen.width), '']);
+                            if (isUpdate)
+                                appendStatic([...formatInfoLine(`progress updated · ${managerProgressPath(sdk.config.workDir, homeDir)}`), '']);
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(`manager error: ${error.message}`), '']);
+                        }
+                        return;
+                    }
+                    appendStatic([...formatErrorLine('usage: /manager [status|chat <message>|update [instruction]|config|schedule]'), '']);
+                    return;
+                }
                 default:
                     appendStatic([...formatErrorLine(`unknown command: /${name} — type /help`), '']);
                     return;
@@ -3133,7 +3558,7 @@ export async function runActoviqTui(options = {}) {
                 renderDynamic();
                 return;
             }
-            queuedInputs.push(text);
+            session.steer(text);
             appendStatic(formatQueuedPrompt(text));
             renderDynamic();
             return;