@compilr-dev/cli 0.8.10 → 0.9.1

package/dist/commands-v2/handlers/team.js

@@ -6,9 +6,11 @@
 import pc from 'picocolors';
 import { TeamOverlayV2 } from '../../ui/overlay/impl/team-overlay-v2.js';
 import { CustomAgentFormOverlayV2 } from '../../ui/overlay/impl/custom-agent-form-overlay-v2.js';
+import { AgentEditOverlayV2 } from '../../ui/overlay/impl/agent-edit-overlay-v2.js';
 import { ArtifactOverlayV2, ArtifactDetailOverlayV2 } from '../../ui/overlay/index.js';
 import { ROLE_METADATA, PREDEFINED_ROLE_IDS } from '../../multi-agent/index.js';
-import { loadCustomAgents, createCustomAgentDefinition, addCustomAgent, removeCustomAgent, } from '../../multi-agent/custom-agents.js';
+import { loadCustomAgents, createCustomAgentDefinition, addCustomAgent, removeCustomAgent, updateCustomAgent, } from '../../multi-agent/custom-agents.js';
+import { readEditableInstructions, buildAgentPatch, } from '../../multi-agent/agent-edit.js';
 import { getCurrentProject } from '../../tools/project-db.js';
 import { listTemplates, saveTemplate } from '@compilr-dev/sdk';
 import { getSessionRegistry } from '../../multi-agent/session-registry.js';
@@ -276,8 +278,182 @@ async function openTeamOverlay(ctx, team) {
             });
         }
     }
+    else if (result?.action === 'edit' && result.agentId) {
+        await handleEditAgent(ctx, team, result.agentId);
+    }
     return true;
 }
