actoviq-agent-sdk 0.4.6 → 0.4.7

package/dist/src/cli/actoviq-react.js

@@ -6,9 +6,11 @@
  * and real-time streaming output. Uses the main terminal buffer for
  * native scrollback.
  */
-import { createAgentSdk, loadJsonConfigFile, loadDefaultActoviqSettings, createActoviqCoreTools, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, createModelTeam, WorktreeService, } from 'actoviq-agent-sdk';
+import { createAgentSdk, loadJsonConfigFile, loadDefaultActoviqSettings, getLoadedJsonConfig, createActoviqCoreTools, 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, transitionProjectIssue, WorktreeService, } from 'actoviq-agent-sdk';
+import { readProjectMeta } from '../gui/projectMeta.js';
+import { LegacySurfaceEventPipeline, } from '../surfaces/index.js';
+import { applyTeamRunEvent, createTeamRunViewState, formatTeamRunTreeLines } from '../team/teamRunView.js';
 import { execSync } from 'node:child_process';
-import os from 'node:os';
 import path from 'node:path';
 import * as readline from 'node:readline';
 import { hasVersionFlag, readPackageVersion } from './version.js';
@@ -17,7 +19,7 @@ if (hasVersionFlag(process.argv.slice(2))) {
     process.exit(0);
 }
 const WORK_DIR = path.resolve(process.argv[2] ?? process.cwd());
