zelari-code 0.4.3 → 0.7.5

package/dist/cli/hooks/useChatTurn.js

@@ -1,20 +1,27 @@
 // @ts-nocheck — pre-existing strict-mode type narrowing issues carried over
 // from app.tsx. Runtime is correct; tighten signatures in a follow-up.
-import { useState, useRef, useCallback } from 'react';
-import { AgentHarness } from '../../main/core/AgentHarness.js';
-import { getMetricsLogger } from '../metrics.js';
-import { openaiCompatibleProvider, providerFromEnv, providerConfigFor } from '../provider/openai-compatible.js';
-import { providerFailover } from '../providerFailover.js';
-import { resolveFailoverStream } from '../crossProviderFailover.js';
-import { PROVIDERS } from '../keyStore.js';
-import { createBuiltinToolRegistry } from '../toolRegistry.js';
-import { appendOrExtendStreamingAssistant, appendSystem, appendToolEnd, appendToolStart, updateToolMessageEnd, } from './messageHelpers.js';
-import { computeSessionStatsDelta } from './chatStats.js';
+import { useState, useRef, useCallback } from "react";
+import { AgentHarness } from "@zelari/core/harness";
+import { getMetricsLogger } from "../metrics.js";
+import { openaiCompatibleProvider, providerFromEnv, providerConfigFor, resolveActiveProvider, } from "../provider/openai-compatible.js";
+import { providerFailover } from "../providerFailover.js";
+import { resolveFailoverStream } from "../crossProviderFailover.js";
+import { resolveShell } from "@zelari/core/harness/tools/builtin/shellResolver";
+import { PROVIDERS } from "../keyStore.js";
+import { createBuiltinToolRegistry } from "../toolRegistry.js";
+import { appendOrExtendStreamingAssistant, appendSystem, appendToolStart, finalizeStreamingAssistant, updateToolMessageEnd, } from "./messageHelpers.js";
+import { setStreaming, finalizeStreaming, startTool, completeTool, } from "./chatState.js";
+import { computeSessionStatsDelta } from "./chatStats.js";
 export function useChatTurn(params) {
-    const { sessionId, writerRef, setMessages, setBusy, setSessionActive, setSessionStats } = params;
+    const { sessionId, writerRef, setMessages, commitStreaming, flushStreaming, setBusy, setSessionActive, setSessionStats, setLive, liveRef, } = params;
     const harnessRef = useRef(null);
     const [queueCount, setQueueCount] = useState(0);
-    const dispatchPrompt = useCallback(async (userText) => {
+    // v0.7.0: when the live region is wired, streaming + tool events route
+    // there; otherwise we fall back to the v0.6 single-array behavior so the
+    // existing unit tests (which pass only setMessages/commitStreaming) keep
+    // asserting on `messages` directly.
+    const useLiveModel = !!(setLive && liveRef);
+    const dispatchPrompt = useCallback(async (userText, opts) => {
         // v0.4.3 audit fix: provider resolution + harness construction now
         // live INSIDE the try block. Previously, throws from providerFromEnv,
         // resolveFailoverStream, or createBuiltinToolRegistry happened
@@ -27,14 +34,18 @@ export function useChatTurn(params) {
         try {
             envConfig = await providerFromEnv();
             if (!envConfig) {
-                appendSystem(setMessages, 'OPENAI_API_KEY not set. Export it before running zelari-code.');
+                // Name the ACTIVE provider — the old hardcoded "OPENAI_API_KEY not
+                // set" message told grok/glm/minimax users to export the wrong var.
+                const active = resolveActiveProvider();
+                const spec = PROVIDERS.find((p) => p.id === active);
+                appendSystem(setMessages, `No API key for the active provider "${active}". Set ${spec?.envVar ?? "the provider API key env var"} or run /login ${active}.`);
                 return;
             }
             setBusy(true);
             const { registry: toolRegistry } = createBuiltinToolRegistry();
             const baseProviderStream = openaiCompatibleProvider(envConfig);
             const failoverResolution = await resolveFailoverStream({
-                failoverEnabled: process.env.ANATHEMA_FAILOVER !== '0',
+                failoverEnabled: process.env.ANATHEMA_FAILOVER !== "0",
                 envValue: process.env.ANATHEMA_FAILOVER_PROVIDER,
                 primaryProviderId: envConfig.providerId,
                 primary: baseProviderStream,
@@ -43,7 +54,9 @@ export function useChatTurn(params) {
                 buildStream: (config) => openaiCompatibleProvider(config),
             });
             if (failoverResolution.warning) {
-                console.warn(failoverResolution.warning);
+                // Surface in the chat instead of console.warn: writes that bypass
+                // Ink force a full repaint of the TUI frame (visible flicker).
+                appendSystem(setMessages, `[failover] ${failoverResolution.warning}`);
             }
             const providerStream = failoverResolution.fallbackLabel
                 ? providerFailover({
@@ -56,13 +69,101 @@ export function useChatTurn(params) {
                     fallback: failoverResolution.fallback,
                 });
             const cwd = process.cwd();
+            // v0.7.3: surface the council plan (if any) to the single agent too.
+            // The plan lives in .zelari/plan.json but the agent had no idea it
+            // existed — users had to paste task-file paths by hand. Best-effort:
+            // no plan → null → zero prompt-token cost.
+            let planSummary = null;
+            // v0.7.4: give the single agent the same project awareness the council
+            // has (tech stack, file layout, scripts) plus a pointer to the council
+            // workspace so it reads .zelari/plan.json with its own tools.
+            let workspaceSummary = null;
+            let zelariReadHint = '';
+            try {
+                const { buildPlanSummary, buildWorkspaceSummary, buildZelariReadHint } = await import('../workspace/workspaceSummary.js');
+                planSummary = buildPlanSummary(cwd);
+                workspaceSummary = buildWorkspaceSummary(cwd);
+                zelariReadHint = buildZelariReadHint(cwd);
+                // v0.7.4: close the plan loop. The single agent implements the tasks
+                // the council planned, but had no official way to advance their
+                // status — it would have to hand-edit plan.json with write_file
+                // (racy, no validation). Register the workspace `updateTask` stub so
+                // status changes go through the same mutex + atomic plan.json write
+                // the council uses. Only when a plan exists: fresh projects don't pay
+                // the extra tool-schema prompt tokens.
+                // v0.7.5: also register any workspace stubs a /skill invocation
+                // requires (opts.requiredTools), mapping the Electron-era `searchRAG`
+                // to the CLI's `searchDocuments`.
+                const wantedWorkspaceTools = new Set();
+                if (planSummary)
+                    wantedWorkspaceTools.add('updateTask');
+                const WORKSPACE_STUB_NAMES = new Set([
+                    'createPhase', 'createTask', 'updateTask', 'addIdea', 'createMilestone',
+                    'createDocument', 'searchDocuments', 'linkDocuments', 'getDocumentBacklinks',
+                ]);
+                for (const raw of opts?.requiredTools ?? []) {
+                    const name = raw === 'searchRAG' ? 'searchDocuments' : raw;
+                    if (WORKSPACE_STUB_NAMES.has(name))
+                        wantedWorkspaceTools.add(name);
+                }
+                if (wantedWorkspaceTools.size > 0) {
+                    const { createWorkspaceContext } = await import('../workspace/stubs.js');
+                    const { createWorkspaceToolRegistry } = await import('../workspace/toolRegistry.js');
+                    const wsRegistry = createWorkspaceToolRegistry(createWorkspaceContext(cwd));
+                    for (const name of wantedWorkspaceTools) {
+                        const td = wsRegistry.get(name);
+                        if (td)
+                            toolRegistry.register(td);
+                    }
+                }
+                // v0.7.5: MCP tools. Discovery runs once per process (lazy singleton);
+                // per-turn cost after that is just re-registering into the fresh
+                // registry. Disabled with ZELARI_MCP=0. Best-effort like the rest.
+                try {
+                    const { registerMcpTools } = await import('../mcp/mcpManager.js');
+                    const mcp = await registerMcpTools(toolRegistry, cwd);
+                    for (const w of mcp.warnings)
+                        appendSystem(setMessages, w);
+                }
+                catch {
+                    // MCP is an enhancement — a broken server config must not block prompts.
+                }
+            }
+            catch {
+                // Plan summary is a nice-to-have — never block a prompt on it.
+            }
+            // NOTE: computed AFTER the workspace wiring so updateTask (when
+            // registered) is advertised in the # Available Tools section too.
             const toolList = toolRegistry.toOpenAITools().map((t) => `- ${t.function.name}: ${t.function.description}`).join('\n');
+            // v0.7.2 (C3): platform-aware shell guidance. The model must know which
+            // shell the `bash` tool actually runs in so it writes the right commands
+            // (POSIX for Git Bash, Windows-native for cmd.exe fallback).
+            const resolvedShell = resolveShell();
+            const isWindows = process.platform === 'win32';
+            const shellGuidance = resolvedShell.isBash
+                ? `The bash tool runs commands via Git Bash / MSYS2 (${resolvedShell.shell}). Write POSIX commands: ls, grep, $VAR, &&, /c/Users/... all work.`
+                : isWindows
+                    ? `The bash tool runs commands via cmd.exe (Git Bash not found). Write Windows-native commands: use dir (not ls), %VAR% (not $VAR), avoid POSIX-only syntax.`
+                    : `The bash tool runs commands via /bin/sh.`;
+            // v0.7.3: the shell has NO interactive stdin. Without this warning the
+            // model retried `npm create vite` four times against the interactive
+            // prompt ("Operation cancelled") and then gave up asking the user.
+            const nonInteractiveGuidance = 'The shell is NON-INTERACTIVE (stdin closed): commands that prompt for input fail immediately. ' +
+                'Always pass non-interactive flags (--yes, -y, --template, --force). ' +
+                'If a scaffolder still insists on prompting (e.g. `npm create vite` in a non-empty directory), do NOT retry it — ' +
+                'scaffold into a fresh empty subdirectory and move the files, or write package.json/configs/sources yourself with write_file, then run `npm install`.';
             const systemPrompt = [
                 "You are Zelari Code, an interactive AI coding agent operating directly in the user's terminal.",
                 '',
                 'You ARE connected to this machine and have real tools to read, modify, and explore the codebase.',
                 "Never claim you lack filesystem or shell access — you have it. Use your tools instead of asking the user to paste file contents.",
                 '',
+                '# Platform & Shell',
+                `platform: ${process.platform}`,
+                `shell: ${resolvedShell.via}`,
+                shellGuidance,
+                nonInteractiveGuidance,
+                '',
                 '# Working Directory',
                 `You are running in: ${cwd}`,
                 'All relative file paths are resolved against this directory. Always work with real files here.',
@@ -70,12 +171,32 @@ export function useChatTurn(params) {
                 '# Available Tools',
                 'You can call these tools. Use them to take action and gather information autonomously:',
                 toolList,
+                ...(workspaceSummary ? ['', workspaceSummary] : []),
+                ...(zelariReadHint ? ['', zelariReadHint] : []),
+                ...(planSummary ? ['', planSummary] : []),
                 '',
                 '# Guidelines',
-                '- When the user asks you to write code, debug, or explore, be proactive: list files (bash: ls, list_files) and read key files (read_file) to understand the project instead of asking the user to paste file contents.',
+                '- When the user asks you to write code, debug, or explore, be proactive: list files (list_files, or bash: ls/dir) and read key files (read_file) to understand the project instead of asking the user to paste file contents.',
+                '- If a command fails or is cancelled, do NOT retry variants of the same command: diagnose why (read the hint in the result if present) and take a DIFFERENT approach (e.g. create the files yourself with write_file).',
+                '- After a tool result, CONTINUE your answer from where you left off. NEVER restate or re-print text you already wrote earlier in this turn.',
                 "- Only invoke tools when they are necessary to answer the user's prompt. If the user is just saying hello or greeting them (e.g., \"ciao\", \"hello\"), simply greet them back and ask how you can help, without running any commands or tools.",
                 '- When you finish a task, briefly summarize what you did.',
+                ...(planSummary
+                    ? [
+                        '- Plan tasks: when you START working on a plan task call updateTask {taskId, status: "in_progress"}; when it is complete and verified call updateTask {taskId, status: "done"}. NEVER edit .zelari/plan.json by hand.',
+                    ]
+                    : []),
             ].join('\n');
+            // v0.7.1 (A2): per-turn tool-call budget for single-prompt turns.
+            // The council sets 5; the single-prompt path previously set NONE, so a
+            // flailing model could loop for the full MAX_TOOL_LOOP_ITERATIONS (12)
+            // of junk calls (e.g. read_file same path ×3 then silence). Default 25,
+            // overridable via ZELARI_MAX_TOOL_CALLS.
+            const maxToolCallsPerTurn = (() => {
+                const raw = process.env.ZELARI_MAX_TOOL_CALLS;
+                const n = raw ? Number.parseInt(raw, 10) : 25;
+                return Number.isFinite(n) && n > 0 ? n : 25;
+            })();
             const harness = new AgentHarness({
                 model: envConfig.model,
                 provider: 'openai-compatible',
@@ -91,16 +212,36 @@ export function useChatTurn(params) {
                 toolRegistry,
                 providerStream,
                 cwd,
+                maxToolCallsPerTurn,
             });
             harnessRef.current = harness;
             setQueueCount(harness.queueLength);
+            // Total assistant output across the whole turn — feeds the token/cost
+            // estimate fallback in computeSessionStatsDelta.
             let assistantContent = '';
+            // Display buffer for the CURRENT streamed message only. Reset on every
+            // message_end: without this, the post-tool-call message re-rendered the
+            // full accumulated turn text, duplicating everything said before the
+            // tool ran.
+            let streamContent = '';
+            // tool_execution_end doesn't carry toolName — remember it from the
+            // matching start event (keyed by toolCallId) for metrics.
+            const toolNameById = new Map();
             const metrics = getMetricsLogger();
             let realUsage = null;
             try {
                 for await (const event of harness.run()) {
-                    if (event.type === 'message_end' && event.usage) {
-                        realUsage = event.usage;
+                    if (event.type === 'message_end') {
+                        if (event.usage)
+                            realUsage = event.usage;
+                        // Message boundary: drain buffered deltas, then seal the streamed
+                        // bubble so the next message starts fresh instead of merging.
+                        flushStreaming();
+                        if (useLiveModel)
+                            finalizeStreaming(setMessages, setLive);
+                        else
+                            finalizeStreamingAssistant(setMessages);
+                        streamContent = '';
                     }
                     if (event.type === 'queue_update') {
                         setQueueCount(harness.queueLength);
@@ -133,7 +274,7 @@ export function useChatTurn(params) {
                             sessionId,
                             provider: envConfig.providerId,
                             model: envConfig.model,
-                            toolName: event.toolName,
+                            toolName: toolNameById.get(event.toolCallId) ?? 'unknown',
                             toolCallId: event.toolCallId,
                             durationMs: event.durationMs,
                             ok: !event.isError,
@@ -141,26 +282,64 @@ export function useChatTurn(params) {
                     }
                     if (event.type === 'message_delta') {
                         assistantContent += event.delta;
-                        appendOrExtendStreamingAssistant(setMessages, assistantContent, Date.now());
+                        streamContent += event.delta;
+                        // Route through the throttled setter so per-token deltas (50-200/sec)
+                        // coalesce into ≤60 renders/sec instead of flickering the TUI.
+                        if (useLiveModel) {
+                            setStreaming(commitStreaming, streamContent, Date.now(), {
+                                ...(event.memberId ? { memberId: event.memberId } : {}),
+                                ...(event.memberName ? { memberName: event.memberName } : {}),
+                            });
+                        }
+                        else {
+                            // Legacy single-array fallback (existing tests).
+                            appendOrExtendStreamingAssistant(commitStreaming, streamContent, Date.now(), {
+                                ...(event.memberId ? { memberId: event.memberId } : {}),
+                                ...(event.memberName ? { memberName: event.memberName } : {}),
+                            });
+                        }
                     }
                     else if (event.type === 'error') {
+                        flushStreaming();
                         appendSystem(setMessages, `[error] ${event.message}`, Date.now());
                     }
-                    else if (event.type === 'tool_call') {
-                        appendSystem(setMessages, `[tool_call] ${event.toolName}(${JSON.stringify(event.arguments).slice(0, 80)})`, event.ts);
-                    }
-                    else if (event.type === 'tool_result') {
-                        appendSystem(setMessages, `[tool_result] ${event.toolName} → ${event.ok ? 'ok' : 'error'}`, event.ts);
-                    }
                     else if (event.type === 'tool_execution_start') {
-                        appendToolStart(setMessages, event.toolName, event.args, event.ts);
+                        toolNameById.set(event.toolCallId, event.toolName);
+                        // Drain buffered deltas FIRST so the text streamed before the
+                        // call renders above the tool line, not below it — then seal
+                        // that bubble: it's complete once the model starts calling tools.
+                        flushStreaming();
+                        if (useLiveModel) {
+                            finalizeStreaming(setMessages, setLive);
+                            startTool(setLive, event.toolName, event.toolCallId, event.args, event.ts);
+                        }
+                        else {
+                            finalizeStreamingAssistant(setMessages);
+                            appendToolStart(setMessages, event.toolName, event.toolCallId, event.args, event.ts);
+                        }
+                        // The pre-tool bubble is sealed: reset the display buffer so the
+                        // next delta starts a fresh bubble instead of re-showing (and
+                        // duplicating) the text already printed above the tool line.
+                        streamContent = '';
                     }
                     else if (event.type === 'tool_execution_end') {
-                        appendToolEnd(setMessages, event.result, event.isError, event.durationMs, event.ts);
+                        if (useLiveModel) {
+                            completeTool(setMessages, setLive, event.toolCallId, event.isError, event.durationMs, event.result);
+                        }
+                        else {
+                            updateToolMessageEnd(setMessages, event.toolCallId, event.isError, event.durationMs, event.result);
+                        }
                     }
                 }
             }
             finally {
+                // Drain any buffered streaming deltas so the final assistant message
+                // is committed before busy flips to false (and the input re-enables).
+                flushStreaming();
+                if (useLiveModel)
+                    finalizeStreaming(setMessages, setLive);
+                else
+                    finalizeStreamingAssistant(setMessages);
                 harnessRef.current = null;
                 setQueueCount(0);
                 setBusy(false);
@@ -172,26 +351,61 @@ export function useChatTurn(params) {
             // resolveFailoverStream / AgentHarness construction that were
             // previously escaping the function unhandled. Surfaces the error
             // to the chat instead of hanging silently.
+            // Flush first so any partial assistant content streamed before the
+            // throw is committed before the error message renders.
+            flushStreaming();
             appendSystem(setMessages, `[dispatch error] ${err instanceof Error ? err.message : String(err)}`);
             setBusy(false);
         }
-    }, [sessionId, writerRef, setMessages, setBusy, setSessionActive, setSessionStats]);
+    }, [
+        sessionId,
+        writerRef,
+        setMessages,
+        commitStreaming,
+        flushStreaming,
+        setBusy,
+        setSessionActive,
+        setSessionStats,
+        useLiveModel,
+        setLive,
+        liveRef,
+    ]);
     const dispatchCouncilPrompt = useCallback(async (text) => {
         await dispatchCouncilPromptImpl(text, {
             sessionId,
             writerRef,
             setMessages,
+            commitStreaming,
+            flushStreaming,
             setBusy,
             setQueueCount,
+            setLive,
+            liveRef,
         });
-    }, [sessionId, writerRef, setMessages, setBusy, setQueueCount]);
-    return { dispatchPrompt, dispatchCouncilPrompt, harnessRef, queueCount, setQueueCount };
+    }, [
+        sessionId,
+        writerRef,
+        setMessages,
+        commitStreaming,
+        flushStreaming,
+        setBusy,
+        setQueueCount,
+        setLive,
+        liveRef,
+    ]);
+    return {
+        dispatchPrompt,
+        dispatchCouncilPrompt,
+        harnessRef,
+        queueCount,
+        setQueueCount,
+    };
 }
 /**
  * dispatchCouncilPrompt — multi-agent council dispatch.
  *
- * Surfaces tool_execution_start/end as 'tool' role messages so ChatStream
- * renders CollapsibleToolOutput. Runs AGENTS.MD auto-maintenance after the
+ * Surfaces tool_execution_start/end as 'tool' role messages so the live
+ * region renders them. Runs AGENTS.MD auto-maintenance after the
  * council finishes (controlled by ZELARI_AGENTS_MD env var).
  *
  * Implementation lives outside the hook closure so it doesn't depend on the
@@ -199,20 +413,24 @@ export function useChatTurn(params) {
  * useChatTurn wrapper.
  */
 async function dispatchCouncilPromptImpl(text, deps) {
-    const { sessionId, writerRef, setMessages, setBusy } = deps;
+    const { sessionId, writerRef, setMessages, commitStreaming, flushStreaming, setBusy, setLive, liveRef, } = deps;
+    const useLiveModel = !!(setLive && liveRef);
     const envConfig = await providerFromEnv();
     if (!envConfig) {
-        appendSystem(setMessages, 'OPENAI_API_KEY not set. Export it before invoking /council.');
+        const active = resolveActiveProvider();
+        const spec = PROVIDERS.find((p) => p.id === active);
+        appendSystem(setMessages, `No API key for the active provider "${active}". Set ${spec?.envVar ?? "the provider API key env var"} or run /login ${active} before invoking /council.`);
         return;
     }
     setBusy(true);
     // Import dynamically to avoid a circular dep at module-load time.
-    const { dispatchCouncil } = await import('../councilDispatcher.js');
-    const { createWorkspaceContext, createWorkspaceStubs } = await import('../workspace/stubs.js');
-    const { createWorkspaceToolRegistry } = await import('../workspace/toolRegistry.js');
-    const { setWorkspaceStubs } = await import('../../agents/tools.js');
-    const { runPostCouncilHook } = await import('../workspace/postCouncilHook.js');
-    const { FeedbackStore } = await import('../councilFeedback.js');
+    const { dispatchCouncil } = await import("../councilDispatcher.js");
+    const { createWorkspaceContext, createWorkspaceStubs } = await import("../workspace/stubs.js");
+    const { createWorkspaceToolRegistry } = await import("../workspace/toolRegistry.js");
+    const { setWorkspaceStubs } = await import("@zelari/core/skills");
+    const { runPostCouncilHook } = await import("../workspace/postCouncilHook.js");
+    const { buildWorkspaceSummary, buildPlanSummary } = await import("../workspace/workspaceSummary.js");
+    const { FeedbackStore } = await import("../councilFeedback.js");
     const { registry: councilToolRegistry } = createBuiltinToolRegistry();
     const workspaceCtx = createWorkspaceContext();
     const workspaceReg = createWorkspaceToolRegistry(workspaceCtx);
@@ -221,77 +439,228 @@ async function dispatchCouncilPromptImpl(text, deps) {
         if (td)
             councilToolRegistry.register(td);
     }
+    // v0.7.5: MCP tools for the council too (same lazy singleton as the
+    // single-agent path — zero extra spawns).
+    try {
+        const { registerMcpTools } = await import('../mcp/mcpManager.js');
+        const mcp = await registerMcpTools(councilToolRegistry);
+        for (const w of mcp.warnings)
+            appendSystem(setMessages, w);
+    }
+    catch {
+        // Best-effort.
+    }
     setWorkspaceStubs(createWorkspaceStubs(workspaceCtx));
     const councilFeedbackStore = new FeedbackStore();
+    // v0.7.3: per-member display accumulator for the streaming bubble.
+    // The previous code accumulated by reading `liveRef.current.streaming` —
+    // but that ref only updates on render (useEffect) and the delta commits go
+    // through a 16ms throttle window, so every delta inside a window computed
+    // staleContent+delta and the LAST write won: most tokens were silently
+    // dropped (the mangled member text from the 2026-07-02 live test).
+    // The accumulator lives here, in the event loop, exactly like
+    // `streamContent` in dispatchPrompt.
+    let streamContent = "";
+    let streamMemberId = null;
+    // v0.7.3: council members legitimately need more than the core default of
+    // 5 tool calls per turn (a planner creating 8 tasks got 3 of them skipped
+    // with "[skipped] maxToolCallsPerTurn reached"). Same env override as the
+    // single-prompt path.
+    const councilMaxToolCalls = (() => {
+        const raw = process.env.ZELARI_MAX_TOOL_CALLS;
+        const n = raw ? Number.parseInt(raw, 10) : 15;
+        return Number.isFinite(n) && n > 0 ? n : 15;
+    })();
+    // v0.7.1 (A3): track member completion so the AGENTS.MD hook only runs when
+    // the council actually produced output. v0.7.1 (A4): track repeated provider
+    // errors to abort the remaining members instead of grinding through every
+    // specialist after the API is clearly broken.
+    let membersCompleted = 0;
+    let chairmanProducedOutput = false;
+    let consecutiveProviderErrors = 0;
+    let lastErrorMessage = "";
+    let councilAborted = false;
+    const PROVIDER_ERROR_ABORT_THRESHOLD = 2;
     try {
         for await (const event of dispatchCouncil(text, {
             apiKey: envConfig.apiKey,
             model: envConfig.model,
-            provider: 'openai-compatible',
+            provider: "openai-compatible",
             providerStream: openaiCompatibleProvider(envConfig),
             sessionId,
             tools: councilToolRegistry,
             feedbackStore: councilFeedbackStore,
+            // v0.7.2 (B2): give the council the same project awareness the
+            // single-prompt path has — cwd, tech stack, file layout, build scripts.
+            // Without this, members had no idea which project they were operating
+            // on and projected their identity onto the task.
+            // v0.7.3: append the existing plan (if any) so a follow-up /council
+            // continues it instead of re-planning from scratch.
+            workspaceContext: [
+                buildWorkspaceSummary(process.cwd()),
+                buildPlanSummary(process.cwd()),
+            ]
+                .filter(Boolean)
+                .join("\n\n"),
+            maxToolCallsPerTurn: councilMaxToolCalls,
         })) {
+            if (councilAborted) {
+                // Drain remaining events silently after the abort decision.
+                if (writerRef.current)
+                    await writerRef.current.append(event);
+                continue;
+            }
             if (writerRef.current) {
                 await writerRef.current.append(event);
             }
-            if (event.type === 'message_delta') {
-                // Coalesce streaming assistant content
-                setMessages((prev) => {
-                    const last = prev[prev.length - 1];
-                    if (last && last.role === 'assistant' && last.id.startsWith('streaming-')) {
-                        return [...prev.slice(0, -1), { ...last, content: last.content + event.delta }];
+            if (event.type === "message_delta") {
+                // Coalesce streaming assistant content through the throttled setter so
+                // per-token deltas don't flicker the TUI (same as dispatchPrompt).
+                if (useLiveModel) {
+                    // v0.7.3: accumulate in the local `streamContent` (NOT via liveRef —
+                    // stale under the throttle, see the accumulator comment above) and
+                    // always push the FULL content: dropped intermediate commits are
+                    // then harmless because the last one supersedes them.
+                    const memberId = event.memberId ?? null;
+                    if (memberId !== streamMemberId) {
+                        // Member boundary without a message_end (defensive): seal the
+                        // previous member's bubble before starting the new one.
+                        flushStreaming();
+                        finalizeStreaming(setMessages, setLive);
+                        streamContent = "";
+                        streamMemberId = memberId;
                     }
-                    return [
-                        ...prev,
-                        { id: `streaming-${crypto.randomUUID()}`, role: 'assistant', content: event.delta, ts: event.ts },
-                    ];
-                });
+                    streamContent += event.delta;
+                    setStreaming(commitStreaming, streamContent, event.ts, {
+                        ...(event.memberId ? { memberId: event.memberId } : {}),
+                        ...(event.memberName ? { memberName: event.memberName } : {}),
+                    });
+                }
+                else {
+                    // Legacy single-array fallback. Extend the trailing streaming bubble
+                    // only when it belongs to the SAME member — otherwise one specialist's
+                    // text would be appended to (and attributed to) the previous one.
+                    commitStreaming((prev) => {
+                        const last = prev[prev.length - 1];
+                        if (last &&
+                            last.role === "assistant" &&
+                            last.id.startsWith("streaming-") &&
+                            (last.memberId ?? null) === (event.memberId ?? null)) {
+                            return [
+                                ...prev.slice(0, -1),
+                                { ...last, content: last.content + event.delta },
+                            ];
+                        }
+                        return [
+                            ...prev,
+                            {
+                                id: `streaming-${crypto.randomUUID()}`,
+                                role: "assistant",
+                                content: event.delta,
+                                ts: event.ts,
+                                ...(event.memberId ? { memberId: event.memberId } : {}),
+                                ...(event.memberName ? { memberName: event.memberName } : {}),
+                            },
+                        ];
+                    });
+                }
             }
-            else if (event.type === 'tool_execution_start') {
-                const argsPreview = JSON.stringify(event.args).slice(0, 120);
-                appendSystem(setMessages, `▶ ${event.toolName}(${argsPreview})`, event.ts);
-                // Also surface as 'tool' role for CollapsibleToolOutput rendering.
-                setMessages((prev) => [
-                    ...prev,
-                    {
-                        id: crypto.randomUUID(),
-                        role: 'tool',
-                        content: `${event.toolName}(${argsPreview})`,
-                        ts: event.ts,
-                        toolName: event.toolName,
-                        toolCallId: event.toolCallId,
-                        toolOk: undefined,
-                        toolDurationMs: undefined,
-                    },
-                ]);
+            else if (event.type === "message_end") {
+                // Member/turn boundary: drain buffered deltas and seal the bubble so
+                // the next streamed message starts fresh.
+                flushStreaming();
+                if (useLiveModel)
+                    finalizeStreaming(setMessages, setLive);
+                else
+                    finalizeStreamingAssistant(setMessages);
+                streamContent = "";
+                streamMemberId = null;
+                membersCompleted++;
+                // Chairman is the last member; any assistant content from it counts.
+                if (event.memberId === "lucifer" || event.memberName === "Lucifero") {
+                    chairmanProducedOutput = true;
+                }
             }
-            else if (event.type === 'tool_execution_end') {
-                updateToolMessageEnd(setMessages, event.toolCallId, event.isError, event.durationMs);
+            else if (event.type === "tool_execution_start") {
+                // Drain buffered deltas first so ordering matches reality, and seal
+                // the pre-tool bubble (complete once the member starts calling tools).
+                flushStreaming();
+                if (useLiveModel) {
+                    finalizeStreaming(setMessages, setLive);
+                    startTool(setLive, event.toolName, event.toolCallId, event.args, event.ts);
+                }
+                else {
+                    finalizeStreamingAssistant(setMessages);
+                    appendToolStart(setMessages, event.toolName, event.toolCallId, event.args, event.ts);
+                }
+                // The pre-tool bubble is sealed: the next delta starts a fresh one.
+                streamContent = "";
             }
-            else if (event.type === 'error') {
-                appendSystem(setMessages, `[error] ${event.message}`, event.ts);
+            else if (event.type === "tool_execution_end") {
+                if (useLiveModel) {
+                    completeTool(setMessages, setLive, event.toolCallId, event.isError, event.durationMs, event.result);
+                }
+                else {
+                    updateToolMessageEnd(setMessages, event.toolCallId, event.isError, event.durationMs, event.result);
+                }
+            }
+            else if (event.type === "error") {
+                flushStreaming();
+                // v0.7.1 (A4): attribute the error to the member when known, so the
+                // user sees `[error · Caronte] …` instead of three anonymous lines.
+                const memberTag = event.memberName ? ` · ${event.memberName}` : "";
+                appendSystem(setMessages, `[error${memberTag}] ${event.message}`, event.ts);
+                // v0.7.1 (A4): detect repeated identical provider errors and abort the
+                // remaining members instead of grinding through every specialist.
+                if (event.message === lastErrorMessage) {
+                    consecutiveProviderErrors++;
+                }
+                else {
+                    consecutiveProviderErrors = 1;
+                    lastErrorMessage = event.message;
+                }
+                if (consecutiveProviderErrors >= PROVIDER_ERROR_ABORT_THRESHOLD) {
+                    councilAborted = true;
+                    appendSystem(setMessages, `[council aborted: repeated provider error — ${consecutiveProviderErrors}× "${event.message.slice(0, 80)}"]`, Date.now());
+                }
             }
         }
     }
     catch (err) {
+        // Flush any partial streamed content before the error message renders.
+        flushStreaming();
         appendSystem(setMessages, `[council error] ${err instanceof Error ? err.message : String(err)}`, Date.now());
     }
     finally {
-        try {
-            const hook = await runPostCouncilHook(workspaceCtx);
-            if (hook.ran && hook.changed) {
-                appendSystem(setMessages, `[agents.md] updated: ${hook.sections.length} section(s) changed (${hook.sections.join(', ')})`, Date.now());
-            }
-            else if (hook.ran && hook.reason) {
-                if (!hook.reason.includes('disabled')) {
-                    appendSystem(setMessages, `[agents.md] ${hook.reason}`, Date.now());
+        // Drain any buffered streaming deltas before status messages / busy flip,
+        // so the final council output is committed to the chat.
+        flushStreaming();
+        if (useLiveModel)
+            finalizeStreaming(setMessages, setLive);
+        else
+            finalizeStreamingAssistant(setMessages);
+        // v0.7.1 (A3): only auto-write AGENTS.MD when the council actually produced
+        // output. Running the hook after an all-error run (e.g. the HTTP 400 from
+        // A1) dirtied the working tree with sections rewritten from nothing.
+        const hookShouldRun = membersCompleted > 0 || chairmanProducedOutput;
+        if (hookShouldRun) {
+            try {
+                const hook = await runPostCouncilHook(workspaceCtx);
+                if (hook.ran && hook.changed) {
+                    appendSystem(setMessages, `[agents.md] updated: ${hook.sections.length} section(s) changed (${hook.sections.join(", ")})`, Date.now());
+                }
+                else if (hook.ran && hook.reason) {
+                    if (!hook.reason.includes("disabled")) {
+                        appendSystem(setMessages, `[agents.md] ${hook.reason}`, Date.now());
+                    }
                 }
             }
+            catch {
+                // Best-effort — never block on AGENTS.MD errors.
+            }
         }
-        catch {
-            // Best-effort — never block on AGENTS.MD errors.
+        else if (!councilAborted) {
+            appendSystem(setMessages, "[agents.md] skipped — council produced no output", Date.now());
         }
         setBusy(false);
     }