@minionry/minion 0.7.36

package/dist/server/services/websocket/skill-handlers.js

@@ -0,0 +1,324 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { execSync } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findSkillsDir } from '../../utils/paths.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SYSTEM_AGENTS_DIR = join(__dirname, '..', 'plan', 'agents');
+export const USER_SKILLS_DIR = join(homedir(), '.claude', 'skills');
+const PLATFORM_COMMANDS = [
+    {
+        name: 'board',
+        displayName: '/board',
+        description: 'Convert the current chat conversation into a PM board with issues.',
+        source: 'platform',
+    },
+    {
+        name: 'ship',
+        displayName: '/ship',
+        description: 'Convert chat into a PM board and auto-implement with AI agents.',
+        source: 'platform',
+    },
+    {
+        name: 'clear',
+        displayName: '/clear',
+        description: 'Start a fresh session in this tab. Drops the conversation context, so the next prompt is not billed for everything before it — use it when switching tasks.',
+        source: 'platform',
+    },
+];
+function parseFrontmatter(content) {
+    if (!content.startsWith('---'))
+        return {};
+    const endIdx = content.indexOf('---', 3);
+    if (endIdx === -1)
+        return {};
+    const yaml = content.slice(3, endIdx).trim();
+    const result = {};
+    for (const line of yaml.split('\n')) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        let val = line.slice(colonIdx + 1).trim();
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+            val = val.slice(1, -1);
+        }
+        result[key] = val;
+    }
+    return result;
+}
+function scanProjectSkills(skillsDir) {
+    if (!existsSync(skillsDir))
+        return [];
+    const entries = [];
+    for (const name of readdirSync(skillsDir, { withFileTypes: true })) {
+        if (!name.isDirectory())
+            continue;
+        const skillFile = join(skillsDir, name.name, 'SKILL.md');
+        if (!existsSync(skillFile))
+            continue;
+        try {
+            const content = readFileSync(skillFile, 'utf-8');
+            const fm = parseFrontmatter(content);
+            if (fm['user-invocable'] === 'false')
+                continue;
+            entries.push({
+                name: fm.name || name.name,
+                displayName: `/${fm.name || name.name}`,
+                description: fm.description || '',
+                source: 'project',
+            });
+        }
+        catch {   }
+    }
+    return entries;
+}
+function tryReadSkill(skillFile) {
+    if (!existsSync(skillFile))
+        return null;
+    try {
+        return parseFrontmatter(readFileSync(skillFile, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function scanUserSkills(userSkillsDir, seen) {
+    if (!existsSync(userSkillsDir))
+        return [];
+    const entries = [];
+    for (const name of readdirSync(userSkillsDir, { withFileTypes: true })) {
+        if (!name.isDirectory() || seen.has(name.name))
+            continue;
+        const fm = tryReadSkill(join(userSkillsDir, name.name, 'SKILL.md'));
+        if (!fm || fm['user-invocable'] === 'false')
+            continue;
+        const skillName = fm.name || name.name;
+        if (seen.has(skillName))
+            continue;
+        entries.push({
+            name: skillName,
+            displayName: `/${skillName}`,
+            description: fm.description || '',
+            source: 'user',
+        });
+    }
+    return entries;
+}
+function scanSystemAgents(agentsDir, seen) {
+    if (!existsSync(agentsDir))
+        return [];
+    const entries = [];
+    for (const file of readdirSync(agentsDir)) {
+        if (!file.endsWith('.md'))
+            continue;
+        const name = file.replace(/\.md$/, '');
+        if (seen.has(name))
+            continue;
+        try {
+            const content = readFileSync(join(agentsDir, file), 'utf-8');
+            const fm = parseFrontmatter(content);
+            if (fm['user-invocable'] === 'false')
+                continue;
+            entries.push({
+                name: fm.name || name,
+                displayName: `/${fm.name || name}`,
+                description: fm.description || '',
+                source: 'system',
+            });
+        }
+        catch {   }
+    }
+    return entries;
+}
+export function collectAllSkills(workingDir) {
+    const skills = [];
+    const seen = new Set();
+    const projectSkillsDir = findSkillsDir(workingDir);
+    if (projectSkillsDir) {
+        for (const s of scanProjectSkills(projectSkillsDir)) {
+            if (!seen.has(s.name)) {
+                skills.push(s);
+                seen.add(s.name);
+            }
+        }
+    }
+    skills.push(...scanUserSkills(USER_SKILLS_DIR, seen));
+    for (const s of skills)
+        seen.add(s.name);
+    for (const cmd of PLATFORM_COMMANDS) {
+        if (!seen.has(cmd.name)) {
+            skills.push(cmd);
+            seen.add(cmd.name);
+        }
+    }
+    skills.push(...scanSystemAgents(SYSTEM_AGENTS_DIR, seen));
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return skills;
+}
+export function handleListSkills(ctx, ws, workingDir) {
+    const skills = collectAllSkills(workingDir);
+    ctx.send(ws, { type: 'skillsList', data: { skills } });
+}
+function extractSkillContent(fileContent) {
+    if (!fileContent.startsWith('---'))
+        return fileContent;
+    const endIdx = fileContent.indexOf('---', 3);
+    if (endIdx === -1)
+        return fileContent;
+    return fileContent.slice(endIdx + 3).trim();
+}
+function tryReadSkillFile(filePath, skillDir, userInvocableOnly, source) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        if (userInvocableOnly && parseFrontmatter(content)['user-invocable'] === 'false')
+            return null;
+        return { content, skillDir, source };
+    }
+    catch {
+        return null;
+    }
+}
+function findSkillContent(skillName, workingDir, userInvocableOnly = false) {
+    const projectSkillsDir = findSkillsDir(workingDir);
+    if (projectSkillsDir) {
+        const skillDir = join(projectSkillsDir, skillName);
+        const found = tryReadSkillFile(join(skillDir, 'SKILL.md'), skillDir, userInvocableOnly, 'project');
+        if (found)
+            return found;
+    }
+    const userSkillDir = join(USER_SKILLS_DIR, skillName);
+    const found = tryReadSkillFile(join(userSkillDir, 'SKILL.md'), userSkillDir, userInvocableOnly, 'user');
+    if (found)
+        return found;
+    const agentFile = join(SYSTEM_AGENTS_DIR, `${skillName}.md`);
+    return tryReadSkillFile(agentFile, SYSTEM_AGENTS_DIR, userInvocableOnly, 'system');
+}
+function fillTemplateVariables(content, vars) {
+    let result = content;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}
+function parseShellArgs(argsStr) {
+    const args = [];
+    let current = '';
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < argsStr.length; i++) {
+        const ch = argsStr[i];
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (ch === ' ' && !inSingle && !inDouble) {
+            if (current) {
+                args.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        args.push(current);
+    return args;
+}
+export function shellEscape(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+const SHELL_BLOCK_RE = /```!\n[\s\S]*?```|!`[^`]+`/g;
+function substituteArgsInSegment(segment, parsedArgs, userArgs, escapeShell) {
+    const wrap = (v) => (escapeShell ? shellEscape(v) : v);
+    let result = segment;
+    result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_, n) => wrap(parsedArgs[parseInt(n, 10)] ?? ''));
+    result = result.replace(/\$(\d+)\b/g, (_, n) => wrap(parsedArgs[parseInt(n, 10)] ?? ''));
+    result = result.replaceAll('$ARGUMENTS', wrap(userArgs));
+    return result;
+}
+export function fillArgumentVariables(content, userArgs) {
+    const parsedArgs = parseShellArgs(userArgs);
+    let result = '';
+    let lastIndex = 0;
+    SHELL_BLOCK_RE.lastIndex = 0;
+    let match;
+    while ((match = SHELL_BLOCK_RE.exec(content)) !== null) {
+        result += substituteArgsInSegment(content.slice(lastIndex, match.index), parsedArgs, userArgs, false);
+        result += substituteArgsInSegment(match[0], parsedArgs, userArgs, true);
+        lastIndex = SHELL_BLOCK_RE.lastIndex;
+    }
+    result += substituteArgsInSegment(content.slice(lastIndex), parsedArgs, userArgs, false);
+    return result;
+}
+function executeInlineShellCommands(content, workingDir, source) {
+    if (source !== 'system' && source !== 'user')
+        return content;
+    let result = content.replace(/```!\n([\s\S]*?)```/g, (_, block) => {
+        const cmd = block.trim();
+        try {
+            return execSync(cmd, { cwd: workingDir, timeout: 10_000, encoding: 'utf-8' }).trim();
+        }
+        catch {
+            return `[shell command failed: ${cmd.split('\n')[0]}]`;
+        }
+    });
+    result = result.replace(/!`([^`]+)`/g, (_, cmd) => {
+        try {
+            return execSync(cmd.trim(), { cwd: workingDir, timeout: 10_000, encoding: 'utf-8' }).trim();
+        }
+        catch {
+            return `[shell command failed: ${cmd.trim()}]`;
+        }
+    });
+    return result;
+}
+function parseSlashCommand(trimmed) {
+    if (!trimmed.startsWith('/'))
+        return null;
+    const spaceIdx = trimmed.indexOf(' ');
+    const skillName = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+    const userArgs = spaceIdx === -1 ? '' : trimmed.slice(spaceIdx + 1).trim();
+    return skillName ? { skillName, userArgs } : null;
+}
+const CLAUDE_SKILL_DIR_RE = /\$\{CLAUDE_SKILL_DIR}/g;
+const CLAUDE_SESSION_ID_RE = /\$\{CLAUDE_SESSION_ID}/g;
+function processSkillContent(rawContent, userArgs, skillDir, workingDir, source) {
+    let content = extractSkillContent(rawContent);
+    content = fillTemplateVariables(content, {
+        dirPath: userArgs || workingDir,
+        cliFindingsSection: '',
+    });
+    const hasArgumentsPlaceholder = /\$ARGUMENTS|\$\d+\b/.test(content);
+    if (hasArgumentsPlaceholder) {
+        content = fillArgumentVariables(content, userArgs);
+    }
+    content = content.replace(CLAUDE_SKILL_DIR_RE, skillDir);
+    content = content.replace(CLAUDE_SESSION_ID_RE, `minionry-${Date.now()}`);
+    if (/!`[^`]+`/.test(content) || /```!\n/.test(content)) {
+        content = executeInlineShellCommands(content, workingDir, source);
+    }
+    if (userArgs && !hasArgumentsPlaceholder && !rawContent.includes('{{dirPath}}')) {
+        content = `${content}\n\nARGUMENTS: ${userArgs}`;
+    }
+    return content;
+}
+export function resolveSkillPrompt(prompt, workingDir) {
+    const parsed = parseSlashCommand(prompt.trim());
+    if (!parsed)
+        return null;
+    const found = findSkillContent(parsed.skillName, workingDir, true);
+    if (!found)
+        return null;
+    const skillPrompt = processSkillContent(found.content, parsed.userArgs, found.skillDir, workingDir, found.source);
+    return { prompt: skillPrompt, skillName: parsed.skillName, userArgs: parsed.userArgs };
+}

package/dist/server/services/websocket/skill-watcher.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { watch } from 'node:fs';
+import { findSkillsDir } from '../../utils/paths.js';
+import { collectAllSkills, USER_SKILLS_DIR } from './skill-handlers.js';
+export class SkillsWatcher {
+    workingDir;
+    ctx;
+    userWatcher = null;
+    projectWatcher = null;
+    debounceTimer = null;
+    lastSkillsHash = '';
+    started = false;
+    constructor(workingDir, ctx) {
+        this.workingDir = workingDir;
+        this.ctx = ctx;
+    }
+    start() {
+        if (this.started)
+            return;
+        this.lastSkillsHash = this.computeHash();
+        try {
+            this.userWatcher = watch(USER_SKILLS_DIR, { recursive: true }, (_event, filename) => {
+                if (!filename?.endsWith('.md'))
+                    return;
+                this.debounce();
+            });
+            this.userWatcher.on('error', () => { });
+        }
+        catch {   }
+        const projectSkillsDir = findSkillsDir(this.workingDir);
+        if (projectSkillsDir) {
+            try {
+                this.projectWatcher = watch(projectSkillsDir, { recursive: true }, (_event, filename) => {
+                    if (!filename?.endsWith('.md'))
+                        return;
+                    this.debounce();
+                });
+                this.projectWatcher.on('error', () => { });
+            }
+            catch {   }
+        }
+        this.started = true;
+    }
+    stop() {
+        if (this.userWatcher) {
+            this.userWatcher.close();
+            this.userWatcher = null;
+        }
+        if (this.projectWatcher) {
+            this.projectWatcher.close();
+            this.projectWatcher = null;
+        }
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.started = false;
+    }
+    debounce() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+            this.handleChange();
+        }, 250);
+    }
+    handleChange() {
+        try {
+            const skills = collectAllSkills(this.workingDir);
+            const hash = JSON.stringify(skills.map(s => `${s.name}:${s.source}:${s.description}`));
+            if (hash === this.lastSkillsHash)
+                return;
+            this.lastSkillsHash = hash;
+            this.ctx.broadcastToAll({ type: 'skillsList', data: { skills } });
+        }
+        catch {
+        }
+    }
+    computeHash() {
+        const skills = collectAllSkills(this.workingDir);
+        return JSON.stringify(skills.map(s => `${s.name}:${s.source}:${s.description}`));
+    }
+}

