superkit-mcp-server 1.2.6 → 1.2.8

package/build/tools/ProjectAssets.js

@@ -0,0 +1,177 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// The conventional folder name for project-local Super-Kit assets
+export const PROJECT_ASSETS_DIR = '.agents';
+/**
+ * Resolves the effective project root path.
+ * - If an explicit projectPath is provided, it is resolved to an absolute path.
+ * - Otherwise, falls back to process.cwd().
+ */
+export function resolve_project_path(projectPath) {
+    if (projectPath) {
+        return path.resolve(projectPath);
+    }
+    return process.cwd();
+}
+/**
+ * Returns the absolute path to the .agents/ root for the given project.
+ */
+export function get_project_agents_root(projectPath) {
+    return path.join(resolve_project_path(projectPath), PROJECT_ASSETS_DIR);
+}
+/**
+ * Internal guard: ensures the resolved path stays strictly within the .agents/ root.
+ * Returns the resolved absolute path, or null if a traversal attempt is detected.
+ */
+function safe_project_path(agentsRoot, relative) {
+    // Normalize the root so the startsWith check is reliable on all platforms
+    const normalizedRoot = path.resolve(agentsRoot);
+    const resolved = path.resolve(agentsRoot, relative);
+    // On Windows path.resolve produces lower-cased drive letters consistently,
+    // so this comparison is safe cross-platform.
+    if (!resolved.startsWith(normalizedRoot + path.sep) && resolved !== normalizedRoot) {
+        return null; // traversal detected
+    }
+    return resolved;
+}
+/**
+ * Validates a user-supplied asset name (agentName, skillName, workflowName).
+ * Rejects absolute paths and anything containing path-separator characters.
+ */
+function validate_asset_name(name) {
+    if (!name || typeof name !== 'string') {
+        throw new Error('Asset name must be a non-empty string.');
+    }
+    if (path.isAbsolute(name)) {
+        throw new Error(`Asset name must not be an absolute path: "${name}"`);
+    }
+    // Reject any component that contains a path separator or navigates upward
+    const normalized = path.normalize(name);
+    if (normalized.includes('..') || normalized.startsWith('/') || normalized.startsWith('\\')) {
+        throw new Error(`Asset name contains invalid path components: "${name}"`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Listing helpers
+// ---------------------------------------------------------------------------
+/**
+ * Lists project-scoped agent names (without .md extension) from .agents/agents/.
+ * Returns an empty array if the directory does not exist.
+ */
+export async function list_project_agents(projectPath) {
+    const agentsRoot = get_project_agents_root(projectPath);
+    const agentsDir = path.join(agentsRoot, 'agents');
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith('.md'))
+            .map((e) => e.name.replace(/\.md$/, ''));
+    }
+    catch {
+        // Directory does not exist — graceful degradation
+        return [];
+    }
+}
+/**
+ * Lists project-scoped skill directory names from .agents/skills/tech/ and .agents/skills/meta/.
+ * Returns empty arrays for each category if the directories do not exist.
+ */
+export async function list_project_skills(projectPath) {
+    const agentsRoot = get_project_agents_root(projectPath);
+    const list_category_skills = async (category) => {
+        const categoryDir = path.join(agentsRoot, 'skills', category);
+        try {
+            const entries = await fs.readdir(categoryDir, { withFileTypes: true });
+            return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        }
+        catch {
+            return [];
+        }
+    };
+    const [tech, meta] = await Promise.all([
+        list_category_skills('tech'),
+        list_category_skills('meta'),
+    ]);
+    return { tech, meta };
+}
+/**
+ * Lists project-scoped workflow names (without .md extension) from .agents/workflows/.
+ * Returns an empty array if the directory does not exist.
+ */
+export async function list_project_workflows(projectPath) {
+    const agentsRoot = get_project_agents_root(projectPath);
+    const workflowsDir = path.join(agentsRoot, 'workflows');
+    try {
+        const entries = await fs.readdir(workflowsDir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith('.md'))
+            .map((e) => e.name.replace(/\.md$/, ''));
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Loading helpers
+// ---------------------------------------------------------------------------
+/**
+ * Loads a project-scoped agent's markdown content from:
+ *   {projectPath}/.agents/agents/{agentName}.md
+ */
+export async function load_project_agent_file(agentName, projectPath) {
+    validate_asset_name(agentName);
+    const agentsRoot = get_project_agents_root(projectPath);
+    const relative = path.join('agents', `${agentName}.md`);
+    const safePath = safe_project_path(agentsRoot, relative);
+    if (!safePath) {
+        throw new Error(`Path traversal detected for agent name: "${agentName}"`);
+    }
+    try {
+        return await fs.readFile(safePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Project agent not found: "${agentName}". ` +
+            `Expected file at: ${safePath}`);
+    }
+}
+/**
+ * Loads a project-scoped skill's SKILL.md content from:
+ *   {projectPath}/.agents/skills/{category}/{skillName}/SKILL.md
+ */
+export async function load_project_skill_file(category, skillName, projectPath) {
+    validate_asset_name(category);
+    validate_asset_name(skillName);
+    const agentsRoot = get_project_agents_root(projectPath);
+    const relative = path.join('skills', category, skillName, 'SKILL.md');
+    const safePath = safe_project_path(agentsRoot, relative);
+    if (!safePath) {
+        throw new Error(`Path traversal detected for skill: category="${category}", skillName="${skillName}"`);
+    }
+    try {
+        return await fs.readFile(safePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Project skill not found: category="${category}", skillName="${skillName}". ` +
+            `Expected SKILL.md at: ${safePath}`);
+    }
+}
+/**
+ * Loads a project-scoped workflow's markdown content from:
+ *   {projectPath}/.agents/workflows/{workflowName}.md
+ */
+export async function load_project_workflow_file(workflowName, projectPath) {
+    validate_asset_name(workflowName);
+    const agentsRoot = get_project_agents_root(projectPath);
+    const relative = path.join('workflows', `${workflowName}.md`);
+    const safePath = safe_project_path(agentsRoot, relative);
+    if (!safePath) {
+        throw new Error(`Path traversal detected for workflow name: "${workflowName}"`);
+    }
+    try {
+        return await fs.readFile(safePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Project workflow not found: "${workflowName}". ` +
+            `Expected file at: ${safePath}`);
+    }
+}

package/commands/kit-setup.toml

@@ -29,7 +29,8 @@ When you finish answering, I will:
 1. Create file `docs/agents/product.md`
 2. Continue asking about Tech Stack
 3. Continue asking about Guidelines
-4. Complete setup!
+4. Ask about Claude Code agent installation (optional)
+5. Complete setup!
 
 **You can answer freely or following the format:**
 ```
@@ -38,4 +39,33 @@ Users: [who uses it]
 Goals: [goals]
 Features: [main features]
 ```
+
+---
+
+## Step 4: Claude Code Agent Installation (Optional)
+
+After completing Steps 1-3, ask the user:
+
+> "Are you using **Claude Code** as your AI assistant? If so, I can install the Super-Kit agents directly into your `.claude/agents/` folder so they appear in the `/agents` dialog — giving you one-click access to the Planner, Coder, Scout, Reviewer, Tester, and all other Super-Kit specialists."
+
+If the user says **yes**, ask:
+
+> "Where would you like to install them?
+> - **a) Global** — `~/.claude/agents/` (available in every project)
+> - **b) Project-local** — `.claude/agents/` in the current directory (this project only)"
+
+If the user chooses **global (a)**:
+- Use the `list_superkit_assets` MCP tool to get all agent names
+- For each agent, use the `load_superkit_agent` MCP tool to get its content
+- Write each agent file to `~/.claude/agents/{agent-name}.md`
+- The files already contain the required YAML frontmatter — copy them as-is
+
+If the user chooses **project-local (b)**:
+- Same process, but write to `.claude/agents/{agent-name}.md` relative to the current working directory
+- Create the `.claude/agents/` directory if it doesn't exist
+
+After writing all files, confirm:
+> "✅ Super-Kit agents installed! Open the `/agents` dialog in Claude Code to see them."
+
+If the user says **no** or skips, complete setup without this step.
 """

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superkit-mcp-server",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "type": "module",
   "description": "An MCP server for exploring and loading Super-Kit AI agent resources.",
   "main": "build/index.js",
@@ -8,6 +8,8 @@
     "superkit-mcp-server": "./build/index.js"
   },
   "scripts": {
+    "clean": "rimraf build",
+    "prebuild": "rimraf build",
     "build": "tsc",
     "start": "node build/index.js",
     "dev": "tsc --watch"
@@ -21,6 +23,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.19.13",
+    "rimraf": "^6.1.3",
     "typescript": "^5.7.2",
     "vitest": "^4.0.18"
   },
@@ -33,4 +36,4 @@
     "README.md",
     "ARCHITECTURE.md"
   ]
-}
+}

package/build/__tests__/test_apply_prompt_args.js

@@ -1,104 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { apply_prompt_args } from '../index.js';
-describe('apply_prompt_args', () => {
-    describe('{{args}} substitution', () => {
-        it('should replace {{args}} with the provided user args', () => {
-            const result = apply_prompt_args('Task: {{args}}', 'Add user authentication');
-            expect(result).toBe('Task: Add user authentication');
-        });
-        it('should replace all occurrences of {{args}}', () => {
-            const result = apply_prompt_args('{{args}} and also {{args}}', 'hello');
-            expect(result).toBe('hello and also hello');
-        });
-        it('should replace {{args}} with an empty string when no args are provided', () => {
-            const result = apply_prompt_args('Task: {{args}}', '');
-            expect(result).toBe('Task: ');
-        });
-        it('should replace {{args}} with an empty string when args is only whitespace', () => {
-            const result = apply_prompt_args('Task: {{args}}', '   ');
-            expect(result).toBe('Task:    ');
-        });
-    });
-    describe('{{#if args}} ... {{/if}} block (no else branch)', () => {
-        it('should include the block content when args is provided', () => {
-            const template = '{{#if args}}Task: {{args}}{{/if}}';
-            const result = apply_prompt_args(template, 'Fix bug');
-            expect(result).toBe('Task: Fix bug');
-        });
-        it('should remove the block entirely when args is empty', () => {
-            const template = 'Before\n{{#if args}}Task: {{args}}{{/if}}\nAfter';
-            const result = apply_prompt_args(template, '');
-            expect(result).toBe('Before\n\nAfter');
-        });
-        it('should remove the block entirely when args is only whitespace', () => {
-            const template = '{{#if args}}Task: {{args}}{{/if}}';
-            const result = apply_prompt_args(template, '   ');
-            expect(result).toBe('');
-        });
-        it('should handle multiline block content', () => {
-            const template = '{{#if args}}\n# Task\n**Input:** {{args}}\n{{/if}}';
-            const result = apply_prompt_args(template, 'Do something');
-            expect(result).toBe('\n# Task\n**Input:** Do something\n');
-        });
-    });
-    describe('{{#if args}} ... {{else}} ... {{/if}} block', () => {
-        it('should render the if-block when args is provided', () => {
-            const template = '{{#if args}}Task: {{args}}{{else}}No task provided.{{/if}}';
-            const result = apply_prompt_args(template, 'Add login');
-            expect(result).toBe('Task: Add login');
-        });
-        it('should render the else-block when args is empty', () => {
-            const template = '{{#if args}}Task: {{args}}{{else}}No task provided.{{/if}}';
-            const result = apply_prompt_args(template, '');
-            expect(result).toBe('No task provided.');
-        });
-        it('should render the else-block when args is only whitespace', () => {
-            const template = '{{#if args}}Task: {{args}}{{else}}No task provided.{{/if}}';
-            const result = apply_prompt_args(template, '   ');
-            expect(result).toBe('No task provided.');
-        });
-        it('should handle multiline if and else blocks', () => {
-            const template = [
-                '{{#if args}}',
-                '# Running: {{args}}',
-                'Execute the task above.',
-                '{{else}}',
-                '# Usage',
-                'Provide a task to run.',
-                '{{/if}}',
-            ].join('\n');
-            const with_args = apply_prompt_args(template, 'Build the feature');
-            expect(with_args).toContain('# Running: Build the feature');
-            expect(with_args).not.toContain('# Usage');
-            const without_args = apply_prompt_args(template, '');
-            expect(without_args).toContain('# Usage');
-            expect(without_args).not.toContain('# Running:');
-        });
-    });
-    describe('edge cases', () => {
-        it('should return the template unchanged when it has no placeholders', () => {
-            const template = '# Plan\nThis is a static template.';
-            const result = apply_prompt_args(template, 'some args');
-            expect(result).toBe(template);
-        });
-        it('should handle a template with both {{args}} and {{#if args}} blocks', () => {
-            const template = [
-                '{{#if args}}',
-                '**Task:** {{args}}',
-                '{{else}}',
-                '**Task:** (none)',
-                '{{/if}}',
-                '',
-                'Details: {{args}}',
-            ].join('\n');
-            const result = apply_prompt_args(template, 'Refactor auth');
-            expect(result).toContain('**Task:** Refactor auth');
-            expect(result).toContain('Details: Refactor auth');
-            expect(result).not.toContain('(none)');
-        });
-        it('should handle empty template string', () => {
-            const result = apply_prompt_args('', 'some args');
-            expect(result).toBe('');
-        });
-    });
-});

package/build/tools/__tests__/archTools.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { completePlan, validateArchitecture } from '../archTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Arch Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'arch-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should complete a plan successfully', async () => {
-        const planPath = path.join(tempDir, 'plan1.md');
-        await fs.writeFile(planPath, '> Status: Draft\n\n- [x] Done item');
-        const res = await completePlan('plan1.md', false, tempDir);
-        expect(res).toContain('Plan marked as Implemented');
-        const content = await fs.readFile(planPath, 'utf8');
-        expect(content).toContain('> Status: Implemented');
-    });
-    it('should fail to complete a plan if unchecked items exist', async () => {
-        const planPath = path.join(tempDir, 'plan2.md');
-        await fs.writeFile(planPath, '> Status: Draft\n\n- [ ] Pending item');
-        const res = await completePlan('plan2.md', false, tempDir);
-        expect(res).toContain('unchecked acceptance criteria found');
-    });
-    it('should force complete a plan with unchecked items', async () => {
-        const planPath = path.join(tempDir, 'plan3.md');
-        await fs.writeFile(planPath, '> Status: Draft\n\n- [ ] Pending item');
-        const res = await completePlan('plan3.md', true, tempDir);
-        expect(res).toContain('Plan marked as Implemented');
-    });
-    it('should validate architecture counts', async () => {
-        const archDir = path.join(tempDir, 'docs', 'architecture');
-        await fs.mkdir(archDir, { recursive: true });
-        await fs.writeFile(path.join(archDir, 'compound-system.md'), '---\nskills: 1\nworkflows: 0\nscripts: 0\npatterns: 0\n---');
-        const res = await validateArchitecture(tempDir);
-        expect(res).toContain('Architecture Document is stale!');
-        expect(res).toContain('Skills mismatch');
-    });
-});

package/build/tools/__tests__/compoundTools.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { compoundSearch, updateSolutionRef, validateCompound, auditStateDrift } from '../compoundTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Compound Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'compound-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should search for solutions', async () => {
-        const solDir = path.join(tempDir, 'docs', 'solutions');
-        await fs.mkdir(solDir, { recursive: true });
-        await fs.writeFile(path.join(solDir, 'test.md'), '# Test Solution\n\nThis mentions React and Next.js.');
-        await fs.writeFile(path.join(solDir, 'test2.md'), '# Other Solution\n\nThis mentions Vue.');
-        const res = await compoundSearch(['React'], tempDir);
-        expect(res).toContain('test.md');
-        expect(res).toContain('Test Solution');
-        expect(res).not.toContain('test2.md');
-    });
-    it('should update solution ref', async () => {
-        const solDir = path.join(tempDir, 'docs', 'solutions');
-        await fs.mkdir(solDir, { recursive: true });
-        const filePath = path.join(solDir, 'test.md');
-        await fs.writeFile(filePath, '---\ntags: [test]\n---\n# Test Solution');
-        const res = await updateSolutionRef([path.relative(tempDir, filePath)], tempDir);
-        expect(res).toContain('Updated 1 files');
-        const content = await fs.readFile(filePath, 'utf-8');
-        expect(content).toContain('last_referenced:');
-    });
-    it('should validate compound health', async () => {
-        const planPath = path.join(tempDir, 'implementation_plan.md');
-        await fs.writeFile(planPath, '- [ ] todo 1\n- [ ] todo 2\n');
-        const res = await validateCompound(tempDir);
-        expect(res).toContain('⚠️  Found 2 unchecked items in implementation_plan.md');
-        expect(res).toContain('❌ Validation failed.');
-    });
-    it('should audit state drift and report drift', async () => {
-        const todosDir = path.join(tempDir, 'todos');
-        await fs.mkdir(todosDir, { recursive: true });
-        const todoPath = path.join(todosDir, '001-pending-p1-test.md');
-        await fs.writeFile(todoPath, 'status: pending\n\n- [x] tick 1\n- [x] tick 2');
-        const res = await auditStateDrift(tempDir, false);
-        expect(res).toContain('DRIFT: 001-pending-p1-test.md');
-        expect(res).toContain('Checked: 2/2');
-    });
-    it('should audit state drift and fix drift', async () => {
-        const todosDir = path.join(tempDir, 'todos');
-        await fs.mkdir(todosDir, { recursive: true });
-        const todoPath = path.join(todosDir, '001-pending-p1-test.md');
-        await fs.writeFile(todoPath, 'status: pending\n\n- [x] tick 1\n- [x] tick 2');
-        const res = await auditStateDrift(tempDir, true);
-        expect(res).toContain('FIXED: 001-pending-p1-test.md');
-        const content = await fs.readFile(todoPath, 'utf8');
-        expect(content).toContain('status: done');
-    });
-});

package/build/tools/__tests__/docsTools.test.js

@@ -1,44 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { bootstrapFolderDocs, checkDocsFreshness, discoverUndocumentedFolders, validateFolderDocs } from '../docsTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Docs Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'docs-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should bootstrap folder docs', async () => {
-        const targetDir = path.join(tempDir, 'src');
-        await fs.mkdir(targetDir, { recursive: true });
-        await fs.writeFile(path.join(targetDir, 'utils.ts'), 'content');
-        const result = await bootstrapFolderDocs('src', tempDir);
-        expect(result).toContain('Bootstrapped');
-        const readme = await fs.readFile(path.join(targetDir, 'README.md'), 'utf8');
-        expect(readme).toContain('# src');
-        expect(readme).toContain('`utils.ts`');
-    });
-    it('should discover undocumented folders', async () => {
-        const srcDir = path.join(tempDir, 'src');
-        await fs.mkdir(srcDir, { recursive: true });
-        await fs.writeFile(path.join(srcDir, 'logic.ts'), 'content');
-        // no readme -> should be discovered
-        const result = await discoverUndocumentedFolders(tempDir);
-        expect(result).toContain('src');
-    });
-    it('should validate folder docs', async () => {
-        const targetDir = path.join(tempDir, 'src');
-        await fs.mkdir(targetDir, { recursive: true });
-        await fs.writeFile(path.join(targetDir, 'README.md'), '# src\n');
-        const result = await validateFolderDocs(false, ['src'], tempDir);
-        expect(result).toContain('missing sections: Purpose, Components, Component Details, Changelog');
-    });
-    it('should check docs freshness without failing', async () => {
-        // Just tests the skip-docs flag since git repo isn't present
-        const result = await checkDocsFreshness(true, tempDir);
-        expect(result).toContain('Skipping documentation freshness check');
-    });
-});

package/build/tools/__tests__/gitTools.test.js

@@ -1,45 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { validateChangelog, archiveCompleted, prePushHousekeeping } from '../gitTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Git Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'git-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    it('should validate changelog', async () => {
-        const changelogPath = path.join(tempDir, 'CHANGELOG.md');
-        await fs.writeFile(changelogPath, '## [Unreleased]\n## [Unreleased]\n<<<<<<< HEAD');
-        const result = await validateChangelog(tempDir);
-        expect(result).toContain('Multiple [Unreleased] sections found');
-        expect(result).toContain('Merge conflict markers found');
-    });
-    it('should archive completed items in dry-run mode', async () => {
-        await fs.mkdir(path.join(tempDir, 'todos'), { recursive: true });
-        const todoPath = path.join(tempDir, 'todos', '001-done-test.md');
-        await fs.writeFile(todoPath, 'content');
-        const res = await archiveCompleted(tempDir, false);
-        expect(res).toContain('DRY-RUN');
-        expect(res).toContain('[ARCHIVED] 001-done-test.md');
-        // Still exists
-        await fs.access(todoPath);
-    });
-    it('should archive completed items and move them', async () => {
-        await fs.mkdir(path.join(tempDir, 'todos'), { recursive: true });
-        const todoPath = path.join(tempDir, 'todos', '001-done-test.md');
-        await fs.writeFile(todoPath, 'content');
-        const res = await archiveCompleted(tempDir, true);
-        expect(res).toContain('APPLYING CHANGES');
-        const archivedPath = path.join(tempDir, 'todos', 'archive', '001-done-test.md');
-        await fs.access(archivedPath); // Should not throw
-    });
-    it('should run pre-push housekeeping', async () => {
-        const res = await prePushHousekeeping(tempDir, false);
-        expect(res).toContain('Pre-Push Housekeeping Check');
-        expect(res).toContain('All checks passed');
-    });
-});

package/build/tools/__tests__/loggerTools.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { logSkill, logWorkflow, rotateLogs } from '../loggerTools.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('Logger Tools', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'logger-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('should log skill usage', async () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-03-04T00:00:00Z'));
-        const result = await logSkill('test-skill', 'manual', 'context', tempDir);
-        expect(result).toBe('Successfully logged skill usage for test-skill');
-        const logFile = path.join(tempDir, 'docs', 'agents', 'logs', 'skill_usage.log');
-        const content = await fs.readFile(logFile, 'utf-8');
-        expect(content).toContain('2026-03-04T00:00:00Z|test-skill|manual|context\n');
-        vi.useRealTimers();
-    });
-    it('should log workflow usage', async () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-03-04T00:00:00Z'));
-        const result = await logWorkflow('test-workflow', 'session-123', tempDir);
-        expect(result).toBe('Successfully logged workflow usage for test-workflow');
-        const logFile = path.join(tempDir, 'docs', 'agents', 'logs', 'workflow_usage.log');
-        const content = await fs.readFile(logFile, 'utf-8');
-        expect(content).toContain('2026-03-04T00:00:00Z|test-workflow|session-123\n');
-        vi.useRealTimers();
-    });
-    it('should generate a default session id if not provided', async () => {
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date('2026-03-04T00:00:00Z')); // 1772582400 in seconds
-        await logWorkflow('test-workflow', '', tempDir);
-        const logFile = path.join(tempDir, 'docs', 'agents', 'logs', 'workflow_usage.log');
-        const content = await fs.readFile(logFile, 'utf-8');
-        expect(content).toContain('2026-03-04T00:00:00Z|test-workflow|1772582400\n');
-        vi.useRealTimers();
-    });
-    it('should rotate logs older than retention days', async () => {
-        const logDir = path.join(tempDir, 'docs', 'agents', 'logs');
-        await fs.mkdir(logDir, { recursive: true });
-        // Old log line (e.g. 100 days old)
-        const oldTimestamp = new Date();
-        oldTimestamp.setDate(oldTimestamp.getDate() - 100);
-        const oldStr = oldTimestamp.toISOString().replace(/\.[0-9]{3}Z$/, 'Z');
-        // New log line (10 days old)
-        const newTimestamp = new Date();
-        newTimestamp.setDate(newTimestamp.getDate() - 10);
-        const newStr = newTimestamp.toISOString().replace(/\.[0-9]{3}Z$/, 'Z');
-        const logContent = `${oldStr}|test|manual|context1\n${newStr}|test|manual|context2\n`;
-        await fs.writeFile(path.join(logDir, 'skill_usage.log'), logContent);
-        const output = await rotateLogs(tempDir, 90);
-        expect(output).toContain('Pruned 1 lines');
-        const finalContent = await fs.readFile(path.join(logDir, 'skill_usage.log'), 'utf-8');
-        expect(finalContent).not.toContain('context1');
-        expect(finalContent).toContain('context2');
-    });
-    it('should report if no logs need rotation', async () => {
-        const logDir = path.join(tempDir, 'docs', 'agents', 'logs');
-        await fs.mkdir(logDir, { recursive: true });
-        const newTimestamp = new Date();
-        newTimestamp.setDate(newTimestamp.getDate() - 10);
-        const newStr = newTimestamp.toISOString().replace(/\.[0-9]{3}Z$/, 'Z');
-        const logContent = `${newStr}|test|manual|context2\n`;
-        await fs.writeFile(path.join(logDir, 'skill_usage.log'), logContent);
-        const output = await rotateLogs(tempDir, 90);
-        expect(output).toContain('(No logs needed rotation)');
-    });
-});