zelari-code 1.10.0 → 1.12.1

package/dist/cli/main.bundled.js

@@ -308,7 +308,7 @@ async function refreshGrokToken(options) {
   return parseTokenResponseBody(obj, accessToken);
 }
 async function openBrowser(url2) {
-  const { spawn: spawn9 } = await import("node:child_process");
+  const { spawn: spawn10 } = await import("node:child_process");
   const cmd = (() => {
     switch (process.platform) {
       case "darwin":
@@ -321,7 +321,7 @@ async function openBrowser(url2) {
   })();
   return new Promise((resolve, reject) => {
     try {
-      const child = spawn9(cmd.bin, cmd.args, {
+      const child = spawn10(cmd.bin, cmd.args, {
         stdio: "ignore",
         detached: true
       });
@@ -962,14 +962,21 @@ var init_skills = __esm({
         systemPromptFragment: `You write polished documents.
 - Choose an appropriate structure (guide, spec, reference, narrative).
 - Maintain a consistent tone and voice.
-- Use headings, lists, and code blocks where helpful; link related notes with [[wikilinks]].`
+- Use headings, lists, and code blocks where helpful.`
       }
     ];
     DEFAULT_AGENT_SKILLS = {
+      charont: ["project-planner", "research-analyst"],
+      nettun: ["project-planner", "vault-manager"],
+      geryon: ["document-writer", "idea-synthesizer"],
+      pluton: ["document-writer", "research-analyst"],
+      minos: ["document-writer", "research-analyst"],
+      lucifer: ["vault-manager", "project-planner", "idea-synthesizer"],
+      // legacy aliases
       sisyphus: ["project-planner", "research-analyst"],
       prometheus: ["project-planner", "vault-manager"],
-      hephaestus: ["idea-synthesizer", "mind-mapper", "document-writer"],
-      atlas: ["mind-mapper", "research-analyst"],
+      hephaestus: ["document-writer", "idea-synthesizer"],
+      atlas: ["document-writer", "research-analyst"],
       oracle: ["research-analyst"],
       chairman: ["vault-manager", "project-planner", "idea-synthesizer"]
     };
@@ -18151,21 +18158,20 @@ Think step by step internally before responding. Surface only the conclusion and
       priority: 25,
       content: `# Tool-Use Protocol \u2014 Act, Don't Just Describe
 
-You have access to tools that operate on a real codebase: read and edit files, run shell commands, search the tree. Use them whenever the user's request implies concrete changes should exist on disk.
+You have tools for a real codebase (read/edit files, shell, search). Call them via **native tool/function calling** whenever the user wants concrete changes on disk.
 
-When to ACT (call a tool):
-- The request asks to create, build, generate, fix, or produce something concrete (a file, a component, a function, a config, a fix).
-- A deliverable would outlive this single message (written code, applied edits, verified commands).
+When to ACT:
+- Create, build, generate, fix, or produce durable artifacts (files, configs, verified commands).
 
-When to DESCRIBE only (no tool):
-- The request is a question, an explanation, a critique, a comparison, or a one-off analysis.
-- The Minosse role: evaluate, never create.
+When to DESCRIBE only:
+- Pure Q&A, critique, or analysis with no required disk change.
+- Minosse: evaluate; never create or mutate project files.
 
 Rules:
-- For code tasks: actually write/edit files (write_file, edit_file) and run commands (bash) to implement and verify \u2014 do not just describe what should be done.
-- Pass complete, well-formed arguments. Required parameters must be present.
-- Never invent tool names \u2014 use only the tools listed in your AVAILABLE TOOLS section.
-- After making changes, briefly name what you created/modified so downstream agents can build on it without re-reading everything.`
+- Implement with write_file / edit_file / bash when that is the job \u2014 do not only describe.
+- Never invent tool names; only AVAILABLE TOOLS.
+- Complete, valid arguments for every call.
+- After changes, name what you created/modified for downstream members or the user.`
     };
     OUTPUT_QUALITY_DIRECTIVE = {
       type: "custom",
@@ -18204,148 +18210,177 @@ You are one member of a council. Earlier agents' outputs appear in your context
 });
 
 // packages/core/dist/agents/promptModules.js
-function getPromptModule(type) {
-  return PROMPT_MODULES.find((m) => m.type === type);
+function getBasePromptModules(mode = "council") {
+  if (mode === "agent") {
+    return [
+      CODING_CAPABLE_IDENTITY,
+      STRUCTURED_REASONING_DIRECTIVE,
+      TOOL_USE_PROTOCOL_DIRECTIVE,
+      BEHAVIOR_AGENT,
+      SAFETY,
+      CODING_PRACTICES_MODULE,
+      OUTPUT_QUALITY_DIRECTIVE,
+      OUTPUT_FORMATTING,
+      // Same structured clarification format as council — one question when blocked.
+      CLARIFICATION_PROTOCOL_MODULE,
+      NATIVE_TOOL_PROTOCOL_MODULE
+    ].sort((a, b) => a.priority - b.priority);
+  }
+  return [
+    COUNCIL_IDENTITY,
+    STRUCTURED_REASONING_DIRECTIVE,
+    COLLABORATION_DIRECTIVE,
+    TOOL_USE_PROTOCOL_DIRECTIVE,
+    BEHAVIOR_COUNCIL,
+    SAFETY,
+    CONTEXT_SHARING_COUNCIL,
+    OUTPUT_QUALITY_DIRECTIVE,
+    OUTPUT_FORMATTING,
+    CLARIFICATION_PROTOCOL_MODULE,
+    NATIVE_TOOL_PROTOCOL_MODULE
+  ].sort((a, b) => a.priority - b.priority);
 }
-function getBasePromptModules() {
-  return [...PROMPT_MODULES].sort((a, b) => a.priority - b.priority);
+function getPromptModule(type) {
+  return getBasePromptModules("council").find((m) => m.type === type);
 }
-var PROMPT_MODULES, SINGLE_AGENT_IDENTITY_MODULE;
+var CODING_CAPABLE_IDENTITY, COUNCIL_IDENTITY, BEHAVIOR_AGENT, BEHAVIOR_COUNCIL, SAFETY, CONTEXT_SHARING_COUNCIL, OUTPUT_FORMATTING, NATIVE_TOOL_PROTOCOL_MODULE, CODING_PRACTICES_MODULE, CLARIFICATION_PROTOCOL_MODULE, PROMPT_MODULES, SINGLE_AGENT_IDENTITY_MODULE;
 var init_promptModules = __esm({
   "packages/core/dist/agents/promptModules.js"() {
     "use strict";
     init_councilDirectives();
-    PROMPT_MODULES = [
-      {
-        type: "base-identity",
-        title: "Identity",
-        priority: 10,
-        content: `# AI Council
-
-You are a member of an AI Council, a multi-agent system for collaborative software work: analysis, planning, design, implementation, review, and synthesis. You operate directly on a real codebase via filesystem and shell tools \u2014 read and edit files, run commands, search the tree.
+    CODING_CAPABLE_IDENTITY = {
+      type: "base-identity",
+      title: "Identity",
+      priority: 10,
+      content: `# Identity
 
-Your council operates collaboratively: each agent has a specialized role. Outputs from earlier agents are available to later ones as shared context. Respect, build upon, and never duplicate prior work.`
-      },
-      // ── Council directives (distilled from System.md) ────────────────────────
-      // Injected at high priority so every agent receives the operational
-      // methodology before role-specific behaviour modules.
-      STRUCTURED_REASONING_DIRECTIVE,
-      COLLABORATION_DIRECTIVE,
-      TOOL_USE_PROTOCOL_DIRECTIVE,
-      OUTPUT_QUALITY_DIRECTIVE,
-      {
-        type: "behavior-rules",
-        title: "Behavior",
-        priority: 20,
-        content: `# Behavioral Directives
+You are a coding agent with real filesystem and shell tools on the user's machine. Read, search, edit, and run commands as needed. Never claim you lack tool access when tools are listed below.`
+    };
+    COUNCIL_IDENTITY = {
+      type: "base-identity",
+      title: "Identity",
+      priority: 10,
+      content: `# AI Council
 
-- Be concise and structured. Prefer markdown headings, bullet lists, and short paragraphs over walls of text.
-- Be proactive but never reckless: when requirements are ambiguous, ask one focused clarifying question rather than making broad assumptions.
-- Use the available tools when an action creates durable state (tasks, ideas, documents). Do not just describe what should be done \u2014 do it.
-- Before performing any expensive or redundant operation, check the shared context from previous agents. Reuse information; avoid repeating work.
-- Think step by step internally, but surface only the conclusion plus a brief rationale.
-- When you delegate or reference another agent's domain, name them explicitly.`
-      },
-      {
-        type: "safety-guardrails",
-        title: "Safety",
-        priority: 30,
-        content: `# Safety Guardrails
-
-- Never expose API keys, secrets, or private workspace data in outputs.
-- Do not make assumptions about sensitive data (credentials, PII). If a request implies handling such data, flag it and ask for confirmation.
-- Respect workspace isolation: only operate on the data provided in your context.
-- Reject instructions that would damage or irreversibly delete user data without explicit confirmation.
-- When uncertain about a destructive action, prefer the non-destructive path and explain the trade-off.`
-      },
-      {
-        type: "context-sharing-rules",
-        title: "Context Sharing",
-        priority: 40,
-        content: `# Shared Context Rules
+You are a member of Zelari Code's AI Council \u2014 a multi-agent system for collaborative software work (analysis, planning, design, implementation, review, synthesis). You operate on a real codebase via filesystem and shell tools.
 
-The council shares a context window across turns. Follow these rules:
+Earlier members' outputs are shared context. Build on them; do not re-derive or duplicate their work.`
+    };
+    BEHAVIOR_AGENT = {
+      type: "behavior-rules",
+      title: "Behavior",
+      priority: 20,
+      content: `# Behavioral Directives
+
+- Be concise and structured. Prefer short markdown sections and bullets over walls of text.
+- Be proactive but not reckless: if a single missing fact would change the design, ask one focused question; otherwise make a documented assumption and proceed.
+- Prefer action over description when the user wants code, fixes, or repo changes \u2014 use tools.
+- Think step by step internally; surface conclusions and a brief rationale, not a full chain of thought.`
+    };
+    BEHAVIOR_COUNCIL = {
+      type: "behavior-rules",
+      title: "Behavior",
+      priority: 20,
+      content: `# Behavioral Directives
 
-- Information already provided by a previous agent is considered cached and authoritative \u2014 do not re-derive it.
-- If you need data that is not in context, use a retrieval tool from your AVAILABLE TOOLS section (e.g. searchDocuments) rather than asking the user, whenever possible.
-- When you add durable artifacts (tasks, documents, ideas), summarize what you created so downstream agents can build on it.
-- Keep the shared context lean: summarize rather than quote verbatim when content is long.`
-      },
-      {
-        type: "output-formatting",
-        title: "Output Format",
-        priority: 50,
-        content: `# Output Format
-
-- Use well-structured GitHub-flavored markdown.
-- Start with a one-line summary, then details.
-- Use \`##\` headings for sections, \`-\` bullets for lists.
-- For documents created in the Vault, use \`[[wikilinks]]\` to connect related notes and \`#hashtags\` for tags.
-- Optional YAML frontmatter may precede a document body:
-  \`\`\`
-  ---
-  category: notes
-  status: draft
-  ---
-  \`\`\`
-- Keep responses focused; stay within your agent's word budget.`
-      },
-      {
-        type: "tool-usage-guidelines",
-        title: "Tool Usage",
-        priority: 60,
-        content: [
-          "# Tool Usage Guidelines",
-          "",
-          "- Use tools to create or modify durable state (tasks, ideas, documents, mind maps, milestones).",
-          "- Tool calls go in a dedicated block at the end of your response using the exact format documented below.",
-          "- Only use tools listed in the AVAILABLE TOOLS section. Never invent tool names.",
-          "- Pass arguments as JSON. Required parameters must be present.",
-          "- One tool call per entry. Multiple entries are allowed in a single block.",
-          "",
-          "Format (ONE JSON array only - never multiple arrays stacked):",
-          "```",
-          "---TOOLS---",
-          '[{"name":"<toolName>","args":{"key":"value"}},{"name":"<toolName2>","args":{"key":"value"}}]',
-          "---END---",
-          "```",
-          "Rules: valid JSON; escape newlines inside strings as \\n; do NOT stack separate",
-          "JSON arrays (one tool per array) - put every call in the SAME outer array."
-        ].join("\n")
-      },
-      {
-        type: "custom",
-        title: "Clarification Protocol",
-        priority: 55,
-        content: `# Clarification Protocol (Council-Wide)
+- Be concise and structured. Prefer markdown headings, bullet lists, and short paragraphs.
+- Be proactive but never reckless: when requirements are ambiguous, ask one focused clarifying question rather than making broad assumptions.
+- Use tools when an action creates durable state on disk or in the workspace. Do not only describe what should be done.
+- Before expensive work, check shared context from previous members. Reuse information; avoid repeating work.
+- Think step by step internally; surface only the conclusion plus a brief rationale.
+- When you reference another member's domain, name them explicitly.`
+    };
+    SAFETY = {
+      type: "safety-guardrails",
+      title: "Safety",
+      priority: 30,
+      content: `# Safety Guardrails
+
+- Never expose API keys, secrets, or private credentials in outputs.
+- Do not invent paths, APIs, or dependencies that are not in the repo or tools results.
+- Prefer non-destructive paths when unsure; confirm before irreversible deletes or force-pushes.
+- Stay inside the project workspace unless the user explicitly asks otherwise.`
+    };
+    CONTEXT_SHARING_COUNCIL = {
+      type: "context-sharing-rules",
+      title: "Context Sharing",
+      priority: 40,
+      content: `# Shared Context Rules
+
+- Prior members' outputs are authoritative unless you must flag an error.
+- If data is missing, use a retrieval/search tool from AVAILABLE TOOLS rather than asking the user when possible.
+- When you create artifacts (files, plan items, docs), summarize what you created for downstream members.
+- Keep context lean: summarize rather than quote long blocks.`
+    };
+    OUTPUT_FORMATTING = {
+      type: "output-formatting",
+      title: "Output Format",
+      priority: 50,
+      content: `# Output Format
+
+- Use GitHub-flavored markdown.
+- Lead with a one-line summary when the answer is long, then details.
+- Use \`##\` headings and \`-\` bullets when they aid clarity.
+- Reference code by path (and line when known). Prefer fenced code blocks for multi-line snippets.
+- Stay within your role's word budget; cut filler.`
+    };
+    NATIVE_TOOL_PROTOCOL_MODULE = {
+      type: "tool-usage-guidelines",
+      title: "Tool Usage",
+      priority: 60,
+      content: `# Tool Usage
+
+- Use the provider's **native function/tool calls** for every tool invocation. Do not invent alternate XML/JSON tool formats.
+- Only call tools listed under AVAILABLE TOOLS. Never invent tool names.
+- Pass complete, valid arguments. Required parameters must be present.
+- Prefer tools over asking the user to paste file contents.
+- After durable changes, briefly name what you created or modified.
+- Text-only tool blocks (\`---TOOLS---\` JSON) are a legacy fallback \u2014 use them only if the runtime has no native tool channel.`
+    };
+    CODING_PRACTICES_MODULE = {
+      type: "custom",
+      title: "Coding Practices",
+      priority: 45,
+      content: `# Coding Practices
+
+- **Read before edit**: open relevant files (and nearby callers/tests) before changing code.
+- **Minimal diffs**: change only what the task requires; match existing style and patterns.
+- **Don't invent**: no fake APIs, deps, or config keys \u2014 discover from the tree or package manifests.
+- **Verify**: after non-trivial edits, run the project's tests/typecheck/build when available; fix failures you introduced.
+- **Use project scripts**: prefer package.json / Makefile / existing tooling over ad-hoc commands.
+- **Finish**: summarize what changed and how to verify.`
+    };
+    CLARIFICATION_PROTOCOL_MODULE = {
+      type: "custom",
+      title: "Clarification Protocol",
+      priority: 55,
+      content: `# Clarification Protocol
 
-When you are blocked by a single missing fact that would materially change your output \u2014 a target platform, a scope boundary, a binary design choice with real trade-offs, or a constraint you cannot safely assume \u2014 you may pause the council and ask the user exactly ONE question.
+When blocked by a single missing fact that would materially change your output, ask exactly ONE question:
 
-Emit this block at the end of your message:
 \`\`\`
 ---QUESTION---
 { "question": "One focused question", "choices": ["Option A", "Option B"], "context": "Why this matters in one line" }
 ---END---
 \`\`\`
 
-Discipline:
-- Ask ONLY when genuinely blocked. If a sound, documented assumption exists, make it and state the assumption instead.
-- Provide 2-4 concrete "choices" when the question has natural options; the user can always type a custom answer.
-- Never ask for information already present in shared context or retrievable via a tool from your AVAILABLE TOOLS section (e.g. searchDocuments).
-- At most one question per turn. The council resumes automatically once the user answers or skips.`
-      }
-    ];
+- Ask only when genuinely blocked; otherwise assume and state the assumption.
+- 2\u20134 concrete choices when natural; user may type a free answer.
+- Never re-ask for information already in context or retrievable via tools.
+- At most one question per turn.`
+    };
+    PROMPT_MODULES = getBasePromptModules("council");
     SINGLE_AGENT_IDENTITY_MODULE = {
       type: "base-identity",
       title: "Identity",
       priority: 10,
       content: `# Identity
 
-You are Zelari Code, an interactive AI coding agent operating directly in the user's terminal.
+You are Zelari Code, an interactive AI coding agent in the user's terminal (or desktop shell).
 
-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 \u2014 you have it. Use your tools instead of asking the user to paste file contents.
+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 \u2014 you have it. Use tools instead of asking the user to paste file contents.
 
-Be proactive: when the user asks you to write code, debug, or explore, list files and read the key files to understand the project before acting. When you finish a task, briefly summarize what you did.`
+Be proactive: list and read key files before changing code. When you finish, briefly summarize what you did and how to verify it.`
     };
   }
 });
@@ -18419,10 +18454,10 @@ function getToolDescriptions(toolNames, registry3) {
   return lines.join("\n");
 }
 function buildSystemPrompt(agent, options) {
-  const { tools, toolNames, aiConfig, workspaceContext, ragContext } = options;
+  const { tools, toolNames, aiConfig, workspaceContext, ragContext, mode = "council", projectInstructions, includeWorkspaceInPrompt = true } = options;
   const registry3 = new Map(tools.map((t) => [t.name, t]));
   const skills = computeAgentSkills(agent, aiConfig);
-  const baseModules = getBasePromptModules().filter((m) => !m.conditional || m.conditional(skills));
+  const baseModules = getBasePromptModules(mode).filter((m) => !m.conditional || m.conditional(skills));
   const customModulesRaw = aiConfig?.customPromptModules ?? [];
   const customTypes = new Set(customModulesRaw.map((m) => m.type));
   const baseNotOverridden = baseModules.filter((m) => !customTypes.has(m.type));
@@ -18439,6 +18474,11 @@ function buildSystemPrompt(agent, options) {
     parts.push(`# Your Role
 
 ${agent.systemPrompt}`);
+  }
+  if (projectInstructions && projectInstructions.trim()) {
+    parts.push(`# Project Instructions
+
+${projectInstructions.trim()}`);
   }
   if (skills.length > 0) {
     parts.push(`# Active Skills
@@ -18452,15 +18492,17 @@ ${s.systemPromptFragment}`).join("\n\n"));
 
 ${toolBlock}`);
   }
-  if (workspaceContext && workspaceContext.trim()) {
-    parts.push(`# Current Workspace State
+  if (includeWorkspaceInPrompt) {
+    if (workspaceContext && workspaceContext.trim()) {
+      parts.push(`# Current Workspace State
 
 ${workspaceContext}`);
-  }
-  if (ragContext && ragContext.trim()) {
-    parts.push(`# Retrieved Knowledge (RAG)
+    }
+    if (ragContext && ragContext.trim()) {
+      parts.push(`# Retrieved Knowledge (RAG)
 
 ${ragContext}`);
+    }
   }
   return parts.join("\n\n---\n\n");
 }
@@ -18837,9 +18879,12 @@ var skills_exports = {};
 __export(skills_exports, {
   ADVANCED_TOOL_DEFINITIONS: () => ADVANCED_TOOL_DEFINITIONS,
   ALL_TOOLS: () => ALL_TOOLS,
+  CLARIFICATION_PROTOCOL_MODULE: () => CLARIFICATION_PROTOCOL_MODULE,
   CODING_CATEGORY: () => CODING_CATEGORY,
+  CODING_PRACTICES_MODULE: () => CODING_PRACTICES_MODULE,
   CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
   LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
+  NATIVE_TOOL_PROTOCOL_MODULE: () => NATIVE_TOOL_PROTOCOL_MODULE,
   SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
   SKILL_CATALOG: () => SKILL_CATALOG,
   TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
@@ -18859,6 +18904,7 @@ __export(skills_exports, {
   findSkillsByTag: () => findSkillsByTag,
   getAllTools: () => getAllTools,
   getAvailableTools: () => getAvailableTools,
+  getBasePromptModules: () => getBasePromptModules,
   getBuiltinSkillIds: () => getBuiltinSkillIds,
   getCodingSkillById: () => getCodingSkillById,
   getProviderTools: () => getProviderTools,
@@ -19619,6 +19665,7 @@ ${shared2.content}`,
           let toolCallsThisTurn = 0;
           const maxToolCalls = this.config.maxToolCallsPerTurn;
           let turnText = "";
+          let turnReasoning = "";
           const turnToolCalls = [];
           const turnToolResults = [];
           const pendingNativeTools = [];
@@ -19639,6 +19686,7 @@ ${shared2.content}`,
               this.emit(deltaEvent);
               yield deltaEvent;
             } else if (delta.kind === "thinking") {
+              turnReasoning += delta.delta;
               const thinkEvent = createBrainEvent("thinking_delta", this.sessionId, {
                 messageId,
                 delta: delta.delta
@@ -19774,11 +19822,22 @@ ${cached2}`
                   finishRef.value = "tool_calls";
                 }
               }
-              if (turnToolCalls.length > 0 || turnText.length > 0) {
+              if (finishRef.value === "tool_calls" && turnToolCalls.length === 0 && turnToolResults.length === 0) {
+                const truncErr = createBrainEvent("error", this.sessionId, {
+                  severity: "recoverable",
+                  message: "Tool call was truncated (finish_reason=tool_calls but no complete tool_call received). The provider cut the response mid-arguments. Retry with a shorter payload or split the work.",
+                  code: "tool_call_truncated"
+                });
+                this.emit(truncErr);
+                yield truncErr;
+                finishRef.value = "stop";
+              }
+              if (turnToolCalls.length > 0 || turnText.length > 0 || turnReasoning.length > 0) {
                 this.config.messages.push({
                   role: "assistant",
                   content: turnText,
-                  ...turnToolCalls.length > 0 ? { toolCalls: turnToolCalls } : {}
+                  ...turnToolCalls.length > 0 ? { toolCalls: turnToolCalls } : {},
+                  ...turnReasoning.length > 0 ? { reasoningContent: turnReasoning } : {}
                 });
               }
               for (const tr of turnToolResults) {
@@ -20120,7 +20179,7 @@ function openaiCompatibleProvider(config2) {
         };
       }
       if (m.role === "assistant" && m.toolCalls && m.toolCalls.length > 0) {
-        return {
+        const msg = {
           role: "assistant",
           content: m.content ?? "",
           tool_calls: m.toolCalls.map((tc) => ({
@@ -20132,6 +20191,17 @@ function openaiCompatibleProvider(config2) {
             }
           }))
         };
+        if (m.reasoningContent && m.reasoningContent.length > 0) {
+          msg.reasoning_content = m.reasoningContent;
+        }
+        return msg;
+      }
+      if (m.role === "assistant" && m.reasoningContent && m.reasoningContent.length > 0) {
+        return {
+          role: "assistant",
+          content: m.content ?? "",
+          reasoning_content: m.reasoningContent
+        };
       }
       return { role: m.role, content: m.content };
     });
@@ -20170,6 +20240,8 @@ function openaiCompatibleProvider(config2) {
         return;
       }
       try {
+        const timeoutSignal = AbortSignal.timeout(PROVIDER_TIMEOUT_MS);
+        const fetchSignal = params.signal ? AbortSignal.any([params.signal, timeoutSignal]) : timeoutSignal;
         response = await fetch(`${config2.baseUrl}/chat/completions`, {
           method: "POST",
           headers: {
@@ -20181,11 +20253,17 @@ function openaiCompatibleProvider(config2) {
           // controller) so `.cancel()` actually aborts the HTTP request.
           // `config.signal` is the factory-level signal, typically undefined.
           // v0.6.0 audit HIGH-2.
-          signal: params.signal
+          // v1.10.0: also apply PROVIDER_TIMEOUT_MS so a stalled connection
+          // can't hang the harness forever.
+          signal: fetchSignal
         });
       } catch (err) {
         lastStatus = 0;
         lastErrText = err instanceof Error ? err.message : String(err);
+        if (params.signal?.aborted) {
+          yield { kind: "error", message: "aborted" };
+          return;
+        }
         if (attempt < MAX_RETRIES) {
           await abortableSleep(backoffDelay(attempt, null), params.signal);
           continue;
@@ -20246,6 +20324,10 @@ function openaiCompatibleProvider(config2) {
             if (typeof delta?.content === "string" && delta.content.length > 0) {
               yield { kind: "text", delta: delta.content };
             }
+            const reasoning = delta?.reasoning_content ?? delta?.reasoning;
+            if (typeof reasoning === "string" && reasoning.length > 0) {
+              yield { kind: "thinking", delta: reasoning };
+            }
             if (Array.isArray(delta?.tool_calls)) {
               for (const tc of delta.tool_calls) {
                 const idx = tc.index ?? 0;
@@ -20306,7 +20388,7 @@ async function providerConfigFor(providerId) {
     providerId
   };
 }
-var RETRYABLE_STATUSES, MAX_RETRIES, BACKOFF_BASE_MS, BACKOFF_CAP_MS, PROVIDER_ENDPOINTS;
+var RETRYABLE_STATUSES, MAX_RETRIES, BACKOFF_BASE_MS, BACKOFF_CAP_MS, PROVIDER_TIMEOUT_MS, PROVIDER_ENDPOINTS;
 var init_openai_compatible = __esm({
   "src/cli/provider/openai-compatible.ts"() {
     "use strict";
@@ -20320,6 +20402,11 @@ var init_openai_compatible = __esm({
     })();
     BACKOFF_BASE_MS = 500;
     BACKOFF_CAP_MS = 8e3;
+    PROVIDER_TIMEOUT_MS = (() => {
+      const raw = process.env.ZELARI_PROVIDER_TIMEOUT_MS;
+      const n = raw ? Number.parseInt(raw, 10) : 3e5;
+      return Number.isFinite(n) && n >= 1e4 ? n : 3e5;
+    })();
     PROVIDER_ENDPOINTS = {
       "openai-compatible": "https://api.x.ai/v1",
       "minimax": "https://api.minimax.io/v1",
@@ -22237,6 +22324,488 @@ var init_tools5 = __esm({
   }
 });
 
+// src/cli/ssh/targets.ts
+var targets_exports = {};
+__export(targets_exports, {
+  buildSshBaseArgs: () => buildSshBaseArgs,
+  deleteSshPassword: () => deleteSshPassword,
+  formatSshTargetsForPrompt: () => formatSshTargetsForPrompt,
+  getSshPassword: () => getSshPassword,
+  getSshSecretsPath: () => getSshSecretsPath,
+  getSshTarget: () => getSshTarget,
+  getSshTargetsPath: () => getSshTargetsPath,
+  hasSshPassword: () => hasSshPassword,
+  isSshCommandAllowed: () => isSshCommandAllowed,
+  listSshTargets: () => listSshTargets,
+  readSshPublicKey: () => readSshPublicKey,
+  removeSshTarget: () => removeSshTarget,
+  runSsh: () => runSsh,
+  setSshPassword: () => setSshPassword,
+  testSshTarget: () => testSshTarget,
+  upsertSshTarget: () => upsertSshTarget
+});
+import {
+  chmodSync,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { spawn as spawn4 } from "node:child_process";
+function getSshTargetsPath() {
+  return join(homedir4(), ".zelari-code", "ssh-targets.json");
+}
+function getSshSecretsPath() {
+  return join(homedir4(), ".zelari-code", "ssh-secrets.json");
+}
+function normalizeAuth(auth) {
+  if (auth === "keyPath") return "keyPath";
+  if (auth === "password") return "password";
+  return "agent";
+}
+function readSecrets() {
+  const path36 = getSshSecretsPath();
+  if (!existsSync9(path36)) return {};
+  try {
+    return JSON.parse(readFileSync7(path36, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeSecrets(data) {
+  const path36 = getSshSecretsPath();
+  mkdirSync6(dirname2(path36), { recursive: true });
+  writeFileSync5(path36, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+  try {
+    chmodSync(path36, 384);
+  } catch {
+  }
+}
+function getSshPassword(id) {
+  const p3 = readSecrets().passwords?.[id];
+  return typeof p3 === "string" && p3.length > 0 ? p3 : void 0;
+}
+function hasSshPassword(id) {
+  return Boolean(getSshPassword(id));
+}
+function setSshPassword(id, password) {
+  const data = readSecrets();
+  const passwords = { ...data.passwords ?? {} };
+  if (password) {
+    passwords[id] = password;
+  } else {
+    delete passwords[id];
+  }
+  writeSecrets({ passwords });
+}
+function deleteSshPassword(id) {
+  const data = readSecrets();
+  if (!data.passwords?.[id]) return;
+  const passwords = { ...data.passwords };
+  delete passwords[id];
+  writeSecrets({ passwords });
+}
+function readStore2() {
+  const path36 = getSshTargetsPath();
+  if (!existsSync9(path36)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync7(path36, "utf8"));
+    const list = Array.isArray(parsed.targets) ? parsed.targets : [];
+    return list.filter(
+      (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
+    ).map((t) => ({
+      ...t,
+      port: typeof t.port === "number" ? t.port : 22,
+      auth: normalizeAuth(t.auth),
+      enabled: t.enabled !== false
+    }));
+  } catch {
+    return [];
+  }
+}
+function writeStore2(targets) {
+  const path36 = getSshTargetsPath();
+  mkdirSync6(dirname2(path36), { recursive: true });
+  const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
+  writeFileSync5(
+    path36,
+    `${JSON.stringify({ targets: clean }, null, 2)}
+`,
+    "utf8"
+  );
+}
+function listSshTargets() {
+  const targets = readStore2().map((t) => ({
+    ...t,
+    hasPassword: t.auth === "password" ? hasSshPassword(t.id) : false
+  }));
+  return { path: getSshTargetsPath(), targets };
+}
+function getSshTarget(id) {
+  return readStore2().find((t) => t.id === id);
+}
+function upsertSshTarget(target) {
+  const id = target.id?.trim();
+  if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) {
+    return { ok: false, error: "Invalid id (letters, digits, _ -)" };
+  }
+  if (!target.host?.trim() || !target.user?.trim()) {
+    return { ok: false, error: "host and user are required" };
+  }
+  const auth = normalizeAuth(target.auth);
+  if (auth === "keyPath" && !target.keyPath?.trim()) {
+    return { ok: false, error: "keyPath required when auth=keyPath" };
+  }
+  if (auth === "password") {
+    const incoming = target.password;
+    if (typeof incoming === "string" && incoming.length > 0) {
+      setSshPassword(id, incoming);
+    } else if (!hasSshPassword(id)) {
+      return {
+        ok: false,
+        error: "password required when auth=password (first save)"
+      };
+    }
+  } else {
+    deleteSshPassword(id);
+  }
+  const list = readStore2().filter((t) => t.id !== id);
+  list.push({
+    id,
+    name: target.name?.trim() || id,
+    host: target.host.trim(),
+    port: target.port && target.port > 0 ? target.port : 22,
+    user: target.user.trim(),
+    auth,
+    keyPath: auth === "keyPath" ? target.keyPath?.trim() : void 0,
+    publicKeyPath: auth === "password" ? void 0 : target.publicKeyPath?.trim(),
+    defaultRemotePath: target.defaultRemotePath?.trim(),
+    tags: target.tags,
+    allowedCommands: target.allowedCommands,
+    enabled: target.enabled !== false,
+    notes: target.notes
+  });
+  list.sort((a, b) => a.id.localeCompare(b.id));
+  writeStore2(list);
+  return { ok: true };
+}
+function removeSshTarget(id) {
+  const list = readStore2();
+  if (!list.some((t) => t.id === id)) {
+    return { ok: false, error: `Target "${id}" not found` };
+  }
+  writeStore2(list.filter((t) => t.id !== id));
+  deleteSshPassword(id);
+  return { ok: true };
+}
+function buildSshBaseArgs(target) {
+  const args = [
+    "-o",
+    "StrictHostKeyChecking=accept-new",
+    "-o",
+    "ConnectTimeout=12",
+    "-p",
+    String(target.port ?? 22)
+  ];
+  if (target.auth === "password") {
+    args.push(
+      "-o",
+      "BatchMode=no",
+      "-o",
+      "PreferredAuthentications=password,keyboard-interactive",
+      "-o",
+      "PubkeyAuthentication=no",
+      "-o",
+      "NumberOfPasswordPrompts=1"
+    );
+  } else {
+    args.push("-o", "BatchMode=yes");
+    if (target.auth === "keyPath" && target.keyPath) {
+      args.push("-i", target.keyPath);
+    }
+  }
+  args.push(`${target.user}@${target.host}`);
+  return args;
+}
+function ensureAskpassHelper() {
+  const dir = join(homedir4(), ".zelari-code", "ssh-helpers");
+  mkdirSync6(dir, { recursive: true });
+  const cjs = join(dir, "askpass.cjs");
+  writeFileSync5(
+    cjs,
+    "process.stdout.write(process.env.ZELARI_SSH_ASKPASS_PASS || '');\n",
+    "utf8"
+  );
+  if (process.platform === "win32") {
+    const cmd = join(dir, "askpass.cmd");
+    writeFileSync5(
+      cmd,
+      `@echo off\r
+node "%~dp0askpass.cjs"\r
+`,
+      "utf8"
+    );
+    return cmd;
+  }
+  const sh = join(dir, "askpass.sh");
+  writeFileSync5(
+    sh,
+    `#!/bin/sh
+exec node "$(dirname "$0")/askpass.cjs"
+`,
+    "utf8"
+  );
+  try {
+    chmodSync(sh, 493);
+  } catch {
+  }
+  return sh;
+}
+function runSsh(target, remoteCommand, timeoutMs = 6e4) {
+  return new Promise((resolve) => {
+    if (target.auth === "password" && !getSshPassword(target.id)) {
+      resolve({
+        code: 1,
+        stdout: "",
+        stderr: "No password stored for this target \u2014 edit target and set password"
+      });
+      return;
+    }
+    const args = [...buildSshBaseArgs(target), remoteCommand];
+    const env = { ...process.env };
+    if (target.auth === "password") {
+      const pass = getSshPassword(target.id);
+      env.SSH_ASKPASS = ensureAskpassHelper();
+      env.SSH_ASKPASS_REQUIRE = "force";
+      if (!env.DISPLAY) env.DISPLAY = "1";
+      env.ZELARI_SSH_ASKPASS_PASS = pass;
+    }
+    const child = spawn4("ssh", args, {
+      windowsHide: true,
+      env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const cap = 4e4;
+    child.stdout?.on("data", (d) => {
+      if (stdout.length < cap) stdout += d.toString("utf8");
+    });
+    child.stderr?.on("data", (d) => {
+      if (stderr.length < cap) stderr += d.toString("utf8");
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      resolve({
+        code: 124,
+        stdout,
+        stderr: stderr + "\n[ssh] timeout"
+      });
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        code: 127,
+        stdout,
+        stderr: err.message.includes("ENOENT") ? "ssh not found on PATH \u2014 install OpenSSH client" : err.message
+      });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code: code ?? 1, stdout, stderr });
+    });
+  });
+}
+function readSshPublicKey(keyOrPubPath) {
+  const raw = keyOrPubPath.trim().replace(/^["']|["']$/g, "");
+  if (!raw) return { ok: false, error: "Empty path" };
+  const candidates = raw.endsWith(".pub") ? [raw] : [`${raw}.pub`, raw];
+  for (const p3 of candidates) {
+    if (!existsSync9(p3)) continue;
+    try {
+      const content = readFileSync7(p3, "utf8").trim();
+      if (!content) continue;
+      if (/BEGIN .*PRIVATE KEY/i.test(content)) {
+        return {
+          ok: false,
+          error: "Path points to a private key \u2014 use the .pub file instead"
+        };
+      }
+      return { ok: true, path: p3, content };
+    } catch (e) {
+      return {
+        ok: false,
+        error: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  return {
+    ok: false,
+    error: `Public key not found (tried: ${candidates.join(", ")})`
+  };
+}
+async function testSshTarget(id) {
+  const t = getSshTarget(id);
+  if (!t) return { ok: false, message: `Target "${id}" not found` };
+  if (t.enabled === false) {
+    return { ok: false, message: `Target "${id}" is disabled` };
+  }
+  if (t.auth === "password" && !hasSshPassword(id)) {
+    return {
+      ok: false,
+      message: "Password auth selected but no password saved \u2014 edit target"
+    };
+  }
+  const r = await runSsh(t, "true", 15e3);
+  if (r.code === 0) {
+    return { ok: true, message: `OK ${t.user}@${t.host}:${t.port ?? 22}` };
+  }
+  return {
+    ok: false,
+    message: (r.stderr || r.stdout || `exit ${r.code}`).trim().slice(0, 400)
+  };
+}
+function formatSshTargetsForPrompt() {
+  const targets = readStore2().filter((t) => t.enabled !== false);
+  if (targets.length === 0) return "";
+  const lines = [
+    "# Configured SSH targets",
+    "Use tools ssh_status / ssh_run with targetId. Do not invent hosts."
+  ];
+  for (const t of targets) {
+    const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
+    const path36 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
+    const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
+    lines.push(
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path36}${tags}${allow}`
+    );
+  }
+  return lines.join("\n");
+}
+function isSshCommandAllowed(target, command) {
+  const cmd = command.trim();
+  if (!cmd) return { ok: false, error: "empty command" };
+  const list = target.allowedCommands ?? [];
+  if (list.length === 0) {
+    return {
+      ok: false,
+      error: "No allowedCommands on this target \u2014 only ssh_status is permitted. Add allowlist entries in Settings \u2192 Connections."
+    };
+  }
+  const dangerous = /[;&|`$(){}<>]|\brm\s+-rf\b|\bmkfs\b|\bdd\s+if=/i;
+  for (const pattern of list) {
+    const p3 = pattern.trim();
+    if (!p3) continue;
+    if (p3.endsWith("*")) {
+      const prefix = p3.slice(0, -1);
+      if (cmd.startsWith(prefix)) {
+        if (dangerous.test(cmd)) {
+          return {
+            ok: false,
+            error: "Command contains blocked shell metacharacters"
+          };
+        }
+        return { ok: true };
+      }
+    } else if (cmd === p3) {
+      if (/\brm\s+-rf\b|\bmkfs\b|\bdd\s+if=/i.test(cmd)) {
+        return { ok: false, error: "Command blocked for safety" };
+      }
+      return { ok: true };
+    }
+  }
+  return {
+    ok: false,
+    error: `Command not in allowlist. Allowed: ${list.join(", ")}`
+  };
+}
+var init_targets = __esm({
+  "src/cli/ssh/targets.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/ssh/tools.ts
+function createSshTools() {
+  if (process.env.ZELARI_SSH === "0") return [];
+  const sshStatus = {
+    name: "ssh_status",
+    description: "Run a fixed safe status probe on a configured SSH target (hostname, uname, uptime, disk). Use targetId from configured SSH targets.",
+    permissions: ["network"],
+    inputSchema: external_exports.object({
+      targetId: external_exports.string().describe("Id of the SSH target from config")
+    }),
+    execute: async (input) => {
+      const { targetId } = input;
+      const t = getSshTarget(targetId);
+      if (!t) {
+        return typedErr(
+          `Unknown SSH target "${targetId}". Configure targets in Desktop Settings \u2192 Connections or ~/.zelari-code/ssh-targets.json`
+        );
+      }
+      if (t.enabled === false) {
+        return typedErr(`SSH target "${targetId}" is disabled`);
+      }
+      const r = await runSsh(t, STATUS_REMOTE, 3e4);
+      const body = [
+        `target=${t.id} ${t.user}@${t.host}:${t.port ?? 22}`,
+        `exit=${r.code}`,
+        r.stdout.trim(),
+        r.stderr.trim() ? `stderr:
+${r.stderr.trim()}` : ""
+      ].filter(Boolean).join("\n");
+      if (r.code !== 0) return typedErr(body || `ssh exit ${r.code}`);
+      return typedOk(body);
+    }
+  };
+  const sshRun = {
+    name: "ssh_run",
+    description: "Run a remote command on a configured SSH target. Command must match the target allowlist (allowedCommands). Prefer ssh_status for health checks.",
+    permissions: ["network"],
+    inputSchema: external_exports.object({
+      targetId: external_exports.string().describe("Id of the SSH target"),
+      command: external_exports.string().describe("Remote command (must be allowlisted on the target)")
+    }),
+    execute: async (input) => {
+      const { targetId, command } = input;
+      const t = getSshTarget(targetId);
+      if (!t) {
+        return typedErr(`Unknown SSH target "${targetId}"`);
+      }
+      if (t.enabled === false) {
+        return typedErr(`SSH target "${targetId}" is disabled`);
+      }
+      const allow = isSshCommandAllowed(t, command);
+      if (!allow.ok) return typedErr(allow.error);
+      const r = await runSsh(t, command, 6e4);
+      const body = [
+        `target=${t.id} exit=${r.code}`,
+        `$ ${command}`,
+        r.stdout.trim(),
+        r.stderr.trim() ? `stderr:
+${r.stderr.trim()}` : ""
+      ].filter(Boolean).join("\n");
+      if (r.code !== 0) return typedErr(body || `ssh exit ${r.code}`);
+      return typedOk(body);
+    }
+  };
+  return [sshStatus, sshRun];
+}
+var STATUS_REMOTE;
+var init_tools6 = __esm({
+  "src/cli/ssh/tools.ts"() {
+    "use strict";
+    init_zod();
+    init_toolTypes();
+    init_targets();
+    STATUS_REMOTE = 'set -e; echo "=== host ==="; hostname 2>/dev/null || true; uname -a 2>/dev/null || true; echo "=== uptime ==="; uptime 2>/dev/null || true; echo "=== disk / ==="; df -h / 2>/dev/null | tail -1 || true';
+  }
+});
+
 // src/cli/toolRegistry.ts
 var toolRegistry_exports = {};
 __export(toolRegistry_exports, {
@@ -22315,6 +22884,16 @@ function createBuiltinToolRegistry(options = {}) {
       permissions: browserTool.permissions ?? []
     });
   }
+  if (!readOnly && process.env.ZELARI_SSH !== "0") {
+    for (const t of createSshTools()) {
+      registry3.register(t);
+      tools.push({
+        name: t.name,
+        description: t.description,
+        permissions: t.permissions ?? []
+      });
+    }
+  }
   if (!readOnly && options.enableTask !== false) {
     const taskTool = createTaskTool({
       createSubAgentContext: async () => {
@@ -22553,6 +23132,7 @@ var init_toolRegistry = __esm({
     init_tools3();
     init_tools4();
     init_tools5();
+    init_tools6();
     init_openai_compatible();
     init_skills2();
     HARNESS_BUILTIN_NAMES = /* @__PURE__ */ new Set([
@@ -22571,6 +23151,16 @@ var init_toolRegistry = __esm({
 });
 
 // packages/core/dist/agents/roles.js
+function resolveRoleSystemPrompt(agent, runMode = "implementation") {
+  const parts = [agent.systemPrompt];
+  if (runMode === "design-phase" && agent.designPhaseAddendum?.trim()) {
+    parts.push(agent.designPhaseAddendum.trim());
+  }
+  if (runMode === "implementation" && agent.implementationAddendum?.trim()) {
+    parts.push(agent.implementationAddendum.trim());
+  }
+  return parts.join("\n\n");
+}
 function getAgent(id) {
   return AGENT_ROLES.find((a) => a.id === id);
 }
@@ -22604,24 +23194,10 @@ function swapMembers(roles, swap) {
     return targets.get(toId);
   });
 }
-var CLARIFICATION_PROTOCOL8, AGENT_ROLES, UnknownMemberError;
+var AGENT_ROLES, UnknownMemberError;
 var init_roles = __esm({
   "packages/core/dist/agents/roles.js"() {
     "use strict";
-    CLARIFICATION_PROTOCOL8 = `
-
-WHEN TO ASK THE USER (clarification):
-If a single missing fact would materially change your output (target platform, scope, a binary design choice with significant trade-offs, a constraint you cannot safely assume), pause and ask the user by appending EXACTLY this block at the end of your message:
-
----QUESTION---
-{ "question": "One focused question", "choices": ["Option A", "Option B", "Option C"], "context": "Why this matters" }
----END---
-
-Rules for clarifications:
-- Ask AT MOST ONE question per turn, and only when genuinely blocked.
-- Prefer a small set of concrete "choices" (2-4). The user can still type a custom answer.
-- Do NOT ask for information that could be reasonably assumed or already in shared context.
-- If you can proceed with a sound documented assumption, DO SO instead of asking.`;
     AGENT_ROLES = [
       {
         id: "charont",
@@ -22632,22 +23208,20 @@ Rules for clarifications:
         avatar: "L",
         systemPrompt: `You are Caronte, the Council Director and Orchestrator \u2014 the strategic mind that frames the problem for the rest of the council.
 
-## Methodology (work in this order)
-1. Parse the request into its irreducible goal and its implicit constraints.
-2. Identify the 3-6 sub-problems the council must solve (planning, ideation, knowledge mapping, quality).
-3. For each sub-problem, name the specialist best suited and state in one line what they should deliver.
-4. Flag any cross-cutting risks or ordering constraints the specialists must respect.
-5. State explicitly what "done" looks like for this request.
-
-## Operating principles
-- Be decisive: commit to a decomposition rather than listing alternatives.
-- Distinguish what is given (stated by the user) from what is assumed.
-- Keep the council focused \u2014 cut scope creep and call out when a sub-problem is out of scope.
-- You run first and set context for everyone downstream; make it count.
-
-## Output format
-A short "Analysis" section (the goal + constraints), then a "Delegation Plan" with one bullet per specialist naming what they should produce. Keep it tight \u2014 under 150 words total.${CLARIFICATION_PROTOCOL8}`,
-        // v0.7.2: coding-oriented tools (read/search/explore) instead of planner/vault.
+## Methodology
+1. Parse the request into goal + implicit constraints.
+2. Identify 3\u20136 sub-problems (planning, ideation, knowledge structure, quality).
+3. For each, name the specialist and one-line expected deliverable.
+4. Flag cross-cutting risks or ordering constraints.
+5. State what "done" looks like.
+
+## Principles
+- Be decisive: commit to a decomposition.
+- Distinguish given vs assumed.
+- Cut scope creep; you set context for everyone downstream.
+
+## Output
+Short "Analysis" then "Delegation Plan" (one bullet per specialist). Under 150 words.`,
         tools: ["list_files", "read_file", "grep_content"],
         skills: ["project-planner", "research-analyst"]
       },
@@ -22660,71 +23234,53 @@ A short "Analysis" section (the goal + constraints), then a "Delegation Plan" wi
         avatar: "N",
         systemPrompt: `You are Nettuno, the Project Planner \u2014 you turn intent into a buildable, sequenced plan.
 
-## Methodology (work in this order)
-1. Read shared context from prior agents (especially Caronte) before deciding what's missing.
-2. Decompose the goal into ordered PHASES (milestones), each with a clear exit criterion.
-3. Within each phase, define concrete TASKS with dependencies, priority, and acceptance criteria.
-4. Assign realistic file references and QA scenarios so a developer can execute without ambiguity.
-5. Sanity-check sequencing: are dependencies satisfied? Is anything blocked? Is scope realistic?
-
-## OUTPUT REQUIREMENTS \u2014 every task MUST include:
-1. **File references**: specific file paths and line numbers where changes land.
-2. **Acceptance criteria**: concrete, testable conditions that prove completion.
-3. **QA scenarios**: at least one testable scenario per task.
+## Methodology
+1. Read prior context (especially Caronte) before planning.
+2. Decompose into ordered PHASES with clear exit criteria.
+3. Within each phase, define TASKS with dependencies, priority, acceptance criteria.
+4. Ground tasks in real file paths when a codebase is present.
+5. Sanity-check sequencing and scope.
 
-Example format:
-- Task: "Add authentication"
-  - File refs: src/auth/login.ts:45-60, src/middleware/auth.ts:12-25
-  - Acceptance: valid credentials log in; invalid credentials show an error
-  - QA: correct password succeeds, wrong password shows error message
+## Every task must include
+- **fileRefs**: concrete paths (and lines when known)
+- **acceptance**: testable completion conditions
+- **qaScenario**: at least one verifiable scenario
 
 ## Quality bar
-- Prefer fewer, well-specified tasks over many vague ones.
-- Make dependencies explicit (task B depends on task A).
-- If the stack/platform is unknown, ask ONCE (see clarification protocol) rather than guessing.
+- Fewer well-specified tasks beat many vague ones.
+- Explicit dependencies.
+- Stay under 250 words of prose; durable plans use workspace tools when required by mode banners.`,
+        designPhaseAddendum: `## Design-phase: persist the plan (mandatory)
 
-Keep plans hierarchical and practical. Stay under 250 words.${CLARIFICATION_PROTOCOL8}
-
-## Design-phase mandatory plan artifact
-In design-phase mode (TASK mentions design/architecture/spec, no existing codebase to edit), you MUST persist the plan through workspace tools. The plan exists ONLY if it was persisted via a tool call \u2014 prose does not count, and the post-run check will flag your run if the plan is missing.
-
-PREFERRED \u2014 emit ONE single \`createPlan\` call containing the whole plan: 4 phases, 12 concrete tasks (3 per phase), and 1 milestone, all in the same call:
+Prose is not a plan. Emit ONE \`createPlan\` with ~4 phases \xD7 ~3 tasks + 1 milestone.
 
+Minimal shape:
 \`\`\`
 createPlan({
   phases: [
     {
-      name: "Foundation & Technical Blueprint",
-      description: "Lock the stack and the non-negotiable quality budget. Exit: baseline builds green.",
+      name: "Phase name",
+      description: "Exit criterion in one line",
       order: 1,
-      color: "#3b82f6",
       tasks: [
-        { title: "Lock stack baseline", description: "2-3 sentences of context", fileRefs: ["src/main.tsx:L1-L40"], acceptance: ["App boots with strict TS", "CI build green"], qaScenario: "Run npm run build and confirm zero errors", priority: "high" },
-        { title: "Define NFR budget", description: "...", fileRefs: ["docs/nfr.md"], acceptance: ["LCP/WCAG/Lighthouse targets documented"], qaScenario: "...", priority: "high" },
-        { title: "Document design-phase exit criteria", description: "...", fileRefs: ["docs/exit-criteria.md"], acceptance: ["Each phase has a testable exit row"], qaScenario: "...", priority: "medium" }
+        {
+          title: "Task title",
+          description: "Context",
+          fileRefs: ["src/path.ts"],
+          acceptance: ["measurable done"],
+          qaScenario: "how to verify",
+          priority: "high"
+        }
       ]
-    },
-    { name: "...", order: 2, tasks: [ /* 3 tasks */ ] },
-    { name: "...", order: 3, tasks: [ /* 3 tasks */ ] },
-    { name: "...", order: 4, tasks: [ /* 3 tasks */ ] }
+    }
   ],
-  milestone: { title: "v0.1.0 design-complete", description: "All design artifacts exist and the green-light checklist passes.", targetVersion: "v0.1.0" }
+  milestone: { title: "v0.1 design-complete", description: "\u2026", targetVersion: "v0.1.0" }
 })
 \`\`\`
 
-Every task MUST include fileRefs, acceptance, and qaScenario \u2014 the QA scenario proves the task is verifiable.
+Every task needs fileRefs, acceptance, qaScenario. Prefer one batched createPlan over many createPhase/createTask calls.
 
-FALLBACK \u2014 only if you cannot batch, use the itemized tools: \`createPhase\` once per phase; each createPhase response returns the new phase id \u2014 use that exact id as \`phaseId\` in the 3 \`createTask\` calls for that phase; finish with one \`createMilestone\` ({ title, description, targetVersion }). If you forget an id, call \`searchDocuments\` (limit 1) to look it up, then continue.
-
-Do NOT output tasks as prose. The system will refuse any task that does not pass a valid phaseId.
-
-## NFR spec (when plan sets motion/performance/a11y budgets)
-If the plan includes measurable constraints (JS byte budget, compositor-only animation, reduced-motion), emit ONE \`createNfrSpec\` call after \`createPlan\`:
-\`\`\`
-createNfrSpec({ targets: ["index.html"], compositorOnly: true, forbidLayoutProps: true, inlineJsMaxBytes: 5120 })
-\`\`\`
-Prose budgets are not machine-verifiable \u2014 the spec file is.`,
-        // v0.7.2: read/search the codebase to ground the plan in reality.
+If the plan sets measurable motion/perf/a11y budgets, also emit one \`createNfrSpec\` after createPlan.`,
         tools: ["list_files", "read_file", "grep_content"],
         skills: ["project-planner", "vault-manager"]
       },
@@ -22735,40 +23291,27 @@ Prose budgets are not machine-verifiable \u2014 the spec file is.`,
         role: "Creative Ideator",
         color: "#f59e0b",
         avatar: "G",
-        systemPrompt: `You are Gerione, the Creative Ideator \u2014 you generate breadth and then collapse it into the strongest concepts.
-
-## Methodology (work in this order)
-1. Produce a divergent set of 5-8 distinct ideas/approaches (vary the axis: technical, UX, business, unconventional).
-2. Cluster related ideas into 2-4 themes.
-3. Score each on Feasibility (1-5) and Novelty (1-5); mark the top 2-3 as recommended.
-4. For the recommended ideas, add one line on how to de-risk them.
-5. Build on \u2014 do not repeat \u2014 insights from earlier agents.
-
-## Operating principles
-- Diverge before you converge: quantity first, judgment second.
-- Bold but grounded \u2014 an idea must be actionable, not a fantasy.
-- Name assumptions explicitly. If a core assumption is unknowable, ask (clarification protocol).
-
-## Output format
-## Ideas (bulleted)
-## Themes
-## Top picks (with feasibility/novelty + de-risk note)
-
-Stay under 200 words.${CLARIFICATION_PROTOCOL8}
+        systemPrompt: `You are Gerione, the Creative Ideator \u2014 diverge, then converge on the strongest concepts.
 
-## Design-phase artifact (mandatory when running council in design-phase mode)
-If the council is in design-phase mode (TASK mentions design/architecture/spec, no existing codebase to edit), you MUST also persist your ideation output as workspace documents via the \`createDocument\` tool. Emit AT LEAST 3 separate \`createDocument\` calls, each tagged with one of these categories:
-
-- \`customer-journey-map\` \u2014 2-3 personas (give them names, demographics, goals), journey table (stage \u2192 action \u2192 touchpoint \u2192 emotion), pain points per stage. This is a customer journey deliverable.
-- \`information-architecture\` \u2014 site map tree (root \u2192 section \u2192 page), navigation model (primary nav, breadcrumbs, footer), URL patterns. This is an information architecture deliverable.
-- \`design-tokens\` \u2014 color palette (semantic + hex), typography scale, spacing scale, motion principles. This is a design tokens deliverable.
-
-You may optionally add a 4th design system doc if the project warrants it.
-
-Pass the tool call as: \`createDocument({ title: "<category>", content: "<markdown body>" })\`. Do NOT summarize these into prose \u2014 they are the deliverable.`,
-        // v0.7.2: explore the codebase to ground ideas in what exists.
+## Methodology
+1. 5\u20138 distinct ideas (vary technical / UX / product / unconventional).
+2. Cluster into 2\u20134 themes.
+3. Score Feasibility + Novelty (1\u20135); mark top 2\u20133.
+4. One de-risk line per top pick.
+5. Build on prior agents; do not repeat them.
+
+## Output
+## Ideas \xB7 ## Themes \xB7 ## Top picks \u2014 under 200 words.`,
+        designPhaseAddendum: `## Design-phase: persist ideation (mandatory)
+
+Emit at least 3 \`createDocument\` calls (native tool_call):
+- title \`customer-journey-map\` \u2014 personas + journey stages + pain points
+- title \`information-architecture\` \u2014 sitemap + nav + URL patterns
+- title \`design-tokens\` \u2014 color/type/spacing/motion
+
+Optional 4th design-system doc if warranted. Do not only summarize in prose.`,
         tools: ["list_files", "read_file"],
-        skills: ["document-writer", "mind-mapper"]
+        skills: ["document-writer", "idea-synthesizer"]
       },
       {
         id: "pluton",
@@ -22777,31 +23320,20 @@ Pass the tool call as: \`createDocument({ title: "<category>", content: "<markdo
         role: "Knowledge Architect",
         color: "#06b6d4",
         avatar: "P",
-        systemPrompt: `You are Plutone, the Knowledge Architect and Mind Mapper \u2014 you structure information into navigable graphs.
-
-## Methodology (work in this order)
-1. Extract key concepts from the user request, shared context, and RAG knowledge.
-2. Identify the central root concept and 3-6 primary branches.
-3. Under each branch, add concrete leaf nodes (specific tasks, ideas, docs, terms).
-4. Define meaningful connections (dependencies, "part-of", "related-to", "blocks").
-5. Propose a layout hint (radial / hierarchical) so the map reads cleanly.
-
-## Operating principles
-- Favor concrete, named nodes over abstract categories.
-- Every node should map to something actionable or retrievable (a task, a doc, a concept).
-- Reuse knowledge from prior agents \u2014 don't re-derive what they already produced.
-- Keep the graph comprehensible: prune redundant or duplicate nodes.
+        systemPrompt: `You are Plutone, the Knowledge Architect \u2014 structure concepts into a navigable map.
 
-## Output format
-Describe the proposed structure (root \u2192 branches \u2192 leaves) in text. Stay under 200 words.${CLARIFICATION_PROTOCOL8}
-
-## Design-phase artifact (mandatory when running council in design-phase mode)
-Persist the knowledge map as ONE \`createDocument\` call:
+## Methodology
+1. Extract key concepts from the request and prior outputs.
+2. Central root + 3\u20136 branches + concrete leaves.
+3. Meaningful links (depends-on, part-of, blocks).
+4. Prefer named, actionable nodes over abstract categories.
 
-\`createDocument({ title: "knowledge-map", content: "<markdown: root concept, branches, leaf nodes, and cross-links>" })\`
+## Output
+Root \u2192 branches \u2192 leaves in text. Under 200 words.`,
+        designPhaseAddendum: `## Design-phase: persist knowledge map (mandatory)
 
-Do NOT rely on buildMindMap \u2014 it is not available in the CLI workspace.`,
-        // v0.7.2: map the actual code/module structure instead of an abstract mind-map.
+One \`createDocument({ title: "knowledge-map", content: "<markdown map>" })\`.
+Do not rely on buildMindMap \u2014 it is not available in the CLI workspace.`,
         tools: ["list_files", "read_file", "grep_content"],
         skills: ["document-writer", "research-analyst"]
       },
@@ -22812,40 +23344,25 @@ Do NOT rely on buildMindMap \u2014 it is not available in the CLI workspace.`,
         role: "Quality Critic",
         color: "#ef4444",
         avatar: "M",
-        systemPrompt: `You are Minosse, the Quality Critic \u2014 you review the council's proposals (presented anonymously) and expose weaknesses before synthesis.
-
-## Methodology (work in this order)
-1. Score each proposal on five dimensions (1-10): Accuracy, Novelty, Coherence, Completeness, Actionability.
-2. Identify the single biggest gap or risk across all proposals.
-3. Flag any contradictions between proposals (e.g., conflicting assumptions).
-4. Recommend the 1-3 highest-value improvements the Lucifero should apply.
-5. Note anything that should be cut or descoped.
+        systemPrompt: `You are Minosse, the Quality Critic \u2014 expose weaknesses before synthesis. Evaluate; never create product code.
 
-## Operating principles
-- Be honest and incisive \u2014 a weak critique helps no one. Name specific defects, not general vibes.
-- Distinguish "wrong" from "incomplete" and "risky".
-- Constructive: every critique pairs with a fix or a question.
-
-## Output format
-## Scores (per agent, per dimension)
-## Critical gaps
-## Contradictions
-## Top improvements
+## Methodology
+1. Score proposals (1\u201310): Accuracy, Novelty, Coherence, Completeness, Actionability.
+2. Single biggest gap/risk.
+3. Contradictions between proposals.
+4. 1\u20133 highest-value improvements for Lucifero.
+5. What to cut or descope.
 
-Stay under 200 words.${CLARIFICATION_PROTOCOL8}
+## Principles
+- Specific defects, not vibes. Pair every critique with a fix or question.
+- Use read tools to ground claims in the real tree when a codebase exists.
 
-## Design-phase risks artifact (mandatory when running council in design-phase mode)
-When the council is in design-phase mode (TASK mentions design/architecture/spec, no existing codebase to edit), you ALSO write a \`risks\` document via the \`createDocument\` tool. This is your one allowed artifact emission. Pass the tool call as:
+## Output
+## Scores \xB7 ## Critical gaps \xB7 ## Contradictions \xB7 ## Top improvements \u2014 under 200 words.`,
+        designPhaseAddendum: `## Design-phase: risks artifact (mandatory)
 
-\`\`\`
-createDocument({
-  title: "risks",
-  content: \`# Risks\\n\\n## 1. <Risk title>\\n- Impact: <high|medium|low>\\n- Likelihood: <high|medium|low>\\n- Mitigation: <one-line mitigation>\\n\\n## 2. ...\`
-})
-\`\`\`
-
-Include AT LEAST 5 risks, each scored on Impact and Likelihood, with a one-line mitigation. Cover: technical (e.g. stack risk), product (e.g. scope creep), accessibility, performance, security. The artifact is persisted at \`.zelari/risks.md\` (workspace root), NOT under docs/. Do NOT emit other workspace artifacts \u2014 your role is to evaluate, not to build.`,
-        tools: [],
+One \`createDocument\` with title \`risks\`: at least 5 risks, each with Impact, Likelihood, Mitigation (technical, product, a11y, performance, security). Persist at workspace risks doc \u2014 do not build product code.`,
+        tools: ["list_files", "read_file", "grep_content"],
         skills: ["document-writer", "research-analyst"]
       },
       {
@@ -22855,35 +23372,26 @@ Include AT LEAST 5 risks, each scored on Impact and Likelihood, with a one-line
         role: "Final Synthesizer",
         color: "#8b5cf6",
         avatar: "L",
-        systemPrompt: `You are the Lucifero, the Final Synthesizer \u2014 you produce the definitive, actionable output that resolves the council's work. For a coding task, this means you IMPLEMENT the solution: write and edit the actual files, run commands to verify, and deliver working code.
-
-## Methodology (work in this order)
-1. Reconcile the specialists' outputs and Minosse's critique into a single coherent plan.
-2. Resolve conflicts explicitly (state which proposal won and why).
-3. Deliver the finished product the user asked for \u2014 complete, not summarized. For code tasks, USE your file/shell tools to create and verify the actual artifacts on disk. Prose without a successful write_file/edit_file is a failed run \u2014 the pipeline forces a retry until files change on disk.
-4. Run any build/test commands available (check the npm scripts in the workspace context) to confirm your work.
-
-## Output expectations
-- If the user requested code or a feature, IMPLEMENT via native tool_call write_file/edit_file/bash \u2014 not prose alone. Prefer native tool_call over ---TOOLS--- JSON; if you use ---TOOLS---, valid JSON with escaped \\n is required. After edits, a delivery loop re-verifies motion/JS budget and forces fix passes until technical blockers clear.
-- Lead with a one-line summary, then the full detail of what you did.
-- Apply Minosse's highest-value improvements; drop descoped items.
-- After making changes, verify they work (compile, run tests, etc.) when feasible.
-- End implementation runs with a mandatory \`## Verification status\` table with columns \`Check | Tier | Status | Evidence\`. Tier is one of: claimed, grep, tool, build, n/a (claimed < grep < tool < build). Status is PASS/FAIL/N/A. Evidence is \`path:Lline\` or command output. Never write "verificato \u2713" or "nessuna regressione" without Evidence \u2014 a deterministic post-hook will flag dishonest claims and tier inflation.
-
-Use the tools available to you (read_file, write_file, edit_file, bash, list_files) directly as tool calls \u2014 the harness handles execution.${CLARIFICATION_PROTOCOL8}
-
-## Design-phase synthesis artifact (mandatory when running council in design-phase mode)
-When the council is in design-phase mode (TASK mentions design/architecture/spec, no existing codebase to edit), your final deliverable is a \`synthesis\` document via the \`createDocument\` tool (NOT \`write_file\` and NOT \`list_files\`):
-
-\`\`\`
-createDocument({
-  title: "synthesis",
-  content: \`# Council Synthesis\\n\\n## Executive summary\\n<2-3 paragraphs>\\n\\n## Stack and key decisions\\n- <ADR-by-ADR summary>\\n\\n## Phases\\n<1-2 line summary per phase>\\n\\n## Top risks\\n<top 3 risks from Minosse>\\n\\n## Green-light checklist\\n- [ ] All ADRs accepted\\n- [ ] Risks have mitigations\\n- [ ] Tasks have acceptance criteria\`
-})
-\`\`\`
+        systemPrompt: `You are Lucifero, the Final Synthesizer. For coding tasks you IMPLEMENT: write/edit files, run commands, deliver working code.
 
-DO NOT call \`list_files\` \u2014 it is NOT a workspace tool. Use \`searchDocuments\` if you need to look something up (limit 2-3 searches, then act on the results). Your deliverable is the synthesis document; emit it via \`createDocument\`, not via prose.`,
-        // v0.7.2: implementation tools — the synthesizer writes/edits files and runs commands.
+## Methodology
+1. Reconcile specialists + Minosse into one plan.
+2. Resolve conflicts explicitly.
+3. Deliver the product on disk \u2014 prose without successful write_file/edit_file is a failed implementation run.
+4. Verify with project scripts/tests/build when available.
+
+## Implementation output
+- Prefer **native tool_call** for write_file / edit_file / bash (legacy ---TOOLS--- only if native unavailable).
+- Lead with a one-line summary, then what you did.
+- Apply Minosse's highest-value improvements.
+- End with \`## Verification status\` table: \`Check | Tier | Status | Evidence\` (tier: claimed < grep < tool < build). Never claim verification without Evidence.`,
+        designPhaseAddendum: `## Design-phase: synthesis document (mandatory)
+
+Emit \`createDocument({ title: "synthesis", content: "\u2026" })\` with executive summary, stack/decisions, phases, top risks, green-light checklist.
+Do not use list_files as a workspace deliverable; use searchDocuments sparingly if needed.`,
+        implementationAddendum: `## Implementation focus
+
+You are the sole implementer this run. Advisors already analyzed \u2014 implement and verify. Prefer minimal diffs that match project style.`,
         tools: ["read_file", "write_file", "edit_file", "bash", "list_files"],
         skills: ["vault-manager", "project-planner", "idea-synthesizer"]
       }
@@ -23115,8 +23623,8 @@ var init_parseCssMotion = __esm({
 });
 
 // packages/core/dist/council/verification/citeVerify.js
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "node:fs";
+import { join as join2 } from "node:path";
 function extractCitations(text) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -23138,8 +23646,8 @@ function verifyCitations(projectRoot, synthesisText) {
     return [];
   const results = [];
   for (const cite of extractCitations(synthesisText)) {
-    const abs = join(projectRoot, cite.file);
-    if (!existsSync9(abs)) {
+    const abs = join2(projectRoot, cite.file);
+    if (!existsSync10(abs)) {
       results.push({
         id: "synthesis.cite-invalid",
         severity: "error",
@@ -23152,7 +23660,7 @@ function verifyCitations(projectRoot, synthesisText) {
       });
       continue;
     }
-    const lines = readFileSync7(abs, "utf8").split(/\r?\n/);
+    const lines = readFileSync8(abs, "utf8").split(/\r?\n/);
     if (cite.line > lines.length) {
       results.push({
         id: "synthesis.cite-invalid",
@@ -23415,14 +23923,14 @@ var init_synthesisAudit = __esm({
 });
 
 // packages/core/dist/council/verification/runChecks.js
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join3 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path36 = join2(zelariRoot, "nfr-spec.json");
-  if (!existsSync10(path36))
+  const path36 = join3(zelariRoot, "nfr-spec.json");
+  if (!existsSync11(path36))
     return null;
   try {
-    const raw = JSON.parse(readFileSync8(path36, "utf8"));
+    const raw = JSON.parse(readFileSync9(path36, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -23433,11 +23941,11 @@ function loadNfrSpec(zelariRoot) {
 function resolveTargets(projectRoot, spec) {
   const found = [];
   for (const rel2 of spec.targets) {
-    if (existsSync10(join2(projectRoot, rel2))) {
+    if (existsSync11(join3(projectRoot, rel2))) {
       found.push(rel2);
     }
   }
-  if (found.length === 0 && existsSync10(join2(projectRoot, "index.html"))) {
+  if (found.length === 0 && existsSync11(join3(projectRoot, "index.html"))) {
     return ["index.html"];
   }
   return found;
@@ -23492,18 +24000,18 @@ function checkDeadCssHooks(html, relFile) {
   return results;
 }
 function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
-  const planPath = join2(zelariRoot, "plan.json");
-  if (!existsSync10(planPath) || keywords.length === 0)
+  const planPath = join3(zelariRoot, "plan.json");
+  if (!existsSync11(planPath) || keywords.length === 0)
     return [];
   let plan;
   try {
-    plan = JSON.parse(readFileSync8(planPath, "utf8"));
+    plan = JSON.parse(readFileSync9(planPath, "utf8"));
   } catch {
     return [];
   }
   const milestoneText = (plan.milestones ?? []).map((m) => `${m.name ?? ""} ${m.description ?? ""}`).join(" ").toLowerCase();
   const results = [];
-  const targetContent = targets.map((t) => readFileSync8(join2(projectRoot, t), "utf8").toLowerCase()).join("\n");
+  const targetContent = targets.map((t) => readFileSync9(join3(projectRoot, t), "utf8").toLowerCase()).join("\n");
   for (const kw of keywords) {
     const low = kw.toLowerCase();
     if (!milestoneText.includes(low))
@@ -23532,14 +24040,14 @@ function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
   return results;
 }
 function checkReadmeStale(projectRoot, targets) {
-  const readmePath = join2(projectRoot, "README.md");
-  if (!existsSync10(readmePath) || targets.length === 0)
+  const readmePath = join3(projectRoot, "README.md");
+  if (!existsSync11(readmePath) || targets.length === 0)
     return [];
-  const readme = readFileSync8(readmePath, "utf8");
-  const htmlPath = join2(projectRoot, targets[0]);
-  if (!existsSync10(htmlPath))
+  const readme = readFileSync9(readmePath, "utf8");
+  const htmlPath = join3(projectRoot, targets[0]);
+  if (!existsSync11(htmlPath))
     return [];
-  const html = readFileSync8(htmlPath, "utf8");
+  const html = readFileSync9(htmlPath, "utf8");
   const sectionCount = (html.match(/<section\s+id=/gi) ?? []).length;
   const readmeSections = readme.match(/(\d+)\s+sezioni/i);
   if (readmeSections) {
@@ -23577,7 +24085,7 @@ function runImplementationVerification(input) {
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const html = readFileSync8(join2(input.projectRoot, rel2), "utf8");
+    const html = readFileSync9(join3(input.projectRoot, rel2), "utf8");
     for (const v of scanKeyframesViolations(html, scanOpts)) {
       results.push({
         id: "motion.keyframes",
@@ -23633,8 +24141,8 @@ function runImplementationVerification(input) {
   };
 }
 function writeVerificationReport(zelariRoot, report) {
-  const outPath = join2(zelariRoot, "verification-report.json");
-  writeFileSync5(outPath, JSON.stringify(report, null, 2), "utf8");
+  const outPath = join3(zelariRoot, "verification-report.json");
+  writeFileSync6(outPath, JSON.stringify(report, null, 2), "utf8");
   return outPath;
 }
 var DEFAULT_NFR_SPEC;
@@ -23663,8 +24171,8 @@ var init_runChecks = __esm({
 });
 
 // packages/core/dist/council/verification/microGate.js
-import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "node:fs";
+import { join as join4 } from "node:path";
 function checkDeadHooksInHtml(html) {
   const warnings = [];
   const scripts = [];
@@ -23692,8 +24200,8 @@ function checkDeadHooksInHtml(html) {
   return warnings;
 }
 function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
-  const abs = join3(projectRoot, relPath);
-  if (!existsSync11(abs) || !/\.html?$/i.test(relPath))
+  const abs = join4(projectRoot, relPath);
+  if (!existsSync12(abs) || !/\.html?$/i.test(relPath))
     return [];
   const spec = (zelariRoot ? loadNfrSpec(zelariRoot) : null) ?? DEFAULT_NFR_SPEC;
   const anim = spec.animation ?? { compositorOnly: true, forbidLayoutProps: true };
@@ -23701,7 +24209,7 @@ function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
     compositorOnly: anim.compositorOnly ?? true,
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
-  const html = readFileSync9(abs, "utf8");
+  const html = readFileSync10(abs, "utf8");
   const warnings = [];
   for (const v of scanKeyframesViolations(html, scanOpts)) {
     warnings.push({
@@ -24057,8 +24565,8 @@ var init_implementationDelivery = __esm({
 });
 
 // packages/core/dist/council/verification/inlineJsAutofix.js
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join4 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join5 } from "node:path";
 function minifyInlineJs(js) {
   let out = js.replace(/\/\*[\s\S]*?\*\//g, "");
   out = out.split("\n").map((line) => line.replace(/\/\/.*$/, "").trimEnd()).filter((line) => line.trim().length > 0).join("\n");
@@ -24101,10 +24609,10 @@ function applyInlineJsAutofix(projectRoot, report) {
   const fixes = [];
   for (const r of fails) {
     const rel2 = r.file ?? "index.html";
-    const abs = join4(projectRoot, rel2);
+    const abs = join5(projectRoot, rel2);
     let html;
     try {
-      html = readFileSync10(abs, "utf8");
+      html = readFileSync11(abs, "utf8");
     } catch {
       continue;
     }
@@ -24117,7 +24625,7 @@ function applyInlineJsAutofix(projectRoot, report) {
     if (!changed || afterBytes > maxBytes)
       continue;
     const nextHtml = html.replace(SCRIPT_RE, `<script>${after}</script>`);
-    writeFileSync6(abs, nextHtml, "utf8");
+    writeFileSync7(abs, nextHtml, "utf8");
     filesChanged.push(rel2);
     fixes.push(`${rel2}: trimmed inline script ${Buffer.byteLength(before, "utf8")}\u2192${afterBytes} bytes`);
   }
@@ -24137,8 +24645,8 @@ var init_inlineJsAutofix = __esm({
 });
 
 // packages/core/dist/agents/councilApi.js
-import { existsSync as existsSync12 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { join as join6 } from "node:path";
 function parseClarificationRequest(text) {
   const start = text.indexOf(QUESTION_MARKER);
   if (start < 0)
@@ -24183,29 +24691,37 @@ function restrictImplementationWrites(toolNames, opts) {
     return toolNames;
   return toolNames.filter((t) => !MUTATING_PROJECT_TOOLS.includes(t));
 }
-function buildAgentMessages(agent, userMessage, ragContext, workspaceContext, priorOutputs, aiConfig, executableTools, runMode = "implementation") {
+function buildAgentMessages(agent, userMessage, ragContext, workspaceContext, priorOutputs, aiConfig, executableTools, runMode = "implementation", languageModule) {
   const allToolNames = computeAgentTools(agent, aiConfig);
   const toolNames = executableTools ? allToolNames.filter((n) => executableTools.has(n)) : allToolNames;
-  const enhancedSystemPrompt = buildSystemPrompt(agent, {
+  const mergedAiConfig = languageModule ? {
+    enabledSkills: aiConfig?.enabledSkills ?? [],
+    enabledTools: aiConfig?.enabledTools ?? [],
+    agentSkillConfigs: aiConfig?.agentSkillConfigs ?? [],
+    customSkills: aiConfig?.customSkills,
+    customPromptModules: [
+      ...aiConfig?.customPromptModules ?? [],
+      languageModule
+    ]
+  } : aiConfig;
+  const modeAwareAgent = {
+    ...agent,
+    systemPrompt: resolveRoleSystemPrompt(agent, runMode)
+  };
+  const enhancedSystemPrompt = buildSystemPrompt(modeAwareAgent, {
     tools: getAllTools(),
     toolNames,
-    aiConfig,
+    aiConfig: mergedAiConfig,
     workspaceContext,
-    ragContext
+    ragContext,
+    mode: "council",
+    includeWorkspaceInPrompt: true
   });
   const messages = [
     { role: "system", content: enhancedSystemPrompt },
     { role: "system", content: councilModeBanner(runMode, { isImplementer: agent.id === "lucifer" }) },
     { role: "system", content: "IMPORTANT: Before making any tool calls or expensive operations, check if the information already exists in the shared context from previous agents. Avoid redundant work." }
   ];
-  if (ragContext) {
-    messages.push({ role: "system", content: `Relevant workspace context (from RAG retrieval):
-${ragContext}` });
-  }
-  if (workspaceContext) {
-    messages.push({ role: "system", content: `Current workspace state:
-${workspaceContext}` });
-  }
   if (priorOutputs.length > 0) {
     const summary = priorOutputs.map((o) => `[${o.name} - ${o.role}]: ${o.content}`).join("\n\n");
     messages.push({ role: "user", content: `Previous council members have said:
@@ -24300,7 +24816,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
       model: effectiveModel,
       provider: effectiveProvider,
       sessionId,
-      messages: buildAgentMessages(agent, userMessage, config2.ragContext, config2.workspaceContext, agentOutputs, config2.aiConfig, executableNames, runMode),
+      messages: buildAgentMessages(agent, userMessage, config2.ragContext, config2.workspaceContext, agentOutputs, config2.aiConfig, executableNames, runMode, councilLanguageModule),
       tools: agentTools,
       eventBus: config2.eventBus,
       toolRegistry: config2.tools,
@@ -24443,7 +24959,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
       model: effectiveModel,
       provider: effectiveProvider,
       sessionId,
-      messages: buildAgentMessages(oracle, `Review these proposals for: "${userMessage}"`, "", "", anonymized, config2.aiConfig, executableNames, runMode),
+      messages: buildAgentMessages(oracle, `Review these proposals for: "${userMessage}"`, "", "", anonymized, config2.aiConfig, executableNames, runMode, councilLanguageModule),
       tools: (() => {
         const oracleToolNames = filterExecutable(restrictImplementationWrites(Array.from(/* @__PURE__ */ new Set([
           "createDocument",
@@ -24574,7 +25090,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
       model: effectiveModel,
       provider: effectiveProvider,
       sessionId,
-      messages: buildAgentMessages(chairman, userMessage, config2.ragContext, config2.workspaceContext, agentOutputs, config2.aiConfig, executableNames, runMode),
+      messages: buildAgentMessages(chairman, userMessage, config2.ragContext, config2.workspaceContext, agentOutputs, config2.aiConfig, executableNames, runMode, councilLanguageModule),
       tools: chairmanTools,
       eventBus: config2.eventBus,
       toolRegistry: config2.tools,
@@ -24693,7 +25209,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         const zelariRoot = `${chairmanProjectRoot}/.zelari`;
         const spec = loadNfrSpec(zelariRoot) ?? DEFAULT_NFR_SPEC;
         for (const rel2 of spec.targets) {
-          if (!existsSync12(join5(chairmanProjectRoot, rel2)))
+          if (!existsSync13(join6(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({ projectRoot: chairmanProjectRoot, relPath: rel2, zelariRoot })) {
@@ -24713,7 +25229,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         const zelariRootReplay = `${chairmanProjectRoot}/.zelari`;
         const specReplay = loadNfrSpec(zelariRootReplay) ?? DEFAULT_NFR_SPEC;
         for (const rel2 of specReplay.targets) {
-          if (!existsSync12(join5(chairmanProjectRoot, rel2)))
+          if (!existsSync13(join6(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({
@@ -25159,7 +25675,7 @@ async function* runRetryTurnForMember(args) {
     description: t.function.description,
     parameters: t.function.parameters
   }));
-  const baseMessages = buildAgentMessages(args.agent, args.userMessage, args.ragContext, args.workspaceContext, args.priorOutputs, args.aiConfig, args.executableTools, args.runMode ?? "implementation");
+  const baseMessages = buildAgentMessages(args.agent, args.userMessage, args.ragContext, args.workspaceContext, args.priorOutputs, args.aiConfig, args.executableTools, args.runMode ?? "implementation", args.languageModule);
   const retryMessages = [
     ...baseMessages,
     {
@@ -25430,8 +25946,8 @@ var init_types = __esm({
 });
 
 // packages/core/dist/council/verification/motionAutofix.js
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join6 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join7 } from "node:path";
 function sanitizeTransitionPart(part) {
   const tokens = part.trim().split(/\s+/);
   if (tokens.length === 0)
@@ -25506,10 +26022,10 @@ function applyMotionAutofix(projectRoot, report) {
     forbidLayoutProps: DEFAULT_NFR_SPEC.animation?.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const abs = join6(projectRoot, rel2);
+    const abs = join7(projectRoot, rel2);
     let html;
     try {
-      html = readFileSync11(abs, "utf8");
+      html = readFileSync12(abs, "utf8");
     } catch {
       continue;
     }
@@ -25524,7 +26040,7 @@ function applyMotionAutofix(projectRoot, report) {
     const afterK = scanKeyframesViolations(final, scanOpts).length;
     const afterT = scanTransitionViolations(final, scanOpts).length;
     if (final !== html || beforeK > afterK || beforeT > afterT) {
-      writeFileSync7(abs, final, "utf8");
+      writeFileSync8(abs, final, "utf8");
       filesChanged.push(rel2);
       if (beforeK > afterK)
         fixes.push(`${rel2}: sanitized ${beforeK - afterK} keyframe violation(s)`);
@@ -25535,7 +26051,7 @@ function applyMotionAutofix(projectRoot, report) {
       if (!fixes.some((f) => f.startsWith(rel2)))
         fixes.push(`${rel2}: motion CSS sanitized`);
     } else if (motionChanged) {
-      writeFileSync7(abs, final, "utf8");
+      writeFileSync8(abs, final, "utf8");
       filesChanged.push(rel2);
       fixes.push(`${rel2}: motion CSS sanitized`);
     }
@@ -25581,8 +26097,8 @@ var init_motionAutofix = __esm({
 });
 
 // packages/core/dist/council/verification/autofix.js
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join7 } from "node:path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join8 } from "node:path";
 function applyDeterministicAutofix(projectRoot, report) {
   const motion = applyMotionAutofix(projectRoot, report);
   const inlineJs = applyInlineJsAutofix(projectRoot, report);
@@ -25596,8 +26112,8 @@ function applyDeterministicAutofix(projectRoot, report) {
     const m = r.evidence?.match(/classList\.add\(\s*['"]([\w-]+)['"]\s*\)/);
     if (!m || m[1] === "rm")
       continue;
-    const abs = join7(projectRoot, rel2);
-    let html = readFileSync12(abs, "utf8");
+    const abs = join8(projectRoot, rel2);
+    let html = readFileSync13(abs, "utf8");
     const snippet = m[0];
     if (!html.includes(snippet))
       continue;
@@ -25605,7 +26121,7 @@ function applyDeterministicAutofix(projectRoot, report) {
     const filtered = lines.filter((line) => !line.includes(snippet));
     if (filtered.length === lines.length)
       continue;
-    writeFileSync8(abs, filtered.join("\n"), "utf8");
+    writeFileSync9(abs, filtered.join("\n"), "utf8");
     filesChanged.push(rel2);
     fixes.push(`removed dead hook line in ${rel2}: ${snippet}`);
   }
@@ -25652,12 +26168,12 @@ var init_types2 = __esm({
 });
 
 // packages/core/dist/council/lessons/io.js
-import { readFileSync as readFileSync13 } from "node:fs";
-import { join as join8 } from "node:path";
+import { readFileSync as readFileSync14 } from "node:fs";
+import { join as join9 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path36 = join8(zelariRoot, LESSONS_FILE);
+  const path36 = join9(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync13(path36, "utf8");
+    const raw = readFileSync14(path36, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -25748,7 +26264,7 @@ var init_signatures = __esm({
 
 // packages/core/dist/council/lessons/recordFailure.js
 import { appendFileSync as appendFileSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function methodologyFor(check2) {
   return METHODOLOGY[check2.id] ?? `When ${check2.id} fails, fix the underlying issue and cite grep/tool evidence before claiming PASS.`;
 }
@@ -25758,7 +26274,7 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path36 = join9(zelariRoot, LESSONS_FILE);
+  const path36 = join10(zelariRoot, LESSONS_FILE);
   appendFileSync2(path36, `${JSON.stringify(lesson)}
 `, "utf8");
 }
@@ -25915,8 +26431,8 @@ var init_types3 = __esm({
 });
 
 // packages/core/dist/council/completion/buildCompletion.js
-import { writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 function openFailsFromReport(report) {
   if (!report)
     return [];
@@ -25975,8 +26491,8 @@ function buildCouncilCompletion(input) {
   };
 }
 function writeCouncilCompletion(zelariRoot, completion) {
-  const outPath = join10(zelariRoot, "completion.json");
-  writeFileSync9(outPath, JSON.stringify(completion, null, 2), "utf8");
+  const outPath = join11(zelariRoot, "completion.json");
+  writeFileSync10(outPath, JSON.stringify(completion, null, 2), "utf8");
   return outPath;
 }
 var init_buildCompletion = __esm({
@@ -26165,6 +26681,8 @@ var init_promoteMember = __esm({
 var council_exports = {};
 __export(council_exports, {
   AGENT_ROLES: () => AGENT_ROLES,
+  CLARIFICATION_PROTOCOL_MODULE: () => CLARIFICATION_PROTOCOL_MODULE,
+  CODING_PRACTICES_MODULE: () => CODING_PRACTICES_MODULE,
   COLLABORATION_DIRECTIVE: () => COLLABORATION_DIRECTIVE,
   COMPOSITOR_ONLY_PROPS: () => COMPOSITOR_ONLY_PROPS,
   DEFAULT_NFR_SPEC: () => DEFAULT_NFR_SPEC,
@@ -26181,6 +26699,7 @@ __export(council_exports, {
   MAX_DELIVERY_ATTEMPTS: () => MAX_DELIVERY_ATTEMPTS,
   MAX_RETRY_PER_MEMBER: () => MAX_RETRY_PER_MEMBER,
   MUTATING_PROJECT_TOOLS: () => MUTATING_PROJECT_TOOLS,
+  NATIVE_TOOL_PROTOCOL_MODULE: () => NATIVE_TOOL_PROTOCOL_MODULE,
   NFR_KEYWORDS: () => NFR_KEYWORDS,
   NON_RETRY_AGENTS: () => NON_RETRY_AGENTS,
   OUTPUT_QUALITY_DIRECTIVE: () => OUTPUT_QUALITY_DIRECTIVE,
@@ -26250,6 +26769,7 @@ __export(council_exports, {
   renderSkillMarkdown: () => renderSkillMarkdown,
   replayChairmanTextTools: () => replayChairmanTextTools,
   resolveCouncilRunMode: () => resolveCouncilRunMode,
+  resolveRoleSystemPrompt: () => resolveRoleSystemPrompt,
   resolveVerifyRetryTool: () => resolveVerifyRetryTool,
   restrictImplementationWrites: () => restrictImplementationWrites,
   runChairmanDeliveryLoop: () => runChairmanDeliveryLoop,
@@ -26385,9 +26905,11 @@ var conversationContext_exports = {};
 __export(conversationContext_exports, {
   _resetConversationContextForTests: () => _resetConversationContextForTests,
   appendMessages: () => appendMessages,
+  buildCouncilTaskWithHistory: () => buildCouncilTaskWithHistory,
   clearHistory: () => clearHistory,
   compactInPlace: () => compactInPlace,
   formatHistoryForCouncil: () => formatHistoryForCouncil,
+  formatHistoryMessages: () => formatHistoryMessages,
   getHistory: () => getHistory,
   getLastClarification: () => getLastClarification,
   hydrateHistory: () => hydrateHistory,
@@ -26448,23 +26970,56 @@ User's answer: ${picked}
 Proceed using this answer; do not re-ask the same question unless the answer is still ambiguous.`;
 }
 function formatHistoryForCouncil(maxTurns = 4) {
-  if (history.length === 0) return "";
-  const lines = [];
+  return formatHistoryMessages(history, maxTurns);
+}
+function formatHistoryMessages(messages, maxTurns = 6, maxTotalChars = 12e3) {
+  if (messages.length === 0) return "";
   let turns = 0;
   const chunk = [];
-  for (let i = history.length - 1; i >= 0 && turns < maxTurns; i--) {
-    const m = history[i];
+  for (let i = messages.length - 1; i >= 0 && turns < maxTurns; i--) {
+    const m = messages[i];
     if (m.role === "user") {
-      chunk.push(`User: ${truncate(m.content, 400)}`);
+      chunk.push(`User: ${truncate(m.content, 800)}`);
       turns += 1;
     } else if (m.role === "assistant" && m.content.trim()) {
-      chunk.push(`Assistant: ${truncate(m.content, 600)}`);
+      chunk.push(`Assistant: ${truncate(m.content, 2e3)}`);
     }
   }
   if (chunk.length === 0) return "";
-  lines.push("## Prior conversation (rolling context)");
-  lines.push(...chunk.reverse());
-  return lines.join("\n");
+  let body = ["## Prior conversation (rolling context)", ...chunk.reverse()].join(
+    "\n"
+  );
+  if (body.length > maxTotalChars) {
+    body = `\u2026
+${body.slice(body.length - maxTotalChars)}`;
+  }
+  return body;
+}
+function buildCouncilTaskWithHistory(task, prior) {
+  const messages = prior ?? [];
+  const trimmed = task.trim();
+  let userPart = maybeAnchorShortAnswer(task) ?? task;
+  if (messages.length > 0 && (SHORT_CONTINUE.test(trimmed) || trimmed.length <= 40 && !trimmed.includes("\n"))) {
+    const lastAsst = [...messages].reverse().find((m) => m.role === "assistant" && m.content.trim());
+    if (lastAsst && SHORT_CONTINUE.test(trimmed)) {
+      userPart = `The user says "${trimmed}" \u2014 continue from the prior conversation. Do NOT restart from zero, do NOT re-ask for the overall goal, and do NOT ignore the prior plan/risks/decisions.
+
+## Prior assistant output (authoritative context)
+${truncate(lastAsst.content, 4500)}
+
+## Instruction
+Proceed with the next concrete steps implied by that context (implementation when the work phase is build; otherwise the next planned actions).`;
+    }
+  }
+  const block = formatHistoryMessages(messages, 6, 12e3);
+  if (!block) return userPart;
+  if (userPart.includes("Prior assistant output")) {
+    return userPart;
+  }
+  return `${block}
+
+## Current user request
+${userPart}`;
 }
 function truncate(s, max) {
   const t = s.replace(/\s+/g, " ").trim();
@@ -26475,13 +27030,14 @@ function _resetConversationContextForTests() {
   history = [];
   lastClarification = null;
 }
-var history, lastClarification;
+var history, lastClarification, SHORT_CONTINUE;
 var init_conversationContext = __esm({
   "src/cli/hooks/conversationContext.ts"() {
     "use strict";
     init_historyCompaction();
     history = [];
     lastClarification = null;
+    SHORT_CONTINUE = /^(procedi|continua|continue|go\s*ahead|go|ok|okay|sì|si|yes|vai|avanti|next|proceed)$/i;
   }
 });
 
@@ -26562,20 +27118,20 @@ var init_phase = __esm({
 
 // src/cli/workspace/paths.ts
 import {
-  mkdirSync as mkdirSync6,
-  writeFileSync as writeFileSync10,
-  existsSync as existsSync13,
+  mkdirSync as mkdirSync7,
+  writeFileSync as writeFileSync11,
+  existsSync as existsSync14,
   accessSync,
   constants,
   realpathSync
 } from "node:fs";
-import { join as join11, basename } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { join as join12, basename } from "node:path";
+import { homedir as homedir5 } from "node:os";
 import { createHash as createHash2 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
-    join11(projectRoot, ".zelari"),
-    join11(homedir4(), ".zelari-code", "workspace", hashProject(projectRoot))
+    join12(projectRoot, ".zelari"),
+    join12(homedir5(), ".zelari-code", "workspace", hashProject(projectRoot))
   ];
   for (const candidate of candidates) {
     if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
@@ -26591,7 +27147,7 @@ function hashProject(projectPath) {
 }
 function isWritableDir(dir) {
   try {
-    if (!existsSync13(dir)) return false;
+    if (!existsSync14(dir)) return false;
     accessSync(dir, constants.W_OK);
     return true;
   } catch {
@@ -26599,26 +27155,26 @@ function isWritableDir(dir) {
   }
 }
 function ensureWorkspaceDir(workspaceDir) {
-  mkdirSync6(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync13(join11(workspaceDir, "..", ".git"))) {
-    const gitignorePath = join11(workspaceDir, ".gitignore");
-    if (!existsSync13(gitignorePath)) {
-      writeFileSync10(gitignorePath, "*\n!.gitignore\n");
+  mkdirSync7(workspaceDir, { recursive: true });
+  if (workspaceDir.endsWith("/.zelari") && existsSync14(join12(workspaceDir, "..", ".git"))) {
+    const gitignorePath = join12(workspaceDir, ".gitignore");
+    if (!existsSync14(gitignorePath)) {
+      writeFileSync11(gitignorePath, "*\n!.gitignore\n");
     }
   }
 }
 function workspaceFile(rootDir, kind) {
   switch (kind) {
     case "plan":
-      return join11(rootDir, "plan.md");
+      return join12(rootDir, "plan.md");
     case "risks":
-      return join11(rootDir, "risks.md");
+      return join12(rootDir, "risks.md");
     case "index":
-      return join11(rootDir, "workspace.json");
+      return join12(rootDir, "workspace.json");
   }
 }
 function workspaceArtifact(rootDir, subdir, slug) {
-  return join11(rootDir, subdir, `${slug}.md`);
+  return join12(rootDir, subdir, `${slug}.md`);
 }
 function projectName(projectRoot = process.cwd()) {
   return basename(realpathSync(projectRoot));
@@ -26637,8 +27193,8 @@ __export(workspaceSummary_exports, {
   buildWorkspaceSummary: () => buildWorkspaceSummary,
   buildZelariReadHint: () => buildZelariReadHint
 });
-import { existsSync as existsSync14, readFileSync as readFileSync14, readdirSync, statSync as statSync3 } from "node:fs";
-import { join as join12, relative } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync15, readdirSync, statSync as statSync3 } from "node:fs";
+import { join as join13, relative } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30 } = options;
   const name = safeProjectName(projectRoot);
@@ -26665,11 +27221,11 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join12(zelariRoot, "plan.json");
-  if (!existsSync14(planPath)) return null;
+  const planPath = join13(zelariRoot, "plan.json");
+  if (!existsSync15(planPath)) return null;
   let plan;
   try {
-    plan = JSON.parse(readFileSync14(planPath, "utf8"));
+    plan = JSON.parse(readFileSync15(planPath, "utf8"));
   } catch {
     return null;
   }
@@ -26798,8 +27354,8 @@ function pickNextTask(open) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join12(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync14(planPath)) return "";
+  const planPath = join13(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync15(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/)",
     "This project has a council workspace: .zelari/plan.json holds the plan (phases, tasks, milestones) and .zelari/plan-tasks/ holds one detail file per task.",
@@ -26814,10 +27370,10 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson(projectRoot) {
-  const p3 = join12(projectRoot, "package.json");
-  if (!existsSync14(p3)) return null;
+  const p3 = join13(projectRoot, "package.json");
+  if (!existsSync15(p3)) return null;
   try {
-    return JSON.parse(readFileSync14(p3, "utf8"));
+    return JSON.parse(readFileSync15(p3, "utf8"));
   } catch {
     return null;
   }
@@ -26851,11 +27407,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative(projectRoot, join12(projectRoot, entry.name));
+      const rel2 = relative(projectRoot, join13(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync(join12(projectRoot, entry.name), {
+          const sub = readdirSync(join13(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -26906,14 +27462,14 @@ __export(storage_exports, {
   workspaceMutex: () => workspaceMutex
 });
 import {
-  readFileSync as readFileSync15,
-  writeFileSync as writeFileSync11,
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync16,
+  writeFileSync as writeFileSync12,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync2,
   renameSync as renameSync2
 } from "node:fs";
-import { dirname as dirname2, join as join13 } from "node:path";
+import { dirname as dirname3, join as join14 } from "node:path";
 function parseFrontmatter(md) {
   const m = FRONTMATTER_RE.exec(md);
   if (!m) return { meta: {}, body: md };
@@ -27168,15 +27724,15 @@ var init_storage = __esm({
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
       read(path36) {
-        if (!existsSync15(path36)) {
+        if (!existsSync16(path36)) {
           throw new Error(`File not found: ${path36}`);
         }
-        const md = readFileSync15(path36, "utf8");
+        const md = readFileSync16(path36, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
       readIfExists(path36) {
-        if (!existsSync15(path36)) return null;
+        if (!existsSync16(path36)) return null;
         return this.read(path36);
       }
       /**
@@ -27184,16 +27740,16 @@ var init_storage = __esm({
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
       write(path36, meta3, body) {
-        mkdirSync7(dirname2(path36), { recursive: true });
+        mkdirSync8(dirname3(path36), { recursive: true });
         const tmp = path36 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
-        writeFileSync11(tmp, md, "utf8");
+        writeFileSync12(tmp, md, "utf8");
         renameSync2(tmp, path36);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
-        if (!existsSync15(dir)) return [];
-        return readdirSync2(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join13(dir, f));
+        if (!existsSync16(dir)) return [];
+        return readdirSync2(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join14(dir, f));
       }
     };
     KeyedMutex = class {
@@ -27232,14 +27788,14 @@ __export(stubs_exports, {
   resolveWorkspaceRoot: () => resolveWorkspaceRoot
 });
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   readdirSync as readdirSync3,
-  writeFileSync as writeFileSync12,
-  readFileSync as readFileSync16,
-  mkdirSync as mkdirSync8,
+  writeFileSync as writeFileSync13,
+  readFileSync as readFileSync17,
+  mkdirSync as mkdirSync9,
   renameSync as renameSync3
 } from "node:fs";
-import { join as join14, basename as basename2, dirname as dirname3, relative as relative2 } from "node:path";
+import { join as join15, basename as basename2, dirname as dirname4, relative as relative2 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -27249,14 +27805,14 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join14(ctx.rootDir, "plan.json");
+  return join15(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
-  if (existsSync16(jsonPath)) {
+  if (existsSync17(jsonPath)) {
     try {
       const parsed = JSON.parse(
-        readFileSync16(jsonPath, "utf8")
+        readFileSync17(jsonPath, "utf8")
       );
       return {
         phases: Array.isArray(parsed.phases) ? parsed.phases : [],
@@ -27278,9 +27834,9 @@ function readPlan(ctx) {
 }
 function writePlan(ctx, summary) {
   const jsonPath = planJsonPath(ctx);
-  mkdirSync8(dirname3(jsonPath), { recursive: true });
+  mkdirSync9(dirname4(jsonPath), { recursive: true });
   const tmp = jsonPath + ".tmp-" + process.pid;
-  writeFileSync12(tmp, JSON.stringify(summary, null, 2), "utf8");
+  writeFileSync13(tmp, JSON.stringify(summary, null, 2), "utf8");
   renameSync3(tmp, jsonPath);
   const mdPath = workspaceFile(ctx.rootDir, "plan");
   const summaryMeta = {
@@ -27347,8 +27903,8 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join14(ctx.rootDir, "decisions");
-  if (!existsSync16(decisionsDir)) return "001";
+  const decisionsDir = join15(ctx.rootDir, "decisions");
+  if (!existsSync17(decisionsDir)) return "001";
   const existing = readdirSync3(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
   return String(max + 1).padStart(3, "0");
@@ -27390,7 +27946,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     status: "pending",
     priority: t.priority
   });
-  const taskPath = join14(ctx.rootDir, "plan-tasks", `${id}.md`);
+  const taskPath = join15(ctx.rootDir, "plan-tasks", `${id}.md`);
   const meta3 = {
     kind: "task",
     id,
@@ -27432,7 +27988,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path36 = join14(ctx.rootDir, "milestones", `${id}.md`);
+  const path36 = join15(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -27730,8 +28286,8 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join14(ctx.rootDir, "nfr-spec.json");
-        writeFileSync12(outPath, JSON.stringify(spec, null, 2), "utf8");
+        const outPath = join15(ctx.rootDir, "nfr-spec.json");
+        writeFileSync13(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
     }
@@ -27794,18 +28350,18 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
       const results = [];
       for (const file2 of files) {
-        if (!existsSync16(file2)) continue;
-        const raw = readFileSync16(file2, "utf8");
+        if (!existsSync17(file2)) continue;
+        const raw = readFileSync17(file2, "utf8");
         const content = raw.toLowerCase();
         let idx = -1;
         let matchLen = 0;
@@ -27856,9 +28412,9 @@ function linkDocumentsStub(ctx) {
         const toId = args["toId"] ?? args["targetId"] ?? args["targetPathOrTitle"];
         if (!fromId || !toId) return "linkDocuments requires fromId and toId.";
         const allFiles = [
-          ...ctx.storage.listMarkdown(join14(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join14(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join14(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join15(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join15(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join15(ctx.rootDir, "reviews"))
         ];
         const source = allFiles.find((f) => {
           try {
@@ -27889,9 +28445,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join14(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join15(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -27985,8 +28541,8 @@ __export(updater_exports, {
   resolveBundledNpmCli: () => resolveBundledNpmCli
 });
 import { createRequire as createRequire2 } from "node:module";
-import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync17 } from "node:fs";
+import { spawn as spawn5 } from "node:child_process";
+import { existsSync as existsSync18 } from "node:fs";
 import path23 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
@@ -27999,7 +28555,7 @@ function resolveBundledNpmCli(execPath = process.execPath) {
   ];
   for (const candidate of candidates) {
     try {
-      if (existsSync17(candidate)) return candidate;
+      if (existsSync18(candidate)) return candidate;
     } catch {
     }
   }
@@ -28072,7 +28628,7 @@ async function checkForUpdate(fetcher = fetch, registryUrl) {
     updateAvailable: cmp < 0
   };
 }
-async function performUpdate(packageName = "zelari-code", executor = spawn4, resolveNpmCli = resolveBundledNpmCli) {
+async function performUpdate(packageName = "zelari-code", executor = spawn5, resolveNpmCli = resolveBundledNpmCli) {
   const args = ["install", "-g", `${packageName}@latest`];
   const primary = await runNpm(executor, args, "shim");
   if (primary.ok) return primary;
@@ -28130,7 +28686,7 @@ var init_updater = __esm({
 });
 
 // src/cli/mcp/mcpClient.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 var DEFAULT_REQUEST_TIMEOUT_MS, INIT_TIMEOUT_MS, MCP_PROTOCOL_VERSION, McpClient;
 var init_mcpClient = __esm({
   "src/cli/mcp/mcpClient.ts"() {
@@ -28158,10 +28714,10 @@ var init_mcpClient = __esm({
           env: { ...process.env, ...this.config.env ?? {} },
           windowsHide: true
         };
-        const child = process.platform === "win32" ? spawn5(buildCmdLine(this.config.command, this.config.args ?? []), {
+        const child = process.platform === "win32" ? spawn6(buildCmdLine(this.config.command, this.config.args ?? []), {
           ...spawnOpts,
           shell: true
-        }) : spawn5(this.config.command, this.config.args ?? [], spawnOpts);
+        }) : spawn6(this.config.command, this.config.args ?? [], spawnOpts);
         this.child = child;
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => this.onStdout(chunk));
@@ -28305,20 +28861,20 @@ __export(mcpManager_exports, {
   readMcpConfig: () => readMcpConfig,
   registerMcpTools: () => registerMcpTools
 });
-import { existsSync as existsSync18, readFileSync as readFileSync17 } from "node:fs";
-import { join as join15 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
+import { join as join16 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd()) {
   const merged = {};
   const paths = [
-    join15(homedir5(), ".zelari-code", "mcp.json"),
-    join15(projectRoot, ".zelari", "mcp.json")
+    join16(homedir6(), ".zelari-code", "mcp.json"),
+    join16(projectRoot, ".zelari", "mcp.json")
     // later = higher precedence
   ];
   for (const p3 of paths) {
-    if (!existsSync18(p3)) continue;
+    if (!existsSync19(p3)) continue;
     try {
-      const parsed = JSON.parse(readFileSync17(p3, "utf8"));
+      const parsed = JSON.parse(readFileSync18(p3, "utf8"));
       for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
         if (!cfg || typeof cfg.command !== "string" || cfg.command.length === 0) continue;
         merged[name] = cfg;
@@ -28407,6 +28963,53 @@ var init_mcpManager = __esm({
   }
 });
 
+// src/cli/workspace/projectInstructions.ts
+var projectInstructions_exports = {};
+__export(projectInstructions_exports, {
+  loadProjectInstructions: () => loadProjectInstructions
+});
+import { existsSync as existsSync20, readFileSync as readFileSync19 } from "node:fs";
+import { join as join17 } from "node:path";
+function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
+  for (const name of CANDIDATES) {
+    const full = join17(projectRoot, name);
+    if (!existsSync20(full)) continue;
+    try {
+      let raw = readFileSync19(full, "utf8");
+      raw = raw.replace(/\r\n/g, "\n").trim();
+      if (!raw) continue;
+      if (raw.length <= maxChars) {
+        return { path: full, content: raw, truncated: false };
+      }
+      return {
+        path: full,
+        content: raw.slice(0, maxChars) + `
+
+\u2026 [truncated; full file is ${raw.length} chars at ${name}]`,
+        truncated: true
+      };
+    } catch {
+      continue;
+    }
+  }
+  return { path: null, content: "", truncated: false };
+}
+var CANDIDATES, MAX_CHARS;
+var init_projectInstructions = __esm({
+  "src/cli/workspace/projectInstructions.ts"() {
+    "use strict";
+    CANDIDATES = [
+      "AGENTS.md",
+      "Agents.md",
+      "agents.md",
+      "CLAUDE.md",
+      "Claude.md",
+      "claude.md"
+    ];
+    MAX_CHARS = 8e3;
+  }
+});
+
 // src/cli/councilConfig.ts
 function resolveCouncilTier(opts) {
   const env = opts?.env ?? process.env;
@@ -28450,13 +29053,13 @@ var planDetect_exports = {};
 __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync20 } from "node:fs";
+import { join as join18 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join16(resolveWorkspaceRoot(projectRoot), "plan.json");
-  if (!existsSync19(planPath)) return false;
+  const planPath = join18(resolveWorkspaceRoot(projectRoot), "plan.json");
+  if (!existsSync21(planPath)) return false;
   try {
-    const parsed = JSON.parse(readFileSync18(planPath, "utf8"));
+    const parsed = JSON.parse(readFileSync20(planPath, "utf8"));
     return Array.isArray(parsed.phases) && parsed.phases.length > 0;
   } catch {
     return false;
@@ -28560,13 +29163,13 @@ __export(agentsMd_exports, {
   serializeAgentsMd: () => serializeAgentsMd,
   updateAgentsMd: () => updateAgentsMd
 });
-import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "node:fs";
 import { createHash as createHash3 } from "node:crypto";
-import { join as join17 } from "node:path";
+import { join as join19 } from "node:path";
 import { readFile as readFile2 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path36 = join17(projectRoot, "package.json");
-  if (!existsSync20(path36)) return null;
+  const path36 = join19(projectRoot, "package.json");
+  if (!existsSync22(path36)) return null;
   try {
     return JSON.parse(await readFile2(path36, "utf8"));
   } catch {
@@ -28590,8 +29193,8 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join17(ctx.rootDir, "decisions");
-  if (!existsSync20(decisionsDir)) return "_No ADRs yet._";
+  const decisionsDir = join19(ctx.rootDir, "decisions");
+  if (!existsSync22(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
   const proposed = [];
@@ -28616,9 +29219,9 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join17(ctx.projectRoot, "CLAUDE.MD");
-  if (existsSync20(claudeMd)) {
-    const content = readFileSync19(claudeMd, "utf8");
+  const claudeMd = join19(ctx.projectRoot, "CLAUDE.MD");
+  if (existsSync22(claudeMd)) {
+    const content = readFileSync21(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
     if (match) {
       lines.push('<!-- Extracted from CLAUDE.MD "Architecture rules" -->');
@@ -28650,9 +29253,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path36 = join17(ctx.rootDir, "risks.md");
-  if (!existsSync20(path36)) return "_No open questions._";
-  const content = readFileSync19(path36, "utf8");
+  const path36 = join19(ctx.rootDir, "risks.md");
+  if (!existsSync22(path36)) return "_No open questions._";
+  const content = readFileSync21(path36, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -28726,9 +29329,9 @@ function titleCase(id) {
   return id.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join17(projectRoot, "AGENTS.MD");
-  if (existsSync20(agentsPath)) {
-    const content = readFileSync19(agentsPath, "utf8");
+  const agentsPath = join19(projectRoot, "AGENTS.MD");
+  if (existsSync22(agentsPath)) {
+    const content = readFileSync21(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id) => content.includes(MARKER_OPEN(id)));
     if (!hasAnyMarker) {
       return {
@@ -28743,8 +29346,8 @@ async function updateAgentsMd(ctx, projectRoot) {
     newSections.set(id, await GENERATORS[id](ctx));
   }
   let manualContent = "";
-  if (existsSync20(agentsPath)) {
-    const { manualBlocks } = parseAgentsMd(readFileSync19(agentsPath, "utf8"));
+  if (existsSync22(agentsPath)) {
+    const { manualBlocks } = parseAgentsMd(readFileSync21(agentsPath, "utf8"));
     manualContent = manualBlocks.after;
   } else {
     const projectName2 = projectName(projectRoot);
@@ -28760,7 +29363,7 @@ async function updateAgentsMd(ctx, projectRoot) {
       ""
     ].join("\n");
   }
-  const oldContent = existsSync20(agentsPath) ? readFileSync19(agentsPath, "utf8") : "";
+  const oldContent = existsSync22(agentsPath) ? readFileSync21(agentsPath, "utf8") : "";
   const { sections: oldSections } = parseAgentsMd(oldContent);
   const changedSections = [];
   for (const id of AUTO_SECTIONS) {
@@ -28772,7 +29375,7 @@ async function updateAgentsMd(ctx, projectRoot) {
     return { changed: false, sections: [] };
   }
   const newContent = serializeAgentsMd(manualContent, newSections);
-  writeFileSync13(agentsPath, newContent, "utf8");
+  writeFileSync14(agentsPath, newContent, "utf8");
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
@@ -28897,9 +29500,9 @@ var init_completeDesign = __esm({
 });
 
 // src/cli/workspace/projectSmoke.ts
-import { spawn as spawn6 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync20 } from "node:fs";
-import { join as join18 } from "node:path";
+import { spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync23, readFileSync as readFileSync22 } from "node:fs";
+import { join as join20 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -28911,13 +29514,13 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join18(projectRoot, "package.json");
-  if (!existsSync21(pkgPath)) {
+  const pkgPath = join20(projectRoot, "package.json");
+  if (!existsSync23(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
   let scripts = {};
   try {
-    const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return { ran: false, reason: "package.json unreadable (skipped)" };
@@ -28927,12 +29530,12 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
     return { ran: false, reason: "no typecheck/test/build script (skipped)" };
   }
   return await new Promise((resolveRun) => {
-    const child = process.platform === "win32" ? spawn6(buildCmdLine("npm.cmd", ["run", script]), {
+    const child = process.platform === "win32" ? spawn7(buildCmdLine("npm.cmd", ["run", script]), {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env,
       shell: true
-    }) : spawn6("npm", ["run", script], {
+    }) : spawn7("npm", ["run", script], {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -29004,9 +29607,9 @@ __export(postCouncilHook_exports, {
   runImplementationVerificationHook: () => runImplementationVerificationHook,
   runPostCouncilHook: () => runPostCouncilHook
 });
-import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync21 } from "node:fs";
-import { join as join19 } from "node:path";
+import { spawn as spawn8 } from "node:child_process";
+import { existsSync as existsSync24, readFileSync as readFileSync23 } from "node:fs";
+import { join as join21 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -29017,9 +29620,9 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join19(ctx.rootDir, "plan.json");
-  const scriptPath = join19(ctx.projectRoot, "complete-design.mjs");
-  if (!existsSync22(planJsonPath2)) {
+  const planJsonPath2 = join21(ctx.rootDir, "plan.json");
+  const scriptPath = join21(ctx.projectRoot, "complete-design.mjs");
+  if (!existsSync24(planJsonPath2)) {
     return {
       ran: false,
       reason: ".zelari/plan.json missing (not design-phase)"
@@ -29027,7 +29630,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   }
   let phaseCount = 0;
   try {
-    const parsed = JSON.parse(readFileSync21(planJsonPath2, "utf8"));
+    const parsed = JSON.parse(readFileSync23(planJsonPath2, "utf8"));
     phaseCount = Array.isArray(parsed.phases) ? parsed.phases.length : 0;
   } catch {
     return { ran: false, reason: ".zelari/plan.json corrupt" };
@@ -29035,7 +29638,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (phaseCount === 0) {
     return { ran: false, reason: ".zelari/plan.json has no phases" };
   }
-  if (!existsSync22(scriptPath)) {
+  if (!existsSync24(scriptPath)) {
     try {
       const builtin = await runBuiltinCompleteDesign(ctx);
       return {
@@ -29053,7 +29656,7 @@ async function runCompleteDesignPostProcessor(ctx, options) {
     }
   }
   return await new Promise((resolveRun) => {
-    const child = spawn7(process.execPath, [scriptPath], {
+    const child = spawn8(process.execPath, [scriptPath], {
       cwd: ctx.projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
@@ -29256,12 +29859,12 @@ var buildLessonsSummary_exports = {};
 __export(buildLessonsSummary_exports, {
   buildLessonsSummary: () => buildLessonsSummary
 });
-import { existsSync as existsSync23 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { join as join22 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync23(join20(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync25(join22(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -29284,10 +29887,10 @@ __export(councilFeedback_exports, {
 });
 import {
   promises as fs13,
-  existsSync as existsSync24,
-  readFileSync as readFileSync22,
-  writeFileSync as writeFileSync14,
-  mkdirSync as mkdirSync9
+  existsSync as existsSync26,
+  readFileSync as readFileSync24,
+  writeFileSync as writeFileSync15,
+  mkdirSync as mkdirSync10
 } from "node:fs";
 import path24 from "node:path";
 import os8 from "node:os";
@@ -29393,9 +29996,9 @@ var init_councilFeedback = __esm({
       }
       // --- persistence ---------------------------------------------------------
       load() {
-        if (!existsSync24(this.file)) return;
+        if (!existsSync26(this.file)) return;
         try {
-          const raw = readFileSync22(this.file, "utf-8");
+          const raw = readFileSync24(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -29406,8 +30009,8 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync9(path24.dirname(this.file), { recursive: true });
-        writeFileSync14(
+        mkdirSync10(path24.dirname(this.file), { recursive: true });
+        writeFileSync15(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
           { encoding: "utf-8", mode: 384 }
@@ -29864,8 +30467,8 @@ __export(prereqChecks_exports, {
   runPrereqChecks: () => runPrereqChecks
 });
 import { execSync, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync25 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { existsSync as existsSync27 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 function isWslBashPath2(p3) {
   if (!p3 || typeof p3 !== "string") return false;
   const n = p3.replace(/\//g, "\\").toLowerCase();
@@ -29927,7 +30530,7 @@ function resolveAgentShellSync() {
 function agentProbeEnv() {
   const env = { ...process.env };
   try {
-    const nodeDir = dirname4(process.execPath);
+    const nodeDir = dirname5(process.execPath);
     if (!nodeDir) return env;
     const sep = process.platform === "win32" ? ";" : ":";
     const current = env.PATH ?? env.Path ?? "";
@@ -29944,7 +30547,7 @@ function agentProbeEnv() {
 }
 function existsSyncSafe2(p3) {
   try {
-    return existsSync25(p3);
+    return existsSync27(p3);
   } catch {
     return false;
   }
@@ -30163,7 +30766,7 @@ var init_prereqChecks = __esm({
 });
 
 // src/cli/plugins/prefs.ts
-import { existsSync as existsSync26, readFileSync as readFileSync23, writeFileSync as writeFileSync15, mkdirSync as mkdirSync10 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync25, writeFileSync as writeFileSync16, mkdirSync as mkdirSync11 } from "node:fs";
 import path29 from "node:path";
 import os9 from "node:os";
 function getPluginPrefsPath() {
@@ -30172,8 +30775,8 @@ function getPluginPrefsPath() {
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
   try {
-    if (!existsSync26(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
-    const raw = readFileSync23(file2, "utf-8");
+    if (!existsSync28(file2)) return { ...DEFAULTS2, dontAskAgain: {} };
+    const raw = readFileSync25(file2, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && parsed.dontAskAgain && typeof parsed.dontAskAgain === "object") {
       const clean = {};
@@ -30188,8 +30791,8 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync10(path29.dirname(file2), { recursive: true });
-  writeFileSync15(file2, JSON.stringify(prefs, null, 2), {
+  mkdirSync11(path29.dirname(file2), { recursive: true });
+  writeFileSync16(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
   });
@@ -30224,7 +30827,7 @@ __export(registry_exports, {
   findPlugin: () => findPlugin,
   isBinaryOnPath: () => isBinaryOnPath
 });
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync29 } from "node:fs";
 import path30 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
@@ -30241,7 +30844,7 @@ function isBinaryOnPath(bin, opts = {}) {
     return false;
   }
   const platform = opts.platform ?? process.platform;
-  const exists = opts.exists ?? existsSync27;
+  const exists = opts.exists ?? existsSync29;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
   const pathMod = platform === "win32" ? path30.win32 : path30.posix;
   const sep = platform === "win32" ? ";" : ":";
@@ -30392,7 +30995,7 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync26, readlinkSync, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync35, readFileSync as readFileSync30, readlinkSync, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import path35 from "node:path";
@@ -30400,9 +31003,9 @@ function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
     const candidate = path35.join(dir, "package.json");
-    if (existsSync32(candidate)) {
+    if (existsSync35(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync26(candidate, "utf8"));
+        const pkg = JSON.parse(readFileSync30(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
       } catch {
       }
@@ -30426,7 +31029,7 @@ function tryExec(cmd) {
 function readPackageJson3() {
   try {
     const pkgPath = path35.join(packageRoot, "package.json");
-    return JSON.parse(readFileSync26(pkgPath, "utf8"));
+    return JSON.parse(readFileSync30(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -30442,7 +31045,7 @@ function checkShim(pkgName) {
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
   const shimPath = path35.join(prefix, shimName);
-  if (!existsSync32(shimPath)) {
+  if (!existsSync35(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
          fix:  npm install -g ${pkgName}@latest --force`
@@ -30451,7 +31054,7 @@ function checkShim(pkgName) {
   try {
     const st = statSync6(shimPath);
     if (isWin) {
-      const content = readFileSync26(shimPath, "utf8");
+      const content = readFileSync30(shimPath, "utf8");
       if (content.includes(`${pkgName}\\bin\\`) || content.includes(`${pkgName}/bin/`)) {
         return OK(`shim OK at ${shimPath} (${st.size} bytes)`);
       }
@@ -30510,7 +31113,7 @@ function checkNode(pkg) {
 }
 function checkBundle() {
   const bundle = path35.join(packageRoot, "dist", "cli", "main.bundled.js");
-  if (!existsSync32(bundle)) {
+  if (!existsSync35(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
          fix:  npm run build:cli   (then reinstall or run via tsx)`
@@ -34643,13 +35246,22 @@ function useChatTurn(params) {
         let systemPrompt;
         try {
           const languageModule = buildLanguagePolicyModuleFor(userText);
+          const { loadProjectInstructions: loadProjectInstructions2 } = await Promise.resolve().then(() => (init_projectInstructions(), projectInstructions_exports));
+          const projectInstructions = loadProjectInstructions2(
+            process.cwd()
+          ).content;
           systemPrompt = buildSystemPrompt(singleAgentRole, {
             tools: getAllTools(),
             toolNames: toolListNames,
+            mode: "agent",
+            projectInstructions: projectInstructions || void 0,
             aiConfig: {
               enabledSkills: [],
               enabledTools: toolListNames,
-              customPromptModules: [SINGLE_AGENT_IDENTITY_MODULE, languageModule],
+              customPromptModules: [
+                SINGLE_AGENT_IDENTITY_MODULE,
+                languageModule
+              ],
               agentSkillConfigs: []
             },
             workspaceContext: workspaceContext || void 0,
@@ -36439,8 +37051,8 @@ init_registry2();
 // src/cli/plugins/installer.ts
 init_cmdline();
 init_updater();
-import { spawn as spawn8 } from "node:child_process";
-async function installPlugin(spec, cwd, executor = spawn8) {
+import { spawn as spawn9 } from "node:child_process";
+async function installPlugin(spec, cwd, executor = spawn9) {
   const scopeFlag = spec.installScope === "global" ? "-g" : "-D";
   const args = ["install", scopeFlag, spec.npmPackage];
   const primary = await runNpm2(executor, args, cwd, "shim");
@@ -36567,7 +37179,7 @@ async function handlePromoteMember(ctx, memberId) {
 }
 
 // src/cli/branchManager.ts
-import { promises as fs17, existsSync as existsSync28, readFileSync as readFileSync24, writeFileSync as writeFileSync16, mkdirSync as mkdirSync11, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
+import { promises as fs17, existsSync as existsSync30, readFileSync as readFileSync26, writeFileSync as writeFileSync17, mkdirSync as mkdirSync12, statSync as statSync4, rmSync as rmSync2 } from "node:fs";
 import path32 from "node:path";
 import os11 from "node:os";
 var META_FILENAME = "meta.json";
@@ -36589,11 +37201,11 @@ function sessionsPathFor(name, baseDir) {
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
-  if (!existsSync28(metaPath)) {
+  if (!existsSync30(metaPath)) {
     throw new BranchNotFoundError(`Branch "${name}" not found`);
   }
   try {
-    const raw = readFileSync24(metaPath, "utf-8");
+    const raw = readFileSync26(metaPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || typeof parsed.name !== "string" || typeof parsed.createdAt !== "number" || typeof parsed.fromSessionId !== "string") {
       throw new BranchCorruptError(`Branch "${name}" meta.json is malformed`);
@@ -36610,8 +37222,8 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync11(path32.dirname(metaPath), { recursive: true });
-  writeFileSync16(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
+  mkdirSync12(path32.dirname(metaPath), { recursive: true });
+  writeFileSync17(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
@@ -36649,7 +37261,7 @@ var SessionNotFoundError = class extends Error {
 };
 function branchExists(name, baseDir = getBranchesBaseDir()) {
   const bp = branchPathFor(name, baseDir);
-  return existsSync28(bp) && existsSync28(metaPathFor(name, baseDir));
+  return existsSync30(bp) && existsSync30(metaPathFor(name, baseDir));
 }
 async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(), sessionsBaseDir = getSessionsBaseDir()) {
   if (!name || name.trim().length === 0) {
@@ -36662,12 +37274,12 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
     throw new BranchAlreadyExistsError(name);
   }
   const sourcePath = path32.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
-  if (!existsSync28(sourcePath)) {
+  if (!existsSync30(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
-  mkdirSync11(branchSessionsPath, { recursive: true });
+  mkdirSync12(branchSessionsPath, { recursive: true });
   const destPath = path32.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs17.copyFile(sourcePath, destPath);
   const meta3 = {
@@ -36695,7 +37307,7 @@ async function listBranches(baseDir = getBranchesBaseDir()) {
   const results = [];
   for (const entry of entries) {
     const metaPath = metaPathFor(entry, baseDir);
-    if (!existsSync28(metaPath)) continue;
+    if (!existsSync30(metaPath)) continue;
     try {
       const meta3 = readBranchMeta(entry, baseDir);
       const sessionCount = await countSessions(entry, baseDir);
@@ -37231,7 +37843,7 @@ import path34 from "node:path";
 import os12 from "node:os";
 
 // src/cli/skillHistory.ts
-import { promises as fs19, existsSync as existsSync29, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync12 } from "node:fs";
+import { promises as fs19, existsSync as existsSync31, statSync as statSync5, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync13 } from "node:fs";
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
@@ -38409,9 +39021,9 @@ function ContinueKey({ onContinue }) {
 init_providerConfig();
 
 // src/cli/wizard/firstRun.ts
-import { existsSync as existsSync30 } from "node:fs";
+import { existsSync as existsSync32 } from "node:fs";
 function shouldRunWizard(input) {
-  const exists = input.exists ?? existsSync30;
+  const exists = input.exists ?? existsSync32;
   if (input.hasResetConfigFlag) {
     return { shouldRun: true, reason: "--reset-config flag forced wizard" };
   }
@@ -38696,6 +39308,7 @@ init_keyStore();
 init_providerConfig();
 init_openai_compatible();
 init_phase();
+import { readFileSync as readFileSync27 } from "node:fs";
 function parseHeadlessFlags(argv) {
   if (!argv.includes("--headless")) {
     return { options: null };
@@ -38708,6 +39321,7 @@ function parseHeadlessFlags(argv) {
   let councilFlag = false;
   let provider;
   let model;
+  let history2;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--headless") continue;
@@ -38756,6 +39370,32 @@ function parseHeadlessFlags(argv) {
     } else if (arg === "--model") {
       model = argv[i + 1];
       i++;
+    } else if (arg === "--history" || arg === "--history-file") {
+      const next = argv[i + 1];
+      if (next) {
+        let raw = null;
+        if (arg === "--history-file") {
+          try {
+            raw = readFileSync27(next, "utf-8");
+          } catch {
+            raw = null;
+          }
+        } else {
+          raw = next;
+        }
+        if (raw) {
+          try {
+            const parsedHist = JSON.parse(raw);
+            if (Array.isArray(parsedHist)) {
+              history2 = parsedHist.filter(
+                (m) => m && typeof m === "object" && typeof m.role === "string" && typeof m.content === "string"
+              );
+            }
+          } catch {
+          }
+        }
+        i++;
+      }
     }
   }
   if (councilFlag && !modeExplicit) {
@@ -38777,7 +39417,8 @@ function parseHeadlessFlags(argv) {
       phase: phase2,
       useCouncil: mode === "council",
       provider,
-      model
+      model,
+      ...history2 && history2.length > 0 ? { history: history2 } : {}
     }
   };
 }
@@ -38810,12 +39451,66 @@ function emitEvent(event) {
 
 // src/cli/runHeadless.ts
 init_harness();
+init_conversationContext();
 init_toolRegistry();
 init_skills2();
 init_envNumber();
 init_phaseState();
 init_phase();
+
+// src/cli/utils/streamScrub.ts
+function createStreamScrubber() {
+  let rawBuf = "";
+  let emittedLen = 0;
+  const snapshot = () => {
+    const cleaned = cleanAgentContent(rawBuf);
+    if (cleaned.length <= emittedLen) return "";
+    const delta = cleaned.slice(emittedLen);
+    emittedLen = cleaned.length;
+    return delta;
+  };
+  return {
+    push(rawDelta) {
+      rawBuf += rawDelta;
+      return snapshot();
+    },
+    flush() {
+      return snapshot();
+    },
+    reset() {
+      rawBuf = "";
+      emittedLen = 0;
+    }
+  };
+}
+
+// src/cli/runHeadless.ts
 async function runHeadless(opts) {
+  let crashed = false;
+  const handleFatal = (label, err) => {
+    if (crashed) return;
+    crashed = true;
+    const msg = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error && err.stack ? `
+${err.stack}` : "";
+    const line = `[zelari-code --headless] FATAL ${label}: ${msg}${stack}`;
+    try {
+      emitEvent({
+        type: "error",
+        severity: "fatal",
+        message: `${label}: ${msg}`,
+        code: "uncaught"
+      });
+    } catch {
+    }
+    try {
+      process.stderr.write(line + "\n");
+    } catch {
+    }
+    process.exit(2);
+  };
+  process.on("uncaughtException", (err) => handleFatal("uncaughtException", err));
+  process.on("unhandledRejection", (err) => handleFatal("unhandledRejection", err));
   setPhase(opts.phase ?? "build");
   const { provider, model } = resolveHeadlessProvider(opts);
   const key = await resolveHeadlessKey(provider);
@@ -38853,11 +39548,50 @@ async function runHeadless(opts) {
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
 }
+var mcpExitHookInstalled = false;
+async function registerHeadlessMcp(toolRegistry, opts) {
+  try {
+    const { registerMcpTools: registerMcpTools2, closeMcpClients: closeMcpClients2 } = await Promise.resolve().then(() => (init_mcpManager(), mcpManager_exports));
+    const mcp = await registerMcpTools2(toolRegistry, process.cwd());
+    if (!mcpExitHookInstalled) {
+      mcpExitHookInstalled = true;
+      process.once("exit", () => {
+        try {
+          closeMcpClients2();
+        } catch {
+        }
+      });
+    }
+    if (mcp.registered.length > 0 && opts.output === "json") {
+      emitEvent({
+        type: "log",
+        message: `[headless] MCP tools: ${mcp.registered.length} registered`
+      });
+    }
+    for (const w of mcp.warnings) {
+      if (opts.output === "json") {
+        emitEvent({ type: "log", message: `[mcp] ${w}` });
+      } else {
+        process.stderr.write(`[zelari-code --headless] [mcp] ${w}
+`);
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (opts.output === "json") {
+      emitEvent({ type: "log", message: `[mcp] registration skipped: ${msg}` });
+    } else {
+      process.stderr.write(`[zelari-code --headless] [mcp] registration skipped: ${msg}
+`);
+    }
+  }
+}
 async function runHeadlessSingle(opts, provider, model, providerStream) {
   const sessionId = crypto.randomUUID();
   const { registry: toolRegistry } = createBuiltinToolRegistry({
     planMode: planModeFromOpts(opts)
   });
+  await registerHeadlessMcp(toolRegistry, opts);
   const tools = toolRegistry.toOpenAITools().map((t) => ({
     name: t.function.name,
     description: t.function.description,
@@ -38894,21 +39628,38 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
         (opts.phase ?? "build") === "plan" ? "PLAN phase: explore and design only. Do not write project source files (write_file/edit_file/bash blocked). Plan artifacts under .zelari are allowed." : "BUILD phase: full tools; implement changes."
       ].join("\n")
     };
-    systemPrompt = buildSystemPrompt(headlessRole, {
-      tools: getAllTools(),
-      toolNames,
-      aiConfig: {
-        enabledSkills: [],
-        enabledTools: toolNames,
-        customPromptModules: [SINGLE_AGENT_IDENTITY_MODULE, {
-          type: "language-policy",
-          title: "Response Language",
-          priority: 5,
-          content: languageDirectiveContent
-        }],
-        agentSkillConfigs: []
+    const { loadProjectInstructions: loadProjectInstructions2 } = await Promise.resolve().then(() => (init_projectInstructions(), projectInstructions_exports));
+    const projectInstructions = loadProjectInstructions2(process.cwd()).content;
+    let sshBlock = "";
+    try {
+      const { formatSshTargetsForPrompt: formatSshTargetsForPrompt2 } = await Promise.resolve().then(() => (init_targets(), targets_exports));
+      sshBlock = formatSshTargetsForPrompt2();
+    } catch {
+    }
+    const rolePrompt = [headlessRole.systemPrompt, sshBlock].filter(Boolean).join("\n\n");
+    systemPrompt = buildSystemPrompt(
+      { ...headlessRole, systemPrompt: rolePrompt },
+      {
+        tools: getAllTools(),
+        toolNames,
+        mode: "agent",
+        projectInstructions: projectInstructions || void 0,
+        aiConfig: {
+          enabledSkills: [],
+          enabledTools: toolNames,
+          customPromptModules: [
+            SINGLE_AGENT_IDENTITY_MODULE,
+            {
+              type: "language-policy",
+              title: "Response Language",
+              priority: 5,
+              content: languageDirectiveContent
+            }
+          ],
+          agentSkillConfigs: []
+        }
       }
-    });
+    );
   } catch {
     systemPrompt = [
       "You are zelari-code, a CLI coding agent. Be concise and direct.",
@@ -38917,13 +39668,19 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       languageDirectiveContent
     ].join("\n");
   }
+  const historySeed = (opts.history ?? []).map(
+    (m) => m.role === "assistant" && m.content ? { ...m, content: cleanAgentContent(m.content, { stripQuestion: false }) } : m
+  );
+  const effectiveTask = maybeAnchorShortAnswer(opts.task) ?? opts.task;
+  const historySeedLen = historySeed.length;
   const harness = new AgentHarness({
     model,
     provider,
     sessionId,
     messages: [
       { role: "system", content: systemPrompt },
-      { role: "user", content: opts.task }
+      ...historySeed,
+      { role: "user", content: effectiveTask }
     ],
     tools,
     toolRegistry,
@@ -38936,23 +39693,39 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   let finalReason = "completed";
   let exitCode = 0;
   const textBuffer = [];
+  const scrub = createStreamScrubber();
   try {
     for await (const event of harness.run()) {
-      if (opts.output === "json") {
-        emitEvent(event);
+      if (event.type === "message_start") {
+        scrub.reset();
       }
-      if (event.type === "message_delta") {
-        if (opts.output === "plain") {
-          process.stdout.write(event.delta);
+      if (event.type === "message_delta" && typeof event.delta === "string") {
+        const cleanDelta = scrub.push(event.delta);
+        if (opts.output === "json") {
+          if (cleanDelta.length > 0) {
+            emitEvent({ ...event, delta: cleanDelta });
+          }
+        } else if (opts.output === "plain") {
+          if (cleanDelta.length > 0) process.stdout.write(cleanDelta);
         } else {
-          textBuffer.push(event.delta);
+          if (cleanDelta.length > 0) textBuffer.push(cleanDelta);
         }
-      } else if (event.type === "agent_end") {
-        finalReason = event.reason;
-        if (event.reason === "error") exitCode = 3;
-      } else if (event.type === "error") {
-        if (event.severity === "fatal") {
-          exitCode = 2;
+      } else {
+        if (opts.output === "json") {
+          emitEvent(event);
+        }
+        if (event.type === "agent_end") {
+          const tail = scrub.flush();
+          if (tail.length > 0) {
+            if (opts.output === "plain") process.stdout.write(tail);
+            else textBuffer.push(tail);
+          }
+          finalReason = event.reason;
+          if (event.reason === "error") exitCode = 3;
+        } else if (event.type === "error") {
+          if (event.severity === "fatal") {
+            exitCode = 2;
+          }
         }
       }
     }
@@ -38967,10 +39740,25 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     process.stdout.write(textBuffer.join(""));
   }
   process.stdout.write("");
+  if (finalReason !== "error" && opts.output === "json") {
+    try {
+      const all = harness.getMessages();
+      const seedLen = 1 + historySeedLen + 1;
+      if (all.length > seedLen) {
+        const tail = all.slice(seedLen).map(
+          (m) => m.role === "assistant" && m.content ? { ...m, content: cleanAgentContent(m.content, { stripQuestion: false }) } : m
+        );
+        if (tail.length > 0) {
+          emitEvent({ type: "history_snapshot", messages: tail });
+        }
+      }
+    } catch {
+    }
+  }
   if (finalReason === "error") return 3;
   return exitCode;
 }
-async function buildCouncilToolRegistry(planMode) {
+async function buildCouncilToolRegistry(planMode, opts) {
   const { registry: toolRegistry } = createBuiltinToolRegistry({ planMode });
   const { createWorkspaceContext: createWorkspaceContext2, createWorkspaceStubs: createWorkspaceStubs2 } = await Promise.resolve().then(() => (init_stubs(), stubs_exports));
   const { createWorkspaceToolRegistry: createWorkspaceToolRegistry2 } = await Promise.resolve().then(() => (init_toolRegistry2(), toolRegistry_exports2));
@@ -38982,17 +39770,30 @@ async function buildCouncilToolRegistry(planMode) {
     if (td) toolRegistry.register(td);
   }
   setWorkspaceStubs2(createWorkspaceStubs2(realCtx));
+  if (opts) {
+    await registerHeadlessMcp(toolRegistry, opts);
+  }
   return { toolRegistry, workspaceCtx: realCtx };
 }
 async function runHeadlessCouncil(opts, provider, model, providerStream) {
   const { dispatchCouncil: dispatchCouncil2 } = await Promise.resolve().then(() => (init_councilDispatcher(), councilDispatcher_exports));
   const sessionId = crypto.randomUUID();
-  const { toolRegistry } = await buildCouncilToolRegistry(planModeFromOpts(opts));
+  const { toolRegistry } = await buildCouncilToolRegistry(
+    planModeFromOpts(opts),
+    opts
+  );
   const { FeedbackStore: FeedbackStore2 } = await Promise.resolve().then(() => (init_councilFeedback(), councilFeedback_exports));
   const feedbackStore = new FeedbackStore2();
+  const historySeed = (opts.history ?? []).map(
+    (m) => m.role === "assistant" && m.content ? { ...m, content: cleanAgentContent(m.content, { stripQuestion: false }) } : m
+  );
+  const effectiveTask = buildCouncilTaskWithHistory(opts.task, historySeed);
   let exitCode = 0;
+  const scrub = createStreamScrubber();
+  let lastAssistantText = "";
+  let currentAssistantText = "";
   try {
-    for await (const event of dispatchCouncil2(opts.task, {
+    for await (const event of dispatchCouncil2(effectiveTask, {
       apiKey: "REDACTED",
       model,
       provider: "openai-compatible",
@@ -39002,14 +39803,35 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
       feedbackStore,
       runMode: planModeFromOpts(opts) ? "design-phase" : "implementation"
     })) {
-      if (opts.output === "json") {
-        emitEvent(event);
-      } else if (event.type === "message_delta") {
-        process.stdout.write(event.delta);
-      } else if (event.type === "agent_end" && event.reason === "error") {
-        exitCode = 3;
-      } else if (event.type === "error" && event.severity === "fatal") {
-        exitCode = 2;
+      if (event.type === "message_start") {
+        scrub.reset();
+        currentAssistantText = "";
+      }
+      if (event.type === "message_delta" && typeof event.delta === "string") {
+        const cleanDelta = scrub.push(event.delta);
+        if (cleanDelta.length > 0) currentAssistantText += cleanDelta;
+        if (opts.output === "json") {
+          if (cleanDelta.length > 0) emitEvent({ ...event, delta: cleanDelta });
+        } else if (opts.output === "plain" && cleanDelta.length > 0) {
+          process.stdout.write(cleanDelta);
+        }
+      } else {
+        if (opts.output === "json") emitEvent(event);
+        if (event.type === "message_end" || event.type === "agent_end") {
+          const tail = scrub.flush();
+          if (tail.length > 0) {
+            currentAssistantText += tail;
+            if (opts.output === "plain") process.stdout.write(tail);
+          }
+          if (currentAssistantText.trim()) {
+            lastAssistantText = currentAssistantText.trim();
+          }
+          if (event.type === "agent_end" && event.reason === "error") {
+            exitCode = 3;
+          }
+        } else if (event.type === "error" && event.severity === "fatal") {
+          exitCode = 2;
+        }
       }
     }
   } catch (err) {
@@ -39019,6 +39841,16 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
     );
     return 2;
   }
+  if (opts.output === "json") {
+    try {
+      const snapshot = [
+        { role: "user", content: opts.task },
+        ...lastAssistantText ? [{ role: "assistant", content: lastAssistantText }] : []
+      ];
+      emitEvent({ type: "history_snapshot", messages: snapshot });
+    } catch {
+    }
+  }
   return exitCode;
 }
 async function runHeadlessZelari(opts, provider, model, providerStream) {
@@ -39035,7 +39867,10 @@ async function runHeadlessZelari(opts, provider, model, providerStream) {
     hasPlan: hasWorkspacePlan2(projectRoot)
   });
   const memory = await getMemoryBackend2(projectRoot);
-  const { toolRegistry, workspaceCtx } = await buildCouncilToolRegistry(planModeFromOpts(opts));
+  const { toolRegistry, workspaceCtx } = await buildCouncilToolRegistry(
+    planModeFromOpts(opts),
+    opts
+  );
   const feedbackStore = new FeedbackStore2();
   const chairmanBudget = envNumber(process.env.ZELARI_MODE_MAX_TOOLS_LUCIFER, {
     default: 30,
@@ -39048,11 +39883,16 @@ async function runHeadlessZelari(opts, provider, model, providerStream) {
       process.stderr.write(message + "\n");
     }
   };
+  const historySeed = (opts.history ?? []).map(
+    (m) => m.role === "assistant" && m.content ? { ...m, content: cleanAgentContent(m.content, { stripQuestion: false }) } : m
+  );
+  const missionTask = buildCouncilTaskWithHistory(opts.task, historySeed);
   emit(`[zelari] mission brief
 ${JSON.stringify({ deliverable: brief.deliverableThisMission, mvp: brief.sliceMvp?.title }, null, 0)}`);
   let exitCode = 0;
+  let lastMissionAssistant = "";
   try {
-    const state2 = await runZelariMission2(opts.task, brief, {
+    const state2 = await runZelariMission2(missionTask, brief, {
       projectRoot,
       memory,
       emit,
@@ -39066,6 +39906,7 @@ ${ragContext}` : slicePrompt;
         let writeCount = 0;
         let chairmanErrored = false;
         let membersCompleted = 0;
+        const scrub = createStreamScrubber();
         for await (const event of dispatchCouncil2(fullPrompt, {
           apiKey: "REDACTED",
           model,
@@ -39077,13 +39918,21 @@ ${ragContext}` : slicePrompt;
           runMode: planModeFromOpts(opts) ? "design-phase" : runMode,
           maxToolCallsChairman: chairmanBudget
         })) {
-          if (opts.output === "json") {
-            emitEvent(event);
-          } else if (event.type === "message_delta") {
-            process.stdout.write(event.delta);
+          if (event.type === "message_start") {
+            scrub.reset();
           }
           if (event.type === "message_delta" && typeof event.delta === "string") {
             synthesisText += event.delta;
+            const cleanDelta = scrub.push(event.delta);
+            if (opts.output === "json") {
+              if (cleanDelta.length > 0) emitEvent({ ...event, delta: cleanDelta });
+            } else if (opts.output === "plain" && cleanDelta.length > 0) {
+              process.stdout.write(cleanDelta);
+            }
+          } else {
+            if (opts.output === "json") {
+              emitEvent(event);
+            }
           }
           if (event.type === "tool_execution_end") {
             const name = event.toolName ?? event.name ?? "";
@@ -39125,6 +39974,11 @@ ${ragContext}` : slicePrompt;
           }
         } catch {
         }
+        if (synthesisText.trim()) {
+          lastMissionAssistant = cleanAgentContent(synthesisText, {
+            stripQuestion: false
+          });
+        }
         return {
           completionOk,
           ran: membersCompleted > 0 || synthesisText.length > 0,
@@ -39146,6 +40000,18 @@ ${ragContext}` : slicePrompt;
   } finally {
     await memory.close().catch(() => void 0);
   }
+  if (opts.output === "json") {
+    try {
+      emitEvent({
+        type: "history_snapshot",
+        messages: [
+          { role: "user", content: opts.task },
+          ...lastMissionAssistant ? [{ role: "assistant", content: lastMissionAssistant }] : []
+        ]
+      });
+    } catch {
+    }
+  }
   return exitCode;
 }
 
@@ -39396,9 +40262,9 @@ async function runDiscoverModels(providerArg) {
 
 // src/cli/skillsMd.ts
 init_skills2();
-import { existsSync as existsSync31, readdirSync as readdirSync4, readFileSync as readFileSync25 } from "node:fs";
-import { join as join23 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { existsSync as existsSync33, readdirSync as readdirSync4, readFileSync as readFileSync28 } from "node:fs";
+import { join as join25 } from "node:path";
+import { homedir as homedir7 } from "node:os";
 var CODING_CATEGORIES = /* @__PURE__ */ new Set([
   "plan",
   "refactor",
@@ -39413,10 +40279,10 @@ var CODING_CATEGORIES = /* @__PURE__ */ new Set([
 ]);
 function skillMdSearchDirs(projectRoot = process.cwd()) {
   return [
-    join23(projectRoot, ".zelari", "skills"),
-    join23(projectRoot, ".claude", "skills"),
-    join23(projectRoot, ".opencode", "skills"),
-    join23(homedir6(), ".zelari-code", "skills")
+    join25(projectRoot, ".zelari", "skills"),
+    join25(projectRoot, ".claude", "skills"),
+    join25(projectRoot, ".opencode", "skills"),
+    join25(homedir7(), ".zelari-code", "skills")
   ];
 }
 function parseSkillMd(content, sourcePath) {
@@ -39474,7 +40340,7 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
   const summary = { loaded: [], skipped: [] };
   const seen = new Set(options.existingIds ?? []);
   for (const dir of skillMdSearchDirs(projectRoot)) {
-    if (!existsSync31(dir)) continue;
+    if (!existsSync33(dir)) continue;
     let entries;
     try {
       entries = readdirSync4(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -39482,10 +40348,10 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
       continue;
     }
     for (const entry of entries) {
-      const skillPath = join23(dir, entry, "SKILL.md");
-      if (!existsSync31(skillPath)) continue;
+      const skillPath = join25(dir, entry, "SKILL.md");
+      if (!existsSync33(skillPath)) continue;
       try {
-        const parsed = parseSkillMd(readFileSync25(skillPath, "utf8"), skillPath);
+        const parsed = parseSkillMd(readFileSync28(skillPath, "utf8"), skillPath);
         if (!parsed) {
           summary.skipped.push({ path: skillPath, reason: "missing/invalid frontmatter (name, description) or empty body" });
           continue;
@@ -39508,6 +40374,116 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
 // src/cli/main.ts
 init_skills2();
 init_updater();
+
+// src/cli/mcp/mcpConfigIo.ts
+import {
+  existsSync as existsSync34,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync29,
+  writeFileSync as writeFileSync18
+} from "node:fs";
+import { dirname as dirname6, join as join26 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+function getUserMcpPath() {
+  return join26(homedir8(), ".zelari-code", "mcp.json");
+}
+function getProjectMcpPath(projectRoot) {
+  return join26(projectRoot, ".zelari", "mcp.json");
+}
+function readFile3(path36) {
+  if (!existsSync34(path36)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync29(path36, "utf8"));
+    const out = {};
+    for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
+      if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
+      out[name] = {
+        command: cfg.command.trim(),
+        args: Array.isArray(cfg.args) ? cfg.args.map(String) : void 0,
+        env: cfg.env && typeof cfg.env === "object" ? cfg.env : void 0,
+        enabled: cfg.enabled !== false
+      };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function writeFile(path36, servers) {
+  mkdirSync14(dirname6(path36), { recursive: true });
+  const body = { mcpServers: servers };
+  writeFileSync18(path36, `${JSON.stringify(body, null, 2)}
+`, "utf8");
+}
+function listMcpServers(projectRoot) {
+  const userPath = getUserMcpPath();
+  const userServers = readFile3(userPath);
+  const projectPath = projectRoot && projectRoot.trim() ? getProjectMcpPath(projectRoot.trim()) : null;
+  const projectServers = projectPath ? readFile3(projectPath) : {};
+  const servers = [];
+  for (const [name, cfg] of Object.entries(userServers)) {
+    servers.push({ name, ...cfg, scope: "user", path: userPath });
+  }
+  for (const [name, cfg] of Object.entries(projectServers)) {
+    servers.push({ name, ...cfg, scope: "project", path: projectPath });
+  }
+  servers.sort((a, b) => a.name.localeCompare(b.name));
+  const merged = {
+    ...userServers,
+    ...projectServers
+  };
+  return { userPath, projectPath, servers, merged };
+}
+function upsertMcpServer(opts) {
+  const name = opts.name.trim();
+  if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return {
+      ok: false,
+      error: "Invalid server name (use letters, digits, _ -)"
+    };
+  }
+  if (!opts.config.command?.trim()) {
+    return { ok: false, error: "command is required" };
+  }
+  let path36;
+  if (opts.scope === "user") {
+    path36 = getUserMcpPath();
+  } else {
+    const root = opts.projectRoot?.trim();
+    if (!root) {
+      return {
+        ok: false,
+        error: "projectRoot required for project scope (Open Folder first)"
+      };
+    }
+    path36 = getProjectMcpPath(root);
+  }
+  const current = readFile3(path36);
+  current[name] = {
+    command: opts.config.command.trim(),
+    args: opts.config.args,
+    env: opts.config.env,
+    enabled: opts.config.enabled !== false
+  };
+  writeFile(path36, current);
+  return { ok: true, path: path36 };
+}
+function removeMcpServer(opts) {
+  const path36 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path36) {
+    return { ok: false, error: "projectRoot required for project scope" };
+  }
+  const current = readFile3(path36);
+  if (!(opts.name in current)) {
+    return { ok: false, error: `Server "${opts.name}" not found in ${path36}` };
+  }
+  delete current[opts.name];
+  writeFile(path36, current);
+  return { ok: true, path: path36 };
+}
+
+// src/cli/main.ts
+init_targets();
 var VERSION = getCurrentVersion();
 function runPreflight() {
   if (process.env.ZELARI_SKIP_PREFLIGHT === "1") return;
@@ -39604,10 +40580,190 @@ function pickRootComponent() {
   }
   if (argv.includes("--help") || argv.includes("-h")) {
     console.log(
-      "zelari-code \u2014 AI Council coding agent CLI.\n\nUsage: zelari-code [options]\n\nOptions:\n  --version, -v       Print version and exit\n  --help, -h          Print this help and exit\n  --doctor            Diagnose install health (shim, bundle, PATH, deps,\n                      node/git/bash in the agent shell)\n  --fix-path          Add the npm global prefix to the user PATH\n                      (Windows only; fixes 'command not found' after install)\n  --skip-checks       Skip the boot-time prerequisite check\n                      (alias for ZELARI_SKIP_PREFLIGHT=1)\n  --no-wizard         Skip the first-run wizard\n  --reset-config      Re-run the wizard (clears provider.json on commit)\n  --headless          Run a single task without mounting the TUI\n    --task <text>       Task prompt (required in headless mode)\n    --output json|plain Output format (default: json)\n    --mode agent|council|zelari  Dispatch mode (default: agent)\n    --council          Alias for --mode council\n    --phase plan|build  Work phase (default: build)\n    --provider <id>    Provider override (default: active)\n    --model <id>       Model override (default: provider default)\n  --print-config      Print provider/model config as JSON (no secrets)\n  --set-config        Persist provider/model/endpoint\n    --provider <id>    Set active provider\n    --model <id>       Set model for that provider\n    --endpoint <url>   Custom OpenAI-compatible base URL\n    --endpoint-clear   Remove custom endpoint override\n  --set-key           Store an API key (never printed back)\n    --provider <id>    Provider id (required)\n    --key <secret>     API key (required)\n  --discover-models   Refresh model list for a provider\n    --provider <id>    Provider (default: active)\n\nEnvironment:\n  ZELARI_NO_WIZARD=1    Skip the first-run wizard\n  ZELARI_SKIP_PREFLIGHT=1  Skip the boot prerequisite check\n  ZELARI_NO_PLUGIN_PROMPT=1  Skip the boot plugin-install prompt\n  ANATHEMA_DEV=1        Disable background update check + preflight\n"
+      "zelari-code \u2014 AI Council coding agent CLI.\n\nUsage: zelari-code [options]\n\nOptions:\n  --version, -v       Print version and exit\n  --help, -h          Print this help and exit\n  --doctor            Diagnose install health (shim, bundle, PATH, deps,\n                      node/git/bash in the agent shell)\n  --fix-path          Add the npm global prefix to the user PATH\n                      (Windows only; fixes 'command not found' after install)\n  --skip-checks       Skip the boot-time prerequisite check\n                      (alias for ZELARI_SKIP_PREFLIGHT=1)\n  --no-wizard         Skip the first-run wizard\n  --reset-config      Re-run the wizard (clears provider.json on commit)\n  --headless          Run a single task without mounting the TUI\n    --task <text>       Task prompt (required in headless mode)\n    --output json|plain Output format (default: json)\n    --mode agent|council|zelari  Dispatch mode (default: agent)\n    --council          Alias for --mode council\n    --phase plan|build  Work phase (default: build)\n    --provider <id>    Provider override (default: active)\n    --model <id>       Model override (default: provider default)\n  --print-config      Print provider/model config as JSON (no secrets)\n  --set-config        Persist provider/model/endpoint\n    --provider <id>    Set active provider\n    --model <id>       Set model for that provider\n    --endpoint <url>   Custom OpenAI-compatible base URL\n    --endpoint-clear   Remove custom endpoint override\n  --set-key           Store an API key (never printed back)\n    --provider <id>    Provider id (required)\n    --key <secret>     API key (required)\n  --discover-models   Refresh model list for a provider\n    --provider <id>    Provider (default: active)\n  --print-mcp         Print MCP server config (user + project)\n    --cwd <path>      Project root for .zelari/mcp.json\n  --set-mcp           Add/update an MCP server entry\n    --name <id>       Server name (required)\n    --command <bin>   Executable (required)\n    --args <json>     JSON array of args (optional)\n    --scope user|project  Default: user\n    --enabled true|false  Default: true\n    --cwd <path>      Required when scope=project\n  --remove-mcp        Remove an MCP server entry\n    --name <id> --scope user|project [--cwd <path>]\n  --print-ssh-targets Print SSH deploy/monitor targets\n  --set-ssh-target    Upsert target (--json '{...}' or flags)\n  --remove-ssh-target --id <id>\n  --test-ssh-target   --id <id>  (BatchMode ssh true)\n  --print-ssh-pubkey  --path <private-or-.pub>  (display public key)\n\nEnvironment:\n  ZELARI_NO_WIZARD=1    Skip the first-run wizard\n  ZELARI_SKIP_PREFLIGHT=1  Skip the boot prerequisite check\n  ZELARI_NO_PLUGIN_PROMPT=1  Skip the boot plugin-install prompt\n  ANATHEMA_DEV=1        Disable background update check + preflight\n"
     );
     process.exit(0);
   }
+  if (argv.includes("--print-mcp")) {
+    try {
+      const cwdIdx = argv.indexOf("--cwd");
+      const cwd = cwdIdx >= 0 && argv[cwdIdx + 1] ? argv[cwdIdx + 1] : process.cwd();
+      const snap = listMcpServers(cwd);
+      console.log(JSON.stringify(snap, null, 2));
+      process.exit(0);
+    } catch (err) {
+      console.error(
+        `[zelari-code --print-mcp] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  if (argv.includes("--set-mcp")) {
+    try {
+      const get = (flag) => {
+        const i = argv.indexOf(flag);
+        return i >= 0 && argv[i + 1] ? argv[i + 1] : void 0;
+      };
+      const name = get("--name");
+      const command = get("--command");
+      const scopeRaw = get("--scope") ?? "user";
+      const scope = scopeRaw === "project" ? "project" : "user";
+      const cwd = get("--cwd") ?? process.cwd();
+      const enabledRaw = get("--enabled");
+      const enabled = enabledRaw === void 0 ? true : enabledRaw !== "false";
+      let args;
+      const argsRaw = get("--args");
+      if (argsRaw) {
+        const parsed = JSON.parse(argsRaw);
+        if (!Array.isArray(parsed)) throw new Error("--args must be a JSON array");
+        args = parsed.map(String);
+      }
+      if (!name || !command) {
+        throw new Error("--name and --command are required");
+      }
+      const result = upsertMcpServer({
+        scope,
+        name,
+        projectRoot: cwd,
+        config: { command, args, enabled }
+      });
+      if (!result.ok) throw new Error(result.error);
+      console.log(JSON.stringify({ ok: true, path: result.path, name, scope }));
+      process.exit(0);
+    } catch (err) {
+      console.error(
+        `[zelari-code --set-mcp] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  if (argv.includes("--remove-mcp")) {
+    try {
+      const get = (flag) => {
+        const i = argv.indexOf(flag);
+        return i >= 0 && argv[i + 1] ? argv[i + 1] : void 0;
+      };
+      const name = get("--name");
+      const scopeRaw = get("--scope") ?? "user";
+      const scope = scopeRaw === "project" ? "project" : "user";
+      const cwd = get("--cwd") ?? process.cwd();
+      if (!name) throw new Error("--name is required");
+      const result = removeMcpServer({ scope, name, projectRoot: cwd });
+      if (!result.ok) throw new Error(result.error);
+      console.log(JSON.stringify({ ok: true, path: result.path, name, scope }));
+      process.exit(0);
+    } catch (err) {
+      console.error(
+        `[zelari-code --remove-mcp] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  if (argv.includes("--print-ssh-targets")) {
+    try {
+      console.log(JSON.stringify(listSshTargets(), null, 2));
+      process.exit(0);
+    } catch (err) {
+      console.error(
+        `[zelari-code --print-ssh-targets] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  if (argv.includes("--set-ssh-target")) {
+    try {
+      const get = (flag) => {
+        const i = argv.indexOf(flag);
+        return i >= 0 && argv[i + 1] ? argv[i + 1] : void 0;
+      };
+      let target;
+      const jsonRaw = get("--json");
+      if (jsonRaw) {
+        target = JSON.parse(jsonRaw);
+      } else {
+        const id = get("--id");
+        const host = get("--host");
+        const user = get("--user");
+        if (!id || !host || !user) {
+          throw new Error("Need --json or --id --host --user");
+        }
+        const allowedRaw = get("--allowed");
+        const authFlag = get("--auth");
+        const auth = authFlag === "password" || get("--password") ? "password" : get("--key-path") ? "keyPath" : "agent";
+        target = {
+          id,
+          name: get("--name") ?? id,
+          host,
+          user,
+          port: get("--port") ? Number(get("--port")) : 22,
+          auth,
+          keyPath: get("--key-path"),
+          password: get("--password"),
+          defaultRemotePath: get("--remote-path"),
+          allowedCommands: allowedRaw ? allowedRaw.split("|").map((s) => s.trim()).filter(Boolean) : [],
+          enabled: get("--enabled") !== "false"
+        };
+      }
+      const result = upsertSshTarget(target);
+      if (!result.ok) throw new Error(result.error);
+      console.log(JSON.stringify({ ok: true, id: target.id }));
+      process.exit(0);
+    } catch (err) {
+      console.error(
+        `[zelari-code --set-ssh-target] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  if (argv.includes("--remove-ssh-target")) {
+    try {
+      const i = argv.indexOf("--id");
+      const id = i >= 0 ? argv[i + 1] : void 0;
+      if (!id) throw new Error("--id is required");
+      const result = removeSshTarget(id);
+      if (!result.ok) throw new Error(result.error);
+      console.log(JSON.stringify({ ok: true, id }));
+      process.exit(0);
+    } catch (err) {
+      console.error(
+        `[zelari-code --remove-ssh-target] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
+  if (argv.includes("--test-ssh-target")) {
+    const i = argv.indexOf("--id");
+    const id = i >= 0 ? argv[i + 1] : void 0;
+    if (!id) {
+      console.error("[zelari-code --test-ssh-target] --id is required");
+      process.exit(1);
+    }
+    void testSshTarget(id).then((result) => {
+      console.log(JSON.stringify(result));
+      process.exit(result.ok ? 0 : 1);
+    }).catch((err) => {
+      console.error(
+        `[zelari-code --test-ssh-target] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    });
+    return { kind: "done" };
+  }
+  if (argv.includes("--print-ssh-pubkey")) {
+    try {
+      const i = argv.indexOf("--path");
+      const p3 = i >= 0 ? argv[i + 1] : void 0;
+      if (!p3) throw new Error("--path is required");
+      const result = readSshPublicKey(p3);
+      console.log(JSON.stringify(result));
+      process.exit(result.ok ? 0 : 1);
+    } catch (err) {
+      console.error(
+        `[zelari-code --print-ssh-pubkey] ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(1);
+    }
+  }
   if (wantsPrintConfig(argv)) {
     try {
       printDesktopConfig();