@shrkcrft/mcp-server 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/tools/plan-quality-review.tool.js

@@ -0,0 +1,294 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+/**
+ * `plan_quality_review` — score a plan blob for hallucination,
+ * generic boilerplate, contradictions, and ungrounded commands.
+ *
+ * Inputs:
+ *   - `plan`: either a stringified JSON / Markdown plan body, OR a
+ *     `{ from: { slug } }` reference that resolves to a saved
+ *     `.sharkcraft/smart-context/<slug>.plan.json`.
+ *   - `recommendedCommands` (optional): the set of commands that are
+ *     considered "real" (typically `verificationCommands` from the
+ *     same focused bundle). Anything outside this set in
+ *     `firstCommands`/`validationCommands` gets flagged.
+ *
+ * Output: structured findings + an overall verdict so the calling
+ * agent can decide whether to use, retry, or reject the plan.
+ *
+ * Read-only — does not modify or rewrite the plan.
+ */
+export const planQualityReviewTool = {
+    name: 'plan_quality_review',
+    description: 'Critique a plan (JSON or Markdown) for hallucinated paths, generic boilerplate, contradictions, and ungrounded commands. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            plan: { type: 'string' },
+            planFrom: { type: 'object' },
+            recommendedCommands: { type: 'array', items: { type: 'string' } },
+        },
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        let planText;
+        const planFrom = input['planFrom'];
+        if (typeof input['plan'] === 'string' && input['plan'].length > 0) {
+            planText = input['plan'];
+        }
+        else if (planFrom && typeof planFrom === 'object') {
+            const slug = typeof planFrom['slug'] === 'string'
+                ? planFrom['slug']
+                : '';
+            if (slug.length === 0) {
+                return { data: { error: 'planFrom.slug is required when using planFrom' } };
+            }
+            const path = nodePath.join(ctx.cwd, '.sharkcraft', 'smart-context', `${slug}.plan.json`);
+            if (!existsSync(path)) {
+                return { data: { error: 'no-plan-for-slug', slug, lookedAt: path } };
+            }
+            try {
+                const { readFileSync } = await import('node:fs');
+                planText = readFileSync(path, 'utf8');
+            }
+            catch (e) {
+                return { data: { error: `read failed: ${e.message}` } };
+            }
+        }
+        else {
+            return { data: { error: 'one of `plan` or `planFrom` is required' } };
+        }
+        if (!planText)
+            return { data: { error: 'empty plan' } };
+        const parsed = tryExtractJson(planText);
+        const recommendedCommandsRaw = Array.isArray(input['recommendedCommands'])
+            ? input['recommendedCommands'].filter((c) => typeof c === 'string')
+            : [];
+        const knownCommands = new Set(recommendedCommandsRaw.map(normaliseCommand));
+        const findings = analysePlan({
+            cwd: ctx.cwd,
+            raw: planText,
+            parsed,
+            knownCommands,
+        });
+        const score = scoreFindings(findings);
+        const verdict = score >= 0.85
+            ? 'good'
+            : score >= 0.6
+                ? 'usable-with-review'
+                : score >= 0.35
+                    ? 'weak'
+                    : 'reject';
+        return {
+            data: {
+                verdict,
+                score,
+                parsed: parsed !== null,
+                findings,
+                handoffForClaude: verdict === 'reject'
+                    ? 'Reject this plan — too many ungrounded claims.'
+                    : verdict === 'weak'
+                        ? 'Plan is weak; consider regenerating with --polish or a stronger model.'
+                        : verdict === 'usable-with-review'
+                            ? 'Plan is usable but verify the flagged paths and commands.'
+                            : 'Plan looks well-grounded.',
+            },
+        };
+    },
+};
+function analysePlan(input) {
+    const out = [];
+    // 1. Hallucinated paths — walk the parsed JSON.
+    if (input.parsed) {
+        const seen = new Set();
+        walkPathLeaves(input.parsed, '$', (path, where) => {
+            const id = `${where}:${path}`;
+            if (seen.has(id))
+                return;
+            seen.add(id);
+            if (!looksLikePathRef(path))
+                return;
+            if (!pathExistsInWorkspace(input.cwd, path)) {
+                out.push({
+                    category: 'hallucinated-path',
+                    severity: 'high',
+                    message: `Path "${path}" does not exist in the workspace.`,
+                    where,
+                });
+            }
+        });
+    }
+    // 2. Generic boilerplate (the polish preamble's anti-patterns).
+    const genericPatterns = [
+        { re: /may require additional resources and infrastructure/i, msg: 'Generic "additional resources" boilerplate.' },
+        { re: /may introduce additional complexity/i, msg: 'Generic "additional complexity" boilerplate.' },
+        { re: /may require additional security and privacy considerations/i, msg: 'Generic "security and privacy" boilerplate.' },
+        { re: /can be implemented as a separate tool or as a plugin/i, msg: '"Can be implemented as a separate tool" — useless differentiation.' },
+        { re: /documentation and support level/i, msg: 'Enterprise-boilerplate question about "documentation and support level".' },
+        { re: /\bGET\b.*\b(cli|file|stdout|mcp)/i, msg: 'HTTP verb on a CLI/file/stdout/MCP surface.' },
+    ];
+    for (const p of genericPatterns) {
+        if (p.re.test(input.raw)) {
+            out.push({ category: 'generic-boilerplate', severity: 'medium', message: p.msg });
+        }
+    }
+    // 3. Contradictions: filesToAvoid ∩ likelyFilesToModify.
+    if (input.parsed) {
+        const avoid = collectPathSet(input.parsed['filesToAvoid']);
+        const modify = collectPathSet(input.parsed['likelyFilesToModify']);
+        const overlap = [...avoid].filter((p) => modify.has(p));
+        for (const p of overlap) {
+            out.push({
+                category: 'contradiction',
+                severity: 'high',
+                message: `"${p}" appears in both filesToAvoid and likelyFilesToModify.`,
+            });
+        }
+    }
+    // 4. Ungrounded commands.
+    if (input.parsed && input.knownCommands.size > 0) {
+        const firstCmds = collectStringArrayFromKey(input.parsed['firstCommands'], 'command');
+        const valCmds = collectStringArrayFromKey(input.parsed['validationCommands'], 'command');
+        const plainVal = collectStringArray(input.parsed['validationCommands']);
+        const all = new Set([...firstCmds, ...valCmds, ...plainVal].map(normaliseCommand));
+        for (const c of all) {
+            if (c.length === 0)
+                continue;
+            // Don't flag commands that obviously start with `git` or `bun x tsc` —
+            // those are universal even when the rule registry doesn't list them.
+            if (/^(git|bun\s+x\s+tsc|npm|pnpm|yarn)\b/.test(c))
+                continue;
+            if (!input.knownCommands.has(c)) {
+                out.push({
+                    category: 'ungrounded-command',
+                    severity: 'low',
+                    message: `Command "${c}" is not in the supplied recommendedCommands.`,
+                });
+            }
+        }
+    }
+    // 5. Missing-section heuristic for arch-plan shapes.
+    if (input.parsed) {
+        if ('candidateArchitectures' in input.parsed) {
+            // architecture mode — recommendedMvp + firstSpike are required.
+            if (!input.parsed['recommendedMvp']) {
+                out.push({
+                    category: 'missing-section',
+                    severity: 'medium',
+                    message: 'architecture plan is missing recommendedMvp.',
+                });
+            }
+            if (!input.parsed['firstSpike']) {
+                out.push({
+                    category: 'missing-section',
+                    severity: 'medium',
+                    message: 'architecture plan is missing firstSpike.',
+                });
+            }
+        }
+    }
+    return out;
+}
+function scoreFindings(findings) {
+    if (findings.length === 0)
+        return 1;
+    let penalty = 0;
+    for (const f of findings) {
+        penalty += f.severity === 'high' ? 0.2 : f.severity === 'medium' ? 0.08 : 0.03;
+    }
+    return Math.max(0, 1 - penalty);
+}
+function walkPathLeaves(value, where, visit) {
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i += 1)
+            walkPathLeaves(value[i], `${where}[${i}]`, visit);
+        return;
+    }
+    if (value === null || typeof value !== 'object')
+        return;
+    const rec = value;
+    for (const k of Object.keys(rec)) {
+        if (k === 'path' && typeof rec[k] === 'string') {
+            visit(rec[k], `${where}.${k}`);
+            continue;
+        }
+        walkPathLeaves(rec[k], `${where}.${k}`, visit);
+    }
+}
+function collectPathSet(value) {
+    const out = new Set();
+    if (!Array.isArray(value))
+        return out;
+    for (const item of value) {
+        if (item && typeof item === 'object' && typeof item['path'] === 'string') {
+            out.add(item['path'].trim());
+        }
+    }
+    return out;
+}
+function collectStringArrayFromKey(value, key) {
+    const out = [];
+    if (!Array.isArray(value))
+        return out;
+    for (const item of value) {
+        if (item && typeof item === 'object' && typeof item[key] === 'string') {
+            out.push(item[key].trim());
+        }
+    }
+    return out;
+}
+function collectStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((s) => typeof s === 'string');
+}
+function looksLikePathRef(s) {
+    if (s.length === 0)
+        return false;
+    if (/[<>{}]/.test(s))
+        return false;
+    if (s.includes('/'))
+        return true;
+    return /\.(ts|tsx|js|jsx|mjs|cjs|json|md|yml|yaml|css|html)$/.test(s);
+}
+function pathExistsInWorkspace(cwd, candidate) {
+    const normalised = candidate.replace(/\\/g, '/').replace(/^\.\//, '');
+    const abs = nodePath.isAbsolute(normalised) ? normalised : nodePath.join(cwd, normalised);
+    try {
+        return existsSync(abs);
+    }
+    catch {
+        return false;
+    }
+}
+function normaliseCommand(c) {
+    return c.trim().replace(/\s+/g, ' ');
+}
+function tryExtractJson(text) {
+    const trimmed = text.trim();
+    const fenced = trimmed.match(/```json\s*([\s\S]*?)```/i);
+    const candidate = fenced?.[1]?.trim() ?? trimmed;
+    try {
+        const parsed = JSON.parse(candidate);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Try balanced extraction
+    }
+    const first = candidate.indexOf('{');
+    const last = candidate.lastIndexOf('}');
+    if (first >= 0 && last > first) {
+        try {
+            const parsed = JSON.parse(candidate.slice(first, last + 1));
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}

package/dist/tools/primary-tools.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Primary MCP tools — the core set advertised to a connected agent
+ * by default. Every tool in {@link ALL_TOOLS} stays callable (so an
+ * agent that already knows the name can use it), but `tools/list`
+ * only advertises the primary set. Smaller surface = better
+ * tool-selection accuracy for the agent.
+ *
+ * Picked to match the CLI's allowlist semantics: anything an agent
+ * could realistically reach for during a normal task — discovery,
+ * context, planning, validation — is in. Internal introspection
+ * (catalog dumps, fix-preview internals, drift baselines) is out;
+ * still callable, just not in the default tool list.
+ *
+ * Escape hatch: set `SHRK_MCP_FULL_TOOLS=1` to advertise the full
+ * catalog (useful when debugging an agent's tool selection).
+ */
+export declare const PRIMARY_MCP_TOOLS: ReadonlySet<string>;
+/**
+ * Should `tools/list` advertise the full catalog instead of the
+ * primary set? Driven by the env var so an agent operator can flip it
+ * without rebuilding.
+ */
+export declare function shouldAdvertiseFullToolset(): boolean;
+//# sourceMappingURL=primary-tools.d.ts.map

package/dist/tools/primary-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primary-tools.d.ts","sourceRoot":"","sources":["../../src/tools/primary-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CA4DhD,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAGpD"}

package/dist/tools/primary-tools.js

@@ -0,0 +1,86 @@
+/**
+ * Primary MCP tools — the core set advertised to a connected agent
+ * by default. Every tool in {@link ALL_TOOLS} stays callable (so an
+ * agent that already knows the name can use it), but `tools/list`
+ * only advertises the primary set. Smaller surface = better
+ * tool-selection accuracy for the agent.
+ *
+ * Picked to match the CLI's allowlist semantics: anything an agent
+ * could realistically reach for during a normal task — discovery,
+ * context, planning, validation — is in. Internal introspection
+ * (catalog dumps, fix-preview internals, drift baselines) is out;
+ * still callable, just not in the default tool list.
+ *
+ * Escape hatch: set `SHRK_MCP_FULL_TOOLS=1` to advertise the full
+ * catalog (useful when debugging an agent's tool selection).
+ */
+export const PRIMARY_MCP_TOOLS = new Set([
+    // Project orientation
+    'inspect_workspace',
+    'get_project_overview',
+    'get_agent_instructions',
+    'get_start_here',
+    // Context / task routing
+    'get_relevant_context',
+    'get_task_packet',
+    'get_action_hints',
+    'create_agent_brief',
+    'get_relevant_rules',
+    'explain_command',
+    // Browse the registries
+    'list_knowledge',
+    'get_knowledge',
+    'list_rules',
+    'get_rule',
+    'list_path_conventions',
+    'list_templates',
+    'get_template',
+    'list_pipelines',
+    'get_pipeline',
+    'list_presets',
+    'get_preset',
+    'list_packs',
+    'get_pack',
+    // Safe code generation (plan-first)
+    'create_generation_plan',
+    'render_template_preview',
+    'explain_generation_target',
+    // Validation gates (read-only)
+    'check_boundaries',
+    'get_diff_check_report',
+    'get_file_advice',
+    'get_architecture_constraints',
+    'get_architecture_violations',
+    // Doctor / readiness
+    'get_ai_readiness_report',
+    'doctor_packs',
+    // Code-intelligence graph — the agent's grep replacement for understanding
+    // existing code: who calls X, where is X used (path:line), what breaks if I
+    // change X, is X wired. Verifiable file:line truth from the indexed graph.
+    'get_graph_callers',
+    'code_find_usages',
+    'get_graph_impact',
+    'get_graph_path',
+    'get_graph_hubs',
+    'graph_why',
+    'get_graph_node',
+    'get_graph_search',
+    // Search
+    'search_all',
+    'search_knowledge',
+    'search_commands',
+    // Token compression (deterministic, reversible)
+    'compress_context',
+    'retrieve_original',
+    'align_cache',
+    'restore_cache',
+]);
+/**
+ * Should `tools/list` advertise the full catalog instead of the
+ * primary set? Driven by the env var so an agent operator can flip it
+ * without rebuilding.
+ */
+export function shouldAdvertiseFullToolset() {
+    const v = process.env.SHRK_MCP_FULL_TOOLS;
+    return v === '1' || v === 'true' || v === 'yes';
+}

package/dist/tools/r19-extras.tool.js

@@ -93,7 +93,7 @@ export const getCommandTaxonomyTool = {
     inputSchema: { type: 'object', properties: {}, additionalProperties: false },
     async handler() {
         // The CLI carries the canonical catalog; here we describe the surface
-        // without importing it (no inspector → CLI dependency). Adopters can
+        // without importing it (no inspector → CLI dependency). Consumers can
         // run `shrk commands taxonomy` for the full grouped output.
         return {
             data: {

package/dist/tools/r32-profiles.tool.d.ts

@@ -2,7 +2,4 @@ import type { IToolDefinition } from '../server/tool-definition.js';
 export declare const listProfilesTool: IToolDefinition;
 export declare const getProfileTool: IToolDefinition;
 export declare const getProfilesDoctorTool: IToolDefinition;
-export declare const listPluginLifecycleProfilesTool: IToolDefinition;
-export declare const getPluginLifecycleProfileTool: IToolDefinition;
-export declare const getPluginLifecycleProfileDoctorTool: IToolDefinition;
 //# sourceMappingURL=r32-profiles.tool.d.ts.map

package/dist/tools/r32-profiles.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"r32-profiles.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r32-profiles.tool.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,eAe9B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,eAsB5B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAOnC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,eAO7C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAmB3C,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,eAqBjD,CAAC"}
+{"version":3,"file":"r32-profiles.tool.d.ts","sourceRoot":"","sources":["../../src/tools/r32-profiles.tool.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,gBAAgB,EAAE,eAe9B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,eAsB5B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAOnC,CAAC"}

package/dist/tools/r32-profiles.tool.js

@@ -1,11 +1,11 @@
 /**
- * Read-only MCP tools for profiles + lifecycle profiles.
+ * Read-only MCP tools for profiles.
  *
  * Engine never writes from MCP. These tools surface pack-contributed and
  * locally configured profiles so an agent can decide which one to pass to
- * `shrk plugin rename|remove --profile <id>` (the human runs the CLI).
+ * a profile-aware command (the human runs the CLI).
  */
-import { checkPluginLifecycleProfileHealth, findProfile, listProfileIssues, listProfiles, listPluginLifecycleProfiles, ProfileKind, } from '@shrkcrft/inspector';
+import { findProfile, listProfileIssues, listProfiles, ProfileKind, } from '@shrkcrft/inspector';
 export const listProfilesTool = {
     name: 'list_profiles',
     description: 'List all pack-contributed and locally configured profiles. Read-only.',
@@ -54,54 +54,3 @@ export const getProfilesDoctorTool = {
         return { data: { issues: await listProfileIssues(ctx.inspection) } };
     },
 };
-export const listPluginLifecycleProfilesTool = {
-    name: 'list_plugin_lifecycle_profiles',
-    description: 'List registered plugin lifecycle profiles. Read-only.',
-    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
-    async handler(_input, ctx) {
-        return { data: await listPluginLifecycleProfiles(ctx.inspection) };
-    },
-};
-export const getPluginLifecycleProfileTool = {
-    name: 'get_plugin_lifecycle_profile',
-    description: 'Get one plugin lifecycle profile by id. Read-only.',
-    inputSchema: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['id'],
-        properties: { id: { type: 'string' } },
-    },
-    async handler(input, ctx) {
-        const id = typeof input.id === 'string' ? input.id : '';
-        if (!id)
-            return { isError: true, error: { code: 'invalid-input', message: 'id is required.' } };
-        const entries = await listPluginLifecycleProfiles(ctx.inspection);
-        const entry = entries.find((e) => e.profile.id === id);
-        if (!entry) {
-            return { isError: true, error: { code: 'not-found', message: `Unknown lifecycle profile "${id}".` } };
-        }
-        return { data: entry };
-    },
-};
-export const getPluginLifecycleProfileDoctorTool = {
-    name: 'get_plugin_lifecycle_profile_doctor',
-    description: 'Health check for plugin lifecycle profiles. Read-only.',
-    inputSchema: {
-        type: 'object',
-        additionalProperties: false,
-        properties: { id: { type: 'string' } },
-    },
-    async handler(input, ctx) {
-        const id = typeof input.id === 'string' ? input.id : undefined;
-        const entries = await listPluginLifecycleProfiles(ctx.inspection);
-        const targets = id ? entries.filter((e) => e.profile.id === id) : entries;
-        if (id && targets.length === 0) {
-            return { isError: true, error: { code: 'not-found', message: `Unknown lifecycle profile "${id}".` } };
-        }
-        const health = {};
-        for (const e of targets) {
-            health[e.profile.id] = checkPluginLifecycleProfileHealth(ctx.cwd, e.profile);
-        }
-        return { data: { health } };
-    },
-};

package/dist/tools/retrieve-original.tool.d.ts

@@ -0,0 +1,9 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * The retrieve half of Compress-Cache-Retrieve. Given a `<<ccr:KEY>>` key
+ * emitted by `compress_context`, return the full uncompressed original. Reads
+ * from the server's in-memory store only — never the filesystem — so it stays
+ * read-only.
+ */
+export declare const retrieveOriginalTool: IToolDefinition;
+//# sourceMappingURL=retrieve-original.tool.d.ts.map

package/dist/tools/retrieve-original.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieve-original.tool.d.ts","sourceRoot":"","sources":["../../src/tools/retrieve-original.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAyClC,CAAC"}

package/dist/tools/retrieve-original.tool.js

@@ -0,0 +1,47 @@
+/**
+ * The retrieve half of Compress-Cache-Retrieve. Given a `<<ccr:KEY>>` key
+ * emitted by `compress_context`, return the full uncompressed original. Reads
+ * from the server's in-memory store only — never the filesystem — so it stays
+ * read-only.
+ */
+export const retrieveOriginalTool = {
+    name: 'retrieve_original',
+    description: 'Retrieve the full, uncompressed original that `compress_context` cached, by its `<<ccr:KEY>>` key. The reverse of compression — use it when a compressed blob elided a detail you now need. Cache lives for the MCP server session. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'The CCR key from a `<<ccr:KEY>>` marker.' },
+        },
+        required: ['key'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const key = typeof input.key === 'string' ? input.key.trim() : '';
+        if (key.length === 0) {
+            return {
+                isError: true,
+                text: 'retrieve_original requires a "key".',
+                error: { code: 'invalid-input', message: 'key is required' },
+            };
+        }
+        if (!ctx.ccrStore) {
+            return {
+                isError: true,
+                text: 'No CCR store is wired on this server.',
+                error: { code: 'unavailable', message: 'ccr store not available' },
+            };
+        }
+        const entry = ctx.ccrStore.get(key);
+        if (!entry) {
+            return {
+                isError: true,
+                text: `No cached original for key "${key}". It may have been evicted (cache is bounded) or never existed in this session.`,
+                error: { code: 'cache-miss', message: `unknown ccr key ${key}` },
+            };
+        }
+        return {
+            data: { key: entry.key, bytes: entry.bytes, content: entry.content },
+            text: entry.content,
+        };
+    },
+};

package/dist/tools/runtime-reports.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-reports.tool.d.ts","sourceRoot":"","sources":["../../src/tools/runtime-reports.tool.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAYpE,eAAO,MAAM,qBAAqB,EAAE,eAsBnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAsBtC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAgBtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAqBrC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAqCrC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAU3C,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAUxC,CAAC"}
+{"version":3,"file":"runtime-reports.tool.d.ts","sourceRoot":"","sources":["../../src/tools/runtime-reports.tool.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAYpE,eAAO,MAAM,qBAAqB,EAAE,eAsBnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAsBtC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAgBtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAqBrC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAqCrC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAU3C,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAUxC,CAAC"}

package/dist/tools/runtime-reports.tool.js

@@ -6,8 +6,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import { buildAdoptionReport, buildCoverageReport, buildDriftReport, buildOnboardingAdoptionPlan, buildOnboardingPlan, buildQualityReport, buildSafetyAudit, readAdoptionState, renderAdoptionReportHtml, renderAdoptionReportMarkdown, renderAdoptionReportText, renderDevSessionHtml, renderDevSessionFinalReport, renderReviewComment, renderReviewHtml, renderQualityHtml, renderSafetyHtml, scanDevSession, } from '@shrkcrft/inspector';
-// DX#4 — derive audit view from ALL_TOOLS at runtime.
-import { ALL_TOOLS } from "./all-tools.js";
 function pickFormat(input, fallback = 'json') {
     const f = String(input.format ?? fallback).toLowerCase();
     if (f === 'text' || f === 'markdown' || f === 'html' || f === 'json')
@@ -95,7 +93,7 @@ export const getSafetyHtmlReportTool = {
         const audit = buildSafetyAudit({
             inspection: ctx.inspection,
             catalog: [],
-            mcpTools: ALL_TOOLS.map((t) => ({ name: t.name, description: t.description, canWrite: false })),
+            mcpTools: (ctx.allTools ?? []).map((t) => ({ name: t.name, description: t.description, canWrite: false })),
             planSecretEnv: 'SHARKCRAFT_PLAN_SECRET',
             planSecretConfigured: typeof process.env.SHARKCRAFT_PLAN_SECRET === 'string' && process.env.SHARKCRAFT_PLAN_SECRET.length > 0,
         });

package/dist/tools/safety-audit.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safety-audit.tool.d.ts","sourceRoot":"","sources":["../../src/tools/safety-audit.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAQpE,eAAO,MAAM,kBAAkB,EAAE,eAqChC,CAAC"}
+{"version":3,"file":"safety-audit.tool.d.ts","sourceRoot":"","sources":["../../src/tools/safety-audit.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAKpE,eAAO,MAAM,kBAAkB,EAAE,eAqChC,CAAC"}

package/dist/tools/safety-audit.tool.js

@@ -1,7 +1,4 @@
 import { buildSafetyAudit } from '@shrkcrft/inspector';
-// DX#4 — derive the audit list at runtime from ALL_TOOLS instead of
-// maintaining a parallel static list.
-import { ALL_TOOLS } from "./all-tools.js";
 import { COMMAND_CATALOG_EXPORT } from "./command-catalog.tool.js";
 const PLAN_SECRET_ENV = 'SHARKCRAFT_PLAN_SECRET';
 export const getSafetyAuditTool = {
@@ -26,7 +23,7 @@ export const getSafetyAuditTool = {
             requiresReview: e.requiresReview,
             mcpAvailable: e.mcpAvailable,
         }));
-        const mcpTools = ALL_TOOLS.map((t) => ({
+        const mcpTools = (ctx.allTools ?? []).map((t) => ({
             name: t.name,
             description: t.description,
         }));

package/dist/tools/search-knowledge.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-knowledge.tool.d.ts","sourceRoot":"","sources":["../../src/tools/search-knowledge.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,mBAAmB,EAAE,eAwCjC,CAAC"}
+{"version":3,"file":"search-knowledge.tool.d.ts","sourceRoot":"","sources":["../../src/tools/search-knowledge.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE,eAAO,MAAM,mBAAmB,EAAE,eA4CjC,CAAC"}

package/dist/tools/search-knowledge.tool.js

@@ -1,7 +1,8 @@
 import { searchKnowledge } from '@shrkcrft/knowledge';
+import { FORMAT_INPUT_PROPERTY, formatRows } from "../server/columnar-format.js";
 export const searchKnowledgeTool = {
     name: 'search_knowledge',
-    description: 'Search knowledge entries by query/tags/types/scope/appliesWhen.',
+    description: 'Search knowledge entries by query/tags/types/scope/appliesWhen. Pass `format:"table"` for a token-efficient columnar payload.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -12,6 +13,7 @@ export const searchKnowledgeTool = {
             appliesWhen: { type: 'array', items: { type: 'string' } },
             minPriority: { type: 'string' },
             limit: { type: 'integer', minimum: 1 },
+            ...FORMAT_INPUT_PROPERTY,
         },
         additionalProperties: false,
     },
@@ -26,17 +28,19 @@ export const searchKnowledgeTool = {
             minPriority: typeof input.minPriority === 'string' ? input.minPriority : undefined,
             limit,
         });
-        return {
-            data: results.map((r) => ({
-                id: r.entry.id,
-                title: r.entry.title,
-                score: r.score,
-                type: r.entry.type,
-                priority: r.entry.priority,
-                tags: r.entry.tags,
-                scope: r.entry.scope,
-                reasons: r.reasons,
-            })),
-        };
+        const rows = results.map((r) => ({
+            id: r.entry.id,
+            title: r.entry.title,
+            score: r.score,
+            type: r.entry.type,
+            priority: r.entry.priority,
+            tags: r.entry.tags,
+            scope: r.entry.scope,
+            reasons: r.reasons,
+        }));
+        // `format:"table"` columnar-encodes the homogeneous hit rows; scalars and
+        // string-array cells (tags/scope/reasons) reconstruct losslessly. Default
+        // (no format / format:"json") returns the bare array unchanged.
+        return { data: formatRows(rows, input) };
     },
 };