@jagilber-org/index-server 1.22.1 → 1.26.4

package/dist/services/storage/migrationEngine.js

@@ -10,9 +10,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrateJsonToSqlite = migrateJsonToSqlite;
 exports.migrateSqliteToJson = migrateSqliteToJson;
+exports.migrateJsonEmbeddingsToStore = migrateJsonEmbeddingsToStore;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const jsonFileStore_js_1 = require("./jsonFileStore.js");
+const jsonEmbeddingStore_js_1 = require("./jsonEmbeddingStore.js");
 const sqliteStore_js_1 = require("./sqliteStore.js");
 /**
  * Migrate all instructions from JSON files to a SQLite database.
@@ -91,3 +93,32 @@ function migrateSqliteToJson(dbPath, jsonDir, opts) {
     }
     return { exported, errors };
 }
+/**
+ * Migrate embeddings from a JSON file to an IEmbeddingStore (e.g. SqliteEmbeddingStore).
+ *
+ * Reads the JSON embedding cache and saves it into the target store.
+ * Idempotent: calling again with the same data overwrites safely.
+ */
+function migrateJsonEmbeddingsToStore(jsonEmbeddingPath, targetStore) {
+    try {
+        const jsonStore = new jsonEmbeddingStore_js_1.JsonEmbeddingStore(jsonEmbeddingPath);
+        const data = jsonStore.load();
+        jsonStore.close();
+        if (!data) {
+            return { migrated: 0, skipped: 0, error: 'No embedding data in JSON file' };
+        }
+        const count = Object.keys(data.embeddings).length;
+        if (count === 0) {
+            return { migrated: 0, skipped: 0 };
+        }
+        targetStore.save(data);
+        return { migrated: count, skipped: 0 };
+    }
+    catch (err) {
+        return {
+            migrated: 0,
+            skipped: 0,
+            error: err instanceof Error ? err.message : 'Migration failed',
+        };
+    }
+}

package/dist/services/storage/sqliteEmbeddingStore.d.ts

@@ -0,0 +1,30 @@
+/**
+ * SqliteEmbeddingStore — IEmbeddingStore backed by sqlite-vec (vec0 virtual table).
+ *
+ * Uses node:sqlite (DatabaseSync) with sqlite-vec extension for KNN vector search.
+ * Vectors stored as BLOB (Float32Array buffer), metadata in a companion table.
+ *
+ * Requires: Node.js ≥22.13.0, sqlite-vec npm package.
+ */
+import type { IEmbeddingStore, EmbeddingCacheData, EmbeddingSearchResult } from './types.js';
+export declare class SqliteEmbeddingStore implements IEmbeddingStore {
+    private db;
+    private readonly dims;
+    private readonly dbPath;
+    constructor(dbPath: string, dims?: number);
+    private initExtension;
+    /**
+     * Run PRAGMA integrity_check to detect database corruption.
+     * @returns true if the database is intact, false if corrupt.
+     */
+    private verifyIntegrity;
+    /**
+     * Rebuild a corrupt database by closing, deleting, and recreating it.
+     */
+    private rebuildDatabase;
+    private initSchema;
+    load(): EmbeddingCacheData | null;
+    save(data: EmbeddingCacheData): void;
+    search(queryVector: Float32Array, limit: number): EmbeddingSearchResult[];
+    close(): void;
+}

