@agenthippo-ai/agenthippo 0.1.0

package/out/test/stores.test.js

@@ -0,0 +1,504 @@
+"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 });
+require("mocha");
+const assert = __importStar(require("assert"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs_1 = require("fs");
+const stores_1 = require("../agentpack/stores");
+const paths_1 = require("../agentpack/paths");
+const manifest_fixtures_1 = require("./helpers/manifest-fixtures");
+// =============================================================================
+// Test Utilities
+// =============================================================================
+/** Mock OutputChannel that captures log messages */
+class MockOutputChannel {
+    lines = [];
+    name = 'MockOutput';
+    appendLine(value) {
+        this.lines.push(value);
+    }
+    append(value) {
+        this.lines.push(value);
+    }
+    clear() {
+        this.lines = [];
+    }
+    show() { }
+    hide() { }
+    dispose() { }
+    replace(_value) { }
+}
+/** Create a minimal valid agent.yaml content */
+function createAgentYaml(name, version, engine = 'claude') {
+    return (0, manifest_fixtures_1.createTestAgentYaml)({
+        name,
+        version,
+        engine,
+        quoteVersion: true,
+        description: 'Test agent',
+        fileAccess: 'workspace-write',
+    });
+}
+/** Create a test agent directory structure */
+async function createTestAgent(baseDir, agentId, version, engine = 'claude') {
+    const agentDir = path.join(baseDir, agentId);
+    await fs_1.promises.mkdir(agentDir, { recursive: true });
+    await fs_1.promises.mkdir(path.join(agentDir, 'rules'), { recursive: true });
+    await fs_1.promises.mkdir(path.join(agentDir, 'skills'), { recursive: true });
+    const manifestPath = path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+    await fs_1.promises.writeFile(manifestPath, createAgentYaml(agentId, version, engine));
+    // Add a sample rule file
+    await fs_1.promises.writeFile(path.join(agentDir, 'rules', 'example.md'), `# Example Rule\nThis is a test rule.`);
+    return agentDir;
+}
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+let testDir;
+let workspaceRoot;
+let ualRoot;
+let outputChannel;
+let originalAgentideHome;
+async function setupTestEnvironment() {
+    // Create temp directories
+    testDir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'agentide-test-'));
+    workspaceRoot = path.join(testDir, 'workspace');
+    ualRoot = path.join(testDir, 'ual');
+    await fs_1.promises.mkdir(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), { recursive: true });
+    await fs_1.promises.mkdir(path.join(ualRoot, 'agents'), { recursive: true });
+    // Set env to use our test UAL
+    originalAgentideHome = process.env.AGENTHIPPO_HOME;
+    process.env.AGENTHIPPO_HOME = ualRoot;
+    outputChannel = new MockOutputChannel();
+}
+async function teardownTestEnvironment() {
+    // Restore env
+    if (originalAgentideHome !== undefined) {
+        process.env.AGENTHIPPO_HOME = originalAgentideHome;
+    }
+    else {
+        delete process.env.AGENTHIPPO_HOME;
+    }
+    // Clean up temp directories
+    try {
+        await fs_1.promises.rm(testDir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+// =============================================================================
+// User Agent Library Tests
+// =============================================================================
+suite('Agent Stores - User Agent Library', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('listUserLibraryAgents returns empty array when no agents', async () => {
+        const agents = await (0, stores_1.listUserLibraryAgents)();
+        assert.deepStrictEqual(agents, []);
+    });
+    test('listUserLibraryAgents lists agents with versions', async () => {
+        // Create agent in UAL with version
+        const agentDir = path.join(ualRoot, 'agents', 'test-agent', '1.0.0');
+        await fs_1.promises.mkdir(agentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('test-agent', '1.0.0'));
+        const agents = await (0, stores_1.listUserLibraryAgents)();
+        assert.strictEqual(agents.length, 1);
+        assert.strictEqual(agents[0].id, 'test-agent');
+        assert.deepStrictEqual(agents[0].versions, ['1.0.0']);
+        assert.strictEqual(agents[0].description, 'Test agent');
+        assert.strictEqual(agents[0].preferredEngine, 'claude');
+    });
+    test('listUserLibraryAgents lists multiple versions', async () => {
+        // Create multiple versions
+        for (const version of ['1.0.0', '1.1.0', '2.0.0']) {
+            const agentDir = path.join(ualRoot, 'agents', 'multi-version', version);
+            await fs_1.promises.mkdir(agentDir, { recursive: true });
+            await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('multi-version', version));
+        }
+        const agents = await (0, stores_1.listUserLibraryAgents)();
+        assert.strictEqual(agents.length, 1);
+        assert.strictEqual(agents[0].id, 'multi-version');
+        assert.deepStrictEqual(agents[0].versions, ['1.0.0', '1.1.0', '2.0.0']);
+    });
+    test('listUserLibraryAgents sorts versions using semver (10.0.0 > 2.0.0)', async () => {
+        // Create versions that would sort incorrectly with string sort
+        for (const version of ['2.0.0', '10.0.0', '1.0.0', '1.10.0', '1.2.0']) {
+            const agentDir = path.join(ualRoot, 'agents', 'semver-test', version);
+            await fs_1.promises.mkdir(agentDir, { recursive: true });
+            await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('semver-test', version));
+        }
+        const agents = await (0, stores_1.listUserLibraryAgents)();
+        assert.strictEqual(agents.length, 1);
+        assert.strictEqual(agents[0].id, 'semver-test');
+        // Should be sorted by semver, not string
+        assert.deepStrictEqual(agents[0].versions, ['1.0.0', '1.2.0', '1.10.0', '2.0.0', '10.0.0']);
+    });
+    test('isAgentInUserLibrary returns true when agent exists', async () => {
+        const agentDir = path.join(ualRoot, 'agents', 'existing-agent', '1.0.0');
+        await fs_1.promises.mkdir(agentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('existing-agent', '1.0.0'));
+        const exists = await (0, stores_1.isAgentInUserLibrary)('existing-agent');
+        assert.strictEqual(exists, true);
+    });
+    test('isAgentInUserLibrary returns false when agent does not exist', async () => {
+        const exists = await (0, stores_1.isAgentInUserLibrary)('non-existent-agent');
+        assert.strictEqual(exists, false);
+    });
+});
+// =============================================================================
+// Workspace Agent Tests
+// =============================================================================
+suite('Agent Stores - Workspace Agents', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('isWorkspaceAgentAvailable returns true for valid agent', async () => {
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'my-agent', '1.0.0');
+        const available = await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, 'my-agent');
+        assert.strictEqual(available, true);
+    });
+    test('isWorkspaceAgentAvailable returns false for missing agent', async () => {
+        const available = await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, 'missing-agent');
+        assert.strictEqual(available, false);
+    });
+    test('isWorkspaceAgentAvailable returns false for agent with mismatched name', async () => {
+        // Create agent directory with different name in manifest
+        const agentDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'wrong-name');
+        await fs_1.promises.mkdir(agentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('different-name', '1.0.0'));
+        const available = await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, 'wrong-name');
+        assert.strictEqual(available, false);
+    });
+});
+// =============================================================================
+// Hydration Tests
+// =============================================================================
+suite('Agent Stores - Hydration', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('hydrateFromUserLibrary copies agent to workspace', async () => {
+        // Create agent in UAL
+        const ualAgentDir = path.join(ualRoot, 'agents', 'hydrate-test', '1.0.0');
+        await fs_1.promises.mkdir(ualAgentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('hydrate-test', '1.0.0'));
+        await fs_1.promises.mkdir(path.join(ualAgentDir, 'rules'), { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, 'rules', 'test.md'), '# Test Rule');
+        // Hydrate
+        const version = await (0, stores_1.hydrateFromUserLibrary)(workspaceRoot, 'hydrate-test', undefined, outputChannel);
+        assert.strictEqual(version, '1.0.0');
+        // Verify files were copied
+        const wsAgentDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'hydrate-test');
+        const manifestExists = await fs_1.promises.stat(path.join(wsAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE))
+            .then(() => true).catch(() => false);
+        assert.strictEqual(manifestExists, true);
+        const ruleExists = await fs_1.promises.stat(path.join(wsAgentDir, 'rules', 'test.md'))
+            .then(() => true).catch(() => false);
+        assert.strictEqual(ruleExists, true);
+        // Verify provenance file was created
+        const sourceFile = path.join(wsAgentDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE);
+        const sourceExists = await fs_1.promises.stat(sourceFile).then(() => true).catch(() => false);
+        assert.strictEqual(sourceExists, true);
+        const source = JSON.parse(await fs_1.promises.readFile(sourceFile, 'utf8'));
+        assert.strictEqual(source.source, 'user-library');
+        assert.strictEqual(source.agentId, 'hydrate-test');
+        assert.strictEqual(source.version, '1.0.0');
+    });
+    test('hydrateFromUserLibrary uses current.txt pointer', async () => {
+        // Create multiple versions
+        for (const version of ['1.0.0', '2.0.0']) {
+            const agentDir = path.join(ualRoot, 'agents', 'versioned-agent', version);
+            await fs_1.promises.mkdir(agentDir, { recursive: true });
+            await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('versioned-agent', version));
+        }
+        // Set current.txt to point to 2.0.0
+        await fs_1.promises.writeFile(path.join(ualRoot, 'agents', 'versioned-agent', 'current.txt'), '2.0.0');
+        const version = await (0, stores_1.hydrateFromUserLibrary)(workspaceRoot, 'versioned-agent', undefined, outputChannel);
+        assert.strictEqual(version, '2.0.0');
+    });
+    test('hydrateFromUserLibrary returns undefined for non-existent agent', async () => {
+        const version = await (0, stores_1.hydrateFromUserLibrary)(workspaceRoot, 'non-existent', undefined, outputChannel);
+        assert.strictEqual(version, undefined);
+    });
+    test('hydrateFromUserLibrary clears dirty target directory', async () => {
+        // Create a "dirty" agent directory with invalid content
+        const dirtyDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'dirty-agent');
+        await fs_1.promises.mkdir(dirtyDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(dirtyDir, 'leftover.txt'), 'old content');
+        await fs_1.promises.writeFile(path.join(dirtyDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), 'invalid yaml {{{{');
+        // Create valid agent in UAL
+        const ualAgentDir = path.join(ualRoot, 'agents', 'dirty-agent', '1.0.0');
+        await fs_1.promises.mkdir(ualAgentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('dirty-agent', '1.0.0'));
+        // Hydrate should clear the dirty directory
+        const version = await (0, stores_1.hydrateFromUserLibrary)(workspaceRoot, 'dirty-agent', undefined, outputChannel);
+        assert.strictEqual(version, '1.0.0');
+        // Verify leftover file is gone
+        const leftoverExists = await fs_1.promises.stat(path.join(dirtyDir, 'leftover.txt'))
+            .then(() => true).catch(() => false);
+        assert.strictEqual(leftoverExists, false, 'Leftover file should be removed');
+        // Verify new manifest is valid
+        const available = await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, 'dirty-agent');
+        assert.strictEqual(available, true, 'Agent should now be valid');
+    });
+});
+// =============================================================================
+// Promotion Tests
+// =============================================================================
+suite('Agent Stores - Promotion', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('promoteToUserLibrary copies agent to UAL', async () => {
+        // Create workspace agent
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'promote-test', '1.0.0');
+        // Promote
+        const version = await (0, stores_1.promoteToUserLibrary)(workspaceRoot, 'promote-test', outputChannel);
+        assert.strictEqual(version, '1.0.0');
+        // Verify files were copied to UAL
+        const ualAgentDir = path.join(ualRoot, 'agents', 'promote-test', '1.0.0');
+        const manifestExists = await fs_1.promises.stat(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE))
+            .then(() => true).catch(() => false);
+        assert.strictEqual(manifestExists, true);
+        // Verify current.txt was updated
+        const currentPath = path.join(ualRoot, 'agents', 'promote-test', 'current.txt');
+        const current = await fs_1.promises.readFile(currentPath, 'utf8');
+        assert.strictEqual(current, '1.0.0');
+    });
+    test('promoteToUserLibrary throws on default agent', async () => {
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'default', '1.0.0');
+        await assert.rejects((0, stores_1.promoteToUserLibrary)(workspaceRoot, 'default', outputChannel), /Cannot promote the default agent/);
+    });
+    test('promoteToUserLibrary throws on version conflict', async () => {
+        // Create workspace agent
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'conflict-test', '1.0.0');
+        // Create same version in UAL with different content
+        const ualAgentDir = path.join(ualRoot, 'agents', 'conflict-test', '1.0.0');
+        await fs_1.promises.mkdir(ualAgentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('conflict-test', '1.0.0', 'codex') // Different engine
+        );
+        await assert.rejects((0, stores_1.promoteToUserLibrary)(workspaceRoot, 'conflict-test', outputChannel), /Version conflict/);
+    });
+    test('promoteToUserLibrary allows identical re-promotion', async () => {
+        // Create workspace agent
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'same-content', '1.0.0');
+        // Promote once
+        await (0, stores_1.promoteToUserLibrary)(workspaceRoot, 'same-content', outputChannel);
+        // Promote again (same content) - should succeed
+        const version = await (0, stores_1.promoteToUserLibrary)(workspaceRoot, 'same-content', outputChannel);
+        assert.strictEqual(version, '1.0.0');
+    });
+});
+// =============================================================================
+// Update Tests
+// =============================================================================
+suite('Agent Stores - Update', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('checkForUpdate returns new version when available', async () => {
+        // Create workspace agent with provenance
+        const wsAgentDir = await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'update-check', '1.0.0');
+        // Write provenance file
+        await fs_1.promises.writeFile(path.join(wsAgentDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE), JSON.stringify({
+            source: 'user-library',
+            agentId: 'update-check',
+            version: '1.0.0',
+            sha256: 'test-hash',
+            hydratedAt: new Date().toISOString(),
+        }));
+        // Create newer version in UAL
+        const ualAgentDir = path.join(ualRoot, 'agents', 'update-check', '2.0.0');
+        await fs_1.promises.mkdir(ualAgentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('update-check', '2.0.0'));
+        await fs_1.promises.writeFile(path.join(ualRoot, 'agents', 'update-check', 'current.txt'), '2.0.0');
+        const newVersion = await (0, stores_1.checkForUpdate)(workspaceRoot, 'update-check');
+        assert.strictEqual(newVersion, '2.0.0');
+    });
+    test('checkForUpdate returns undefined when no update available', async () => {
+        // Create workspace agent with provenance pointing to current version
+        const wsAgentDir = await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'no-update', '1.0.0');
+        await fs_1.promises.writeFile(path.join(wsAgentDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE), JSON.stringify({
+            source: 'user-library',
+            agentId: 'no-update',
+            version: '1.0.0',
+            sha256: 'test-hash',
+            hydratedAt: new Date().toISOString(),
+        }));
+        // UAL has same version as current
+        const ualAgentDir = path.join(ualRoot, 'agents', 'no-update', '1.0.0');
+        await fs_1.promises.mkdir(ualAgentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('no-update', '1.0.0'));
+        await fs_1.promises.writeFile(path.join(ualRoot, 'agents', 'no-update', 'current.txt'), '1.0.0');
+        const newVersion = await (0, stores_1.checkForUpdate)(workspaceRoot, 'no-update');
+        assert.strictEqual(newVersion, undefined);
+    });
+    test('updateFromUserLibrary creates backup and updates', async () => {
+        // Create workspace agent
+        const wsAgentDir = await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'update-test', '1.0.0');
+        // Add unique file to identify backup
+        await fs_1.promises.writeFile(path.join(wsAgentDir, 'unique.txt'), 'original content');
+        // Create new version in UAL
+        const ualAgentDir = path.join(ualRoot, 'agents', 'update-test', '2.0.0');
+        await fs_1.promises.mkdir(ualAgentDir, { recursive: true });
+        await fs_1.promises.writeFile(path.join(ualAgentDir, paths_1.AGENT_CONSTANTS.MANIFEST_FILE), createAgentYaml('update-test', '2.0.0'));
+        await fs_1.promises.writeFile(path.join(ualRoot, 'agents', 'update-test', 'current.txt'), '2.0.0');
+        // Update
+        const version = await (0, stores_1.updateFromUserLibrary)(workspaceRoot, 'update-test', undefined, outputChannel);
+        assert.strictEqual(version, '2.0.0');
+        // Verify backup was created
+        const agentsDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents');
+        const entries = await fs_1.promises.readdir(agentsDir);
+        const backups = entries.filter(e => e.startsWith('.update-test.backup-'));
+        assert.strictEqual(backups.length, 1, 'Should have created one backup');
+        // Verify backup contains original file
+        const backupDir = path.join(agentsDir, backups[0]);
+        const backupContent = await fs_1.promises.readFile(path.join(backupDir, 'unique.txt'), 'utf8');
+        assert.strictEqual(backupContent, 'original content');
+    });
+});
+// =============================================================================
+// Duplicate Tests
+// =============================================================================
+suite('Agent Stores - Duplicate', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('duplicateAgent creates copy with new ID', async () => {
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'original-agent', '1.0.0');
+        const newId = await (0, stores_1.duplicateAgent)(workspaceRoot, 'original-agent', outputChannel);
+        assert.strictEqual(newId, 'original-agent-copy');
+        // Verify new agent exists
+        const available = await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, newId);
+        assert.strictEqual(available, true);
+        // Verify manifest has new name
+        const manifestPath = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', newId, paths_1.AGENT_CONSTANTS.MANIFEST_FILE);
+        const content = await fs_1.promises.readFile(manifestPath, 'utf8');
+        assert.ok(content.includes(`name: ${newId}`));
+    });
+    test('duplicateAgent uses numeric suffix when -copy exists', async () => {
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'dupe-agent', '1.0.0');
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'dupe-agent-copy', '1.0.0');
+        const newId = await (0, stores_1.duplicateAgent)(workspaceRoot, 'dupe-agent', outputChannel);
+        assert.strictEqual(newId, 'dupe-agent-2');
+    });
+    test('duplicateAgent removes provenance file from copy', async () => {
+        const agentDir = await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'with-provenance', '1.0.0');
+        // Add provenance file
+        await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE), JSON.stringify({ source: 'user-library', agentId: 'with-provenance', version: '1.0.0' }));
+        const newId = await (0, stores_1.duplicateAgent)(workspaceRoot, 'with-provenance', outputChannel);
+        // Verify provenance file was removed from copy
+        const sourceFile = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', newId, paths_1.AGENT_CONSTANTS.SOURCE_FILE);
+        const exists = await fs_1.promises.stat(sourceFile).then(() => true).catch(() => false);
+        assert.strictEqual(exists, false, 'Provenance file should be removed from duplicate');
+    });
+});
+// =============================================================================
+// Reset Default Tests
+// =============================================================================
+suite('Agent Stores - Reset Default', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('resetDefaultAgent creates fresh default agent', async () => {
+        // Create existing default agent with custom content
+        const defaultDir = await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'default', '1.0.0');
+        await fs_1.promises.writeFile(path.join(defaultDir, 'custom.txt'), 'custom content');
+        // Reset without bundled dir
+        await (0, stores_1.resetDefaultAgent)(workspaceRoot, undefined, outputChannel);
+        // Verify backup was created
+        const agentsDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents');
+        const entries = await fs_1.promises.readdir(agentsDir);
+        const backups = entries.filter(e => e.startsWith('.default.backup-'));
+        assert.strictEqual(backups.length, 1, 'Should have created backup');
+        // Verify new default agent exists
+        const available = await (0, stores_1.isWorkspaceAgentAvailable)(workspaceRoot, 'default');
+        assert.strictEqual(available, true);
+        // Verify custom content is gone from default (but in backup)
+        const customExists = await fs_1.promises.stat(path.join(defaultDir, 'custom.txt'))
+            .then(() => true).catch(() => false);
+        assert.strictEqual(customExists, false);
+        const backupCustomExists = await fs_1.promises.stat(path.join(agentsDir, backups[0], 'custom.txt')).then(() => true).catch(() => false);
+        assert.strictEqual(backupCustomExists, true);
+    });
+    test('resetDefaultAgent restores from bundled templates', async () => {
+        // Create bundled templates
+        const bundledDir = path.join(testDir, 'bundled');
+        await fs_1.promises.mkdir(path.join(bundledDir, 'rules'), { recursive: true });
+        await fs_1.promises.mkdir(path.join(bundledDir, 'skills', 'test-skill'), { recursive: true });
+        await fs_1.promises.writeFile(path.join(bundledDir, 'rules', 'AGENTS.md'), '# Bundled AGENTS.md');
+        await fs_1.promises.writeFile(path.join(bundledDir, 'skills', 'test-skill', 'README.md'), '# Test Skill');
+        // Reset with bundled dir
+        await (0, stores_1.resetDefaultAgent)(workspaceRoot, bundledDir, outputChannel);
+        // Verify AGENTS.md was copied
+        const defaultDir = path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents', 'default');
+        const agentsMd = await fs_1.promises.readFile(path.join(defaultDir, paths_1.AGENT_CONSTANTS.AGENTS_MD), 'utf8');
+        assert.strictEqual(agentsMd, '# Bundled AGENTS.md');
+        // Verify skill was copied
+        const skillReadme = await fs_1.promises.readFile(path.join(defaultDir, 'skills', 'test-skill', 'README.md'), 'utf8');
+        assert.strictEqual(skillReadme, '# Test Skill');
+    });
+});
+// =============================================================================
+// Provenance Tests
+// =============================================================================
+suite('Agent Stores - Provenance', () => {
+    setup(setupTestEnvironment);
+    teardown(teardownTestEnvironment);
+    test('readAgentSource returns source info', async () => {
+        const agentDir = await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'provenance-test', '1.0.0');
+        const sourceData = {
+            source: 'user-library',
+            agentId: 'provenance-test',
+            version: '1.0.0',
+            sha256: 'abc123',
+            hydratedAt: '2024-01-01T00:00:00.000Z',
+        };
+        await fs_1.promises.writeFile(path.join(agentDir, paths_1.AGENT_CONSTANTS.SOURCE_FILE), JSON.stringify(sourceData));
+        const source = await (0, stores_1.readAgentSource)(workspaceRoot, 'provenance-test');
+        assert.deepStrictEqual(source, sourceData);
+    });
+    test('readAgentSource returns undefined when no source file', async () => {
+        await createTestAgent(path.join(workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, 'agents'), 'no-source', '1.0.0');
+        const source = await (0, stores_1.readAgentSource)(workspaceRoot, 'no-source');
+        assert.strictEqual(source, undefined);
+    });
+});
+// =============================================================================
+// Cleanup Tests (requires AgentPackManager - commented out as it needs vscode mock)
+// =============================================================================
+// Note: AgentPackManager.cleanupStaleAgents() is tested indirectly through
+// listInstalledWithCleanup() in the extension. Full unit testing would require
+// mocking SyncService which is beyond the scope of these integration tests.