@jagilber-org/index-server 1.19.1

package/dist/services/handlers.manifest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/handlers.manifest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../server/registry");
+const manifestManager_1 = require("./manifestManager");
+const indexContext_1 = require("./indexContext");
+// manifest_status: returns current drift (without repairing) and manifest presence.
+(0, registry_1.registerHandler)('manifest_status', () => {
+    const st = (0, indexContext_1.ensureLoaded)();
+    const manifest = (0, manifestManager_1.loadManifest)();
+    const drift = (0, manifestManager_1.computeManifestDrift)();
+    return { hash: st.hash, manifestPresent: !!manifest, count: st.list.length, drift: drift.drift, details: drift.details.slice(0, 25) };
+});
+// manifest_refresh: force rewrite from current index (non-mutating to index itself)
+(0, registry_1.registerHandler)('manifest_refresh', () => {
+    const st = (0, indexContext_1.ensureLoaded)();
+    const manifest = (0, manifestManager_1.writeManifestFromIndex)();
+    return { refreshed: !!manifest, count: manifest?.count ?? 0, hash: st.hash };
+});
+// manifest_repair: recompute manifest if drift present.
+(0, registry_1.registerHandler)('manifest_repair', () => {
+    const st = (0, indexContext_1.ensureLoaded)();
+    const result = (0, manifestManager_1.repairManifest)();
+    return { hash: st.hash, ...result };
+});

package/dist/services/handlers.messaging.d.ts

@@ -0,0 +1,12 @@
+/**
+ * MCP tool handlers for inter-agent messaging.
+ *
+ * Registers 8 tools via registerHandler() following constitution patterns:
+ * - A-1: Side-effect import triggers registration
+ * - A-5: Audit logging on mutations
+ * - Q-5: registerHandler() pattern
+ *
+ * Messages are NOT stored in the instruction index (A-3).
+ */
+/** Reset mailbox (for testing). */
+export declare function _resetMailbox(): void;

