@zelari/core 0.7.9

package/dist/agents/promptModules.js

@@ -0,0 +1,139 @@
+import { STRUCTURED_REASONING_DIRECTIVE, TOOL_USE_PROTOCOL_DIRECTIVE, OUTPUT_QUALITY_DIRECTIVE, COLLABORATION_DIRECTIVE, } from './councilDirectives.js';
+/**
+ * Base system prompt modules for AnathemaBrain.
+ *
+ * Each module is a self-contained fragment that gets assembled (by priority)
+ * into the final system prompt for an agent. These are inspired by the
+ * enterprise-grade System.md directive structure but adapted for
+ * AnathemaBrain's knowledge-management context and the MiniMax/GLM providers.
+ *
+ * The four `councilDirectives` modules (structured-reasoning, tool-use
+ * protocol, output-quality, collaboration) are distilled from System.md and
+ * injected at high priority so every agent receives the operational
+ * methodology. Total additive cost is ~2KB per agent.
+ */
+export const 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 — 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 — 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 — 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 — a target platform, a scope boundary, a binary design choice with real trade-offs, or a constraint you cannot safely assume — 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.`,
+    },
+];
+/** Get a module by type. */
+export function getPromptModule(type) {
+    return PROMPT_MODULES.find((m) => m.type === type);
+}
+/** All base modules sorted by priority (ascending). */
+export function getBasePromptModules() {
+    return [...PROMPT_MODULES].sort((a, b) => a.priority - b.priority);
+}
+//# sourceMappingURL=promptModules.js.map

package/dist/agents/promptModules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promptModules.js","sourceRoot":"","sources":["../../src/agents/promptModules.ts"],"names":[],"mappings":"AACA,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,cAAc,GAAyB;IAClD;QACE,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,UAAU;QACjB,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;0MAI6L;KACvM;IACD,4EAA4E;IAC5E,oEAAoE;IACpE,sDAAsD;IACtD,8BAA8B;IAC9B,uBAAuB;IACvB,2BAA2B;IAC3B,wBAAwB;IACxB;QACE,IAAI,EAAE,gBAAgB;QACtB,KAAK,EAAE,UAAU;QACjB,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;;;;+EAOkE;KAC5E;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,KAAK,EAAE,QAAQ;QACf,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;;;wGAM2F;KACrG;IACD;QACE,IAAI,EAAE,uBAAuB;QAC7B,KAAK,EAAE,iBAAiB;QACxB,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;;;;2FAO8E;KACxF;IACD;QACE,IAAI,EAAE,mBAAmB;QACzB,KAAK,EAAE,eAAe;QACtB,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;;;;;;;;;;gEAamD;KAC7D;IACD;QACE,IAAI,EAAE,uBAAuB;QAC7B,KAAK,EAAE,YAAY;QACnB,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;;;;;;;;;;OAaN;KACJ;IACD;QACE,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,wBAAwB;QAC/B,QAAQ,EAAE,EAAE;QACZ,OAAO,EAAE;;;;;;;;;;;;;;;mGAesF;KAChG;CACF,CAAC;AAEF,4BAA4B;AAC5B,MAAM,UAAU,eAAe,CAAC,IAAgC;IAC9D,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AACrD,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,oBAAoB;IAClC,OAAO,CAAC,GAAG,cAAc,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;AACrE,CAAC"}

package/dist/agents/roles.d.ts

@@ -0,0 +1,40 @@
+import type { AgentRole } from '../types/index.js';
+export declare const AGENT_ROLES: AgentRole[];
+export declare function getAgent(id: string): AgentRole | undefined;
+export declare function getCouncilAgents(size: number): AgentRole[];
+/**
+ * Typed error thrown by `swapMembers` when a swap target id does not
+ * correspond to any known member of the source roster (Task I.3, v3-I).
+ * Carries the unknown id and a list of available ids for diagnostics.
+ */
+export declare class UnknownMemberError extends Error {
+    readonly unknownId: string;
+    readonly availableIds: string[];
+    constructor(unknownId: string, availableIds: string[]);
+}
+/**
+ * Pure helper: remap members in a roster by id.
+ *
+ *   swapMembers(
+ *     [{id: 'charont', ...}, {id: 'minos', ...}],
+ *     { sisyphus: 'nettun' }  // or just { sisyphus: 'nettun' }
+ *   )
+ *   // => [{id: 'nettun', ...}, {id: 'minos', ...}]
+ *
+ * Behavior (Task I.3, v3-I):
+ *   - For each member in `roles`, if `swap[member.id]` is defined, replace
+ *     it with the agent whose id equals `swap[member.id]` from the
+ *     built-in `AGENT_ROLES` registry.
+ *   - Members without a swap mapping pass through unchanged.
+ *   - If `swap[memberId]` references an id that is not in `AGENT_ROLES`,
+ *     throw `UnknownMemberError`. (Defensive: a typo would otherwise
+ *     silently produce a member with the same id but no resolved target.)
+ *   - Pure function: no I/O, deterministic. Returns a NEW array.
+ *   - Self-mapping is a no-op: `swap[memberId] === memberId` keeps the
+ *     original AgentRole object.
+ *
+ * @param roles  - source roster (typically the output of `getCouncilAgents`).
+ * @param swap   - `{ fromId: toId }` remapping table. Empty object = no-op.
+ */
+export declare function swapMembers(roles: AgentRole[], swap: Record<string, string>): AgentRole[];
+//# sourceMappingURL=roles.d.ts.map

package/dist/agents/roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/agents/roles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAqBnD,eAAO,MAAM,WAAW,EAAE,SAAS,EAiQlC,CAAC;AAEF,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,CAG1D;AAED;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;gBAEpB,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE;CAQtD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,EAAE,EAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,SAAS,EAAE,CAiCb"}

package/dist/agents/roles.js

@@ -0,0 +1,352 @@
+/**
+ * Shared block documenting the clarifying-question protocol. Appended to every
+ * agent's role prompt so the convention is uniform across the council.
+ */
+const CLARIFICATION_PROTOCOL = `
+
+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.`;
+export const AGENT_ROLES = [
+    {
+        id: 'charont',
+        name: 'Caronte',
+        codename: 'Orchestrator',
+        role: 'Council Director',
+        color: '#3b82f6',
+        avatar: 'L',
+        systemPrompt: `You are Caronte, the Council Director and Orchestrator — 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 — 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 — under 150 words total.${CLARIFICATION_PROTOCOL}`,
+        // v0.7.2: coding-oriented tools (read/search/explore) instead of planner/vault.
+        tools: ['list_files', 'read_file', 'grep_content'],
+        skills: ['project-planner', 'research-analyst'],
+    },
+    {
+        id: 'nettun',
+        name: 'Nettuno',
+        codename: 'Planner',
+        role: 'Project Planner',
+        color: '#10b981',
+        avatar: 'N',
+        systemPrompt: `You are Nettuno, the Project Planner — 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 — 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.
+
+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
+
+## 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_PROTOCOL}
+
+## 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 — prose does not count, and the post-run check will flag your run if the plan is missing.
+
+PREFERRED — 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 — the QA scenario proves the task is verifiable.
+
+FALLBACK — only if you cannot batch, use the itemized tools: \`createPhase\` once per phase; each createPhase response returns the new phase id — 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.`,
+        // 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 — 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 — do not repeat — insights from earlier agents.
+
+## Operating principles
+- Diverge before you converge: quantity first, judgment second.
+- Bold but grounded — 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_PROTOCOL}
+
+## 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\` — 2-3 personas (give them names, demographics, goals), journey table (stage → action → touchpoint → emotion), pain points per stage. This is a customer journey deliverable.
+- \`information-architecture\` — site map tree (root → section → page), navigation model (primary nav, breadcrumbs, footer), URL patterns. This is an information architecture deliverable.
+- \`design-tokens\` — 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 — 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 — 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 — don't re-derive what they already produced.
+- Keep the graph comprehensible: prune redundant or duplicate nodes.
+
+## Output format
+Describe the proposed structure (root → branches → leaves) in text. Stay under 200 words.${CLARIFICATION_PROTOCOL}
+
+## 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 — 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 — 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 — 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_PROTOCOL}
+
+## 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 — 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 — 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 — complete, not summarized. For code tasks, USE your file/shell tools to create and verify the actual artifacts 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 it via write_file/edit_file/bash — do not just describe what should be done. Then summarize what you changed.
+- 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.
+
+Use the tools available to you (read_file, write_file, edit_file, bash, list_files) directly as tool calls — the harness handles execution.${CLARIFICATION_PROTOCOL}
+
+## 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\` — 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'],
+    },
+];
+export function getAgent(id) {
+    return AGENT_ROLES.find((a) => a.id === id);
+}
+export function getCouncilAgents(size) {
+    const core = ['charont', 'nettun', 'geryon', 'pluton', 'minos', 'lucifer'];
+    return core.slice(0, Math.min(size, 6)).map((id) => getAgent(id));
+}
+/**
+ * Typed error thrown by `swapMembers` when a swap target id does not
+ * correspond to any known member of the source roster (Task I.3, v3-I).
+ * Carries the unknown id and a list of available ids for diagnostics.
+ */
+export class UnknownMemberError 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;
+    }
+}
+/**
+ * Pure helper: remap members in a roster by id.
+ *
+ *   swapMembers(
+ *     [{id: 'charont', ...}, {id: 'minos', ...}],
+ *     { sisyphus: 'nettun' }  // or just { sisyphus: 'nettun' }
+ *   )
+ *   // => [{id: 'nettun', ...}, {id: 'minos', ...}]
+ *
+ * Behavior (Task I.3, v3-I):
+ *   - For each member in `roles`, if `swap[member.id]` is defined, replace
+ *     it with the agent whose id equals `swap[member.id]` from the
+ *     built-in `AGENT_ROLES` registry.
+ *   - Members without a swap mapping pass through unchanged.
+ *   - If `swap[memberId]` references an id that is not in `AGENT_ROLES`,
+ *     throw `UnknownMemberError`. (Defensive: a typo would otherwise
+ *     silently produce a member with the same id but no resolved target.)
+ *   - Pure function: no I/O, deterministic. Returns a NEW array.
+ *   - Self-mapping is a no-op: `swap[memberId] === memberId` keeps the
+ *     original AgentRole object.
+ *
+ * @param roles  - source roster (typically the output of `getCouncilAgents`).
+ * @param swap   - `{ fromId: toId }` remapping table. Empty object = no-op.
+ */
+export function swapMembers(roles, swap) {
+    const swapEntries = Object.entries(swap);
+    if (swapEntries.length === 0)
+        return roles.slice();
+    // Pre-resolve targets once for O(1) lookup + early unknown-id detection.
+    const targets = new Map();
+    for (const [fromId, toId] of swapEntries) {
+        if (!targets.has(toId)) {
+            const target = getAgent(toId);
+            if (!target) {
+                throw new UnknownMemberError(toId, AGENT_ROLES.map((r) => r.id));
+            }
+            targets.set(toId, target);
+        }
+        // Validate `fromId` is in the source roster (defensive — a typo in
+        // `fromId` would otherwise be silently ignored).
+        if (!roles.some((r) => r.id === fromId)) {
+            throw new UnknownMemberError(fromId, roles.map((r) => r.id));
+        }
+    }
+    return roles.map((role) => {
+        const toId = swap[role.id];
+        if (toId === undefined)
+            return role;
+        if (toId === role.id)
+            return role; // self-mapping → no-op
+        return targets.get(toId);
+    });
+}
+//# sourceMappingURL=roles.js.map

package/dist/agents/roles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roles.js","sourceRoot":"","sources":["../../src/agents/roles.ts"],"names":[],"mappings":"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"}

package/dist/agents/skills/builtin/debugging.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=debugging.d.ts.map

package/dist/agents/skills/builtin/debugging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugging.d.ts","sourceRoot":"","sources":["../../../../src/agents/skills/builtin/debugging.ts"],"names":[],"mappings":""}