@agent-spaces/server 0.3.61 → 0.3.62

package/dist/adapters/claude-code-runtime/index.js

@@ -84,9 +84,12 @@ export class ClaudeCodeRuntime {
                     options?.onEvent?.({ type: 'session', sessionId });
                 }
                 const toolUses = extractToolUseEvents(message);
+                let sawAskUserQuestion = false;
                 for (const toolUse of toolUses) {
                     if (toolUse.name === 'AskUserQuestion') {
                         pendingAskUserQuestionToolIds.add(toolUse.id);
+                        waitingForUserAnswer = true;
+                        sawAskUserQuestion = true;
                     }
                 }
                 const toolResult = extractToolResultEvent(message);
@@ -133,8 +136,24 @@ export class ClaudeCodeRuntime {
                         error = message.errors.join('\n') || message.subtype;
                     }
                 }
+                if (sawAskUserQuestion)
+                    break;
             }
             const elapsed = Date.now() - startTime;
+            if (waitingForUserAnswer) {
+                d(`waiting for user answer ${elapsed}ms | turns=${turns} tokens=${tokenCount}`);
+                if (usageLine)
+                    output.push(usageLine);
+                return {
+                    success: true,
+                    summary: 'Waiting for user answer',
+                    artifacts: [],
+                    output,
+                    usage,
+                    costUsd,
+                    sessionId,
+                };
+            }
             if (!sawResult) {
                 const runtimeError = extractRuntimeError([...stderrLines, ...output])
                     || 'Claude Code execution stopped before reporting a final result';

package/dist/adapters/claude-code-runtime/sdk-config.js

@@ -1,6 +1,6 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { extname, isAbsolute, resolve } from 'node:path';
+import { basename, extname, isAbsolute, resolve } from 'node:path';
 import { join } from 'node:path';
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicBridgeProvider } from './types.js';
@@ -125,7 +125,7 @@ export function normalizeSkillNames(skills, configDir) {
     if (!Array.isArray(skills))
         return [];
     return skills
-        .map((skill) => skill.trim().replace(/\.md$/i, ''))
+        .map(sanitizeSkillName)
         .filter((skill) => Boolean(skill) && hasSkillContent(skill, configDir));
 }
 export function prepareConfigDir(configDir, agentDir) {
@@ -138,19 +138,43 @@ export function prepareConfigDir(configDir, agentDir) {
     mkdirSync(targetSkillsDir, { recursive: true });
     if (!existsSync(sourceSkillsDir))
         return;
-    for (const file of readdirSync(sourceSkillsDir)) {
-        if (extname(file).toLowerCase() !== '.md')
+    for (const entry of readdirSync(sourceSkillsDir)) {
+        const source = join(sourceSkillsDir, entry);
+        const sourceStat = statSync(source);
+        if (sourceStat.isDirectory()) {
+            const skillName = sanitizeSkillName(entry);
+            if (!skillName)
+                continue;
+            const sourceSkillFile = join(source, 'SKILL.md');
+            const targetSkillDir = join(targetSkillsDir, skillName);
+            if (existsSync(sourceSkillFile) && statSync(sourceSkillFile).size > 0) {
+                cpSync(source, targetSkillDir, { recursive: true, force: true });
+            }
             continue;
-        copyFileSync(join(sourceSkillsDir, file), join(targetSkillsDir, file));
+        }
+        if (!sourceStat.isFile() || extname(entry).toLowerCase() !== '.md')
+            continue;
+        const skillName = sanitizeSkillName(entry);
+        if (!skillName || sourceStat.size === 0)
+            continue;
+        const targetSkillDir = join(targetSkillsDir, skillName);
+        mkdirSync(targetSkillDir, { recursive: true });
+        writeFileSync(join(targetSkillDir, 'SKILL.md'), readFileSync(source, 'utf-8'), 'utf-8');
+        copyFileSync(source, join(targetSkillsDir, `${skillName}.md`));
     }
 }
 function hasSkillContent(skill, configDir) {
     if (!configDir)
         return true;
-    const skillFile = join(configDir, 'skills', `${skill}.md`);
-    if (!existsSync(skillFile))
-        return false;
-    return statSync(skillFile).size > 0;
+    const skillFile = join(configDir, 'skills', skill, 'SKILL.md');
+    if (existsSync(skillFile) && statSync(skillFile).size > 0)
+        return true;
+    const legacySkillFile = join(configDir, 'skills', `${skill}.md`);
+    return existsSync(legacySkillFile) && statSync(legacySkillFile).size > 0;
+}
+function sanitizeSkillName(name) {
+    const raw = basename(name).replace(/\.md$/i, '').trim();
+    return raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
 }
 export function normalizePermissionMode(permissionMode) {
     if (permissionMode === 'default' ||

package/dist/adapters/git.js

@@ -3,6 +3,19 @@ import { getWorkspace } from '../storage/workspace-store.js';
 import { writeFile, readFile, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
+const BINARY_EXTENSIONS = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'svg', 'tiff', 'tif',
+    'mp3', 'mp4', 'wav', 'avi', 'mov', 'mkv', 'flv', 'wmv', 'webm',
+    'zip', 'tar', 'gz', 'bz2', 'xz', '7z', 'rar', 'dmg', 'iso',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+    'woff', 'woff2', 'ttf', 'otf', 'eot',
+    'exe', 'dll', 'so', 'dylib', 'bin', 'dat',
+    'sqlite', 'db', 'pyc', 'o', 'obj', 'class', 'jar', 'wasm',
+]);
+function isBinaryPath(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    return ext ? BINARY_EXTENSIONS.has(ext) : true;
+}
 const gitInstances = new Map();
 function getGitOptions() {
     const proxy = process.env.HTTPS_PROXY || process.env.https_proxy
@@ -115,9 +128,9 @@ export async function gitDiff(workspaceId, filePath) {
         const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${filePath}`, 'utf-8')).catch(() => '');
         diffs.push({
             path: filePath,
-            oldContent,
-            newContent,
-            isBinary: false,
+            oldContent: isBinaryPath(filePath) ? '' : oldContent,
+            newContent: isBinaryPath(filePath) ? '' : newContent,
+            isBinary: isBinaryPath(filePath),
             isNew: !oldContent,
             isDeleted: !newContent,
         });
@@ -126,13 +139,14 @@ export async function gitDiff(workspaceId, filePath) {
         const raw = await git.diff(['--name-only']);
         const files = raw.split('\n').filter(Boolean);
         for (const f of files) {
-            const oldContent = await git.show([`HEAD:${f}`]).catch(() => '');
-            const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
+            const binary = isBinaryPath(f);
+            const oldContent = binary ? '' : await git.show([`HEAD:${f}`]).catch(() => '');
+            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
             diffs.push({
                 path: f,
                 oldContent,
                 newContent,
-                isBinary: false,
+                isBinary: binary,
                 isNew: !oldContent,
                 isDeleted: !newContent,
             });
@@ -140,13 +154,14 @@ export async function gitDiff(workspaceId, filePath) {
         // Also check untracked (staged new files)
         const status = await git.status();
         for (const f of status.not_added) {
-            const newContent = await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
-            if (newContent) {
+            const binary = isBinaryPath(f);
+            const newContent = binary ? '' : await import('node:fs/promises').then(fs => fs.readFile(`${ws.boundDirs[0]}/${f}`, 'utf-8')).catch(() => '');
+            if (newContent || binary) {
                 diffs.push({
                     path: f,
                     oldContent: '',
-                    newContent,
-                    isBinary: false,
+                    newContent: binary ? '' : newContent,
+                    isBinary: binary,
                     isNew: true,
                     isDeleted: false,
                 });
@@ -337,9 +352,10 @@ export async function gitCommitDiff(workspaceId, commitHash) {
     const files = nameOnlyRaw.split('\n').filter(Boolean);
     const diffs = [];
     for (const f of files) {
-        const oldContent = await git.show([`${commitHash}^:${f}`]).catch(() => '');
-        const newContent = await git.show([`${commitHash}:${f}`]).catch(() => '');
-        diffs.push({ path: f, oldContent, newContent, isBinary: false, isNew: !oldContent, isDeleted: !newContent });
+        const binary = isBinaryPath(f);
+        const oldContent = binary ? '' : await git.show([`${commitHash}^:${f}`]).catch(() => '');
+        const newContent = binary ? '' : await git.show([`${commitHash}:${f}`]).catch(() => '');
+        diffs.push({ path: f, oldContent, newContent, isBinary: binary, isNew: !oldContent, isDeleted: !newContent });
     }
     return diffs;
 }

package/dist/agents/agent-message-parts.js

@@ -46,7 +46,7 @@ export function createAgentMessagePartsTracker(input) {
             output.push(event.line);
             input.onOutput?.(event.line);
         },
-        buildParts({ sessionId, workspaceRoot, model, usage, success, error }) {
+        buildParts({ sessionId, workspaceRoot, model, usage, persistentContext, success, error }) {
             return buildAgentMessageParts({
                 sessionId,
                 workspaceRoot,
@@ -55,6 +55,7 @@ export function createAgentMessagePartsTracker(input) {
                 output,
                 reasoning,
                 toolDetails,
+                persistentContext,
                 success,
                 error,
             });
@@ -69,7 +70,7 @@ function buildAgentMessageParts(input) {
         : '';
     const usage = input.usage ?? extractUsage(lines);
     const parts = [];
-    const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails);
+    const chainItems = buildChainItems(lines, finalTextRange, finalText, input.workspaceRoot, input.toolDetails, input.persistentContext);
     const reasoningText = normalizeReasoningText(input.reasoning);
     if (reasoningText) {
         parts.push({
@@ -181,12 +182,17 @@ function findFinalTextRange(lines) {
     }
     return { start, end };
 }
-function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDetails) {
+function buildChainItems(lines, finalTextRange, finalText, workspaceRoot, toolDetails, persistentContext) {
     let toolIndex = 0;
     let messageIndex = 0;
     const items = [];
     const toolDetailMatchCounts = new Map();
     let messageBuffer = [];
+    const persistentContextItem = buildPersistentContextToolItem(persistentContext);
+    if (persistentContextItem) {
+        items.push(persistentContextItem);
+        toolIndex += 1;
+    }
     const flushMessageBuffer = () => {
         if (messageBuffer.length === 0)
             return;
@@ -229,6 +235,7 @@ function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchC
     const detailId = findToolDetailId(line, toolDetails, toolDetailMatchCounts);
     return {
         id: `tool-${index}`,
+        kind: 'tool',
         title: summary.title,
         description: summary.description,
         status: 'completed',
@@ -238,6 +245,23 @@ function buildToolTodo(line, index, workspaceRoot, toolDetails, toolDetailMatchC
         detailId,
     };
 }
+function buildPersistentContextToolItem(persistentContext) {
+    const counts = persistentContext?.counts;
+    if (!counts?.total)
+        return null;
+    const description = [
+        counts.claudeMd ? `${counts.claudeMd} claude.md` : null,
+        counts.agentsMd ? `${counts.agentsMd} AGENTS.md` : null,
+    ].filter(Boolean).join(', ') || `${counts.total} instruction files`;
+    return {
+        id: 'tool-persistent-context',
+        kind: 'tool',
+        title: 'Load claude.md',
+        description,
+        status: 'completed',
+        toolName: 'LoadClaudeMd',
+    };
+}
 function summarizeToolLine(line, workspaceRoot) {
     const trimmed = line.trim();
     const toolName = extractToolName(trimmed);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-spaces/server",
-  "version": "0.3.5",
+  "version": "0.3.62",
   "type": "module",
   "main": "app.js",
   "packageManager": "pnpm@10.17.1",

package/dist/routes/channel.js

@@ -2,7 +2,7 @@ import { Router } from 'express';
 import { listChannels, createChannel, getChannel, updateChannel, deleteChannel } from '../services/channel.js';
 import { listMessages, createMessage, updateMessage, deleteMessage, clearMessages } from '../services/message.js';
 import { broadcastToWorkspace } from '../ws/connection-manager.js';
-import { hasActiveChannelRuns, markInactiveChannelRunsStopped, stopChannelRuns } from '../ws/agent-runner.js';
+import { hasActiveChannelRuns, stopChannelRuns } from '../ws/agent-runner.js';
 import { getToolDetail } from '../services/tool-detail.js';
 import * as issueService from '../services/issue.js';
 const router = Router({ mergeParams: true });
@@ -69,11 +69,28 @@ router.get('/:channelId/messages', (req, res) => {
         res.status(404).json({ error: 'channel not found' });
         return;
     }
-    if (!hasActiveChannelRuns(id, channelId)) {
-        markInactiveChannelRunsStopped(id, channelId);
-    }
     res.json(listMessages(id, channelId, { limit: limit ? Number(limit) : undefined, before: before }));
 });
+// GET /api/workspaces/:id/channels/:channelId/state
+router.get('/:channelId/state', (req, res) => {
+    const { id, channelId } = req.params;
+    if (!getChannel(id, channelId)) {
+        res.status(404).json({ error: 'channel not found' });
+        return;
+    }
+    const messages = listMessages(id, channelId, { limit: 1 });
+    const lastMessage = messages.at(-1);
+    res.json({
+        channelId,
+        active: hasActiveChannelRuns(id, channelId),
+        lastMessage: lastMessage ? {
+            id: lastMessage.id,
+            status: lastMessage.status,
+            metadata: lastMessage.metadata,
+            hasPendingQuestion: Boolean(lastMessage.parts?.some((part) => (part.type === 'ask_user_question' && part.status !== 'answered' && !part.answer))),
+        } : null,
+    });
+});
 // GET /api/workspaces/:id/channels/:channelId/messages/:messageId/tool-details/:detailId
 router.get('/:channelId/messages/:messageId/tool-details/:detailId', (req, res) => {
     const { id, channelId, messageId, detailId } = req.params;

package/dist/routes/file.js

@@ -1,6 +1,7 @@
 import { Router } from 'express';
 import { exec } from 'child_process';
-import { resolve, join } from 'path';
+import { resolve, join, extname } from 'path';
+import { existsSync, createReadStream, statSync } from 'node:fs';
 import * as fileService from '../services/file.js';
 import { getDataDir } from '../storage/json-store.js';
 const EDITOR_STATE_PATH = '.agentspace/editor-state.json';
@@ -16,6 +17,13 @@ router.get('/tree', async (req, res) => {
     const tree = await fileService.readTree(ws, path, depth);
     res.json(tree);
 });
+const MIME_MAP = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.webp': 'image/webp', '.svg': 'image/svg+xml', '.bmp': 'image/bmp', '.ico': 'image/x-icon',
+    '.mp4': 'video/mp4', '.webm': 'video/webm', '.ogg': 'video/ogg', '.mov': 'video/quicktime',
+    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.flac': 'audio/flac', '.aac': 'audio/aac',
+    '.m4a': 'audio/mp4', '.opus': 'audio/opus',
+};
 router.get('/content', async (req, res) => {
     const ws = fileService.getWorkspace(req.params.id);
     if (!ws) {
@@ -27,6 +35,38 @@ router.get('/content', async (req, res) => {
         res.status(400).json({ error: 'path is required' });
         return;
     }
+    const raw = req.query.raw === 'true';
+    if (raw) {
+        const abs = fileService.resolvePath(ws, path);
+        if (!abs || !existsSync(abs)) {
+            res.status(404).json({ error: 'File not found' });
+            return;
+        }
+        const ext = extname(path).toLowerCase();
+        const mime = MIME_MAP[ext] || 'application/octet-stream';
+        const stat = statSync(abs);
+        const fileSize = stat.size;
+        // Handle Range requests for video/audio seeking
+        const range = req.headers.range;
+        if (range) {
+            const parts = range.replace(/bytes=/, '').split('-');
+            const start = parseInt(parts[0], 10);
+            const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+            const chunkSize = end - start + 1;
+            res.status(206);
+            res.setHeader('Content-Range', `bytes ${start}-${end}/${fileSize}`);
+            res.setHeader('Accept-Ranges', 'bytes');
+            res.setHeader('Content-Length', chunkSize);
+            res.setHeader('Content-Type', mime);
+            createReadStream(abs, { start, end }).pipe(res);
+            return;
+        }
+        res.setHeader('Content-Type', mime);
+        res.setHeader('Accept-Ranges', 'bytes');
+        res.setHeader('Content-Length', fileSize);
+        createReadStream(abs).pipe(res);
+        return;
+    }
     const result = await fileService.readFileContent(ws, path);
     if (!result) {
         res.status(404).json({ error: 'File not found' });
@@ -253,5 +293,51 @@ router.post('/upload', async (req, res) => {
     }
     res.json({ ok: true, paths: results });
 });
+router.get('/download', async (req, res) => {
+    const ws = fileService.getWorkspace(req.params.id);
+    if (!ws) {
+        res.status(404).json({ error: 'Workspace not found' });
+        return;
+    }
+    const path = req.query.path;
+    if (!path) {
+        res.status(400).json({ error: 'path is required' });
+        return;
+    }
+    const abs = fileService.resolvePath(ws, path);
+    if (!abs || !existsSync(abs)) {
+        res.status(404).json({ error: 'File not found' });
+        return;
+    }
+    const stat = statSync(abs);
+    if (stat.isDirectory()) {
+        res.status(400).json({ error: 'Cannot download a directory' });
+        return;
+    }
+    const ext = extname(path).toLowerCase();
+    const mime = MIME_MAP[ext] || 'application/octet-stream';
+    const fileName = path.split('/').pop() || 'download';
+    // Handle Range requests for large files
+    const range = req.headers.range;
+    if (range) {
+        const parts = range.replace(/bytes=/, '').split('-');
+        const start = parseInt(parts[0], 10);
+        const end = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;
+        const chunkSize = end - start + 1;
+        res.status(206);
+        res.setHeader('Content-Range', `bytes ${start}-${end}/${stat.size}`);
+        res.setHeader('Accept-Ranges', 'bytes');
+        res.setHeader('Content-Length', chunkSize);
+        res.setHeader('Content-Type', mime);
+        res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(fileName)}"`);
+        createReadStream(abs, { start, end }).pipe(res);
+        return;
+    }
+    res.setHeader('Content-Type', mime);
+    res.setHeader('Content-Length', stat.size);
+    res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(fileName)}"`);
+    res.setHeader('Accept-Ranges', 'bytes');
+    createReadStream(abs).pipe(res);
+});
 export default router;
 //# sourceMappingURL=file.js.map

