wyrm-mcp 7.3.2 → 7.4.0

package/dist/sync.js

@@ -1,5 +1,359 @@
-import{watch as y,existsSync as d,readFileSync as u,writeFileSync as m,mkdirSync as S,statSync as x}from"fs";import{join as $,basename as C,resolve as f,normalize as p,relative as b,sep as P}from"path";function h(a,s){const i=p(f(a)),o=p(f(a,s)),t=b(i,o);if(t.startsWith("..")||t.startsWith(P))throw new Error("SECURITY: Path traversal detected");if(!o.startsWith(i))throw new Error("SECURITY: Path traversal detected");return o}function g(a){const s=p(f(a));if(!d(s))throw new Error(`Project path does not exist: ${a}`);if(!x(s).isDirectory())throw new Error(`Project path is not a directory: ${a}`);return s}class q{db;watchers=new Map;constructor(s){this.db=s}importFromFolder(s){const i=g(s),o=h(i,".wyrm");if(!d(o))throw new Error(`No .wyrm folder found at ${i}`);const t=C(i);let n=this.db.getProject(i);n||(n=this.db.registerProject(t,i));const e=h(o,"hoard.md");if(d(e)){const c=u(e,"utf-8");this.parseHoard(n.id,c)}const r=h(o,"chronicles.md");if(d(r)){const c=u(r,"utf-8");this.parseChronicles(n.id,c)}const l=h(o,"quests.md");if(d(l)){const c=u(l,"utf-8");this.parseQuests(n.id,c)}return n}exportToFolder(s){const i=g(s),o=this.db.getProject(i);if(!o)throw new Error(`Project not found: ${i}`);const t=h(i,".wyrm");d(t)||S(t,{recursive:!0});const n=this.generateHoard(o);m(h(t,"hoard.md"),n);const e=this.generateChronicles(o.id);m(h(t,"chronicles.md"),e);const r=this.generateQuests(o.id);m(h(t,"quests.md"),r)}watchFolder(s){const i=$(s,".wyrm");if(!d(i))return;this.watchers.has(s)&&this.watchers.get(s).close();const o=y(i,{recursive:!0},(t,n)=>{n&&n.endsWith(".md")&&(console.log(`[Wyrm] File changed: ${n}`),this.importFromFolder(s))});this.watchers.set(s,o)}stopWatching(s){const i=this.watchers.get(s);i&&(i.close(),this.watchers.delete(s))}parseHoard(s,i){const o=this.splitSections(i);for(const[t,n]of Object.entries(o)){const e=t.toLowerCase().replace(/[^a-z0-9]+/g,"_");this.db.setContext(s,e,n)}}parseChronicles(s,i){const o=/## Session:\s*(\d{4}-\d{2}-\d{2})([\s\S]*?)(?=## Session:|$)/g;let t;for(;(t=o.exec(i))!==null;){const n=t[1],e=t[2],r=this.db.getTodaySession(s);r&&r.date===n?this.db.updateSession(r.id,this.parseSessionBody(e)):this.db.createSession(s,{date:n,...this.parseSessionBody(e)})}}parseSessionBody(s){const i={},o=this.extractSection(s,"Objectives","Mission");o&&(i.objectives=o);const t=this.extractSection(s,"Completed","Done","Quests Completed");t&&(i.completed=t);const n=this.extractSection(s,"Issues","Problems","Battles","Fixed");n&&(i.issues=n);const e=this.extractSection(s,"Commits");e&&(i.commits=e);const r=this.extractSection(s,"Files","Changed");r&&(i.files_changed=r);const l=this.extractSection(s,"Notes","Wisdom");return l&&(i.notes=l),i}parseQuests(s,i){const o=i.split(`
-`);let t="medium";const n=new Set(this.db.getPendingQuests(s).map(e=>e.title));for(const e of o){e.match(/critical|urgent/i)?t="critical":e.match(/high/i)?t="high":e.match(/medium/i)?t="medium":e.match(/low|future|backlog/i)&&(t="low");const r=e.match(/^[\s]*[-*]\s*\[([x\s])\]\s*\*?\*?(.+?)\*?\*?\s*$/i);if(r){const l=r[1].toLowerCase()==="x",c=r[2].trim();if(!n.has(c)){const w=this.db.addQuest(s,c,"",t);l&&this.db.updateQuest(w.id,"completed"),n.add(c)}}}}generateHoard(s){const i=this.db.getAllContext(s.id),o=[`# Wyrm Hoard // ${s.name}`,"",`> **Last Updated:** ${new Date().toISOString().split("T")[0]}`,`> **Project:** ${s.name}`,s.repo?`> **Repo:** ${s.repo}`:"","","---",""];for(const[t,n]of Object.entries(i)){const e=t.replace(/_/g," ").replace(/\b\w/g,r=>r.toUpperCase());o.push(`## ${e}`,"",n,"")}return o.filter(t=>t!==void 0).join(`
-`)}generateChronicles(s){const i=this.db.getRecentSessions(s,20),o=["# Wyrm Chronicles","","> Session history","","---",""];for(const t of i)o.push(`## Session: ${t.date}`,""),t.objectives&&o.push("### Objectives",t.objectives,""),t.completed&&o.push("### Completed",t.completed,""),t.issues&&o.push("### Issues Solved",t.issues,""),t.commits&&o.push("### Commits",t.commits,""),t.files_changed&&o.push("### Files Changed",t.files_changed,""),t.notes&&o.push("### Notes",t.notes,""),o.push("---","");return o.join(`
-`)}generateQuests(s){const i=this.db.getPendingQuests(s),o=this.db.getRecentlyCompleted(s,10),t=["# Wyrm Quests","","> Task queue","","---",""],n={critical:i.filter(e=>e.priority==="critical"),high:i.filter(e=>e.priority==="high"),medium:i.filter(e=>e.priority==="medium"),low:i.filter(e=>e.priority==="low")};if(n.critical.length>0){t.push("## Critical","");for(const e of n.critical)t.push(`- [ ] **${e.title}**${e.description?` - ${e.description}`:""}`);t.push("")}if(n.high.length>0){t.push("## High Priority","");for(const e of n.high)t.push(`- [ ] **${e.title}**${e.description?` - ${e.description}`:""}`);t.push("")}if(n.medium.length>0){t.push("## Medium Priority","");for(const e of n.medium)t.push(`- [ ] ${e.title}${e.description?` - ${e.description}`:""}`);t.push("")}if(n.low.length>0){t.push("## Low Priority / Future","");for(const e of n.low)t.push(`- [ ] ${e.title}`);t.push("")}if(o.length>0){t.push("## Completed","");for(const e of o)t.push(`- [x] ${e.title} (${e.completed_at?.split("T")[0]})`);t.push("")}return t.join(`
-`)}splitSections(s){const i={},o=/^##\s+(.+?)$/gm;let t="",n=0,e;for(;(e=o.exec(s))!==null;)t&&(i[t]=s.slice(n,e.index).trim()),t=e[1],n=e.index+e[0].length;return t&&(i[t]=s.slice(n).trim()),i}extractSection(s,...i){for(const o of i){const t=new RegExp(`###?\\s*${o}[^\\n]*\\n([\\s\\S]*?)(?=###|$)`,"i"),n=s.match(t);if(n)return n[1].trim()}}}export{q as WyrmSync};
+/**
+ * Wyrm File Sync - Watches and syncs .wyrm folder with database
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ *
+ * - Watches for changes to markdown files
+ * - Syncs changes to SQLite database
+ * - Exports database state back to markdown
+ */
+import { watch, existsSync, readFileSync, writeFileSync, mkdirSync, statSync } from 'fs';
+import { join, basename, resolve, normalize, relative, sep } from 'path';
+// ==================== PATH SECURITY ====================
+/**
+ * SECURITY: Validate path is within the base directory
+ */
+function validatePath(basePath, targetPath) {
+    const normalizedBase = normalize(resolve(basePath));
+    const normalizedTarget = normalize(resolve(basePath, targetPath));
+    // Check if target is within base
+    const rel = relative(normalizedBase, normalizedTarget);
+    if (rel.startsWith('..') || rel.startsWith(sep)) {
+        throw new Error('SECURITY: Path traversal detected');
+    }
+    if (!normalizedTarget.startsWith(normalizedBase)) {
+        throw new Error('SECURITY: Path traversal detected');
+    }
+    return normalizedTarget;
+}
+/**
+ * SECURITY: Validate project path is a real directory
+ */
+function validateProjectPath(projectPath) {
+    const normalizedPath = normalize(resolve(projectPath));
+    if (!existsSync(normalizedPath)) {
+        throw new Error(`Project path does not exist: ${projectPath}`);
+    }
+    if (!statSync(normalizedPath).isDirectory()) {
+        throw new Error(`Project path is not a directory: ${projectPath}`);
+    }
+    return normalizedPath;
+}
+export class WyrmSync {
+    db;
+    watchers = new Map();
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Import markdown files from .wyrm folder into database
+     */
+    importFromFolder(projectPath) {
+        // SECURITY: Validate project path
+        const validatedPath = validateProjectPath(projectPath);
+        const wyrmPath = validatePath(validatedPath, '.wyrm');
+        if (!existsSync(wyrmPath)) {
+            throw new Error(`No .wyrm folder found at ${validatedPath}`);
+        }
+        // Get or create project
+        const projectName = basename(validatedPath);
+        let project = this.db.getProject(validatedPath);
+        if (!project) {
+            project = this.db.registerProject(projectName, validatedPath);
+        }
+        // Import hoard.md - SECURITY: validatePath ensures no traversal
+        const hoardPath = validatePath(wyrmPath, 'hoard.md');
+        if (existsSync(hoardPath)) {
+            const content = readFileSync(hoardPath, 'utf-8');
+            this.parseHoard(project.id, content);
+        }
+        // Import chronicles.md
+        const chroniclesPath = validatePath(wyrmPath, 'chronicles.md');
+        if (existsSync(chroniclesPath)) {
+            const content = readFileSync(chroniclesPath, 'utf-8');
+            this.parseChronicles(project.id, content);
+        }
+        // Import quests.md
+        const questsPath = validatePath(wyrmPath, 'quests.md');
+        if (existsSync(questsPath)) {
+            const content = readFileSync(questsPath, 'utf-8');
+            this.parseQuests(project.id, content);
+        }
+        return project;
+    }
+    /**
+     * Export database state to .wyrm folder
+     */
+    exportToFolder(projectPath) {
+        // SECURITY: Validate project path
+        const validatedPath = validateProjectPath(projectPath);
+        const project = this.db.getProject(validatedPath);
+        if (!project) {
+            throw new Error(`Project not found: ${validatedPath}`);
+        }
+        const wyrmPath = validatePath(validatedPath, '.wyrm');
+        if (!existsSync(wyrmPath)) {
+            mkdirSync(wyrmPath, { recursive: true });
+        }
+        // Export hoard.md - SECURITY: validatePath ensures no traversal
+        const hoardContent = this.generateHoard(project);
+        writeFileSync(validatePath(wyrmPath, 'hoard.md'), hoardContent);
+        // Export chronicles.md
+        const chroniclesContent = this.generateChronicles(project.id);
+        writeFileSync(validatePath(wyrmPath, 'chronicles.md'), chroniclesContent);
+        // Export quests.md
+        const questsContent = this.generateQuests(project.id);
+        writeFileSync(validatePath(wyrmPath, 'quests.md'), questsContent);
+    }
+    /**
+     * Watch .wyrm folder for changes
+     */
+    watchFolder(projectPath) {
+        const wyrmPath = join(projectPath, '.wyrm');
+        if (!existsSync(wyrmPath))
+            return;
+        if (this.watchers.has(projectPath)) {
+            this.watchers.get(projectPath).close();
+        }
+        const watcher = watch(wyrmPath, { recursive: true }, (eventType, filename) => {
+            if (filename && filename.endsWith('.md')) {
+                console.log(`[Wyrm] File changed: ${filename}`);
+                this.importFromFolder(projectPath);
+            }
+        });
+        this.watchers.set(projectPath, watcher);
+    }
+    stopWatching(projectPath) {
+        const watcher = this.watchers.get(projectPath);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(projectPath);
+        }
+    }
+    // Parse hoard.md
+    parseHoard(projectId, content) {
+        const sections = this.splitSections(content);
+        for (const [title, body] of Object.entries(sections)) {
+            const key = title.toLowerCase().replace(/[^a-z0-9]+/g, '_');
+            this.db.setContext(projectId, key, body);
+        }
+    }
+    // Parse chronicles.md
+    parseChronicles(projectId, content) {
+        const sessionRegex = /## Session:\s*(\d{4}-\d{2}-\d{2})([\s\S]*?)(?=## Session:|$)/g;
+        let match;
+        while ((match = sessionRegex.exec(content)) !== null) {
+            const date = match[1];
+            const body = match[2];
+            // Check if session exists
+            const existing = this.db.getTodaySession(projectId);
+            if (existing && existing.date === date) {
+                // Update existing
+                this.db.updateSession(existing.id, this.parseSessionBody(body));
+            }
+            else {
+                // Create new
+                this.db.createSession(projectId, {
+                    date,
+                    ...this.parseSessionBody(body)
+                });
+            }
+        }
+    }
+    parseSessionBody(body) {
+        const result = {};
+        const objectives = this.extractSection(body, 'Objectives', 'Mission');
+        if (objectives)
+            result.objectives = objectives;
+        const completed = this.extractSection(body, 'Completed', 'Done', 'Quests Completed');
+        if (completed)
+            result.completed = completed;
+        const issues = this.extractSection(body, 'Issues', 'Problems', 'Battles', 'Fixed');
+        if (issues)
+            result.issues = issues;
+        const commits = this.extractSection(body, 'Commits');
+        if (commits)
+            result.commits = commits;
+        const files = this.extractSection(body, 'Files', 'Changed');
+        if (files)
+            result.files_changed = files;
+        const notes = this.extractSection(body, 'Notes', 'Wisdom');
+        if (notes)
+            result.notes = notes;
+        return result;
+    }
+    // Parse quests.md
+    parseQuests(projectId, content) {
+        const lines = content.split('\n');
+        let currentPriority = 'medium';
+        // Hoist the dedup lookup out of the per-line loop — re-querying every pending
+        // quest for every markdown line is O(lines × quests). Build the title set once.
+        const existingTitles = new Set(this.db.getPendingQuests(projectId).map((q) => q.title));
+        for (const line of lines) {
+            // Check for priority headers
+            if (line.match(/critical|urgent/i))
+                currentPriority = 'critical';
+            else if (line.match(/high/i))
+                currentPriority = 'high';
+            else if (line.match(/medium/i))
+                currentPriority = 'medium';
+            else if (line.match(/low|future|backlog/i))
+                currentPriority = 'low';
+            // Check for task items
+            const taskMatch = line.match(/^[\s]*[-*]\s*\[([x\s])\]\s*\*?\*?(.+?)\*?\*?\s*$/i);
+            if (taskMatch) {
+                const isCompleted = taskMatch[1].toLowerCase() === 'x';
+                const title = taskMatch[2].trim();
+                // Add quest (avoid duplicates by title)
+                if (!existingTitles.has(title)) {
+                    const quest = this.db.addQuest(projectId, title, '', currentPriority);
+                    if (isCompleted) {
+                        this.db.updateQuest(quest.id, 'completed');
+                    }
+                    existingTitles.add(title);
+                }
+            }
+        }
+    }
+    // Generate hoard.md from database
+    generateHoard(project) {
+        const context = this.db.getAllContext(project.id);
+        const lines = [
+            `# Wyrm Hoard // ${project.name}`,
+            '',
+            `> **Last Updated:** ${new Date().toISOString().split('T')[0]}`,
+            `> **Project:** ${project.name}`,
+            project.repo ? `> **Repo:** ${project.repo}` : '',
+            '',
+            '---',
+            ''
+        ];
+        // Add all context sections
+        for (const [key, value] of Object.entries(context)) {
+            const title = key.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+            lines.push(`## ${title}`, '', value, '');
+        }
+        return lines.filter(l => l !== undefined).join('\n');
+    }
+    // Generate chronicles.md from database
+    generateChronicles(projectId) {
+        const sessions = this.db.getRecentSessions(projectId, 20);
+        const lines = [
+            '# Wyrm Chronicles',
+            '',
+            '> Session history',
+            '',
+            '---',
+            ''
+        ];
+        for (const session of sessions) {
+            lines.push(`## Session: ${session.date}`, '');
+            if (session.objectives) {
+                lines.push('### Objectives', session.objectives, '');
+            }
+            if (session.completed) {
+                lines.push('### Completed', session.completed, '');
+            }
+            if (session.issues) {
+                lines.push('### Issues Solved', session.issues, '');
+            }
+            if (session.commits) {
+                lines.push('### Commits', session.commits, '');
+            }
+            if (session.files_changed) {
+                lines.push('### Files Changed', session.files_changed, '');
+            }
+            if (session.notes) {
+                lines.push('### Notes', session.notes, '');
+            }
+            lines.push('---', '');
+        }
+        return lines.join('\n');
+    }
+    // Generate quests.md from database
+    generateQuests(projectId) {
+        const pending = this.db.getPendingQuests(projectId);
+        const completed = this.db.getRecentlyCompleted(projectId, 10);
+        const lines = [
+            '# Wyrm Quests',
+            '',
+            '> Task queue',
+            '',
+            '---',
+            ''
+        ];
+        const byPriority = {
+            critical: pending.filter(q => q.priority === 'critical'),
+            high: pending.filter(q => q.priority === 'high'),
+            medium: pending.filter(q => q.priority === 'medium'),
+            low: pending.filter(q => q.priority === 'low')
+        };
+        if (byPriority.critical.length > 0) {
+            lines.push('## Critical', '');
+            for (const q of byPriority.critical) {
+                lines.push(`- [ ] **${q.title}**${q.description ? ` - ${q.description}` : ''}`);
+            }
+            lines.push('');
+        }
+        if (byPriority.high.length > 0) {
+            lines.push('## High Priority', '');
+            for (const q of byPriority.high) {
+                lines.push(`- [ ] **${q.title}**${q.description ? ` - ${q.description}` : ''}`);
+            }
+            lines.push('');
+        }
+        if (byPriority.medium.length > 0) {
+            lines.push('## Medium Priority', '');
+            for (const q of byPriority.medium) {
+                lines.push(`- [ ] ${q.title}${q.description ? ` - ${q.description}` : ''}`);
+            }
+            lines.push('');
+        }
+        if (byPriority.low.length > 0) {
+            lines.push('## Low Priority / Future', '');
+            for (const q of byPriority.low) {
+                lines.push(`- [ ] ${q.title}`);
+            }
+            lines.push('');
+        }
+        if (completed.length > 0) {
+            lines.push('## Completed', '');
+            for (const q of completed) {
+                lines.push(`- [x] ${q.title} (${q.completed_at?.split('T')[0]})`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    // Helpers
+    splitSections(content) {
+        const sections = {};
+        const regex = /^##\s+(.+?)$/gm;
+        let lastTitle = '';
+        let lastIndex = 0;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            if (lastTitle) {
+                sections[lastTitle] = content.slice(lastIndex, match.index).trim();
+            }
+            lastTitle = match[1];
+            lastIndex = match.index + match[0].length;
+        }
+        if (lastTitle) {
+            sections[lastTitle] = content.slice(lastIndex).trim();
+        }
+        return sections;
+    }
+    extractSection(body, ...titles) {
+        for (const title of titles) {
+            const regex = new RegExp(`###?\\s*${title}[^\\n]*\\n([\\s\\S]*?)(?=###|$)`, 'i');
+            const match = body.match(regex);
+            if (match) {
+                return match[1].trim();
+            }
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=sync.js.map

package/dist/tasks-dispatch.js

@@ -1 +1,84 @@
-import{GetTaskRequestSchema as i,GetTaskPayloadRequestSchema as o,ListTasksRequestSchema as l,CancelTaskRequestSchema as c}from"@modelcontextprotocol/sdk/types.js";import{toWireTask as n,taskPayload as d,adminGateBlocks as u,adminDeniedResponse as k}from"./tasks.js";function T(s,t){s.setRequestHandler(l,async()=>({tasks:t.list().map(n)})),s.setRequestHandler(i,async a=>{const e=t.get(a.params.taskId);if(!e)throw new Error(`Task not found: ${a.params.taskId}`);return n(e)}),s.setRequestHandler(o,async a=>{const e=d(t,a.params.taskId);if(!e)throw new Error(`Task result not available: ${a.params.taskId}`);return e}),s.setRequestHandler(c,async a=>{t.cancel(a.params.taskId);const e=t.get(a.params.taskId);if(!e)throw new Error(`Task not found: ${a.params.taskId}`);return n(e)})}function p(s,t,a,e){if(!t.asTask)return e;const r=s.create(a,t.ttlMs);return s.settle(r.taskId,e.isError?"failed":"completed",e),{task:n(s.get(r.taskId)??r)}}function y(s,t,a,e){if(!u(a))return null;const r=k(a);return e(r),p(s,t,a,r)}function I(s,t){if(t.kind==="task"){const a=d(s,t.createTask.task.taskId)??{content:[{type:"text",text:""}]};return{wireValue:t.createTask,payload:a}}return{wireValue:t.result,payload:t.result}}export{y as applyAdminGate,p as finalizeEarly,T as registerTaskHandlers,I as unwrapOutcome};
+import { GetTaskRequestSchema, GetTaskPayloadRequestSchema, ListTasksRequestSchema, CancelTaskRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { toWireTask, taskPayload, adminGateBlocks, adminDeniedResponse, } from './tasks.js';
+/**
+ * Register the MCP Tasks RC handlers (tasks/get|result|list|cancel) backed by
+ * the local TaskStore. On a task-augmented CallTool the op ran SYNCHRONOUSLY
+ * and the completed CallToolResult was stored; these serve the lifecycle so a
+ * Tasks-aware client can fetch status / payload / list / cancel. A client that
+ * ignores tasks gets the synchronous fallback (the payload inline on the
+ * original CallTool). Unknown/expired ids surface a clean JSON-RPC error.
+ */
+export function registerTaskHandlers(server, taskStore) {
+    server.setRequestHandler(ListTasksRequestSchema, async () => {
+        return { tasks: taskStore.list().map(toWireTask) };
+    });
+    server.setRequestHandler(GetTaskRequestSchema, async (request) => {
+        const record = taskStore.get(request.params.taskId);
+        if (!record)
+            throw new Error(`Task not found: ${request.params.taskId}`);
+        return toWireTask(record);
+    });
+    server.setRequestHandler(GetTaskPayloadRequestSchema, async (request) => {
+        // The stored CallToolResult for a completed task — the deferred payload the
+        // task path withheld from the CreateTaskResult envelope. Its shape matches
+        // the result of the original tools/call (CallToolResult).
+        const payload = taskPayload(taskStore, request.params.taskId);
+        if (!payload)
+            throw new Error(`Task result not available: ${request.params.taskId}`);
+        return payload;
+    });
+    server.setRequestHandler(CancelTaskRequestSchema, async (request) => {
+        // Wyrm tasks complete synchronously, so a cancel almost always races a
+        // terminal record (no-op). We still honor the verb: a still-working record
+        // (only possible for a concurrent in-flight op) flips to 'cancelled'.
+        taskStore.cancel(request.params.taskId);
+        const record = taskStore.get(request.params.taskId);
+        if (!record)
+            throw new Error(`Task not found: ${request.params.taskId}`);
+        return toWireTask(record);
+    });
+}
+/**
+ * Finalize an EARLY (pre-dispatch) ToolResult — admin denial, cache hit, etc. —
+ * for the wire. Under a `task` augmentation the MCP SDK demands a
+ * CreateTaskResult even for these (returning a plain result is a -32602), so we
+ * record a settled task (completed, or failed for an isError body) and return
+ * its envelope; otherwise the result rides inline unchanged. Keeps every
+ * early-return path crash-free for a task-augmenting client.
+ */
+export function finalizeEarly(taskStore, gate, tool, early) {
+    if (!gate.asTask)
+        return early;
+    const rec = taskStore.create(tool, gate.ttlMs);
+    taskStore.settle(rec.taskId, early.isError ? 'failed' : 'completed', early);
+    return { task: toWireTask(taskStore.get(rec.taskId) ?? rec) };
+}
+/**
+ * Apply the admin gate (T037, Article VII). When `name` is an admin-gated long
+ * op and WYRM_ADMIN is not set, returns the wire value for a deterministic,
+ * non-retryable SEP-1303 denial (task-wrapped when params.task is present, via
+ * finalizeEarly), after firing the supplied telemetry callback. Returns null
+ * when the call is allowed (the dispatcher proceeds). Keeps the admin-gate
+ * branch out of index.ts to hold the quest #80 line ceiling.
+ */
+export function applyAdminGate(taskStore, gate, name, onDenied) {
+    if (!adminGateBlocks(name))
+        return null;
+    const denied = adminDeniedResponse(name);
+    onDenied(denied);
+    return finalizeEarly(taskStore, gate, name, denied);
+}
+/**
+ * Unwrap a {@link LongOpOutcome} for the dispatcher: `payload` is the real
+ * CallToolResult (telemetry/golden use it); `wireValue` is what the SDK
+ * receives — the CreateTaskResult on the task path, the payload on the inline
+ * path. On the task path the payload is read back from the store under its id.
+ */
+export function unwrapOutcome(taskStore, outcome) {
+    if (outcome.kind === 'task') {
+        const payload = taskPayload(taskStore, outcome.createTask.task.taskId) ?? { content: [{ type: 'text', text: '' }] };
+        return { wireValue: outcome.createTask, payload };
+    }
+    return { wireValue: outcome.result, payload: outcome.result };
+}
+//# sourceMappingURL=tasks-dispatch.js.map