zelari-code 1.5.2 → 1.5.4

package/dist/cli/main.bundled.js

@@ -18050,6 +18050,357 @@ var init_toolSchemas = __esm({
   }
 });
 
+// packages/core/dist/agents/councilDirectives.js
+function getCouncilDirectiveModules() {
+  return [
+    STRUCTURED_REASONING_DIRECTIVE,
+    COLLABORATION_DIRECTIVE,
+    TOOL_USE_PROTOCOL_DIRECTIVE,
+    OUTPUT_QUALITY_DIRECTIVE
+  ].sort((a, b) => a.priority - b.priority);
+}
+var STRUCTURED_REASONING_DIRECTIVE, TOOL_USE_PROTOCOL_DIRECTIVE, OUTPUT_QUALITY_DIRECTIVE, COLLABORATION_DIRECTIVE;
+var init_councilDirectives = __esm({
+  "packages/core/dist/agents/councilDirectives.js"() {
+    "use strict";
+    STRUCTURED_REASONING_DIRECTIVE = {
+      type: "custom",
+      title: "Structured Reasoning",
+      priority: 15,
+      content: `# Structured Reasoning
+
+Think step by step internally before responding. Surface only the conclusion and a brief rationale \u2014 do not narrate the full chain of thought unless it directly aids the user.
+
+- For any non-trivial task, decompose it into ordered sub-steps and address each one before synthesizing.
+- Prefer concrete specifics over vague generalities: file paths, line numbers, measurable acceptance criteria, and concrete examples beat abstract advice.
+- When evaluating options, weigh trade-offs explicitly (cost, risk, effort, coverage) rather than listing features.
+- If information may have changed since your knowledge cutoff (project state, current tasks, stored documents), consult the shared context or use a retrieval tool rather than relying on memory.
+- Distinguish what you know from what you assume. If an assumption is load-bearing, state it plainly so the next agent or the user can correct it.
+- Do not confabulate. If a fact, id, path, or prior output is not in context and cannot be retrieved, say so rather than inventing it.`
+    };
+    TOOL_USE_PROTOCOL_DIRECTIVE = {
+      type: "custom",
+      title: "Tool-Use Protocol",
+      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.
+
+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 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.
+
+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.`
+    };
+    OUTPUT_QUALITY_DIRECTIVE = {
+      type: "custom",
+      title: "Output Quality & Self-Check",
+      priority: 35,
+      content: `# Output Quality & Self-Check
+
+Before finalising your response, run a quick self-check against these criteria:
+
+- **Completeness**: Did you address the whole request, not just the easy part?
+- **Correctness**: Are file paths, ids, and facts accurate (or explicitly flagged as assumptions)?
+- **Actionability**: Can the user (or the next agent) act on this immediately? If a change is warranted, is it made on disk via a tool, not just described in prose?
+- **Non-redundancy**: Does this add to what prior agents already said, or merely repeat it? Reference prior work by name rather than restating it.
+- **Conciseness**: Stay within your role's word budget. Cut filler. Prefer one concrete example over three abstract ones.
+
+Formatting:
+- Use well-structured markdown. Lead with a one-line summary, then details.
+- Use \`##\` headings and \`-\` bullets only when they materially aid clarity; avoid over-formatting.
+- Reference files and code by path and line number so the next agent can locate them.`
+    };
+    COLLABORATION_DIRECTIVE = {
+      type: "custom",
+      title: "Inter-Agent Collaboration",
+      priority: 16,
+      content: `# Inter-Agent Collaboration
+
+You are one member of a council. Earlier agents' outputs appear in your context as shared work.
+
+- Treat prior agents' outputs as authoritative unless they contain an error you must flag. Do not re-derive what they already established.
+- Build on, extend, or critique prior work by name (e.g. "Nettuno proposed X; I add Y").
+- If you spot a gap, risk, or contradiction in a prior agent's output, name it explicitly and propose a concrete fix.
+- Keep the shared context lean: summarise rather than quote verbatim when content is long.
+- Hand off cleanly: end with a crisp statement of what you produced and what remains for downstream agents or the Lucifero.`
+    };
+  }
+});
+
+// packages/core/dist/agents/promptModules.js
+function getPromptModule(type) {
+  return PROMPT_MODULES.find((m) => m.type === type);
+}
+function getBasePromptModules() {
+  return [...PROMPT_MODULES].sort((a, b) => a.priority - b.priority);
+}
+var 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.
+
+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
+
+- 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
+
+The council shares a context window across turns. Follow these rules:
+
+- 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:
+\`\`\`
+---TOOLS---
+[{"name":"<toolName>","args":{...}}]
+---END---
+\`\`\``
+      },
+      {
+        type: "custom",
+        title: "Clarification Protocol",
+        priority: 55,
+        content: `# Clarification Protocol (Council-Wide)
+
+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.
+
+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.`
+      }
+    ];
+    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 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.
+
+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.`
+    };
+  }
+});
+
+// packages/core/dist/agents/systemPromptBuilder.js
+function computeAgentSkills(agent, aiConfig, customSkills) {
+  const declared = agent.skills ?? resolveAgentSkills(agent.id).map((s) => s.id);
+  const globalEnabled = aiConfig?.enabledSkills;
+  const override = aiConfig?.agentSkillConfigs.find((c) => c.agentId === agent.id);
+  let effectiveIds;
+  if (override) {
+    effectiveIds = override.enabledSkillIds;
+  } else if (globalEnabled && globalEnabled.length > 0) {
+    effectiveIds = declared.filter((id) => globalEnabled.includes(id));
+  } else {
+    effectiveIds = declared;
+  }
+  const customs = customSkills ?? [];
+  for (const cs of customs) {
+    if (cs.enabled && cs.autoAttachTo?.includes(agent.id) && !effectiveIds.includes(cs.id)) {
+      effectiveIds.push(cs.id);
+    }
+  }
+  const builtin = effectiveIds.map((id) => getSkillById(id)).filter((s) => s !== void 0);
+  const customDefs = [];
+  for (const cs of customs) {
+    if (!cs.enabled)
+      continue;
+    if (effectiveIds.includes(cs.id) && !builtin.find((b) => b.id === cs.id)) {
+      customDefs.push({
+        id: cs.id,
+        name: cs.name,
+        description: cs.description,
+        category: cs.category,
+        color: cs.color,
+        enabledByDefault: cs.enabled,
+        builtin: false,
+        requiredTools: cs.requiredTools,
+        systemPromptFragment: cs.systemPromptFragment
+      });
+    }
+  }
+  return [...builtin, ...customDefs];
+}
+function computeAgentTools(agent, aiConfig) {
+  const skills = computeAgentSkills(agent, aiConfig);
+  const skillTools = skills.flatMap((s) => s.requiredTools);
+  const declared = agent.tools ?? [];
+  const merged = Array.from(/* @__PURE__ */ new Set([...declared, ...skillTools]));
+  const globalEnabled = aiConfig?.enabledTools;
+  if (globalEnabled && globalEnabled.length > 0) {
+    return merged.filter((t) => globalEnabled.includes(t));
+  }
+  return merged;
+}
+function getToolDescriptions(toolNames, registry3) {
+  const lines = ["AVAILABLE TOOLS (use ONLY these exact names):"];
+  for (const name of toolNames) {
+    const tool = registry3.get(name);
+    if (!tool)
+      continue;
+    let paramList;
+    if (Array.isArray(tool.parameters)) {
+      paramList = tool.parameters.map((p3) => `${p3.name}:${p3.type}`).join(", ");
+    } else {
+      const obj = tool.parameters;
+      paramList = Object.entries(obj.properties ?? {}).map(([k, v]) => `${k}:${v.type ?? "any"}`).join(", ");
+    }
+    lines.push(`- ${name}: ${tool.description} \u2014 args { ${paramList} }`);
+  }
+  return lines.join("\n");
+}
+function buildSystemPrompt(agent, options) {
+  const { tools, toolNames, aiConfig, workspaceContext, ragContext } = 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 customModulesRaw = aiConfig?.customPromptModules ?? [];
+  const customTypes = new Set(customModulesRaw.map((m) => m.type));
+  const baseNotOverridden = baseModules.filter((m) => !customTypes.has(m.type));
+  const customModules = customModulesRaw.map((m) => ({
+    ...m,
+    priority: 1e3 + m.priority
+  }));
+  const allModules = [...baseNotOverridden, ...customModules].sort((a, b) => a.priority - b.priority);
+  const parts = [];
+  for (const mod of allModules) {
+    parts.push(mod.content);
+  }
+  if (agent.systemPrompt && agent.systemPrompt.trim()) {
+    parts.push(`# Your Role
+
+${agent.systemPrompt}`);
+  }
+  if (skills.length > 0) {
+    parts.push(`# Active Skills
+
+` + skills.map((s) => `## ${s.name}
+${s.systemPromptFragment}`).join("\n\n"));
+  }
+  const toolBlock = getToolDescriptions(toolNames, registry3);
+  if (toolNames.length > 0) {
+    parts.push(`# Tools
+
+${toolBlock}`);
+  }
+  if (workspaceContext && workspaceContext.trim()) {
+    parts.push(`# Current Workspace State
+
+${workspaceContext}`);
+  }
+  if (ragContext && ragContext.trim()) {
+    parts.push(`# Retrieved Knowledge (RAG)
+
+${ragContext}`);
+  }
+  return parts.join("\n\n---\n\n");
+}
+var init_systemPromptBuilder = __esm({
+  "packages/core/dist/agents/systemPromptBuilder.js"() {
+    "use strict";
+    init_promptModules();
+    init_skills();
+  }
+});
+
 // packages/core/dist/skills/index.js
 var skills_exports = {};
 __export(skills_exports, {
@@ -18057,10 +18408,12 @@ __export(skills_exports, {
   ALL_TOOLS: () => ALL_TOOLS,
   CODING_CATEGORY: () => CODING_CATEGORY,
   CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
+  SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
   SKILL_CATALOG: () => SKILL_CATALOG,
   TOOL_DEFINITIONS: () => TOOL_DEFINITIONS,
   VAULT_TOOL_DEFINITIONS: () => VAULT_TOOL_DEFINITIONS,
   buildCustomParameters: () => buildCustomParameters,
+  buildSystemPrompt: () => buildSystemPrompt,
   clearCustomTools: () => clearCustomTools,
   cliToolToEnhanced: () => cliToolToEnhanced,
   executeTool: () => executeTool,
@@ -18098,6 +18451,8 @@ var init_skills2 = __esm({
     init_advancedTools();
     init_vaultTools();
     init_harnessToolBridge();
+    init_promptModules();
+    init_systemPromptBuilder();
   }
 });
 
@@ -19201,7 +19556,21 @@ var init_openai_compatible = __esm({
 });
 
 // packages/core/dist/core/tools/registry.js
-var TOOL_NAME_ALIASES, ToolRegistry;
+function truncateToolResult(text, cap = TOOL_RESULT_LINE_CAP) {
+  if (text.length === 0)
+    return text;
+  const lines = text.split("\n");
+  if (lines.length <= cap)
+    return text;
+  const half = Math.floor(cap / 2);
+  const head = lines.slice(0, half);
+  const tail = lines.slice(lines.length - half);
+  const omitted = lines.length - cap;
+  return head.join("\n") + `
+\u2026 [+${omitted} lines omitted \u2014 showing head:${half}, tail:${half} of ${lines.length} total] \u2026
+` + tail.join("\n");
+}
+var TOOL_NAME_ALIASES, TOOL_RESULT_LINE_CAP, ToolRegistry;
 var init_registry = __esm({
   "packages/core/dist/core/tools/registry.js"() {
     "use strict";
@@ -19231,6 +19600,11 @@ var init_registry = __esm({
       run: "bash",
       exec: "bash"
     };
+    TOOL_RESULT_LINE_CAP = (() => {
+      const raw = process.env.ZELARI_TOOL_RESULT_LINES;
+      const n = raw ? Number.parseInt(raw, 10) : 200;
+      return Number.isFinite(n) && n >= 10 ? n : 200;
+    })();
     ToolRegistry = class {
       tools = /* @__PURE__ */ new Map();
       register(def) {
@@ -19282,6 +19656,17 @@ var init_registry = __esm({
               });
             })
           ]);
+          if (result.ok) {
+            if (typeof result.value === "string") {
+              return { ok: true, value: truncateToolResult(result.value) };
+            }
+            if (result.value && typeof result.value === "object") {
+              const v = result.value;
+              if (typeof v.content === "string") {
+                v.content = truncateToolResult(v.content);
+              }
+            }
+          }
           return result;
         } catch (err) {
           const error51 = err instanceof Error ? err.message : String(err);
@@ -19487,6 +19872,21 @@ var init_auditLogger = __esm({
   }
 });
 
+// src/cli/utils/cmdline.ts
+function quoteCmdArg(arg) {
+  if (arg === "") return '""';
+  if (!/[\s"^&|<>()%!]/.test(arg)) return arg;
+  return `"${arg.replace(/"/g, '""')}"`;
+}
+function buildCmdLine(command, args) {
+  return [command, ...args].map(quoteCmdArg).join(" ");
+}
+var init_cmdline = __esm({
+  "src/cli/utils/cmdline.ts"() {
+    "use strict";
+  }
+});
+
 // src/cli/diagnostics/engine.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync7 } from "node:fs";