package/dist/server/services/websocket/snippet-handlers.js

@@ -0,0 +1,261 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import Fuse from 'fuse.js';
+import { parseFrontMatter } from '../plan/parser-core.js';
+const MAX_RESULTS = 12;
+const PREVIEW_CHARS = 140;
+const FUSE_OPTIONS = {
+    keys: [
+        { name: 'name', weight: 0.7 },
+        { name: 'aliases', weight: 0.2 },
+        { name: 'description', weight: 0.1 },
+    ],
+    threshold: 0.4,
+    includeMatches: true,
+    ignoreLocation: true,
+};
+function buildPreview(body) {
+    const collapsed = body.replace(/\s+/g, ' ').trim();
+    if (collapsed.length <= PREVIEW_CHARS)
+        return collapsed;
+    return `${collapsed.slice(0, PREVIEW_CHARS - 1).trimEnd()}…`;
+}
+function toSuggestion(snippet, matchedIndices) {
+    return {
+        name: snippet.name,
+        aliases: snippet.aliases,
+        description: snippet.description,
+        origin: snippet.origin,
+        preview: buildPreview(snippet.body),
+        bodyLength: snippet.body.length,
+        matchedIndices,
+    };
+}
+export function rankAllSnippets(snippets) {
+    return [...snippets]
+        .sort((a, b) => {
+        if (a.origin !== b.origin)
+            return a.origin === 'project' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    })
+        .slice(0, MAX_RESULTS)
+        .map((s) => toSuggestion(s, []));
+}
+export function rankQuerySnippets(snippets, query) {
+    const fuse = new Fuse(snippets, FUSE_OPTIONS);
+    const results = fuse.search(query, { limit: MAX_RESULTS });
+    return results.map((r) => {
+        const nameMatch = r.matches?.find((m) => m.key === 'name');
+        const indices = nameMatch?.indices
+            ? nameMatch.indices.map(([s, e]) => [s, e + 1])
+            : [];
+        return toSuggestion(r.item, indices);
+    });
+}
+const VALID_SNIPPET_NAME_RE = /^[a-z][a-z0-9-]*$/;
+function sanitizeSnippetName(raw) {
+    const cleaned = raw.toLowerCase().trim();
+    return VALID_SNIPPET_NAME_RE.test(cleaned) ? cleaned : null;
+}
+function buildSnippetFile(description, body) {
+    const trimmedBody = body.trim();
+    const desc = description.replace(/[\r\n]+/g, ' ').replace(/"/g, "'").trim();
+    if (!desc)
+        return `${trimmedBody}\n`;
+    return `---\ndescription: "${desc}"\n---\n\n${trimmedBody}\n`;
+}
+export function handleSnippetMessage(ctx, ws, msg, tabId) {
+    switch (msg.type) {
+        case 'snippetAutocomplete':
+            handleSnippetAutocomplete(ctx, ws, msg, tabId);
+            return;
+        case 'snippetList':
+            handleSnippetList(ctx, ws, msg, tabId);
+            return;
+        case 'snippetCreate':
+            handleSnippetCreate(ctx, ws, msg, tabId);
+            return;
+        case 'snippetGet':
+            handleSnippetGet(ctx, ws, msg, tabId);
+            return;
+        case 'snippetUpdate':
+            handleSnippetUpdate(ctx, ws, msg, tabId);
+            return;
+        default:
+            throw new Error(`Unknown snippet message type: ${msg.type}`);
+    }
+}
+function handleSnippetAutocomplete(ctx, ws, msg, tabId) {
+    const registry = ctx.snippetRegistry;
+    if (!registry) {
+        ctx.send(ws, { type: 'snippetSuggestions', tabId, data: { suggestions: [], query: '' } });
+        return;
+    }
+    const queryRaw = typeof msg.data?.query === 'string' ? msg.data.query : '';
+    const query = queryRaw.trim().toLowerCase();
+    const all = registry.list();
+    const suggestions = query.length === 0 ? rankAllSnippets(all) : rankQuerySnippets(all, query);
+    ctx.send(ws, { type: 'snippetSuggestions', tabId, data: { suggestions, query: queryRaw } });
+}
+export function buildSnippetListResultData(registry) {
+    const all = registry ? registry.list() : [];
+    return {
+        snippets: all.map((s) => ({
+            name: s.name,
+            aliases: s.aliases,
+            description: s.description,
+            origin: s.origin,
+            sourcePath: s.sourcePath,
+            bodyLength: s.body.length,
+        })),
+    };
+}
+function handleSnippetList(ctx, ws, _msg, tabId) {
+    ctx.send(ws, {
+        type: 'snippetListResult',
+        tabId,
+        data: buildSnippetListResultData(ctx.snippetRegistry),
+    });
+}
+function handleSnippetCreate(ctx, ws, msg, tabId) {
+    const reply = (data) => ctx.send(ws, { type: 'snippetCreateResult', tabId, data });
+    const registry = ctx.snippetRegistry;
+    if (!registry) {
+        reply({ success: false, error: 'Snippets are not available yet — connect a machine first.' });
+        return;
+    }
+    const rawName = typeof msg.data?.name === 'string' ? msg.data.name : '';
+    const body = typeof msg.data?.body === 'string' ? msg.data.body : '';
+    const description = typeof msg.data?.description === 'string' ? msg.data.description : '';
+    const origin = msg.data?.origin === 'project' ? 'project' : 'personal';
+    const scopeLabel = origin === 'personal' ? 'global' : 'project';
+    const name = sanitizeSnippetName(rawName);
+    if (!name) {
+        reply({
+            success: false,
+            error: 'Name must be lowercase letters, numbers, and hyphens, and start with a letter.',
+        });
+        return;
+    }
+    if (!body.trim()) {
+        reply({ success: false, error: 'Snippet content cannot be empty.' });
+        return;
+    }
+    const dir = registry.sourceDir(origin);
+    if (!dir) {
+        reply({ success: false, error: `No ${scopeLabel} snippet directory is configured.` });
+        return;
+    }
+    const filePath = join(dir, `${name}.md`);
+    if (existsSync(filePath)) {
+        reply({ success: false, error: `A ${scopeLabel} snippet named #${name} already exists.` });
+        return;
+    }
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(filePath, buildSnippetFile(description, body), 'utf-8');
+        registry.reload();
+        reply({ success: true, name, origin });
+    }
+    catch (error) {
+        reply({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to write snippet file.',
+        });
+    }
+}
+function handleSnippetGet(ctx, ws, msg, tabId) {
+    const reply = (data) => ctx.send(ws, { type: 'snippetGetResult', tabId, data });
+    const registry = ctx.snippetRegistry;
+    if (!registry) {
+        reply({ success: false, error: 'Snippets are not available yet — connect a machine first.' });
+        return;
+    }
+    const rawName = typeof msg.data?.name === 'string' ? msg.data.name : '';
+    const origin = msg.data?.origin === 'project' ? 'project' : 'personal';
+    const scopeLabel = origin === 'personal' ? 'global' : 'project';
+    const name = sanitizeSnippetName(rawName);
+    if (!name) {
+        reply({ success: false, error: 'Invalid snippet name.' });
+        return;
+    }
+    const dir = registry.sourceDir(origin);
+    if (!dir) {
+        reply({ success: false, error: `No ${scopeLabel} snippet directory is configured.` });
+        return;
+    }
+    const filePath = join(dir, `${name}.md`);
+    if (!existsSync(filePath)) {
+        reply({ success: false, error: 'Snippet not found.' });
+        return;
+    }
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        reply({ success: false, error: 'Could not read snippet file.' });
+        return;
+    }
+    try {
+        const { frontMatter, body } = parseFrontMatter(raw);
+        reply({
+            success: true,
+            name,
+            origin,
+            body: body.trim(),
+            description: typeof frontMatter.description === 'string' ? frontMatter.description : '',
+        });
+    }
+    catch {
+        reply({ success: false, error: 'Could not parse snippet file.' });
+    }
+}
+function handleSnippetUpdate(ctx, ws, msg, tabId) {
+    const reply = (data) => ctx.send(ws, { type: 'snippetUpdateResult', tabId, data });
+    const registry = ctx.snippetRegistry;
+    if (!registry) {
+        reply({ success: false, error: 'Snippets are not available yet — connect a machine first.' });
+        return;
+    }
+    const rawName = typeof msg.data?.name === 'string' ? msg.data.name : '';
+    const body = typeof msg.data?.body === 'string' ? msg.data.body : '';
+    const description = typeof msg.data?.description === 'string' ? msg.data.description : '';
+    const origin = msg.data?.origin === 'project' ? 'project' : 'personal';
+    const scopeLabel = origin === 'personal' ? 'global' : 'project';
+    const name = sanitizeSnippetName(rawName);
+    if (!name) {
+        reply({
+            success: false,
+            error: 'Name must be lowercase letters, numbers, and hyphens, and start with a letter.',
+        });
+        return;
+    }
+    if (!body.trim()) {
+        reply({ success: false, error: 'Snippet content cannot be empty.' });
+        return;
+    }
+    const dir = registry.sourceDir(origin);
+    if (!dir) {
+        reply({ success: false, error: `No ${scopeLabel} snippet directory is configured.` });
+        return;
+    }
+    const filePath = join(dir, `${name}.md`);
+    if (!existsSync(filePath)) {
+        reply({ success: false, error: `A ${scopeLabel} snippet named #${name} doesn't exist.` });
+        return;
+    }
+    try {
+        writeFileSync(filePath, buildSnippetFile(description, body), 'utf-8');
+        registry.reload();
+        reply({ success: true, name, origin });
+    }
+    catch (error) {
+        reply({
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to write snippet file.',
+        });
+    }
+}

