gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -1,111 +0,0 @@
-/**
- * GSD Milestone Actions — Park, Unpark, and Discard operations.
- *
- * Park: Creates a PARKED.md marker file. deriveState() skips parked milestones
- * when finding the active milestone, but keeps them in the registry.
- *
- * Unpark: Removes the PARKED.md marker. The milestone resumes normal state
- * derivation (active/pending depending on position and dependencies).
- *
- * Discard: Permanently removes the milestone directory. Also prunes
- * QUEUE-ORDER.json if the discarded milestone was in it.
- */
-import { existsSync, rmSync, writeFileSync, readFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } from "./paths.js";
-import { invalidateAllCaches } from "./cache.js";
-import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
-// ─── Park ──────────────────────────────────────────────────────────────────
-/**
- * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
- * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
- */
-export function parkMilestone(basePath, milestoneId, reason) {
-    const mDir = resolveMilestonePath(basePath, milestoneId);
-    if (!mDir || !existsSync(mDir))
-        return false;
-    // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-    if (summaryFile)
-        return false;
-    const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
-    if (existsSync(parkedPath))
-        return false; // already parked
-    const content = [
-        "---",
-        `parked_at: ${new Date().toISOString()}`,
-        `reason: "${reason.replace(/"/g, '\\"')}"`,
-        "---",
-        "",
-        `# ${milestoneId} — Parked`,
-        "",
-        `> ${reason}`,
-        "",
-    ].join("\n");
-    writeFileSync(parkedPath, content, "utf-8");
-    invalidateAllCaches();
-    return true;
-}
-// ─── Unpark ────────────────────────────────────────────────────────────────
-/**
- * Unpark a milestone — removes the PARKED.md marker file.
- * Returns true if successfully unparked, false if milestone not found or not parked.
- */
-export function unparkMilestone(basePath, milestoneId) {
-    const mDir = resolveMilestonePath(basePath, milestoneId);
-    if (!mDir || !existsSync(mDir))
-        return false;
-    const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
-    if (!existsSync(parkedPath))
-        return false; // not parked
-    unlinkSync(parkedPath);
-    invalidateAllCaches();
-    return true;
-}
-// ─── Discard ───────────────────────────────────────────────────────────────
-/**
- * Discard a milestone — permanently removes the milestone directory and
- * prunes it from QUEUE-ORDER.json if present.
- * Returns true if successfully discarded, false if milestone not found.
- */
-export function discardMilestone(basePath, milestoneId) {
-    const mDir = resolveMilestonePath(basePath, milestoneId);
-    if (!mDir || !existsSync(mDir))
-        return false;
-    rmSync(mDir, { recursive: true, force: true });
-    // Prune from queue order if present
-    const order = loadQueueOrder(basePath);
-    if (order && order.includes(milestoneId)) {
-        saveQueueOrder(basePath, order.filter(id => id !== milestoneId));
-    }
-    invalidateAllCaches();
-    return true;
-}
-// ─── Query ─────────────────────────────────────────────────────────────────
-/**
- * Check whether a milestone is parked (PARKED.md exists).
- */
-export function isParked(basePath, milestoneId) {
-    return !!resolveMilestoneFile(basePath, milestoneId, "PARKED");
-}
-/**
- * Read the park reason from PARKED.md frontmatter.
- * Returns null if the milestone is not parked or the reason can't be extracted.
- */
-export function getParkedReason(basePath, milestoneId) {
-    const parkedFile = resolveMilestoneFile(basePath, milestoneId, "PARKED");
-    if (!parkedFile)
-        return null;
-    try {
-        const content = readFileSync(parkedFile, "utf-8");
-        const match = content.match(/^---\n([\s\S]*?)\n---/);
-        if (!match)
-            return null;
-        const reasonMatch = match[1].match(/reason:\s*"([^"]*?)"/);
-        return reasonMatch ? reasonMatch[1] : null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -1,48 +0,0 @@
-// GSD Extension — Model Cost Table
-// Static cost reference for known models, used by the dynamic router
-// for cross-provider cost comparison.
-//
-// Costs are approximate per-1K-token rates in USD (input tokens).
-// Updated with GSD releases. Users can override via preferences.
-/**
- * Bundled cost table for known models.
- * Updated periodically with GSD releases.
- */
-export const BUNDLED_COST_TABLE = [
-    // Anthropic
-    { id: "claude-opus-4-6", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
-    { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
-    { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
-    { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
-    { id: "claude-3-5-sonnet-latest", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
-    { id: "claude-3-5-haiku-latest", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
-    { id: "claude-3-opus-latest", inputPer1k: 0.015, outputPer1k: 0.075, updatedAt: "2025-03-15" },
-    // OpenAI
-    { id: "gpt-4o", inputPer1k: 0.0025, outputPer1k: 0.01, updatedAt: "2025-03-15" },
-    { id: "gpt-4o-mini", inputPer1k: 0.00015, outputPer1k: 0.0006, updatedAt: "2025-03-15" },
-    { id: "o1", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
-    { id: "o3", inputPer1k: 0.015, outputPer1k: 0.06, updatedAt: "2025-03-15" },
-    { id: "gpt-4-turbo", inputPer1k: 0.01, outputPer1k: 0.03, updatedAt: "2025-03-15" },
-    // Google
-    { id: "gemini-2.0-flash", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
-    { id: "gemini-flash-2.0", inputPer1k: 0.0001, outputPer1k: 0.0004, updatedAt: "2025-03-15" },
-    { id: "gemini-2.5-pro", inputPer1k: 0.00125, outputPer1k: 0.005, updatedAt: "2025-03-15" },
-    // DeepSeek
-    { id: "deepseek-chat", inputPer1k: 0.00014, outputPer1k: 0.00028, updatedAt: "2025-03-15" },
-];
-/**
- * Lookup cost for a model ID. Returns undefined if not found.
- */
-export function lookupModelCost(modelId) {
-    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
-    return BUNDLED_COST_TABLE.find(e => e.id === bareId)
-        ?? BUNDLED_COST_TABLE.find(e => bareId.includes(e.id) || e.id.includes(bareId));
-}
-/**
- * Compare two models by input cost. Returns negative if a is cheaper.
- */
-export function compareModelCost(modelIdA, modelIdB) {
-    const costA = lookupModelCost(modelIdA)?.inputPer1k ?? 999;
-    const costB = lookupModelCost(modelIdB)?.inputPer1k ?? 999;
-    return costA - costB;
-}

package/dist/resources/extensions/gsd/model-router.js

@@ -1,187 +0,0 @@
-// GSD Extension — Dynamic Model Router
-// Maps complexity tiers to models, enforcing downgrade-only semantics.
-// The user's configured model is always the ceiling.
-import { tierOrdinal } from "./complexity-classifier.js";
-// ─── Known Model Tiers ───────────────────────────────────────────────────────
-// Maps known model IDs to their capability tier. Used when tier_models is not
-// explicitly configured to pick the best available model for each tier.
-const MODEL_CAPABILITY_TIER = {
-    // Light-tier models (cheapest)
-    "claude-haiku-4-5": "light",
-    "claude-3-5-haiku-latest": "light",
-    "claude-3-haiku-20240307": "light",
-    "gpt-4o-mini": "light",
-    "gemini-2.0-flash": "light",
-    "gemini-flash-2.0": "light",
-    // Standard-tier models
-    "claude-sonnet-4-6": "standard",
-    "claude-sonnet-4-5-20250514": "standard",
-    "claude-3-5-sonnet-latest": "standard",
-    "gpt-4o": "standard",
-    "gemini-2.5-pro": "standard",
-    "deepseek-chat": "standard",
-    // Heavy-tier models (most capable)
-    "claude-opus-4-6": "heavy",
-    "claude-3-opus-latest": "heavy",
-    "gpt-4-turbo": "heavy",
-    "o1": "heavy",
-    "o3": "heavy",
-};
-// ─── Cost Table (per 1K input tokens, approximate USD) ───────────────────────
-// Used for cross-provider cost comparison when multiple providers offer
-// the same capability tier.
-const MODEL_COST_PER_1K_INPUT = {
-    "claude-haiku-4-5": 0.0008,
-    "claude-3-5-haiku-latest": 0.0008,
-    "claude-sonnet-4-6": 0.003,
-    "claude-sonnet-4-5-20250514": 0.003,
-    "claude-opus-4-6": 0.015,
-    "gpt-4o-mini": 0.00015,
-    "gpt-4o": 0.0025,
-    "gemini-2.0-flash": 0.0001,
-    "gemini-2.5-pro": 0.00125,
-    "deepseek-chat": 0.00014,
-};
-// ─── Public API ──────────────────────────────────────────────────────────────
-/**
- * Resolve the model to use for a given complexity tier.
- *
- * Downgrade-only: the returned model is always equal to or cheaper than
- * the user's configured primary model. Never upgrades beyond configuration.
- *
- * @param classification  The complexity classification result
- * @param phaseConfig     The user's configured model for this phase (ceiling)
- * @param routingConfig   Dynamic routing configuration
- * @param availableModelIds  List of available model IDs (from registry)
- */
-export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds) {
-    // If no phase config or routing disabled, pass through
-    if (!phaseConfig || !routingConfig.enabled) {
-        return {
-            modelId: phaseConfig?.primary ?? "",
-            fallbacks: phaseConfig?.fallbacks ?? [],
-            tier: classification.tier,
-            wasDowngraded: false,
-            reason: "dynamic routing disabled or no phase config",
-        };
-    }
-    const configuredPrimary = phaseConfig.primary;
-    const configuredTier = getModelTier(configuredPrimary);
-    const requestedTier = classification.tier;
-    // Downgrade-only: if requested tier >= configured tier, no change
-    if (tierOrdinal(requestedTier) >= tierOrdinal(configuredTier)) {
-        return {
-            modelId: configuredPrimary,
-            fallbacks: phaseConfig.fallbacks,
-            tier: requestedTier,
-            wasDowngraded: false,
-            reason: `tier ${requestedTier} >= configured ${configuredTier}`,
-        };
-    }
-    // Find the best model for the requested tier
-    const targetModelId = findModelForTier(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false);
-    if (!targetModelId) {
-        // No suitable model found — use configured primary
-        return {
-            modelId: configuredPrimary,
-            fallbacks: phaseConfig.fallbacks,
-            tier: requestedTier,
-            wasDowngraded: false,
-            reason: `no ${requestedTier}-tier model available`,
-        };
-    }
-    // Build fallback chain: [downgraded_model, ...configured_fallbacks, configured_primary]
-    const fallbacks = [
-        ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
-        configuredPrimary,
-    ].filter(f => f !== targetModelId);
-    return {
-        modelId: targetModelId,
-        fallbacks,
-        tier: requestedTier,
-        wasDowngraded: true,
-        reason: classification.reason,
-    };
-}
-/**
- * Escalate to the next tier after a failure.
- * Returns the new tier, or null if already at heavy (max).
- */
-export function escalateTier(currentTier) {
-    switch (currentTier) {
-        case "light": return "standard";
-        case "standard": return "heavy";
-        case "heavy": return null;
-    }
-}
-/**
- * Get the default routing config (all features enabled).
- */
-export function defaultRoutingConfig() {
-    return {
-        enabled: false,
-        escalate_on_failure: true,
-        budget_pressure: true,
-        cross_provider: true,
-        hooks: true,
-    };
-}
-// ─── Internal ────────────────────────────────────────────────────────────────
-function getModelTier(modelId) {
-    // Strip provider prefix if present
-    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
-    // Check exact match first
-    if (MODEL_CAPABILITY_TIER[bareId])
-        return MODEL_CAPABILITY_TIER[bareId];
-    // Check if any known model ID is a prefix/suffix match
-    for (const [knownId, tier] of Object.entries(MODEL_CAPABILITY_TIER)) {
-        if (bareId.includes(knownId) || knownId.includes(bareId))
-            return tier;
-    }
-    // Unknown models are assumed heavy (safest assumption)
-    return "heavy";
-}
-function findModelForTier(tier, config, availableModelIds, crossProvider) {
-    // 1. Check explicit tier_models config
-    const explicitModel = config.tier_models?.[tier];
-    if (explicitModel && availableModelIds.includes(explicitModel)) {
-        return explicitModel;
-    }
-    // Also check with provider prefix stripped
-    if (explicitModel) {
-        const match = availableModelIds.find(id => {
-            const bareAvail = id.includes("/") ? id.split("/").pop() : id;
-            const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop() : explicitModel;
-            return bareAvail === bareExplicit;
-        });
-        if (match)
-            return match;
-    }
-    // 2. Auto-detect: find the cheapest available model in the requested tier
-    const candidates = availableModelIds
-        .filter(id => {
-        const modelTier = getModelTier(id);
-        return modelTier === tier;
-    })
-        .sort((a, b) => {
-        if (!crossProvider)
-            return 0;
-        const costA = getModelCost(a);
-        const costB = getModelCost(b);
-        return costA - costB;
-    });
-    return candidates[0] ?? null;
-}
-function getModelCost(modelId) {
-    const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
-    if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {
-        return MODEL_COST_PER_1K_INPUT[bareId];
-    }
-    // Check partial matches
-    for (const [knownId, cost] of Object.entries(MODEL_COST_PER_1K_INPUT)) {
-        if (bareId.includes(knownId) || knownId.includes(bareId))
-            return cost;
-    }
-    // Unknown cost — assume expensive to avoid routing to unknown cheap models
-    return 999;
-}

package/dist/resources/extensions/gsd/namespaced-registry.js

@@ -1,322 +0,0 @@
-/**
- * Namespaced Component Registry Module
- *
- * Provides the canonical identity model for imported plugin components.
- * Supports both namespaced (plugin:component) and flat (bare name) components,
- * detects collisions at registration time, and provides lookup by canonical name
- * or namespace listing.
- *
- * This registry serves as the bridge between S01's plugin discovery output
- * and Pi's internal component resolution system.
- */
-// ============================================================================
-// NamespacedRegistry Class
-// ============================================================================
-/**
- * Registry for namespaced plugin components.
- *
- * Features:
- * - Computes canonical names from namespace + name
- * - Detects and reports collisions at registration time
- * - First registration wins; subsequent duplicates return diagnostic
- * - Lookup by canonical name or namespace listing
- * - Compatible with both namespaced and flat (non-namespaced) components
- *
- * Usage:
- * ```typescript
- * const registry = new NamespacedRegistry();
- *
- * // Register a namespaced component
- * const diag = registry.register({
- *   name: 'code-review',
- *   namespace: 'my-plugin',
- *   type: 'skill',
- *   filePath: '/plugins/my-plugin/skills/code-review/SKILL.md',
- *   source: 'plugin:my-plugin',
- *   description: 'Reviews code for quality issues',
- *   metadata: { pluginVersion: '1.0.0' }
- * });
- *
- * // Lookup by canonical name
- * const skill = registry.getByCanonical('my-plugin:code-review');
- *
- * // List all components in a namespace
- * const allSkills = registry.getByNamespace('my-plugin');
- * ```
- */
-export class NamespacedRegistry {
-    /** Internal storage: canonicalName -> component */
-    components = new Map();
-    /** Internal storage: alias -> canonicalName */
-    aliasMap = new Map();
-    /** Collision diagnostics collected during registration */
-    diagnostics = [];
-    /**
-     * Register a component in the registry.
-     *
-     * Computes the canonical name as `${namespace}:${name}` when namespace is present,
-     * or bare `name` otherwise. Returns a diagnostic if the canonical name already exists.
-     *
-     * @param component - Component data (without canonicalName, which is computed)
-     * @returns Diagnostic if collision detected, undefined otherwise
-     */
-    register(component) {
-        // Compute canonical name
-        const canonicalName = component.namespace
-            ? `${component.namespace}:${component.name}`
-            : component.name;
-        // Create full component with canonical name
-        const fullComponent = {
-            ...component,
-            canonicalName,
-        };
-        // Check for collision
-        const existing = this.components.get(canonicalName);
-        if (existing) {
-            const diagnostic = {
-                type: 'collision',
-                message: `canonical name "${canonicalName}" collision`,
-                collision: {
-                    canonicalName,
-                    winnerPath: existing.filePath,
-                    loserPath: component.filePath,
-                    winnerSource: existing.source,
-                    loserSource: component.source,
-                },
-            };
-            this.diagnostics.push(diagnostic);
-            return diagnostic;
-        }
-        // Register the component
-        this.components.set(canonicalName, fullComponent);
-        return undefined;
-    }
-    /**
-     * Get a component by its canonical name.
-     *
-     * @param canonicalName - The canonical name (e.g., "my-plugin:code-review" or "code-review")
-     * @returns The component if found, undefined otherwise
-     */
-    getByCanonical(canonicalName) {
-        return this.components.get(canonicalName);
-    }
-    /**
-     * Get all components belonging to a specific namespace.
-     *
-     * @param namespace - The namespace to filter by (e.g., "my-plugin")
-     * @returns Array of components in that namespace
-     */
-    getByNamespace(namespace) {
-        const results = [];
-        for (const component of this.components.values()) {
-            if (component.namespace === namespace) {
-                results.push(component);
-            }
-        }
-        return results;
-    }
-    /**
-     * Get all registered components.
-     *
-     * @returns Array of all components
-     */
-    getAll() {
-        return Array.from(this.components.values());
-    }
-    /**
-     * Get all diagnostics collected during registration.
-     *
-     * Returns deep copies to prevent external mutation of internal state.
-     *
-     * @returns Array of diagnostics (collisions, etc.)
-     */
-    getDiagnostics() {
-        return this.diagnostics.map((d) => ({
-            type: d.type,
-            message: d.message,
-            collision: { ...d.collision },
-        }));
-    }
-    /**
-     * Check if a canonical name is already registered.
-     *
-     * @param canonicalName - The canonical name to check
-     * @returns true if registered, false otherwise
-     */
-    has(canonicalName) {
-        return this.components.has(canonicalName);
-    }
-    /**
-     * Get the count of registered components.
-     *
-     * @returns Number of components
-     */
-    get size() {
-        return this.components.size;
-    }
-    // ============================================================================
-    // Alias Management
-    // ============================================================================
-    /**
-     * Register an alias for a canonical name.
-     *
-     * Validates:
-     * 1. The target canonical name must exist
-     * 2. The alias cannot shadow an existing canonical name
-     * 3. The alias cannot already exist pointing to a different target
-     *
-     * @param alias - The short alias (e.g., "py3d")
-     * @param canonicalName - The target canonical name (e.g., "python-tools:3d-visualizer")
-     * @returns Result indicating success or failure with reason
-     */
-    registerAlias(alias, canonicalName) {
-        // Check that target canonical name exists
-        if (!this.components.has(canonicalName)) {
-            return {
-                success: false,
-                reason: 'canonical-not-found',
-                message: `Cannot create alias "${alias}": target canonical name "${canonicalName}" does not exist`,
-            };
-        }
-        // Check that alias doesn't shadow an existing canonical name
-        if (this.components.has(alias)) {
-            return {
-                success: false,
-                reason: 'shadows-canonical',
-                message: `Cannot create alias "${alias}": it shadows an existing canonical name`,
-            };
-        }
-        // Check for duplicate alias pointing to different target
-        const existingTarget = this.aliasMap.get(alias);
-        if (existingTarget !== undefined && existingTarget !== canonicalName) {
-            return {
-                success: false,
-                reason: 'duplicate-alias',
-                message: `Cannot create alias "${alias}": already exists pointing to "${existingTarget}"`,
-            };
-        }
-        // Register the alias (idempotent if same target)
-        this.aliasMap.set(alias, canonicalName);
-        return { success: true };
-    }
-    /**
-     * Remove an alias.
-     *
-     * @param alias - The alias to remove
-     * @returns true if the alias existed and was removed, false otherwise
-     */
-    removeAlias(alias) {
-        return this.aliasMap.delete(alias);
-    }
-    /**
-     * Resolve an alias to its canonical name.
-     *
-     * @param alias - The alias to resolve
-     * @returns The canonical name if alias exists, undefined otherwise
-     */
-    resolveAlias(alias) {
-        return this.aliasMap.get(alias);
-    }
-    /**
-     * Get all registered aliases.
-     *
-     * @returns A copy of the alias map (alias -> canonicalName)
-     */
-    getAliases() {
-        return new Map(this.aliasMap);
-    }
-    /**
-     * Check if an alias exists.
-     *
-     * @param alias - The alias to check
-     * @returns true if the alias exists, false otherwise
-     */
-    hasAlias(alias) {
-        return this.aliasMap.has(alias);
-    }
-}
-// ============================================================================
-// Discovery Bridge Helper
-// ============================================================================
-/**
- * Convert a discovered plugin's inventory into registerable component entries.
- *
- * This helper bridges S01's discovery output (DiscoveredPlugin) with the
- * namespaced registry. It maps skill and agent directory names to component
- * entries with the plugin's namespace.
- *
- * @param plugin - A discovered plugin from S01's discovery process
- * @returns Array of registerable component entries (without canonicalName)
- */
-export function componentsFromDiscovery(plugin) {
-    const components = [];
-    // Use the plugin's canonical name as the namespace
-    const namespace = plugin.canonicalName;
-    // Extract common metadata from the plugin
-    const commonMetadata = {
-        pluginVersion: plugin.version,
-        pluginAuthor: plugin.author?.name,
-        pluginHomepage: plugin.homepage,
-        pluginCategory: plugin.category,
-    };
-    // Process skills
-    for (const skillName of plugin.inventory.skills) {
-        // Resolve the skill file path
-        // Skills are in <plugin>/skills/<name>/SKILL.md or <plugin>/skills/<name>.md
-        let filePath;
-        if (plugin.resolvedPath) {
-            const skillDirPath = `${plugin.resolvedPath}/skills/${skillName}`;
-            // Prefer direct markdown file entries, otherwise directory with SKILL.md
-            filePath = skillName.endsWith('.md')
-                ? `${plugin.resolvedPath}/skills/${skillName}`
-                : `${skillDirPath}/SKILL.md`;
-        }
-        else {
-            // External plugin - use placeholder path
-            filePath = `<external>/${namespace}/skills/${skillName}/SKILL.md`;
-        }
-        components.push({
-            name: skillName.replace(/\.md$/, ''), // Strip .md if present
-            namespace,
-            type: 'skill',
-            filePath,
-            source: `plugin:${namespace}`,
-            description: undefined, // Would require reading the file
-            metadata: {
-                ...commonMetadata,
-                componentDir: skillName,
-            },
-        });
-    }
-    // Process agents
-    for (const agentName of plugin.inventory.agents) {
-        // Resolve the agent file path
-        let filePath;
-        if (plugin.resolvedPath) {
-            const agentDirPath = `${plugin.resolvedPath}/agents/${agentName}`;
-            filePath = agentName.endsWith('.md')
-                ? `${plugin.resolvedPath}/agents/${agentName}`
-                : `${agentDirPath}/AGENT.md`;
-        }
-        else {
-            filePath = `<external>/${namespace}/agents/${agentName}/AGENT.md`;
-        }
-        components.push({
-            name: agentName.replace(/\.md$/, ''), // Strip .md if present
-            namespace,
-            type: 'agent',
-            filePath,
-            source: `plugin:${namespace}`,
-            description: undefined, // Would require reading the file
-            metadata: {
-                ...commonMetadata,
-                componentDir: agentName,
-            },
-        });
-    }
-    return components;
-}
-// ============================================================================
-// Exports
-// ============================================================================
-export default NamespacedRegistry;