package/dist/services/storage/sqliteEmbeddingStore.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * SqliteEmbeddingStore — IEmbeddingStore backed by sqlite-vec (vec0 virtual table).
+ *
+ * Uses node:sqlite (DatabaseSync) with sqlite-vec extension for KNN vector search.
+ * Vectors stored as BLOB (Float32Array buffer), metadata in a companion table.
+ *
+ * Requires: Node.js ≥22.13.0, sqlite-vec npm package.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteEmbeddingStore = void 0;
+const node_sqlite_1 = require("node:sqlite");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sqlite_vec_1 = require("sqlite-vec");
+const logger_js_1 = require("../logger.js");
+const DEFAULT_VECTOR_DIMS = 384;
+const MAX_VECTOR_DIMS = 65536;
+const EMBEDDING_META_DDL = `CREATE TABLE IF NOT EXISTS embedding_meta (
+  instruction_id TEXT PRIMARY KEY,
+  model_name TEXT NOT NULL,
+  source_hash TEXT NOT NULL,
+  index_hash TEXT NOT NULL,
+  computed_at TEXT NOT NULL
+)`;
+/** Cache metadata stored in the SQLite metadata table. */
+const META_INDEX_HASH_KEY = 'embedding_index_hash';
+const META_MODEL_NAME_KEY = 'embedding_model_name';
+class SqliteEmbeddingStore {
+    db;
+    dims;
+    dbPath;
+    constructor(dbPath, dims = DEFAULT_VECTOR_DIMS) {
+        if (!Number.isInteger(dims) || dims < 1 || dims > MAX_VECTOR_DIMS) {
+            throw new Error(`Invalid vector dimensions: ${dims}. Must be an integer between 1 and ${MAX_VECTOR_DIMS}.`);
+        }
+        this.dims = dims;
+        this.dbPath = dbPath;
+        this.db = new node_sqlite_1.DatabaseSync(dbPath, { allowExtension: true });
+        this.initExtension();
+        if (!this.verifyIntegrity()) {
+            this.rebuildDatabase();
+        }
+        this.initSchema();
+    }
+    initExtension() {
+        const extPath = (0, sqlite_vec_1.getLoadablePath)();
+        // Security: validate the extension path resolves within node_modules
+        const resolved = path_1.default.resolve(extPath);
+        const nmDir = path_1.default.resolve(__dirname, '..', '..', '..', 'node_modules');
+        if (!resolved.startsWith(nmDir + path_1.default.sep) && !resolved.startsWith(nmDir + '/')) {
+            throw new Error(`sqlite-vec extension path escapes node_modules: ${resolved}`);
+        }
+        this.db.loadExtension(extPath);
+    }
+    /**
+     * Run PRAGMA integrity_check to detect database corruption.
+     * @returns true if the database is intact, false if corrupt.
+     */
+    verifyIntegrity() {
+        try {
+            const result = this.db.prepare('PRAGMA integrity_check').all();
+            if (result.length === 1 && result[0].integrity_check === 'ok')
+                return true;
+            const issues = result.map(r => r.integrity_check).join('; ');
+            (0, logger_js_1.logWarn)(`[embedding-store] Integrity check failed: ${issues}`);
+            return false;
+        }
+        catch (err) {
+            (0, logger_js_1.logWarn)(`[embedding-store] Integrity check error: ${err instanceof Error ? err.message : 'unknown'}`);
+            return false;
+        }
+    }
+    /**
+     * Rebuild a corrupt database by closing, deleting, and recreating it.
+     */
+    rebuildDatabase() {
+        (0, logger_js_1.logWarn)(`[embedding-store] Rebuilding corrupt database: ${this.dbPath}`);
+        try {
+            this.db.close();
+        }
+        catch { /* may already be unusable */ }
+        // Remove the corrupt DB and WAL/SHM files
+        for (const suffix of ['', '-wal', '-shm']) {
+            try {
+                fs_1.default.unlinkSync(this.dbPath + suffix);
+            }
+            catch { /* file may not exist */ }
+        }
+        this.db = new node_sqlite_1.DatabaseSync(this.dbPath, { allowExtension: true });
+        this.initExtension();
+        (0, logger_js_1.logInfo)(`[embedding-store] Database rebuilt successfully`);
+    }
+    initSchema() {
+        this.db.exec('PRAGMA journal_mode = WAL');
+        this.db.exec('PRAGMA busy_timeout = 5000');
+        // Ensure metadata table exists (may already exist from SqliteStore)
+        this.db.exec('CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT)');
+        this.db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS embeddings USING vec0(
+      instruction_id TEXT PRIMARY KEY,
+      embedding float[${this.dims}]
+    )`);
+        this.db.exec(EMBEDDING_META_DDL);
+    }
+    load() {
+        // Read cache metadata
+        const hashRow = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get(META_INDEX_HASH_KEY);
+        const modelRow = this.db.prepare('SELECT value FROM metadata WHERE key = ?').get(META_MODEL_NAME_KEY);
+        if (!hashRow)
+            return null;
+        // Read all embeddings
+        const rows = this.db.prepare('SELECT instruction_id, embedding FROM embeddings').all();
+        if (rows.length === 0) {
+            // CodeQL flagged the original `&& !hashRow` as dead code (already
+            // null-guarded at L115). We cannot upgrade to `if (rows.length === 0) return null`
+            // because the public contract (see embeddingStore.contract.spec.ts
+            // "save() with empty embeddings map succeeds") requires a non-null cache
+            // when hashRow exists but no embeddings have been persisted. Fall through
+            // to return { indexHash, entryHashes, embeddings: {} } so subsequent saves
+            // can layer onto the same metadata.
+        }
+        const embeddings = {};
+        for (const row of rows) {
+            // Validate buffer bounds before creating Float32Array view
+            const expectedBytes = this.dims * 4;
+            if (row.embedding.byteLength !== expectedBytes) {
+                (0, logger_js_1.logWarn)(`[embedding-store] Skipping entry '${row.instruction_id}': buffer size ${row.embedding.byteLength} bytes, expected ${expectedBytes} (${this.dims} dims × 4 bytes)`);
+                continue;
+            }
+            embeddings[row.instruction_id] = Array.from(new Float32Array(row.embedding.buffer, row.embedding.byteOffset, this.dims));
+        }
+        // Read entry hashes from embedding_meta
+        const metaRows = this.db.prepare('SELECT instruction_id, source_hash FROM embedding_meta').all();
+        const entryHashes = {};
+        for (const m of metaRows) {
+            entryHashes[m.instruction_id] = m.source_hash;
+        }
+        return {
+            indexHash: hashRow.value,
+            modelName: modelRow?.value,
+            entryHashes,
+            embeddings,
+        };
+    }
+    save(data) {
+        // TODO: Replace full-table clear+reinsert with incremental upsert for large datasets.
+        // Use a diff of entryHashes to INSERT OR REPLACE only changed entries and DELETE removed ones.
+        // Use a transaction for atomicity
+        const tx = this.db.prepare('BEGIN');
+        const commit = this.db.prepare('COMMIT');
+        const rollback = this.db.prepare('ROLLBACK');
+        try {
+            tx.run();
+            // Clear existing data
+            this.db.exec('DELETE FROM embeddings');
+            this.db.exec('DELETE FROM embedding_meta');
+            // Upsert cache metadata
+            const upsertMeta = this.db.prepare('INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)');
+            upsertMeta.run(META_INDEX_HASH_KEY, data.indexHash);
+            if (data.modelName) {
+                upsertMeta.run(META_MODEL_NAME_KEY, data.modelName);
+            }
+            // Insert embeddings
+            const insertVec = this.db.prepare('INSERT INTO embeddings (instruction_id, embedding) VALUES (?, ?)');
+            const insertMeta = this.db.prepare('INSERT INTO embedding_meta (instruction_id, model_name, source_hash, index_hash, computed_at) VALUES (?, ?, ?, ?, ?)');
+            const now = new Date().toISOString();
+            for (const [id, vec] of Object.entries(data.embeddings)) {
+                if (vec.length !== this.dims) {
+                    throw new Error(`Vector dimension mismatch for '${id}': expected ${this.dims}, got ${vec.length}`);
+                }
+                for (let i = 0; i < vec.length; i++) {
+                    if (!Number.isFinite(vec[i])) {
+                        throw new Error(`Invalid vector value for '${id}' at index ${i}: ${vec[i]}. Vectors must contain only finite numbers.`);
+                    }
+                }
+                const buf = Buffer.from(new Float32Array(vec).buffer);
+                insertVec.run(id, buf);
+                insertMeta.run(id, data.modelName ?? 'unknown', data.entryHashes?.[id] ?? '', data.indexHash, now);
+            }
+            commit.run();
+        }
+        catch (err) {
+            try {
+                rollback.run();
+            }
+            catch { /* rollback may fail if tx already aborted */ }
+            throw err;
+        }
+    }
+    search(queryVector, limit) {
+        if (limit <= 0)
+            return [];
+        if (queryVector.length !== this.dims) {
+            (0, logger_js_1.logWarn)(`[embedding-store] Search query dimension mismatch: expected ${this.dims}, got ${queryVector.length}`);
+            return [];
+        }
+        try {
+            const buf = Buffer.from(queryVector.buffer, queryVector.byteOffset, queryVector.byteLength);
+            const rows = this.db.prepare('SELECT instruction_id, distance FROM embeddings WHERE embedding MATCH ? ORDER BY distance LIMIT ?').all(buf, limit);
+            return rows.map(r => ({
+                id: r.instruction_id,
+                distance: r.distance,
+            }));
+        }
+        catch (err) {
+            (0, logger_js_1.logWarn)(`[embedding-store] search failed: ${err instanceof Error ? err.message : 'unknown'}`);
+            return [];
+        }
+    }
+    close() {
+        try {
+            this.db.close();
+        }
+        catch {
+            // Already closed
+        }
+    }
+}
+exports.SqliteEmbeddingStore = SqliteEmbeddingStore;

package/dist/services/storage/sqliteStore.d.ts

@@ -23,7 +23,9 @@ export declare class SqliteStore implements IInstructionStore {
     load(): LoadResult;
     close(): void;
     get(id: string): InstructionEntry | null;
-    write(entry: InstructionEntry): void;
+    write(entry: InstructionEntry, opts?: {
+        createOnly?: boolean;
+    }): void;
     remove(id: string): void;
     list(opts?: ListOptions): InstructionEntry[];
     query(opts: QueryOptions): InstructionEntry[];

package/dist/services/storage/sqliteStore.js

@@ -162,8 +162,8 @@ class SqliteStore {
         this.ensureLoaded();
         return this.cache.get(id) ?? null;
     }
-    write(entry) {
-        const sql = `INSERT OR REPLACE INTO instructions (
+    write(entry, opts) {
+        const sql = `${opts?.createOnly ? 'INSERT INTO' : 'INSERT OR REPLACE INTO'} instructions (
       id, title, body, rationale, priority, audience, requirement,
       categories, content_type, primary_category, source_hash,
       schema_version, deprecated_by, created_at, updated_at,

package/dist/services/storage/types.d.ts

@@ -123,7 +123,9 @@ export interface IInstructionStore {
      * Write (create or update) an instruction.
      * @param entry - The instruction to persist.
      */
-    write(entry: InstructionEntry): void;
+    write(entry: InstructionEntry, opts?: {
+        createOnly?: boolean;
+    }): void;
     /**
      * Remove an instruction by ID. No-op if not found.
      * @param id - Instruction ID to remove.
@@ -169,3 +171,48 @@ export interface IInstructionStore {
      */
     count(): number;
 }
+/**
+ * Persisted embedding cache format (backwards-compatible: entryHashes is optional).
+ */
+export interface EmbeddingCacheData {
+    indexHash: string;
+    modelName?: string;
+    /** Per-entry content hashes for incremental invalidation (required for v2+). */
+    entryHashes?: Record<string, string>;
+    embeddings: Record<string, number[]>;
+}
+/** A single embedding search result with distance score. */
+export interface EmbeddingSearchResult {
+    id: string;
+    distance: number;
+}
+/**
+ * Storage backend interface for embedding vectors.
+ *
+ * Implementations:
+ * - JsonEmbeddingStore: Flat JSON file (default, current behavior)
+ * - SqliteEmbeddingStore: sqlite-vec vec0 virtual table
+ */
+export interface IEmbeddingStore {
+    /**
+     * Load cached embedding data from the backing store.
+     * @returns The cached data, or null if no data exists.
+     */
+    load(): EmbeddingCacheData | null;
+    /**
+     * Save embedding data to the backing store.
+     * @param data - The embedding cache data to persist.
+     */
+    save(data: EmbeddingCacheData): void;
+    /**
+     * Search for the nearest vectors to a query vector (KNN).
+     * @param queryVector - The query embedding vector.
+     * @param limit - Maximum number of results to return.
+     * @returns Array of { id, distance } sorted by distance ascending.
+     */
+    search(queryVector: Float32Array, limit: number): EmbeddingSearchResult[];
+    /**
+     * Close the store and release resources.
+     */
+    close(): void;
+}

package/dist/services/toolRegistry.js

@@ -10,8 +10,55 @@ exports.getToolRegistry = getToolRegistry;
  */
 const schemas_1 = require("../schemas");
 const featureFlags_1 = require("./featureFlags");
+const envUtils_1 = require("../utils/envUtils");
+const runtimeConfig_1 = require("../config/runtimeConfig");
 // Input schema helpers (keep intentionally permissive if params optional)
 const stringReq = (name) => ({ type: 'object', additionalProperties: false, required: [name], properties: { [name]: { type: 'string' } } });
+const extensionsInputSchema = {
+    type: 'object',
+    additionalProperties: {
+        anyOf: [
+            { type: 'string' },
+            { type: 'number' },
+            { type: 'boolean' },
+            { type: 'array', items: {} },
+            { type: 'object', additionalProperties: true },
+        ],
+    },
+};
+const DANGEROUS_DIAGNOSTIC_TOOLS = new Set([
+    'diagnostics_block',
+    'diagnostics_microtaskFlood',
+    'diagnostics_memoryPressure',
+]);
+function buildInstructionBodyInputSchema(baseDescription) {
+    const maxLength = (0, runtimeConfig_1.getRuntimeConfig)().index.bodyWarnLength;
+    return {
+        type: 'string',
+        maxLength,
+        description: `${baseDescription} Current write limit: ${maxLength} characters via INDEX_SERVER_BODY_WARN_LENGTH. Split oversized content into cross-linked instructions.`,
+    };
+}
+function withDynamicInstructionBodyLimits(name, inputSchema) {
+    const schema = JSON.parse(JSON.stringify(inputSchema));
+    if (name === 'index_add') {
+        const entryProps = schema.properties?.entry?.properties ?? {};
+        entryProps.body = buildInstructionBodyInputSchema('Instruction body.');
+    }
+    else if (name === 'index_import') {
+        const entries = schema.properties?.entries?.oneOf;
+        const arrayVariant = Array.isArray(entries) ? entries.find((candidate) => candidate.type === 'array') : undefined;
+        const itemProps = arrayVariant?.items?.properties ?? {};
+        itemProps.body = buildInstructionBodyInputSchema('Instruction body.');
+    }
+    else if (name === 'index_dispatch') {
+        const props = schema.properties ?? {};
+        const entryProps = props.entry?.properties ?? {};
+        entryProps.body = buildInstructionBodyInputSchema('Instruction body for action="add".');
+        props.body = buildInstructionBodyInputSchema('Flat instruction body for action="add".');
+    }
+    return schema;
+}
 // Explicit param schemas derived from handlers in toolHandlers.ts
 const INPUT_SCHEMAS = {
     // graph export (Phase 1 + Phase 2 enrichment). All params optional.
@@ -47,7 +94,7 @@ const INPUT_SCHEMAS = {
             keywords: { type: 'array', items: { type: 'string' }, description: 'Explicit keyword array for search action when the caller wants direct token control.' },
             ids: { type: 'array', items: { type: 'string' }, description: 'Array of instruction IDs for remove or export actions.' },
             category: { type: 'string', description: 'Filter by category for list action.' },
-            contentType: { type: 'string', description: 'Filter by content type for list, search, or query actions.' },
+            contentType: { type: 'string', enum: ['instruction', 'template', 'chat-session', 'reference', 'example', 'agent'], description: 'Filter by content type for list, search, or query actions, or specify the entry content type for add action.' },
             text: { type: 'string', description: 'Full-text search within query action.' },
             includeCategories: { type: 'boolean', description: 'Search categories in addition to id/title/semanticSummary/body for search action.' },
             caseSensitive: { type: 'boolean', description: 'Enable case-sensitive matching for search action.' },
@@ -59,6 +106,15 @@ const INPUT_SCHEMAS = {
             offset: { type: 'number', description: 'Pagination offset (query action).' },
             // Mutation params for add action (flat-param support: agents can pass these at top level instead of nested entry wrapper)
             entry: { type: 'object', description: 'Instruction entry object for add action. Alternatively, pass id/body/title as top-level params.', additionalProperties: true, properties: { id: { type: 'string' }, title: { type: 'string' }, body: { type: 'string' } } },
+            priority: { type: 'number' },
+            audience: { type: 'string' },
+            requirement: { type: 'string' },
+            categories: { type: 'array', items: { type: 'string' } },
+            deprecatedBy: { type: 'string' },
+            riskScore: { type: 'number' },
+            version: { type: 'string' },
+            priorityTier: { type: 'string', enum: ['P1', 'P2', 'P3', 'P4'] },
+            classification: { type: 'string', enum: ['public', 'internal', 'restricted'] },
             overwrite: { type: 'boolean', description: 'Allow overwriting existing instruction (add action).' },
             lax: { type: 'boolean', description: 'Enable lax mode with default fills for missing optional fields (add action).' },
             // Import action params
@@ -66,8 +122,8 @@ const INPUT_SCHEMAS = {
             source: { type: 'string', description: 'Directory path containing .json instruction files to import (import action).' },
             mode: { description: 'Import conflict resolution mode (import action) or groom mode object (groom action).' },
             // Governance update params
-            owner: { type: 'string', description: 'Owner identifier for governanceUpdate action.' },
-            status: { type: 'string', description: 'Governance status for governanceUpdate action.', enum: ['approved', 'draft', 'deprecated'] },
+            owner: { type: 'string', description: 'Owner identifier for governanceUpdate action or add action.' },
+            status: { type: 'string', description: 'Governance status for governanceUpdate action or add action.', enum: ['approved', 'draft', 'review', 'deprecated'] },
             bump: { type: 'string', description: 'Version bump level for governanceUpdate action.', enum: ['patch', 'minor', 'major', 'none'] },
             lastReviewedAt: { type: 'string', description: 'Last review date (ISO 8601) for governanceUpdate action.' },
             nextReviewDue: { type: 'string', description: 'Next review due date (ISO 8601) for governanceUpdate action.' },
@@ -91,8 +147,8 @@ const INPUT_SCHEMAS = {
     // legacy read-only instruction method schemas removed in favor of dispatcher
     'index_import': { type: 'object', additionalProperties: false, properties: {
             entries: { oneOf: [
-                    { type: 'array', minItems: 1, items: { type: 'object', required: ['id', 'title', 'body', 'priority', 'audience', 'requirement'], additionalProperties: true, properties: {
-                                id: { type: 'string' }, title: { type: 'string' }, body: { type: 'string', maxLength: 1000000, description: 'Instruction body (default limit 20K chars, absolute max 1MB). Split oversized content into cross-linked instructions.' }, rationale: { type: 'string' }, priority: { type: 'number' }, audience: { type: 'string' }, requirement: { type: 'string' }, categories: { type: 'array', items: { type: 'string' } }, extensions: { type: 'object', additionalProperties: true }, mode: { type: 'string' }
+                    { type: 'array', minItems: 1, items: { type: 'object', required: ['id', 'title', 'body', 'priority', 'audience', 'requirement'], additionalProperties: false, properties: {
+                                id: { type: 'string' }, title: { type: 'string' }, body: { type: 'string' }, rationale: { type: 'string' }, priority: { type: 'number' }, audience: { type: 'string' }, requirement: { type: 'string' }, categories: { type: 'array', items: { type: 'string' } }, version: { type: 'string' }, owner: { type: 'string' }, status: { type: 'string', enum: ['approved', 'draft', 'review', 'deprecated'] }, priorityTier: { type: 'string', enum: ['P1', 'P2', 'P3', 'P4'] }, classification: { type: 'string', enum: ['public', 'internal', 'restricted'] }, lastReviewedAt: { type: 'string' }, nextReviewDue: { type: 'string' }, semanticSummary: { type: 'string' }, changeLog: { type: 'array', items: { type: 'object', additionalProperties: true } }, contentType: { type: 'string', enum: ['instruction', 'template', 'chat-session', 'reference', 'example', 'agent'] }, extensions: extensionsInputSchema, mode: { type: 'string' }
                             } } },
                     { type: 'string', description: 'Stringified JSON array of instruction entries, or a file path to a JSON array of instruction entries' }
                 ] },
@@ -100,8 +156,8 @@ const INPUT_SCHEMAS = {
             mode: { enum: ['skip', 'overwrite'] }
         } },
     'index_add': { type: 'object', additionalProperties: false, required: ['entry'], properties: {
-            entry: { type: 'object', required: ['id', 'body'], additionalProperties: true, properties: {
-                    id: { type: 'string' }, title: { type: 'string' }, body: { type: 'string', maxLength: 1000000, description: 'Instruction body (default limit 20K chars, absolute max 1MB). If content exceeds the limit, split into multiple cross-linked instructions with shared categories.' }, rationale: { type: 'string' }, priority: { type: 'number' }, audience: { type: 'string' }, requirement: { type: 'string' }, categories: { type: 'array', items: { type: 'string' } }, deprecatedBy: { type: 'string' }, riskScore: { type: 'number' }, extensions: { type: 'object', additionalProperties: true }
+            entry: { type: 'object', required: ['id', 'body'], additionalProperties: false, properties: {
+                    id: { type: 'string', maxLength: 120 }, title: { type: 'string' }, body: { type: 'string' }, rationale: { type: 'string' }, priority: { type: 'number' }, audience: { type: 'string' }, requirement: { type: 'string' }, categories: { type: 'array', items: { type: 'string' } }, deprecatedBy: { type: 'string' }, riskScore: { type: 'number' }, version: { type: 'string' }, owner: { type: 'string' }, status: { type: 'string', enum: ['approved', 'draft', 'review', 'deprecated'] }, priorityTier: { type: 'string', enum: ['P1', 'P2', 'P3', 'P4'] }, classification: { type: 'string', enum: ['public', 'internal', 'restricted'] }, lastReviewedAt: { type: 'string' }, nextReviewDue: { type: 'string' }, semanticSummary: { type: 'string' }, changeLog: { type: 'array', items: { type: 'object', additionalProperties: true } }, contentType: { type: 'string', enum: ['instruction', 'template', 'chat-session', 'reference', 'example', 'agent'] }, extensions: extensionsInputSchema
                 } },
             overwrite: { type: 'boolean' },
             lax: { type: 'boolean' }
@@ -152,46 +208,6 @@ const INPUT_SCHEMAS = {
             metadata: { type: 'object', additionalProperties: true },
             tags: { type: 'array', maxItems: 10, items: { type: 'string' } }
         } },
-    'feedback_list': { type: 'object', additionalProperties: false, properties: {
-            type: { type: 'string', enum: ['issue', 'status', 'security', 'feature-request', 'bug-report', 'performance', 'usability', 'other'] },
-            severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-            status: { type: 'string', enum: ['new', 'acknowledged', 'in-progress', 'resolved', 'closed'] },
-            limit: { type: 'number', minimum: 1, maximum: 200 },
-            offset: { type: 'number', minimum: 0 },
-            since: { type: 'string' },
-            tags: { type: 'array', items: { type: 'string' } }
-        } },
-    'feedback_get': { type: 'object', additionalProperties: false, required: ['id'], properties: {
-            id: { type: 'string' }
-        } },
-    'feedback_update': { type: 'object', additionalProperties: false, required: ['id'], properties: {
-            id: { type: 'string' },
-            status: { type: 'string', enum: ['new', 'acknowledged', 'in-progress', 'resolved', 'closed'] },
-            metadata: { type: 'object', additionalProperties: true }
-        } },
-    'feedback_stats': { type: 'object', additionalProperties: false, properties: {
-            since: { type: 'string' }
-        } },
-    'feedback_health': { type: 'object', additionalProperties: true },
-    // Unified feedback dispatch (002 Phase 2a)
-    'feedback_dispatch': { type: 'object', additionalProperties: true, required: ['action'], properties: {
-            action: { type: 'string', enum: ['submit', 'list', 'get', 'update', 'stats', 'health', 'rate'], description: 'Feedback action to perform.' },
-            instructionId: { type: 'string', description: 'Instruction ID to rate (rate action).' },
-            rating: { type: 'string', enum: ['useful', 'not-useful', 'outdated', 'incomplete'], description: 'Rating value (rate action).' },
-            comment: { type: 'string', maxLength: 1000, description: 'Optional comment with rating (rate action).' },
-            type: { type: 'string', enum: ['issue', 'status', 'security', 'feature-request', 'bug-report', 'performance', 'usability', 'other'] },
-            severity: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-            title: { type: 'string', maxLength: 200 },
-            description: { type: 'string', maxLength: 10000, description: 'Feedback description/body text (submit).' },
-            body: { type: 'string', maxLength: 10000, description: 'Alias for description (submit).' },
-            id: { type: 'string' },
-            status: { type: 'string', enum: ['new', 'acknowledged', 'in-progress', 'resolved', 'closed'] },
-            limit: { type: 'number', minimum: 1, maximum: 200 },
-            offset: { type: 'number', minimum: 0 },
-            since: { type: 'string' },
-            tags: { type: 'array', items: { type: 'string' } },
-            metadata: { type: 'object', additionalProperties: true }
-        } },
     // instructions search tool - PRIMARY discovery mechanism
     'index_search': { type: 'object', additionalProperties: false, required: ['keywords'], properties: {
             keywords: {
@@ -226,9 +242,9 @@ const INPUT_SCHEMAS = {
             token: { type: 'string', description: 'Token for confirm action.' }
         } },
     // diagnostics / test-only tools (not stable)
-    'diagnostics_block': { type: 'object', additionalProperties: false, required: ['ms'], properties: { ms: { type: 'number', minimum: 0, maximum: 10000 } } },
-    'diagnostics_microtaskFlood': { type: 'object', additionalProperties: false, properties: { count: { type: 'number', minimum: 0, maximum: 200000 } } },
-    'diagnostics_memoryPressure': { type: 'object', additionalProperties: false, properties: { mb: { type: 'number', minimum: 1, maximum: 512 } } }
+    'diagnostics_block': { type: 'object', additionalProperties: false, required: ['ms'], properties: { ms: { type: 'number', minimum: 0, maximum: 1000 } } },
+    'diagnostics_microtaskFlood': { type: 'object', additionalProperties: false, properties: { count: { type: 'number', minimum: 0, maximum: 25000 } } },
+    'diagnostics_memoryPressure': { type: 'object', additionalProperties: false, properties: { mb: { type: 'number', minimum: 1, maximum: 64 } } }
 };
 // Inject new schema after definition block (kept outside literal to avoid large diff churn if ordering changes)
 // Provide permissive object with optional includeTrace boolean.
@@ -305,20 +321,19 @@ INPUT_SCHEMAS['trace_dump'] = { type: 'object', additionalProperties: false, pro
         file: { type: 'string', description: 'Optional path to write the trace buffer JSON file' }
     } };
 // Stable & mutation classification lists (mirrors usage in toolHandlers; exported to remove duplication there).
-exports.STABLE = new Set(['health_check', 'graph_export', 'index_dispatch', 'index_search', 'index_governanceHash', 'prompt_review', 'integrity_verify', 'usage_track', 'usage_hotset', 'metrics_snapshot', 'gates_evaluate', 'meta_tools', 'help_overview', 'index_schema', 'feedback_list', 'feedback_get', 'feedback_stats', 'feedback_health', 'manifest_status', 'index_diagnostics', 'meta_activation_guide', 'meta_check_activation', 'feedback_dispatch', 'bootstrap', 'bootstrap_status', 'feature_status', 'index_health', 'index_inspect', 'index_debug', 'integrity_manifest', 'diagnostics_block', 'diagnostics_microtaskFlood', 'diagnostics_memoryPressure', 'messaging_read', 'messaging_list_channels', 'messaging_stats', 'messaging_get', 'messaging_thread', 'trace_dump']);
-exports.MUTATION = new Set(['index_add', 'index_import', 'index_repair', 'index_reload', 'index_remove', 'index_groom', 'index_enrich', 'index_governanceUpdate', 'index_normalize', 'usage_flush', 'feedback_submit', 'feedback_update', 'manifest_refresh', 'manifest_repair', 'promote_from_repo', 'bootstrap_request', 'bootstrap_confirmFinalize', 'messaging_send', 'messaging_ack', 'messaging_update', 'messaging_purge', 'messaging_reply']);
+exports.STABLE = new Set(['health_check', 'graph_export', 'index_dispatch', 'index_search', 'index_governanceHash', 'prompt_review', 'integrity_verify', 'usage_track', 'usage_hotset', 'metrics_snapshot', 'gates_evaluate', 'meta_tools', 'help_overview', 'index_schema', 'manifest_status', 'index_diagnostics', 'meta_activation_guide', 'meta_check_activation', 'bootstrap', 'bootstrap_status', 'feature_status', 'index_health', 'index_inspect', 'index_debug', 'integrity_manifest', 'messaging_read', 'messaging_list_channels', 'messaging_stats', 'messaging_get', 'messaging_thread', 'trace_dump']);
+exports.MUTATION = new Set(['index_add', 'index_import', 'index_repair', 'index_reload', 'index_remove', 'index_groom', 'index_enrich', 'index_governanceUpdate', 'index_normalize', 'usage_flush', 'feedback_submit', 'manifest_refresh', 'manifest_repair', 'promote_from_repo', 'bootstrap_request', 'bootstrap_confirmFinalize', 'messaging_send', 'messaging_ack', 'messaging_update', 'messaging_purge', 'messaging_reply', 'diagnostics_block', 'diagnostics_microtaskFlood', 'diagnostics_memoryPressure']);
 // Tool tier classification (002-tool-consolidation spec)
 // core: always visible, essential daily use
 // extended: opt-in via INDEX_SERVER_FLAG_TOOLS_EXTENDED=1 or flags.json tools_extended:true
 // admin: opt-in via INDEX_SERVER_FLAG_TOOLS_ADMIN=1, rarely needed ops/debug tools
 const TOOL_TIERS = {
-    // Core (7)
+    // Core (7 → 6 after feedback_dispatch removal)
     'health_check': 'core',
     'index_dispatch': 'core',
     'index_search': 'core',
     'prompt_review': 'core',
     'help_overview': 'core',
-    'feedback_dispatch': 'core',
     'bootstrap': 'core',
     // Extended (14)
     'graph_export': 'extended',
@@ -337,8 +352,6 @@ const TOOL_TIERS = {
     'index_schema': 'extended',
     // Admin (everything else)
     'feedback_submit': 'admin',
-    'feedback_list': 'admin',
-    'feedback_get': 'admin',
     'meta_tools': 'admin',
     'meta_activation_guide': 'admin',
     'meta_check_activation': 'admin',
@@ -350,9 +363,6 @@ const TOOL_TIERS = {
     'index_enrich': 'admin',
     'index_normalize': 'admin',
     'usage_flush': 'admin',
-    'feedback_update': 'admin',
-    'feedback_stats': 'admin',
-    'feedback_health': 'admin',
     'manifest_status': 'admin',
     'manifest_refresh': 'admin',
     'manifest_repair': 'admin',
@@ -391,12 +401,18 @@ function resolveActiveTier() {
 function getToolRegistry(filter) {
     const maxTier = filter?.tier ?? resolveActiveTier();
     const maxLevel = TIER_LEVEL[maxTier];
+    const diagnosticsEnabled = (0, envUtils_1.dangerousDiagnosticsEnabled)();
     const entries = [];
     const names = new Set([...exports.STABLE, ...exports.MUTATION]);
     // Ensure we also expose any tools that have schemas even if not in STABLE/MUTATION lists.
-    for (const k of Object.keys(INPUT_SCHEMAS))
+    for (const k of Object.keys(INPUT_SCHEMAS)) {
+        if (!diagnosticsEnabled && DANGEROUS_DIAGNOSTIC_TOOLS.has(k))
+            continue;
         names.add(k);
+    }
     for (const name of Array.from(names).sort()) {
+        if (!diagnosticsEnabled && DANGEROUS_DIAGNOSTIC_TOOLS.has(name))
+            continue;
         const tier = TOOL_TIERS[name] || 'admin';
         if (TIER_LEVEL[tier] > maxLevel)
             continue;
@@ -407,7 +423,7 @@ function getToolRegistry(filter) {
             stable: exports.STABLE.has(name),
             mutation: exports.MUTATION.has(name),
             tier,
-            inputSchema: INPUT_SCHEMAS[name] || { type: 'object' },
+            inputSchema: withDynamicInstructionBodyLimits(name, INPUT_SCHEMAS[name] || { type: 'object' }),
             outputSchema,
             // zodSchema to be attached incrementally by a forthcoming zodRegistry enhancer.
         });
@@ -443,12 +459,6 @@ function describeTool(name) {
         case 'meta_tools': return 'Enumerate available tools & their metadata.';
         // feedback system descriptions
         case 'feedback_submit': return 'Submit feedback entry (issue, status report, security alert, feature request, etc.).';
-        case 'feedback_list': return 'List feedback entries with filtering options (type, severity, status, date range).';
-        case 'feedback_get': return 'Get specific feedback entry by ID with full details.';
-        case 'feedback_update': return 'Update feedback entry status and metadata (admin function).';
-        case 'feedback_stats': return 'Get feedback system statistics and metrics dashboard.';
-        case 'feedback_health': return 'Health check for feedback system storage and configuration.';
-        case 'feedback_dispatch': return 'Unified feedback dispatcher. Actions: submit, list, get, update, stats, health, rate.';
         case 'bootstrap': return 'Unified bootstrap dispatcher. Actions: request, confirm, status.';
         case 'manifest_status': return 'Report index manifest presence and drift summary.';
         case 'manifest_refresh': return 'Rewrite manifest from current index state.';