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

package/dist/tools/all-tools.js

@@ -42,8 +42,36 @@ import { checkBoundariesTool } from "./check-boundaries.tool.js";
 import { listBoundaryRulesTool } from "./list-boundary-rules.tool.js";
 import { getBoundaryRuleTool } from "./get-boundary-rule.tool.js";
 import { getImportGraphSummaryTool } from "./get-import-graph-summary.tool.js";
+import { getGraphStatusTool } from "./get-graph-status.tool.js";
+import { getGraphSearchTool } from "./get-graph-search.tool.js";
+import { getGraphContextTool } from "./get-graph-context.tool.js";
+import { getGraphImpactTool } from "./get-graph-impact.tool.js";
+import { getGraphPathTool } from "./get-graph-path.tool.js";
+import { getGraphHubsTool } from "./get-graph-hubs.tool.js";
+import { getGraphCallersTool } from "./get-graph-callers.tool.js";
+import { delegateTaskTool } from "./delegate-task.tool.js";
+import { getGraphCyclesTool } from "./get-graph-cycles.tool.js";
+import { getGraphUnresolvedTool } from "./get-graph-unresolved.tool.js";
+import { getGraphDepsTool } from "./get-graph-deps.tool.js";
+import { getImpactBaselineTool } from "./get-impact-baseline.tool.js";
+import { getPatternRegistryTool } from "./get-pattern-registry.tool.js";
+import { getIntentBenchmarkRunTool } from "./get-intent-benchmark-run.tool.js";
+import { getCodeIntelligenceStateTool } from "./get-code-intelligence-state.tool.js";
+import { getRulesForFileTool } from "./get-rules-for-file.tool.js";
+import { getStructuralSearchTool } from "./get-structural-search.tool.js";
+import { getStructuralRewritePlanTool } from "./get-structural-rewrite-plan.tool.js";
+import { getGraphImpactAnalysisTool } from "./get-graph-impact-analysis.tool.js";
+import { getContextPackTool } from "./get-context-pack.tool.js";
+import { getArchViolationsTool } from "./get-arch-violations.tool.js";
+import { getFrameworkEntitiesTool } from "./get-framework-entities.tool.js";
+import { getApiSurfaceDiffTool } from "./get-api-surface-diff.tool.js";
+import { getQualityGateTool } from "./get-quality-gate.tool.js";
+import { getMigrationsTool } from "./get-migrations.tool.js";
 import { getDriftReportTool } from "./get-drift-report.tool.js";
 import { getKnowledgeGraphTool } from "./get-knowledge-graph.tool.js";
+import { compressContextTool } from "./compress-context.tool.js";
+import { retrieveOriginalTool } from "./retrieve-original.tool.js";
+import { alignCacheTool, restoreCacheTool } from "./align-cache.tool.js";
 import { getGraphNodeTool } from "./get-graph-node.tool.js";
 import { getCoverageReportTool } from "./get-coverage-report.tool.js";
 import { getReviewPacketTool } from "./get-review-packet.tool.js";
@@ -74,6 +102,11 @@ import { getImportGraphAnalysisTool } from "./import-graph-analysis.tool.js";
 import { getDashboardSummaryTool } from "./dashboard-summary.tool.js";
 import { searchAllTool } from "./search.tool.js";
 import { createAgentBriefTool } from "./agent-brief.tool.js";
+import { smartContextBundleTool } from "./smart-context-bundle.tool.js";
+import { smartContextFeedTool } from "./smart-context-feed.tool.js";
+import { codeFindUsagesTool } from "./code-find-usages.tool.js";
+import { planQualityReviewTool } from "./plan-quality-review.tool.js";
+import { depsAuditTool } from "./deps-audit.tool.js";
 import { getConstructApiTool, getConstructTool, listConstructFacetsTool, listConstructsTool, traceConstructTool, } from "./constructs.tool.js";
 import { getPlaybookTool, listPlaybooksTool, recommendPlaybooksTool, } from "./playbooks.tool.js";
 import { replayBundleApplyTool } from "./bundle-replay.tool.js";