package/dist/services/handlers.messaging.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * MCP tool handlers for inter-agent messaging.
+ *
+ * Registers 8 tools via registerHandler() following constitution patterns:
+ * - A-1: Side-effect import triggers registration
+ * - A-5: Audit logging on mutations
+ * - Q-5: registerHandler() pattern
+ *
+ * Messages are NOT stored in the instruction index (A-3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._resetMailbox = _resetMailbox;
+const registry_1 = require("../server/registry");
+const auditLog_1 = require("./auditLog");
+const logger_1 = require("./logger");
+const agentMailbox_1 = require("./messaging/agentMailbox");
+const runtimeConfig_1 = require("../config/runtimeConfig");
+const messagingTypes_1 = require("./messaging/messagingTypes");
+// Singleton mailbox instance (lazy init)
+let _mailbox = null;
+function getMailbox() {
+    if (!_mailbox) {
+        const config = (0, runtimeConfig_1.getRuntimeConfig)().messaging;
+        _mailbox = new agentMailbox_1.AgentMailbox(config);
+    }
+    return _mailbox;
+}
+/** Reset mailbox (for testing). */
+function _resetMailbox() {
+    if (_mailbox) {
+        _mailbox.destroy();
+        _mailbox = null;
+    }
+}
+// ── messaging_send (MUTATION) ────────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_send', async (params) => {
+    const parsed = messagingTypes_1.SendMessageOptionsSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(`Invalid send options: ${parsed.error.issues.map(i => i.message).join(', ')}`);
+    }
+    const mailbox = getMailbox();
+    const messageId = await mailbox.send(parsed.data);
+    (0, auditLog_1.logAudit)('messaging_send', [messageId], {
+        channel: params.channel,
+        sender: params.sender,
+        priority: params.priority,
+    });
+    (0, logger_1.logInfo)('[messaging] Message sent', { messageId, channel: params.channel, sender: params.sender });
+    return {
+        messageId,
+        channel: params.channel,
+        status: 'sent',
+        ttlCapped: params.ttlSeconds ? params.ttlSeconds > messagingTypes_1.MAX_TTL_SECONDS : false,
+    };
+});
+// ── messaging_read (STABLE) ─────────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_read', (params = {}) => {
+    const parsed = messagingTypes_1.ReadMessagesOptionsSchema.safeParse(params);
+    if (!parsed.success) {
+        throw new Error(`Invalid read options: ${parsed.error.issues.map(i => i.message).join(', ')}`);
+    }
+    const mailbox = getMailbox();
+    const messages = mailbox.read(parsed.data);
+    return {
+        channel: params.channel || 'all',
+        reader: params.reader || 'anonymous',
+        count: messages.length,
+        messages,
+    };
+});
+// ── messaging_list_channels (STABLE) ─────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_list_channels', () => {
+    const mailbox = getMailbox();
+    const channels = mailbox.listChannels();
+    return {
+        count: channels.length,
+        channels,
+    };
+});
+// ── messaging_ack (MUTATION) ─────────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_ack', (params) => {
+    if (!params.messageIds?.length || !params.reader) {
+        throw new Error('Missing required parameters: messageIds, reader');
+    }
+    const mailbox = getMailbox();
+    const acknowledged = mailbox.ack(params.messageIds, params.reader);
+    (0, auditLog_1.logAudit)('messaging_ack', params.messageIds, { reader: params.reader });
+    return {
+        acknowledged,
+        reader: params.reader,
+    };
+});
+// ── messaging_stats (STABLE) ─────────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_stats', (params = {}) => {
+    const reader = params.reader || '*';
+    const mailbox = getMailbox();
+    const stats = mailbox.getStats(reader);
+    return {
+        reader,
+        channel: params.channel || 'all',
+        ...stats,
+    };
+});
+// ── messaging_get (STABLE) ───────────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_get', (params) => {
+    if (!params.messageId) {
+        throw new Error('Missing required parameter: messageId');
+    }
+    const mailbox = getMailbox();
+    const message = mailbox.getMessage(params.messageId);
+    if (!message) {
+        return { found: false, messageId: params.messageId };
+    }
+    return { found: true, message };
+});
+// ── messaging_update (MUTATION) ──────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_update', (params) => {
+    if (!params.messageId) {
+        throw new Error('Missing required parameter: messageId');
+    }
+    const mailbox = getMailbox();
+    const updated = mailbox.updateMessage(params.messageId, {
+        body: params.body,
+        recipients: params.recipients,
+        payload: params.payload,
+        persistent: params.persistent,
+    });
+    if (!updated) {
+        return { found: false, messageId: params.messageId };
+    }
+    (0, auditLog_1.logAudit)('messaging_update', [params.messageId], {
+        fields: Object.keys(params).filter(k => k !== 'messageId'),
+    });
+    return { found: true, message: updated };
+});
+// ── messaging_purge (MUTATION) ───────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_purge', (params = {}) => {
+    const mailbox = getMailbox();
+    let removed = 0;
+    let action = 'none';
+    if (params.all) {
+        removed = mailbox.purgeAll();
+        action = 'purge_all';
+    }
+    else if (params.messageIds?.length) {
+        removed = mailbox.deleteMessages(params.messageIds);
+        action = 'delete_by_ids';
+    }
+    else if (params.channel) {
+        removed = mailbox.purgeChannel(params.channel);
+        action = 'purge_channel';
+    }
+    else {
+        removed = mailbox.purgeAll();
+        action = 'purge_all';
+    }
+    (0, auditLog_1.logAudit)('messaging_purge', [], { action, removed });
+    (0, logger_1.logInfo)('[messaging] Messages purged', { action, removed });
+    return { action, removed };
+});
+// ── messaging_reply (MUTATION) ───────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_reply', async (params) => {
+    if (!params.parentId || !params.sender || !params.body) {
+        throw new Error('Missing required parameters: parentId, sender, body');
+    }
+    const mailbox = getMailbox();
+    const result = await mailbox.reply(params.parentId, params.sender, params.body, {
+        replyAll: params.replyAll,
+        recipients: params.recipients,
+        priority: params.priority,
+        tags: params.tags,
+        persistent: params.persistent,
+        payload: params.payload,
+    });
+    (0, auditLog_1.logAudit)('messaging_reply', [result.messageId], {
+        parentId: params.parentId,
+        sender: params.sender,
+        replyAll: params.replyAll,
+    });
+    (0, logger_1.logInfo)('[messaging] Reply sent', { messageId: result.messageId, parentId: params.parentId, channel: result.channel });
+    return {
+        messageId: result.messageId,
+        channel: result.channel,
+        recipients: result.recipients,
+        parentId: params.parentId,
+        replyAll: !!params.replyAll,
+        status: 'sent',
+    };
+});
+// ── messaging_thread (STABLE) ────────────────────────────────────────────────
+(0, registry_1.registerHandler)('messaging_thread', (params) => {
+    if (!params.parentId) {
+        throw new Error('Missing required parameter: parentId');
+    }
+    const mailbox = getMailbox();
+    const messages = mailbox.getThread(params.parentId);
+    return {
+        parentId: params.parentId,
+        count: messages.length,
+        messages,
+    };
+});

