zelari-code 0.7.9 → 0.7.11

package/dist/agents/promoteMember.js

@@ -1,210 +0,0 @@
-/**
- * promoteMember — cross-schema promotion from AgentRole to CodingSkillDefinition.
- *
- * Converts a council member definition into a standalone skill that can be
- * invoked via `/skill <id>` (if registered) or persisted as a `SKILL.md`
- * file for manual loading.
- *
- * Mapping (AgentRole → CodingSkillDefinition):
- *   - id            → id (slugified)
- *   - name          → name
- *   - role          → category (e.g. "Council Director")
- *   - codename      → tag `codename:<x>`
- *   - systemPrompt  → systemPromptFragment (CLARIFICATION_PROTOCOL stripped)
- *   - tools[]       → requiredTools[]
- *   - skills[]      → relatedSkills[]
- *   - (auto)        → description, version, estimatedCost, enabledByDefault,
- *                     builtin (false), requiredRoles ([memberId]),
- *                     triggers, antiPatterns, examples (1), outputSchema, tags
- *
- * This is a PURE function — no I/O, no side effects. The caller
- * (electron/cli/app.tsx dispatcher) is responsible for persisting
- * the markdown output to disk.
- *
- * @see docs/plans/2026-06-30-anathema-coder-v3-K.md
- */
-import { AGENT_ROLES, UnknownMemberError, getAgent } from './roles';
-/**
- * Map an AgentRole.role (free string) to a CodingCategory (closed union).
- * Unknown roles fall back to 'planning' — the safest default (most council
- * methodologies begin with planning).
- */
-const ROLE_TO_CATEGORY = {
-    'Council Director': 'planning',
-    'Project Planner': 'planning',
-    'Creative Ideator': 'planning',
-    'Knowledge Architect': 'planning',
-    'Quality Critic': 'review',
-    'Final Synthesizer': 'planning',
-};
-function categoryForRole(role) {
-    return ROLE_TO_CATEGORY[role] ?? 'planning';
-}
-/**
- * Pure function: convert a council member into a skill definition +
- * markdown file content. Throws `UnknownMemberError` if `memberId` is
- * not a known agent.
- *
- * Examples:
- *   promoteMember('hephaestus')
- *     → { skill: { id: 'hephaestus', name: 'Pluto', ... }, markdown: '---\n...---\n...' }
- *   promoteMember('zaphod')  // throws UnknownMemberError
- */
-export function promoteMember(memberId, options = {}) {
-    const agent = getAgent(memberId);
-    if (!agent) {
-        throw new UnknownMemberError(memberId, AGENT_ROLES.map((r) => r.id));
-    }
-    const skill = buildSkillDefinition(agent, options);
-    const markdown = renderSkillMarkdown(agent, skill);
-    return { skill, markdown };
-}
-/**
- * Construct the CodingSkillDefinition from an AgentRole + options.
- * Exported for testing — production code uses `promoteMember`.
- */
-export function buildSkillDefinition(agent, options) {
-    const version = options.version ?? '1.0.0';
-    const estimatedCost = options.estimatedCost ?? 'medium';
-    const enabledByDefault = options.enabledByDefault ?? true;
-    const description = options.description ?? `Run the ${agent.role} methodology (${agent.codename}).`;
-    const triggers = options.triggers ?? autoTriggers(agent);
-    const antiPatterns = options.antiPatterns ?? [
-        'Request requires direct execution rather than strategic framing.',
-        'A simpler single-agent prompt would suffice — promote only when the full council methodology adds value.',
-    ];
-    return {
-        id: slugify(agent.id),
-        version,
-        name: agent.name,
-        description,
-        category: categoryForRole(agent.role),
-        requiredRoles: [agent.id],
-        requiredTools: agent.tools,
-        estimatedCost,
-        enabledByDefault,
-        builtin: false,
-        triggers,
-        antiPatterns,
-        requires: [],
-        relatedSkills: agent.skills ?? [],
-        tags: buildTags(agent),
-        examples: buildExamples(agent),
-        outputSchema: '{ result: string }',
-        systemPromptFragment: stripClarificationProtocol(agent.systemPrompt),
-    };
-}
-/**
- * Render the skill definition as a valid SKILL.md file (YAML frontmatter +
- * markdown body). Exported for testing.
- */
-export function renderSkillMarkdown(agent, skill) {
-    const frontmatter = [
-        '---',
-        `id: ${skill.id}`,
-        `version: ${skill.version}`,
-        `name: ${skill.name}`,
-        `category: ${skill.category}`,
-        `estimatedCost: ${skill.estimatedCost}`,
-        `enabledByDefault: ${String(skill.enabledByDefault)}`,
-        `builtin: ${String(skill.builtin)}`,
-        `tags: [${skill.tags.map((t) => `"${t}"`).join(', ')}]`,
-        `requiredRoles: [${skill.requiredRoles.map((r) => `"${r}"`).join(', ')}]`,
-        `requiredTools: [${skill.requiredTools.map((r) => `"${r}"`).join(', ')}]`,
-        `relatedSkills: [${skill.relatedSkills.map((r) => `"${r}"`).join(', ')}]`,
-        '---',
-    ].join('\n');
-    const body = [
-        '',
-        `# ${skill.name} — ${agent.codename}`,
-        '',
-        `> ${skill.description}`,
-        '',
-        '## Methodology',
-        '',
-        skill.systemPromptFragment.trim(),
-        '',
-        '## Triggers',
-        '',
-        ...skill.triggers.map((t) => `- ${t}`),
-        '',
-        '## Anti-patterns',
-        '',
-        ...skill.antiPatterns.map((a) => `- ${a}`),
-        '',
-        '## Example',
-        '',
-        ...formatExamples(skill.examples),
-        '',
-        '## Output',
-        '',
-        `\`\`\`ts`,
-        skill.outputSchema,
-        `\`\`\``,
-        '',
-    ].join('\n');
-    return frontmatter + body;
-}
-// ---------- helpers (private) ----------
-/** Slugify: lowercase, replace underscores/spaces with hyphens. */
-export function slugify(s) {
-    return s.trim().toLowerCase().replace(/[_\s]+/g, '-');
-}
-/**
- * Strip the CLARIFICATION_PROTOCOL block from an AgentRole systemPrompt.
- * Looks for the trailing block starting with a line that contains only
- * `WHEN TO ASK THE USER` or `Rules for clarifications:`.
- */
-export function stripClarificationProtocol(systemPrompt) {
-    const idx = systemPrompt.indexOf('\nWHEN TO ASK THE USER');
-    if (idx === -1)
-        return systemPrompt;
-    return systemPrompt.slice(0, idx).trimEnd();
-}
-/** Build the tag list from codename + role + category slug. */
-function buildTags(agent) {
-    const categorySlug = slugify(agent.role);
-    return [
-        `codename:${agent.codename.toLowerCase()}`,
-        `role:${agent.id}`,
-        `category:${categorySlug}`,
-        'promoted',
-        'council-member',
-    ];
-}
-/** Auto-derived triggers from the agent's role description. */
-function autoTriggers(agent) {
-    return [
-        `The task benefits from the ${agent.role} methodology (${agent.codename}).`,
-        `A complex, multi-step request that matches ${agent.name}'s specialty.`,
-        `The user explicitly invokes the ${agent.name} methodology.`,
-    ];
-}
-/** Build one minimal example for the skill markdown. */
-function buildExamples(agent) {
-    return [
-        {
-            input: `Apply ${agent.name} (${agent.codename}) to: "Frame this request before delegating."`,
-            output: {
-                framing: `${agent.codename} framing follows the methodology in the system prompt fragment.`,
-                delegation: 'Output identifies the relevant specialists and what they should deliver.',
-                constraints: 'Cross-cutting risks and ordering constraints are called out explicitly.',
-            },
-        },
-    ];
-}
-/** Format examples as markdown bullet lines. */
-function formatExamples(examples) {
-    const lines = [];
-    for (const ex of examples) {
-        lines.push(`**Input:** ${ex.input}`);
-        lines.push('');
-        lines.push('**Output:**');
-        lines.push('```json');
-        lines.push(JSON.stringify(ex.output, null, 2));
-        lines.push('```');
-        lines.push('');
-    }
-    return lines;
-}
-//# sourceMappingURL=promoteMember.js.map