+/**
+ * Edit an existing team agent.
+ *
+ * ⚠️ THE INSTRUCTIONS FIELD IS NOT THE SAME FIELD FOR BOTH AGENT KINDS, and reading the
+ * wrong one moves the user's data. A custom agent's live `systemPromptAddition` is the
+ * whole GENERATED prompt ("You are a X specialized in Y. …"), not the instructions the
+ * user typed — those live on the `CustomAgentDefinition` on disk. So:
+ *
+ *   custom agent → read/write `CustomAgentDefinition.systemPromptAddition`, then
+ *                  regenerate the live prompt around it
+ *   role agent   → read/write the live `TeamAgent.systemPromptAddition`, which for that
+ *                  kind genuinely IS free text
+ *
+ * Loading one and saving the other is an asymmetric round trip: it does not look like a
+ * bug until the data has already moved.
+ */
+// Exported for tests: the restoreAgent step below is the one failure in this flow that
+// cannot be seen from the outside, so it is worth exercising directly.
+export async function handleEditAgent(ctx, team, agentId) {
+    const teamAgent = team.get(agentId);
+    if (!teamAgent) {
+        ctx.ui.print({ type: 'error', message: `Agent '${agentId}' not found` });
+        return;
+    }
+    const isCustom = teamAgent.role === 'custom';
+    const projectPath = getCurrentProject()?.path;
+    /*
+      A custom agent's editable text lives in its definition; without the project we cannot
+      read it, and editing the generated prompt instead is the trap above. Path and definition
+      are kept together in one value so "this is a custom agent we can actually write" is a
+      single check later, rather than two that could drift apart.
+    */
+    let custom = null;
+    if (isCustom) {
+        if (!projectPath) {
+            ctx.ui.print({
+                type: 'warning',
+                message: 'Select a project first to edit custom agents',
+            });
+            return;
+        }
+        const definition = loadCustomAgents(projectPath).find((a) => a.id === agentId);
+        if (!definition) {
+            ctx.ui.print({
+                type: 'error',
+                message: `No stored definition for '${agentId}' — it cannot be edited from here.`,
+            });
+            return;
+        }
+        custom = { path: projectPath, definition };
+    }
+    const originals = {
+        displayName: teamAgent.displayName,
+        specialty: teamAgent.description ?? '',
+        instructions: readEditableInstructions(teamAgent.systemPromptAddition, custom?.definition),
+        mascot: teamAgent.mascot,
+        personality: teamAgent.personality ?? '',
+        modelTier: teamAgent.modelTier ?? 'balanced',
+        toolProfile: teamAgent.toolProfile ?? 'full',
+        systemPromptAddition: teamAgent.systemPromptAddition ?? '',
+    };
+    const overlay = new AgentEditOverlayV2({
+        agentId,
+        displayName: originals.displayName,
+        mascot: originals.mascot,
+        specialty: originals.specialty,
+        personality: originals.personality,
+        instructions: originals.instructions,
+        modelTier: originals.modelTier,
+        toolProfile: originals.toolProfile,
+        isCustom,
+        takenMascots: team
+            .getAll()
+            .filter((a) => a.id !== agentId)
+            .map((a) => a.mascot),
+    });
+    const result = await ctx.ui.showOverlay(overlay);
+    if (!result?.saved || !result.values) {
+        return;
+    }
+    const values = result.values;
+    /*
+      What should end up on the LIVE agent's prompt. For a custom agent that is the prompt
+      regenerated from the updated definition; for a role agent it is the edited free text.
+    */
+    let newSystemPromptAddition;
+    if (custom) {
+        /*
+          Write the definition first, then send the user's OWN words to the live agent.
+          SDK 0.23 composes the role scaffold, capability blurb, delegation guidance and
+          personality at `initialize()` from current state — so `systemPromptAddition` holds
+          user-authored text only. Regenerating a composite here and sending THAT would be
+          composed a second time on top.
+        */
+        const updatedDefinition = updateCustomAgent(custom.path, agentId, {
+            displayName: values.displayName,
+            specialty: values.specialty,
+            // Kept on the definition too, so the disk copy and the live agent do not drift.
+            personality: values.personality || undefined,
+            systemPromptAddition: values.instructions || undefined,
+            mascot: values.mascot,
+            modelTier: values.modelTier,
+            toolConfig: { ...custom.definition.toolConfig, profile: values.toolProfile },
+        });
+        if (!updatedDefinition) {
+            ctx.ui.print({
+                type: 'error',
+                message: `Could not write '${agentId}' to custom-agents.json — nothing was changed.`,
+            });
+            return;
+        }
+        /*
+          `?? ''` rather than leaving it undefined: clearing the instructions is a real edit,
+          and `buildAgentPatch` reads undefined as "unchanged" — so an emptied box would
+          silently keep the old text.
+        */
+        newSystemPromptAddition = updatedDefinition.systemPromptAddition ?? '';
+    }
+    else if (values.instructions !== originals.instructions) {
+        newSystemPromptAddition = values.instructions;
+    }
+    const patch = buildAgentPatch(originals, values, newSystemPromptAddition);
+    if (Object.keys(patch).length === 0) {
+        ctx.ui.print({ type: 'info', message: 'No changes.' });
+        return;
+    }
+    try {
+        const update = await team.updateAgent(agentId, patch);
+        syncTeamRoster(team);
+        /*
+          ⚠️ AN EDIT THAT DID NOT REACH DISK IS NOT A SAVE. The change is live in memory either
+          way, so the agent behaves as edited now and the loss only shows up on restart.
+        */
+        saveTeamAndSession(team, ctx);
+        ctx.ui.print({
+            type: 'success',
+            message: `Updated ${teamAgent.getFullLabel()}`,
+        });
+        /*
+          ⚠️ THE REPL HOLDS A DIRECT REFERENCE TO THE LIVE AGENT. A rebuild replaces the object
+          behind it, and without this the REPL keeps talking to the disposed one — so the edit
+          appears to do nothing, but only for the agent that happens to be active, which reads
+          as intermittent rather than broken. `updateAgent` rebuilds eagerly, so `.agent` is
+          already the new instance here.
+        */
+        if (update.rebuilt && agentId === team.activeAgentId && teamAgent.agent && ctx.restoreAgent) {
+            ctx.restoreAgent(teamAgent.agent);
+        }
+        // Capability changes the agent cannot observe have to reach the conversation: its own
+        // history has it planning things it may no longer be able to do.
+        if (update.lostWriteAccess) {
+            ctx.ui.print({
+                type: 'warning',
+                message: `${teamAgent.getFullLabel()} can no longer change files (${update.previousProfile ?? 'unrestricted'} → ${update.newProfile ?? 'unrestricted'}).`,
+            });
+        }
+        else if (update.toolsNarrowed) {
+            ctx.ui.print({
+                type: 'warning',
+                message: `${teamAgent.getFullLabel()} can now reach fewer tools (${update.previousProfile ?? 'unrestricted'} → ${update.newProfile ?? 'unrestricted'}).`,
+            });
+        }
+    }
+    catch (err) {
+        // The SDK throws on an unknown agent, an unknown profile, and any attempt to change id.
+        ctx.ui.print({
+            type: 'error',
+            message: `Failed to update agent: ${err instanceof Error ? err.message : 'Unknown error'}`,
+        });
+    }
+}
 async function handleCreateCustomAgent(ctx, team) {
     // Check for project context
     const currentProject = getCurrentProject();
@@ -317,13 +493,12 @@ async function handleCreateCustomAgent(ctx, team) {
             mascot: '',
             createdAt: new Date().toISOString(),
             toolConfig: agentData.toolConfig,
-            enabledSkills: agentData.enabledSkills,
             modelTier: agentData.modelTier,
         });
         ctx.ui.print({ type: 'success', message: `Template "${formResult.saveAsTemplate}" saved.` });
     }
     // Create the custom agent definition