@@ -19604,6 +20004,7 @@ var DEFAULT_PROVIDERS, defaultRunner;
 var init_engine = __esm({
   "src/cli/diagnostics/engine.ts"() {
     "use strict";
+    init_cmdline();
     init_paths();
     DEFAULT_PROVIDERS = [
       {
@@ -19632,7 +20033,7 @@ var init_engine = __esm({
       };
       let child;
       try {
-        child = process.platform === "win32" ? spawn2(`${cmd} ${args.join(" ")}`, { cwd: opts.cwd, shell: true }) : spawn2(cmd, args, { cwd: opts.cwd });
+        child = process.platform === "win32" ? spawn2(buildCmdLine(cmd, args), { cwd: opts.cwd, shell: true }) : spawn2(cmd, args, { cwd: opts.cwd });
       } catch {
         done({ code: null, stdout: "", stderr: "" });
         return;
@@ -20201,12 +20602,16 @@ var init_manager = __esm({
       cwd;
       spawnImpl;
       timeoutMs;
+      onWarn;
       servers = /* @__PURE__ */ new Map();
       // language → entry (null = unavailable)
+      warnedMissing = /* @__PURE__ */ new Set();
+      // languages already flagged as unavailable
       constructor(options = {}) {
         this.cwd = options.cwd ?? process.cwd();
         this.spawnImpl = options.spawnImpl ?? spawn3;
         this.timeoutMs = options.timeoutMs ?? 15e3;
+        this.onWarn = options.onWarn ?? ((m) => console.error(m));
       }
       /** Lazily start (or reuse) the server for a file's language. Null if none. */
       getServer(file2) {
@@ -20214,27 +20619,58 @@ var init_manager = __esm({
         if (!cmd) return null;
         const cached2 = this.servers.get(cmd.language);
         if (cached2 !== void 0) return cached2;
+        let resolveInit;
+        let rejectInit;
+        const initialized = new Promise((resolve, reject) => {
+          resolveInit = resolve;
+          rejectInit = reject;
+        });
         let entry = null;
         try {
           const child = this.spawnImpl(cmd.command, cmd.args, {
             cwd: this.cwd
           });
           const client = new LspClient(processTransport(child), { timeoutMs: this.timeoutMs });
-          const initialized = client.request("initialize", {
+          child.on("error", (err) => {
+            if (this.servers.get(cmd.language) === null) return;
+            this.servers.set(cmd.language, null);
+            rejectInit(err instanceof Error ? err : new Error(String(err)));
+            try {
+              client.dispose();
+            } catch {
+            }
+            if (!this.warnedMissing.has(cmd.language)) {
+              this.warnedMissing.add(cmd.language);
+              this.onWarn(
+                `[zelari-code] ${cmd.command} unavailable (LSP tools disabled for ${cmd.language}): ${err?.code === "ENOENT" ? "binary not found on PATH" : err?.message ?? String(err)}`
+              );
+            }
+          });
+          client.request("initialize", {
             processId: process.pid,
             rootUri: pathToUri(this.cwd),
             capabilities: {},
             workspaceFolders: [{ uri: pathToUri(this.cwd), name: "root" }]
           }).then(() => {
             client.notify("initialized", {});
-          });
+            resolveInit();
+          }).catch((e) => rejectInit(e instanceof Error ? e : new Error(String(e))));
           entry = { client, initialized, opened: /* @__PURE__ */ new Map(), dispose: () => client.dispose() };
-        } catch {
-          entry = null;
+        } catch (e) {
+          this.servers.set(cmd.language, null);
+          this.warnMissing(cmd.language, cmd.command, e);
+          return null;
         }
         this.servers.set(cmd.language, entry);
         return entry;
       }
+      warnMissing(language, command, err) {
+        if (this.warnedMissing.has(language)) return;
+        this.warnedMissing.add(language);
+        const code = err?.code;
+        const msg = code === "ENOENT" ? "binary not found on PATH" : err?.message ?? String(err);
+        this.onWarn(`[zelari-code] ${command} unavailable (LSP tools disabled for ${language}): ${msg}`);
+      }
       /** Ensure a document is open (or synced) on the server. */
       async openDoc(entry, file2) {
         await entry.initialized;
@@ -21443,562 +21879,223 @@ Example format:
 ## 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.
-
-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:
-
-\`\`\`
-createPlan({
-  phases: [
-    {
-      name: "Foundation & Technical Blueprint",
-      description: "Lock the stack and the non-negotiable quality budget. Exit: baseline builds green.",
-      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" }
-      ]
-    },
-    { 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" }
-})
-\`\`\`
-
-Every task MUST include fileRefs, acceptance, and qaScenario \u2014 the QA scenario proves the task is verifiable.
-
-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.
-        tools: ["list_files", "read_file", "grep_content"],
-        skills: ["project-planner", "vault-manager"]
-      },
-      {
-        id: "geryon",
-        name: "Gerione",
-        codename: "Ideator",
-        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}
-
-## 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.
-        tools: ["list_files", "read_file"],
-        skills: ["document-writer", "mind-mapper"]
-      },
-      {
-        id: "pluton",
-        name: "Plutone",
-        codename: "MindMapper",
-        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.
-
-## 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:
-
-\`createDocument({ title: "knowledge-map", content: "<markdown: root concept, branches, leaf nodes, and cross-links>" })\`
-
-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.
-        tools: ["list_files", "read_file", "grep_content"],
-        skills: ["document-writer", "research-analyst"]
-      },
-      {
-        id: "minos",
-        name: "Minosse",
-        codename: "Critic",
-        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.
-
-## 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
-
-Stay under 200 words.${CLARIFICATION_PROTOCOL8}
-
-## 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:
-
-\`\`\`
-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: [],
-        skills: ["document-writer", "research-analyst"]
-      },
-      {
-        id: "lucifer",
-        name: "Lucifero",
-        codename: "Synthesizer",
-        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\`
-})
-\`\`\`
-
-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.
-        tools: ["read_file", "write_file", "edit_file", "bash", "list_files"],
-        skills: ["vault-manager", "project-planner", "idea-synthesizer"]
-      }
-    ];
-    UnknownMemberError = class extends Error {
-      unknownId;
-      availableIds;
-      constructor(unknownId, availableIds) {
-        super(`Unknown member id for swap: "${unknownId}". Available: ${availableIds.join(", ") || "(none)"}.`);
-        this.name = "UnknownMemberError";
-        this.unknownId = unknownId;
-        this.availableIds = availableIds;
-      }
-    };
-  }
-});
+- If the stack/platform is unknown, ask ONCE (see clarification protocol) rather than guessing.
 
-// packages/core/dist/agents/councilDirectives.js
-function getCouncilDirectiveModules() {
-  return [
-    STRUCTURED_REASONING_DIRECTIVE,
-    COLLABORATION_DIRECTIVE,
-    TOOL_USE_PROTOCOL_DIRECTIVE,
-    OUTPUT_QUALITY_DIRECTIVE
-  ].sort((a, b) => a.priority - b.priority);
-}
-var STRUCTURED_REASONING_DIRECTIVE, TOOL_USE_PROTOCOL_DIRECTIVE, OUTPUT_QUALITY_DIRECTIVE, COLLABORATION_DIRECTIVE;
-var init_councilDirectives = __esm({
-  "packages/core/dist/agents/councilDirectives.js"() {
-    "use strict";
-    STRUCTURED_REASONING_DIRECTIVE = {
-      type: "custom",
-      title: "Structured Reasoning",
-      priority: 15,
-      content: `# Structured Reasoning
+Keep plans hierarchical and practical. Stay under 250 words.${CLARIFICATION_PROTOCOL8}
 
-Think step by step internally before responding. Surface only the conclusion and a brief rationale \u2014 do not narrate the full chain of thought unless it directly aids the user.
+## 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.
 
-- For any non-trivial task, decompose it into ordered sub-steps and address each one before synthesizing.
-- Prefer concrete specifics over vague generalities: file paths, line numbers, measurable acceptance criteria, and concrete examples beat abstract advice.
-- When evaluating options, weigh trade-offs explicitly (cost, risk, effort, coverage) rather than listing features.
-- If information may have changed since your knowledge cutoff (project state, current tasks, stored documents), consult the shared context or use a retrieval tool rather than relying on memory.
-- Distinguish what you know from what you assume. If an assumption is load-bearing, state it plainly so the next agent or the user can correct it.
-- Do not confabulate. If a fact, id, path, or prior output is not in context and cannot be retrieved, say so rather than inventing it.`
-    };
-    TOOL_USE_PROTOCOL_DIRECTIVE = {
-      type: "custom",
-      title: "Tool-Use Protocol",
-      priority: 25,
-      content: `# Tool-Use Protocol \u2014 Act, Don't Just Describe
+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:
 
-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.
+\`\`\`
+createPlan({
+  phases: [
+    {
+      name: "Foundation & Technical Blueprint",
+      description: "Lock the stack and the non-negotiable quality budget. Exit: baseline builds green.",
+      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" }
+      ]
+    },
+    { 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" }
+})
+\`\`\`
 
-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).
+Every task MUST include fileRefs, acceptance, and qaScenario \u2014 the QA scenario proves the task is verifiable.
 
-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.
+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.
 
-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.`
-    };
-    OUTPUT_QUALITY_DIRECTIVE = {
-      type: "custom",
-      title: "Output Quality & Self-Check",
-      priority: 35,
-      content: `# Output Quality & Self-Check
+Do NOT output tasks as prose. The system will refuse any task that does not pass a valid phaseId.
 
-Before finalising your response, run a quick self-check against these criteria:
+## 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.
+        tools: ["list_files", "read_file", "grep_content"],
+        skills: ["project-planner", "vault-manager"]
+      },
+      {
+        id: "geryon",
+        name: "Gerione",
+        codename: "Ideator",
+        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.
 
-- **Completeness**: Did you address the whole request, not just the easy part?
-- **Correctness**: Are file paths, ids, and facts accurate (or explicitly flagged as assumptions)?
-- **Actionability**: Can the user (or the next agent) act on this immediately? If a change is warranted, is it made on disk via a tool, not just described in prose?
-- **Non-redundancy**: Does this add to what prior agents already said, or merely repeat it? Reference prior work by name rather than restating it.
-- **Conciseness**: Stay within your role's word budget. Cut filler. Prefer one concrete example over three abstract ones.
+## 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.
 
-Formatting:
-- Use well-structured markdown. Lead with a one-line summary, then details.
-- Use \`##\` headings and \`-\` bullets only when they materially aid clarity; avoid over-formatting.
-- Reference files and code by path and line number so the next agent can locate them.`
-    };
-    COLLABORATION_DIRECTIVE = {
-      type: "custom",
-      title: "Inter-Agent Collaboration",
-      priority: 16,
-      content: `# Inter-Agent Collaboration
+## 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).
 
-You are one member of a council. Earlier agents' outputs appear in your context as shared work.
+## Output format
+## Ideas (bulleted)
+## Themes
+## Top picks (with feasibility/novelty + de-risk note)
 
-- Treat prior agents' outputs as authoritative unless they contain an error you must flag. Do not re-derive what they already established.
-- Build on, extend, or critique prior work by name (e.g. "Nettuno proposed X; I add Y").
-- If you spot a gap, risk, or contradiction in a prior agent's output, name it explicitly and propose a concrete fix.
-- Keep the shared context lean: summarise rather than quote verbatim when content is long.
-- Hand off cleanly: end with a crisp statement of what you produced and what remains for downstream agents or the Lucifero.`
-    };
-  }
-});
+Stay under 200 words.${CLARIFICATION_PROTOCOL8}
 
-// packages/core/dist/agents/promptModules.js
-function getPromptModule(type) {
-  return PROMPT_MODULES.find((m) => m.type === type);
-}
-function getBasePromptModules() {
-  return [...PROMPT_MODULES].sort((a, b) => a.priority - b.priority);
-}
-var PROMPT_MODULES;
-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
+## 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:
 
-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.
+- \`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.
 
-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 may optionally add a 4th design system doc if the project warrants it.
 
-- 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.`
+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.
+        tools: ["list_files", "read_file"],
+        skills: ["document-writer", "mind-mapper"]
       },
       {
-        type: "safety-guardrails",
-        title: "Safety",
-        priority: 30,
-        content: `# Safety Guardrails
+        id: "pluton",
+        name: "Plutone",
+        codename: "MindMapper",
+        role: "Knowledge Architect",
+        color: "#06b6d4",
+        avatar: "P",
+        systemPrompt: `You are Plutone, the Knowledge Architect and Mind Mapper \u2014 you structure information into navigable graphs.
 
-- 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
+## 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.
 
-The council shares a context window across turns. Follow these rules:
+## 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.
 
-- 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
+## Output format
+Describe the proposed structure (root \u2192 branches \u2192 leaves) in text. Stay under 200 words.${CLARIFICATION_PROTOCOL8}
 
-- 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
+## Design-phase artifact (mandatory when running council in design-phase mode)
+Persist the knowledge map as ONE \`createDocument\` call:
 
-- 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.
+\`createDocument({ title: "knowledge-map", content: "<markdown: root concept, branches, leaf nodes, and cross-links>" })\`
 
-Format:
-\`\`\`
----TOOLS---
-[{"name":"<toolName>","args":{...}}]
----END---
-\`\`\``
+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.
+        tools: ["list_files", "read_file", "grep_content"],
+        skills: ["document-writer", "research-analyst"]
       },
       {
-        type: "custom",
-        title: "Clarification Protocol",
-        priority: 55,
-        content: `# Clarification Protocol (Council-Wide)
+        id: "minos",
+        name: "Minosse",
+        codename: "Critic",
+        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.
 
-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.
+## 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.
+
+## 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
+
+Stay under 200 words.${CLARIFICATION_PROTOCOL8}
+
+## 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:
 
-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---
+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. ...\`
+})
 \`\`\`
 
-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.`
-      }
-    ];
-  }
-});
+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: [],
+        skills: ["document-writer", "research-analyst"]
+      },
+      {
+        id: "lucifer",
+        name: "Lucifero",
+        codename: "Synthesizer",
+        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.
 
-// packages/core/dist/agents/systemPromptBuilder.js
-function computeAgentSkills(agent, aiConfig, customSkills) {
-  const declared = agent.skills ?? resolveAgentSkills(agent.id).map((s) => s.id);
-  const globalEnabled = aiConfig?.enabledSkills;
-  const override = aiConfig?.agentSkillConfigs.find((c) => c.agentId === agent.id);
-  let effectiveIds;
-  if (override) {
-    effectiveIds = override.enabledSkillIds;
-  } else if (globalEnabled && globalEnabled.length > 0) {
-    effectiveIds = declared.filter((id) => globalEnabled.includes(id));
-  } else {
-    effectiveIds = declared;
-  }
-  const customs = customSkills ?? [];
-  for (const cs of customs) {
-    if (cs.enabled && cs.autoAttachTo?.includes(agent.id) && !effectiveIds.includes(cs.id)) {
-      effectiveIds.push(cs.id);
-    }
-  }
-  const builtin = effectiveIds.map((id) => getSkillById(id)).filter((s) => s !== void 0);
-  const customDefs = [];
-  for (const cs of customs) {
-    if (!cs.enabled)
-      continue;
-    if (effectiveIds.includes(cs.id) && !builtin.find((b) => b.id === cs.id)) {
-      customDefs.push({
-        id: cs.id,
-        name: cs.name,
-        description: cs.description,
-        category: cs.category,
-        color: cs.color,
-        enabledByDefault: cs.enabled,
-        builtin: false,
-        requiredTools: cs.requiredTools,
-        systemPromptFragment: cs.systemPromptFragment
-      });
-    }
-  }
-  return [...builtin, ...customDefs];
-}
-function computeAgentTools(agent, aiConfig) {
-  const skills = computeAgentSkills(agent, aiConfig);
-  const skillTools = skills.flatMap((s) => s.requiredTools);
-  const declared = agent.tools ?? [];
-  const merged = Array.from(/* @__PURE__ */ new Set([...declared, ...skillTools]));
-  const globalEnabled = aiConfig?.enabledTools;
-  if (globalEnabled && globalEnabled.length > 0) {
-    return merged.filter((t) => globalEnabled.includes(t));
-  }
-  return merged;
-}
-function getToolDescriptions(toolNames, registry3) {
-  const lines = ["AVAILABLE TOOLS (use ONLY these exact names):"];
-  for (const name of toolNames) {
-    const tool = registry3.get(name);
-    if (!tool)
-      continue;
-    let paramList;
-    if (Array.isArray(tool.parameters)) {
-      paramList = tool.parameters.map((p3) => `${p3.name}:${p3.type}`).join(", ");
-    } else {
-      const obj = tool.parameters;
-      paramList = Object.entries(obj.properties ?? {}).map(([k, v]) => `${k}:${v.type ?? "any"}`).join(", ");
-    }
-    lines.push(`- ${name}: ${tool.description} \u2014 args { ${paramList} }`);
-  }
-  return lines.join("\n");
-}
-function buildSystemPrompt(agent, options) {
-  const { tools, toolNames, aiConfig, workspaceContext, ragContext } = 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 customModulesRaw = aiConfig?.customPromptModules ?? [];
-  const customTypes = new Set(customModulesRaw.map((m) => m.type));
-  const baseNotOverridden = baseModules.filter((m) => !customTypes.has(m.type));
-  const customModules = customModulesRaw.map((m) => ({
-    ...m,
-    priority: 1e3 + m.priority
-  }));
-  const allModules = [...baseNotOverridden, ...customModules].sort((a, b) => a.priority - b.priority);
-  const parts = [];
-  for (const mod of allModules) {
-    parts.push(mod.content);
-  }
-  if (agent.systemPrompt && agent.systemPrompt.trim()) {
-    parts.push(`# Your Role
+## 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.
 
-${agent.systemPrompt}`);
-  }
-  if (skills.length > 0) {
-    parts.push(`# Active Skills
+## 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.
 
-` + skills.map((s) => `## ${s.name}
-${s.systemPromptFragment}`).join("\n\n"));
-  }
-  const toolBlock = getToolDescriptions(toolNames, registry3);
-  if (toolNames.length > 0) {
-    parts.push(`# Tools
+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}
 
-${toolBlock}`);
-  }
-  if (workspaceContext && workspaceContext.trim()) {
-    parts.push(`# Current Workspace State
+## 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\`):
 
-${workspaceContext}`);
-  }
-  if (ragContext && ragContext.trim()) {
-    parts.push(`# Retrieved Knowledge (RAG)
+\`\`\`
+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\`
+})
+\`\`\`
 
-${ragContext}`);
-  }
-  return parts.join("\n\n---\n\n");
-}
-var init_systemPromptBuilder = __esm({
-  "packages/core/dist/agents/systemPromptBuilder.js"() {
-    "use strict";
-    init_promptModules();
-    init_skills();
+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.
+        tools: ["read_file", "write_file", "edit_file", "bash", "list_files"],
+        skills: ["vault-manager", "project-planner", "idea-synthesizer"]
+      }
+    ];
+    UnknownMemberError = class extends Error {
+      unknownId;
+      availableIds;
+      constructor(unknownId, availableIds) {
+        super(`Unknown member id for swap: "${unknownId}". Available: ${availableIds.join(", ") || "(none)"}.`);
+        this.name = "UnknownMemberError";
+        this.unknownId = unknownId;
+        this.availableIds = availableIds;
+      }
+    };
   }
 });
 
@@ -25242,6 +25339,7 @@ __export(council_exports, {
   NON_RETRY_AGENTS: () => NON_RETRY_AGENTS,
   OUTPUT_QUALITY_DIRECTIVE: () => OUTPUT_QUALITY_DIRECTIVE,
   PROMPT_MODULES: () => PROMPT_MODULES,
+  SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
   STRUCTURED_REASONING_DIRECTIVE: () => STRUCTURED_REASONING_DIRECTIVE,
   TIER_RANK: () => TIER_RANK,
   TOOL_USE_PROTOCOL_DIRECTIVE: () => TOOL_USE_PROTOCOL_DIRECTIVE,
@@ -26761,21 +26859,6 @@ var init_toolRegistry2 = __esm({
   }
 });
 
-// src/cli/utils/cmdline.ts
-function quoteCmdArg(arg) {
-  if (arg === "") return '""';
-  if (!/[\s"^&|<>()%!]/.test(arg)) return arg;
-  return `"${arg.replace(/"/g, '""')}"`;
-}
-function buildCmdLine(command, args) {
-  return [command, ...args].map(quoteCmdArg).join(" ");
-}
-var init_cmdline = __esm({
-  "src/cli/utils/cmdline.ts"() {
-    "use strict";
-  }
-});
-
 // src/cli/updater.ts
 var updater_exports = {};
 __export(updater_exports, {
@@ -27728,12 +27811,15 @@ async function runProjectSmoke(projectRoot, timeoutMs = DEFAULT_TIMEOUT_MS) {
     return { ran: false, reason: "no typecheck/test/build script (skipped)" };
   }
   return await new Promise((resolveRun) => {
-    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-    const child = spawn6(npmCmd, ["run", script], {
+    const child = process.platform === "win32" ? spawn6(buildCmdLine("npm.cmd", ["run", script]), {
       cwd: projectRoot,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env,
-      shell: process.platform === "win32"
+      shell: true
+    }) : spawn6("npm", ["run", script], {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
     });
     let stdout = "";
     let stderr = "";
@@ -27789,6 +27875,7 @@ var SMOKE_SCRIPT_PRIORITY, DEFAULT_TIMEOUT_MS;
 var init_projectSmoke = __esm({
   "src/cli/workspace/projectSmoke.ts"() {
     "use strict";
+    init_cmdline();
     SMOKE_SCRIPT_PRIORITY = ["typecheck", "test", "build"];
     DEFAULT_TIMEOUT_MS = 12e4;
   }
@@ -28985,9 +29072,13 @@ function detectLocalBin(bin) {
 function detectGlobalBin(bin) {
   return () => {
     try {
-      const res = spawnSync3(bin, ["--version"], {
+      const args = ["--version"];
+      const res = process.platform === "win32" ? spawnSync3(buildCmdLine(bin, args), {
+        stdio: ["ignore", "pipe", "ignore"],
+        shell: true,
+        timeout: 4e3
+      }) : spawnSync3(bin, args, {
         stdio: ["ignore", "pipe", "ignore"],
-        shell: process.platform === "win32",
         timeout: 4e3
       });
       return Promise.resolve(res.status === 0 || res.stdout != null && res.stdout.toString().trim().length > 0 && res.error === void 0);
@@ -29036,6 +29127,7 @@ var PLUGINS;
 var init_registry2 = __esm({
   "src/cli/plugins/registry.ts"() {
     "use strict";
+    init_cmdline();
     init_engine();
     init_driver();
     init_engine();
@@ -32956,6 +33048,7 @@ async function resolveFailoverStream(options) {
 init_shellResolver();
 init_keyStore();
 init_toolRegistry();
+init_skills2();
 
 // src/cli/hooks/messageHelpers.ts
 function appendSystem(setMessages, content, ts = Date.now()) {
@@ -33161,17 +33254,14 @@ function useChatTurn(params) {
           }
         } catch {
         }
-        const toolList = toolRegistry.toOpenAITools().map((t) => `- ${t.function.name}: ${t.function.description}`).join("\n");
+        const openAiTools = toolRegistry.toOpenAITools();
+        const toolListNames = openAiTools.map((t) => t.function.name);
+        const toolList = openAiTools.map((t) => `- ${t.function.name}: ${t.function.description}`).join("\n");
         const resolvedShell = resolveShell();
         const isWindows = process.platform === "win32";
         const shellGuidance = resolvedShell.isBash ? `The bash tool runs commands via Git Bash / MSYS2 (${resolvedShell.shell}). Write POSIX commands: ls, grep, $VAR, &&, /c/Users/... all work.` : isWindows ? `The bash tool runs commands via cmd.exe (Git Bash not found). Write Windows-native commands: use dir (not ls), %VAR% (not $VAR), avoid POSIX-only syntax.` : `The bash tool runs commands via /bin/sh.`;
         const nonInteractiveGuidance = "The shell is NON-INTERACTIVE (stdin closed): commands that prompt for input fail immediately. Always pass non-interactive flags (--yes, -y, --template, --force). If a scaffolder still insists on prompting (e.g. `npm create vite` in a non-empty directory), do NOT retry it \u2014 scaffold into a fresh empty subdirectory and move the files, or write package.json/configs/sources yourself with write_file, then run `npm install`.";
-        const systemPrompt = [
-          "You are Zelari Code, an interactive AI coding agent operating directly in the user's terminal.",
-          "",
-          "You ARE connected to this machine and have real tools to read, modify, and explore the codebase.",
-          "Never claim you lack filesystem or shell access \u2014 you have it. Use your tools instead of asking the user to paste file contents.",
-          "",
+        const shellContextBlock = [
           "# Platform & Shell",
           `platform: ${process.platform}`,
           `shell: ${resolvedShell.via}`,
@@ -33181,24 +33271,48 @@ function useChatTurn(params) {
           "# Working Directory",
           `You are running in: ${cwd}`,
           "All relative file paths are resolved against this directory. Always work with real files here.",
-          "",
-          "# Available Tools",
-          "You can call these tools. Use them to take action and gather information autonomously:",
-          toolList,
-          ...workspaceSummary ? ["", workspaceSummary] : [],
-          ...zelariReadHint ? ["", zelariReadHint] : [],
-          ...planSummary ? ["", planSummary] : [],
-          "",
-          "# Guidelines",
-          "- When the user asks you to write code, debug, or explore, be proactive: list files (list_files, or bash: ls/dir) and read key files (read_file) to understand the project instead of asking the user to paste file contents.",
-          "- If a command fails or is cancelled, do NOT retry variants of the same command: diagnose why (read the hint in the result if present) and take a DIFFERENT approach (e.g. create the files yourself with write_file).",
-          "- After a tool result, CONTINUE your answer from where you left off. NEVER restate or re-print text you already wrote earlier in this turn.",
-          `- Only invoke tools when they are necessary to answer the user's prompt. If the user is just saying hello or greeting them (e.g., "ciao", "hello"), simply greet them back and ask how you can help, without running any commands or tools.`,
-          "- When you finish a task, briefly summarize what you did.",
           ...planSummary ? [
+            "",
+            "# Plan Tracking",
             '- Plan tasks: when you START working on a plan task call updateTask {taskId, status: "in_progress"}; when it is complete and verified call updateTask {taskId, status: "done"}. NEVER edit .zelari/plan.json by hand.'
           ] : []
         ].join("\n");
+        const singleAgentRole = {
+          id: "single",
+          name: "Zelari Code",
+          codename: "zelari",
+          role: "interactive coding agent",
+          color: "#00d9a3",
+          avatar: "\u25C6",
+          tools: toolListNames,
+          systemPrompt: shellContextBlock
+        };
+        const workspaceContext = [workspaceSummary, zelariReadHint].filter(Boolean).join("\n\n");
+        let systemPrompt;
+        try {
+          systemPrompt = buildSystemPrompt(singleAgentRole, {
+            tools: getAllTools(),
+            toolNames: toolListNames,
+            aiConfig: {
+              enabledSkills: [],
+              enabledTools: toolListNames,
+              customPromptModules: [SINGLE_AGENT_IDENTITY_MODULE],
+              agentSkillConfigs: []
+            },
+            workspaceContext: workspaceContext || void 0,
+            ragContext: planSummary || void 0
+          });
+        } catch {
+          systemPrompt = [
+            SINGLE_AGENT_IDENTITY_MODULE.content,
+            shellContextBlock,
+            "# Available Tools",
+            "You can call these tools. Use them to take action and gather information autonomously:",
+            toolList,
+            ...workspaceContext ? ["", workspaceContext] : [],
+            ...planSummary ? ["", planSummary] : []
+          ].join("\n");
+        }
         const maxToolCallsPerTurn = (() => {
           const raw = process.env.ZELARI_MAX_TOOL_CALLS;
           const n = raw ? Number.parseInt(raw, 10) : 25;
@@ -33206,8 +33320,8 @@ function useChatTurn(params) {
         })();
         const maxToolLoopIterations = (() => {
           const raw = process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS;
-          const n = raw ? Number.parseInt(raw, 10) : 30;
-          return Number.isFinite(n) && n > 0 ? n : 30;
+          const n = raw ? Number.parseInt(raw, 10) : 90;
+          return Number.isFinite(n) && n > 0 ? n : 90;
         })();
         const harness2 = new AgentHarness({
           model: envConfig.model,