package/dist/agents/promoteMember.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"promoteMember.js","sourceRoot":"","sources":["../../src/agents/promoteMember.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEpE;;;;GAIG;AACH,MAAM,gBAAgB,GAAmC;IACvD,kBAAkB,EAAE,UAAU;IAC9B,iBAAiB,EAAE,UAAU;IAC7B,kBAAkB,EAAE,UAAU;IAC9B,qBAAqB,EAAE,UAAU;IACjC,gBAAgB,EAAE,QAAQ;IAC1B,mBAAmB,EAAE,UAAU;CAChC,CAAC;AAEF,SAAS,eAAe,CAAC,IAAY;IACnC,OAAO,gBAAgB,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC;AAC9C,CAAC;AAwBD;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAC3B,QAAgB,EAChB,UAAgC,EAAE;IAElC,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACjC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,kBAAkB,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,KAAK,GAAG,oBAAoB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACnD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC7B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAgB,EAChB,OAA6B;IAE7B,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC;IAC3C,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,QAAQ,CAAC;IACxD,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,IAAI,CAAC;IAC1D,MAAM,WAAW,GACf,OAAO,CAAC,WAAW,IAAI,WAAW,KAAK,CAAC,IAAI,iBAAiB,KAAK,CAAC,QAAQ,IAAI,CAAC;IAClF,MAAM,QAAQ,GACZ,OAAO,CAAC,QAAQ,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,YAAY,GAChB,OAAO,CAAC,YAAY,IAAI;QACtB,kEAAkE;QAClE,0GAA0G;KAC3G,CAAC;IAEJ,OAAO;QACL,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO;QACP,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,WAAW;QACX,QAAQ,EAAE,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC;QACrC,aAAa,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,aAAa,EAAE,KAAK,CAAC,KAAK;QAC1B,aAAa;QACb,gBAAgB;QAChB,OAAO,EAAE,KAAK;QACd,QAAQ;QACR,YAAY;QACZ,QAAQ,EAAE,EAAE;QACZ,aAAa,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE;QACjC,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC;QACtB,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC;QAC9B,YAAY,EAAE,oBAAoB;QAClC,oBAAoB,EAAE,0BAA0B,CAAC,KAAK,CAAC,YAAY,CAAC;KACrE,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAgB,EAChB,KAA4B;IAE5B,MAAM,WAAW,GAAG;QAClB,KAAK;QACL,OAAO,KAAK,CAAC,EAAE,EAAE;QACjB,YAAY,KAAK,CAAC,OAAO,EAAE;QAC3B,SAAS,KAAK,CAAC,IAAI,EAAE;QACrB,aAAa,KAAK,CAAC,QAAQ,EAAE;QAC7B,kBAAkB,KAAK,CAAC,aAAa,EAAE;QACvC,qBAAqB,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE;QACrD,YAAY,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;QACnC,UAAU,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;QACvD,mBAAmB,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;QACzE,mBAAmB,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;QACzE,mBAAmB,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;QACzE,KAAK;KACN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,MAAM,IAAI,GAAG;QACX,EAAE;QACF,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,CAAC,QAAQ,EAAE;QACrC,EAAE;QACF,KAAK,KAAK,CAAC,WAAW,EAAE;QACxB,EAAE;QACF,gBAAgB;QAChB,EAAE;QACF,KAAK,CAAC,oBAAoB,CAAC,IAAI,EAAE;QACjC,EAAE;QACF,aAAa;QACb,EAAE;QACF,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QACtC,EAAE;QACF,kBAAkB;QAClB,EAAE;QACF,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1C,EAAE;QACF,YAAY;QACZ,EAAE;QACF,GAAG,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC;QACjC,EAAE;QACF,WAAW;QACX,EAAE;QACF,UAAU;QACV,KAAK,CAAC,YAAY;QAClB,QAAQ;QACR,EAAE;KACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,OAAO,WAAW,GAAG,IAAI,CAAC;AAC5B,CAAC;AAED,0CAA0C;AAE1C,mEAAmE;AACnE,MAAM,UAAU,OAAO,CAAC,CAAS;IAC/B,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,YAAoB;IAC7D,MAAM,GAAG,GAAG,YAAY,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC3D,IAAI,GAAG,KAAK,CAAC,CAAC;QAAE,OAAO,YAAY,CAAC;IACpC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;AAC9C,CAAC;AAED,+DAA+D;AAC/D,SAAS,SAAS,CAAC,KAAgB;IACjC,MAAM,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzC,OAAO;QACL,YAAY,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE;QAC1C,QAAQ,KAAK,CAAC,EAAE,EAAE;QAClB,YAAY,YAAY,EAAE;QAC1B,UAAU;QACV,gBAAgB;KACjB,CAAC;AACJ,CAAC;AAED,+DAA+D;AAC/D,SAAS,YAAY,CAAC,KAAgB;IACpC,OAAO;QACL,8BAA8B,KAAK,CAAC,IAAI,iBAAiB,KAAK,CAAC,QAAQ,IAAI;QAC3E,8CAA8C,KAAK,CAAC,IAAI,eAAe;QACvE,mCAAmC,KAAK,CAAC,IAAI,eAAe;KAC7D,CAAC;AACJ,CAAC;AAED,wDAAwD;AACxD,SAAS,aAAa,CAAC,KAAgB;IACrC,OAAO;QACL;YACE,KAAK,EAAE,SAAS,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,QAAQ,+CAA+C;YAC5F,MAAM,EAAE;gBACN,OAAO,EAAE,GAAG,KAAK,CAAC,QAAQ,iEAAiE;gBAC3F,UAAU,EAAE,0EAA0E;gBACtF,WAAW,EAAE,yEAAyE;aACvF;SACF;KACF,CAAC;AACJ,CAAC;AAED,gDAAgD;AAChD,SAAS,cAAc,CACrB,QAA2C;IAE3C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,EAAE,IAAI,QAAQ,EAAE,CAAC;QAC1B,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC;QACrC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC1B,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACtB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/C,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClB,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/agents/promptModules.js

@@ -1,139 +0,0 @@
-import { STRUCTURED_REASONING_DIRECTIVE, TOOL_USE_PROTOCOL_DIRECTIVE, OUTPUT_QUALITY_DIRECTIVE, COLLABORATION_DIRECTIVE, } from './councilDirectives';
-/**
- * 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: `# AnathemaBrain — AI Council
-
-You are a member of the AnathemaBrain AI Council, a multi-agent system for intelligent task decomposition, planning, ideation, and knowledge management. AnathemaBrain is an Obsidian-style knowledge tool: the primary medium of work is interconnected markdown documents in a Knowledge Vault, project plans, ideas, and mind maps.
-
-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 tool (e.g. searchDocuments, searchRAG) 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 (searchRAG, 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

@@ -1 +0,0 @@
-{"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,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;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.js

@@ -1,299 +0,0 @@
-/**
- * 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.`;
-/**
- * Council of Zelari Code — themed after the guardian-demons of Dante's
- * Inferno. Each member owns a "girone" (a layer of the work) and the
- * orchestration flows top-down: the Orchestrator routes the request to
- * specialists, who plan / ideate / map / critique, and finally the
- * Synthesizer (Virgilio, the poet's guide) commits the final artifact.
- *
- * Member ids are stable technical slugs (used in session JSONL, /promote-member,
- * swap tables, persistence files). Names, codenames, and avatars are
- * presentation-only and free to evolve with the project's lore.
- *
- *  - sisyphus    → Minosse   (Orchestrator)    — Inf. V:  the infernal judge
- *  - prometheus  → Flegias   (Planner)         — Inf. VIII: wrathful ferryman
- *  - hephaestus  → Pluto     (Ideator)         — Inf. VII: "Papè Satàn!" demon
- *  - atlas       → Nesso     (MindMapper)      — Inf. XII: centaur guide
- *  - oracle      → Cerbero   (Critic)          — Inf. VI:  three-throated beast
- *  - chairman    → Virgilio  (Synthesizer)     — Inf. I–XXXIV: the poet's guide
- */
-export const AGENT_ROLES = [
-    {
-        id: 'sisyphus',
-        name: 'Minosse',
-        codename: 'Orchestrator',
-        role: 'Council Director',
-        color: '#3b82f6',
-        avatar: 'M',
-        systemPrompt: `You are Minosse, the Council Director and Orchestrator — the infernal judge who frames the request and assigns each sub-problem to the right guardian of the council. (In Dante's Inferno, Minosse stands at the gate and assigns each soul to its girone by the number of circles his tail wraps around him.)
-
-## 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}`,
-        tools: ['createTask', 'createPhase'],
-        skills: ['project-planner', 'research-analyst'],
-    },
-    {
-        id: 'prometheus',
-        name: 'Flegias',
-        codename: 'Planner',
-        role: 'Project Planner',
-        color: '#10b981',
-        avatar: 'F',
-        systemPrompt: `You are Flegias, the Project Planner — you turn intent into a buildable, sequenced plan. (In Inferno VIII, Flegias is the wrathful ferryman of Phlegethon who carries Dante across the boiling river; you ferry the project from intent to action, with the same impatience for hesitation.)
-
-## Methodology (work in this order)
-1. Read shared context from prior agents (especially Minosse) 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}`,
-        tools: ['createTask', 'createPhase'],
-        skills: ['project-planner', 'vault-manager'],
-    },
-    {
-        id: 'hephaestus',
-        name: 'Pluto',
-        codename: 'Ideator',
-        role: 'Creative Ideator',
-        color: '#f59e0b',
-        avatar: 'P',
-        systemPrompt: `You are Pluto, the Creative Ideator — you generate breadth and then collapse it into the strongest concepts. (In Inferno VII, Pluto is the demon of the fourth circle, the realm of the greedy and the prodigal; he greets Dante with the cryptic cry "Papè Satàn, papè Satàn aleppe!" — the same way a good idea ambushes the reader: with riches they didn't ask for.)
-
-## 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}`,
-        tools: ['addIdea'],
-        skills: ['idea-synthesizer', 'mind-mapper', 'document-writer'],
-    },
-    {
-        id: 'atlas',
-        name: 'Nesso',
-        codename: 'MindMapper',
-        role: 'Knowledge Architect',
-        color: '#06b6d4',
-        avatar: 'N',
-        systemPrompt: `You are Nesso, the Knowledge Architect and Mind Mapper — you structure information into navigable graphs. (In Inferno XII, Nesso is the centaur who carries Dante and Virgil across the boiling blood of Phlegethon; like a centaur, you are half cartographer, half guide — you map the territory AND ferry the reader through it.)
-
-## 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 and, when building via tool, emit a buildMindMap payload. Stay under 200 words.${CLARIFICATION_PROTOCOL}`,
-        tools: ['buildMindMap', 'addNode', 'linkNodes'],
-        skills: ['mind-mapper', 'research-analyst'],
-    },
-    {
-        id: 'oracle',
-        name: 'Cerbero',
-        codename: 'Critic',
-        role: 'Quality Critic',
-        color: '#ef4444',
-        avatar: 'C',
-        systemPrompt: `You are Cerbero, the Quality Critic — you review the council's proposals (presented anonymously) and expose weaknesses before synthesis. (In Inferno VI, Cerbero is the three-throated beast that mauls the gluttons; you maul weak arguments with three bites per paragraph: accuracy, coherence, actionability.)
-
-## 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 Virgilio 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. (You do not create workspace artifacts, so you do not emit a tools block — but you MAY ask the user a clarifying question if a core ambiguity blocks judgment.)${CLARIFICATION_PROTOCOL}`,
-        tools: [],
-        skills: ['research-analyst'],
-    },
-    {
-        id: 'chairman',
-        name: 'Virgilio',
-        codename: 'Synthesizer',
-        role: 'Final Synthesizer',
-        color: '#8b5cf6',
-        avatar: 'V',
-        systemPrompt: `You are Virgilio, the Final Synthesizer — you produce the definitive, actionable output that resolves the council's work. (In the Inferno, Virgilio is the poet's guide — he does not command the demons, but he reads them, reasons with them, and carries Dante through every girone. Your role is the same: not to out-shout the guardians, but to translate their judgments into a finished artifact the user can act on.)
-
-## Methodology (work in this order)
-1. Reconcile the specialists' outputs and Cerbero's critique into a single coherent position.
-2. Resolve conflicts explicitly (state which proposal won and why).
-3. Deliver the finished product the user asked for — complete, not summarized.
-4. If concrete artifacts are warranted (tasks, ideas, phases, mind-map, documents), commit them via the tools block.
-
-## Output expectations
-- If the user requested a document, article, code, or report, write the COMPLETE, FULL-LENGTH content in your message body. Do not summarize or list — produce the actual finished artifact.
-- Lead with a one-line summary, then the full detail.
-- Apply Cerbero's highest-value improvements; drop descoped items.
-
-## Tool execution (only when actions are warranted)
-Append EXACTLY this block at the very end of your message when you must create workspace artifacts:
----TOOLS---
-[
-  { "name": "createPhase", "args": { "title": "Phase 1: Research", "description": "..." } },
-  { "name": "createTask", "args": { "title": "Write Draft", "description": "..." } },
-  { "name": "createDocument", "args": { "title": "My Document", "content": "..." } }
-]
----END---
-Available tool names: createTask, addIdea, createPhase, buildMindMap, addNode, linkNodes, createDocument.
-Only emit this block at the very end and only if actions are needed. Otherwise output plain text.${CLARIFICATION_PROTOCOL}`,
-        tools: ['createTask', 'addIdea', 'createPhase', 'buildMindMap', 'addNode', 'linkNodes', 'createDocument'],
-        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 = ['sisyphus', 'prometheus', 'hephaestus', 'atlas', 'oracle', 'chairman'];
-    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: 'sisyphus', ...}, {id: 'oracle', ...}],
- *     { sisyphus: 'prometheus' }  // or just { sisyphus: 'prometheus' }
- *   )
- *   // => [{id: 'prometheus', ...}, {id: 'oracle', ...}]
- *
- * 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