@@ -116,7 +149,8 @@ import { getContractTemplateTool, getLanguageCommandsTool, getLanguageProfilesTo
 import { getTaskContextTool, understandTaskTool, validateChangeContextTool, } from "./r26-task-context.tool.js";
 import { getLanguageCacheStatusTool, getLanguageProfilesLiveTool, getLanguageRunPlanTool, getPolyglotBoundaryReportTool, } from "./r27-polyglot.tool.js";
 import { getChangedBoundaryReportTool } from "./r28-changed-boundary.tool.js";
-import { previewPluginRemoveTool, previewPluginRenameTool } from "./r28-plugin-lifecycle.tool.js";
+import { getDiffCheckReportTool } from "./diff-check.tool.js";
+import { getFileAdviceTool } from "./file-advice.tool.js";
 import { getHelperTool, listHelpersTool, previewHelperPlanTool } from "./r28-helpers.tool.js";
 import { getPackDevStatusTool, previewPackTestsTool } from "./r28-pack-author.tool.js";
 import { getRegistryLifecycleReportTool } from "./r28-registry-lifecycle.tool.js";
@@ -135,7 +169,7 @@ import { suggestCommandsTool, searchCommandsTool, explainCommandTool, } from "./
 import { previewFixTool, listFixKindsTool, } from "./r31-fix-preview.tool.js";
 import { getScaffoldCoverageReportTool } from "./r31-scaffold-coverage.tool.js";
 import { getChangesSummaryTool, getPrSummaryPreviewTool, getCiIntegrityReportTool, } from "./r31-changes-pr-ci.tool.js";
-import { listProfilesTool, getProfileTool, getProfilesDoctorTool, listPluginLifecycleProfilesTool, getPluginLifecycleProfileTool, getPluginLifecycleProfileDoctorTool, } from "./r32-profiles.tool.js";
+import { listProfilesTool, getProfileTool, getProfilesDoctorTool, } from "./r32-profiles.tool.js";
 import { getProjectCouplingReportTool } from "./r32-project-coupling.tool.js";
 import { getPackContributionsTool, getPackConflictsTool, } from "./r33-pack-contributions.tool.js";
 import { listConventionsTool, getConventionTool, getConventionsDoctorTool, } from "./r33-conventions.tool.js";
@@ -192,8 +226,37 @@ export const ALL_TOOLS = Object.freeze([
     listBoundaryRulesTool,
     getBoundaryRuleTool,
     getImportGraphSummaryTool,
+    getGraphStatusTool,
+    getGraphSearchTool,
+    getGraphContextTool,
+    getGraphImpactTool,
+    getGraphPathTool,
+    getGraphHubsTool,
+    getGraphCallersTool,
+    delegateTaskTool,
+    getGraphCyclesTool,
+    getGraphUnresolvedTool,
+    getGraphDepsTool,
+    getImpactBaselineTool,
+    getPatternRegistryTool,
+    getIntentBenchmarkRunTool,
+    getCodeIntelligenceStateTool,
+    getRulesForFileTool,
+    getStructuralSearchTool,
+    getStructuralRewritePlanTool,
+    getGraphImpactAnalysisTool,
+    getContextPackTool,
+    getArchViolationsTool,
+    getFrameworkEntitiesTool,
+    getApiSurfaceDiffTool,
+    getQualityGateTool,
+    getMigrationsTool,
     getDriftReportTool,
     getKnowledgeGraphTool,
+    compressContextTool,
+    retrieveOriginalTool,
+    alignCacheTool,
+    restoreCacheTool,
     getGraphNodeTool,
     getCoverageReportTool,
     getReviewPacketTool,
@@ -242,6 +305,11 @@ export const ALL_TOOLS = Object.freeze([
     getDashboardSummaryTool,
     searchAllTool,
     createAgentBriefTool,
+    smartContextBundleTool,
+    smartContextFeedTool,
+    codeFindUsagesTool,
+    planQualityReviewTool,
+    depsAuditTool,
     listConstructsTool,
     getConstructTool,
     traceConstructTool,
@@ -334,8 +402,8 @@ export const ALL_TOOLS = Object.freeze([
     getLanguageCacheStatusTool,
     getLanguageProfilesLiveTool,
     getChangedBoundaryReportTool,
-    previewPluginRenameTool,
-    previewPluginRemoveTool,
+    getDiffCheckReportTool,
+    getFileAdviceTool,
     listHelpersTool,
     getHelperTool,
     previewHelperPlanTool,
@@ -370,9 +438,6 @@ export const ALL_TOOLS = Object.freeze([
     listProfilesTool,
     getProfileTool,
     getProfilesDoctorTool,
-    listPluginLifecycleProfilesTool,
-    getPluginLifecycleProfileTool,
-    getPluginLifecycleProfileDoctorTool,
     getProjectCouplingReportTool,
     getPackContributionsTool,
     getPackConflictsTool,

package/dist/tools/architecture-map.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"architecture-map.tool.d.ts","sourceRoot":"","sources":["../../src/tools/architecture-map.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,eAAO,MAAM,sBAAsB,EAAE,eAoBpC,CAAC"}
+{"version":3,"file":"architecture-map.tool.d.ts","sourceRoot":"","sources":["../../src/tools/architecture-map.tool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,eAAO,MAAM,sBAAsB,EAAE,eAqBpC,CAAC"}

package/dist/tools/architecture-map.tool.js

@@ -1,12 +1,14 @@
 import { buildArchitectureMap } from '@shrkcrft/inspector';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
 export const getArchitectureMapTool = {
     name: 'get_architecture_map',
-    description: 'Build an architecture map: layers, constructs, boundary rules, public-API surfaces, tests/ownership hints, risks. Read-only.',
+    description: 'Build an architecture map: layers, constructs, boundary rules, public-API surfaces, tests/ownership hints, risks. Pass `format:"table"` for a token-efficient columnar encoding of the array fields. Read-only.',
     inputSchema: {
         type: 'object',
         properties: {
             include: { type: 'array', items: { type: 'string' } },
             risk: { type: 'boolean' },
+            ...FORMAT_INPUT_PROPERTY,
         },
         additionalProperties: false,
     },
@@ -17,6 +19,6 @@ export const getArchitectureMapTool = {
             ...(include ? { include } : {}),
             ...(risk !== undefined ? { risk } : {}),
         });
-        return { data: map };
+        return { data: formatObjectArrays(map, input) };
     },
 };

package/dist/tools/code-find-usages.tool.d.ts

@@ -0,0 +1,16 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * `code_find_usages` — structured usage finder backed by the
+ * SharkCraft graph (file + symbol nodes + import/declare edges).
+ *
+ * Unlike grep, this distinguishes:
+ *   - the symbol's definition site
+ *   - which files import the declaring file (runtime + type-only
+ *     can't be split without TS-level checks, so we mark them all as
+ *     `import-of-declaring-file` for honesty)
+ *   - which other symbols neighbour the target in the graph
+ *
+ * Read-only. Skips when the graph is missing (returns a hint).
+ */
+export declare const codeFindUsagesTool: IToolDefinition;
+//# sourceMappingURL=code-find-usages.tool.d.ts.map

package/dist/tools/code-find-usages.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-find-usages.tool.d.ts","sourceRoot":"","sources":["../../src/tools/code-find-usages.tool.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAuIhC,CAAC"}

package/dist/tools/code-find-usages.tool.js

@@ -0,0 +1,180 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { EdgeKind, GraphQueryApi, GraphStore, NodeKind, loadGraphApiCached } from '@shrkcrft/graph';
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
+import { callGraphLanguageNote } from "./graph-staleness.js";
+/**
+ * `code_find_usages` — structured usage finder backed by the
+ * SharkCraft graph (file + symbol nodes + import/declare edges).
+ *
+ * Unlike grep, this distinguishes:
+ *   - the symbol's definition site
+ *   - which files import the declaring file (runtime + type-only
+ *     can't be split without TS-level checks, so we mark them all as
+ *     `import-of-declaring-file` for honesty)
+ *   - which other symbols neighbour the target in the graph
+ *
+ * Read-only. Skips when the graph is missing (returns a hint).
+ */
+export const codeFindUsagesTool = {
+    name: 'code_find_usages',
+    description: 'Find where a symbol is used (use this instead of grep). Returns the definition site and exact use sites as path:line via the SharkCraft graph, plus files that import the declaring file and neighbouring symbols. Read-only; needs `shrk graph index`. Pass `format:"table"` for a token-efficient columnar encoding.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            symbolName: { type: 'string' },
+            kindHint: { type: 'string' },
+            maxResults: { type: 'number' },
+            ...FORMAT_INPUT_PROPERTY,
+        },
+        required: ['symbolName'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const symbolName = typeof input['symbolName'] === 'string' ? input['symbolName'].trim() : '';
+        if (symbolName.length === 0) {
+            return { data: { error: 'symbolName is required' } };
+        }
+        const maxResults = clamp(typeof input['maxResults'] === 'number' ? input['maxResults'] : 25, 1, 200);
+        const store = new GraphStore(ctx.cwd);
+        if (!store.exists()) {
+            return {
+                data: {
+                    error: 'no-graph',
+                    message: 'The SharkCraft graph index has not been built yet. Build it with `shrk graph index`.',
+                    nextCommand: 'shrk graph index',
+                },
+            };
+        }
+        const api = loadGraphApiCached(ctx.cwd) ?? GraphQueryApi.fromStore(ctx.cwd);
+        const matches = api.findSymbol(symbolName, { exact: true, limit: maxResults });
+        if (matches.length === 0) {
+            return {
+                data: {
+                    symbol: { name: symbolName, kind: 'unknown' },
+                    definitions: [],
+                    importersOfDeclaringFile: [],
+                    neighbouringSymbols: [],
+                    totalSymbolMatches: 0,
+                    note: 'No exact symbol match in the graph. Try `shrk knowledge search` for fuzzy lookup.',
+                },
+            };
+        }
+        const definitions = [];
+        const importerSet = new Map();
+        const neighbours = [];
+        const useSites = [];
+        for (const sym of matches) {
+            const declaringFile = declaringFileOf(api, sym.id);
+            definitions.push({
+                symbolId: sym.id,
+                file: declaringFile?.path ?? null,
+                ...(sym.line ? { line: sym.line } : {}),
+                kind: String(sym.label && sym.label.length > 0 ? sym.label : sym.kind),
+            });
+            // Exact use sites (path:line) from the symbol's own call/reference
+            // edges, so the agent jumps straight to where it's used rather than
+            // grepping inside each importing file.
+            for (const site of api.referenceSitesOf(sym.id)) {
+                if (!site.node.path)
+                    continue;
+                // Prune use sites whose file no longer exists — uniformly with
+                // importersOfDeclaringFile below, so the payload never lists a deleted
+                // file in one field while dropping it in another (a self-contradicting,
+                // authoritative-looking result is worse than a uniformly-stale one).
+                if (!pathExists(ctx.cwd, site.node.path))
+                    continue;
+                useSites.push({ file: site.node.path, ...(site.line ? { line: site.line } : {}) });
+            }
+            if (declaringFile) {
+                for (const importer of api.importersOf(declaringFile.id)) {
+                    if (!importer.path)
+                        continue;
+                    const exists = pathExists(ctx.cwd, importer.path);
+                    if (!exists)
+                        continue;
+                    const key = `${importer.path}::${declaringFile.path}`;
+                    if (!importerSet.has(key)) {
+                        importerSet.set(key, {
+                            file: importer.path,
+                            via: declaringFile.path ?? '',
+                        });
+                    }
+                }
+            }
+            // Sibling symbols declared by the same file.
+            if (declaringFile) {
+                for (const sib of api.symbolsIn(declaringFile.id).slice(0, 6)) {
+                    if (sib.id === sym.id)
+                        continue;
+                    neighbours.push({
+                        name: sib.label,
+                        kind: String(sib.kind),
+                        file: declaringFile.path ?? null,
+                    });
+                }
+            }
+        }
+        // Result-file staleness: which surviving result files changed content
+        // since indexing (deleted ones are already pruned above). Flags a payload
+        // whose line numbers / membership may be out of date for files the agent
+        // just edited. Read-only.
+        const resultPaths = [
+            ...definitions.map((d) => d.file),
+            ...useSites.map((u) => u.file),
+            ...[...importerSet.values()].map((i) => i.file),
+        ].filter((p) => !!p);
+        const stale = api.staleFilesAmong(ctx.cwd, resultPaths);
+        // Non-TS languages have no call/reference extraction, so empty useSites must
+        // not be read as "no usages".
+        const langNote = matches[0] ? callGraphLanguageNote(api, matches[0]) : undefined;
+        const data = {
+            symbol: { name: symbolName, kind: matches[0]?.kind ?? 'unknown' },
+            definitions,
+            useSites,
+            importersOfDeclaringFile: [...importerSet.values()],
+            neighbouringSymbols: neighbours.slice(0, 12),
+            totalSymbolMatches: matches.length,
+            note: (langNote ? langNote + ' ' : '') +
+                'useSites = exact file:line of each call/reference to the symbol (first use per file). importersOfDeclaringFile = files that import the declaring file (coarser; may include type-only/unused imports). Pair with `shrk impact` for a tighter blast radius.',
+            ...(stale.modified.length > 0
+                ? {
+                    stale: { modified: stale.modified },
+                    staleHint: 'Some result files changed since indexing — run `shrk graph index --changed` for fresh line numbers.',
+                }
+                : {}),
+        };
+        // `format:"table"` columnar-encodes the homogeneous object-array fields
+        // (definitions, importersOfDeclaringFile, neighbouringSymbols); the scalar
+        // `symbol` object, totalSymbolMatches, and the note string pass through
+        // untouched. Default/`format:"json"` returns the bare object unchanged.
+        return { data: formatObjectArrays(data, input) };
+    },
+};
+function declaringFileOf(api, symbolId) {
+    const n = api.neighbours(symbolId);
+    if (!n)
+        return undefined;
+    for (const incoming of n.in) {
+        if (incoming.edge.kind !== EdgeKind.DeclaresSymbol)
+            continue;
+        if ('resolved' in incoming.source)
+            continue;
+        if (incoming.source.kind === NodeKind.File)
+            return incoming.source;
+    }
+    return undefined;
+}
+function pathExists(cwd, path) {
+    try {
+        return existsSync(nodePath.isAbsolute(path) ? path : nodePath.join(cwd, path));
+    }
+    catch {
+        return false;
+    }
+}
+function clamp(n, lo, hi) {
+    if (Number.isNaN(n))
+        return lo;
+    return Math.max(lo, Math.min(hi, Math.floor(n)));
+}

package/dist/tools/command-catalog.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-catalog.tool.d.ts","sourceRoot":"","sources":["../../src/tools/command-catalog.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAiBpE,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,cAAc,CAAC;CAC7C;AAwBD,eAAO,MAAM,sBAAsB,EAAE,SAAS,aAAa,EAgFzD,CAAC;AA+BH,eAAO,MAAM,qBAAqB,EAAE,eA4BnC,CAAC"}
+{"version":3,"file":"command-catalog.tool.d.ts","sourceRoot":"","sources":["../../src/tools/command-catalog.tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAkBpE,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,cAAc,CAAC;CAC7C;AAwBD,eAAO,MAAM,sBAAsB,EAAE,SAAS,aAAa,EAgFzD,CAAC;AA+BH,eAAO,MAAM,qBAAqB,EAAE,eA+BnC,CAAC"}

package/dist/tools/command-catalog.tool.js

@@ -1,3 +1,4 @@
+import { FORMAT_INPUT_PROPERTY, formatObjectArrays } from "../server/columnar-format.js";
 const MCP_BOOTSTRAP_CORE = new Set([
     'doctor',
     'init',
@@ -123,6 +124,7 @@ export const getCommandCatalogTool = {
         properties: {
             safetyLevel: { type: 'string', description: 'Filter by safety level (read-only, writes-session, writes-drafts, writes-source, runs-shell, requires-review).' },
             category: { type: 'string', description: 'Filter by category.' },
+            ...FORMAT_INPUT_PROPERTY,
         },
         additionalProperties: false,
     },
@@ -134,14 +136,16 @@ export const getCommandCatalogTool = {
             entries = entries.filter((e) => e.safetyLevel === safety);
         if (typeof category === 'string')
             entries = entries.filter((e) => e.category === category);
-        return {
-            data: {
-                entries,
-                totals: {
-                    total: COMMAND_CATALOG_EXPORT.length,
-                    returned: entries.length,
-                },
+        const data = {
+            entries,
+            totals: {
+                total: COMMAND_CATALOG_EXPORT.length,
+                returned: entries.length,
             },
         };
+        // `format:"table"` columnar-encodes the homogeneous `entries` array
+        // (the ~11-field catalog rows); the `totals` scalar object is left
+        // untouched. Default/`format:"json"` returns the object unchanged.
+        return { data: formatObjectArrays(data, input) };
     },
 };

package/dist/tools/compress-context.tool.d.ts

@@ -0,0 +1,8 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * Deterministic context compressor exposed to agents — shrink a blob before it
+ * re-enters the prompt, with no model in the loop: it's a pure function of the
+ * input. Reversible via the CCR store wired into the server context.
+ */
+export declare const compressContextTool: IToolDefinition;
+//# sourceMappingURL=compress-context.tool.d.ts.map

package/dist/tools/compress-context.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-context.tool.d.ts","sourceRoot":"","sources":["../../src/tools/compress-context.tool.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAIpE;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,eA6EjC,CAAC"}

package/dist/tools/compress-context.tool.js

@@ -0,0 +1,81 @@
+import { compressContent, EContentType, } from '@shrkcrft/compress';
+const CONTENT_TYPES = new Set(Object.values(EContentType));
+/**
+ * Deterministic context compressor exposed to agents — shrink a blob before it
+ * re-enters the prompt, with no model in the loop: it's a pure function of the
+ * input. Reversible via the CCR store wired into the server context.
+ */
+export const compressContextTool = {
+    name: 'compress_context',
+    description: 'Deterministically compress a blob (tool output, build/test log, grep/search results, unified diff, or JSON) BEFORE you feed it back to the model — same information, far fewer tokens. Routes by content type, hoists JSON object-array schemas into dense tables, and reduces logs/search/diffs to their highest-signal lines. Reversible: when a lossy pass drops detail it caches the original and emits a `<<ccr:KEY>>` marker — call `retrieve_original` to get the full text back. No AI involved; same bytes in, same bytes out. Read-only.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            content: { type: 'string', description: 'The text to compress.' },
+            contentType: {
+                type: 'string',
+                description: 'Force a content class instead of auto-detecting: json | json-array | git-diff | search-results | build-log | source-code | markdown | plain-text.',
+            },
+            query: {
+                type: 'string',
+                description: 'Optional task/query text that biases which lines or matches are kept.',
+            },
+            maxItems: {
+                type: 'integer',
+                minimum: 1,
+                description: 'Soft cap on retained lines / matches / hunks (compressor-specific).',
+            },
+            maxTokens: {
+                type: 'integer',
+                minimum: 1,
+                description: 'Token budget for a JSON array. When set and the lossless columnar form still exceeds it, falls back to the lossy SmartCrusher row-sampler (kept rows + CCR original).',
+            },
+        },
+        required: ['content'],
+        additionalProperties: false,
+    },
+    handler(input, ctx) {
+        const content = typeof input.content === 'string' ? input.content : '';
+        if (content.length === 0) {
+            return {
+                isError: true,
+                text: 'compress_context requires a non-empty "content" string.',
+                error: { code: 'invalid-input', message: 'content is required' },
+            };
+        }
+        const opts = {};
+        if (ctx.ccrStore)
+            opts.store = ctx.ccrStore;
+        if (typeof input.query === 'string')
+            opts.query = input.query;
+        if (typeof input.maxItems === 'number' && input.maxItems > 0) {
+            opts.maxItems = Math.floor(input.maxItems);
+        }
+        if (typeof input.maxTokens === 'number' && input.maxTokens > 0) {
+            opts.maxTokens = Math.floor(input.maxTokens);
+        }
+        if (typeof input.contentType === 'string' && CONTENT_TYPES.has(input.contentType)) {
+            opts.contentType = input.contentType;
+        }
+        const result = compressContent(content, opts);
+        const pct = Math.round(result.savings.ratio * 100);
+        return {
+            data: {
+                contentType: result.contentType,
+                strategy: result.strategy,
+                lossy: result.lossy,
+                tokensBefore: result.savings.before,
+                tokensAfter: result.savings.after,
+                tokensSaved: result.savings.saved,
+                savedRatio: result.savings.ratio,
+                ccrKey: result.ccrKey ?? null,
+                note: result.note,
+                compressed: result.compressed,
+                ...(result.ccrKey
+                    ? { retrieveWith: `retrieve_original { "key": "${result.ccrKey}" }` }
+                    : {}),
+            },
+            text: `${result.strategy}: ${result.savings.before} → ${result.savings.after} tokens (−${pct}%)${result.ccrKey ? ` · original cached as ${result.ccrKey}` : ''}`,
+        };
+    },
+};

package/dist/tools/dashboard-summary.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dashboard-summary.tool.d.ts","sourceRoot":"","sources":["../../src/tools/dashboard-summary.tool.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE,eAAO,MAAM,uBAAuB,EAAE,eA0LrC,CAAC"}
+{"version":3,"file":"dashboard-summary.tool.d.ts","sourceRoot":"","sources":["../../src/tools/dashboard-summary.tool.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAQpE,eAAO,MAAM,uBAAuB,EAAE,eA0LrC,CAAC"}

package/dist/tools/dashboard-summary.tool.js

@@ -1,8 +1,6 @@
 import { buildAreaMap, buildAiReadinessReport, buildCoverageReport, buildDriftReport, buildQualityReport, buildReleaseReadiness, buildSafetyAudit, evaluatePolicy, listConstructs, listDevSessionsDetailed, listFeatureBundles, listPlaybooks, } from '@shrkcrft/inspector';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import * as nodePath from 'node:path';
-// DX#4 — derive audit view from ALL_TOOLS at runtime.
-import { ALL_TOOLS } from "./all-tools.js";
 export const getDashboardSummaryTool = {
     name: 'get_dashboard_summary',
     description: 'Compact dashboard summary aggregating quality, safety, readiness, coverage, drift, packs, sessions, bundles, command-safety totals, and recommended next commands. Read-only.',
@@ -75,7 +73,7 @@ export const getDashboardSummaryTool = {
         const safety = buildSafetyAudit({
             inspection,
             catalog: [],
-            mcpTools: ALL_TOOLS.map((t) => ({ name: t.name, description: t.description })),
+            mcpTools: (ctx.allTools ?? []).map((t) => ({ name: t.name, description: t.description })),
             planSecretEnv: 'SHARKCRAFT_PLAN_SECRET',
             planSecretConfigured: typeof process.env['SHARKCRAFT_PLAN_SECRET'] === 'string' &&
                 process.env['SHARKCRAFT_PLAN_SECRET'].length > 0,
@@ -155,7 +153,7 @@ export const getDashboardSummaryTool = {
                 invalid: inspection.packs.invalidPacks?.length ?? 0,
             },
             policy: policySummary,
-            mcpTools: { total: ALL_TOOLS.length, anyWritable: safety.mcp.anyWritable },
+            mcpTools: { total: ctx.allTools?.length ?? 0, anyWritable: safety.mcp.anyWritable },
             reportSite: { available: siteAvailable, dir: reportSiteDir },
             releaseReadiness: releaseReadinessSummary,
             releaseSmoke: smokeSummary,

package/dist/tools/delegate-task.tool.d.ts

@@ -0,0 +1,3 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+export declare const delegateTaskTool: IToolDefinition;
+//# sourceMappingURL=delegate-task.tool.d.ts.map

package/dist/tools/delegate-task.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-task.tool.d.ts","sourceRoot":"","sources":["../../src/tools/delegate-task.tool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE,eAAO,MAAM,gBAAgB,EAAE,eA0E9B,CAAC"}

package/dist/tools/delegate-task.tool.js

@@ -0,0 +1,94 @@
+import { compressMarkdown } from '@shrkcrft/compress';
+import { loadProjectConfig } from '@shrkcrft/config';
+const READONLY_NOTE = 'Read-only. The CLI is the only write path. The worker may emit ONLY the allowed ops and touch ONLY the guardrail globs; the edit is verified deterministically and auto-reverted on failure — so it lands only if it passes the recipe verification.';
+export const delegateTaskTool = {
+    name: 'delegate_task',
+    description: 'Get a compact brief for delegating a MECHANICAL, deterministically-verifiable edit to the local-LLM worker (read-only). Returns the recipe fence — allowed ops, guardrail globs, verification — and the exact `shrk delegate run` next command. Hand the grunt edit to the local worker instead of spending your own tokens reading the whole file and writing the edit. Never writes; needs a `delegation` block in sharkcraft.config.ts.',
+    cliCommand: 'delegate',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            task: { type: 'string' },
+            recipe: { type: 'string' },
+        },
+        required: ['task', 'recipe'],
+        additionalProperties: false,
+    },
+    async handler(input, ctx) {
+        const args = input;
+        const task = (args.task ?? '').trim();
+        const recipeId = (args.recipe ?? '').trim();
+        if (!task || !recipeId) {
+            return { isError: true, error: { code: 'invalid-input', message: 'task and recipe are required' } };
+        }
+        const loaded = await loadProjectConfig(ctx.inspection.projectRoot);
+        if (!loaded.ok) {
+            return { isError: true, error: { code: 'config-error', message: loaded.error.message } };
+        }
+        const delegation = loaded.value.config.delegation;
+        if (!delegation || delegation.enabled === false) {
+            return {
+                isError: true,
+                error: {
+                    code: 'not-enabled',
+                    message: 'delegation is not enabled in sharkcraft.config.ts',
+                    details: { nextCommand: 'add a delegation { recipes: [...] } block to sharkcraft.config.ts' },
+                },
+            };
+        }
+        const recipes = delegation.recipes ?? [];
+        const recipe = recipes.find((r) => r.id === recipeId);
+        if (!recipe) {
+            return {
+                isError: true,
+                error: {
+                    code: 'not-found',
+                    message: `unknown recipe "${recipeId}". Available: ${recipes.map((r) => r.id).join(', ') || '(none)'}`,
+                    details: { available: recipes.map((r) => r.id) },
+                },
+            };
+        }
+        const provider = recipe.provider ?? delegation.provider ?? 'auto';
+        const briefMarkdown = buildBriefMarkdown(task, recipe, provider);
+        // Compress the brief body (CCR-reversible when the server store is present).
+        // Small briefs pass through unchanged via the net-loss guard.
+        const compressed = compressMarkdown(briefMarkdown, ctx.ccrStore ? { store: ctx.ccrStore, query: task } : { query: task });
+        return {
+            data: {
+                schema: 'sharkcraft.delegate-task/v1',
+                recipeId: recipe.id,
+                title: recipe.title ?? recipe.id,
+                task,
+                allowedOps: recipe.allowedOps,
+                guardrailGlobs: recipe.guardrailGlobs,
+                verificationIds: recipe.verificationIds,
+                provider,
+                riskCeiling: recipe.riskCeiling ?? null,
+                brief: compressed.compressed,
+                ...(compressed.ccrKey ? { ccrKey: compressed.ccrKey } : {}),
+                next: `shrk delegate run "${task}" --recipe ${recipe.id} --apply`,
+                note: READONLY_NOTE,
+            },
+        };
+    },
+};
+function buildBriefMarkdown(task, recipe, provider) {
+    return [
+        `# Delegate brief: ${recipe.title ?? recipe.id}`,
+        '',
+        `**Task:** ${task}`,
+        '',
+        `**Recipe:** \`${recipe.id}\``,
+        `**Allowed ops:** ${recipe.allowedOps.join(', ')}`,
+        `**Guardrail globs (the worker may ONLY touch files matching these):** ${recipe.guardrailGlobs.join(', ')}`,
+        `**Verification (must pass or the edit is reverted):** ${recipe.verificationIds.join(', ') || '(none)'}`,
+        `**Provider:** ${provider}${recipe.model ? ` (${recipe.model})` : ''}`,
+        '',
+        '## How to delegate',
+        '',
+        'The CLI is the only write path. Run the `next` command: the local worker generates the edit,',
+        'the deterministic engine verifies it against the recipe verification, and auto-reverts on failure —',
+        'so the edit lands only if it is correct. You pay for this brief and the compact result, not for',
+        'reading the whole file or writing the edit yourself.',
+    ].join('\n');
+}

package/dist/tools/deps-audit.tool.d.ts

@@ -0,0 +1,10 @@
+import type { IToolDefinition } from '../server/tool-definition.js';
+/**
+ * `deps_audit` — MCP wrapper around `shrk deps-audit`. Pure read-only.
+ * Returns the same shape the CLI's `--json` mode emits.
+ *
+ * NOTE: we re-implement the body here rather than shell out so MCP
+ * tools never spawn subprocesses. Identical logic, identical output.
+ */
+export declare const depsAuditTool: IToolDefinition;
+//# sourceMappingURL=deps-audit.tool.d.ts.map