package/dist/services/handlers.metrics.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/handlers.metrics.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../server/registry");
+const indexContext_1 = require("../services/indexContext");
+const features_1 = require("../services/features");
+const InstanceManager_1 = require("../dashboard/server/InstanceManager");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const validationService_1 = require("./validationService");
+(0, registry_1.registerHandler)('metrics_snapshot', () => { const raw = (0, registry_1.getMetricsRaw)(); const methods = Object.entries(raw).map(([method, rec]) => ({ method, count: rec.count, avgMs: rec.count ? +(rec.totalMs / rec.count).toFixed(2) : 0, maxMs: +rec.maxMs.toFixed(2) })).sort((a, b) => a.method.localeCompare(b.method)); const features = (0, features_1.featureStatus)(); const validation = (0, validationService_1.getValidationMetrics)(); return { generatedAt: new Date().toISOString(), methods, features, validation }; });
+// health_check retained here (meta_tools provided by shim for rich output)
+// Resolve version locally (mirrors transport logic) to avoid import cycles
+let VERSION = '0.0.0';
+try {
+    const pkgPath = path_1.default.join(process.cwd(), 'package.json');
+    if (fs_1.default.existsSync(pkgPath)) {
+        const raw = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+        if (raw.version)
+            VERSION = raw.version;
+    }
+}
+catch { /* ignore */ }
+(0, registry_1.registerHandler)('health_check', () => {
+    let summary;
+    try {
+        const st = (0, indexContext_1.getIndexState)();
+        if (st.loadSummary) {
+            const s = st.loadSummary;
+            summary = { scanned: s.scanned, accepted: s.accepted, skipped: s.skipped, reasons: s.reasons, salvage: s.salvage, softWarnings: s.softWarnings };
+        }
+    }
+    catch { /* swallow to keep health resilient */ }
+    // Instance discovery — resilient: never fail health due to port-file read errors
+    let instances = [];
+    try {
+        instances = (0, InstanceManager_1.getActiveInstances)().map(i => ({ pid: i.pid, port: i.port, host: i.host, startedAt: i.startedAt, current: i.current }));
+    }
+    catch { /* swallow */ }
+    return { status: 'ok', timestamp: new Date().toISOString(), version: VERSION, pid: process.pid, uptime: Math.round(process.uptime()), index: summary, instances };
+});

