@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/agentpack/stores.js

@@ -1,554 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listUserLibraryAgents = listUserLibraryAgents;
-exports.isWorkspaceAgentAvailable = isWorkspaceAgentAvailable;
-exports.isAgentInUserLibrary = isAgentInUserLibrary;
-exports.hydrateFromUserLibrary = hydrateFromUserLibrary;
-exports.promoteToUserLibrary = promoteToUserLibrary;
-exports.readAgentSource = readAgentSource;
-exports.checkForUpdate = checkForUpdate;
-exports.updateFromUserLibrary = updateFromUserLibrary;
-exports.duplicateAgent = duplicateAgent;
-exports.resetDefaultAgent = resetDefaultAgent;
-/**
- * Agent Stores: User Agent Library (UAL) and Hydration Logic
- *
- * Implements the local-first storage model from AgentStores.md:
- * - Workspace Agent Store (WAS): .agentide/agents/<agentId>/ (authoritative)
- * - User Agent Library (UAL): ${AGENTHIPPO_HOME}/agents/<agentId>/<version>/ (shared)
- * - Hydration: Pull-only copy from UAL when workspace agent is missing/empty
- */
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const utils_1 = require("../utils");
-const paths_1 = require("./paths");
-const manifest_1 = require("./manifest");
-const branding_1 = require("../branding");
-// -----------------------------------------------------------------------------
-// Version Utilities
-// -----------------------------------------------------------------------------
-/**
- * Compare two semver-like version strings.
- * Returns: negative if a < b, 0 if equal, positive if a > b
- */
-function compareSemver(a, b) {
-    const parseVersion = (v) => {
-        // Extract numeric parts, treating non-numeric as 0
-        return v.split('.').map(part => {
-            const num = parseInt(part, 10);
-            return isNaN(num) ? 0 : num;
-        });
-    };
-    const aParts = parseVersion(a);
-    const bParts = parseVersion(b);
-    const maxLen = Math.max(aParts.length, bParts.length);
-    for (let i = 0; i < maxLen; i++) {
-        const aVal = aParts[i] ?? 0;
-        const bVal = bParts[i] ?? 0;
-        if (aVal !== bVal) {
-            return aVal - bVal;
-        }
-    }
-    return 0;
-}
-/**
- * Sort versions in ascending semver order.
- */
-function sortVersions(versions) {
-    return [...versions].sort(compareSemver);
-}
-/**
- * Copy a directory recursively, excluding dot-directories (like .claude, .codex).
- * Used for UAL promotion to ensure only source-of-truth content is copied.
- */
-async function copyDirExcludingDotDirs(sourceDir, targetDir) {
-    await fs_1.promises.mkdir(targetDir, { recursive: true });
-    const entries = await fs_1.promises.readdir(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const srcPath = path.join(sourceDir, entry.name);
-        const dstPath = path.join(targetDir, entry.name);
-        if (entry.isDirectory()) {
-            // Skip dot-directories (derived dirs like .claude, .codex)
-            if (entry.name.startsWith('.')) {
-                continue;
-            }
-            await copyDirExcludingDotDirs(srcPath, dstPath);
-        }
-        else {
-            await fs_1.promises.copyFile(srcPath, dstPath);
-        }
-    }
-}
-// -----------------------------------------------------------------------------
-// User Agent Library Operations
-// -----------------------------------------------------------------------------
-/**
- * List all agents in the User Agent Library.
- */
-async function listUserLibraryAgents() {
-    const agentsDir = (0, paths_1.getUserAgentsDir)();
-    if (!(await (0, utils_1.pathExists)(agentsDir))) {
-        return [];
-    }
-    const entries = await fs_1.promises.readdir(agentsDir, { withFileTypes: true });
-    const agents = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith('.')) {
-            continue;
-        }
-        const agentId = entry.name;
-        const agentRoot = (0, paths_1.getUserAgentRoot)(agentId);
-        const versions = await listAgentVersions(agentRoot);
-        if (versions.length === 0) {
-            continue;
-        }
-        const currentVersion = await readCurrentVersion(agentId);
-        // Load metadata from current or latest version
-        const metadataVersion = currentVersion || versions[versions.length - 1];
-        const versionDir = (0, paths_1.getUserAgentVersionDir)(agentId, metadataVersion);
-        const manifestPath = path.join(versionDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
-        let description;
-        let preferredEngine;
-        try {
-            const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
-            description = manifest.metadata.description;
-            preferredEngine = manifest.spec.engine;
-        }
-        catch {
-            // Ignore - use defaults
-        }
-        agents.push({
-            id: agentId,
-            versions,
-            currentVersion,
-            description,
-            preferredEngine,
-        });
-    }
-    return agents;
-}
-/**
- * List available versions for an agent in the UAL.
- * Returns versions sorted in ascending semver order.
- */
-async function listAgentVersions(agentRoot) {
-    try {
-        const entries = await fs_1.promises.readdir(agentRoot, { withFileTypes: true });
-        const versions = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.')) {
-                continue;
-            }
-            // Check if this looks like a version (has valid agent.yaml)
-            const manifestPath = path.join(agentRoot, entry.name, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
-            if (await (0, utils_1.pathExists)(manifestPath)) {
-                // Validate manifest is parseable
-                try {
-                    await (0, manifest_1.loadAgentManifest)(manifestPath);
-                    versions.push(entry.name);
-                }
-                catch {
-                    // Invalid manifest - skip this version
-                }
-            }
-        }
-        // Sort versions using proper semver comparison
-        return sortVersions(versions);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Read the current version pointer for an agent in the UAL.
- * Validates that the version directory contains a valid agent.yaml.
- */
-async function readCurrentVersion(agentId) {
-    const currentPath = (0, paths_1.getUserAgentCurrentPath)(agentId);
-    try {
-        const version = (await fs_1.promises.readFile(currentPath, 'utf8')).trim();
-        if (!version) {
-            return undefined;
-        }
-        // Validate version has a valid agent.yaml
-        const versionDir = (0, paths_1.getUserAgentVersionDir)(agentId, version);
-        const manifestPath = path.join(versionDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
-        if (!(await (0, utils_1.pathExists)(manifestPath))) {
-            return undefined;
-        }
-        // Validate manifest is parseable
-        try {
-            await (0, manifest_1.loadAgentManifest)(manifestPath);
-            return version;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    catch {
-        // No current.txt or invalid
-    }
-    return undefined;
-}
-// -----------------------------------------------------------------------------
-// Hydration: Copy from UAL to Workspace
-// -----------------------------------------------------------------------------
-/**
- * Check if a workspace agent is available (has valid agent.yaml).
- */
-async function isWorkspaceAgentAvailable(workspaceRoot, agentId) {
-    const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agentId);
-    if (!(await (0, utils_1.pathExists)(manifestPath))) {
-        return false;
-    }
-    try {
-        const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
-        return manifest.metadata.name === agentId;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if an agent is available in the User Agent Library.
- */
-async function isAgentInUserLibrary(agentId) {
-    const currentVersion = await readCurrentVersion(agentId);
-    if (currentVersion) {
-        return true;
-    }
-    // Check if any versions exist
-    const agentRoot = (0, paths_1.getUserAgentRoot)(agentId);
-    const versions = await listAgentVersions(agentRoot);
-    return versions.length > 0;
-}
-/**
- * Hydrate an agent from the User Agent Library into the workspace.
- * Only called when workspace agent is missing/empty.
- *
- * @param workspaceRoot - Workspace root path
- * @param agentId - Agent ID to hydrate
- * @param version - Specific version (or undefined for current/latest)
- * @param outputChannel - Output channel for logging
- * @returns The hydrated version, or undefined if hydration failed
- */
-async function hydrateFromUserLibrary(workspaceRoot, agentId, version, outputChannel) {
-    // Resolve version
-    let resolvedVersion = version;
-    let resolvedFrom = version ?? 'current';
-    if (!resolvedVersion) {
-        resolvedVersion = await readCurrentVersion(agentId);
-        if (!resolvedVersion) {
-            // Fall back to latest version
-            const agentRoot = (0, paths_1.getUserAgentRoot)(agentId);
-            const versions = await listAgentVersions(agentRoot);
-            if (versions.length === 0) {
-                (0, utils_1.logInfo)(outputChannel, `[AgentStores] Agent not in User Library: ${agentId}`);
-                return undefined;
-            }
-            resolvedVersion = versions[versions.length - 1];
-            resolvedFrom = resolvedVersion;
-        }
-    }
-    const sourceDir = (0, paths_1.getUserAgentVersionDir)(agentId, resolvedVersion);
-    if (!(await (0, utils_1.pathExists)(sourceDir))) {
-        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Version not found in User Library: ${agentId}@${resolvedVersion}`);
-        return undefined;
-    }
-    const targetDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Hydrating ${agentId}@${resolvedVersion} from User Library`);
-    // Clear target directory if it exists to avoid mixed/dirty state
-    if (await (0, utils_1.pathExists)(targetDir)) {
-        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Clearing existing directory: ${targetDir}`);
-        await fs_1.promises.rm(targetDir, { recursive: true, force: true });
-    }
-    // Copy agent to workspace
-    await (0, utils_1.copyDirRecursive)(sourceDir, targetDir);
-    // Write provenance file
-    const manifestPath = path.join(targetDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
-    const { sha256 } = await (0, utils_1.readFileSha256)(manifestPath);
-    const source = {
-        source: 'user-library',
-        agentId,
-        version: resolvedVersion,
-        resolvedFrom,
-        sha256,
-        hydratedAt: new Date().toISOString(),
-    };
-    const sourcePath = path.join(targetDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE);
-    await fs_1.promises.writeFile(sourcePath, JSON.stringify(source, null, 2), 'utf8');
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Hydrated ${agentId}@${resolvedVersion} to ${targetDir}`);
-    return resolvedVersion;
-}
-// -----------------------------------------------------------------------------
-// Promote: Copy from Workspace to UAL
-// -----------------------------------------------------------------------------
-/**
- * Promote (share) a workspace agent to the User Agent Library.
- *
- * @param workspaceRoot - Workspace root path
- * @param agentId - Agent ID to promote
- * @param outputChannel - Output channel for logging
- * @returns The promoted version, or throws on conflict
- */
-async function promoteToUserLibrary(workspaceRoot, agentId, outputChannel) {
-    // Cannot promote the default agent
-    if (agentId === paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID) {
-        throw new Error('Cannot promote the default agent to User Library');
-    }
-    const sourceDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
-    const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, agentId);
-    if (!(await (0, utils_1.pathExists)(manifestPath))) {
-        throw new Error(`Agent not found: ${agentId}`);
-    }
-    // Load manifest to get version
-    const manifest = await (0, manifest_1.loadAgentManifest)(manifestPath);
-    const version = manifest.metadata.version;
-    const targetDir = (0, paths_1.getUserAgentVersionDir)(agentId, version);
-    const targetManifestPath = path.join(targetDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
-    // Check for version conflict
-    if (await (0, utils_1.pathExists)(targetManifestPath)) {
-        const sourceHash = await (0, utils_1.readFileSha256)(manifestPath);
-        const targetHash = await (0, utils_1.readFileSha256)(targetManifestPath);
-        if (sourceHash.sha256 === targetHash.sha256) {
-            (0, utils_1.logInfo)(outputChannel, `[AgentStores] ${agentId}@${version} already in User Library (identical)`);
-            return version;
-        }
-        throw new Error(`Version conflict: ${agentId}@${version} already exists in User Library with different content. ` +
-            `Bump the version in agent.yaml and try again.`);
-    }
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Promoting ${agentId}@${version} to User Library`);
-    // Ensure UAL directories exist
-    await fs_1.promises.mkdir(targetDir, { recursive: true });
-    // Copy agent to UAL (excluding dot-dirs like .claude, .codex)
-    await copyDirExcludingDotDirs(sourceDir, targetDir);
-    // Update current.txt pointer
-    const currentPath = (0, paths_1.getUserAgentCurrentPath)(agentId);
-    await fs_1.promises.writeFile(currentPath, version, 'utf8');
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Promoted ${agentId}@${version} to ${targetDir}`);
-    return version;
-}
-// -----------------------------------------------------------------------------
-// Update: Pull new version from UAL to Workspace
-// -----------------------------------------------------------------------------
-/**
- * Read the provenance of a workspace agent.
- */
-async function readAgentSource(workspaceRoot, agentId) {
-    const sourcePath = path.join((0, paths_1.getAgentRoot)(workspaceRoot, agentId), paths_1.AGENT_CONSTANTS.SOURCE_FILE);
-    try {
-        const content = await fs_1.promises.readFile(sourcePath, 'utf8');
-        return JSON.parse(content);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Check if an update is available from the User Agent Library.
- * Returns the UAL's current version if it differs from the workspace version.
- *
- * @returns The new version if available, undefined otherwise
- */
-async function checkForUpdate(workspaceRoot, agentId) {
-    const source = await readAgentSource(workspaceRoot, agentId);
-    if (!source || source.source !== 'user-library') {
-        return undefined;
-    }
-    const ualCurrentVersion = await readCurrentVersion(agentId);
-    if (!ualCurrentVersion) {
-        return undefined;
-    }
-    // Check if UAL has a different version than what we hydrated
-    // Note: This is a simple check - doesn't determine if it's newer or older
-    if (ualCurrentVersion !== source.version) {
-        return ualCurrentVersion;
-    }
-    return undefined;
-}
-/**
- * Update a workspace agent from the User Agent Library.
- * Creates a backup before updating.
- *
- * @param workspaceRoot - Workspace root path
- * @param agentId - Agent ID to update
- * @param version - Specific version (or undefined for current)
- * @param outputChannel - Output channel for logging
- * @returns The updated version
- */
-async function updateFromUserLibrary(workspaceRoot, agentId, version, outputChannel) {
-    const agentDir = (0, paths_1.getAgentRoot)(workspaceRoot, agentId);
-    // Create backup
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupDir = path.join(path.dirname(agentDir), `.${agentId}.backup-${timestamp}`);
-    if (await (0, utils_1.pathExists)(agentDir)) {
-        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Backing up ${agentId} to ${backupDir}`);
-        await (0, utils_1.copyDirRecursive)(agentDir, backupDir);
-        await fs_1.promises.rm(agentDir, { recursive: true, force: true });
-    }
-    // Hydrate new version
-    const hydratedVersion = await hydrateFromUserLibrary(workspaceRoot, agentId, version, outputChannel);
-    if (!hydratedVersion) {
-        // Restore backup
-        if (await (0, utils_1.pathExists)(backupDir)) {
-            (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restoring backup after failed update`);
-            await (0, utils_1.copyDirRecursive)(backupDir, agentDir);
-        }
-        throw new Error(`Failed to update ${agentId} from User Library`);
-    }
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Updated ${agentId} to ${hydratedVersion}`);
-    return hydratedVersion;
-}
-// -----------------------------------------------------------------------------
-// Duplicate: Create a copy of an agent with new ID
-// -----------------------------------------------------------------------------
-/**
- * Generate a unique agent ID by appending a suffix.
- */
-async function generateUniqueAgentId(workspaceRoot, baseId) {
-    // First try <baseId>-copy
-    const copyId = `${baseId}-copy`;
-    if (!(await (0, utils_1.pathExists)((0, paths_1.getAgentRoot)(workspaceRoot, copyId)))) {
-        return copyId;
-    }
-    // Then try <baseId>-2, <baseId>-3, etc.
-    for (let i = 2; i < 100; i++) {
-        const suffixedId = `${baseId}-${i}`;
-        if (!(await (0, utils_1.pathExists)((0, paths_1.getAgentRoot)(workspaceRoot, suffixedId)))) {
-            return suffixedId;
-        }
-    }
-    // Fallback: use timestamp
-    return `${baseId}-${Date.now()}`;
-}
-/**
- * Duplicate a workspace agent with a new ID.
- *
- * @param workspaceRoot - Workspace root path
- * @param sourceAgentId - Agent ID to duplicate
- * @param outputChannel - Output channel for logging
- * @returns The new agent ID
- */
-async function duplicateAgent(workspaceRoot, sourceAgentId, outputChannel) {
-    const sourceAgentDir = (0, paths_1.getAgentRoot)(workspaceRoot, sourceAgentId);
-    const manifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, sourceAgentId);
-    if (!(await (0, utils_1.pathExists)(manifestPath))) {
-        throw new Error(`Agent not found: ${sourceAgentId}`);
-    }
-    const newAgentId = await generateUniqueAgentId(workspaceRoot, sourceAgentId);
-    const targetDir = (0, paths_1.getAgentRoot)(workspaceRoot, newAgentId);
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Duplicating ${sourceAgentId} to ${newAgentId}`);
-    // Copy agent (excluding dot-dirs like .claude, .codex)
-    await copyDirExcludingDotDirs(sourceAgentDir, targetDir);
-    // Update metadata.name in agent.yaml using proper YAML handling
-    const newManifestPath = (0, paths_1.getAgentManifestPath)(workspaceRoot, newAgentId);
-    await (0, manifest_1.updateManifestName)(newManifestPath, newAgentId);
-    // Mark as locally created (remove provenance file if exists)
-    const sourcePath = path.join(targetDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE);
-    try {
-        await fs_1.promises.rm(sourcePath, { force: true });
-    }
-    catch {
-        // Ignore
-    }
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Duplicated ${sourceAgentId} to ${newAgentId}`);
-    return newAgentId;
-}
-// -----------------------------------------------------------------------------
-// Reset: Restore default agent from bundled templates
-// -----------------------------------------------------------------------------
-/**
- * Reset the default agent from bundled templates.
- * Creates a backup before resetting.
- *
- * @param workspaceRoot - Workspace root path
- * @param bundledDir - Bundled base prompts directory
- * @param outputChannel - Output channel for logging
- */
-async function resetDefaultAgent(workspaceRoot, bundledDir, outputChannel) {
-    const defaultAgentDir = (0, paths_1.getAgentRoot)(workspaceRoot, paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID);
-    // Create backup
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupDir = path.join(path.dirname(defaultAgentDir), `.default.backup-${timestamp}`);
-    if (await (0, utils_1.pathExists)(defaultAgentDir)) {
-        (0, utils_1.logInfo)(outputChannel, `[AgentStores] Backing up default agent to ${backupDir}`);
-        await (0, utils_1.copyDirRecursive)(defaultAgentDir, backupDir);
-        await fs_1.promises.rm(defaultAgentDir, { recursive: true, force: true });
-    }
-    // Create fresh default agent structure
-    await fs_1.promises.mkdir(defaultAgentDir, { recursive: true });
-    await fs_1.promises.mkdir(path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.RULES_DIR), { recursive: true });
-    await fs_1.promises.mkdir(path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.SKILLS_DIR), { recursive: true });
-    // Copy bundled AGENTS.md if available (with branding tokens applied)
-    if (bundledDir) {
-        const bundledAgentsFile = path.join(bundledDir, 'rules', 'AGENTS.md');
-        const targetAgentsFile = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.AGENTS_MD);
-        if (await (0, utils_1.pathExists)(bundledAgentsFile)) {
-            const content = await fs_1.promises.readFile(bundledAgentsFile, 'utf8');
-            await fs_1.promises.writeFile(targetAgentsFile, (0, branding_1.applyBrandingTokens)(content), 'utf8');
-            (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restored AGENTS.md from bundled templates`);
-        }
-        // Copy bundled GHOST_TEXT.md (inline completions prompt) if available
-        const bundledGhostTextFile = path.join(bundledDir, paths_1.AGENT_CONSTANTS.GHOST_TEXT_FILE);
-        const targetGhostTextFile = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.GHOST_TEXT_FILE);
-        if (await (0, utils_1.pathExists)(bundledGhostTextFile) && !(await (0, utils_1.pathExists)(targetGhostTextFile))) {
-            const content = await fs_1.promises.readFile(bundledGhostTextFile, 'utf8');
-            await fs_1.promises.writeFile(targetGhostTextFile, content, 'utf8');
-            (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restored GHOST_TEXT.md from bundled templates`);
-        }
-        // Copy bundled skills (with branding tokens applied to markdown files)
-        const bundledSkillsDir = path.join(bundledDir, 'skills');
-        if (await (0, utils_1.pathExists)(bundledSkillsDir)) {
-            const entries = await fs_1.promises.readdir(bundledSkillsDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory()) {
-                    continue;
-                }
-                const srcSkill = path.join(bundledSkillsDir, entry.name);
-                const dstSkill = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.SKILLS_DIR, entry.name);
-                await (0, utils_1.copyDirRecursiveWithTransform)(srcSkill, dstSkill, branding_1.applyBrandingTokens);
-                (0, utils_1.logInfo)(outputChannel, `[AgentStores] Restored skill: ${entry.name}`);
-            }
-        }
-    }
-    const defaultAgentYaml = (0, paths_1.generateDefaultAgentYaml)({ model: 'claude' });
-    const agentYamlPath = path.join(defaultAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
-    await fs_1.promises.writeFile(agentYamlPath, defaultAgentYaml, 'utf8');
-    (0, utils_1.logInfo)(outputChannel, `[AgentStores] Reset default agent complete`);
-}

package/out/analytics/dashboard/fleetStatusUtils.js

@@ -1,30 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeFleetStatusFromTimes = normalizeFleetStatusFromTimes;
-exports.renormalizeFleetRowStatus = renormalizeFleetRowStatus;
-const FUTURE_START_SCHEDULED_MS = 60_000;
-const RECENT_END_IN_PROGRESS_MS = 90_000;
-function normalizeFleetStatusFromTimes(startedAt, endedAt, now = Date.now()) {
-    const startedMs = Date.parse(startedAt);
-    const endedMs = Date.parse(endedAt);
-    if (Number.isFinite(startedMs) && startedMs > now + FUTURE_START_SCHEDULED_MS) {
-        return 'scheduled';
-    }
-    if (!Number.isFinite(endedMs) || endedMs <= 0 || (Number.isFinite(startedMs) && endedMs < startedMs)) {
-        return 'in_progress';
-    }
-    if (endedMs > now - RECENT_END_IN_PROGRESS_MS) {
-        return 'in_progress';
-    }
-    return 'done';
-}
-/** Recompute status for rows already in fleet_sessions (light refresh without span queries). */
-function renormalizeFleetRowStatus(row, now = Date.now()) {
-    if (row.status === 'scheduled') {
-        return;
-    }
-    row.status = normalizeFleetStatusFromTimes(row.startedAt, row.endedAt, now);
-}

package/out/analytics/dashboard/fleetTitleUtils.js

@@ -1,68 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGenericFleetTitle = isGenericFleetTitle;
-exports.pickPreferredFleetTitle = pickPreferredFleetTitle;
-exports.resolveFleetDisplayTitle = resolveFleetDisplayTitle;
-exports.resolveFleetCardTitleForPersist = resolveFleetCardTitleForPersist;
-const GENERIC_TASK_TITLES = new Set(['task', 'scheduled task']);
-/**
- * True when a fleet title is an empty/id placeholder, not a user-facing label.
- */
-function isGenericFleetTitle(title, sessionId, agentId) {
-    const normalized = String(title ?? '').trim();
-    if (!normalized) {
-        return true;
-    }
-    const sid = String(sessionId ?? '').trim();
-    if (sid && normalized === sid) {
-        return true;
-    }
-    const aid = String(agentId ?? '').trim();
-    if (aid && normalized === aid) {
-        return true;
-    }
-    return GENERIC_TASK_TITLES.has(normalized.toLowerCase());
-}
-/**
- * Pick the first non-generic title from candidates; otherwise fall back to session id / Task.
- */
-function pickPreferredFleetTitle(candidates, sessionId, agentId) {
-    for (const candidate of candidates) {
-        const value = String(candidate ?? '').trim();
-        if (value && !isGenericFleetTitle(value, sessionId, agentId)) {
-            return value;
-        }
-    }
-    const sid = String(sessionId ?? '').trim();
-    return sid || 'Task';
-}
-/**
- * Display title for fleet cards: ignore card_title when it is only the session id.
- */
-function resolveFleetDisplayTitle(input) {
-    const sessionId = String(input.sessionId ?? '').trim();
-    const agentId = String(input.agentId ?? '').trim() || undefined;
-    return pickPreferredFleetTitle([input.cardTitle, input.taskTitle, agentId, sessionId], sessionId, agentId);
-}
-/**
- * Whether a user edit should be persisted to card_title (reject accidental uuid commits).
- */
-function resolveFleetCardTitleForPersist(input) {
-    const sessionId = String(input.sessionId ?? '').trim();
-    const agentId = String(input.agentId ?? '').trim() || undefined;
-    const edited = String(input.editedTitle ?? '').trim();
-    const taskTitle = String(input.taskTitle ?? '').trim();
-    if (!edited) {
-        return '';
-    }
-    if (!isGenericFleetTitle(edited, sessionId, agentId)) {
-        return edited;
-    }
-    if (taskTitle && !isGenericFleetTitle(taskTitle, sessionId, agentId)) {
-        return '';
-    }
-    return edited;
-}

package/out/analytics/dashboard/refreshPolicy.js

@@ -1,16 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldRunScriptsOnNavigation = shouldRunScriptsOnNavigation;
-/**
- * Spotlight refresh policy for navigation (view switch).
- * @see PLAN/spotlight-refresh-policy.md
- */
-function shouldRunScriptsOnNavigation(viewId, artifactTypes) {
-    if (viewId === 'fleet') {
-        return true;
-    }
-    return !artifactTypes.some(type => type === 'chart');
-}