-const CONFIG_PATH = process.argv[3] ?? path.join(os.homedir(), '.actoviq', 'settings.json');
+const CONFIG_PATH = process.argv[3] ?? path.join(resolveActoviqHome(), 'settings.json');
 const DEFAULT_PERMISSION_MODE = 'bypassPermissions';
 const PERMISSION_MODES = new Set([
     'default',
@@ -40,6 +42,17 @@ const C = {
 function stripAnsi(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, '').length;
 }
+function surfaceRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function surfaceString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function surfaceInteger(value) {
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
 // ── System prompt ────────────────────────────────────────────────────
 const SYSTEM_PROMPT = `You are Actoviq, an interactive CLI agent. Working directory: ${WORK_DIR}\n\n` +
     `<env>\nWorking directory: ${WORK_DIR}\nIs git repo: ${isGit ? 'Yes' : 'No'}\nPlatform: ${process.platform}\nDate: ${new Date().toISOString().slice(0, 10)}\n</env>\n\n` +
@@ -74,7 +87,9 @@ const CMDS = {
     dream: 'Trigger memory consolidation',
     workflows: 'List or run dynamic workflows',
     worktree: 'Enter, exit, or list git worktrees',
-    team: 'List or query Model Teams',
+    team: 'List, attach, or run Model Teams',
+    issues: 'List or update project issues',
+    manager: 'Project Manager: progress docs + status',
 };
 function completer(line) {
     if (!line.startsWith('/'))
@@ -145,6 +160,54 @@ async function main() {
     process.stdout.write(`${C.c}├${'─'.repeat(Math.min(w - 2, 60))}┤${C.r}\n\n`);
     let abortCtrl = null;
     let msgCount = 0;
+    // Persistent Manager session (kind: 'manager') — reused across /manager
+    // update/chat turns so the Manager keeps its own conversation context.
+    let managerSession = null;
+    // ── Team state (Phase 0: attach / autoInvoke / status) ─────────
+    const teamPrefs = readTeamPreferences(getLoadedJsonConfig()?.raw);
+    let activeTeamTool = null;
+    let activeTeamName = null;
+    let lastTeamRunSummary = null;
+    const attachTeam = (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) {
+        // Silently ignore unresolvable names; /team status surfaces the hint.
+        try {
+            attachTeam(teamPrefs.defaultAttached);
+        }
+        catch { /* ignore */ }
+    }
+    async function resolveManagerSession() {
+        if (managerSession)
+            return managerSession;
+        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) {
+            managerSession = await sdk.resumeSession(existing.id, { permissionMode: DEFAULT_PERMISSION_MODE });
+            return managerSession;
+        }
+        managerSession = await sdk.createSession({
+            title: 'Manager',
+            metadata: { __actoviqKind: 'manager' },
+            permissionMode: DEFAULT_PERMISSION_MODE,
+        });
+        return managerSession;
+    }
     // ── Process message ────────────────────────────────────────────
     async function processMsg(text) {
         const t = text.trim();
@@ -202,7 +265,7 @@ async function main() {
                         process.stdout.write(`${C.d}No stored sessions.${C.r}\n\n`);
                         return;
                     }
-                    for (const stored of sessions) {
+                    for (const stored of sessions.filter(item => item.kind !== 'manager')) {
                         const current = stored.id === session.id ? '*' : ' ';
                         process.stdout.write(`${C.d}${current} ${stored.id}  ${stored.title}  ${stored.model}${C.r}\n`);
                     }
@@ -215,6 +278,12 @@ async function main() {
                         process.stdout.write(`${C.R}Usage: /resume <session-id>${C.r}\n\n`);
                         return;
                     }
+                    const listed = await sdk.sessions.list();
+                    const target = listed.find(item => item.id === sessionId);
+                    if (target?.kind === 'manager') {
+                        process.stdout.write(`${C.R}Manager sessions live in the Project Manager panel only.${C.r}\n\n`);
+                        return;
+                    }
                     session = await sdk.resumeSession(sessionId);
                     process.stdout.write(`${C.g}Resumed ${session.id}: ${session.title} (${session.model})${C.r}\n\n`);
                     return;
@@ -286,6 +355,7 @@ async function main() {
                             const { WorkflowScriptRuntime } = await import('../workflow/workflowScriptRuntime.js');
                             const runtime = new WorkflowScriptRuntime({
                                 sdk: sdk,
+                                trust: 'trusted',
                                 args: wfTask,
                                 onEvent: (e) => {
                                     if (e.type === 'workflow.log')
@@ -364,17 +434,55 @@ async function main() {
                 }
                 // ── v0.5.0: Model Team ─────────────────────────────────────
                 case 'team': {
-                    const sub = t.slice(sp + 1).trim();
+                    const sub = sp === -1 ? '' : t.slice(sp + 1).trim();
                     if (!sub || sub === 'list') {
                         const teams = listTeamDefinitions(sdk.config.workDir);
-                        if (teams.length === 0) {
-                            process.stdout.write(`${C.d}No saved team definitions. Save JSON files to .actoviq/teams/${C.r}\n\n`);
+                        for (const item of teams) {
+                            const active = item.name === activeTeamName ? `${C.g}*${C.r}` : ' ';
+                            process.stdout.write(`${active}${C.c}${item.name}${C.r}${C.d} · ${item.definition.mode} · ${item.source} · ${countTeamAgents(item.definition)} agents${C.r}\n`);
                         }
-                        else {
-                            for (const t of teams) {
-                                process.stdout.write(`${C.c}${t.name}${C.r}${C.d} · ${t.definition.mode} · ${t.source} · ${t.definition.members?.length ?? 0} members${C.r}\n`);
-                            }
-                            process.stdout.write('\n');
+                        process.stdout.write(`${C.d}\n/team attach <name> · /team ask <name> <prompt> · /team off · /team status${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub === 'status') {
+                        const lines = [
+                            `attached: ${activeTeamName ?? 'none'}`,
+                            `autoInvoke: ${teamPrefs.autoInvoke ? 'on (main agent can call the team as a tool)' : 'off (manual /team ask only)'}`,
+                            `defaultAttached: ${teamPrefs.defaultAttached ?? 'none'}` +
+                                (teamPrefs.defaultAttached && !activeTeamName ? ` ${C.y}(not found)${C.r}` : ''),
+                            `last run: ${lastTeamRunSummary ?? 'none'}`,
+                        ];
+                        process.stdout.write(`${C.d}${lines.join('\n')}${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub === 'off') {
+                        activeTeamTool = null;
+                        activeTeamName = null;
+                        process.stdout.write(`${C.d}team: none${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub.startsWith('attach ')) {
+                        const teamName = sub.slice(7).trim();
+                        const definition = attachTeam(teamName);
+                        if (!definition) {
+                            process.stdout.write(`${C.R}Team not found: ${teamName}${C.r}\n\n`);
+                            return;
+                        }
+                        process.stdout.write(`${C.g}team attached: ${definition.name}${C.r}${C.d} (${definition.mode}) · autoInvoke ${teamPrefs.autoInvoke ? 'on' : 'off — run /team ask to use it'}${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub.startsWith('clone ')) {
+                        const parts = sub.slice(6).trim().split(/\s+/);
+                        if (parts.length !== 2) {
+                            process.stdout.write(`${C.R}Usage: /team clone <source> <new-name>${C.r}\n\n`);
+                            return;
+                        }
+                        try {
+                            const clone = await cloneTeamDefinition(parts[0], parts[1], { projectDir: sdk.config.workDir });
+                            process.stdout.write(`${C.g}team cloned: ${parts[0]} → ${clone.name}${C.r}${C.d} (${clone.filePath})${C.r}\n\n`);
+                        }
+                        catch (e) {
+                            process.stdout.write(`${C.R}✕ Clone failed: ${e.message}${C.r}\n\n`);
                         }
                         return;
                     }
@@ -392,10 +500,33 @@ async function main() {
                             process.stdout.write(`${C.R}Team not found: ${teamName}${C.r}\n\n`);
                             return;
                         }
-                        process.stdout.write(`${C.d}Asking team "${teamName}" (${loaded.definition.mode})...${C.r}\n`);
+                        const definition = instantiateTeamDefinition(loaded.definition, session.model);
+                        const memberModels = listTeamAgentLabels(definition);
+                        process.stdout.write(`${C.d}Asking team "${teamName}" (${definition.mode})...${C.r}\n`);
                         try {
-                            const team = createModelTeam(loaded.definition);
-                            const result = await team.ask(prompt);
+                            const team = createModelTeam(definition);
+                            const teamRunView = createTeamRunViewState(definition.name);
+                            const printTeamRunTree = () => {
+                                for (const line of formatTeamRunTreeLines(teamRunView)) {
+                                    process.stdout.write(`${C.d}${line}${C.r}\n`);
+                                }
+                            };
+                            const result = await team.ask(prompt, undefined, {
+                                workDir: sdk.config.workDir,
+                                onEvent: (e) => {
+                                    applyTeamRunEvent(teamRunView, e);
+                                    if (e.type === 'team.synthesis') {
+                                        process.stdout.write(`${C.d}  ◈ synthesis round ${e.round}: ${e.decision}${C.r}\n`);
+                                    }
+                                    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`;
                             process.stdout.write(`${C.g}✓ Response${C.r}${C.d} · ${result.mode} · ${Math.round(result.durationMs / 1000)}s${C.r}\n`);
                             if (result.cost.estimatedCost !== null) {
                                 process.stdout.write(`${C.d}  cost: $${result.cost.estimatedCost.toFixed(4)} · ${result.cost.totalInputTokens + result.cost.totalOutputTokens} tokens${C.r}\n`);
@@ -407,7 +538,272 @@ async function main() {
                         }
                         return;
                     }
-                    process.stdout.write(`${C.d}Usage: /team [list|ask <name> <prompt>]${C.r}\n\n`);
+                    process.stdout.write(`${C.d}Usage: /team [list|attach <name>|off|ask <name> <prompt>|clone <source> <new>|status]${C.r}\n\n`);
+                    return;
+                }
+                // Project issues
+                case 'issues': {
+                    const sub = sp === -1 ? '' : t.slice(sp + 1).trim();
+                    const homeDir = sdk.config.homeDir;
+                    const meta = await readProjectMeta(WORK_DIR, homeDir);
+                    const storage = isIssueStorageMode(meta.issueStorage) ? meta.issueStorage : 'home';
+                    if (!sub || sub === 'list') {
+                        const issues = await listProjectIssues(WORK_DIR, homeDir, storage);
+                        if (issues.length === 0) {
+                            process.stdout.write(`${C.d}No issues yet. Use /issues create <title>${C.r}\n\n`);
+                            return;
+                        }
+                        process.stdout.write(`${C.b}Issues (${storage})${C.r}\n`);
+                        for (const issue of issues) {
+                            process.stdout.write(`#${issue.number} ${issue.title} ${C.d}${issue.status} · ${issue.priority}${C.r}\n`);
+                        }
+                        process.stdout.write('\n');
+                        return;
+                    }
+                    if (sub.startsWith('create ')) {
+                        const title = sub.slice(7).trim();
+                        if (!title) {
+                            process.stdout.write(`${C.R}Usage: /issues create <title>${C.r}\n\n`);
+                            return;
+                        }
+                        const issue = await createProjectIssue(WORK_DIR, homeDir, { title }, storage);
+                        process.stdout.write(`${C.g}issue created: #${issue.number} ${issue.title}${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub.startsWith('show ')) {
+                        const rawId = sub.slice(5).trim().replace(/^#/, '');
+                        const issues = await listProjectIssues(WORK_DIR, homeDir, storage);
+                        const issue = issues.find(candidate => candidate.id === rawId ||
+                            String(candidate.number) === rawId ||
+                            `ISS-${candidate.number}` === rawId.toUpperCase());
+                        if (!issue) {
+                            process.stdout.write(`${C.R}Issue not found: ${rawId}${C.r}\n\n`);
+                            return;
+                        }
+                        process.stdout.write(`${C.b}ISS-${issue.number} ${issue.title}${C.r}\n` +
+                            `${C.d}${issue.status} · ${issue.priority}${C.r}\n` +
+                            `${issue.description || '(no description)'}\n` +
+                            `${issue.acceptanceCriteria.length ? `\nAcceptance criteria:\n${issue.acceptanceCriteria.map(item => `- ${item}`).join('\n')}` : ''}` +
+                            `${issue.brief ? `\n\nManager brief:\n${issue.brief}` : ''}\n\n`);
+                        return;
+                    }
+                    if (sub.startsWith('start ')) {
+                        const [, rawId, agentProfile] = sub.split(/\s+/, 3);
+                        const id = rawId?.replace(/^#/, '');
+                        const issues = await listProjectIssues(WORK_DIR, homeDir, storage);
+                        const issue = issues.find(candidate => candidate.id === id ||
+                            String(candidate.number) === id ||
+                            `ISS-${candidate.number}` === id?.toUpperCase());
+                        if (!issue) {
+                            process.stdout.write(`${C.R}Issue not found: ${rawId ?? ''}${C.r}\n\n`);
+                            return;
+                        }
+                        process.stdout.write(`${C.d}Decomposing and dispatching ISS-${issue.number}...${C.r}\n`);
+                        const dispatched = await executeProjectIssue({
+                            sdk,
+                            managerSession: await resolveManagerSession(),
+                            workDir: WORK_DIR,
+                            homeDir,
+                            storageMode: storage,
+                            issue,
+                            agentProfile,
+                            defaultModel: session.model,
+                            permissionMode: session.permissionContext.mode ?? DEFAULT_PERMISSION_MODE,
+                            systemPrompt: SYSTEM_PROMPT,
+                            onEvent: event => {
+                                if (event.type === 'response.text.delta')
+                                    process.stdout.write(event.delta);
+                                else if (event.type === 'tool.call')
+                                    toolLine(event.call.name, event.call.input);
+                                else if (event.type === 'tool.result')
+                                    resultLine(event.result.isError, event.result.durationMs, event.result.output);
+                            },
+                        });
+                        session = dispatched.session;
+                        process.stdout.write(`\n${C.g}ISS-${dispatched.issue.number}: ${dispatched.issue.status} · session ${session.id}${C.r}\n\n`);
+                        return;
+                    }
+                    const transitions = {
+                        review: 'in_review',
+                        done: 'done',
+                        block: 'blocked',
+                    };
+                    const [verb, rawId] = sub.split(/\s+/, 2);
+                    const nextStatus = transitions[verb ?? ''];
+                    if (nextStatus && isIssueStatus(nextStatus) && rawId) {
+                        const issue = await transitionProjectIssue(WORK_DIR, homeDir, rawId.replace(/^#/, ''), nextStatus, 'user', storage);
+                        if (!issue)
+                            process.stdout.write(`${C.R}Issue not found: ${rawId}${C.r}\n\n`);
+                        else
+                            process.stdout.write(`${C.g}issue #${issue.number}: ${issue.status}${C.r}\n\n`);
+                        return;
+                    }
+                    process.stdout.write(`${C.d}Usage: /issues [list|show <id>|create <title>|start <id> [agent-profile]|review <id>|done <id>|block <id>]${C.r}\n\n`);
+                    return;
+                }
+                // ── Project Manager ────────────────────────────────────────
+                case 'manager': {
+                    const sub = sp === -1 ? '' : t.slice(sp + 1).trim();
+                    const homeDir = sdk.config.homeDir;
+                    if (!sub || sub === 'status') {
+                        const cfg = await readManagerConfig(WORK_DIR, homeDir);
+                        const plan = await readProjectPlanFile(WORK_DIR, homeDir);
+                        const progress = await readProgressFile(WORK_DIR, homeDir);
+                        const lines = [
+                            `model: ${cfg.model ?? session.model + ' (session default)'}`,
+                            `readScope: ${cfg.readScope}`,
+                            `mirror to workspace: ${cfg.mirrorProgressToWorkspace ? 'on' : 'off'}`,
+                            `plan.json: ${plan.milestones.length} milestones · ${plan.today.length} today · ${plan.upcoming.length} upcoming`,
+                            `PROGRESS.md: ${progress ? `${progress.length} chars · ${managerProgressPath(WORK_DIR, homeDir)}` : '(none yet — /manager update)'}`,
+                        ];
+                        process.stdout.write(`${C.b}Manager${C.r}\n${C.d}${lines.join('\n')}${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub === 'config') {
+                        const cfg = await readManagerConfig(WORK_DIR, homeDir);
+                        process.stdout.write(`${C.d}${JSON.stringify(cfg, null, 2)}\nSet: /manager config set <model|bridgeConfig|readScope|mirror|allow> <value>\nThe Manager always runs read-only regardless of model.${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub.startsWith('config set ')) {
+                        const rest = sub.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(WORK_DIR, 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') {
+                                process.stdout.write(`${C.R}readScope must be workspace-only | workspace+docs | explicit-allowlist | full-access${C.r}\n\n`);
+                                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 {
+                            process.stdout.write(`${C.R}usage: /manager config set <model|bridgeConfig|readScope|mirror|allow> <value>${C.r}\n\n`);
+                            return;
+                        }
+                        await writeManagerConfig(WORK_DIR, homeDir, cfg);
+                        process.stdout.write(`${C.g}✓ Manager config updated: ${key}${C.r}\n\n`);
+                        return;
+                    }
+                    if (sub === 'schedule') {
+                        const tasks = (await listScheduledAutomationTasks(WORK_DIR)).filter(task => task.kind === 'manager');
+                        if (tasks.length === 0) {
+                            process.stdout.write(`${C.d}No manager schedules. Add kind:"manager" tasks to .actoviq/scheduled-tasks.json${C.r}\n\n`);
+                            return;
+                        }
+                        for (const task of tasks) {
+                            process.stdout.write(`${C.c}${task.name}${C.r}${C.d} · ${task.cron} · ${task.enabled ? 'enabled' : 'paused'}${C.r}\n`);
+                        }
+                        process.stdout.write('\n');
+                        return;
+                    }
+                    const isUpdate = sub === 'update' || sub.startsWith('update ');
+                    const isChat = sub === 'chat' || sub.startsWith('chat ');
+                    if (isUpdate || isChat) {
+                        const arg = isUpdate
+                            ? (sub === 'update' ? '' : sub.slice('update'.length).trim())
+                            : sub.slice('chat'.length).trim();
+                        if (isChat && !arg) {
+                            process.stdout.write(`${C.d}Usage: /manager chat <message>${C.r}\n\n`);
+                            return;
+                        }
+                        if (isUpdate)
+                            process.stdout.write(`${C.d}Manager: updating progress documents...${C.r}\n`);
+                        try {
+                            const cfg = await readManagerConfig(WORK_DIR, homeDir);
+                            const managerTools = await createManagerTools({ workDir: WORK_DIR, 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: WORK_DIR, encoding: 'utf8' }).trim();
+                                    const dirty = execSync('git status --porcelain', { cwd: WORK_DIR, encoding: 'utf8' }).trim();
+                                    const log = execSync('git log --oneline -10', { cwd: WORK_DIR, 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(WORK_DIR, homeDir);
+                                const progress = await readProgressFile(WORK_DIR, homeDir);
+                                process.stdout.write(`${C.d}${formatManagerUpdatePreview(plan, progress).split('\n').slice(0, 2).join('\n')}${C.r}\n`);
+                                const githubDigest = await resolveGitHubDigestForUpdate(WORK_DIR, arg || undefined);
+                                prompt = buildUpdateProgressPrompt({
+                                    instruction: arg || undefined,
+                                    gitSummary,
+                                    conversationSummaries,
+                                    githubDigest,
+                                    currentPlanJson: JSON.stringify(plan, null, 2),
+                                    currentProgress: progress ?? undefined,
+                                });
+                            }
+                            else {
+                                prompt = arg;
+                            }
+                            managerSession = await resolveManagerSession();
+                            try {
+                                const compactResult = await managerSession.compact({});
+                                if (compactResult.compacted) {
+                                    process.stdout.write(`${C.d}Manager: compacted ${compactResult.messagesRemoved ?? '?'} older messages${C.r}\n`);
+                                }
+                            }
+                            catch { /* auto-compact is best-effort */ }
+                            abortCtrl = new AbortController();
+                            const runOptions = {
+                                systemPrompt: buildManagerSystemPrompt(WORK_DIR, cfg),
+                                tools: managerTools,
+                                signal: abortCtrl.signal,
+                                ...(cfg.model ? { model: cfg.model } : {}),
+                                __actoviqUseDefaultTools: false,
+                                __actoviqAllowedTools: managerTools.map(tool => tool.name),
+                            };
+                            const stream = managerSession.stream(prompt, runOptions);
+                            const managerSurfaceEvents = new LegacySurfaceEventPipeline();
+                            for await (const event of stream) {
+                                for (const surfaceEvent of managerSurfaceEvents.projectFor(event, 'cli')) {
+                                    const data = surfaceEvent.data;
+                                    if (surfaceEvent.type === 'tool.started') {
+                                        toolLine(surfaceString(data.name) ?? surfaceString(data.publicName) ?? 'tool', surfaceRecord(data.input) ?? {});
+                                    }
+                                    else if (surfaceEvent.type === 'tool.completed'
+                                        || surfaceEvent.type === 'tool.failed'
+                                        || surfaceEvent.type === 'tool.rejected') {
+                                        resultLine(data.isError === true, undefined, data.output);
+                                    }
+                                }
+                            }
+                            const result = await stream.result;
+                            if (result.text)
+                                process.stdout.write(`${result.text}\n`);
+                            if (isUpdate) {
+                                process.stdout.write(`${C.g}✓ Progress updated${C.r}${C.d} · ${managerProgressPath(WORK_DIR, homeDir)}${C.r}\n\n`);
+                            }
+                            else {
+                                process.stdout.write('\n');
+                            }
+                        }
+                        catch (e) {
+                            process.stdout.write(`${C.R}✕ Manager error: ${e.message}${C.r}\n\n`);
+                        }
+                        finally {
+                            abortCtrl = null;
+                        }
+                        return;
+                    }
+                    process.stdout.write(`${C.d}Usage: /manager [status|chat <message>|update [instruction]|config|schedule]${C.r}\n\n`);
                     return;
                 }
                 default:
@@ -421,52 +817,71 @@ async function main() {
             signal: abortCtrl.signal,
             model: session.model,
             permissionMode: session.permissionContext.mode ?? DEFAULT_PERMISSION_MODE,
+            // Attached team is only exposed to the main agent when autoInvoke is on;
+            // otherwise attach is a selection and /team ask stays the manual path.
+            ...(activeTeamTool && teamPrefs.autoInvoke ? { tools: [activeTeamTool] } : {}),
         });
         let iteration = 0;
         let hasText = false;
         const activeTools = new Map();
+        const surfaceEvents = new LegacySurfaceEventPipeline();
         for await (const event of stream) {
-            switch (event.type) {
-                case 'request.started':
-                    iteration = event.iteration;
-                    if (iteration > 1)
-                        process.stdout.write(`\n${C.d}── iteration ${iteration} ──${C.r}\n`);
-                    break;
-                case 'response.text.delta': {
-                    const txt = typeof event.delta === 'string' ? event.delta : event.delta?.text ?? '';
-                    process.stdout.write(txt);
-                    hasText = true;
-                    break;
-                }
-                case 'response.content':
-                    if (event.content.type === 'thinking') {
-                        const th = (event.content.thinking ?? '').slice(0, 250);
-                        process.stdout.write(`\n${C.d}💭 ${th}${C.r}\n`);
-                    }
-                    break;
-                case 'tool.call': {
-                    activeTools.set(event.call.id, { name: event.call.name, start: Date.now() });
-                    toolLine(event.call.name, event.call.input);
-                    break;
-                }
-                case 'tool.progress': {
-                    const p = event.data;
-                    if (p?.message)
-                        process.stdout.write(`\r\x1b[K${C.d}     ${p.message}${C.r}`);
-                    break;
-                }
-                case 'tool.result': {
-                    const info = activeTools.get(event.result.id);
-                    activeTools.delete(event.result.id);
-                    resultLine(event.result.isError, info ? Date.now() - info.start : undefined, event.result.output);
-                    break;
+            for (const surfaceEvent of surfaceEvents.projectFor(event, 'cli')) {
+                const data = surfaceEvent.data;
+                switch (surfaceEvent.type) {
+                    case 'request.started':
+                        iteration = surfaceInteger(data.iteration) ?? iteration;
+                        if (iteration > 1)
+                            process.stdout.write(`\n${C.d}── iteration ${iteration} ──${C.r}\n`);
+                        break;
+                    case 'text.delta': {
+                        const txt = surfaceString(data.delta) ?? '';
+                        process.stdout.write(txt);
+                        hasText = true;
+                        break;
+                    }
+                    case 'model.content': {
+                        const content = surfaceRecord(data.content);
+                        if (data.kind === 'content' && content?.type === 'thinking') {
+                            const th = (surfaceString(content.thinking) ?? '').slice(0, 250);
+                            process.stdout.write(`\n${C.d}💭 ${th}${C.r}\n`);
+                        }
+                        break;
+                    }
+                    case 'tool.started': {
+                        const callId = surfaceString(data.callId);
+                        const name = surfaceString(data.name) ?? surfaceString(data.publicName) ?? 'tool';
+                        if (callId)
+                            activeTools.set(callId, { name, start: Date.now() });
+                        toolLine(name, surfaceRecord(data.input) ?? {});
+                        break;
+                    }
+                    case 'tool.progress': {
+                        const message = surfaceString(data.message)
+                            ?? surfaceString(surfaceRecord(data.progress)?.message);
+                        if (message)
+                            process.stdout.write(`\r\x1b[K${C.d}     ${message}${C.r}`);
+                        break;
+                    }
+                    case 'tool.completed':
+                    case 'tool.failed':
+                    case 'tool.rejected': {
+                        const callId = surfaceString(data.callId);
+                        const info = callId ? activeTools.get(callId) : undefined;
+                        if (callId)
+                            activeTools.delete(callId);
+                        resultLine(data.isError === true, info ? Date.now() - info.start : undefined, data.output);
+                        break;
+                    }
+                    case 'compaction.completed':
+                        process.stdout.write(`\n${C.d}── context compacted ──${C.r}\n`);
+                        break;
+                    case 'error':
+                        process.stdout.write(`\n${C.R}  ✕ ${surfaceString(data.message) ?? 'run failed'}${C.r}\n`);
+                        break;
+                    default:
+                        break;
                 }
-                case 'session.compacted':
-                    process.stdout.write(`\n${C.d}── context compacted ──${C.r}\n`);
-                    break;
-                case 'error':
-                    process.stdout.write(`\n${C.R}  ✕ ${event.error.message}${C.r}\n`);
-                    break;
             }
         }
         if (!hasText) {
@@ -529,15 +944,35 @@ async function main() {
     });
     rl.prompt();
     rl.on('line', async (line) => {
-        abortCtrl = null;
+        const queued = line.trim();
+        if (abortCtrl) {
+            if (!queued) {
+                rl.prompt();
+                return;
+            }
+            if (queued.startsWith('/')) {
+                process.stdout.write(`${C.d}Slash commands are unavailable while the agent is working.${C.r}\n`);
+                rl.prompt();
+                return;
+            }
+            session.steer(queued);
+            process.stdout.write(`${C.d}  ⧗ queued steering message${C.r}\n`);
+            rl.prompt();
+            return;
+        }
         try {
             await processMsg(line);
         }
         catch (e) {
-            if (e.name === 'AbortError')
+            if (e.name === 'AbortError' || e.name === 'RunAbortedError') {
                 process.stdout.write(`\n${C.y}  ⏹ aborted${C.r}\n`);
-            else
+            }
+            else {
                 process.stdout.write(`\n${C.R}  ✕ ${e.message}${C.r}\n`);
+            }
+        }
+        finally {
+            abortCtrl = null;
         }
         rl.prompt();
     });