package/dist/services/handlers.promote.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/handlers.promote.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * handlers.promote.ts — promote_from_repo tool handler.
+ *
+ * Scans a local Git repository for promotable knowledge content (constitutions,
+ * docs, instructions, specs) and upserts them into the instruction index.
+ *
+ * Content discovery order:
+ *   1. .specify/config/promotion-map.json  (explicit source→instruction mappings)
+ *   2. instructions/*.json                 (valid instruction JSON files)
+ *
+ * Dedup via SHA-256 content hashing against existing sourceHash in index.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const registry_1 = require("../server/registry");
+const indexContext_1 = require("./indexContext");
+const classificationService_1 = require("./classificationService");
+const auditLog_1 = require("./auditLog");
+const schemaVersion_1 = require("../versioning/schemaVersion");
+// ---------------------------------------------------------------------------
+// Scope → category mapping
+// ---------------------------------------------------------------------------
+const SCOPE_CATEGORIES = {
+    governance: new Set(['governance', 'constitution', 'coding-standards']),
+    docs: new Set(['architecture', 'onboarding']),
+    specs: new Set(['spec']),
+    instructions: new Set(['bootstrap', 'speckit', 'runbook', 'instruction']),
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function sha256(content) {
+    return (0, node_crypto_1.createHash)('sha256').update(content, 'utf8').digest('hex');
+}
+const INSTRUCTION_ID_RE = /^[a-z0-9][a-z0-9\-_]{0,118}[a-z0-9]$/;
+function isValidInstructionId(id) {
+    return INSTRUCTION_ID_RE.test(id);
+}
+function matchesScope(category, scope) {
+    if (scope === 'all')
+        return true;
+    const allowed = SCOPE_CATEGORIES[scope];
+    return allowed ? allowed.has(category.toLowerCase()) : false;
+}
+function loadPromotionMap(repoPath) {
+    const mapPath = node_path_1.default.join(repoPath, '.specify', 'config', 'promotion-map.json');
+    if (!node_fs_1.default.existsSync(mapPath))
+        return null;
+    try {
+        const raw = node_fs_1.default.readFileSync(mapPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.sources || !Array.isArray(parsed.sources)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function buildEntryFromSource(source, content, repoId) {
+    const now = new Date().toISOString();
+    const sourceId = source.instructionId || source.id || 'unknown';
+    const sourceCategory = source.category || source.scope || (Array.isArray(source.categories) ? source.categories[0] : undefined) || 'instruction';
+    const extraCategories = Array.isArray(source.categories) ? source.categories : [];
+    const allCategories = Array.from(new Set([sourceCategory, ...extraCategories, repoId]));
+    return {
+        id: sourceId,
+        title: source.title,
+        body: content,
+        priority: source.priority ?? 50,
+        audience: 'all',
+        requirement: (source.requirement || 'recommended'),
+        categories: allCategories,
+        primaryCategory: sourceCategory,
+        contentType: (source.contentType || 'instruction'),
+        sourceHash: sha256(content),
+        schemaVersion: schemaVersion_1.SCHEMA_VERSION,
+        version: '1.0.0',
+        status: 'approved',
+        owner: 'promote_from_repo',
+        classification: (source.classification || 'internal'),
+        semanticSummary: `${source.title} — promoted from ${repoId} repository`,
+        sourceWorkspace: repoId,
+        createdByAgent: 'promote_from_repo',
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+// Scans .specify/config/promotion-map.json sources
+function scanMappedSources(repoPath, map, scope) {
+    const results = [];
+    const repoId = node_path_1.default.basename(repoPath);
+    for (const source of map.sources) {
+        // Support both field naming conventions: path/file, instructionId/id, category/scope/categories
+        const sourcePath = source.path || source.file;
+        const sourceId = source.instructionId || source.id;
+        const sourceCategory = source.category || source.scope || (Array.isArray(source.categories) ? source.categories[0] : undefined) || 'instruction';
+        if (!sourcePath || !sourceId)
+            continue; // skip entries missing required fields
+        if (!matchesScope(sourceCategory, scope))
+            continue;
+        const filePath = node_path_1.default.join(repoPath, sourcePath);
+        const resolvedFile = node_path_1.default.resolve(filePath);
+        const resolvedRepo = node_path_1.default.resolve(repoPath);
+        if (!resolvedFile.startsWith(resolvedRepo + node_path_1.default.sep) && resolvedFile !== resolvedRepo)
+            continue;
+        if (!node_fs_1.default.existsSync(filePath))
+            continue;
+        try {
+            const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+            const hash = sha256(content);
+            const entry = buildEntryFromSource(source, content, repoId);
+            results.push({ entry, hash, source: 'map' });
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return results;
+}
+// Scans instructions/*.json in the repo
+function scanInstructionFiles(repoPath) {
+    const results = [];
+    const instrDir = node_path_1.default.join(repoPath, 'instructions');
+    if (!node_fs_1.default.existsSync(instrDir) || !node_fs_1.default.statSync(instrDir).isDirectory())
+        return results;
+    const files = node_fs_1.default.readdirSync(instrDir).filter((f) => f.endsWith('.json') && !f.startsWith('_'));
+    for (const file of files) {
+        const filePath = node_path_1.default.join(instrDir, file);
+        try {
+            const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+            const parsed = JSON.parse(raw);
+            // Must have id, title, body to be a valid instruction
+            if (!parsed.id || !parsed.title || !parsed.body)
+                continue;
+            if (typeof parsed.id !== 'string' || typeof parsed.title !== 'string' || typeof parsed.body !== 'string')
+                continue;
+            const hash = sha256(raw);
+            const repoId = node_path_1.default.basename(repoPath);
+            const now = new Date().toISOString();
+            // Build entry from the file's own fields, filling gaps
+            const entry = {
+                id: parsed.id,
+                title: parsed.title,
+                body: parsed.body,
+                rationale: parsed.rationale || undefined,
+                priority: typeof parsed.priority === 'number' ? parsed.priority : 50,
+                audience: parsed.audience || 'all',
+                requirement: parsed.requirement || 'recommended',
+                categories: Array.isArray(parsed.categories) ? parsed.categories : ['instruction'],
+                primaryCategory: parsed.primaryCategory || (Array.isArray(parsed.categories) && parsed.categories.length ? parsed.categories[0] : 'instruction'),
+                contentType: parsed.contentType || 'instruction',
+                sourceHash: hash,
+                schemaVersion: schemaVersion_1.SCHEMA_VERSION,
+                version: parsed.version || '1.0.0',
+                status: parsed.status || 'approved',
+                owner: parsed.owner || 'promote_from_repo',
+                classification: parsed.classification || 'internal',
+                semanticSummary: parsed.semanticSummary || `${parsed.title} — promoted from ${repoId}`,
+                sourceWorkspace: repoId,
+                createdByAgent: parsed.createdByAgent || 'promote_from_repo',
+                createdAt: parsed.createdAt || now,
+                updatedAt: now,
+            };
+            results.push({ entry, hash, source: 'file' });
+        }
+        catch {
+            // skip malformed JSON
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Handler Registration
+// ---------------------------------------------------------------------------
+(0, registry_1.registerHandler)('promote_from_repo', (params) => {
+    const { repoPath, scope = 'all', force = false, dryRun = false } = params;
+    const repoId = params.repoId || node_path_1.default.basename(repoPath);
+    // Validate repoPath
+    if (!repoPath || typeof repoPath !== 'string') {
+        return { error: 'repoPath is required and must be a string' };
+    }
+    if (!node_fs_1.default.existsSync(repoPath) || !node_fs_1.default.statSync(repoPath).isDirectory()) {
+        return { error: `repoPath does not exist or is not a directory: ${repoPath}` };
+    }
+    const promoted = [];
+    const skipped = [];
+    const failed = [];
+    const dryRunEntries = [];
+    // Collect candidates from promotion map + instruction files
+    const candidates = [];
+    // 1. Promotion map
+    const map = loadPromotionMap(repoPath);
+    if (map) {
+        candidates.push(...scanMappedSources(repoPath, map, scope));
+    }
+    // 2. Instruction files (when scope is 'all' or 'instructions')
+    if (scope === 'all' || scope === 'instructions') {
+        candidates.push(...scanInstructionFiles(repoPath));
+    }
+    // Dedup: if same ID appears from both map and file, prefer map
+    const seen = new Set();
+    const deduped = [];
+    for (const c of candidates) {
+        if (!seen.has(c.entry.id)) {
+            seen.add(c.entry.id);
+            deduped.push(c);
+        }
+    }
+    // Load current index state
+    let IndexState;
+    try {
+        IndexState = (0, indexContext_1.ensureLoaded)();
+    }
+    catch (e) {
+        return {
+            repoPath,
+            repoId,
+            promoted: [],
+            skipped: [],
+            failed: [{ id: '*', error: `Failed to load index state: ${e instanceof Error ? e.message : String(e)}` }],
+            total: deduped.length,
+            promotedAt: new Date().toISOString(),
+        };
+    }
+    const classifier = new classificationService_1.ClassificationService();
+    // Process each candidate
+    for (const candidate of deduped) {
+        const { entry, hash } = candidate;
+        // Validate instruction ID format
+        if (!isValidInstructionId(entry.id)) {
+            failed.push({ id: entry.id, error: `Invalid instruction ID format: ${entry.id}` });
+            continue;
+        }
+        // Validate entry has minimum required fields
+        try {
+            classifier.normalize(entry); // will throw if fundamentally invalid
+        }
+        catch (e) {
+            failed.push({
+                id: entry.id,
+                error: `Schema validation failed: ${e instanceof Error ? e.message : String(e)}`,
+            });
+            continue;
+        }
+        // Ensure repoId is in categories
+        if (!entry.categories.includes(repoId)) {
+            entry.categories.push(repoId);
+        }
+        entry.sourceWorkspace = repoId;
+        // Check existing entry for dedup
+        const existing = IndexState.byId.get(entry.id);
+        if (existing && existing.sourceHash === hash && !force) {
+            // Hash unchanged — skip
+            if (dryRun) {
+                dryRunEntries.push({ id: entry.id, title: entry.title, action: 'skip' });
+            }
+            skipped.push(entry.id);
+            continue;
+        }
+        const action = existing ? 'update' : 'add';
+        if (dryRun) {
+            dryRunEntries.push({ id: entry.id, title: entry.title, action });
+            continue;
+        }
+        // Write entry to index
+        try {
+            (0, indexContext_1.writeEntry)(entry);
+            promoted.push(entry.id);
+            (0, auditLog_1.logAudit)('promote_from_repo', entry.id, {
+                repoPath,
+                repoId,
+                action,
+                sourceHash: hash,
+            });
+        }
+        catch (e) {
+            failed.push({
+                id: entry.id,
+                error: `Write failed: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    }
+    // writeEntry() already calls touchIndexVersion() for each entry,
+    // so no explicit touch needed here.
+    const result = {
+        repoPath,
+        repoId,
+        promoted,
+        skipped,
+        failed,
+        total: deduped.length,
+        promotedAt: new Date().toISOString(),
+    };
+    if (dryRun) {
+        result.dryRunEntries = dryRunEntries;
+    }
+    return result;
+});

package/dist/services/handlers.prompt.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/handlers.prompt.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const registry_1 = require("../server/registry");
+const promptReviewService_1 = require("./promptReviewService");
+const promptService = new promptReviewService_1.PromptReviewService();
+(0, registry_1.registerHandler)('prompt_review', (p) => { const raw = p.prompt || ''; const MAX = 10_000; if (raw.length > MAX)
+    return { truncated: true, message: 'prompt too large', max: MAX }; const sanitized = raw.replace(/\0/g, ''); const issues = promptService.review(sanitized); const summary = (0, promptReviewService_1.summarizeIssues)(issues); return { issues, summary, length: sanitized.length }; });