package/dist/server/services/websocket/tab-broadcast.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { mirrorTabEventToSdk } from '../sdk/agents.js';
+import { isTimelineTabEvent } from '../timeline/index.js';
+export function broadcastTabEvent(ctx, tabId, type, data, engine) {
+    const buffer = ctx.tabEventBuffers.getOrCreate(tabId);
+    const seq = buffer.record(type, data);
+    const envelope = { type, tabId, data, seq };
+    if (engine)
+        envelope.engine = engine;
+    ctx.broadcastToAll(envelope);
+    mirrorTabEventToSdk(tabId, type, data, (response) => ctx.broadcastToAll(response));
+    assembleTabTimeline(ctx, tabId, type, data, engine);
+    return seq;
+}
+function assembleTabTimeline(ctx, tabId, type, data, engine) {
+    if (!isTimelineTabEvent(type))
+        return;
+    let events;
+    try {
+        events = ctx.chatTimelines.getOrCreate(tabId).ingest(type, data, engine);
+    }
+    catch (err) {
+        console.error(`[timeline] assembly failed tabId=${tabId} type=${type}:`, err);
+        return;
+    }
+    for (const event of events) {
+        broadcastTabEvent(ctx, tabId, 'timelineEvent', event, engine);
+    }
+}
+export function broadcastTimelineEvents(ctx, tabId, events, engine) {
+    for (const event of events) {
+        broadcastTabEvent(ctx, tabId, 'timelineEvent', event, engine);
+    }
+}