zelari-code 1.15.0 → 1.17.1

package/dist/cli/hooks/useChatTurn.js

@@ -9,7 +9,8 @@ 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 { buildSystemPrompt, getAllTools, SINGLE_AGENT_IDENTITY_MODULE, buildLanguagePolicyModuleFor, } from "@zelari/core/skills";
+import { buildSystemPromptSplit, systemMessagesFromSplit, getAllTools, SINGLE_AGENT_IDENTITY_MODULE, buildLanguagePolicyModuleFor, } from "@zelari/core/skills";
+import { hashStablePrompt } from "../state/fileStateStore.js";
 import { parseClarificationRequest, cleanAgentContent, } from "@zelari/core";
 import { appendOrExtendStreamingAssistant, appendSystem, appendToolStart, finalizeStreamingAssistant, updateToolMessageEnd, } from "./messageHelpers.js";
 import { setStreaming, finalizeStreaming, startTool, completeTool, } from "./chatState.js";
@@ -78,8 +79,45 @@ export function useChatTurn(params) {
             }
             setBusy(true);
             const workPhase = getPhase();
+            // Grok-style ask_user: block the tool-loop until picker resolves so
+            // the same harness run continues with the answer as tool_result.
+            const onAskUser = setPicker
+                ? (req) => new Promise((resolve) => {
+                    const choices = req.choices ?? [];
+                    if (choices.length < 2) {
+                        resolve(null);
+                        return;
+                    }
+                    setLastClarification({
+                        question: req.question,
+                        choices,
+                    });
+                    const choiceLines = choices
+                        .map((c, i) => `  ${i + 1}. ${c}`)
+                        .join("\n");
+                    appendSystem(setMessages, `[in attesa di risposta — ask_user]\n${req.question}\n${choiceLines}` +
+                        (req.context ? `\n_(${req.context})_` : "") +
+                        "\n→ scegli dalla lista (il turno continua dopo).", Date.now());
+                    let settled = false;
+                    const finish = (value) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        setPicker(null);
+                        resolve(value);
+                    };
+                    setPicker({
+                        kind: "clarification",
+                        title: req.question,
+                        items: choices.map((c) => ({ value: c, label: c })),
+                        onAnswer: (value) => finish(value),
+                        onCancel: () => finish(null),
+                    });
+                })
+                : undefined;
             const { registry: toolRegistry } = createBuiltinToolRegistry({
                 planMode: workPhase === "plan",
+                onAskUser,
             });
             const baseProviderStream = openaiCompatibleProvider(envConfig);
             const failoverResolution = await resolveFailoverStream({
@@ -111,17 +149,39 @@ export function useChatTurn(params) {
             // 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 = "";
+            // v1.16: unified compose — product truth + draft plan ops; plan is
+            // NEVER mislabeled as ragContext (that slot is for real memory only).
+            let composedWorkspace = "";
+            let composedInstructions = "";
+            let hasPlan = false;
             try {
-                const { buildPlanSummary, buildWorkspaceSummary, buildZelariReadHint, } = await import("../workspace/workspaceSummary.js");
-                planSummary = buildPlanSummary(cwd);
-                workspaceSummary = buildWorkspaceSummary(cwd);
-                zelariReadHint = buildZelariReadHint(cwd);
+                const { composeProjectContext } = await import("../workspace/composeContext.js");
+                const { hasWorkspacePlan } = await import("../workspace/planDetect.js");
+                hasPlan = hasWorkspacePlan(cwd);
+                const { loadDurableContext } = await import("../state/loadDurableContext.js");
+                const durableState = await loadDurableContext(cwd);
+                const composed = composeProjectContext({
+                    mode: "agent",
+                    cwd,
+                    userMessage: userText,
+                    includeLessons: false,
+                    durableState: durableState || undefined,
+                    // Pre-loaded async — skip sync fallback double-read.
+                    includeDurableState: false,
+                });
+                composedWorkspace = composed.workspaceContext;
+                composedInstructions = composed.projectInstructions;
+                // Put durable into volatile workspace path via rag if compose put it
+                // in ragContext — agent buildSystemPrompt uses workspaceContext only;
+                // merge rag durable into workspace for agent visibility.
+                if (composed.ragContext) {
+                    composedWorkspace = [composedWorkspace, composed.ragContext]
+                        .filter(Boolean)
+                        .join("\n\n");
+                }
+                for (const w of composed.warnings) {
+                    appendSystem(setMessages, w, Date.now());
+                }
                 // 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
@@ -133,7 +193,7 @@ export function useChatTurn(params) {
                 // requires (opts.requiredTools), mapping the Electron-era `searchRAG`
                 // to the CLI's `searchDocuments`.
                 const wantedWorkspaceTools = new Set();
-                if (planSummary)
+                if (hasPlan)
                     wantedWorkspaceTools.add("updateTask");
                 const WORKSPACE_STUB_NAMES = new Set([
                     "createPhase",
@@ -211,7 +271,6 @@ export function useChatTurn(params) {
             // not "member of an AI Council".
             const planPhaseBlock = workPhase === "plan"
                 ? [
-                    "",
                     "# Work Phase: PLAN",
                     "You are in PLAN mode. Explore and design only.",
                     "- Do NOT implement production code or run destructive shell commands.",
@@ -221,39 +280,42 @@ export function useChatTurn(params) {
                 ].join("\n")
                 : workPhase === "build"
                     ? [
-                        "",
                         "# Work Phase: BUILD",
                         "Implement on disk. Prefer acting over describing.",
                         "- Prior plan/synthesis text is a SPEC to apply — not proof files already changed.",
                         "- You MUST use write_file/edit_file for every file you change before claiming done.",
                         "- After read_file: if the planned change is missing, WRITE it — do not stop at analysis.",
                         "- Never claim already-implemented based only on reading a plan or skimming code.",
-                        planSummary
-                            ? "- An approved plan exists in the workspace — implement it and update task statuses as you go."
+                        hasPlan
+                            ? "- A draft plan exists under .zelari/ — implement grounded tasks and update statuses; do not treat design docs as shipped code."
                             : "",
                     ]
                         .filter(Boolean)
                         .join("\n")
                     : "";
+            // Stable platform/shell block (session-constant). Phase/plan go in volatile.
             const shellContextBlock = [
                 "# Platform & Shell",
                 `platform: ${process.platform}`,
                 `shell: ${resolvedShell.via}`,
                 shellGuidance,
                 nonInteractiveGuidance,
-                planPhaseBlock,
                 "",
                 "# Working Directory",
                 `You are running in: ${cwd}`,
                 "All relative file paths are resolved against this directory. Always work with real files here.",
-                ...(planSummary
+            ].join("\n");
+            const volatileSessionBlock = [
+                planPhaseBlock,
+                hasPlan
                     ? [
-                        "",
                         "# Plan Tracking",
-                        '- 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");
+                        '- Plan tasks (draft ops): when you START a task call updateTask {taskId, status: "in_progress"}; when complete and verified call updateTask {taskId, status: "done"}. NEVER edit .zelari/plan.json by hand. Prefer product tree over design docs.',
+                    ].join("\n")
+                    : "",
+            ]
+                .filter(Boolean)
+                .join("\n\n");
             const singleAgentRole = {
                 id: "single",
                 name: "Zelari Code",
@@ -264,17 +326,23 @@ export function useChatTurn(params) {
                 tools: toolListNames,
                 systemPrompt: shellContextBlock,
             };
-            // workspaceContext + ragContext carry the summaries that were inline
-            // before; the builder places them under # Current Workspace State and
-            // # Retrieved Knowledge (RAG) headers.
-            const workspaceContext = [workspaceSummary, zelariReadHint]
+            // Composed workspace already includes product tree + draft plan ops +
+            // epistemic banner. ragContext stays empty on the agent path (memory
+            // is zelari-only) so plan is never mislabeled as "Retrieved Knowledge".
+            const workspaceContext = [
+                volatileSessionBlock,
+                composedWorkspace,
+            ]
                 .filter(Boolean)
                 .join("\n\n");
             // v1.5.3: build via the shared builder. Wrap in try/catch with a
             // minimal fallback so a builder failure (e.g. test context without a
             // populated catalog) never breaks dispatch — the harness still gets a
             // usable system prompt and the turn proceeds.
-            let systemPrompt;
+            // Cache Wars: stable/volatile split so plan/workspace updates do not
+            // bust the cached prefix (identity + tools + platform).
+            let systemMessages = [];
+            let lastStableHash;
             try {
                 // v1.7.0: detect the user's language and inject the language-policy
                 // module so the agent replies in the user's language. Honors
@@ -283,13 +351,11 @@ export function useChatTurn(params) {
                 // — it lives in priority space (5) so it sorts BEFORE the base-identity
                 // module (10): the model sets language scaffolding before reading role text.
                 const languageModule = buildLanguagePolicyModuleFor(userText);
-                const { loadProjectInstructions } = await import("../workspace/projectInstructions.js");
-                const projectInstructions = loadProjectInstructions(process.cwd()).content;
-                systemPrompt = buildSystemPrompt(singleAgentRole, {
+                const split = buildSystemPromptSplit(singleAgentRole, {
                     tools: getAllTools(),
                     toolNames: toolListNames,
                     mode: "agent",
-                    projectInstructions: projectInstructions || undefined,
+                    projectInstructions: composedInstructions || undefined,
                     aiConfig: {
                         enabledSkills: [],
                         enabledTools: toolListNames,
@@ -300,14 +366,18 @@ export function useChatTurn(params) {
                         agentSkillConfigs: [],
                     },
                     workspaceContext: workspaceContext || undefined,
-                    ragContext: planSummary || undefined,
+                    // Do NOT put plan text here — that was mislabeled as RAG and
+                    // taught models to treat design vault as retrieved knowledge.
+                    ragContext: undefined,
                 });
+                lastStableHash = hashStablePrompt(split.stable);
+                systemMessages = systemMessagesFromSplit(split);
             }
             catch {
                 // Fallback: identity + platform/shell + tool list. Keeps the turn
                 // runnable even if the builder or catalog is unavailable.
                 const languageModule = buildLanguagePolicyModuleFor(userText);
-                systemPrompt = [
+                const fallback = [
                     SINGLE_AGENT_IDENTITY_MODULE.content,
                     languageModule.content,
                     shellContextBlock,
@@ -315,8 +385,9 @@ export function useChatTurn(params) {
                     "You can call these tools. Use them to take action and gather information autonomously:",
                     toolList,
                     ...(workspaceContext ? ["", workspaceContext] : []),
-                    ...(planSummary ? ["", planSummary] : []),
                 ].join("\n");
+                lastStableHash = hashStablePrompt(fallback);
+                systemMessages = [{ role: "system", content: fallback }];
             }
             // 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
@@ -338,7 +409,7 @@ export function useChatTurn(params) {
                 model: envConfig.model,
                 provider: "openai-compatible",
                 messages: [
-                    { role: "system", content: systemPrompt },
+                    ...systemMessages,
                     // v1.8.0: shared rolling history (agent/council/zelari) so short
                     // answers bind to prior ---QUESTION--- blocks. Possibly empty
                     // when ZELARI_HISTORY_TURNS=0.
@@ -559,6 +630,14 @@ export function useChatTurn(params) {
                                 question: clar.question,
                                 choices: clar.choices,
                             });
+                            // Visible prompt while the model "waits": turn is finished,
+                            // busy=false, SelectList (or typed short answer) continues.
+                            const choiceLines = clar.choices
+                                .map((c, i) => `  ${i + 1}. ${c}`)
+                                .join("\n");
+                            appendSystem(setMessages, `[in attesa di risposta]\n${clar.question}\n${choiceLines}` +
+                                (clar.context ? `\n_(${clar.context})_` : "") +
+                                "\n→ scegli dalla lista oppure digita la risposta e invia.", Date.now());
                             if (setPicker) {
                                 setPicker({
                                     kind: "clarification",
@@ -567,6 +646,9 @@ export function useChatTurn(params) {
                                     onAnswer: (value) => {
                                         void dispatchPrompt(value);
                                     },
+                                    onCancel: () => {
+                                        appendSystem(setMessages, "[chiarimento annullato — puoi ancora rispondere scrivendo in chat]", Date.now());
+                                    },
                                 });
                             }
                         }
@@ -581,7 +663,7 @@ export function useChatTurn(params) {
                 harnessRef.current = null;
                 setQueueCount(0);
                 setBusy(false);
-                setSessionStats((prev) => computeSessionStatsDelta(realUsage, userText, assistantContent, envConfig.model, prev));
+                setSessionStats((prev) => computeSessionStatsDelta(realUsage, userText, assistantContent, envConfig.model, prev, lastStableHash ? { stableHash: lastStableHash } : undefined));
             }
         }
         catch (err) {
@@ -694,12 +776,46 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
     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 { buildLessonsSummary } = await import("../workspace/buildLessonsSummary.js");
+    const { composeProjectContext } = await import("../workspace/composeContext.js");
     const { FeedbackStore } = await import("../councilFeedback.js");
     const workPhase = getPhase();
+    const onAskUserCouncil = setPicker
+        ? (req) => new Promise((resolve) => {
+            const choices = req.choices ?? [];
+            if (choices.length < 2) {
+                resolve(null);
+                return;
+            }
+            setLastClarification({
+                question: req.question,
+                choices,
+            });
+            const choiceLines = choices
+                .map((c, i) => `  ${i + 1}. ${c}`)
+                .join("\n");
+            appendSystem(setMessages, `[council in attesa — ask_user]\n${req.question}\n${choiceLines}` +
+                (req.context ? `\n_(${req.context})_` : "") +
+                "\n→ scegli dalla lista (il membro riprende dopo la risposta).", Date.now());
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                setPicker(null);
+                resolve(value);
+            };
+            setPicker({
+                kind: "clarification",
+                title: req.question,
+                items: choices.map((c) => ({ value: c, label: c })),
+                onAnswer: (value) => finish(value),
+                onCancel: () => finish(null),
+            });
+        })
+        : undefined;
     const { registry: councilToolRegistry } = createBuiltinToolRegistry({
         planMode: workPhase === "plan",
+        onAskUser: onAskUserCouncil,
     });
     const workspaceCtx = createWorkspaceContext();
     const workspaceReg = createWorkspaceToolRegistry(workspaceCtx);
@@ -718,7 +834,10 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
     // single-agent path — zero extra spawns).
     try {
         const { registerMcpTools } = await import("../mcp/mcpManager.js");
-        const mcp = await registerMcpTools(councilToolRegistry);
+        // Council: skip Cua desktop tools by default (context hygiene).
+        const mcp = await registerMcpTools(councilToolRegistry, process.cwd(), {
+            councilMode: true,
+        });
         for (const w of mcp.warnings)
             appendSystem(setMessages, w);
     }
@@ -745,6 +864,11 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
         default: 15,
         min: 1,
     });
+    // Wire soft/hard tool-loop budgets into every council member harness
+    // (previously only the single-agent path set these — members defaulted
+    // to harness soft=30 with unbounded soft×3 hard extension).
+    const councilMaxToolLoop = envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, { default: 30, min: 1 });
+    const councilMaxToolLoopHard = envNumber(process.env.ZELARI_MAX_TOOL_LOOP_HARD, { default: 0, min: 0 });
     // 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
@@ -763,6 +887,37 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
     let sliceRan = false;
     let sliceDegraded = false;
     const PROVIDER_ERROR_ABORT_THRESHOLD = 2;
+    // Pre-load durable HEAD once (async materialize) for all council members.
+    let councilCompose = { workspaceContext: formatHistoryForCouncil(4) || "" };
+    try {
+        const { loadDurableContext } = await import("../state/loadDurableContext.js");
+        const durableState = await loadDurableContext(process.cwd());
+        const composed = composeProjectContext({
+            mode: overrides.ragContext ? "zelari" : "council",
+            cwd: process.cwd(),
+            userMessage: effectiveText,
+            memoryHits: overrides.ragContext,
+            durableState: durableState || undefined,
+            historySnippet: formatHistoryForCouncil(4) || undefined,
+            includeLessons: true,
+            includeDurableState: false,
+        });
+        for (const w of composed.warnings) {
+            appendSystem(setMessages, w, Date.now());
+        }
+        councilCompose = {
+            workspaceContext: composed.workspaceContext,
+            ...(composed.ragContext ? { ragContext: composed.ragContext } : {}),
+        };
+    }
+    catch {
+        if (overrides.ragContext) {
+            councilCompose = {
+                workspaceContext: formatHistoryForCouncil(4) || "",
+                ragContext: overrides.ragContext,
+            };
+        }
+    }
     try {
         for await (const event of dispatchCouncil(effectiveText, {
             apiKey: envConfig.apiKey,
@@ -772,30 +927,20 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
             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.
-            // v1.8.0: rolling conversation context so short answers bind across
-            // council turns (same history store as the single-agent path).
-            workspaceContext: [
-                buildWorkspaceSummary(process.cwd()),
-                buildPlanSummary(process.cwd(), { userMessage: effectiveText }),
-                buildLessonsSummary(process.cwd(), effectiveText),
-                formatHistoryForCouncil(4),
-            ]
-                .filter(Boolean)
-                .join("\n\n"),
+            workspaceContext: councilCompose.workspaceContext,
+            ...(councilCompose.ragContext
+                ? { ragContext: councilCompose.ragContext }
+                : {}),
             maxToolCallsPerTurn: councilMaxToolCalls,
-            // v1.0: Zelari-mode per-slice overrides (memory RAG, forced run mode,
-            // raised chairman budget). No-ops for a normal /council run.
-            ...(overrides.ragContext ? { ragContext: overrides.ragContext } : {}),
+            maxToolLoopIterations: councilMaxToolLoop,
+            ...(councilMaxToolLoopHard > 0
+                ? { maxToolLoopHardCap: councilMaxToolLoopHard }
+                : {}),
             runMode: phaseRunMode,
             ...(overrides.maxToolCallsChairman
                 ? { maxToolCallsChairman: overrides.maxToolCallsChairman }
                 : {}),
+            ...(overrides.skipSpecialists ? { skipSpecialists: true } : {}),
             onCouncilStatus: (message) => {
                 appendSystem(setMessages, message, Date.now());
             },
@@ -811,6 +956,12 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
                         question: req.question,
                         choices,
                     });
+                    const choiceLines = choices
+                        .map((c, i) => `  ${i + 1}. ${c}`)
+                        .join("\n");
+                    appendSystem(setMessages, `[council in attesa]\n${req.question}\n${choiceLines}` +
+                        (req.context ? `\n_(${req.context})_` : "") +
+                        "\n→ scegli dalla lista (il membro riprende dopo la risposta).", Date.now());
                     let settled = false;
                     const finish = (value) => {
                         if (settled)
@@ -1083,6 +1234,48 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
                         appendSystem(setMessages, `[completion] readyToCommit=false — ${n} blocking issue(s)${c.degraded ? " (degraded run)" : ""}`, Date.now());
                     }
                 }
+                // Durable State Commit after verified council completion (Palmer).
+                // Skip degraded / failed verification — those must not become HEAD.
+                const verifyOk = hook.verification?.ran
+                    ? hook.verification.ok === true
+                    : false;
+                const completionOk = hook.completion?.completion?.ok === true ||
+                    hook.completion?.completion?.readyToCommit === true;
+                if (!degraded.degraded &&
+                    !councilAborted &&
+                    (verifyOk || completionOk) &&
+                    luciferWriteCount > 0) {
+                    try {
+                        const { tryStateCommit, discoveriesFromOutcome } = await import("../state/commitHelpers.js");
+                        const res = await tryStateCommit({
+                            projectRoot: process.cwd(),
+                            mode: "council",
+                            layer: `council:${councilRunMode ?? "run"}`,
+                            label: `council ${councilRunMode ?? "run"} verified`,
+                            sessionId,
+                            verification: {
+                                ok: true,
+                                ran: hook.verification?.ran ?? completionOk,
+                            },
+                            withCheckpoint: true,
+                            discoveries: discoveriesFromOutcome({
+                                stepId: `${sessionId}-${Date.now()}`,
+                                synthesis: chairmanSynthesisText,
+                                writeCount: luciferWriteCount,
+                                note: "Council implementation verified",
+                            }),
+                        });
+                        if (res.ok && res.meta?.id) {
+                            appendSystem(setMessages, `[state] commit ${res.meta.id}` +
+                                (res.checkpointId
+                                    ? ` · checkpoint ${res.checkpointId}`
+                                    : ""), Date.now());
+                        }
+                    }
+                    catch {
+                        // fail-open
+                    }
+                }
             }
             catch {
                 // Best-effort — never block on AGENTS.MD errors.
@@ -1171,11 +1364,12 @@ async function runZelariMissionInTui(userMessage, deps, emit) {
             projectRoot,
             memory,
             emit,
-            runSlice: async ({ userMessage: slicePrompt, runMode, ragContext }) => {
+            runSlice: async ({ userMessage: slicePrompt, runMode, ragContext, implementerRetry, }) => {
                 const r = await dispatchCouncilPromptImpl(slicePrompt, deps, {
                     ragContext,
                     runMode,
                     maxToolCallsChairman: chairmanBudget,
+                    ...(implementerRetry ? { skipSpecialists: true } : {}),
                 });
                 return {
                     completionOk: r.completionOk,