package/dist/routes/skill.js

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { listSkills, importSkill, toggleFavorite, updateSkillContent, deleteSkill, checkSkillSync, syncSkills } from '../services/skill.js';
+import { listSkills, importSkill, importSkillsBatch, toggleFavorite, toggleEnabled, toggleAllEnabled, updateSkillContent, deleteSkill, checkSkillSync, syncSkills } from '../services/skill.js';
 const router = Router();
 router.get('/', (_req, res) => {
     res.json(listSkills());
@@ -17,19 +17,42 @@ router.post('/sync', (req, res) => {
     res.json({ synced });
 });
 router.post('/import', (req, res) => {
-    const { filename, content } = req.body;
+    const { filename, content, group } = req.body;
     if (!filename || !content) {
         res.status(400).json({ error: 'filename and content required' });
         return;
     }
-    const skill = importSkill(filename, content);
+    const skill = importSkill(filename, content, group);
     res.json(skill);
 });
+router.post('/import-batch', (req, res) => {
+    const { items } = req.body;
+    if (!Array.isArray(items) || items.length === 0) {
+        res.status(400).json({ error: 'items required' });
+        return;
+    }
+    const skills = importSkillsBatch(items);
+    res.json(skills);
+});
 router.post('/:name/favorite', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const favorited = toggleFavorite(name);
     res.json({ favorited });
 });
+router.post('/:name/toggle', (req, res) => {
+    const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
+    const enabled = toggleEnabled(name);
+    res.json({ enabled });
+});
+router.post('/toggle-all', (req, res) => {
+    const { names, enabled } = req.body;
+    if (!Array.isArray(names) || typeof enabled !== 'boolean') {
+        res.status(400).json({ error: 'names and enabled required' });
+        return;
+    }
+    toggleAllEnabled(names, enabled);
+    res.json({ success: true });
+});
 router.put('/:name', (req, res) => {
     const name = typeof req.params.name === 'string' ? req.params.name : req.params.name[0];
     const { content } = req.body;

package/dist/services/agent.js

@@ -346,7 +346,13 @@ export function getAvailableSkillNames(agentDir, skills) {
         .filter((skill) => {
         if (!skill)
             return false;
-        const skillFile = join(agentDir, 'skills', `${skill}.md`);
+        const skillsBase = join(agentDir, 'skills');
+        // Check folder structure first, then flat .md
+        const skillFolder = join(skillsBase, skill);
+        if (existsSync(skillFolder) && statSync(skillFolder).isDirectory()) {
+            return readdirSync(skillFolder).some((f) => f.endsWith('.md'));
+        }
+        const skillFile = join(skillsBase, `${skill}.md`);
         return existsSync(skillFile) && statSync(skillFile).size > 0;
     });
 }
@@ -448,25 +454,43 @@ function writeAgentTemplate(preset, skillInputs) {
     else if (preset.skills?.length) {
         const globalSkillsDir = join(getDataDir(), 'skills');
         const keepFiles = new Set(preset.skills.map((s) => s.endsWith('.md') ? s : `${s}.md`));
-        // Remove skill files no longer in the list
+        const keepNames = new Set(preset.skills.map((s) => s.replace(/\.md$/i, '')));
+        // Remove skill entries no longer in the list (flat .md files and folders)
         if (existsSync(skillsDir)) {
             for (const existing of readdirSync(skillsDir)) {
-                if (existing.endsWith('.md') && !keepFiles.has(existing)) {
-                    rmSync(join(skillsDir, existing), { force: true });
+                const name = existing.endsWith('.md') ? existing.replace(/\.md$/i, '') : existing;
+                if (!keepNames.has(name)) {
+                    rmSync(join(skillsDir, existing), { recursive: true, force: true });
                     console.log('[writeAgentTemplate] removed stale skill:', existing);
                 }
             }
         }
-        // Copy / ensure skill files
-        for (const filename of keepFiles) {
-            const target = join(skillsDir, filename);
-            const globalSource = join(globalSkillsDir, filename);
-            console.log('[writeAgentTemplate] skill:', filename, 'globalExists:', existsSync(globalSource), 'targetExists:', existsSync(target));
-            if (existsSync(globalSource)) {
-                copyFileSync(globalSource, target);
+        // Copy / ensure skill files (global skills are folders: skills/{name}/SKILL.md)
+        for (const skillName of keepNames) {
+            const globalFolder = join(globalSkillsDir, skillName);
+            const flatTarget = join(skillsDir, `${skillName}.md`);
+            const folderTarget = join(skillsDir, skillName);
+            console.log('[writeAgentTemplate] skill:', skillName, 'globalFolder:', globalFolder, 'globalExists:', existsSync(globalFolder) && statSync(globalFolder).isDirectory());
+            if (existsSync(globalFolder) && statSync(globalFolder).isDirectory()) {
+                // Copy entire skill folder
+                if (existsSync(folderTarget)) {
+                    rmSync(folderTarget, { recursive: true, force: true });
+                }
+                cpSync(globalFolder, folderTarget, { recursive: true, force: true });
+                // Remove stale flat .md if it exists
+                if (existsSync(flatTarget)) {
+                    rmSync(flatTarget, { force: true });
+                }
             }
-            else if (!existsSync(target)) {
-                writeFileSync(target, '', 'utf-8');
+            else {
+                // Fallback: single SKILL.md or legacy flat file
+                const globalSkillFile = join(globalFolder, 'SKILL.md');
+                if (existsSync(globalSkillFile)) {
+                    copyFileSync(globalSkillFile, flatTarget);
+                }
+                else if (!existsSync(flatTarget) && !existsSync(folderTarget)) {
+                    writeFileSync(flatTarget, '', 'utf-8');
+                }
             }
         }
     }
@@ -492,9 +516,14 @@ function copyAgentTemplateToWorkspace(agentId, agentspaceDir) {
     if (existsSync(skillsDir)) {
         const workspaceSkillsDir = join(agentspaceDir, 'skills');
         ensureDir(workspaceSkillsDir);
-        for (const file of readdirSync(skillsDir)) {
-            if (extname(file).toLowerCase() === '.md') {
-                copyFileSync(join(skillsDir, file), join(workspaceSkillsDir, file));
+        for (const entry of readdirSync(skillsDir)) {
+            const source = join(skillsDir, entry);
+            const sourceStat = statSync(source);
+            if (sourceStat.isDirectory()) {
+                cpSync(source, join(workspaceSkillsDir, entry), { recursive: true, force: true });
+            }
+            else if (sourceStat.isFile() && extname(entry).toLowerCase() === '.md') {
+                copyFileSync(source, join(workspaceSkillsDir, entry));
             }
         }
     }

package/dist/services/persistent-agent-context.js

@@ -1,6 +1,6 @@
 import { existsSync, realpathSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { getDataDir } from '../storage/json-store.js';
 import { readWorkspacePrompt } from './workspace-prompt.js';
 const INSTRUCTION_FILENAMES = ['CLAUDE.md', 'claude.md', 'AGENTS.md', 'agents.md'];
@@ -13,10 +13,8 @@ export function prependPersistentAgentContext(prompt, options) {
     return `${context}\n\n${prompt}`;
 }
 export function buildPersistentAgentContext(options) {
+    const { instructionContext } = buildPersistentAgentContextDetails(options);
     const sections = [];
-    const instructionContext = buildInstructionFileContext(options.workingDir, options.boundDirs, {
-        excludeNativeClaudeMd: options.excludeNativeClaudeMd,
-    });
     if (instructionContext)
         sections.push(instructionContext);
     if (options.includeWorkspacePrompt !== false) {
@@ -30,8 +28,20 @@ export function buildPersistentAgentContext(options) {
     }
     return sections.join('\n\n');
 }
+export function buildPersistentAgentContextDetails(options) {
+    const instructionFiles = collectInstructionFiles(options.workingDir, options.boundDirs, {
+        excludeNativeClaudeMd: options.excludeNativeClaudeMd,
+    });
+    return {
+        instructionContext: buildInstructionFileContextFromFiles(instructionFiles),
+        summary: buildPersistentAgentContextSummary(instructionFiles),
+    };
+}
 function buildInstructionFileContext(workingDir, boundDirs, options = {}) {
     const files = collectInstructionFiles(workingDir, boundDirs, options);
+    return buildInstructionFileContextFromFiles(files);
+}
+function buildInstructionFileContextFromFiles(files) {
     if (files.length === 0)
         return '';
     const lines = [
@@ -51,6 +61,28 @@ function buildInstructionFileContext(workingDir, boundDirs, options = {}) {
     }
     return lines.join('\n').trim();
 }
+function buildPersistentAgentContextSummary(files) {
+    const instructionFiles = files.map((file) => ({
+        path: file.path,
+        label: file.label,
+        filename: file.filename,
+    }));
+    const counts = instructionFiles.reduce((acc, file) => {
+        acc.total += 1;
+        if (file.filename === 'CLAUDE.md' || file.filename === 'claude.md') {
+            acc.claudeMd += 1;
+        }
+        if (file.filename === 'AGENTS.md' || file.filename === 'agents.md') {
+            acc.agentsMd += 1;
+        }
+        return acc;
+    }, {
+        claudeMd: 0,
+        agentsMd: 0,
+        total: 0,
+    });
+    return { instructionFiles, counts };
+}
 function collectInstructionFiles(workingDir, boundDirs, options = {}) {
     const cwd = resolve(workingDir || process.cwd());
     const seen = new Set();
@@ -125,6 +157,7 @@ function addInstructionFile(files, seen, path, label) {
     files.push({
         path: realPath,
         label,
+        filename: basename(realPath),
         content: readFileSync(path, 'utf-8').trim(),
     });
 }