-    const agentDef = createCustomAgentDefinition(agentData.id, agentData.displayName, agentData.specialty, agentData.personality, existingCustomAgents, agentData.toolConfig, agentData.enabledSkills, agentData.modelTier, agentData.systemPromptAddition);
+    const agentDef = createCustomAgentDefinition(agentData.id, agentData.displayName, agentData.specialty, agentData.personality, existingCustomAgents, agentData.toolConfig, agentData.modelTier, agentData.systemPromptAddition);
     // Save to project
     try {
         addCustomAgent(projectPath, agentDef);

package/dist/index.js

@@ -15,6 +15,8 @@ import { perf, flushStartupPerf } from './utils/startup-perf.js';
 perf('imports-start');
 import { createAgent } from './agent.js';
 import { getModelForTier, getProviderMetadata } from './models/index.js';
+import { filterMcpToolsByGrant, loadInstalledSkills, resolveSkillsForTeamAgent } from '@compilr-dev/sdk';
+import { getProjectDir } from './repl-helpers.js';
 import { ReplV2 } from './repl-v2.js';
 import { AgentTeam, setActiveSharedContext } from './multi-agent/index.js';
 import { getStyles } from './themes/index.js';
@@ -657,7 +659,35 @@ async function main() {
     // ==========================================================================
     perf('team-setup-start');
     // Define agent factory for creating team agents
-    const agentFactory = (_config, systemPromptAddition, useMinimalSystemPrompt, noTools, toolFilter, modelTier) => {
+    /**
+     * The skills an agent may CHOOSE — distinct from the slash commands a user types.
+     *
+     * ⚠️ THE HOST FILTERS, THE SDK PRESENTS, and `resolveSkillsForTeamAgent` holds every judgement
+     * so the CLI and Desktop cannot drift about what an absent grant means or which filters apply.
+     * `loadInstalledSkills` excludes the 42 platform prompts on purpose: those are Commands — modes
+     * a user forces — not capabilities a model selects.
+     */
+    const skillsForAgent = (teamAgent) => {
+        // No agent identity means no eligibility context, so no catalogue.
+        if (!teamAgent)
+            return [];
+        const pool = loadInstalledSkills(getProjectDir());
+        if (pool.length === 0)
+            return [];
+        return resolveSkillsForTeamAgent(pool, teamAgent, { toolNames: teamAgent.toolFilter });
+    };
+    /** The MCP tools an agent may be built with. See the note at the `mcpTools` call site. */
+    const grantedMcpTools = (tools, teamAgent) => {
+        if (tools.length === 0)
+            return undefined;
+        // No agent identity means no grant to honour — nothing is filtered, as before.
+        if (!teamAgent)
+            return tools;
+        const servers = mcpManagerInstance?.getServerNames() ?? [];
+        const granted = filterMcpToolsByGrant(tools, servers, (s) => teamAgent.grantsMcpServer(s));
+        return granted.length > 0 ? granted : undefined;
+    };
+    const agentFactory = (_config, systemPromptAddition, useMinimalSystemPrompt, noTools, toolFilter, modelTier, teamAgent) => {
         // Resolve model from tier if provided, otherwise use global model
         const agentModel = modelTier ? getModelForTier(provider, modelTier) : model;
         // Create new agent with same base options plus role-specific system prompt
@@ -701,7 +731,18 @@ async function main() {
             // Tool filter - limit which tools this agent can use
             toolFilter,
             // MCP tools from external servers (reads mutable ref — includes tools once MCP init completes)
-            mcpTools: mcpToolsRef.length > 0 ? mcpToolsRef : undefined,
+            /*
+              ⚠️ MCP REACH IS PER AGENT, AND THE TOOL PROFILE NEVER GATED IT. MCP tools are in no
+              capability pack — discovered at runtime, they never could be — and the SDK allows
+              unpacked "orphan" tools, so a read-only agent could run an MCP WRITE tool. Filtering at
+              construction is the enforcement: a tool the agent is not built with cannot be called.
+      
+              `grantsMcpServer` owns what an absent grant means (undefined = an agent from before
+              grants existed, which still reaches everything), and `filterMcpToolsByGrant` owns the
+              tool→server mapping, so the CLI cannot drift from Desktop on either.
+            */
+            mcpTools: grantedMcpTools(mcpToolsRef, teamAgent),
+            skills: skillsForAgent(teamAgent),
             // Suppress startup logs for team agents (avoid UI interference)
             quiet: true,
             // Episode recorder for work history tracking (team agents share project store)
@@ -982,9 +1023,20 @@ async function main() {
             .then((tools) => {
             perf('mcp-background-done');
             replV2.setMCPLoading(false, tools.length);
+            /*
+              ⚠️ THE SECOND INJECTION PATH. `mcpToolsRef` feeds the factory, which filters by grant —
+              but the main agent already exists by now and gets its tools here instead, straight onto
+              its registry where no capability filter looks. Desktop had the same pair; filtering only
+              the factory leaves grants working except for the agent you are already talking to.
+    
+              `mcpToolsRef` stays UNFILTERED on purpose: it is the pool every agent is filtered FROM,
+              and narrowing it here would apply the default agent's grant to the whole team.
+            */
             if (tools.length > 0) {
-                agent?.registerTools(tools);
                 mcpToolsRef = tools;
+                const forDefault = grantedMcpTools(tools, sharedState.team?.get('default'));
+                if (forDefault && forDefault.length > 0)
+                    agent?.registerTools(forDefault);
             }
         })
             .catch(() => {

package/dist/multi-agent/agent-edit.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Agent edit — the decisions an edit makes, separated from the UI that collects it.
+ *
+ * These are pure so they can be tested. The two things here are the two things most
+ * likely to be silently wrong: WHICH prompt field an edit reads and writes, and WHAT
+ * ends up in the patch.
+ */
+import type { TeamAgentUpdate, MascotExpression, ToolProfile } from '@compilr-dev/sdk';
+import type { CustomAgentDefinition } from './custom-agents.js';
+import type { ModelTier } from '../models/index.js';
+/** The agent's values as they were when the editor opened. */
+export interface AgentEditOriginals {
+    displayName: string;
+    specialty: string;
+    instructions: string;
+    mascot: MascotExpression;
+    modelTier: ModelTier;
+    toolProfile: ToolProfile;
+    /** Tone. Composed into the prompt at initialize() as "Your manner: …". */
+    personality: string;
+    /** The live agent's current prompt addition — user-authored text since SDK 0.23. */
+    systemPromptAddition: string;
+}
+/** The values the editor handed back. */
+export interface AgentEditedValues {
+    displayName: string;
+    specialty: string;
+    instructions: string;
+    mascot: MascotExpression;
+    modelTier: ModelTier;
+    toolProfile: ToolProfile;
+    personality: string;
+}
+/**
+ * Which text is the user's to edit.
+ *
+ * ⚠️ THE TWO FIELDS SHARE A NAME AND DO NOT SHARE A MEANING.
+ * `CustomAgentDefinition.systemPromptAddition` is what the user typed
+ * ("Always cite the ADR."). `TeamAgent.systemPromptAddition` is the whole GENERATED
+ * prompt ("You are a Solution Architect specialized in …"), because
+ * `fromCustomDefinition` stores the generated composite there.
+ *
+ * So a custom agent's editable text comes from its definition, and a role agent's — which
+ * has no definition — comes from the live agent.
+ *
+ * ⚠️ Corrected: before SDK 0.23 the live field was NOT free text for a role agent either.
+ * `fromRole` composed the role scaffold, tool awareness and delegation guidance into it —
+ * 6,321 characters for `pm`. An earlier note here claimed role agents were unaffected; that
+ * was asserted from reading the code rather than running it, and it was wrong. Since 0.23
+ * the field holds user text for both kinds, so this fallback is now correct for both — but
+ * the definition stays authoritative for custom agents, because it is what is on disk.
+ */
+export declare function readEditableInstructions(liveSystemPromptAddition: string | undefined, definition: CustomAgentDefinition | undefined): string;
+/**
+ * Build the minimal patch for an edit.
+ *
+ * Only changed fields are included, so an untouched field never triggers a rebuild —
+ * `applyUpdate` compares each present key against the live value and rebuilds on any
+ * difference in the prompt, personality, profile, filter or skills.
+ *
+ * `newSystemPromptAddition` is the USER'S OWN WORDS, for both agent kinds, or undefined
+ * when the text was not touched.
+ *
+ * ⚠️ This changed in SDK 0.23. `systemPromptAddition` now holds user-authored text ONLY:
+ * the role scaffold, capability blurb, delegation guidance and personality are composed at
+ * `initialize()` from current state. Sending a pre-composed prompt here would be composed a
+ * second time on top of itself — and was previously the reason a tool-profile change could
+ * leave the prompt still claiming tools the filter had already removed.
+ *
+ * ⚠️ `toolProfile` is sent WITHOUT a `toolFilter`. The profile is a label; the filter is
+ * the enforcement, and `applyUpdate` derives the filter from the profile precisely when
+ * the filter is absent. Supplying our own would override that with a second source of
+ * truth for the same fact.
+ */
+export declare function buildAgentPatch(originals: AgentEditOriginals, values: AgentEditedValues, newSystemPromptAddition: string | undefined): TeamAgentUpdate;

package/dist/multi-agent/agent-edit.js

@@ -0,0 +1,84 @@
+/**
+ * Agent edit — the decisions an edit makes, separated from the UI that collects it.
+ *
+ * These are pure so they can be tested. The two things here are the two things most
+ * likely to be silently wrong: WHICH prompt field an edit reads and writes, and WHAT
+ * ends up in the patch.
+ */
+/**
+ * Which text is the user's to edit.
+ *
+ * ⚠️ THE TWO FIELDS SHARE A NAME AND DO NOT SHARE A MEANING.
+ * `CustomAgentDefinition.systemPromptAddition` is what the user typed
+ * ("Always cite the ADR."). `TeamAgent.systemPromptAddition` is the whole GENERATED
+ * prompt ("You are a Solution Architect specialized in …"), because
+ * `fromCustomDefinition` stores the generated composite there.
+ *
+ * So a custom agent's editable text comes from its definition, and a role agent's — which
+ * has no definition — comes from the live agent.
+ *
+ * ⚠️ Corrected: before SDK 0.23 the live field was NOT free text for a role agent either.
+ * `fromRole` composed the role scaffold, tool awareness and delegation guidance into it —
+ * 6,321 characters for `pm`. An earlier note here claimed role agents were unaffected; that
+ * was asserted from reading the code rather than running it, and it was wrong. Since 0.23
+ * the field holds user text for both kinds, so this fallback is now correct for both — but
+ * the definition stays authoritative for custom agents, because it is what is on disk.
+ */
+export function readEditableInstructions(liveSystemPromptAddition, definition) {
+    if (definition) {
+        return definition.systemPromptAddition ?? '';
+    }
+    return liveSystemPromptAddition ?? '';
+}
+/**
+ * Build the minimal patch for an edit.
+ *
+ * Only changed fields are included, so an untouched field never triggers a rebuild —
+ * `applyUpdate` compares each present key against the live value and rebuilds on any
+ * difference in the prompt, personality, profile, filter or skills.
+ *
+ * `newSystemPromptAddition` is the USER'S OWN WORDS, for both agent kinds, or undefined
+ * when the text was not touched.
+ *
+ * ⚠️ This changed in SDK 0.23. `systemPromptAddition` now holds user-authored text ONLY:
+ * the role scaffold, capability blurb, delegation guidance and personality are composed at
+ * `initialize()` from current state. Sending a pre-composed prompt here would be composed a
+ * second time on top of itself — and was previously the reason a tool-profile change could
+ * leave the prompt still claiming tools the filter had already removed.
+ *
+ * ⚠️ `toolProfile` is sent WITHOUT a `toolFilter`. The profile is a label; the filter is
+ * the enforcement, and `applyUpdate` derives the filter from the profile precisely when
+ * the filter is absent. Supplying our own would override that with a second source of
+ * truth for the same fact.
+ */
+export function buildAgentPatch(originals, values, newSystemPromptAddition) {
+    const patch = {};
+    if (values.displayName !== originals.displayName) {
+        patch.displayName = values.displayName;
+    }
+    if (values.specialty !== originals.specialty) {
+        patch.description = values.specialty;
+    }
+    if (values.mascot !== originals.mascot) {
+        patch.mascot = values.mascot;
+    }
+    if (values.modelTier !== originals.modelTier) {
+        patch.modelTier = values.modelTier;
+    }
+    if (values.toolProfile !== originals.toolProfile) {
+        patch.toolProfile = values.toolProfile;
+    }
+    /*
+      Unblocked in SDK 0.23. `fromCustomDefinition` now passes `def.personality` through, so
+      this REPLACES the agent's tone rather than adding a second, contradicting one beside a
+      `Your approach:` line baked into the base prompt.
+    */
+    if (values.personality !== originals.personality) {
+        patch.personality = values.personality;
+    }
+    if (newSystemPromptAddition !== undefined &&
+        newSystemPromptAddition !== originals.systemPromptAddition) {
+        patch.systemPromptAddition = newSystemPromptAddition;
+    }
+    return patch;
+}

package/dist/multi-agent/capability-loader.d.ts

@@ -1,9 +1,19 @@
 /**
- * Capability Loader — Bridge between slash commands and the CapabilityManager.
+ * Capability Loader — bridge between MACROS and the CapabilityManager.
  *
- * Stores a module-level reference to the current CapabilityManager
- * (set by agent.ts during createAgent()). Provides a high-level function
- * for slash command handlers to load capability packs required by a skill.
+ * A macro declares the tools its text assumes (MACRO_REQUIREMENTS); this maps those to
+ * capability packs and loads them before the macro's prompt is queued, so `/design` arrives
+ * with the tools it is about to ask for.
+ *
+ * ⚠️ THIS WHOLE PATH IS DEAD, AND HAS BEEN SINCE IT WAS WRITTEN. `setCapabilityManager` has NO
+ * CALLERS anywhere in the CLI — the header below says it is "set by agent.ts during
+ * createAgent()", and agent.ts does not call it. So `currentManager` is permanently null,
+ * `loadCapabilitiesForMacro` returns at its first guard every time, and the warning it exists
+ * to print has never printed. Verified by grep, not by reading.
+ *
+ * Left in place rather than deleted because the design is sound and the tier flip that made
+ * packs lazy is what it was waiting for — but it is a decision, not an oversight to inherit.
+ * Wire it or delete it; do not assume it works.
  */
 import type { CapabilityManager, CapabilityLoadResult } from '@compilr-dev/sdk';
 /**
@@ -26,4 +36,4 @@ export declare function getCapabilityManager(): CapabilityManager | null;
  * @param skillName - Skill name (e.g., 'design', 'build', 'refactor')
  * @returns Load result, or null if capability loading is not active or skill has no requirements
  */
-export declare function loadCapabilitiesForSkill(skillName: string): CapabilityLoadResult | null;
+export declare function loadCapabilitiesForMacro(skillName: string): CapabilityLoadResult | null;

package/dist/multi-agent/capability-loader.js

@@ -1,11 +1,21 @@
 /**
- * Capability Loader — Bridge between slash commands and the CapabilityManager.
+ * Capability Loader — bridge between MACROS and the CapabilityManager.
  *
- * Stores a module-level reference to the current CapabilityManager
- * (set by agent.ts during createAgent()). Provides a high-level function
- * for slash command handlers to load capability packs required by a skill.
+ * A macro declares the tools its text assumes (MACRO_REQUIREMENTS); this maps those to
+ * capability packs and loads them before the macro's prompt is queued, so `/design` arrives
+ * with the tools it is about to ask for.
+ *
+ * ⚠️ THIS WHOLE PATH IS DEAD, AND HAS BEEN SINCE IT WAS WRITTEN. `setCapabilityManager` has NO
+ * CALLERS anywhere in the CLI — the header below says it is "set by agent.ts during
+ * createAgent()", and agent.ts does not call it. So `currentManager` is permanently null,
+ * `loadCapabilitiesForMacro` returns at its first guard every time, and the warning it exists
+ * to print has never printed. Verified by grep, not by reading.
+ *
+ * Left in place rather than deleted because the design is sound and the tier flip that made
+ * packs lazy is what it was waiting for — but it is a decision, not an oversight to inherit.
+ * Wire it or delete it; do not assume it works.
  */
-import { SKILL_REQUIREMENTS } from '@compilr-dev/sdk';
+import { MACRO_REQUIREMENTS } from '@compilr-dev/sdk';
 // =============================================================================
 // Module-level state
 // =============================================================================
@@ -37,14 +47,14 @@ export function getCapabilityManager() {
  * @param skillName - Skill name (e.g., 'design', 'build', 'refactor')
  * @returns Load result, or null if capability loading is not active or skill has no requirements
  */
-export function loadCapabilitiesForSkill(skillName) {
+export function loadCapabilitiesForMacro(skillName) {
     if (!currentManager) {
         return null;
     }
-    if (!(skillName in SKILL_REQUIREMENTS)) {
+    if (!(skillName in MACRO_REQUIREMENTS)) {
         return null;
     }
-    const requirements = SKILL_REQUIREMENTS[skillName];
+    const requirements = MACRO_REQUIREMENTS[skillName];
     // Combine required + optional tools
     const allTools = [
         ...requirements.required,

package/dist/multi-agent/custom-agents.d.ts

@@ -24,3 +24,15 @@ export declare function addCustomAgent(projectPath: string, agent: CustomAgentDe
  * Remove a custom agent by ID and save.
  */
 export declare function removeCustomAgent(projectPath: string, agentId: string): boolean;
+/**
+ * Update a custom agent's definition in place and save.
+ *
+ * Returns the updated definition (the caller needs it to regenerate the agent's
+ * system prompt), or `null` if no agent with that id is stored.
+ *
+ * ⚠️ `id` and `createdAt` are not patchable, by type rather than by a runtime throw.
+ * The id is persisted in message history as literal text — mentions resolve when
+ * typed, not when read — so renaming `$arch` would strand every prior reference.
+ * `AgentTeam.updateAgent` enforces the same constraint on the live agent.
+ */
+export declare function updateCustomAgent(projectPath: string, agentId: string, patch: Partial<Omit<CustomAgentDefinition, 'id' | 'createdAt'>>): CustomAgentDefinition | null;

package/dist/multi-agent/custom-agents.js

@@ -37,7 +37,6 @@ function migrateAgentV1toV2(agent) {
     return {
         ...agent,
         toolConfig: agent.toolConfig ?? createDefaultToolConfig(),
-        enabledSkills: agent.enabledSkills ?? [],
     };
 }
 /**
@@ -99,3 +98,25 @@ export function removeCustomAgent(projectPath, agentId) {
     saveCustomAgents(projectPath, agents);
     return true;
 }
+/**
+ * Update a custom agent's definition in place and save.
+ *
+ * Returns the updated definition (the caller needs it to regenerate the agent's
+ * system prompt), or `null` if no agent with that id is stored.
+ *
+ * ⚠️ `id` and `createdAt` are not patchable, by type rather than by a runtime throw.
+ * The id is persisted in message history as literal text — mentions resolve when
+ * typed, not when read — so renaming `$arch` would strand every prior reference.
+ * `AgentTeam.updateAgent` enforces the same constraint on the live agent.
+ */
+export function updateCustomAgent(projectPath, agentId, patch) {
+    const agents = loadCustomAgents(projectPath);
+    const index = agents.findIndex((a) => a.id === agentId);
+    if (index === -1) {
+        return null;
+    }
+    const updated = { ...agents[index], ...patch };
+    agents[index] = updated;
+    saveCustomAgents(projectPath, agents);
+    return updated;
+}

package/dist/repl-helpers.d.ts

@@ -5,6 +5,7 @@
  * and improve maintainability. These functions support the REPL but don't
  * depend on REPL instance state.
  */
+import { type SkillSources } from '@compilr-dev/sdk';
 import type { BacklogItem } from './tools/backlog.js';
 /**
  * Keyword patterns for tool selection based on user input.
@@ -38,9 +39,13 @@ export declare function detectCompilrProject(): CompilrProjectInfo;
  * Check if backlog has any items using the shared parser.
  */
 export declare function hasBacklogItems(backlogPath: string | null): boolean;
+/** Get the current project directory (best effort). */
+export declare function getProjectDir(): string | undefined;
+/** Get CLI skill sources (factory + coding). */
+export declare function getCliSkillSources(): SkillSources;
 /**
  * Get skill prompt by name. Delegates to SDK resolveSkillPrompt, minus any
- * Desktop-only SDK skills (see DESKTOP_ONLY_SKILLS).
+ * Desktop-only SDK skills (see DESKTOP_ONLY_MACROS).
  */
 export declare function getSkillPrompt(name: string): string | null;
 /**