wyrm-mcp 7.2.0 → 7.2.2

package/dist/handlers/project.js

@@ -1,182 +1,28 @@
-/**
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later
- */
-import { TOOL_ANNOTATIONS } from "../tool-annotations.js";
-import { currentReadCacheKey } from "./boundary.js";
-import { cache } from "../performance.js";
-import { createContextBundle } from "../summarizer.js";
-export const projectToolSpecs = [
-    {
-        name: "wyrm_scan_projects",
-        description: "Scan a directory for git projects and register them. Use this to auto-discover all projects.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Directory path to scan (e.g., /home/user/Git Projects)" },
-                watch: { type: "boolean", description: "Add to watch list for future auto-scans" },
-                recursive: { type: "boolean", description: "Scan subdirectories recursively" },
-            },
-            required: ["path"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_scan_projects"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const { path, watch, recursive } = args;
-            if (watch) {
-                db.addWatchDir(path, recursive !== false);
-            }
-            const projects = db.scanForProjects(path, recursive !== false);
-            return {
-                content: [{
-                        type: "text",
-                        text: `󱅝 Scanned ${path}\n\nDiscovered ${projects.length} projects:\n${projects.map(p => `- ${p.name} (${p.stack || 'unknown'}) - ${p.branch || 'no branch'}`).join('\n')}${watch ? '\n\nAdded to watch list for future auto-scans.' : ''}`
-                    }]
-            };
-        },
-    },
-    {
-        name: "wyrm_list_projects",
-        description: "List all registered projects with their status",
-        inputSchema: {
-            type: "object",
-            properties: {
-                search: { type: "string", description: "Search query to filter projects" },
-                limit: { type: "number", description: "Max projects to return" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_list_projects"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { search, limit } = args;
-            const projects = search
-                ? db.searchProjects(search)
-                : db.getAllProjects(limit || 50);
-            const projectList = projects.map(p => {
-                const stats = db.getProjectStats(p.id);
-                return `## ${p.name}\n` +
-                    `- **Path:** ${p.path}\n` +
-                    `- **Stack:** ${p.stack || 'unknown'}\n` +
-                    `- **Branch:** ${p.branch || 'N/A'}\n` +
-                    `- **Sessions:** ${stats.sessions} | **Quests:** ${stats.quests.pending}p/${stats.quests.completed}c\n` +
-                    `- **Data:** ${stats.dataPoints}`;
-            }).join('\n\n');
-            const response = cachedResponse(`󱅝 **${projects.length} Projects**\n\n${projectList}`);
-            if (cacheKey)
-                cache.set(cacheKey, response, 60000); // 60s TTL
-            return response;
-        },
-    },
-    {
-        name: "wyrm_project_context",
-        description: "Get full context for a specific project including recent sessions, quests, and stored context",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path" },
-                projectName: { type: "string", description: "Or project name" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_project_context"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { projectPath, projectName } = args;
-            let project = projectPath ? db.getProject(projectPath) : undefined;
-            if (!project && projectName) {
-                project = db.getProjectByName(projectName);
-            }
-            if (!project) {
-                return { content: [{ type: "text", text: "Project not found. Run wyrm_scan_projects first." }] };
-            }
-            // Gather data for context bundle
-            const recentSessions = db.getRecentSessions(project.id, 10);
-            const quests = db.getPendingQuests(project.id).map(q => ({ title: q.title, priority: q.priority }));
-            const currentContext = db.getAllContext(project.id);
-            const context = createContextBundle({ name: project.name, stack: project.stack }, currentContext, recentSessions, quests);
-            const response = cachedResponse(`󱅝 **Context for ${project.name}**\n\n${context}`);
-            if (cacheKey)
-                cache.set(cacheKey, response, 30000); // 30s TTL — context changes more often
-            return response;
-        },
-    },
-    {
-        name: "wyrm_global_context",
-        description: "Get overview of all projects, pending quests across projects, and global context",
-        inputSchema: {
-            type: "object",
-            properties: {
-                includeQuests: { type: "boolean", description: "Include all pending quests" },
-                maxProjects: { type: "number", description: "Max projects to include" },
-            },
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_global_context"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { cachedResponse, db } = ctx;
-            const cacheKey = currentReadCacheKey();
-            const { includeQuests, maxProjects } = args;
-            const projects = db.getAllProjects(maxProjects || 20);
-            const globalContext = db.getAllGlobalContext();
-            let text = `󱅝 **Wyrm Global Overview**\n\n`;
-            // Global context
-            if (Object.keys(globalContext).length > 0) {
-                text += `## Global Context\n`;
-                for (const [key, value] of Object.entries(globalContext)) {
-                    text += `- **${key}:** ${value.slice(0, 200)}${value.length > 200 ? '...' : ''}\n`;
-                }
-                text += '\n';
-            }
-            // Projects summary
-            text += `## Projects (${projects.length})\n`;
-            for (const p of projects) {
-                const stats = db.getProjectStats(p.id);
-                text += `- **${p.name}** (${p.stack || '?'}) - ${stats.quests.pending} quests, ${stats.sessions} sessions\n`;
-            }
-            text += '\n';
-            // All pending quests
-            if (includeQuests) {
-                const allQuests = db.getAllPendingQuests();
-                text += `## All Pending Quests (${allQuests.length})\n`;
-                for (const q of allQuests.slice(0, 20)) {
-                    const emoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' }[q.priority];
-                    text += `- ${emoji} [${q.project_name}] ${q.title}\n`;
-                }
-            }
-            const response = cachedResponse(text);
-            if (cacheKey)
-                cache.set(cacheKey, response, 45000); // 45s TTL
-            return response;
-        },
-    },
-    {
-        name: "wyrm_set_global",
-        description: "Set global context that applies across all projects",
-        inputSchema: {
-            type: "object",
-            properties: {
-                key: { type: "string", description: "Context key" },
-                value: { type: "string", description: "Context value" },
-            },
-            required: ["key", "value"],
-        },
-        annotations: TOOL_ANNOTATIONS["wyrm_set_global"],
-        aliases: [],
-        handler: async (args, ctx) => {
-            const { db } = ctx;
-            const { key, value } = args;
-            db.setGlobalContext(key, value);
-            return {
-                content: [{
-                        type: "text",
-                        text: `󱅝 Global context set: ${key}`
-                    }]
-            };
-        },
-    },
-];
-//# sourceMappingURL=project.js.map
+import{TOOL_ANNOTATIONS as m}from"../tool-annotations.js";import{currentReadCacheKey as h}from"./boundary.js";import{cache as y}from"../performance.js";import{createContextBundle as g}from"../summarizer.js";const _=[{name:"wyrm_scan_projects",description:"Scan a directory for git projects and register them. Use this to auto-discover all projects.",inputSchema:{type:"object",properties:{path:{type:"string",description:"Directory path to scan (e.g., /home/user/Git Projects)"},watch:{type:"boolean",description:"Add to watch list for future auto-scans"},recursive:{type:"boolean",description:"Scan subdirectories recursively"}},required:["path"]},annotations:m.wyrm_scan_projects,aliases:[],handler:async(p,l)=>{const{db:r}=l,{path:t,watch:o,recursive:a}=p;o&&r.addWatchDir(t,a!==!1);const d=r.scanForProjects(t,a!==!1);return{content:[{type:"text",text:`\u{F115D} Scanned ${t}
+
+Discovered ${d.length} projects:
+${d.map(e=>`- ${e.name} (${e.stack||"unknown"}) - ${e.branch||"no branch"}`).join(`
+`)}${o?`
+
+Added to watch list for future auto-scans.`:""}`}]}}},{name:"wyrm_list_projects",description:"List all registered projects with their status",inputSchema:{type:"object",properties:{search:{type:"string",description:"Search query to filter projects"},limit:{type:"number",description:"Max projects to return"}}},annotations:m.wyrm_list_projects,aliases:[],handler:async(p,l)=>{const{cachedResponse:r,db:t}=l,o=h(),{search:a,limit:d}=p,e=a?t.searchProjects(a):t.getAllProjects(d||50),u=e.map(i=>{const n=t.getProjectStats(i.id);return`## ${i.name}
+- **Path:** ${i.path}
+- **Stack:** ${i.stack||"unknown"}
+- **Branch:** ${i.branch||"N/A"}
+- **Sessions:** ${n.sessions} | **Quests:** ${n.quests.pending}p/${n.quests.completed}c
+- **Data:** ${n.dataPoints}`}).join(`
+
+`),s=r(`\u{F115D} **${e.length} Projects**
+
+${u}`);return o&&y.set(o,s,6e4),s}},{name:"wyrm_project_context",description:"Get full context for a specific project including recent sessions, quests, and stored context",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path"},projectName:{type:"string",description:"Or project name"}}},annotations:m.wyrm_project_context,aliases:[],handler:async(p,l)=>{const{cachedResponse:r,db:t}=l,o=h(),{projectPath:a,projectName:d}=p;let e=a?t.getProject(a):void 0;if(!e&&d&&(e=t.getProjectByName(d)),!e)return{content:[{type:"text",text:"Project not found. Run wyrm_scan_projects first."}]};const u=t.getRecentSessions(e.id,10),s=t.getPendingQuests(e.id).map(j=>({title:j.title,priority:j.priority})),i=t.getAllContext(e.id),n=g({name:e.name,stack:e.stack},i,u,s),c=r(`\u{F115D} **Context for ${e.name}**
+
+${n}`);return o&&y.set(o,c,3e4),c}},{name:"wyrm_global_context",description:"Get overview of all projects, pending quests across projects, and global context",inputSchema:{type:"object",properties:{includeQuests:{type:"boolean",description:"Include all pending quests"},maxProjects:{type:"number",description:"Max projects to include"}}},annotations:m.wyrm_global_context,aliases:[],handler:async(p,l)=>{const{cachedResponse:r,db:t}=l,o=h(),{includeQuests:a,maxProjects:d}=p,e=t.getAllProjects(d||20),u=t.getAllGlobalContext();let s=`\u{F115D} **Wyrm Global Overview**
+
+`;if(Object.keys(u).length>0){s+=`## Global Context
+`;for(const[n,c]of Object.entries(u))s+=`- **${n}:** ${c.slice(0,200)}${c.length>200?"...":""}
+`;s+=`
+`}s+=`## Projects (${e.length})
+`;for(const n of e){const c=t.getProjectStats(n.id);s+=`- **${n.name}** (${n.stack||"?"}) - ${c.quests.pending} quests, ${c.sessions} sessions
+`}if(s+=`
+`,a){const n=t.getAllPendingQuests();s+=`## All Pending Quests (${n.length})
+`;for(const c of n.slice(0,20)){const j={critical:"\u{1F534}",high:"\u{1F7E0}",medium:"\u{1F7E1}",low:"\u{1F7E2}"}[c.priority];s+=`- ${j} [${c.project_name}] ${c.title}
+`}}const i=r(s);return o&&y.set(o,i,45e3),i}},{name:"wyrm_set_global",description:"Set global context that applies across all projects",inputSchema:{type:"object",properties:{key:{type:"string",description:"Context key"},value:{type:"string",description:"Context value"}},required:["key","value"]},annotations:m.wyrm_set_global,aliases:[],handler:async(p,l)=>{const{db:r}=l,{key:t,value:o}=p;return r.setGlobalContext(t,o),{content:[{type:"text",text:`\u{F115D} Global context set: ${t}`}]}}}];export{_ as projectToolSpecs};

package/dist/handlers/prompts.js

@@ -1,157 +1,6 @@
-/**
- * MCP prompts primitive (v7 F3 T030, spec FR-4 / Article V).
- *
- * `prime` and `debrief` exposed as PROTOCOL-LEVEL prompts (prompts/list +
- * prompts/get) — the neutral activation channel: a host that never reads
- * CLAUDE.md/AGENTS.md still gets consult-memory-first by surfacing these in
- * its prompt picker. No vendor file formats, no client-name sniffing — the
- * MCP prompts surface IS the activation mechanism (Article V).
- *
- * NO SECOND IMPLEMENTATION: both prompts render through the SAME registry
- * handlers the tools dispatch to —
- *   - `prime`   executes handlerRegistry.get('wyrm_session_prime') (the T026
- *     session domain; fleet args ride through to the T028 byte-stable cached
- *     brief) and embeds its text channel verbatim under a consult-first
- *     preamble;
- *   - `debrief` embeds the live handlerRegistry.get('wyrm_run')
- *     action=status view (when run_id is given) under the end-of-session
- *     filing instructions; the filing itself stays a tool call (wyrm_run
- *     action=debrief needs the learnings only the agent can write).
- * The prompt layer owns ONLY the framing text — never brief compilation,
- * never run logic (source-locked by tests/prompts.test.ts).
- *
- * Argument values are STRINGS per the MCP GetPromptRequest schema; numeric
- * coercion is the boundary validator's job (asInt already accepts numeric
- * strings), so the handler sees the same validation the tool wire applies.
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later — dual-licensed; commercial terms: ghosts.lk@proton.me. See LICENSE.
- */
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { ValidationError } from '../validate.js';
-import { handlerRegistry } from './registry.js';
-import { blockText } from './types.js';
-/**
- * The advertised prompt list — codepoint name order (the T018 byte-stability
- * convention) and fully literal: no Date/random/env anywhere, so consecutive
- * prompts/list responses are byte-identical.
- */
-const WYRM_PROMPTS = [
-    {
-        name: 'debrief',
-        description: 'End-of-session memory debrief: how to file what was learned back into Wyrm '
-            + '(wyrm_run action=debrief in a fleet run, wyrm_capture otherwise, '
-            + 'wyrm_failure_record for failed approaches) -- plus the live run status when run_id is given.',
-        arguments: [
-            { name: 'run_id', description: 'Fleet run to debrief (embeds live wyrm_run status)', required: false },
-            { name: 'project', description: 'Project path the learnings file under', required: false },
-        ],
-    },
-    {
-        name: 'prime',
-        description: 'Load Wyrm institutional memory FIRST -- ground truths, memory brief, reasoning scaffold, '
-            + 'active quests -- rendered by the same wyrm_session_prime code path the tool uses. '
-            + 'Use at session start, before planning or acting. Fleet agents pass run_id + role '
-            + 'for the byte-stable cached brief.',
-        arguments: [
-            { name: 'project', description: 'Project name (fuzzy; default: last active project)', required: false },
-            { name: 'task', description: 'Drives scaffold + memory selection', required: false },
-            { name: 'run_id', description: 'Fleet: brief cached per (run_id, role)', required: false },
-            { name: 'role', description: 'Fleet role slice', required: false },
-            { name: 'token_budget', description: 'Fleet brief token budget (default 1200)', required: false },
-        ],
-    },
-];
-/** prompts/list body. */
-export function wyrmPromptList() {
-    return WYRM_PROMPTS;
-}
-/** Run a registry tool handler, mapping boundary ValidationErrors onto the
- * JSON-RPC invalid-params code (the prompt-surface analogue of the T020
- * WYRM_VALIDATION body — prompts/get has no tool-result channel to carry it). */
-async function runRegistryHandler(tool, args, ctx) {
-    const handler = handlerRegistry.get(tool);
-    if (!handler) {
-        // Structural invariant: both targets are registry-resident (T026/T027).
-        throw new McpError(ErrorCode.InternalError, `prompt target ${tool} is not registry-resident`);
-    }
-    try {
-        return await handler(args, ctx);
-    }
-    catch (error) {
-        if (error instanceof ValidationError) {
-            throw new McpError(ErrorCode.InvalidParams, error.message);
-        }
-        throw error;
-    }
-}
-const PRIME_PREAMBLE = 'Wyrm is this workspace\'s persistent memory and your first priority. The brief below is '
-    + 'institutional ground truth: consult it BEFORE planning, searching, or acting; treat its '
-    + 'ground truths as authoritative over your own assumptions (surface conflicts, never silently '
-    + 'override); check wyrm_failure_check before re-attempting anything it records as failed; and '
-    + 'capture decisions, fixes, and outcomes back with wyrm_capture as you work.';
-async function primePrompt(args, ctx) {
-    // String-typed prompt args adapt onto the tool's own argument names; the
-    // handler's boundary validation (sanitizeActorId on run_id, asInt on
-    // token_budget — numeric strings accepted) applies unchanged.
-    const toolArgs = {};
-    if (args.project !== undefined)
-        toolArgs.project_name = args.project;
-    if (args.task !== undefined)
-        toolArgs.task = args.task;
-    if (args.run_id !== undefined)
-        toolArgs.run_id = args.run_id;
-    if (args.role !== undefined)
-        toolArgs.role = args.role;
-    if (args.token_budget !== undefined)
-        toolArgs.token_budget = args.token_budget;
-    const result = await runRegistryHandler('wyrm_session_prime', toolArgs, ctx);
-    // Not-found advisories ride through too — "No projects found. Run
-    // wyrm_scan_projects first." is still the correct consult-first activation.
-    const text = `${PRIME_PREAMBLE}\n\n---\n\n${blockText(result.content[0])}`;
-    return {
-        description: 'Wyrm session prime — consult-memory-first brief',
-        messages: [{ role: 'user', content: { type: 'text', text } }],
-    };
-}
-async function debriefPrompt(args, ctx) {
-    const runId = args.run_id;
-    const projectPath = args.project;
-    const idRef = runId ?? '<run_id>';
-    const pathRef = projectPath ?? '<project path>';
-    const lines = [
-        'The session is ending. File what was learned back into Wyrm before you stop -- memory you do not write is memory the team loses.',
-        '',
-        '1. Summarize the durable learnings: decisions made, validated fixes, gotchas, and patterns worth reusing.',
-        '2. Record approaches that FAILED with wyrm_failure_record so no future agent repeats them.',
-        runId !== undefined
-            ? `3. Submit the learnings via wyrm_run { action: 'debrief', run_id: '${idRef}', project_path: '${pathRef}', learnings: [{ agent_id?, text }] } -- they are extracted LOCALLY into a run-scoped review queue -- then close the run with wyrm_run { action: 'end', run_id: '${idRef}', agent_id: <your registered agent_id> } (end is member-only).`
-            : `3. In a fleet run, submit the learnings via wyrm_run { action: 'debrief', run_id: '${idRef}', project_path: '${pathRef}', learnings: [{ agent_id?, text }] }, then close the run with wyrm_run { action: 'end', run_id: '${idRef}', agent_id: <your registered agent_id> } (end is member-only). Outside a run, capture each learning directly with wyrm_capture.`,
-        // Survivor-first storefront (T032 findings pass): the default surface
-        // advertises wyrm_session, not the hidden wyrm_session_update alias — a
-        // harness that validates tool names against ListTools must be able to
-        // follow every instruction in this message.
-        "4. Update the session record with wyrm_session { action: 'update', completed, issues, commits }.",
-    ];
-    if (runId !== undefined) {
-        // SAME code path as the tool: the live wyrm_run action=status view. An
-        // isError text (e.g. "Run not found: X") embeds too — it is the honest
-        // status and tells the agent the run_id is wrong before it files anything.
-        const status = await runRegistryHandler('wyrm_run', { action: 'status', run_id: runId }, ctx);
-        lines.push('', 'Current run status:', '', blockText(status.content[0]));
-    }
-    return {
-        description: 'Wyrm end-of-session debrief — file learnings back into memory',
-        messages: [{ role: 'user', content: { type: 'text', text: lines.join('\n') } }],
-    };
-}
-/** prompts/get dispatch. Unknown names are JSON-RPC invalid-params per the
- * MCP spec convention. */
-export async function getPromptResult(name, args, ctx) {
-    if (name === 'prime')
-        return primePrompt(args, ctx);
-    if (name === 'debrief')
-        return debriefPrompt(args, ctx);
-    throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${name}`);
-}
-//# sourceMappingURL=prompts.js.map
+import{ErrorCode as o,McpError as s}from"@modelcontextprotocol/sdk/types.js";import{ValidationError as l}from"../validate.js";import{handlerRegistry as f}from"./registry.js";import{blockText as u}from"./types.js";const p=[{name:"debrief",description:"End-of-session memory debrief: how to file what was learned back into Wyrm (wyrm_run action=debrief in a fleet run, wyrm_capture otherwise, wyrm_failure_record for failed approaches) -- plus the live run status when run_id is given.",arguments:[{name:"run_id",description:"Fleet run to debrief (embeds live wyrm_run status)",required:!1},{name:"project",description:"Project path the learnings file under",required:!1}]},{name:"prime",description:"Load Wyrm institutional memory FIRST -- ground truths, memory brief, reasoning scaffold, active quests -- rendered by the same wyrm_session_prime code path the tool uses. Use at session start, before planning or acting. Fleet agents pass run_id + role for the byte-stable cached brief.",arguments:[{name:"project",description:"Project name (fuzzy; default: last active project)",required:!1},{name:"task",description:"Drives scaffold + memory selection",required:!1},{name:"run_id",description:"Fleet: brief cached per (run_id, role)",required:!1},{name:"role",description:"Fleet role slice",required:!1},{name:"token_budget",description:"Fleet brief token budget (default 1200)",required:!1}]}];function v(){return p}async function c(e,n,r){const i=f.get(e);if(!i)throw new s(o.InternalError,`prompt target ${e} is not registry-resident`);try{return await i(n,r)}catch(t){throw t instanceof l?new s(o.InvalidParams,t.message):t}}const h="Wyrm is this workspace's persistent memory and your first priority. The brief below is institutional ground truth: consult it BEFORE planning, searching, or acting; treat its ground truths as authoritative over your own assumptions (surface conflicts, never silently override); check wyrm_failure_check before re-attempting anything it records as failed; and capture decisions, fixes, and outcomes back with wyrm_capture as you work.";async function y(e,n){const r={};e.project!==void 0&&(r.project_name=e.project),e.task!==void 0&&(r.task=e.task),e.run_id!==void 0&&(r.run_id=e.run_id),e.role!==void 0&&(r.role=e.role),e.token_budget!==void 0&&(r.token_budget=e.token_budget);const i=await c("wyrm_session_prime",r,n);return{description:"Wyrm session prime \u2014 consult-memory-first brief",messages:[{role:"user",content:{type:"text",text:`${h}
+
+---
+
+${u(i.content[0])}`}}]}}async function _(e,n){const r=e.run_id,i=e.project,t=r??"<run_id>",a=i??"<project path>",d=["The session is ending. File what was learned back into Wyrm before you stop -- memory you do not write is memory the team loses.","","1. Summarize the durable learnings: decisions made, validated fixes, gotchas, and patterns worth reusing.","2. Record approaches that FAILED with wyrm_failure_record so no future agent repeats them.",r!==void 0?`3. Submit the learnings via wyrm_run { action: 'debrief', run_id: '${t}', project_path: '${a}', learnings: [{ agent_id?, text }] } -- they are extracted LOCALLY into a run-scoped review queue -- then close the run with wyrm_run { action: 'end', run_id: '${t}', agent_id: <your registered agent_id> } (end is member-only).`:`3. In a fleet run, submit the learnings via wyrm_run { action: 'debrief', run_id: '${t}', project_path: '${a}', learnings: [{ agent_id?, text }] }, then close the run with wyrm_run { action: 'end', run_id: '${t}', agent_id: <your registered agent_id> } (end is member-only). Outside a run, capture each learning directly with wyrm_capture.`,"4. Update the session record with wyrm_session { action: 'update', completed, issues, commits }."];if(r!==void 0){const m=await c("wyrm_run",{action:"status",run_id:r},n);d.push("","Current run status:","",u(m.content[0]))}return{description:"Wyrm end-of-session debrief \u2014 file learnings back into memory",messages:[{role:"user",content:{type:"text",text:d.join(`
+`)}}]}}async function j(e,n,r){if(e==="prime")return y(n,r);if(e==="debrief")return _(n,r);throw new s(o.InvalidParams,`Unknown prompt: ${e}`)}export{j as getPromptResult,v as wyrmPromptList};

package/dist/handlers/quest.js

@@ -1,224 +1,4 @@
-/**
- * Quest domain — ToolSpec contract v2 (v7 F3 T026, hot-path extraction).
- *
- * wyrm_quest_add / wyrm_quest_complete / wyrm_quest_claim / wyrm_quest_release
- * / wyrm_all_quests, moved VERBATIM from the index.ts dispatch switch +
- * buildAllTools() (definitions byte-identical on the wire). The wyrm_quest
- * noun shim (src/handlers/shims.ts) keeps routing action=add|complete|claim|
- * release|list onto THESE names — the registry is checked before the switch,
- * so the shim table needs zero changes (the T022 handoff design).
- *
- * T019 renderer: every success response is a renderResult(body, template) —
- * structuredContent is canonical, text derives from it (plain ASCII default,
- * brand glyphs behind WYRM_FANCY=1; the 6.x priority emoji moved off the
- * default text per the goals-domain precedent, spec §6 "text persists but
- * reformats"). Project/quest not-founds are isError (schema-exempt).
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later — dual-licensed; commercial terms: ghosts.lk@proton.me. See LICENSE.
- */
-import { TOOL_ANNOTATIONS } from '../tool-annotations.js';
-import { renderResult, withGlyph, cacheKeyFor } from '../render.js';
-import { asEnum } from '../validate.js';
-export const questToolSpecs = [
-    {
-        name: "wyrm_quest_add",
-        description: "Add a quest (task) to a project",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path" },
-                title: { type: "string", description: "Quest title" },
-                description: { type: "string", description: "Quest description" },
-                priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-                tags: { type: "string", description: "Comma-separated tags" },
-            },
-            required: ["projectPath", "title"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "integer" },
-                title: { type: "string" },
-                priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-                project: { type: "string" },
-            },
-            required: ["id", "title", "priority", "project"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_quest_add,
-        aliases: [],
-        handler: (args, { store, indexing }) => {
-            const { projectPath, title, description, priority, tags } = args;
-            // Closed enum enforced at the boundary (the MCP SDK treats
-            // inputSchema as advisory). quests.priority has NO schema CHECK, so
-            // without this gate a typo'd value would be SILENTLY STORED and skew
-            // priority-ordered queries — the boundary is the only enforcement
-            // point.
-            const safePriority = asEnum('priority', priority, ['critical', 'high', 'medium', 'low'], 'medium');
-            const project = store.getProject(projectPath);
-            if (!project) {
-                // T026: was a non-error "Project not found" text in 6.x — domain
-                // not-founds are isError per the goals precedent (schema-exempt).
-                return { content: [{ type: "text", text: "Project not found" }], isError: true };
-            }
-            const quest = store.addQuest(project.id, title, description, safePriority, tags);
-            indexing()?.enqueue('quest', quest.id, project.id);
-            return renderResult({ id: quest.id, title, priority: safePriority, project: project.name }, (b, g) => withGlyph(g.brand, `Quest #${b.id} added: ${b.title}`));
-        },
-    },
-    {
-        name: "wyrm_quest_complete",
-        description: "Mark a quest as completed",
-        inputSchema: {
-            type: "object",
-            properties: {
-                questId: { type: "number", description: "Quest ID" },
-            },
-            required: ["questId"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "integer" },
-                title: { type: "string" },
-                status: { type: "string", enum: ["completed"] },
-            },
-            required: ["id", "title", "status"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_quest_complete,
-        aliases: [],
-        handler: (args, { store }) => {
-            const { questId } = args;
-            const quest = store.updateQuest(questId, 'completed');
-            if (!quest) {
-                // T026: 6.x read `.title` off the undefined row and threw a
-                // TypeError into the generic error boundary — a clean isError
-                // not-found is the honest contract (recorded deviation).
-                return { content: [{ type: "text", text: `Quest #${questId} not found.` }], isError: true };
-            }
-            return renderResult({ id: questId, title: quest.title, status: 'completed' }, (b, g) => withGlyph(g.brand, `Quest #${b.id} completed: ${b.title}`));
-        },
-    },
-    {
-        name: "wyrm_all_quests",
-        description: "Get all pending quests across all projects",
-        inputSchema: {
-            type: "object",
-            properties: {
-                priority: { type: "string", enum: ["critical", "high", "medium", "low"], description: "Filter by priority" },
-            },
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                count: { type: "integer" },
-                quests: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            id: { type: "integer" },
-                            title: { type: "string" },
-                            priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-                            project: { type: ["string", "null"] },
-                        },
-                        required: ["id", "title", "priority", "project"],
-                    },
-                },
-            },
-            required: ["count", "quests"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_all_quests,
-        aliases: [],
-        handler: (args, { store, cache }) => {
-            const { priority } = args;
-            let quests = store.getAllPendingQuests();
-            if (priority) {
-                quests = quests.filter(q => q.priority === priority);
-            }
-            const body = {
-                count: quests.length,
-                quests: quests.map((q) => ({
-                    id: q.id,
-                    title: q.title,
-                    priority: q.priority,
-                    project: q.project_name ?? null,
-                })),
-            };
-            const response = renderResult(body, (b, g) => {
-                const lines = b.quests.map((q) => `${g.bullet} [${q.priority}]${q.project ? ` [${q.project}]` : ''} #${q.id}: ${q.title}`).join('\n');
-                return `${withGlyph(g.brand, `**${b.count} Pending Quests**`)}\n\n${lines}`;
-            });
-            // READ_ONLY_TOOLS cache publish — same key convention as the
-            // dispatcher's cache-hit lookup (resolved name + resolved args).
-            cache.set(cacheKeyFor('wyrm_all_quests', JSON.stringify(args)), response, 30000);
-            return response;
-        },
-    },
-    {
-        // T029: description rewritten for the orchestrator audience (T025 house style).
-        name: "wyrm_quest_claim",
-        description: "Use from a fleet subagent to take an exclusive TTL lease on a quest before working it, so no two agents double-work: atomic CAS on the (quest, agent) key - a losing claimer gets a visible already-claimed error, never a partial write. The claim row is stamped with the ambient run_id and the agent's run role for orchestrator audit (wyrm_run action=status counts claims per run). Stale leases are evicted inline at claim time and by wyrm_maintenance. Requires a prior wyrm_presence announce; release with wyrm_quest_release.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                quest_id: { type: "number", description: "Quest to claim" },
-                agent_id: { type: "string", description: "Claiming agent ID (must be announced first)" },
-                ttl_seconds: { type: "number", description: "Claim TTL (default 1800 = 30 min)" },
-            },
-            required: ["quest_id", "agent_id"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                quest_id: { type: "integer" },
-                agent_id: { type: "string" },
-                ttl_seconds: { type: "integer" },
-            },
-            required: ["quest_id", "agent_id", "ttl_seconds"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_quest_claim,
-        aliases: [],
-        handler: (args, { presence }) => {
-            const { quest_id, agent_id, ttl_seconds } = args;
-            const claim = presence.claimQuest(quest_id, agent_id, ttl_seconds);
-            if (!claim) {
-                const existing = presence.getClaim(quest_id);
-                return { content: [{ type: "text", text: `Quest #${quest_id} already claimed by ${existing?.agent_id ?? 'another agent'}.` }], isError: true };
-            }
-            return renderResult({ quest_id, agent_id, ttl_seconds: claim.claim_ttl_seconds }, (b, g) => withGlyph(g.ok, `${b.agent_id} claimed quest #${b.quest_id} for ${b.ttl_seconds}s.`));
-        },
-    },
-    {
-        // T029: description rewritten for the orchestrator audience (T025 house style).
-        name: "wyrm_quest_release",
-        description: "Use when a subagent finishes or abandons a claimed quest: drops the TTL lease (only if held by this agent) so the orchestrator can reassign the quest immediately instead of waiting for expiry; wyrm_run action=end bulk-releases a whole run's claims, and wyrm_maintenance reaps expired ones.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                quest_id: { type: "number" },
-                agent_id: { type: "string" },
-            },
-            required: ["quest_id", "agent_id"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                quest_id: { type: "integer" },
-                agent_id: { type: "string" },
-                released: { type: "boolean" },
-            },
-            required: ["quest_id", "agent_id", "released"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_quest_release,
-        aliases: [],
-        handler: (args, { presence }) => {
-            const { quest_id, agent_id } = args;
-            const ok = presence.releaseClaim(quest_id, agent_id);
-            return renderResult({ quest_id, agent_id, released: ok }, (b, g) => withGlyph(g.brand, b.released
-                ? `Quest #${b.quest_id} released by ${b.agent_id}.`
-                : `No claim by ${b.agent_id} on quest #${b.quest_id}.`));
-        },
-    },
-];
-//# sourceMappingURL=quest.js.map
+import{TOOL_ANNOTATIONS as c}from"../tool-annotations.js";import{renderResult as l,withGlyph as m,cacheKeyFor as _}from"../render.js";import{asEnum as q}from"../validate.js";const b=[{name:"wyrm_quest_add",description:"Add a quest (task) to a project",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path"},title:{type:"string",description:"Quest title"},description:{type:"string",description:"Quest description"},priority:{type:"string",enum:["critical","high","medium","low"]},tags:{type:"string",description:"Comma-separated tags"}},required:["projectPath","title"]},outputSchema:{type:"object",properties:{id:{type:"integer"},title:{type:"string"},priority:{type:"string",enum:["critical","high","medium","low"]},project:{type:"string"}},required:["id","title","priority","project"]},annotations:c.wyrm_quest_add,aliases:[],handler:(a,{store:o,indexing:e})=>{const{projectPath:r,title:t,description:i,priority:n,tags:s}=a,u=q("priority",n,["critical","high","medium","low"],"medium"),d=o.getProject(r);if(!d)return{content:[{type:"text",text:"Project not found"}],isError:!0};const p=o.addQuest(d.id,t,i,u,s);return e()?.enqueue("quest",p.id,d.id),l({id:p.id,title:t,priority:u,project:d.name},(y,g)=>m(g.brand,`Quest #${y.id} added: ${y.title}`))}},{name:"wyrm_quest_complete",description:"Mark a quest as completed",inputSchema:{type:"object",properties:{questId:{type:"number",description:"Quest ID"}},required:["questId"]},outputSchema:{type:"object",properties:{id:{type:"integer"},title:{type:"string"},status:{type:"string",enum:["completed"]}},required:["id","title","status"]},annotations:c.wyrm_quest_complete,aliases:[],handler:(a,{store:o})=>{const{questId:e}=a,r=o.updateQuest(e,"completed");return r?l({id:e,title:r.title,status:"completed"},(t,i)=>m(i.brand,`Quest #${t.id} completed: ${t.title}`)):{content:[{type:"text",text:`Quest #${e} not found.`}],isError:!0}}},{name:"wyrm_all_quests",description:"Get all pending quests across all projects",inputSchema:{type:"object",properties:{priority:{type:"string",enum:["critical","high","medium","low"],description:"Filter by priority"}}},outputSchema:{type:"object",properties:{count:{type:"integer"},quests:{type:"array",items:{type:"object",properties:{id:{type:"integer"},title:{type:"string"},priority:{type:"string",enum:["critical","high","medium","low"]},project:{type:["string","null"]}},required:["id","title","priority","project"]}}},required:["count","quests"]},annotations:c.wyrm_all_quests,aliases:[],handler:(a,{store:o,cache:e})=>{const{priority:r}=a;let t=o.getAllPendingQuests();r&&(t=t.filter(s=>s.priority===r));const i={count:t.length,quests:t.map(s=>({id:s.id,title:s.title,priority:s.priority,project:s.project_name??null}))},n=l(i,(s,u)=>{const d=s.quests.map(p=>`${u.bullet} [${p.priority}]${p.project?` [${p.project}]`:""} #${p.id}: ${p.title}`).join(`
+`);return`${m(u.brand,`**${s.count} Pending Quests**`)}
+
+${d}`});return e.set(_("wyrm_all_quests",JSON.stringify(a)),n,3e4),n}},{name:"wyrm_quest_claim",description:"Use from a fleet subagent to take an exclusive TTL lease on a quest before working it, so no two agents double-work: atomic CAS on the (quest, agent) key - a losing claimer gets a visible already-claimed error, never a partial write. The claim row is stamped with the ambient run_id and the agent's run role for orchestrator audit (wyrm_run action=status counts claims per run). Stale leases are evicted inline at claim time and by wyrm_maintenance. Requires a prior wyrm_presence announce; release with wyrm_quest_release.",inputSchema:{type:"object",properties:{quest_id:{type:"number",description:"Quest to claim"},agent_id:{type:"string",description:"Claiming agent ID (must be announced first)"},ttl_seconds:{type:"number",description:"Claim TTL (default 1800 = 30 min)"}},required:["quest_id","agent_id"]},outputSchema:{type:"object",properties:{quest_id:{type:"integer"},agent_id:{type:"string"},ttl_seconds:{type:"integer"}},required:["quest_id","agent_id","ttl_seconds"]},annotations:c.wyrm_quest_claim,aliases:[],handler:(a,{presence:o})=>{const{quest_id:e,agent_id:r,ttl_seconds:t}=a,i=o.claimQuest(e,r,t);if(!i){const n=o.getClaim(e);return{content:[{type:"text",text:`Quest #${e} already claimed by ${n?.agent_id??"another agent"}.`}],isError:!0}}return l({quest_id:e,agent_id:r,ttl_seconds:i.claim_ttl_seconds},(n,s)=>m(s.ok,`${n.agent_id} claimed quest #${n.quest_id} for ${n.ttl_seconds}s.`))}},{name:"wyrm_quest_release",description:"Use when a subagent finishes or abandons a claimed quest: drops the TTL lease (only if held by this agent) so the orchestrator can reassign the quest immediately instead of waiting for expiry; wyrm_run action=end bulk-releases a whole run's claims, and wyrm_maintenance reaps expired ones.",inputSchema:{type:"object",properties:{quest_id:{type:"number"},agent_id:{type:"string"}},required:["quest_id","agent_id"]},outputSchema:{type:"object",properties:{quest_id:{type:"integer"},agent_id:{type:"string"},released:{type:"boolean"}},required:["quest_id","agent_id","released"]},annotations:c.wyrm_quest_release,aliases:[],handler:(a,{presence:o})=>{const{quest_id:e,agent_id:r}=a,t=o.releaseClaim(e,r);return l({quest_id:e,agent_id:r,released:t},(i,n)=>m(n.brand,i.released?`Quest #${i.quest_id} released by ${i.agent_id}.`:`No claim by ${i.agent_id} on quest #${i.quest_id}.`))}}];export{b as questToolSpecs};