@tankpkg/mcp-server 0.6.3 → 0.8.1

package/dist/index.js

@@ -1,30 +1,2214 @@
 #!/usr/bin/env node
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-// Import tools
-import { registerLoginTool } from './tools/login.js';
-import { registerSearchSkillsTool } from './tools/search-skills.js';
-import { registerSkillInfoTool } from './tools/skill-info.js';
-import { registerScanSkillTool } from './tools/scan-skill.js';
-import { registerPublishSkillTool } from './tools/publish-skill.js';
-import { registerLogoutTool } from './tools/logout.js';
-import { registerWhoamiTool } from './tools/whoami.js';
-import { registerInitSkillTool } from './tools/init-skill.js';
-import { registerRemoveSkillTool } from './tools/remove-skill.js';
-import { registerVerifySkillsTool } from './tools/verify-skills.js';
-import { registerLinkSkillTool } from './tools/link-skill.js';
-import { registerUnlinkSkillTool } from './tools/unlink-skill.js';
-import { registerDoctorTool } from './tools/doctor.js';
-import { registerSkillPermissionsTool } from './tools/skill-permissions.js';
-import { registerInstallSkillTool } from './tools/install-skill.js';
-import { registerUpdateSkillTool } from './tools/update-skill.js';
-import { registerAuditSkillTool } from './tools/audit-skill.js';
-// Create MCP server instance
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import fs from "node:fs";
+import path from "node:path";
+import semver from "semver";
+import { z } from "zod";
+import os from "node:os";
+import crypto$1 from "node:crypto";
+import { create, extract } from "tar";
+import ignore from "ignore";
+const MANIFEST_FILENAME = "tank.json";
+const LEGACY_MANIFEST_FILENAME = "skills.json";
+const LOCKFILE_FILENAME = "tank.lock";
+const LEGACY_LOCKFILE_FILENAME = "skills.lock";
+/**
+* Resolves a semver range against a list of available versions.
+* Returns the highest version that satisfies the range, or null if none match.
+*
+* Pre-release versions are excluded from range matching unless the range
+* explicitly includes a pre-release tag (e.g., ">=1.0.0-beta.1").
+* Exact version matches always work, including for pre-release versions.
+*
+* @param range - A semver range string (e.g., "^2.1.0", "~1.0.0", ">=2.0.0 <3.0.0", "*")
+* @param versions - An array of semver version strings to match against
+* @returns The highest matching version string, or null if no match
+*/
+function resolve(range, versions) {
+	try {
+		if (!range || !semver.validRange(range)) return null;
+		const validVersions = versions.filter((v) => semver.valid(v) !== null);
+		if (validVersions.length === 0) return null;
+		return semver.maxSatisfying(validVersions, range) ?? null;
+	} catch {
+		return null;
+	}
+}
+const networkPermissionsSchema = z.object({ outbound: z.array(z.string()).optional() }).strict();
+const filesystemPermissionsSchema = z.object({
+	read: z.array(z.string()).optional(),
+	write: z.array(z.string()).optional()
+}).strict();
+const permissionsSchema = z.object({
+	network: networkPermissionsSchema.optional(),
+	filesystem: filesystemPermissionsSchema.optional(),
+	subprocess: z.boolean().optional()
+}).strict();
+z.enum(["user", "admin"]);
+z.enum([
+	"active",
+	"suspended",
+	"banned"
+]);
+z.enum([
+	"active",
+	"deprecated",
+	"quarantined",
+	"removed"
+]);
+z.enum([
+	"user.ban",
+	"user.suspend",
+	"user.unban",
+	"user.promote",
+	"user.demote",
+	"skill.quarantine",
+	"skill.remove",
+	"skill.deprecate",
+	"skill.restore",
+	"skill.feature",
+	"skill.unfeature",
+	"org.suspend",
+	"org.member.remove",
+	"org.delete"
+]);
+const skillsJsonSchema = z.object({
+	name: z.string().min(1, "Name must not be empty").max(214, "Name must be 214 characters or fewer").regex(/^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/, "Name must be scoped (@org/name), lowercase alphanumeric and hyphens"),
+	version: z.string().regex(/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/, "Version must be valid semver"),
+	description: z.string().max(500, "Description must be 500 characters or fewer").optional(),
+	skills: z.record(z.string(), z.string()).optional(),
+	permissions: permissionsSchema.optional(),
+	repository: z.string().url("Repository must be a valid URL").optional(),
+	visibility: z.enum(["public", "private"]).optional(),
+	audit: z.object({ min_score: z.number().min(0).max(10) }).strict().optional()
+}).strict();
+const lockedSkillV1Schema = z.object({
+	resolved: z.string().url(),
+	integrity: z.string().regex(/^sha512-/, "Integrity must start with sha512-"),
+	permissions: permissionsSchema,
+	audit_score: z.number().min(0).max(10).nullable()
+});
+z.object({
+	lockfileVersion: z.literal(1),
+	skills: z.record(z.string(), lockedSkillV1Schema)
+});
+const lockedSkillSchema = z.object({
+	resolved: z.string().url(),
+	integrity: z.string().regex(/^sha512-/, "Integrity must start with sha512-"),
+	permissions: permissionsSchema,
+	audit_score: z.number().min(0).max(10).nullable(),
+	dependencies: z.record(z.string(), z.string()).optional()
+});
+z.object({
+	lockfileVersion: z.union([z.literal(1), z.literal(2)]),
+	skills: z.record(z.string(), lockedSkillSchema)
+});
+//#endregion
+//#region src/lib/config.ts
+const DEFAULT_CONFIG = { registry: "https://tankpkg.dev" };
+/**
+* Get the path to the tank config directory.
+*/
+function getConfigDir(configDir) {
+	return configDir ?? path.join(os.homedir(), ".tank");
+}
+/**
+* Get the path to the tank config file.
+*/
+function getConfigPath(configDir) {
+	return path.join(getConfigDir(configDir), "config.json");
+}
+/**
+* Read the tank config file. Returns defaults if file doesn't exist.
+*/
+function getConfig(configDir) {
+	const configPath = getConfigPath(configDir);
+	try {
+		const raw = fs.readFileSync(configPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		const merged = {
+			...DEFAULT_CONFIG,
+			...parsed
+		};
+		const envToken = process.env.TANK_TOKEN?.trim();
+		if (envToken) merged.token = envToken;
+		return merged;
+	} catch {
+		const envToken = process.env.TANK_TOKEN?.trim();
+		return {
+			...DEFAULT_CONFIG,
+			...envToken ? { token: envToken } : {}
+		};
+	}
+}
+/**
+* Write config to disk. Merges with existing config.
+*/
+function setConfig(partial, configDir) {
+	const dir = getConfigDir(configDir);
+	const configPath = getConfigPath(configDir);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const merged = {
+		...getConfig(configDir),
+		...partial
+	};
+	fs.writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}\n`, {
+		encoding: "utf-8",
+		mode: 384
+	});
+}
+//#endregion
+//#region src/lib/api-client.ts
+/**
+* Tank API client for MCP server.
+*/
+var TankApiClient = class {
+	config;
+	constructor(options = {}) {
+		this.config = getConfig(options.configDir);
+	}
+	/**
+	* Get the base URL for the Tank API.
+	*/
+	get baseUrl() {
+		return this.config.registry;
+	}
+	/**
+	* Get the auth token (if available).
+	*/
+	get token() {
+		return this.config.token;
+	}
+	/**
+	* Check if authenticated.
+	*/
+	get isAuthenticated() {
+		return !!this.config.token;
+	}
+	/**
+	* Make an authenticated API request.
+	*/
+	async fetch(path, options = {}) {
+		const url = `${this.baseUrl}${path}`;
+		const headers = {
+			"Content-Type": "application/json",
+			...options.headers
+		};
+		if (this.config.token) headers.Authorization = `Bearer ${this.config.token}`;
+		try {
+			const response = await fetch(url, {
+				...options,
+				headers
+			});
+			if (!response.ok) return {
+				error: (await response.json().catch(() => ({}))).error ?? response.statusText,
+				status: response.status,
+				ok: false
+			};
+			return {
+				data: await response.json(),
+				ok: true
+			};
+		} catch (err) {
+			return {
+				error: err instanceof Error ? err.message : "Network error",
+				status: 0,
+				ok: false
+			};
+		}
+	}
+	async verifyAuth() {
+		if (!this.config.token) return {
+			valid: false,
+			reason: "no-token"
+		};
+		const result = await this.fetch("/api/v1/auth/whoami");
+		if (result.ok) return {
+			valid: true,
+			user: {
+				name: result.data.name,
+				email: result.data.email
+			}
+		};
+		if (result.status === 0) return {
+			valid: false,
+			reason: "network-error",
+			error: result.error
+		};
+		return {
+			valid: false,
+			reason: "unauthorized"
+		};
+	}
+};
+//#endregion
+//#region src/tools/audit-skill.ts
+const SCOPED_NAME_PATTERN$6 = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+function parseLockKey$2(key) {
+	const lastAt = key.lastIndexOf("@");
+	if (lastAt <= 0) return null;
+	return {
+		name: key.slice(0, lastAt),
+		version: key.slice(lastAt + 1)
+	};
+}
+function deriveVerdict(score, status) {
+	if (status !== "completed" || score === null) return "PENDING";
+	if (score >= 7) return "PASS";
+	if (score >= 4) return "FLAGGED";
+	return "FAIL";
+}
+function formatFindings(findings) {
+	if (findings.length === 0) return "";
+	const bySeverity = {
+		critical: [],
+		high: [],
+		medium: [],
+		low: []
+	};
+	for (const f of findings) if (bySeverity[f.severity]) bySeverity[f.severity].push(f);
+	const lines = ["", `### Findings (${findings.length})`];
+	for (const severity of [
+		"critical",
+		"high",
+		"medium",
+		"low"
+	]) {
+		const group = bySeverity[severity];
+		if (group.length === 0) continue;
+		lines.push(`\n**${severity.toUpperCase()} (${group.length}):**`);
+		for (const f of group) lines.push(`- ${f.type}: ${f.description}${f.location ? ` (${f.location})` : ""}`);
+	}
+	return lines.join("\n");
+}
+function registerAuditSkillTool(server) {
+	server.tool("audit-skill", "Show security audit results for a skill from the Tank registry.", {
+		name: z.string().describe("Skill name in @org/name format"),
+		version: z.string().optional().describe("Specific version to audit (defaults to installed or latest)")
+	}, async ({ name, version }) => {
+		if (!SCOPED_NAME_PATTERN$6.test(name)) return {
+			content: [{
+				type: "text",
+				text: `Validation error: Skill name "${name}" must use the @org/name format (e.g. @acme/my-skill).`
+			}],
+			isError: true
+		};
+		const client = new TankApiClient();
+		if (!client.isAuthenticated) return {
+			content: [{
+				type: "text",
+				text: "Authentication required. Please run the \"login\" tool first to authenticate with Tank."
+			}],
+			isError: true
+		};
+		const encodedName = encodeURIComponent(name);
+		let targetVersion = version;
+		if (!targetVersion) {
+			let lockPath = path.join(process.cwd(), LOCKFILE_FILENAME);
+			if (!fs.existsSync(lockPath)) lockPath = path.join(process.cwd(), LEGACY_LOCKFILE_FILENAME);
+			if (fs.existsSync(lockPath)) try {
+				const raw = fs.readFileSync(lockPath, "utf-8");
+				const lock = JSON.parse(raw);
+				for (const key of Object.keys(lock.skills)) {
+					const parsed = parseLockKey$2(key);
+					if (parsed && parsed.name === name) {
+						targetVersion = parsed.version;
+						break;
+					}
+				}
+			} catch {}
+		}
+		if (!targetVersion) {
+			const metaResult = await client.fetch(`/api/v1/skills/${encodedName}`);
+			if (!metaResult.ok) {
+				if (metaResult.status === 0) return {
+					content: [{
+						type: "text",
+						text: "Unable to connect to the Tank registry. Check your network connection and try again."
+					}],
+					isError: true
+				};
+				if (metaResult.status === 404) return {
+					content: [{
+						type: "text",
+						text: `Skill "${name}" not found in the Tank registry.`
+					}],
+					isError: true
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `Failed to fetch skill metadata: ${metaResult.error}`
+					}],
+					isError: true
+				};
+			}
+			targetVersion = metaResult.data.latestVersion;
+		}
+		const versionResult = await client.fetch(`/api/v1/skills/${encodedName}/${targetVersion}`);
+		if (!versionResult.ok) {
+			if (versionResult.status === 0) return {
+				content: [{
+					type: "text",
+					text: "Unable to connect to the Tank registry. Check your network connection and try again."
+				}],
+				isError: true
+			};
+			if (versionResult.status === 404) return {
+				content: [{
+					type: "text",
+					text: `Skill "${name}" version "${targetVersion}" not found in the Tank registry.`
+				}],
+				isError: true
+			};
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to fetch audit data: ${versionResult.error}`
+				}],
+				isError: true
+			};
+		}
+		const details = versionResult.data;
+		const verdict = deriveVerdict(details.auditScore, details.auditStatus);
+		if (details.auditStatus !== "completed") return { content: [{
+			type: "text",
+			text: [
+				`## Audit: ${name}@${targetVersion}`,
+				"",
+				`**Status:** Pending security review`,
+				`**Scan Status:** ${details.auditStatus}`,
+				"",
+				"This skill has not yet been through security scanning. Results will be available once the scan completes."
+			].join("\n")
+		}] };
+		let findingsText = "";
+		const scanResult = await client.fetch(`/api/v1/skills/${encodedName}/${targetVersion}/scan`);
+		if (scanResult.ok && scanResult.data.findings) findingsText = formatFindings(scanResult.data.findings);
+		const score = details.auditScore !== null ? details.auditScore.toFixed(1) : "N/A";
+		const lines = [
+			`## Audit: ${name}@${targetVersion}`,
+			"",
+			`**Verdict:** ${verdict}`,
+			`**Score:** ${score}/10`,
+			`**Scanned:** ${details.publishedAt}`,
+			`**Version:** ${targetVersion}`
+		];
+		if (details.permissions) {
+			lines.push("", "**Permissions:**");
+			const p = details.permissions;
+			if (p.network?.outbound?.length) lines.push(`  - Network: ${p.network.outbound.join(", ")}`);
+			if (p.filesystem?.read?.length || p.filesystem?.write?.length) {
+				const parts = [];
+				if (p.filesystem.read?.length) parts.push(`read: ${p.filesystem.read.join(", ")}`);
+				if (p.filesystem.write?.length) parts.push(`write: ${p.filesystem.write.join(", ")}`);
+				lines.push(`  - Filesystem: ${parts.join("; ")}`);
+			}
+			lines.push(`  - Subprocess: ${p.subprocess ? "yes" : "no"}`);
+		}
+		if (findingsText) lines.push(findingsText);
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/doctor.ts
+const MIN_NODE_MAJOR = 24;
+function checkConfigFile() {
+	const configPath = getConfigPath();
+	if (!fs.existsSync(configPath)) return {
+		name: "Configuration File",
+		status: "FAIL",
+		message: `Configuration file not found at ${configPath}. Run the login tool to create it.`
+	};
+	try {
+		const raw = fs.readFileSync(configPath, "utf-8");
+		JSON.parse(raw);
+		return {
+			name: "Configuration File",
+			status: "PASS",
+			message: `Configuration file exists and is valid JSON (${configPath}).`
+		};
+	} catch (err) {
+		return {
+			name: "Configuration File",
+			status: "FAIL",
+			message: `Configuration file at ${configPath} is malformed: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+}
+async function checkAuthentication() {
+	const client = new TankApiClient();
+	if (!client.isAuthenticated) return {
+		name: "Authentication",
+		status: "FAIL",
+		message: "Not authenticated. Use the login tool to authenticate with Tank."
+	};
+	const authCheck = await client.verifyAuth();
+	if (authCheck.valid) return {
+		name: "Authentication",
+		status: "PASS",
+		message: `Authenticated as ${authCheck.user.name ?? "unknown"}.`
+	};
+	if (authCheck.reason === "network-error") return {
+		name: "Authentication",
+		status: "FAIL",
+		message: `Could not verify credentials (network error). ${authCheck.error ?? ""}`.trim()
+	};
+	return {
+		name: "Authentication",
+		status: "FAIL",
+		message: "Credentials are expired or invalid. Use the login tool to re-authenticate."
+	};
+}
+async function checkRegistryConnectivity() {
+	const registryUrl = getConfig().registry;
+	try {
+		const healthUrl = `${registryUrl}/api/health`;
+		const response = await fetch(healthUrl, { signal: AbortSignal.timeout(1e4) });
+		if (response.ok) return {
+			name: "Registry Connectivity",
+			status: "PASS",
+			message: `Registry at ${registryUrl} is reachable.`
+		};
+		return {
+			name: "Registry Connectivity",
+			status: "FAIL",
+			message: `Registry at ${registryUrl} returned HTTP ${response.status}.`
+		};
+	} catch {
+		return {
+			name: "Registry Connectivity",
+			status: "FAIL",
+			message: `Cannot reach registry at ${registryUrl}. Check your network connection.`
+		};
+	}
+}
+function checkNodeVersion() {
+	const raw = process.version;
+	const match = raw.match(/^v(\d+)/);
+	if ((match ? Number.parseInt(match[1], 10) : 0) >= MIN_NODE_MAJOR) return {
+		name: "Node.js Version",
+		status: "PASS",
+		message: `Node.js ${raw} meets the minimum requirement (v${MIN_NODE_MAJOR}.0.0).`
+	};
+	return {
+		name: "Node.js Version",
+		status: "FAIL",
+		message: `Node.js ${raw} is below the minimum required version v${MIN_NODE_MAJOR}.0.0. Please upgrade Node.js.`
+	};
+}
+function formatChecks(checks) {
+	const lines = [];
+	lines.push("Tank Doctor Report");
+	lines.push("==================");
+	lines.push("");
+	for (const check of checks) {
+		const icon = check.status === "PASS" ? "PASS" : "FAIL";
+		lines.push(`[${icon}] ${check.name}`);
+		lines.push(`      ${check.message}`);
+	}
+	lines.push("");
+	const failedChecks = checks.filter((c) => c.status === "FAIL");
+	if (failedChecks.length === 0) lines.push("All checks passed. Your Tank environment is ready to use.");
+	else {
+		lines.push("Suggestions:");
+		for (const check of failedChecks) if (check.name === "Authentication") lines.push("  - Use the login tool to authenticate with Tank.");
+		else if (check.name === "Registry Connectivity") lines.push("  - Check your network connection and verify the registry URL.");
+		else if (check.name === "Node.js Version") lines.push(`  - Upgrade Node.js to v${MIN_NODE_MAJOR}.0.0 or later.`);
+		else if (check.name === "Configuration File") lines.push("  - Use the login tool to create a valid configuration file.");
+		lines.push("");
+		lines.push("The environment is not healthy. Please address the issues above.");
+	}
+	return lines.join("\n");
+}
+function registerDoctorTool(server) {
+	server.tool("doctor", "Diagnose Tank setup and environment.", {}, async () => {
+		const checks = [];
+		checks.push(checkConfigFile());
+		checks.push(await checkAuthentication());
+		checks.push(await checkRegistryConnectivity());
+		checks.push(checkNodeVersion());
+		return { content: [{
+			type: "text",
+			text: formatChecks(checks)
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/init-skill.ts
+const SCOPED_NAME_PATTERN$5 = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+function registerInitSkillTool(server) {
+	server.tool("init-skill", `Create a new ${MANIFEST_FILENAME} and SKILL.md template for a Tank skill.`, {
+		name: z.string().regex(SCOPED_NAME_PATTERN$5, "Name must be in @org/name format"),
+		version: z.string().regex(SEMVER_PATTERN, "Version must be valid semver").optional().default("0.1.0"),
+		description: z.string().optional().default(""),
+		directory: z.string().optional().default(".")
+	}, async ({ name, version = "0.1.0", description = "", directory = "." }) => {
+		const targetDir = path.resolve(directory);
+		if (!fs.existsSync(targetDir)) return { content: [{
+			type: "text",
+			text: `Directory does not exist: ${targetDir}`
+		}] };
+		if (!fs.statSync(targetDir).isDirectory()) return { content: [{
+			type: "text",
+			text: `Path is not a directory: ${targetDir}`
+		}] };
+		const newManifestPath = path.join(targetDir, MANIFEST_FILENAME);
+		const legacyManifestPath = path.join(targetDir, LEGACY_MANIFEST_FILENAME);
+		const skillsJsonPath = newManifestPath;
+		if (fs.existsSync(newManifestPath) || fs.existsSync(legacyManifestPath)) return { content: [{
+			type: "text",
+			text: `${fs.existsSync(newManifestPath) ? MANIFEST_FILENAME : LEGACY_MANIFEST_FILENAME} already exists at ${targetDir}. Aborting to avoid overwrite.`
+		}] };
+		const manifest = {
+			name,
+			version,
+			description,
+			skills: {},
+			permissions: {
+				network: { outbound: [] },
+				filesystem: {
+					read: [],
+					write: []
+				},
+				subprocess: false
+			}
+		};
+		const parseResult = skillsJsonSchema.safeParse(manifest);
+		if (!parseResult.success) return { content: [{
+			type: "text",
+			text: `Failed to create ${MANIFEST_FILENAME}: ${parseResult.error.issues.map((issue) => `${issue.path.join(".") || "root"}: ${issue.message}`).join("; ")}`
+		}] };
+		fs.writeFileSync(skillsJsonPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+		const skillMdPath = path.join(targetDir, "SKILL.md");
+		let createdSkillMd = false;
+		if (!fs.existsSync(skillMdPath)) {
+			const skillMd = `# ${name}\n\n${description || "Description here."}\n`;
+			fs.writeFileSync(skillMdPath, skillMd, "utf-8");
+			createdSkillMd = true;
+		}
+		return { content: [{
+			type: "text",
+			text: `Initialized skill in ${targetDir}\nCreated: ${skillsJsonPath}\n${createdSkillMd ? `Created: ${skillMdPath}` : `Skipped existing: ${skillMdPath}`}`
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/install-skill.ts
+const SCOPED_NAME_PATTERN$4 = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+function textResult(text, isError) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		...isError ? { isError: true } : {}
+	};
+}
+function getSkillDir$4(projectDir, skillName) {
+	if (skillName.startsWith("@")) {
+		const [scope, name] = skillName.split("/");
+		return path.join(projectDir, ".tank", "skills", scope, name);
+	}
+	return path.join(projectDir, ".tank", "skills", skillName);
+}
+function registerInstallSkillTool(server) {
+	server.tool("install-skill", `Install a skill from the Tank registry. Resolves version, downloads tarball, verifies SHA-512 integrity, extracts files, and updates ${MANIFEST_FILENAME} + ${LOCKFILE_FILENAME}.`, {
+		name: z.string().describe("Skill name in @org/name format"),
+		version: z.string().optional().describe("Specific version or semver range (default: latest)"),
+		directory: z.string().optional().describe("Project directory (defaults to current working directory)")
+	}, async ({ name, version: versionRange, directory }) => {
+		if (!SCOPED_NAME_PATTERN$4.test(name)) return textResult(`Validation error: Skill name "${name}" must use the @org/name format (e.g. @acme/my-skill).`, true);
+		const client = new TankApiClient();
+		if (!client.isAuthenticated) return textResult("Not authenticated. Use the \"login\" tool first to authenticate with Tank.", true);
+		const dir = directory ? path.resolve(directory) : process.cwd();
+		const range = versionRange ?? "*";
+		let skillsJsonPath = path.join(dir, MANIFEST_FILENAME);
+		if (!fs.existsSync(skillsJsonPath) && fs.existsSync(path.join(dir, "skills.json"))) skillsJsonPath = path.join(dir, LEGACY_MANIFEST_FILENAME);
+		let skillsJson = { skills: {} };
+		if (fs.existsSync(skillsJsonPath)) try {
+			const raw = fs.readFileSync(skillsJsonPath, "utf-8");
+			skillsJson = JSON.parse(raw);
+		} catch {
+			return textResult(`Failed to read or parse ${path.basename(skillsJsonPath)}.`, true);
+		}
+		else {
+			skillsJsonPath = path.join(dir, MANIFEST_FILENAME);
+			skillsJson = { skills: {} };
+			fs.mkdirSync(dir, { recursive: true });
+			fs.writeFileSync(skillsJsonPath, `${JSON.stringify(skillsJson, null, 2)}\n`);
+		}
+		let lockPath = path.join(dir, LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockPath) && fs.existsSync(path.join(dir, "skills.lock"))) lockPath = path.join(dir, LEGACY_LOCKFILE_FILENAME);
+		let lock = {
+			lockfileVersion: 2,
+			skills: {}
+		};
+		if (fs.existsSync(lockPath)) try {
+			const raw = fs.readFileSync(lockPath, "utf-8");
+			lock = JSON.parse(raw);
+		} catch {
+			lock = {
+				lockfileVersion: 2,
+				skills: {}
+			};
+		}
+		const encodedName = encodeURIComponent(name);
+		const versionsResult = await client.fetch(`/api/v1/skills/${encodedName}/versions`);
+		if (!versionsResult.ok) {
+			if (versionsResult.status === 401 || versionsResult.status === 403) return textResult("Authentication failed. Use the \"login\" tool to authenticate with Tank.", true);
+			if (versionsResult.status === 404) return textResult(`Skill not found: "${name}" does not exist in the Tank registry.`, true);
+			if (versionsResult.status === 0) return textResult(`Cannot reach the Tank registry. Check your network connection and try again.\nError: ${versionsResult.error}`, true);
+			return textResult(`Failed to fetch versions for ${name}: ${versionsResult.error}`, true);
+		}
+		const availableVersions = versionsResult.data.versions.map((v) => v.version);
+		const resolved = resolve(range, availableVersions);
+		if (!resolved) return textResult(`No version of ${name} satisfies range "${range}". Available versions: ${availableVersions.join(", ")}`, true);
+		const lockKey = `${name}@${resolved}`;
+		if (lock.skills[lockKey]) return textResult(`${name}@${resolved} is already installed. No changes needed.`);
+		const metaResult = await client.fetch(`/api/v1/skills/${encodedName}/${resolved}`);
+		if (!metaResult.ok) {
+			if (metaResult.status === 404) return textResult(`Version ${resolved} of ${name} not found in the registry.`, true);
+			return textResult(`Failed to fetch metadata for ${name}@${resolved}: ${metaResult.error}`, true);
+		}
+		const metadata = metaResult.data;
+		let tarballBuffer;
+		try {
+			const downloadRes = await fetch(metadata.downloadUrl);
+			if (!downloadRes.ok) return textResult(`Failed to download tarball for ${name}@${resolved}: ${downloadRes.status} ${downloadRes.statusText}`, true);
+			tarballBuffer = Buffer.from(await downloadRes.arrayBuffer());
+		} catch (err) {
+			return textResult(`Network error downloading tarball for ${name}@${resolved}: ${err instanceof Error ? err.message : String(err)}`, true);
+		}
+		const computedIntegrity = `sha512-${crypto$1.createHash("sha512").update(tarballBuffer).digest("base64")}`;
+		if (computedIntegrity !== metadata.integrity) return textResult(`Integrity verification failed for ${name}@${resolved}.\nExpected: ${metadata.integrity}\nGot: ${computedIntegrity}\n\nThe tarball may have been tampered with. No files were extracted.`, true);
+		const extractDir = getSkillDir$4(dir, name);
+		fs.mkdirSync(extractDir, { recursive: true });
+		try {
+			await extractSafely(tarballBuffer, extractDir);
+		} catch (err) {
+			fs.rmSync(extractDir, {
+				recursive: true,
+				force: true
+			});
+			return textResult(`Failed to extract tarball for ${name}@${resolved}: ${err instanceof Error ? err.message : String(err)}`, true);
+		}
+		const skills = skillsJson.skills ?? {};
+		skills[name] = range === "*" ? `^${resolved}` : range;
+		skillsJson.skills = skills;
+		fs.writeFileSync(skillsJsonPath, `${JSON.stringify(skillsJson, null, 2)}\n`);
+		lock.skills[lockKey] = {
+			resolved: metadata.downloadUrl,
+			integrity: computedIntegrity,
+			permissions: metadata.permissions ?? {},
+			audit_score: metadata.auditScore ?? null
+		};
+		const sortedSkills = {};
+		for (const key of Object.keys(lock.skills).sort()) sortedSkills[key] = lock.skills[key];
+		lock.skills = sortedSkills;
+		fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+		fs.writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`);
+		const score = metadata.auditScore !== null && metadata.auditScore !== void 0 ? `${metadata.auditScore.toFixed(1)}/10` : "pending";
+		return textResult([
+			`## Installed ${name}@${resolved}`,
+			"",
+			`**Integrity:** SHA-512 verified`,
+			`**Audit Score:** ${score}`,
+			`**Extracted to:** ${extractDir}`,
+			"",
+			"### Updated files",
+			`- ${path.basename(skillsJsonPath)}: added "${name}": "${skills[name]}"`,
+			`- ${path.basename(lockPath)}: added ${lockKey}`
+		].join("\n"));
+	});
+}
+/**
+* Extract a tarball safely with security checks.
+* Rejects: absolute paths, path traversal (..), symlinks/hardlinks.
+*/
+async function extractSafely(tarball, destDir) {
+	const tmpTarball = path.join(destDir, ".tmp-tarball.tgz");
+	fs.writeFileSync(tmpTarball, tarball);
+	try {
+		await extract({
+			file: tmpTarball,
+			cwd: destDir,
+			filter: (entryPath) => {
+				if (path.isAbsolute(entryPath)) throw new Error(`Absolute path in tarball: ${entryPath}`);
+				if (entryPath.split("/").includes("..") || entryPath.split(path.sep).includes("..")) throw new Error(`Path traversal in tarball: ${entryPath}`);
+				return true;
+			},
+			onReadEntry: (entry) => {
+				if (entry.type === "SymbolicLink" || entry.type === "Link") throw new Error(`Symlink/hardlink in tarball: ${entry.path}`);
+			}
+		});
+	} finally {
+		if (fs.existsSync(tmpTarball)) fs.unlinkSync(tmpTarball);
+	}
+}
+//#endregion
+//#region src/tools/link-skill.ts
+const SCOPED_NAME_PATTERN$3 = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+function registerLinkSkillTool(server) {
+	server.tool("link-skill", "Link an installed skill into an agent workspace. Creates a symlink from the workspace .skills directory to the installed skill.", {
+		name: z.string().describe("Skill name in @org/name format"),
+		workspace: z.string().describe("Agent workspace directory path"),
+		directory: z.string().optional().describe("Project directory where skills are installed (defaults to current working directory)")
+	}, async ({ name, workspace, directory }) => {
+		if (!SCOPED_NAME_PATTERN$3.test(name)) return {
+			content: [{
+				type: "text",
+				text: `Validation error: Skill name "${name}" must use the @org/name format (e.g. @acme/my-skill).`
+			}],
+			isError: true
+		};
+		const projectDir = directory ? path.resolve(directory) : process.cwd();
+		const workspaceDir = path.resolve(workspace);
+		if (!fs.existsSync(workspaceDir)) return {
+			content: [{
+				type: "text",
+				text: `Error: Workspace directory does not exist: ${workspaceDir}`
+			}],
+			isError: true
+		};
+		const skillDir = getSkillDir$3(projectDir, name);
+		if (!fs.existsSync(skillDir)) return {
+			content: [{
+				type: "text",
+				text: `Skill "${name}" is not installed. Install it first with "install-skill" before linking.`
+			}],
+			isError: true
+		};
+		const [scope, skillName] = name.split("/");
+		const skillsLinkDir = path.join(workspaceDir, ".skills", scope);
+		const symlinkPath = path.join(skillsLinkDir, skillName);
+		try {
+			if (fs.lstatSync(symlinkPath).isSymbolicLink()) {
+				const currentTarget = fs.readlinkSync(symlinkPath);
+				const resolvedTarget = path.isAbsolute(currentTarget) ? currentTarget : path.resolve(path.dirname(symlinkPath), currentTarget);
+				if (path.resolve(resolvedTarget) === path.resolve(skillDir)) return { content: [{
+					type: "text",
+					text: `Skill "${name}" is already linked in ${workspaceDir}.`
+				}] };
+				fs.unlinkSync(symlinkPath);
+			}
+		} catch {}
+		fs.mkdirSync(skillsLinkDir, { recursive: true });
+		fs.symlinkSync(skillDir, symlinkPath, "dir");
+		return { content: [{
+			type: "text",
+			text: `Successfully linked "${name}" into ${workspaceDir}.\nSymlink: ${symlinkPath} → ${skillDir}`
+		}] };
+	});
+}
+function getSkillDir$3(projectDir, skillName) {
+	if (skillName.startsWith("@")) {
+		const [scope, name] = skillName.split("/");
+		return path.join(projectDir, ".tank", "skills", scope, name);
+	}
+	return path.join(projectDir, ".tank", "skills", skillName);
+}
+//#endregion
+//#region src/tools/login.ts
+const DEFAULT_POLL_INTERVAL_MS = 2e3;
+const DEFAULT_TIMEOUT_MS = 300 * 1e3;
+function registerLoginTool(server) {
+	server.tool("login", "Authenticate with Tank using GitHub OAuth device flow. Opens browser for authorization.", { timeout: z.number().optional().describe("Timeout in milliseconds (default: 300000 = 5 minutes)") }, async ({ timeout = DEFAULT_TIMEOUT_MS }) => {
+		const client = new TankApiClient();
+		const config = getConfig();
+		if (config.token) {
+			const authCheck = await client.verifyAuth();
+			if (authCheck.valid) return { content: [{
+				type: "text",
+				text: `Already logged in as ${authCheck.user?.name ?? authCheck.user?.email ?? "unknown user"}.\n\nTo log out, delete ~/.tank/config.json or use the CLI: tank logout`
+			}] };
+		}
+		const state = crypto.randomUUID();
+		const startRes = await fetch(`${config.registry}/api/v1/cli-auth/start`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ state })
+		});
+		if (!startRes.ok) return { content: [{
+			type: "text",
+			text: `Failed to start login flow: ${(await startRes.json().catch(() => ({}))).error ?? startRes.statusText}`
+		}] };
+		const { sessionCode } = await startRes.json();
+		const deadline = Date.now() + timeout;
+		let lastStatus = "";
+		while (Date.now() < deadline) {
+			try {
+				const exchangeRes = await fetch(`${config.registry}/api/v1/cli-auth/exchange`, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						sessionCode,
+						state
+					})
+				});
+				if (exchangeRes.ok) {
+					const { token, user } = await exchangeRes.json();
+					setConfig({
+						token,
+						user
+					});
+					return { content: [{
+						type: "text",
+						text: `Successfully logged in as ${user.name ?? user.email ?? "unknown user"}!\n\nYou can now use all Tank MCP tools: scan-skill, publish-skill, etc.`
+					}] };
+				}
+				if (exchangeRes.status !== 400) return { content: [{
+					type: "text",
+					text: `Login failed: ${(await exchangeRes.json().catch(() => ({}))).error ?? exchangeRes.statusText}`
+				}] };
+				const newStatus = "Waiting for authorization...";
+				if (newStatus !== lastStatus) lastStatus = newStatus;
+			} catch {}
+			await new Promise((resolve) => setTimeout(resolve, DEFAULT_POLL_INTERVAL_MS));
+		}
+		return { content: [{
+			type: "text",
+			text: `Login timed out. The authorization link may have expired.\n\nTry again: tank login`
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/logout.ts
+function registerLogoutTool(server) {
+	server.tool("logout", "Log out of Tank by clearing local credentials.", {}, async () => {
+		if (!getConfig().token) return { content: [{
+			type: "text",
+			text: "Not logged in. No credentials to clear."
+		}] };
+		setConfig({
+			token: void 0,
+			user: void 0
+		});
+		delete process.env.TANK_TOKEN;
+		return { content: [{
+			type: "text",
+			text: "Successfully logged out."
+		}] };
+	});
+}
+//#endregion
+//#region src/lib/packer.ts
+const MAX_PACKAGE_SIZE = 50 * 1024 * 1024;
+const MAX_FILE_COUNT = 1e3;
+const DEFAULT_IGNORES = [
+	"node_modules",
+	".git",
+	".env*",
+	"*.log",
+	".tank",
+	".DS_Store"
+];
+const ALWAYS_IGNORED = ["node_modules", ".git"];
+const IGNORE_FILES = [".tankignore", ".gitignore"];
+/**
+* Pack a skill directory into a .tgz tarball with integrity hashing.
+*/
+async function pack(directory) {
+	const absDir = path.resolve(directory);
+	if (!fs.existsSync(absDir)) throw new Error(`Directory does not exist: ${absDir}`);
+	if (!fs.statSync(absDir).isDirectory()) throw new Error(`Not a directory: ${absDir}`);
+	let manifestPath = path.join(absDir, MANIFEST_FILENAME);
+	let manifestFilename = MANIFEST_FILENAME;
+	if (!fs.existsSync(manifestPath)) {
+		manifestPath = path.join(absDir, LEGACY_MANIFEST_FILENAME);
+		manifestFilename = LEGACY_MANIFEST_FILENAME;
+	}
+	if (!fs.existsSync(manifestPath)) throw new Error(`Missing required file: ${MANIFEST_FILENAME}`);
+	let skillsJsonContent;
+	try {
+		skillsJsonContent = fs.readFileSync(manifestPath, "utf-8");
+	} catch {
+		throw new Error(`Failed to read ${manifestFilename}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(skillsJsonContent);
+	} catch {
+		throw new Error(`Invalid ${manifestFilename}: not valid JSON`);
+	}
+	const validation = skillsJsonSchema.safeParse(parsed);
+	if (!validation.success) {
+		const issues = validation.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+		throw new Error(`Invalid ${manifestFilename}:\n${issues}`);
+	}
+	const skillMdPath = path.join(absDir, "SKILL.md");
+	if (!fs.existsSync(skillMdPath)) throw new Error("Missing required file: SKILL.md");
+	let readmeContent;
+	try {
+		readmeContent = fs.readFileSync(skillMdPath, "utf-8");
+	} catch {
+		throw new Error("Failed to read SKILL.md");
+	}
+	const files = collectFiles(absDir, absDir, buildIgnoreFilter(absDir));
+	if (files.length > MAX_FILE_COUNT) throw new Error(`Too many files: ${files.length} exceeds maximum of ${MAX_FILE_COUNT}`);
+	let totalSize = 0;
+	for (const file of files) {
+		const filePath = path.join(absDir, file);
+		const fileStat = fs.statSync(filePath);
+		totalSize += fileStat.size;
+	}
+	const tarball = await createTarball(absDir, files);
+	if (tarball.length > MAX_PACKAGE_SIZE) throw new Error(`Tarball too large: ${tarball.length} bytes exceeds maximum of ${MAX_PACKAGE_SIZE} bytes (50MB)`);
+	return {
+		tarball,
+		integrity: `sha512-${crypto$1.createHash("sha512").update(tarball).digest("base64")}`,
+		fileCount: files.length,
+		totalSize,
+		readme: readmeContent,
+		files,
+		manifest: validation.data
+	};
+}
+/**
+* Pack a directory into a .tgz tarball for security scanning.
+*
+* Unlike pack(), this function does NOT require skills.json or SKILL.md.
+* It applies the same security checks (no symlinks, no path traversal, etc.)
+* and returns the same PackResult interface with a synthesised manifest.
+*
+* Validates:
+* - Directory exists
+* - No symlinks or hardlinks
+* - No path traversal (.. components)
+* - No absolute paths
+* - File count <= 1000
+* - Tarball size <= 50MB
+*
+* Does NOT validate:
+* - skills.json existence or validity
+* - SKILL.md existence (but reads it if present)
+*/
+async function packForScan(directory) {
+	const absDir = path.resolve(directory);
+	if (!fs.existsSync(absDir)) throw new Error(`Directory does not exist: ${absDir}`);
+	if (!fs.statSync(absDir).isDirectory()) throw new Error(`Not a directory: ${absDir}`);
+	let readmeContent = "";
+	const skillMdPath = path.join(absDir, "SKILL.md");
+	if (fs.existsSync(skillMdPath)) try {
+		readmeContent = fs.readFileSync(skillMdPath, "utf-8");
+	} catch {
+		readmeContent = "";
+	}
+	const files = collectFiles(absDir, absDir, buildIgnoreFilter(absDir));
+	if (files.length > MAX_FILE_COUNT) throw new Error(`Too many files: ${files.length} exceeds maximum of ${MAX_FILE_COUNT}`);
+	if (files.length === 0) throw new Error("No files to scan: directory is empty or all files are ignored");
+	let totalSize = 0;
+	for (const file of files) {
+		const filePath = path.join(absDir, file);
+		const fileStat = fs.statSync(filePath);
+		totalSize += fileStat.size;
+	}
+	const tarball = await createTarball(absDir, files);
+	if (tarball.length > MAX_PACKAGE_SIZE) throw new Error(`Tarball too large: ${tarball.length} bytes exceeds maximum of ${MAX_PACKAGE_SIZE} bytes (50MB)`);
+	const integrity = `sha512-${crypto$1.createHash("sha512").update(tarball).digest("base64")}`;
+	const manifest = {
+		name: path.basename(absDir),
+		version: "0.0.0",
+		description: "Local scan"
+	};
+	return {
+		tarball,
+		integrity,
+		fileCount: files.length,
+		totalSize,
+		readme: readmeContent,
+		files,
+		manifest
+	};
+}
+/**
+* Build an ignore filter from .tankignore, .gitignore, or defaults.
+*/
+function buildIgnoreFilter(dir) {
+	const ig = ignore();
+	ig.add(ALWAYS_IGNORED);
+	const tankIgnorePath = path.join(dir, ".tankignore");
+	const gitIgnorePath = path.join(dir, ".gitignore");
+	if (fs.existsSync(tankIgnorePath)) {
+		const content = fs.readFileSync(tankIgnorePath, "utf-8");
+		ig.add(content);
+		ig.add(IGNORE_FILES);
+	} else if (fs.existsSync(gitIgnorePath)) {
+		const content = fs.readFileSync(gitIgnorePath, "utf-8");
+		ig.add(content);
+		ig.add(IGNORE_FILES);
+	} else ig.add(DEFAULT_IGNORES);
+	return ig;
+}
+/**
+* Recursively collect files from a directory.
+*/
+function collectFiles(baseDir, currentDir, ig) {
+	const files = [];
+	const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path.join(currentDir, entry.name);
+		const relativePath = path.relative(baseDir, fullPath);
+		if (relativePath.split(path.sep).includes("..")) throw new Error(`Path traversal detected: "${relativePath}" contains ".." component`);
+		if (path.isAbsolute(relativePath)) throw new Error(`Absolute path detected: "${relativePath}"`);
+		const lstatResult = fs.lstatSync(fullPath);
+		if (lstatResult.isSymbolicLink()) throw new Error(`Symlink detected: "${relativePath}" — symlinks are not allowed`);
+		const pathForIgnore = lstatResult.isDirectory() ? `${relativePath}/` : relativePath;
+		if (ig.ignores(pathForIgnore)) continue;
+		if (lstatResult.isDirectory()) {
+			const subFiles = collectFiles(baseDir, fullPath, ig);
+			files.push(...subFiles);
+		} else if (lstatResult.isFile()) files.push(relativePath);
+	}
+	return files;
+}
+/**
+* Create a gzipped tarball from the given files.
+*/
+async function createTarball(cwd, files) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const stream = create({
+			gzip: true,
+			cwd,
+			portable: true
+		}, files);
+		stream.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		stream.on("end", () => {
+			resolve(Buffer.concat(chunks));
+		});
+		stream.on("error", (err) => {
+			reject(err);
+		});
+	});
+}
+//#endregion
+//#region src/tools/publish-skill.ts
+function registerPublishSkillTool(server) {
+	server.tool("publish-skill", "Publish a skill to the Tank registry. Requires authentication.", {
+		directory: z.string().optional().describe("Directory to publish (default: current directory)"),
+		visibility: z.enum(["public", "private"]).optional().default("public").describe("Package visibility"),
+		dryRun: z.boolean().optional().default(false).describe("Validate without publishing")
+	}, async ({ directory = ".", visibility = "public", dryRun = false }) => {
+		const absDir = path.resolve(directory);
+		const client = new TankApiClient();
+		if (!dryRun && !client.isAuthenticated) return { content: [{
+			type: "text",
+			text: "You need to log in first. Use the login tool to authenticate with Tank.\n\nExample: \"Log in to Tank\""
+		}] };
+		if (!dryRun) {
+			if (!(await client.verifyAuth()).valid) return { content: [{
+				type: "text",
+				text: "Your session has expired. Use the login tool to authenticate again."
+			}] };
+		}
+		let packResult;
+		try {
+			packResult = await pack(absDir);
+		} catch (err) {
+			return { content: [{
+				type: "text",
+				text: `Failed to pack skill: ${err instanceof Error ? err.message : String(err)}`
+			}] };
+		}
+		const manifest = packResult.manifest;
+		const skillName = manifest.name ?? "unknown";
+		const skillVersion = manifest.version ?? "0.0.0";
+		if (dryRun) return { content: [{
+			type: "text",
+			text: [
+				`## Dry Run for ${skillName}@${skillVersion}`,
+				"",
+				"**Validation:** ✅ PASSED",
+				"",
+				"### Package Summary",
+				`- **Name:** ${skillName}`,
+				`- **Version:** ${skillVersion}`,
+				`- **Visibility:** ${visibility}`,
+				`- **Files:** ${packResult.fileCount}`,
+				`- **Size:** ${(packResult.totalSize / 1024).toFixed(1)}KB compressed`,
+				`- **Integrity:** ${packResult.integrity.slice(0, 20)}...`,
+				"",
+				"### Manifest",
+				`- **Description:** ${manifest.description ?? "No description"}`,
+				`- **Permissions:** ${JSON.stringify(manifest.permissions ?? {})}`,
+				"",
+				"### Files",
+				...packResult.files.slice(0, 10).map((f) => `  - ${f}`),
+				packResult.files.length > 10 ? `  ... and ${packResult.files.length - 10} more` : "",
+				"",
+				"Ready to publish. Say \"publish my skill\" when you're ready."
+			].join("\n")
+		}] };
+		const startResult = await client.fetch("/api/v1/skills", {
+			method: "POST",
+			body: JSON.stringify({
+				manifest: {
+					...manifest,
+					visibility
+				},
+				readme: packResult.readme,
+				files: packResult.files
+			})
+		});
+		if (!startResult.ok) return { content: [{
+			type: "text",
+			text: `Failed to start publish: ${startResult.error}`
+		}] };
+		const { uploadUrl, versionId } = startResult.data;
+		const uploadRes = await fetch(uploadUrl, {
+			method: "PUT",
+			headers: { "Content-Type": "application/gzip" },
+			body: new Uint8Array(packResult.tarball)
+		});
+		if (!uploadRes.ok) return { content: [{
+			type: "text",
+			text: `Failed to upload tarball: ${uploadRes.statusText}`
+		}] };
+		const confirmResult = await client.fetch("/api/v1/skills/confirm", {
+			method: "POST",
+			body: JSON.stringify({
+				versionId,
+				integrity: packResult.integrity,
+				fileCount: packResult.fileCount,
+				tarballSize: packResult.tarball.length,
+				readme: packResult.readme
+			})
+		});
+		if (!confirmResult.ok) return { content: [{
+			type: "text",
+			text: `Failed to confirm publish: ${confirmResult.error}`
+		}] };
+		const confirm = confirmResult.data;
+		const score = confirm.auditScore !== null ? `${confirm.auditScore.toFixed(1)}/10` : "pending";
+		return { content: [{
+			type: "text",
+			text: [
+				`## Published ${confirm.name}@${confirm.version}`,
+				"",
+				`**Status:** ✅ Successfully published`,
+				`**Visibility:** ${visibility}`,
+				`**Audit Score:** ${score}`,
+				`**Scan Verdict:** ${confirm.scanVerdict ?? "pending"}`,
+				"",
+				"### Package Details",
+				`- **Files:** ${packResult.fileCount}`,
+				`- **Size:** ${(packResult.totalSize / 1024).toFixed(1)}KB`,
+				"",
+				`View your skill: https://tankpkg.dev/skills/${confirm.name}`
+			].join("\n")
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/remove-skill.ts
+const SCOPED_NAME_PATTERN$2 = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+function registerRemoveSkillTool(server) {
+	server.tool("remove-skill", `Remove an installed skill from the project. Removes from ${MANIFEST_FILENAME}, ${LOCKFILE_FILENAME}, and deletes skill files.`, {
+		name: z.string().describe("Skill name in @org/name format"),
+		directory: z.string().optional().describe("Project directory (defaults to current working directory)")
+	}, async ({ name, directory }) => {
+		if (!SCOPED_NAME_PATTERN$2.test(name)) return {
+			content: [{
+				type: "text",
+				text: `Validation error: Skill name "${name}" must use the @org/name format (e.g. @acme/my-skill).`
+			}],
+			isError: true
+		};
+		const dir = directory ? path.resolve(directory) : process.cwd();
+		const results = [];
+		let skillFoundAnywhere = false;
+		let skillsJsonPath = path.join(dir, MANIFEST_FILENAME);
+		if (!fs.existsSync(skillsJsonPath)) skillsJsonPath = path.join(dir, LEGACY_MANIFEST_FILENAME);
+		if (fs.existsSync(skillsJsonPath)) try {
+			const raw = fs.readFileSync(skillsJsonPath, "utf-8");
+			const skillsJson = JSON.parse(raw);
+			const skills = skillsJson.skills ?? {};
+			if (name in skills) {
+				skillFoundAnywhere = true;
+				delete skills[name];
+				skillsJson.skills = skills;
+				fs.writeFileSync(skillsJsonPath, `${JSON.stringify(skillsJson, null, 2)}\n`);
+				results.push(`Removed "${name}" from ${path.basename(skillsJsonPath)}`);
+			}
+		} catch {
+			results.push(`Warning: Failed to read or parse ${path.basename(skillsJsonPath)}`);
+		}
+		let lockPath = path.join(dir, LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockPath)) lockPath = path.join(dir, LEGACY_LOCKFILE_FILENAME);
+		if (fs.existsSync(lockPath)) try {
+			const raw = fs.readFileSync(lockPath, "utf-8");
+			const lock = JSON.parse(raw);
+			let removedFromLock = false;
+			for (const key of Object.keys(lock.skills)) {
+				const lastAt = key.lastIndexOf("@");
+				if (lastAt <= 0) continue;
+				if (key.slice(0, lastAt) === name) {
+					delete lock.skills[key];
+					removedFromLock = true;
+					skillFoundAnywhere = true;
+				}
+			}
+			if (removedFromLock) {
+				const sortedSkills = {};
+				for (const key of Object.keys(lock.skills).sort()) sortedSkills[key] = lock.skills[key];
+				lock.skills = sortedSkills;
+				fs.writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`);
+				results.push(`Removed "${name}" from ${path.basename(lockPath)}`);
+			}
+		} catch {
+			results.push(`Warning: Failed to read or parse ${path.basename(lockPath)}`);
+		}
+		const skillDir = getSkillDir$2(dir, name);
+		if (fs.existsSync(skillDir)) {
+			skillFoundAnywhere = true;
+			fs.rmSync(skillDir, {
+				recursive: true,
+				force: true
+			});
+			results.push(`Deleted skill files from ${skillDir}`);
+		} else results.push(`Skill files were already absent from ${skillDir}`);
+		const symlinkName = name.replace(/\//g, "__");
+		const agentSkillDir = path.join(dir, ".tank", "agent-skills", symlinkName);
+		if (fs.existsSync(agentSkillDir)) {
+			fs.rmSync(agentSkillDir, {
+				recursive: true,
+				force: true
+			});
+			results.push("Removed symlink from agent workspace");
+		}
+		if (!skillFoundAnywhere) return {
+			content: [{
+				type: "text",
+				text: `Skill "${name}" is not installed. It was not found in ${MANIFEST_FILENAME}, ${LOCKFILE_FILENAME}, or .tank/skills/.`
+			}],
+			isError: true
+		};
+		return { content: [{
+			type: "text",
+			text: `Successfully removed ${name}.\n${results.join("\n")}`
+		}] };
+	});
+}
+function getSkillDir$2(projectDir, skillName) {
+	if (skillName.startsWith("@")) {
+		const [scope, name] = skillName.split("/");
+		return path.join(projectDir, ".tank", "skills", scope, name);
+	}
+	return path.join(projectDir, ".tank", "skills", skillName);
+}
+//#endregion
+//#region src/tools/scan-skill.ts
+function registerScanSkillTool(server) {
+	server.tool("scan-skill", "Scan a skill directory for security issues. Requires authentication.", { directory: z.string().optional().describe("Directory to scan (default: current directory)") }, async ({ directory = "." }) => {
+		const absDir = path.resolve(directory);
+		const client = new TankApiClient();
+		if (!client.isAuthenticated) return { content: [{
+			type: "text",
+			text: "You need to log in first. Use the login tool to authenticate with Tank.\n\nExample: \"Log in to Tank\""
+		}] };
+		if (!(await client.verifyAuth()).valid) return { content: [{
+			type: "text",
+			text: "Your session has expired. Use the login tool to authenticate again.\n\nExample: \"Log in to Tank\""
+		}] };
+		let packResult;
+		let usedSynthesisedManifest = false;
+		if (fs.existsSync(path.join(absDir, "tank.json")) || fs.existsSync(path.join(absDir, "skills.json"))) try {
+			packResult = await pack(absDir);
+		} catch (err) {
+			return { content: [{
+				type: "text",
+				text: `Failed to pack skill: ${err instanceof Error ? err.message : String(err)}`
+			}] };
+		}
+		else try {
+			packResult = await packForScan(absDir);
+			usedSynthesisedManifest = true;
+		} catch (err) {
+			return { content: [{
+				type: "text",
+				text: `Failed to pack directory for scan: ${err instanceof Error ? err.message : String(err)}`
+			}] };
+		}
+		const manifest = packResult.manifest;
+		const skillName = manifest.name ?? "unknown";
+		const skillVersion = manifest.version ?? "0.0.0";
+		const formData = new FormData();
+		const blob = new Blob([new Uint8Array(packResult.tarball)], { type: "application/gzip" });
+		formData.append("tarball", blob, `${skillName}-${skillVersion}.tgz`);
+		formData.append("manifest", JSON.stringify(manifest));
+		const config = getConfig();
+		const scanRes = await fetch(`${config.registry}/api/v1/scan`, {
+			method: "POST",
+			headers: { Authorization: `Bearer ${client.token}` },
+			body: formData
+		});
+		if (!scanRes.ok) return { content: [{
+			type: "text",
+			text: `Scan failed: ${(await scanRes.json().catch(() => ({}))).error ?? scanRes.statusText}`
+		}] };
+		const scanResult = await scanRes.json();
+		const verdictEmoji = {
+			pass: "✅",
+			pass_with_notes: "⚠️",
+			flagged: "🚩",
+			fail: "❌"
+		};
+		const severityEmoji = {
+			critical: "🔴",
+			high: "🟠",
+			medium: "🟡",
+			low: "🟢"
+		};
+		const lines = [`## Scan Results for ${skillName}@${skillVersion}`, ""];
+		if (usedSynthesisedManifest) {
+			lines.push(`> **Note:** No \`${MANIFEST_FILENAME}\` found. A synthesised manifest was used for scanning.`);
+			lines.push("");
+		}
+		const auditScore = scanResult.audit_score ?? 0;
+		const durationMs = scanResult.duration_ms ?? 0;
+		lines.push(`**Verdict:** ${verdictEmoji[scanResult.verdict] ?? ""} ${scanResult.verdict.toUpperCase()}`, `**Score:** ${auditScore.toFixed(1)}/10`, `**Duration:** ${(durationMs / 1e3).toFixed(1)}s`, `**Files:** ${packResult.fileCount} (${(packResult.totalSize / 1024).toFixed(1)}KB)`, "");
+		if (scanResult.findings.length > 0) {
+			lines.push(`### Findings (${scanResult.findings.length})`);
+			lines.push("");
+			const bySeverity = {
+				critical: [],
+				high: [],
+				medium: [],
+				low: []
+			};
+			for (const f of scanResult.findings) bySeverity[f.severity].push(f);
+			for (const severity of [
+				"critical",
+				"high",
+				"medium",
+				"low"
+			]) {
+				const findings = bySeverity[severity];
+				if (findings.length === 0) continue;
+				lines.push(`#### ${severityEmoji[severity]} ${severity.toUpperCase()} (${findings.length})`);
+				for (const f of findings) {
+					lines.push(`- **${f.type}**: ${f.description}`);
+					if (f.location) lines.push(`  - Location: ${f.location}`);
+				}
+				lines.push("");
+			}
+		} else {
+			lines.push("No findings. Your skill looks secure!");
+			lines.push("");
+		}
+		if (scanResult.stage_results?.length > 0) {
+			lines.push("### Scan Stages");
+			lines.push("");
+			for (const stage of scanResult.stage_results) {
+				const status = stage.status === "passed" ? "✓" : "✗";
+				lines.push(`- ${status} ${stage.stage} (${stage.duration_ms}ms)`);
+			}
+			lines.push("");
+		}
+		if (scanResult.llm_analysis?.enabled) {
+			const llm = scanResult.llm_analysis;
+			lines.push("### LLM Analysis");
+			lines.push("");
+			lines.push(`**Mode:** ${llm.mode}`);
+			if (llm.provider_used) lines.push(`**Provider:** ${llm.provider_used}`);
+			if (llm.findings_reviewed !== void 0 && llm.findings_reviewed > 0) lines.push(`**Findings Reviewed:** ${llm.findings_reviewed}`);
+			if (llm.findings_dismissed !== void 0 && llm.findings_dismissed > 0) lines.push(`**False Positives Dismissed:** ${llm.findings_dismissed}`);
+			if (llm.findings_confirmed !== void 0 && llm.findings_confirmed > 0) lines.push(`**Threats Confirmed:** ${llm.findings_confirmed}`);
+			if (llm.findings_uncertain !== void 0 && llm.findings_uncertain > 0) lines.push(`**Uncertain:** ${llm.findings_uncertain}`);
+			if (llm.latency_ms) lines.push(`**Latency:** ${llm.latency_ms}ms`);
+			if (llm.error) lines.push(`**Error:** ${llm.error}`);
+			lines.push("");
+		}
+		if (scanResult.scan_id) lines.push(`View full report: https://tankpkg.dev/scans/${scanResult.scan_id}`);
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/search-skills.ts
+function registerSearchSkillsTool(server) {
+	const client = new TankApiClient();
+	server.tool("search-skills", "Search the Tank registry for AI agent skills", {
+		query: z.string().min(1).describe("Search query (skill name or keywords)"),
+		limit: z.number().min(1).max(50).optional().default(10).describe("Maximum results to return")
+	}, async ({ query, limit }) => {
+		const result = await client.fetch(`/api/v1/search?q=${encodeURIComponent(query)}&limit=${limit}`);
+		if (!result.ok) return { content: [{
+			type: "text",
+			text: `Search failed: ${result.error}`
+		}] };
+		const { results, total } = result.data;
+		if (results.length === 0) return { content: [{
+			type: "text",
+			text: `No skills found matching "${query}". Try different keywords or browse the registry at https://tankpkg.dev`
+		}] };
+		const header = "| Skill | Score | Downloads | Description |\n|-------|-------|-----------|-------------|";
+		const rows = results.map((skill) => {
+			const score = skill.auditScore !== null ? skill.auditScore.toFixed(1) : "-";
+			const downloads = skill.downloads > 1e3 ? `${(skill.downloads / 1e3).toFixed(1)}k` : skill.downloads.toString();
+			const desc = skill.description?.slice(0, 50) ?? "No description";
+			return `| ${skill.name} | ${score} | ${downloads} | ${desc} |`;
+		});
+		return { content: [{
+			type: "text",
+			text: [
+				`Found ${total} skill${total !== 1 ? "s" : ""} matching "${query}":`,
+				"",
+				header,
+				...rows,
+				"",
+				`View full results: https://tankpkg.dev/search?q=${encodeURIComponent(query)}`
+			].join("\n")
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/skill-info.ts
+function registerSkillInfoTool(server) {
+	const client = new TankApiClient();
+	server.tool("skill-info", "Get detailed information about a specific skill from the Tank registry", { name: z.string().describe("Skill name (e.g., @org/skill-name or skill-name)") }, async ({ name }) => {
+		const result = await client.fetch(`/api/v1/skills/${encodeURIComponent(name)}`);
+		if (!result.ok) {
+			if (result.status === 404) return { content: [{
+				type: "text",
+				text: `Skill "${name}" not found. Search for skills: https://tankpkg.dev/search`
+			}] };
+			return { content: [{
+				type: "text",
+				text: `Failed to get skill info: ${result.error}`
+			}] };
+		}
+		const skill = result.data;
+		const score = skill.auditScore !== null ? `${skill.auditScore.toFixed(1)}/10` : "Not scored";
+		const size = skill.versions[0] ? `${(skill.versions[0].tarballSize / 1024).toFixed(1)}KB` : "Unknown";
+		let permsText = "None declared";
+		if (skill.permissions) {
+			const perms = [];
+			const p = skill.permissions;
+			if (p.network?.outbound?.length) perms.push(`network: ${p.network.outbound.join(", ")}`);
+			if (p.filesystem?.read?.length || p.filesystem?.write?.length) {
+				const fsPerms = [];
+				if (p.filesystem.read?.length) fsPerms.push(`read: ${p.filesystem.read.length} paths`);
+				if (p.filesystem.write?.length) fsPerms.push(`write: ${p.filesystem.write.length} paths`);
+				perms.push(`filesystem (${fsPerms.join(", ")})`);
+			}
+			if (p.subprocess) perms.push("subprocess: allowed");
+			if (perms.length > 0) permsText = perms.join("\n  - ");
+		}
+		const versionsList = skill.versions.slice(0, 5).map((v) => {
+			const vScore = v.auditScore !== null ? v.auditScore.toFixed(1) : "-";
+			return `${v.version} (score: ${vScore})`;
+		}).join("\n  - ");
+		return { content: [{
+			type: "text",
+			text: [
+				`# ${skill.name}`,
+				"",
+				`**Publisher:** ${skill.publisher}`,
+				`**Latest:** ${skill.latestVersion}`,
+				`**Score:** ${score}`,
+				`**Size:** ${size}`,
+				`**Downloads:** ${skill.downloads}`,
+				"",
+				"**Description:**",
+				skill.description ?? "No description available",
+				"",
+				"**Permissions:**",
+				`  - ${permsText}`,
+				"",
+				"**Versions:**",
+				`  - ${versionsList}`,
+				skill.versions.length > 5 ? `\n  ... and ${skill.versions.length - 5} more` : "",
+				"",
+				`View on Tank: https://tankpkg.dev/skills/${skill.name}`
+			].join("\n")
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/skill-permissions.ts
+function parseSkillName(key) {
+	const lastAt = key.lastIndexOf("@");
+	if (lastAt > 0) return key.slice(0, lastAt);
+	return key;
+}
+function collectPermissions(lockfile) {
+	const networkMap = /* @__PURE__ */ new Map();
+	const fsReadMap = /* @__PURE__ */ new Map();
+	const fsWriteMap = /* @__PURE__ */ new Map();
+	const subprocessSkills = [];
+	const envMap = /* @__PURE__ */ new Map();
+	const execMap = /* @__PURE__ */ new Map();
+	for (const [key, entry] of Object.entries(lockfile.skills)) {
+		const skillName = parseSkillName(key);
+		const perms = entry.permissions;
+		if (perms.network?.outbound) for (const domain of perms.network.outbound) {
+			const existing = networkMap.get(domain) ?? [];
+			existing.push(skillName);
+			networkMap.set(domain, existing);
+		}
+		if (perms.filesystem?.read) for (const p of perms.filesystem.read) {
+			const existing = fsReadMap.get(p) ?? [];
+			existing.push(skillName);
+			fsReadMap.set(p, existing);
+		}
+		if (perms.filesystem?.write) for (const p of perms.filesystem.write) {
+			const existing = fsWriteMap.get(p) ?? [];
+			existing.push(skillName);
+			fsWriteMap.set(p, existing);
+		}
+		if (perms.subprocess === true) subprocessSkills.push(skillName);
+		const rawPerms = perms;
+		if (Array.isArray(rawPerms.env)) for (const envVar of rawPerms.env) {
+			const existing = envMap.get(envVar) ?? [];
+			existing.push(skillName);
+			envMap.set(envVar, existing);
+		}
+		if (Array.isArray(rawPerms.exec)) for (const cmd of rawPerms.exec) {
+			const existing = execMap.get(cmd) ?? [];
+			existing.push(skillName);
+			execMap.set(cmd, existing);
+		}
+	}
+	const toEntries = (map) => Array.from(map.entries()).map(([value, skills]) => ({
+		value,
+		skills
+	}));
+	return {
+		networkOutbound: toEntries(networkMap),
+		filesystemRead: toEntries(fsReadMap),
+		filesystemWrite: toEntries(fsWriteMap),
+		subprocess: subprocessSkills,
+		env: toEntries(envMap),
+		exec: toEntries(execMap)
+	};
+}
+function formatAttribution(skills) {
+	return `<- ${skills.join(", ")}`;
+}
+function formatSection(title, entries) {
+	const lines = [];
+	lines.push(`${title}:`);
+	if (entries.length === 0) lines.push("  none");
+	else for (const entry of entries) lines.push(`  ${entry.value}    ${formatAttribution(entry.skills)}`);
+	return lines.join("\n");
+}
+function isDomainAllowed(domain, allowedDomains) {
+	for (const allowed of allowedDomains) {
+		if (allowed === "*") return true;
+		if (allowed === domain) return true;
+		if (allowed.startsWith("*.")) {
+			const suffix = allowed.slice(1);
+			if (domain.endsWith(suffix) || domain === allowed.slice(2)) return true;
+			if (domain === allowed) return true;
+		}
+	}
+	return false;
+}
+function isPathAllowed(requestedPath, allowedPaths) {
+	for (const allowed of allowedPaths) {
+		if (allowed === requestedPath) return true;
+		if (allowed.endsWith("/**")) {
+			const prefix = allowed.slice(0, -3);
+			if (requestedPath.startsWith(prefix)) return true;
+		}
+	}
+	return false;
+}
+function checkBudget(resolved, budget) {
+	const violations = [];
+	const budgetDomains = budget.network?.outbound ?? [];
+	for (const entry of resolved.networkOutbound) if (!isDomainAllowed(entry.value, budgetDomains)) violations.push({
+		category: "network outbound",
+		value: entry.value,
+		skills: entry.skills
+	});
+	const budgetReadPaths = budget.filesystem?.read ?? [];
+	for (const entry of resolved.filesystemRead) if (!isPathAllowed(entry.value, budgetReadPaths)) violations.push({
+		category: "filesystem read",
+		value: entry.value,
+		skills: entry.skills
+	});
+	const budgetWritePaths = budget.filesystem?.write ?? [];
+	for (const entry of resolved.filesystemWrite) if (!isPathAllowed(entry.value, budgetWritePaths)) violations.push({
+		category: "filesystem write",
+		value: entry.value,
+		skills: entry.skills
+	});
+	if (resolved.subprocess.length > 0 && budget.subprocess !== true) violations.push({
+		category: "subprocess",
+		value: "subprocess access",
+		skills: resolved.subprocess
+	});
+	return violations;
+}
+function registerSkillPermissionsTool(server) {
+	server.tool("skill-permissions", "Display resolved permission summary for installed skills. Shows what capabilities each skill requires and checks against the project permission budget.", { directory: z.string().optional().describe("Project directory path (defaults to current working directory)") }, async ({ directory }) => {
+		const dir = directory ? path.resolve(directory) : process.cwd();
+		if (!fs.existsSync(dir)) return {
+			content: [{
+				type: "text",
+				text: `Directory does not exist: ${dir}`
+			}],
+			isError: true
+		};
+		let skillsJsonPath = path.join(dir, MANIFEST_FILENAME);
+		if (!fs.existsSync(skillsJsonPath)) skillsJsonPath = path.join(dir, LEGACY_MANIFEST_FILENAME);
+		if (!fs.existsSync(skillsJsonPath)) return {
+			content: [{
+				type: "text",
+				text: `No ${MANIFEST_FILENAME} found. Run "init-skill" to create one.`
+			}],
+			isError: true
+		};
+		let skillsJson;
+		try {
+			const raw = fs.readFileSync(skillsJsonPath, "utf-8");
+			skillsJson = JSON.parse(raw);
+		} catch {
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to parse ${path.basename(skillsJsonPath)}. The file may be corrupted.`
+				}],
+				isError: true
+			};
+		}
+		const skillDeps = skillsJson.skills ?? {};
+		if (Object.keys(skillDeps).length === 0) return { content: [{
+			type: "text",
+			text: "No skills with permissions to display. The project has no skill dependencies."
+		}] };
+		let lockfilePath = path.join(dir, LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockfilePath)) lockfilePath = path.join(dir, LEGACY_LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockfilePath)) return { content: [{
+			type: "text",
+			text: `No ${LOCKFILE_FILENAME} found. Skills are declared but not installed. Run install to generate a lockfile.`
+		}] };
+		let lockfile;
+		try {
+			const raw = fs.readFileSync(lockfilePath, "utf-8");
+			lockfile = JSON.parse(raw);
+		} catch {
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to parse ${path.basename(lockfilePath)}. The file may be corrupted.`
+				}],
+				isError: true
+			};
+		}
+		if (!lockfile.skills || Object.keys(lockfile.skills).length === 0) return { content: [{
+			type: "text",
+			text: "No skills installed. The lockfile is empty."
+		}] };
+		const resolved = collectPermissions(lockfile);
+		const lines = [];
+		lines.push("Resolved permissions for this project:");
+		lines.push("");
+		lines.push(formatSection("Network (outbound)", resolved.networkOutbound));
+		lines.push(formatSection("Filesystem (read)", resolved.filesystemRead));
+		lines.push(formatSection("Filesystem (write)", resolved.filesystemWrite));
+		lines.push("Subprocess:");
+		if (resolved.subprocess.length === 0) lines.push("  none");
+		else lines.push(`  allowed    ${formatAttribution(resolved.subprocess)}`);
+		if (resolved.env.length > 0) lines.push(formatSection("Environment variables", resolved.env));
+		if (resolved.exec.length > 0) lines.push(formatSection("Exec", resolved.exec));
+		lines.push("");
+		lines.push("Per-skill breakdown:");
+		for (const [key, entry] of Object.entries(lockfile.skills)) {
+			const skillName = parseSkillName(key);
+			const perms = entry.permissions;
+			const permParts = [];
+			if (perms.network?.outbound && perms.network.outbound.length > 0) permParts.push(`network: ${perms.network.outbound.join(", ")}`);
+			if (perms.filesystem?.read && perms.filesystem.read.length > 0) permParts.push(`filesystem:read: ${perms.filesystem.read.join(", ")}`);
+			if (perms.filesystem?.write && perms.filesystem.write.length > 0) permParts.push(`filesystem:write: ${perms.filesystem.write.join(", ")}`);
+			if (perms.subprocess === true) permParts.push("subprocess: allowed");
+			const rawPerms = perms;
+			if (Array.isArray(rawPerms.env) && rawPerms.env.length > 0) permParts.push(`env: ${rawPerms.env.join(", ")}`);
+			if (Array.isArray(rawPerms.exec) && rawPerms.exec.length > 0) permParts.push(`exec: ${rawPerms.exec.join(", ")}`);
+			if (permParts.length === 0) lines.push(`  ${skillName}: no special permissions`);
+			else lines.push(`  ${skillName}: ${permParts.join("; ")}`);
+		}
+		const budget = skillsJson.permissions;
+		lines.push("");
+		if (!budget) lines.push("Budget status: No budget defined");
+		else {
+			const violations = checkBudget(resolved, budget);
+			if (violations.length === 0) lines.push("Budget status: PASS (all within budget)");
+			else {
+				lines.push("Budget status: FAIL");
+				for (const v of violations) lines.push(`  - ${v.category}: "${v.value}" not in budget (requested by ${v.skills.join(", ")})`);
+			}
+		}
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	});
+}
+//#endregion
+//#region src/tools/unlink-skill.ts
+const SCOPED_NAME_PATTERN$1 = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+function registerUnlinkSkillTool(server) {
+	server.tool("unlink-skill", "Unlink a skill from an agent workspace. Removes the symlink without deleting the installed skill files.", {
+		name: z.string().describe("Skill name in @org/name format"),
+		workspace: z.string().describe("Agent workspace directory path"),
+		directory: z.string().optional().describe("Project directory where skills are installed (defaults to current working directory)")
+	}, async ({ name, workspace, directory }) => {
+		if (!SCOPED_NAME_PATTERN$1.test(name)) return {
+			content: [{
+				type: "text",
+				text: `Validation error: Skill name "${name}" must use the @org/name format (e.g. @acme/my-skill).`
+			}],
+			isError: true
+		};
+		const projectDir = directory ? path.resolve(directory) : process.cwd();
+		const workspaceDir = path.resolve(workspace);
+		if (!fs.existsSync(workspaceDir)) return {
+			content: [{
+				type: "text",
+				text: `Error: Workspace directory does not exist: ${workspaceDir}`
+			}],
+			isError: true
+		};
+		const skillDir = getSkillDir$1(projectDir, name);
+		if (!fs.existsSync(skillDir)) return {
+			content: [{
+				type: "text",
+				text: `Skill "${name}" is not installed. It was not found in ${skillDir}.`
+			}],
+			isError: true
+		};
+		const [scope, skillName] = name.split("/");
+		const symlinkPath = path.join(workspaceDir, ".skills", scope, skillName);
+		try {
+			if (fs.lstatSync(symlinkPath).isSymbolicLink()) {
+				fs.unlinkSync(symlinkPath);
+				return { content: [{
+					type: "text",
+					text: `Successfully unlinked "${name}" from ${workspaceDir}.\nRemoved symlink: ${symlinkPath}`
+				}] };
+			}
+		} catch {}
+		return { content: [{
+			type: "text",
+			text: `No link exists for "${name}" in ${workspaceDir}.`
+		}] };
+	});
+}
+function getSkillDir$1(projectDir, skillName) {
+	if (skillName.startsWith("@")) {
+		const [scope, name] = skillName.split("/");
+		return path.join(projectDir, ".tank", "skills", scope, name);
+	}
+	return path.join(projectDir, ".tank", "skills", skillName);
+}
+//#endregion
+//#region src/tools/update-skill.ts
+const SCOPED_NAME_PATTERN = /^@[a-z0-9-]+\/[a-z0-9][a-z0-9-]*$/;
+function parseLockKey$1(key) {
+	const lastAt = key.lastIndexOf("@");
+	if (lastAt <= 0) return null;
+	return {
+		name: key.slice(0, lastAt),
+		version: key.slice(lastAt + 1)
+	};
+}
+function registerUpdateSkillTool(server) {
+	server.tool("update-skill", "Update an installed skill to the latest compatible version within its declared semver range.", {
+		name: z.string().describe("Skill name in @org/name format"),
+		directory: z.string().optional().describe("Project directory (defaults to current working directory)")
+	}, async ({ name, directory }) => {
+		if (!SCOPED_NAME_PATTERN.test(name)) return {
+			content: [{
+				type: "text",
+				text: `Validation error: Skill name "${name}" must use the @org/name format (e.g. @acme/my-skill).`
+			}],
+			isError: true
+		};
+		const dir = directory ? path.resolve(directory) : process.cwd();
+		let skillsJsonPath = path.join(dir, MANIFEST_FILENAME);
+		if (!fs.existsSync(skillsJsonPath)) skillsJsonPath = path.join(dir, LEGACY_MANIFEST_FILENAME);
+		if (!fs.existsSync(skillsJsonPath)) return {
+			content: [{
+				type: "text",
+				text: `No ${MANIFEST_FILENAME} found in ${dir}. Run the "init-skill" tool first.`
+			}],
+			isError: true
+		};
+		let skillsJson;
+		try {
+			const raw = fs.readFileSync(skillsJsonPath, "utf-8");
+			skillsJson = JSON.parse(raw);
+		} catch {
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to read or parse ${path.basename(skillsJsonPath)}.`
+				}],
+				isError: true
+			};
+		}
+		const versionRange = (skillsJson.skills ?? {})[name];
+		if (!versionRange) return {
+			content: [{
+				type: "text",
+				text: `Skill "${name}" is not installed (not found in ${path.basename(skillsJsonPath)}). Install it first with the install-skill tool.`
+			}],
+			isError: true
+		};
+		let lockPath = path.join(dir, LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockPath)) lockPath = path.join(dir, LEGACY_LOCKFILE_FILENAME);
+		let currentVersion = null;
+		if (fs.existsSync(lockPath)) try {
+			const raw = fs.readFileSync(lockPath, "utf-8");
+			const lock = JSON.parse(raw);
+			for (const key of Object.keys(lock.skills)) {
+				const parsed = parseLockKey$1(key);
+				if (!parsed) continue;
+				if (parsed.name === name) {
+					currentVersion = parsed.version;
+					break;
+				}
+			}
+		} catch {}
+		if (!currentVersion) return {
+			content: [{
+				type: "text",
+				text: `Skill "${name}" is not installed (not found in ${LOCKFILE_FILENAME}). Install it first with the install-skill tool.`
+			}],
+			isError: true
+		};
+		const client = new TankApiClient();
+		if (!client.isAuthenticated) return {
+			content: [{
+				type: "text",
+				text: "Authentication required. Please run the \"login\" tool first to authenticate with Tank."
+			}],
+			isError: true
+		};
+		const encodedName = encodeURIComponent(name);
+		const versionsResult = await client.fetch(`/api/v1/skills/${encodedName}/versions`);
+		if (!versionsResult.ok) {
+			if (versionsResult.status === 0) return {
+				content: [{
+					type: "text",
+					text: `Unable to connect to the Tank registry. Check your network connection and try again.`
+				}],
+				isError: true
+			};
+			if (versionsResult.status === 404) return {
+				content: [{
+					type: "text",
+					text: `Skill "${name}" not found in the registry.`
+				}],
+				isError: true
+			};
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to fetch versions for ${name}: ${versionsResult.error}`
+				}],
+				isError: true
+			};
+		}
+		const availableVersions = versionsResult.data.versions.map((v) => v.version);
+		const resolved = resolve(versionRange, availableVersions);
+		if (!resolved) return {
+			content: [{
+				type: "text",
+				text: `No version of ${name} satisfies range "${versionRange}". Available: ${availableVersions.join(", ")}`
+			}],
+			isError: true
+		};
+		const allMajors = availableVersions.map((v) => {
+			const major = v.split(".")[0];
+			return {
+				version: v,
+				major: Number.parseInt(major, 10)
+			};
+		}).filter((v) => !Number.isNaN(v.major));
+		const currentMajor = Number.parseInt(currentVersion.split(".")[0], 10);
+		const newerMajors = allMajors.filter((v) => v.major > currentMajor).map((v) => v.version);
+		const highestOutOfRange = newerMajors.length > 0 ? newerMajors.sort((a, b) => {
+			const [aMaj, aMin, aPat] = a.split(".").map(Number);
+			const [bMaj, bMin, bPat] = b.split(".").map(Number);
+			return bMaj - aMaj || bMin - aMin || bPat - aPat;
+		})[0] : null;
+		if (resolved === currentVersion) {
+			const lines = [`Already at latest compatible version: ${name}@${resolved}`];
+			if (highestOutOfRange) lines.push(`\nNote: Version ${highestOutOfRange} is available but outside the declared range "${versionRange}". Update ${MANIFEST_FILENAME} to use it.`);
+			return { content: [{
+				type: "text",
+				text: lines.join("")
+			}] };
+		}
+		const versionResult = await client.fetch(`/api/v1/skills/${encodedName}/${resolved}`);
+		if (!versionResult.ok) return {
+			content: [{
+				type: "text",
+				text: `Failed to fetch version details for ${name}@${resolved}: ${versionResult.error}`
+			}],
+			isError: true
+		};
+		const versionData = versionResult.data;
+		let tarballBuffer;
+		try {
+			const tarballRes = await fetch(versionData.downloadUrl, { headers: client.token ? { Authorization: `Bearer ${client.token}` } : {} });
+			if (!tarballRes.ok) return {
+				content: [{
+					type: "text",
+					text: `Failed to download tarball for ${name}@${resolved}: ${tarballRes.statusText}`
+				}],
+				isError: true
+			};
+			tarballBuffer = await tarballRes.arrayBuffer();
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Network error downloading ${name}@${resolved}: ${err instanceof Error ? err.message : String(err)}`
+				}],
+				isError: true
+			};
+		}
+		const { createHash } = await import("node:crypto");
+		const computedIntegrity = `sha512-${createHash("sha512").update(Buffer.from(tarballBuffer)).digest("base64")}`;
+		if (computedIntegrity !== versionData.integrity) return {
+			content: [{
+				type: "text",
+				text: `Integrity check failed for ${name}@${resolved}. The tarball has been tampered with or is corrupted.\nExpected: ${versionData.integrity}\nGot: ${computedIntegrity}`
+			}],
+			isError: true
+		};
+		const { execSync } = await import("node:child_process");
+		const skillDir = getSkillDir(dir, name);
+		if (fs.existsSync(skillDir)) fs.rmSync(skillDir, {
+			recursive: true,
+			force: true
+		});
+		fs.mkdirSync(skillDir, { recursive: true });
+		const tarballPath = path.join(skillDir, "__temp_tarball.tgz");
+		fs.writeFileSync(tarballPath, Buffer.from(tarballBuffer));
+		try {
+			execSync(`tar xzf "${tarballPath}" -C "${skillDir}" --strip-components=1`, { stdio: "pipe" });
+		} catch (err) {
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to extract tarball for ${name}@${resolved}: ${err instanceof Error ? err.message : String(err)}`
+				}],
+				isError: true
+			};
+		} finally {
+			try {
+				fs.unlinkSync(tarballPath);
+			} catch {}
+		}
+		let lock;
+		if (fs.existsSync(lockPath)) try {
+			const raw = fs.readFileSync(lockPath, "utf-8");
+			lock = JSON.parse(raw);
+		} catch {
+			lock = {
+				lockfileVersion: 1,
+				skills: {}
+			};
+		}
+		else lock = {
+			lockfileVersion: 1,
+			skills: {}
+		};
+		for (const key of Object.keys(lock.skills)) {
+			const parsed = parseLockKey$1(key);
+			if (parsed && parsed.name === name) delete lock.skills[key];
+		}
+		const newLockKey = `${name}@${resolved}`;
+		lock.skills[newLockKey] = {
+			resolved: versionData.downloadUrl,
+			integrity: versionData.integrity,
+			permissions: versionData.permissions,
+			audit_score: versionData.auditScore
+		};
+		const sortedSkills = {};
+		for (const key of Object.keys(lock.skills).sort()) sortedSkills[key] = lock.skills[key];
+		lock.skills = sortedSkills;
+		fs.writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`);
+		const lines = [
+			`Updated ${name} from ${currentVersion} to ${resolved}.`,
+			`Integrity verified (SHA-512).`,
+			`Lockfile updated.`
+		];
+		if (highestOutOfRange) lines.push(`\nNote: Version ${highestOutOfRange} is available but outside the declared range "${versionRange}". Update ${MANIFEST_FILENAME} to use it.`);
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	});
+}
+function getSkillDir(projectDir, skillName) {
+	if (skillName.startsWith("@")) {
+		const [scope, name] = skillName.split("/");
+		return path.join(projectDir, ".tank", "skills", scope, name);
+	}
+	return path.join(projectDir, ".tank", "skills", skillName);
+}
+//#endregion
+//#region src/tools/verify-skills.ts
+function registerVerifySkillsTool(server) {
+	server.tool("verify-skills", "Verify that installed skills match their lockfile entries. Checks that skill directories exist and are not empty.", {
+		name: z.string().optional().describe("Specific skill name to verify (verifies all if omitted)"),
+		directory: z.string().optional().describe("Project directory (defaults to current working directory)")
+	}, async ({ name, directory }) => {
+		const dir = directory ? path.resolve(directory) : process.cwd();
+		let lockPath = path.join(dir, LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockPath)) lockPath = path.join(dir, LEGACY_LOCKFILE_FILENAME);
+		if (!fs.existsSync(lockPath)) return {
+			content: [{
+				type: "text",
+				text: `No ${LOCKFILE_FILENAME} found. Run "install-skill" to install skills and generate a lockfile.`
+			}],
+			isError: true
+		};
+		let lock;
+		try {
+			const raw = fs.readFileSync(lockPath, "utf-8");
+			lock = JSON.parse(raw);
+		} catch {
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to parse ${path.basename(lockPath)}. The file may be corrupted.`
+				}],
+				isError: true
+			};
+		}
+		let entries = Object.entries(lock.skills);
+		if (entries.length === 0) return { content: [{
+			type: "text",
+			text: "No skills to verify. The lockfile is empty."
+		}] };
+		if (name) {
+			entries = entries.filter(([key]) => {
+				const lastAt = key.lastIndexOf("@");
+				if (lastAt <= 0) return false;
+				return key.slice(0, lastAt) === name;
+			});
+			if (entries.length === 0) return {
+				content: [{
+					type: "text",
+					text: `Skill "${name}" not found in lockfile.`
+				}],
+				isError: true
+			};
+		}
+		const results = [];
+		for (const [key, entry] of entries) {
+			const skillDir = getExtractDir(dir, parseLockKey(key));
+			if (!fs.existsSync(skillDir)) {
+				results.push({
+					key,
+					status: "MISSING",
+					detail: `Directory missing at ${skillDir}. Reinstall with "install-skill".`
+				});
+				continue;
+			}
+			if (fs.readdirSync(skillDir).length === 0) {
+				results.push({
+					key,
+					status: "FAIL",
+					detail: `Directory exists but is empty. Expected integrity: ${entry.integrity}. SHA-512 mismatch detected.`
+				});
+				continue;
+			}
+			results.push({
+				key,
+				status: "PASS",
+				detail: `Verified (integrity: ${entry.integrity})`
+			});
+		}
+		const passing = results.filter((r) => r.status === "PASS");
+		const failing = results.filter((r) => r.status !== "PASS");
+		const lines = [];
+		for (const r of results) lines.push(`${r.status} ${r.key}: ${r.detail}`);
+		if (failing.length > 0) {
+			lines.push("");
+			lines.push(`Verification failed: ${failing.length} issue(s) found, ${passing.length} passed.`);
+			return {
+				content: [{
+					type: "text",
+					text: lines.join("\n")
+				}],
+				isError: true
+			};
+		}
+		lines.push("");
+		lines.push(`All ${passing.length} skill(s) passed verification.`);
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	});
+}
+function parseLockKey(key) {
+	const lastAt = key.lastIndexOf("@");
+	if (lastAt <= 0) return key;
+	return key.slice(0, lastAt);
+}
+function getExtractDir(projectDir, skillName) {
+	if (skillName.startsWith("@")) {
+		const [scope, name] = skillName.split("/");
+		return path.join(projectDir, ".tank", "skills", scope, name);
+	}
+	return path.join(projectDir, ".tank", "skills", skillName);
+}
+//#endregion
+//#region src/tools/whoami.ts
+function registerWhoamiTool(server) {
+	server.tool("whoami", "Show the authenticated Tank user for the current local session.", {}, async () => {
+		const client = new TankApiClient();
+		if (!client.isAuthenticated) return { content: [{
+			type: "text",
+			text: "Not logged in. Use the login tool to authenticate."
+		}] };
+		const authCheck = await client.verifyAuth();
+		if (authCheck.valid) return { content: [{
+			type: "text",
+			text: `Logged in as ${authCheck.user.name ?? "unknown"}\nEmail: ${authCheck.user.email ?? "unknown"}`
+		}] };
+		if (authCheck.reason === "network-error") return {
+			content: [{
+				type: "text",
+				text: `Failed to connect to the registry. Check your network connection.\nError: ${authCheck.error ?? "unknown"}`
+			}],
+			isError: true
+		};
+		return { content: [{
+			type: "text",
+			text: "Session expired or invalid. Use the login tool to re-authenticate."
+		}] };
+	});
+}
+//#endregion
+//#region src/index.ts
 const server = new McpServer({
-    name: 'tank',
-    version: '0.1.0',
+	name: "tank",
+	version: "0.1.0"
 });
-// Register all tools
 registerLoginTool(server);
 registerSearchSkillsTool(server);
 registerSkillInfoTool(server);
@@ -42,13 +2226,15 @@ registerSkillPermissionsTool(server);
 registerInstallSkillTool(server);
 registerUpdateSkillTool(server);
 registerAuditSkillTool(server);
-// Start stdio transport
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
 }
 main().catch((error) => {
-    console.error('MCP server error:', error);
-    process.exit(1);
+	console.error("MCP server error:", error);
+	process.exit(1);
 });
+//#endregion
+export {};
+
 //# sourceMappingURL=index.js.map