@i4ctime/q-ring 0.9.7 → 0.10.1

package/dist/mcp.js

@@ -3,6 +3,7 @@ import {
   checkDecay,
   checkExecPolicy,
   checkKeyReadPolicy,
+  checkSSRF,
   checkToolPolicy,
   collapseEnvironment,
   deleteSecret,
@@ -17,7 +18,7 @@ import {
   getPolicySummary,
   getSecret,
   hasSecret,
-  httpRequest_,
+  httpRequest,
   listHooks,
   listSecrets,
   logAudit,
@@ -32,14 +33,51 @@ import {
   tunnelList,
   tunnelRead,
   verifyAuditChain
-} from "./chunk-5JBU7TWN.js";
+} from "./chunk-E46HG5NM.js";
 
 // src/mcp.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
+
+// src/version.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function readPackageVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(here, "..", "package.json");
+    const raw = readFileSync(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var PACKAGE_VERSION = readPackageVersion();
+
+// src/mcp/tools/secrets.ts
+import { z as z2 } from "zod";
+
+// src/services/list-secrets-filter.ts
+function globKeyPatternToRegexSource(pattern) {
+  let out = "";
+  for (const c2 of pattern) {
+    if (c2 === "*") out += ".*";
+    else if (c2 === "?") out += ".";
+    else if ("\\^$+{}()|[]".includes(c2)) out += "\\" + c2;
+    else if (c2 === ".") out += "\\.";
+    else out += c2;
+  }
+  return out;
+}
+function filterSecretsByKeyGlob(entries, filter) {
+  if (!filter?.trim()) return entries;
+  const regex = new RegExp("^" + globKeyPatternToRegexSource(filter) + "$", "i");
+  return entries.filter((e) => regex.test(e.key));
+}
 
 // src/core/noise.ts
 import { randomBytes, randomInt } from "crypto";
@@ -124,150 +162,8 @@ function estimateEntropy(secret) {
   return poolSize > 0 ? Math.floor(Math.log2(poolSize) * secret.length) : 0;
 }
 
-// src/utils/colors.ts
-var enabled = process.stdout.isTTY !== false && !process.env.NO_COLOR;
-
-// src/core/agent.ts
-function defaultConfig() {
-  return {
-    intervalSeconds: 60,
-    autoRotate: false,
-    projectPaths: [process.cwd()],
-    verbose: false
-  };
-}
-function runHealthScan(config = {}) {
-  const cfg = { ...defaultConfig(), ...config };
-  const report = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    totalSecrets: 0,
-    healthy: 0,
-    stale: 0,
-    expired: 0,
-    anomalies: 0,
-    rotated: [],
-    warnings: []
-  };
-  const globalEntries = listSecrets({ scope: "global", source: "agent" });
-  const projectEntries = cfg.projectPaths.flatMap(
-    (pp) => listSecrets({ scope: "project", projectPath: pp, source: "agent" })
-  );
-  const allEntries = [...globalEntries, ...projectEntries];
-  report.totalSecrets = allEntries.length;
-  for (const entry of allEntries) {
-    if (!entry.envelope) continue;
-    const decay = checkDecay(entry.envelope);
-    if (decay.isExpired) {
-      report.expired++;
-      report.warnings.push(
-        `EXPIRED: ${entry.key} [${entry.scope}] \u2014 expired ${decay.timeRemaining}`
-      );
-      if (cfg.autoRotate) {
-        const fmt = entry.envelope?.meta.rotationFormat ?? "api-key";
-        const prefix = entry.envelope?.meta.rotationPrefix;
-        const newValue = generateSecret({ format: fmt, prefix });
-        setSecret(entry.key, newValue, {
-          scope: entry.scope,
-          projectPath: cfg.projectPaths[0],
-          source: "agent"
-        });
-        report.rotated.push(entry.key);
-        logAudit({
-          action: "write",
-          key: entry.key,
-          scope: entry.scope,
-          source: "agent",
-          detail: "auto-rotated by agent (expired)"
-        });
-        fireHooks({
-          action: "rotate",
-          key: entry.key,
-          scope: entry.scope,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          source: "agent"
-        }, entry.envelope?.meta.tags).catch(() => {
-        });
-      }
-    } else if (decay.isStale) {
-      report.stale++;
-      report.warnings.push(
-        `STALE: ${entry.key} [${entry.scope}] \u2014 ${decay.lifetimePercent}% lifetime, ${decay.timeRemaining} remaining`
-      );
-    } else {
-      report.healthy++;
-    }
-  }
-  const anomalies = detectAnomalies();
-  report.anomalies = anomalies.length;
-  for (const a of anomalies) {
-    report.warnings.push(`ANOMALY [${a.type}]: ${a.description}`);
-  }
-  return report;
-}
-
-// src/core/teleport.ts
-import {
-  randomBytes as randomBytes2,
-  createCipheriv,
-  createDecipheriv,
-  pbkdf2Sync
-} from "crypto";
-var ALGORITHM = "aes-256-gcm";
-var KEY_LENGTH = 32;
-var IV_LENGTH = 16;
-var SALT_LENGTH = 32;
-var PBKDF2_ITERATIONS = 1e5;
-function deriveKey(passphrase, salt) {
-  return pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha512");
-}
-function teleportPack(secrets, passphrase) {
-  const payload = {
-    secrets,
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const plaintext = JSON.stringify(payload);
-  const salt = randomBytes2(SALT_LENGTH);
-  const iv = randomBytes2(IV_LENGTH);
-  const key = deriveKey(passphrase, salt);
-  const cipher = createCipheriv(ALGORITHM, key, iv);
-  const encrypted = Buffer.concat([
-    cipher.update(plaintext, "utf8"),
-    cipher.final()
-  ]);
-  const tag = cipher.getAuthTag();
-  const bundle = {
-    v: 1,
-    data: encrypted.toString("base64"),
-    salt: salt.toString("base64"),
-    iv: iv.toString("base64"),
-    tag: tag.toString("base64"),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    count: secrets.length
-  };
-  return Buffer.from(JSON.stringify(bundle)).toString("base64");
-}
-function teleportUnpack(encoded, passphrase) {
-  const bundleJson = Buffer.from(encoded, "base64").toString("utf8");
-  const bundle = JSON.parse(bundleJson);
-  if (bundle.v !== 1) {
-    throw new Error(`Unsupported teleport bundle version: ${bundle.v}`);
-  }
-  const salt = Buffer.from(bundle.salt, "base64");
-  const iv = Buffer.from(bundle.iv, "base64");
-  const tag = Buffer.from(bundle.tag, "base64");
-  const encrypted = Buffer.from(bundle.data, "base64");
-  const key = deriveKey(passphrase, salt);
-  const decipher = createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(tag);
-  const decrypted = Buffer.concat([
-    decipher.update(encrypted),
-    decipher.final()
-  ]);
-  return JSON.parse(decrypted.toString("utf8"));
-}
-
 // src/core/import.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 function parseDotenv(content) {
   const result = /* @__PURE__ */ new Map();
   const lines = content.split(/\r?\n/);
@@ -299,7 +195,7 @@ function parseDotenv(content) {
 function importDotenv(filePathOrContent, options = {}) {
   let content;
   try {
-    content = readFileSync(filePathOrContent, "utf8");
+    content = readFileSync2(filePathOrContent, "utf8");
   } catch {
     content = filePathOrContent;
   }
@@ -333,442 +229,444 @@ function importDotenv(filePathOrContent, options = {}) {
   return result;
 }
 
-// src/core/exec.ts
-import { spawn } from "child_process";
-import { Transform } from "stream";
-var BUILTIN_PROFILES = {
-  unrestricted: { name: "unrestricted" },
-  restricted: {
-    name: "restricted",
-    denyCommands: ["curl", "wget", "ssh", "scp", "nc", "netcat", "ncat"],
-    maxRuntimeSeconds: 30,
-    allowNetwork: false,
-    stripEnvVars: ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY"]
-  },
-  ci: {
-    name: "ci",
-    maxRuntimeSeconds: 300,
-    allowNetwork: true,
-    denyCommands: ["rm -rf /", "mkfs", "dd if="]
-  }
-};
-function getProfile(name) {
-  if (!name) return BUILTIN_PROFILES.unrestricted;
-  return BUILTIN_PROFILES[name] ?? { name };
+// src/mcp/tools/_shared.ts
+import { z } from "zod";
+function text(t, isError = false) {
+  return {
+    content: [{ type: "text", text: t }],
+    ...isError ? { isError: true } : {}
+  };
 }
-var RedactionTransform = class extends Transform {
-  patterns = [];
-  tail = "";
-  maxLen = 0;
-  constructor(secretsToRedact) {
-    super();
-    const validSecrets = secretsToRedact.filter((s) => s.length > 5);
-    validSecrets.sort((a, b) => b.length - a.length);
-    this.patterns = validSecrets.map((s) => ({
-      value: s,
-      replacement: "[QRING:REDACTED]"
-    }));
-    if (validSecrets.length > 0) {
-      this.maxLen = validSecrets[0].length;
-    }
-  }
-  _transform(chunk, encoding, callback) {
-    if (this.patterns.length === 0) {
-      this.push(chunk);
-      return callback();
-    }
-    const text2 = this.tail + chunk.toString();
-    let redacted = text2;
-    for (const { value, replacement } of this.patterns) {
-      redacted = redacted.split(value).join(replacement);
-    }
-    if (redacted.length < this.maxLen) {
-      this.tail = redacted;
-      return callback();
-    }
-    const outputLen = redacted.length - this.maxLen + 1;
-    const output = redacted.slice(0, outputLen);
-    this.tail = redacted.slice(outputLen);
-    this.push(output);
-    callback();
+function opts(params) {
+  return {
+    scope: params.scope,
+    projectPath: params.projectPath ?? process.cwd(),
+    teamId: params.teamId,
+    orgId: params.orgId,
+    env: params.env,
+    source: "mcp"
+  };
+}
+function enforceToolPolicy(toolName, projectPath8) {
+  const decision = checkToolPolicy(toolName, projectPath8);
+  if (!decision.allowed) {
+    return text(
+      `Policy Denied: ${decision.reason} (source: ${decision.policySource})`,
+      true
+    );
   }
-  _flush(callback) {
-    if (this.tail) {
-      let final = this.tail;
-      for (const { value, replacement } of this.patterns) {
-        final = final.split(value).join(replacement);
+  return null;
+}
+var commonSchemas = {
+  teamId: z.string().optional().describe("Team identifier for team-scoped secrets"),
+  orgId: z.string().optional().describe("Org identifier for org-scoped secrets"),
+  scope: z.enum(["global", "project", "team", "org"]).optional().describe("Scope: global, project, team, or org"),
+  projectPath: z.string().optional().describe("Project root path for project-scoped secrets"),
+  env: z.string().optional().describe("Environment for superposition collapse (e.g., dev, staging, prod)")
+};
+
+// src/mcp/tools/secrets.ts
+var { teamId, orgId, scope, projectPath, env } = commonSchemas;
+function registerSecretTools(server2) {
+  server2.tool(
+    "get_secret",
+    "[secrets] Retrieve a secret by key. Collapses superposition if the secret has multiple environment states. Records access in audit log (observer effect).",
+    {
+      key: z2.string().describe("The secret key name"),
+      scope,
+      projectPath,
+      env,
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("get_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
+      try {
+        const keyBlock = checkKeyReadPolicy(
+          params.key,
+          void 0,
+          params.projectPath
+        );
+        if (!keyBlock.allowed) {
+          return text(`Policy Denied: ${keyBlock.reason}`, true);
+        }
+        const value = getSecret(params.key, opts(params));
+        if (value === null) return text(`Secret "${params.key}" not found`, true);
+        return text(
+          JSON.stringify({ ok: true, data: { key: params.key, value } }, null, 2)
+        );
+      } catch (err) {
+        return text(err instanceof Error ? err.message : String(err), true);
       }
-      this.push(final);
     }
-    callback();
-  }
-};
-async function execCommand(opts2) {
-  const profile = getProfile(opts2.profile);
-  const fullCommand = [opts2.command, ...opts2.args].join(" ");
-  const policyDecision = checkExecPolicy(fullCommand, opts2.projectPath);
-  if (!policyDecision.allowed) {
-    throw new Error(`Policy Denied: ${policyDecision.reason}`);
-  }
-  if (profile.denyCommands) {
-    const denied = profile.denyCommands.find((d) => fullCommand.includes(d));
-    if (denied) {
-      throw new Error(`Exec profile "${profile.name}" denies command containing "${denied}"`);
-    }
-  }
-  if (profile.allowCommands) {
-    const allowed = profile.allowCommands.some((a) => fullCommand.startsWith(a));
-    if (!allowed) {
-      throw new Error(`Exec profile "${profile.name}" does not allow command "${opts2.command}"`);
-    }
-  }
-  const envMap = {};
-  for (const [k, v] of Object.entries(process.env)) {
-    if (v !== void 0) envMap[k] = v;
-  }
-  if (profile.stripEnvVars) {
-    for (const key of profile.stripEnvVars) {
-      delete envMap[key];
-    }
-  }
-  const secretsToRedact = /* @__PURE__ */ new Set();
-  let entries = listSecrets({
-    scope: opts2.scope,
-    projectPath: opts2.projectPath,
-    source: opts2.source ?? "cli",
-    silent: true
-    // list silently
-  });
-  if (opts2.keys?.length) {
-    const keySet = new Set(opts2.keys);
-    entries = entries.filter((e) => keySet.has(e.key));
-  }
-  if (opts2.tags?.length) {
-    entries = entries.filter(
-      (e) => opts2.tags.some((t) => e.envelope?.meta.tags?.includes(t))
-    );
-  }
-  for (const entry of entries) {
-    if (entry.envelope) {
-      const decay = checkDecay(entry.envelope);
-      if (decay.isExpired) continue;
-    }
-    const val = getSecret(entry.key, {
-      scope: entry.scope,
-      projectPath: opts2.projectPath,
-      env: opts2.env,
-      source: opts2.source ?? "cli",
-      silent: false
-      // Log access for execution
-    });
-    if (val !== null) {
-      envMap[entry.key] = val;
-      if (val.length > 5) {
-        secretsToRedact.add(val);
+  );
+  server2.tool(
+    "list_secrets",
+    "[secrets] List all secret keys with quantum metadata (scope, decay status, superposition states, entanglement, access count). Values are never exposed. Supports filtering by tag, expiry state, and key pattern.",
+    {
+      scope,
+      projectPath,
+      tag: z2.string().optional().describe("Filter by tag"),
+      expired: z2.boolean().optional().describe("Show only expired secrets"),
+      stale: z2.boolean().optional().describe("Show only stale secrets (75%+ decay)"),
+      filter: z2.string().optional().describe("Glob pattern on key name (e.g., 'API_*')"),
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("list_secrets", params.projectPath);
+      if (toolBlock) return toolBlock;
+      let entries = listSecrets(opts(params));
+      if (params.tag) {
+        entries = entries.filter(
+          (e) => e.envelope?.meta.tags?.includes(params.tag)
+        );
+      }
+      if (params.expired) {
+        entries = entries.filter((e) => e.decay?.isExpired);
       }
+      if (params.stale) {
+        entries = entries.filter(
+          (e) => e.decay?.isStale && !e.decay?.isExpired
+        );
+      }
+      if (params.filter) {
+        entries = filterSecretsByKeyGlob(entries, params.filter);
+      }
+      const rows = entries.map((e) => ({
+        scope: e.scope,
+        key: e.key,
+        stateKeys: e.envelope?.states ? Object.keys(e.envelope.states) : void 0,
+        expired: !!e.decay?.isExpired,
+        stale: !!e.decay?.isStale && !e.decay?.isExpired,
+        lifetimePercent: e.decay?.lifetimePercent,
+        timeRemaining: e.decay?.timeRemaining ?? null,
+        entangledCount: e.envelope?.meta.entangled?.length ?? 0,
+        accessCount: e.envelope?.meta.accessCount ?? 0
+      }));
+      return text(JSON.stringify({ ok: true, data: { entries: rows } }, null, 2));
     }
-  }
-  const maxRuntime = profile.maxRuntimeSeconds ?? getExecMaxRuntime(opts2.projectPath);
-  return new Promise((resolve, reject) => {
-    const networkTools = /* @__PURE__ */ new Set([
-      "curl",
-      "wget",
-      "ping",
-      "nc",
-      "netcat",
-      "ssh",
-      "telnet",
-      "ftp",
-      "dig",
-      "nslookup"
-    ]);
-    if (profile.allowNetwork === false && networkTools.has(opts2.command)) {
-      const msg = `[QRING] Execution blocked: network access is disabled for profile "${profile.name}", command "${opts2.command}" is considered network-related`;
-      if (opts2.captureOutput) {
-        return resolve({ code: 126, stdout: "", stderr: msg });
+  );
+  server2.tool(
+    "set_secret",
+    "[secrets] Store a secret with optional quantum metadata: TTL (decay), environment state (superposition), description, tags.",
+    {
+      key: z2.string().describe("The secret key name"),
+      value: z2.string().describe("The secret value"),
+      scope: scope.default("global"),
+      projectPath,
+      env: z2.string().optional().describe(
+        "If provided, sets the value for this specific environment (superposition)"
+      ),
+      ttlSeconds: z2.number().optional().describe("Time-to-live in seconds (quantum decay)"),
+      description: z2.string().optional().describe("Human-readable description"),
+      tags: z2.array(z2.string()).optional().describe("Tags for organization"),
+      rotationFormat: z2.enum([
+        "hex",
+        "base64",
+        "alphanumeric",
+        "uuid",
+        "api-key",
+        "token",
+        "password"
+      ]).optional().describe("Format for auto-rotation when this secret expires"),
+      rotationPrefix: z2.string().optional().describe("Prefix for auto-rotation (e.g. 'sk-')"),
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("set_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const o = opts(params);
+      if (params.env) {
+        const existing = getEnvelope(params.key, o);
+        const states = existing?.envelope?.states ?? {};
+        states[params.env] = params.value;
+        if (existing?.envelope?.value && !states["default"]) {
+          states["default"] = existing.envelope.value;
+        }
+        setSecret(params.key, "", {
+          ...o,
+          states,
+          defaultEnv: existing?.envelope?.defaultEnv ?? params.env,
+          ttlSeconds: params.ttlSeconds,
+          description: params.description,
+          tags: params.tags,
+          rotationFormat: params.rotationFormat,
+          rotationPrefix: params.rotationPrefix
+        });
+        return text(
+          `[${params.scope ?? "global"}] ${params.key} set for env:${params.env}`
+        );
       }
-      process.stderr.write(msg + "\n");
-      return resolve({ code: 126, stdout: "", stderr: "" });
+      setSecret(params.key, params.value, {
+        ...o,
+        ttlSeconds: params.ttlSeconds,
+        description: params.description,
+        tags: params.tags,
+        rotationFormat: params.rotationFormat,
+        rotationPrefix: params.rotationPrefix
+      });
+      return text(`[${params.scope ?? "global"}] ${params.key} saved`);
     }
-    const child = spawn(opts2.command, opts2.args, {
-      env: envMap,
-      stdio: ["inherit", "pipe", "pipe"],
-      shell: false
-    });
-    let timedOut = false;
-    let timer;
-    if (maxRuntime) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        child.kill("SIGKILL");
-      }, maxRuntime * 1e3);
+  );
+  server2.tool(
+    "delete_secret",
+    "[secrets] Remove a secret from the keyring.",
+    {
+      key: z2.string().describe("The secret key name"),
+      scope,
+      projectPath,
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("delete_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const deleted = deleteSecret(params.key, opts(params));
+      return text(
+        deleted ? `Deleted "${params.key}"` : `Secret "${params.key}" not found`,
+        !deleted
+      );
     }
-    const stdoutRedact = new RedactionTransform([...secretsToRedact]);
-    const stderrRedact = new RedactionTransform([...secretsToRedact]);
-    if (child.stdout) child.stdout.pipe(stdoutRedact);
-    if (child.stderr) child.stderr.pipe(stderrRedact);
-    let stdoutStr = "";
-    let stderrStr = "";
-    if (opts2.captureOutput) {
-      stdoutRedact.on("data", (d) => stdoutStr += d.toString());
-      stderrRedact.on("data", (d) => stderrStr += d.toString());
-    } else {
-      stdoutRedact.pipe(process.stdout);
-      stderrRedact.pipe(process.stderr);
+  );
+  server2.tool(
+    "has_secret",
+    "[secrets] Check if a secret exists. Returns boolean. Never reveals the value. Respects decay \u2014 expired secrets return false.",
+    {
+      key: z2.string().describe("The secret key name"),
+      scope,
+      projectPath,
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("has_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
+      return text(hasSecret(params.key, opts(params)) ? "true" : "false");
     }
-    child.on("close", (code) => {
-      if (timer) clearTimeout(timer);
-      if (timedOut) {
-        resolve({ code: 124, stdout: stdoutStr, stderr: stderrStr + `
-[QRING] Process killed: exceeded ${maxRuntime}s runtime limit` });
-      } else {
-        resolve({ code: code ?? 0, stdout: stdoutStr, stderr: stderrStr });
-      }
-    });
-    child.on("error", (err) => {
-      if (timer) clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
-// src/core/scan.ts
-import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
-import { join } from "path";
-var IGNORE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".next",
-  "dist",
-  "build",
-  "coverage",
-  ".cursor",
-  "venv",
-  "__pycache__"
-]);
-var IGNORE_EXTS = /* @__PURE__ */ new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".ico",
-  ".svg",
-  ".webp",
-  ".mp4",
-  ".mp3",
-  ".wav",
-  ".ogg",
-  ".pdf",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".xz",
-  ".ttf",
-  ".woff",
-  ".woff2",
-  ".eot",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".lock"
-]);
-var SECRET_KEYWORDS = /((?:api_?key|secret|token|password|auth|credential|access_?key)[a-z0-9_]*)\s*[:=]\s*(['"])([^'"]+)\2/i;
-function calculateEntropy(str) {
-  if (!str) return 0;
-  const len = str.length;
-  const frequencies = /* @__PURE__ */ new Map();
-  for (let i = 0; i < len; i++) {
-    const char = str[i];
-    frequencies.set(char, (frequencies.get(char) || 0) + 1);
-  }
-  let entropy = 0;
-  for (const count of frequencies.values()) {
-    const p = count / len;
-    entropy -= p * Math.log2(p);
-  }
-  return entropy;
-}
-function scanCodebase(dir) {
-  const results = [];
-  function walk(currentDir) {
-    let entries;
-    try {
-      entries = readdirSync(currentDir);
-    } catch {
-      return;
+  );
+  server2.tool(
+    "export_secrets",
+    "[secrets] Export secrets as .env or JSON format. Collapses superposition. Supports filtering by specific keys or tags.",
+    {
+      format: z2.enum(["env", "json"]).optional().default("env").describe("Output format"),
+      keys: z2.array(z2.string()).optional().describe("Only export these specific key names"),
+      tags: z2.array(z2.string()).optional().describe("Only export secrets with any of these tags"),
+      scope,
+      projectPath,
+      env,
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("export_secrets", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const output = exportSecrets({
+        ...opts(params),
+        format: params.format,
+        keys: params.keys,
+        tags: params.tags
+      });
+      if (!output.trim()) return text("No secrets matched the filters", true);
+      return text(output);
     }
-    for (const entry of entries) {
-      if (IGNORE_DIRS.has(entry)) continue;
-      const fullPath = join(currentDir, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch {
-        continue;
+  );
+  server2.tool(
+    "import_dotenv",
+    "[secrets] Import secrets from .env file content. Parses standard dotenv syntax (comments, quotes, multiline escapes) and stores each key/value pair in q-ring.",
+    {
+      content: z2.string().describe("The .env file content to parse and import"),
+      scope: scope.default("global"),
+      projectPath,
+      skipExisting: z2.boolean().optional().default(false).describe("Skip keys that already exist in q-ring"),
+      dryRun: z2.boolean().optional().default(false).describe("Preview what would be imported without saving")
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("import_dotenv", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const result = importDotenv(params.content, {
+        scope: params.scope,
+        projectPath: params.projectPath ?? process.cwd(),
+        source: "mcp",
+        skipExisting: params.skipExisting,
+        dryRun: params.dryRun
+      });
+      const lines = [
+        params.dryRun ? "Dry run \u2014 no changes made" : `Imported ${result.imported.length} secret(s)`
+      ];
+      if (result.imported.length > 0) {
+        lines.push(`Keys: ${result.imported.join(", ")}`);
       }
-      if (stat.isDirectory()) {
-        walk(fullPath);
-      } else if (stat.isFile()) {
-        const ext = fullPath.slice(fullPath.lastIndexOf(".")).toLowerCase();
-        if (IGNORE_EXTS.has(ext) || entry.endsWith(".lock")) continue;
-        let content;
-        try {
-          content = readFileSync2(fullPath, "utf8");
-        } catch {
-          continue;
-        }
-        if (content.includes("\0")) continue;
-        const lines = content.split(/\r?\n/);
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i];
-          if (line.length > 500) continue;
-          const match = line.match(SECRET_KEYWORDS);
-          if (match) {
-            const varName = match[1];
-            const value = match[3];
-            if (value.length < 8) continue;
-            const lowerValue = value.toLowerCase();
-            if (lowerValue.includes("example") || lowerValue.includes("your_") || lowerValue.includes("placeholder") || lowerValue.includes("replace_me")) {
-              continue;
-            }
-            const entropy = calculateEntropy(value);
-            if (entropy > 3.5 || value.startsWith("sk-") || value.startsWith("ghp_")) {
-              const relPath = fullPath.startsWith(dir) ? fullPath.slice(dir.length).replace(/^[/\\]+/, "") : fullPath;
-              results.push({
-                file: relPath || fullPath,
-                line: i + 1,
-                keyName: varName,
-                match: value,
-                context: line.trim(),
-                entropy: parseFloat(entropy.toFixed(2))
-              });
-            }
-          }
-        }
+      if (result.skipped.length > 0) {
+        lines.push(`Skipped (existing): ${result.skipped.join(", ")}`);
       }
+      return text(lines.join("\n"));
     }
-  }
-  walk(dir);
-  return results;
-}
-
-// src/core/linter.ts
-import { readFileSync as readFileSync3, writeFileSync, existsSync } from "fs";
-import { basename, extname } from "path";
-var ENV_REF_BY_EXT = {
-  ".ts": (k) => `process.env.${k}`,
-  ".tsx": (k) => `process.env.${k}`,
-  ".js": (k) => `process.env.${k}`,
-  ".jsx": (k) => `process.env.${k}`,
-  ".mjs": (k) => `process.env.${k}`,
-  ".cjs": (k) => `process.env.${k}`,
-  ".py": (k) => `os.environ["${k}"]`,
-  ".rb": (k) => `ENV["${k}"]`,
-  ".go": (k) => `os.Getenv("${k}")`,
-  ".rs": (k) => `std::env::var("${k}")`,
-  ".java": (k) => `System.getenv("${k}")`,
-  ".kt": (k) => `System.getenv("${k}")`,
-  ".cs": (k) => `Environment.GetEnvironmentVariable("${k}")`,
-  ".php": (k) => `getenv('${k}')`,
-  ".sh": (k) => `\${${k}}`,
-  ".bash": (k) => `\${${k}}`
-};
-function getEnvRef(filePath, keyName) {
-  const ext = extname(filePath).toLowerCase();
-  const formatter = ENV_REF_BY_EXT[ext];
-  return formatter ? formatter(keyName) : `process.env.${keyName}`;
-}
-function lintFiles(files, opts2 = {}) {
-  const results = [];
-  for (const file of files) {
-    if (!existsSync(file)) continue;
-    let content;
-    try {
-      content = readFileSync3(file, "utf8");
-    } catch {
-      continue;
+  );
+  server2.tool(
+    "inspect_secret",
+    "[secrets] Show full quantum state of a secret: superposition states, decay status, entanglement links, access history. Never reveals the actual value.",
+    {
+      key: z2.string().describe("The secret key name"),
+      scope,
+      projectPath,
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("inspect_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const result = getEnvelope(params.key, opts(params));
+      if (!result) return text(`Secret "${params.key}" not found`, true);
+      const { envelope, scope: entryScope } = result;
+      const decay = checkDecay(envelope);
+      const info = {
+        key: params.key,
+        scope: entryScope,
+        type: envelope.states ? "superposition" : "collapsed",
+        created: envelope.meta.createdAt,
+        updated: envelope.meta.updatedAt,
+        accessCount: envelope.meta.accessCount,
+        lastAccessed: envelope.meta.lastAccessedAt ?? "never"
+      };
+      if (envelope.states) {
+        info.environments = Object.keys(envelope.states);
+        info.defaultEnv = envelope.defaultEnv;
+      }
+      if (decay.timeRemaining) {
+        info.decay = {
+          expired: decay.isExpired,
+          stale: decay.isStale,
+          lifetimePercent: decay.lifetimePercent,
+          timeRemaining: decay.timeRemaining
+        };
+      }
+      if (envelope.meta.entangled?.length) {
+        info.entangled = envelope.meta.entangled;
+      }
+      if (envelope.meta.description)
+        info.description = envelope.meta.description;
+      if (envelope.meta.tags?.length) info.tags = envelope.meta.tags;
+      return text(JSON.stringify(info, null, 2));
     }
-    if (content.includes("\0")) continue;
-    const SECRET_KEYWORDS2 = /((?:api_?key|secret|token|password|auth|credential|access_?key)[a-z0-9_]*)\s*[:=]\s*(['"])([^'"]+)\2/gi;
-    const lines = content.split(/\r?\n/);
-    const fixes = [];
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.length > 500) continue;
-      let match;
-      SECRET_KEYWORDS2.lastIndex = 0;
-      while ((match = SECRET_KEYWORDS2.exec(line)) !== null) {
-        const varName = match[1].toUpperCase();
-        const quote = match[2];
-        const value = match[3];
-        if (value.length < 8) continue;
-        const lv = value.toLowerCase();
-        if (lv.includes("example") || lv.includes("your_") || lv.includes("placeholder") || lv.includes("replace_me") || lv.includes("xxx")) continue;
-        const entropy = calculateEntropy2(value);
-        if (entropy <= 3.5 && !value.startsWith("sk-") && !value.startsWith("ghp_")) continue;
-        const shouldFix = opts2.fix === true;
-        if (shouldFix) {
-          const envRef = getEnvRef(file, varName);
-          fixes.push({
-            line: i,
-            original: `${quote}${value}${quote}`,
-            replacement: envRef,
-            keyName: varName,
-            value
-          });
-        }
-        results.push({
-          file,
-          line: i + 1,
-          keyName: varName,
-          match: value,
-          context: line.trim(),
-          entropy: parseFloat(entropy.toFixed(2)),
-          fixed: shouldFix
+  );
+  server2.tool(
+    "generate_secret",
+    "[secrets] Generate a cryptographic secret (quantum noise). Formats: hex, base64, alphanumeric, uuid, api-key, token, password. Optionally save directly to the keyring.",
+    {
+      format: z2.enum([
+        "hex",
+        "base64",
+        "alphanumeric",
+        "uuid",
+        "api-key",
+        "token",
+        "password"
+      ]).optional().default("api-key").describe("Output format"),
+      length: z2.number().optional().describe("Length in bytes or characters"),
+      prefix: z2.string().optional().describe("Prefix for api-key/token format"),
+      saveAs: z2.string().optional().describe("If provided, save the generated secret with this key name"),
+      scope: scope.default("global"),
+      projectPath,
+      teamId,
+      orgId
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("generate_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const secret = generateSecret({
+        format: params.format,
+        length: params.length,
+        prefix: params.prefix
+      });
+      if (params.saveAs) {
+        setSecret(params.saveAs, secret, {
+          ...opts(params),
+          description: `Generated ${params.format} secret`
         });
+        const entropy = estimateEntropy(secret);
+        return text(
+          `Generated and saved as "${params.saveAs}" (${params.format}, ~${entropy} bits entropy)`
+        );
       }
+      return text(JSON.stringify({ ok: true, data: { value: secret } }, null, 2));
     }
-    if (opts2.fix && fixes.length > 0) {
-      const fixLines = content.split(/\r?\n/);
-      for (const fix of fixes.reverse()) {
-        const lineIdx = fix.line;
-        if (lineIdx >= 0 && lineIdx < fixLines.length) {
-          fixLines[lineIdx] = fixLines[lineIdx].replace(fix.original, fix.replacement);
+  );
+  server2.tool(
+    "entangle_secrets",
+    "[secrets] Create a quantum entanglement between two secrets. When the source is rotated/updated, the target automatically receives the same value.",
+    {
+      sourceKey: z2.string().describe("Source secret key"),
+      targetKey: z2.string().describe("Target secret key"),
+      sourceScope: scope.default("global"),
+      targetScope: scope.default("global"),
+      sourceProjectPath: z2.string().optional(),
+      targetProjectPath: z2.string().optional()
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy(
+        "entangle_secrets",
+        params.sourceProjectPath
+      );
+      if (toolBlock) return toolBlock;
+      entangleSecrets(
+        params.sourceKey,
+        {
+          scope: params.sourceScope,
+          projectPath: params.sourceProjectPath ?? process.cwd(),
+          source: "mcp"
+        },
+        params.targetKey,
+        {
+          scope: params.targetScope,
+          projectPath: params.targetProjectPath ?? process.cwd(),
+          source: "mcp"
         }
-        if (!hasSecret(fix.keyName, { scope: opts2.scope, projectPath: opts2.projectPath })) {
-          setSecret(fix.keyName, fix.value, {
-            scope: opts2.scope ?? "global",
-            projectPath: opts2.projectPath,
-            source: "cli",
-            description: `Auto-imported from ${basename(file)}:${fix.line + 1}`
-          });
+      );
+      return text(`Entangled: ${params.sourceKey} <-> ${params.targetKey}`);
+    }
+  );
+  server2.tool(
+    "disentangle_secrets",
+    "[secrets] Remove a quantum entanglement between two secrets. They will no longer synchronize on rotation.",
+    {
+      sourceKey: z2.string().describe("Source secret key"),
+      targetKey: z2.string().describe("Target secret key"),
+      sourceScope: scope.default("global"),
+      targetScope: scope.default("global"),
+      sourceProjectPath: z2.string().optional(),
+      targetProjectPath: z2.string().optional()
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy(
+        "disentangle_secrets",
+        params.sourceProjectPath
+      );
+      if (toolBlock) return toolBlock;
+      disentangleSecrets(
+        params.sourceKey,
+        {
+          scope: params.sourceScope,
+          projectPath: params.sourceProjectPath ?? process.cwd(),
+          source: "mcp"
+        },
+        params.targetKey,
+        {
+          scope: params.targetScope,
+          projectPath: params.targetProjectPath ?? process.cwd(),
+          source: "mcp"
         }
-      }
-      writeFileSync(file, fixLines.join("\n"), "utf8");
+      );
+      return text(`Disentangled: ${params.sourceKey} </> ${params.targetKey}`);
     }
-  }
-  return results;
-}
-function calculateEntropy2(str) {
-  if (!str) return 0;
-  const len = str.length;
-  const frequencies = /* @__PURE__ */ new Map();
-  for (let i = 0; i < len; i++) {
-    const ch = str[i];
-    frequencies.set(ch, (frequencies.get(ch) || 0) + 1);
-  }
-  let entropy = 0;
-  for (const count of frequencies.values()) {
-    const p = count / len;
-    entropy -= p * Math.log2(p);
-  }
-  return entropy;
+  );
 }
 
 // src/core/validate.ts
 function makeRequest(url, headers, timeoutMs = 1e4) {
-  return httpRequest_({ url, method: "GET", headers, timeoutMs });
+  return httpRequest({ url, method: "GET", headers, timeoutMs });
 }
 var ProviderRegistry = class {
   providers = /* @__PURE__ */ new Map();
@@ -900,6 +798,10 @@ var httpProvider = {
     if (!url) {
       return { valid: false, status: "unknown", message: "No validation URL configured", latencyMs: 0, provider: "http" };
     }
+    const ssrfBlock = await checkSSRF(url);
+    if (ssrfBlock) {
+      return { valid: false, status: "error", message: `SSRF blocked: ${ssrfBlock}`, latencyMs: Date.now() - start, provider: "http" };
+    }
     try {
       const { statusCode } = await makeRequest(url, {
         Authorization: `Bearer ${value}`,
@@ -975,11 +877,11 @@ async function ciValidateBatch(secrets) {
 
 // src/core/context.ts
 function getProjectContext(opts2 = {}) {
-  const projectPath = opts2.projectPath ?? process.cwd();
-  const envResult = collapseEnvironment({ projectPath });
+  const projectPath8 = opts2.projectPath ?? process.cwd();
+  const envResult = collapseEnvironment({ projectPath: projectPath8 });
   const secretsList = listSecrets({
     ...opts2,
-    projectPath,
+    projectPath: projectPath8,
     silent: true
   });
   let expiredCount = 0;
@@ -1009,7 +911,7 @@ function getProjectContext(opts2 = {}) {
     };
   });
   let manifest = null;
-  const config = readProjectConfig(projectPath);
+  const config = readProjectConfig(projectPath8);
   if (config?.secrets) {
     const declaredKeys = Object.keys(config.secrets);
     const existingKeys = new Set(secrets.map((s) => s.key));
@@ -1024,7 +926,7 @@ function getProjectContext(opts2 = {}) {
     timestamp: e.timestamp
   }));
   return {
-    projectPath,
+    projectPath: projectPath8,
     environment: envResult ? { env: envResult.env, source: envResult.source } : null,
     secrets,
     totalSecrets: secrets.length,
@@ -1039,970 +941,1291 @@ function getProjectContext(opts2 = {}) {
   };
 }
 
-// src/core/memory.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync } from "fs";
-import { join as join2 } from "path";
-import { homedir, hostname, userInfo } from "os";
-import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, createHash, randomBytes as randomBytes3 } from "crypto";
-var MEMORY_FILE = "agent-memory.enc";
-function getMemoryDir() {
-  const dir = join2(homedir(), ".config", "q-ring");
-  if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function getMemoryPath() {
-  return join2(getMemoryDir(), MEMORY_FILE);
-}
-function deriveKey2() {
-  const fingerprint = `qring-memory:${hostname()}:${userInfo().username}`;
-  return createHash("sha256").update(fingerprint).digest();
+// src/mcp/tools/project.ts
+var { teamId: teamId2, orgId: orgId2, scope: scope2, projectPath: projectPath2, env: env2 } = commonSchemas;
+function registerProjectTools(server2) {
+  server2.tool(
+    "check_project",
+    "[project] Validate project secrets against the .q-ring.json manifest. Returns which required secrets are present, missing, expired, or stale. Use this to verify project readiness.",
+    {
+      projectPath: projectPath2
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("check_project", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const pp = params.projectPath ?? process.cwd();
+      const config = readProjectConfig(pp);
+      if (!config?.secrets || Object.keys(config.secrets).length === 0) {
+        return text("No secrets manifest found in .q-ring.json", true);
+      }
+      const results = [];
+      let presentCount = 0;
+      let missingCount = 0;
+      let expiredCount = 0;
+      let staleCount = 0;
+      for (const [key, manifest] of Object.entries(config.secrets)) {
+        const result = getEnvelope(key, { projectPath: pp, source: "mcp" });
+        if (!result) {
+          const status = manifest.required !== false ? "missing" : "optional_missing";
+          if (manifest.required !== false) missingCount++;
+          results.push({
+            key,
+            status,
+            required: manifest.required !== false,
+            description: manifest.description
+          });
+          continue;
+        }
+        const decay = checkDecay(result.envelope);
+        if (decay.isExpired) {
+          expiredCount++;
+          results.push({
+            key,
+            status: "expired",
+            timeRemaining: decay.timeRemaining,
+            description: manifest.description
+          });
+        } else if (decay.isStale) {
+          staleCount++;
+          results.push({
+            key,
+            status: "stale",
+            lifetimePercent: decay.lifetimePercent,
+            timeRemaining: decay.timeRemaining,
+            description: manifest.description
+          });
+        } else {
+          presentCount++;
+          results.push({ key, status: "ok", description: manifest.description });
+        }
+      }
+      const summary = {
+        total: Object.keys(config.secrets).length,
+        present: presentCount,
+        missing: missingCount,
+        expired: expiredCount,
+        stale: staleCount,
+        ready: missingCount === 0 && expiredCount === 0,
+        secrets: results
+      };
+      return text(JSON.stringify(summary, null, 2));
+    }
+  );
+  server2.tool(
+    "env_generate",
+    "[project] Generate .env file content from the project manifest (.q-ring.json). Resolves each declared secret from q-ring, collapses superposition, and returns .env formatted output. Warns about missing or expired secrets.",
+    {
+      projectPath: projectPath2,
+      env: env2
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("env_generate", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const pp = params.projectPath ?? process.cwd();
+      const config = readProjectConfig(pp);
+      if (!config?.secrets || Object.keys(config.secrets).length === 0) {
+        return text("No secrets manifest found in .q-ring.json", true);
+      }
+      const lines = [];
+      const warnings = [];
+      for (const [key, manifest] of Object.entries(config.secrets)) {
+        const value = getSecret(key, {
+          projectPath: pp,
+          env: params.env,
+          source: "mcp"
+        });
+        if (value === null) {
+          if (manifest.required !== false) {
+            warnings.push(`MISSING (required): ${key}`);
+          }
+          lines.push(`# ${key}=`);
+          continue;
+        }
+        const result2 = getEnvelope(key, { projectPath: pp, source: "mcp" });
+        if (result2) {
+          const decay = checkDecay(result2.envelope);
+          if (decay.isExpired) warnings.push(`EXPIRED: ${key}`);
+          else if (decay.isStale) warnings.push(`STALE: ${key}`);
+        }
+        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+        lines.push(`${key}="${escaped}"`);
+      }
+      const output = lines.join("\n");
+      const result = warnings.length > 0 ? `${output}
+
+# Warnings:
+${warnings.map((w) => `# ${w}`).join("\n")}` : output;
+      return text(result);
+    }
+  );
+  server2.tool(
+    "detect_environment",
+    "[project] Detect the current environment context (wavefunction collapse). Returns the detected environment and its source (NODE_ENV, git branch, project config, etc.).",
+    {
+      projectPath: projectPath2
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy(
+        "detect_environment",
+        params.projectPath
+      );
+      if (toolBlock) return toolBlock;
+      const result = collapseEnvironment({
+        projectPath: params.projectPath ?? process.cwd()
+      });
+      if (!result) {
+        return text(
+          "No environment detected. Set QRING_ENV, NODE_ENV, or create .q-ring.json"
+        );
+      }
+      return text(JSON.stringify(result, null, 2));
+    }
+  );
+  server2.tool(
+    "get_project_context",
+    "[agent] Get a safe, redacted overview of the project's secrets, environment, manifest, providers, hooks, and recent audit activity. No secret values are ever exposed. Use this to understand what secrets exist before asking to read them.",
+    {
+      scope: scope2,
+      projectPath: projectPath2,
+      teamId: teamId2,
+      orgId: orgId2
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy(
+        "get_project_context",
+        params.projectPath
+      );
+      if (toolBlock) return toolBlock;
+      const context = getProjectContext(opts(params));
+      return text(JSON.stringify(context, null, 2));
+    }
+  );
+}
+
+// src/mcp/tools/tunnel.ts
+import { z as z3 } from "zod";
+function registerTunnelTools(server2) {
+  server2.tool(
+    "tunnel_create",
+    "[tunnel] Create an ephemeral secret that exists only in memory (quantum tunneling). Never persisted to disk. Optional TTL and max-reads for self-destruction.",
+    {
+      value: z3.string().describe("The secret value"),
+      ttlSeconds: z3.number().optional().describe("Auto-expire after N seconds"),
+      maxReads: z3.number().optional().describe("Self-destruct after N reads")
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("tunnel_create");
+      if (toolBlock) return toolBlock;
+      const id = tunnelCreate(params.value, {
+        ttlSeconds: params.ttlSeconds,
+        maxReads: params.maxReads
+      });
+      return text(JSON.stringify({ ok: true, data: { id } }, null, 2));
+    }
+  );
+  server2.tool(
+    "tunnel_read",
+    "[tunnel] Read an ephemeral tunneled secret by ID. May self-destruct if max-reads is reached.",
+    {
+      id: z3.string().describe("Tunnel ID")
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("tunnel_read");
+      if (toolBlock) return toolBlock;
+      const value = tunnelRead(params.id);
+      if (value === null) {
+        return text(`Tunnel "${params.id}" not found or expired`, true);
+      }
+      return text(
+        JSON.stringify({ ok: true, data: { id: params.id, value } }, null, 2)
+      );
+    }
+  );
+  server2.tool(
+    "tunnel_list",
+    "[tunnel] List active tunneled secrets (IDs and metadata only, never values).",
+    {},
+    async () => {
+      const toolBlock = enforceToolPolicy("tunnel_list");
+      if (toolBlock) return toolBlock;
+      const tunnels = tunnelList();
+      if (tunnels.length === 0) return text("No active tunnels");
+      const lines = tunnels.map((t) => {
+        const parts = [t.id];
+        parts.push(`reads:${t.accessCount}`);
+        if (t.maxReads) parts.push(`max:${t.maxReads}`);
+        if (t.expiresAt) {
+          const rem = Math.max(
+            0,
+            Math.floor((t.expiresAt - Date.now()) / 1e3)
+          );
+          parts.push(`expires:${rem}s`);
+        }
+        return parts.join(" | ");
+      });
+      return text(lines.join("\n"));
+    }
+  );
+  server2.tool(
+    "tunnel_destroy",
+    "[tunnel] Immediately destroy a tunneled secret.",
+    {
+      id: z3.string().describe("Tunnel ID")
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("tunnel_destroy");
+      if (toolBlock) return toolBlock;
+      const destroyed = tunnelDestroy(params.id);
+      return text(
+        destroyed ? `Destroyed ${params.id}` : `Tunnel "${params.id}" not found`,
+        !destroyed
+      );
+    }
+  );
+}
+
+// src/mcp/tools/teleport.ts
+import { z as z5 } from "zod";
+
+// src/core/teleport.ts
+import {
+  randomBytes as randomBytes2,
+  createCipheriv,
+  createDecipheriv,
+  pbkdf2Sync
+} from "crypto";
+import { z as z4 } from "zod";
+var ALGORITHM = "aes-256-gcm";
+var KEY_LENGTH = 32;
+var IV_LENGTH = 12;
+var SALT_LENGTH = 32;
+var PBKDF2_ITERATIONS = 1e5;
+var TeleportBundleSchema = z4.object({
+  v: z4.literal(1),
+  data: z4.string(),
+  salt: z4.string(),
+  iv: z4.string(),
+  tag: z4.string(),
+  createdAt: z4.string(),
+  count: z4.number()
+});
+var TeleportPayloadSchema = z4.object({
+  secrets: z4.array(
+    z4.object({
+      key: z4.string(),
+      value: z4.string(),
+      scope: z4.string().optional()
+    })
+  ),
+  exportedAt: z4.string(),
+  exportedBy: z4.string().optional()
+});
+function deriveKey(passphrase, salt) {
+  return pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha512");
 }
-function encrypt(data) {
-  const key = deriveKey2();
-  const iv = randomBytes3(12);
-  const cipher = createCipheriv2("aes-256-gcm", key, iv);
-  const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+function teleportPack(secrets, passphrase) {
+  const payload = {
+    secrets,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const plaintext = JSON.stringify(payload);
+  const salt = randomBytes2(SALT_LENGTH);
+  const iv = randomBytes2(IV_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  const cipher = createCipheriv(ALGORITHM, key, iv);
+  const encrypted = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
   const tag = cipher.getAuthTag();
-  return `${iv.toString("base64")}:${tag.toString("base64")}:${encrypted.toString("base64")}`;
+  const bundle = {
+    v: 1,
+    data: encrypted.toString("base64"),
+    salt: salt.toString("base64"),
+    iv: iv.toString("base64"),
+    tag: tag.toString("base64"),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    count: secrets.length
+  };
+  return Buffer.from(JSON.stringify(bundle)).toString("base64");
 }
-function decrypt(blob) {
-  const parts = blob.split(":");
-  if (parts.length !== 3) throw new Error("Invalid encrypted format");
-  const iv = Buffer.from(parts[0], "base64");
-  const tag = Buffer.from(parts[1], "base64");
-  const encrypted = Buffer.from(parts[2], "base64");
-  const key = deriveKey2();
-  const decipher = createDecipheriv2("aes-256-gcm", key, iv);
+function teleportUnpack(encoded, passphrase) {
+  let bundleJson;
+  try {
+    bundleJson = Buffer.from(encoded, "base64").toString("utf8");
+  } catch {
+    throw new Error("ERR_TELEPORT_CORRUPT: invalid base64 bundle");
+  }
+  let rawBundle;
+  try {
+    rawBundle = JSON.parse(bundleJson);
+  } catch {
+    throw new Error("ERR_TELEPORT_CORRUPT: bundle is not valid JSON");
+  }
+  const parsedBundle = TeleportBundleSchema.safeParse(rawBundle);
+  if (!parsedBundle.success) {
+    throw new Error(
+      `ERR_TELEPORT_CORRUPT: invalid bundle shape (${parsedBundle.error.message})`
+    );
+  }
+  const bundle = parsedBundle.data;
+  const salt = Buffer.from(bundle.salt, "base64");
+  const iv = Buffer.from(bundle.iv, "base64");
+  const tag = Buffer.from(bundle.tag, "base64");
+  const encrypted = Buffer.from(bundle.data, "base64");
+  const key = deriveKey(passphrase, salt);
+  const decipher = createDecipheriv(ALGORITHM, key, iv);
   decipher.setAuthTag(tag);
-  return decipher.update(encrypted) + decipher.final("utf8");
-}
-function loadStore() {
-  const path = getMemoryPath();
-  if (!existsSync2(path)) {
-    return { entries: {} };
+  let decrypted;
+  try {
+    decrypted = Buffer.concat([
+      decipher.update(encrypted),
+      decipher.final()
+    ]);
+  } catch {
+    throw new Error("ERR_TELEPORT_BAD_PASSPHRASE: decryption failed (wrong passphrase or corrupt data)");
   }
+  let rawPayload;
   try {
-    const raw = readFileSync4(path, "utf8");
-    const decrypted = decrypt(raw);
-    return JSON.parse(decrypted);
+    rawPayload = JSON.parse(decrypted.toString("utf8"));
   } catch {
-    return { entries: {} };
+    throw new Error("ERR_TELEPORT_CORRUPT: decrypted payload is not valid JSON");
   }
-}
-function saveStore(store) {
-  const json = JSON.stringify(store);
-  const encrypted = encrypt(json);
-  writeFileSync2(getMemoryPath(), encrypted, "utf8");
-}
-function remember(key, value) {
-  const store = loadStore();
-  store.entries[key] = {
-    value,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  saveStore(store);
-}
-function recall(key) {
-  const store = loadStore();
-  return store.entries[key]?.value ?? null;
-}
-function listMemory() {
-  const store = loadStore();
-  return Object.entries(store.entries).map(([key, entry]) => ({
-    key,
-    updatedAt: entry.updatedAt
-  }));
-}
-function forget(key) {
-  const store = loadStore();
-  if (key in store.entries) {
-    delete store.entries[key];
-    saveStore(store);
-    return true;
+  const payload = TeleportPayloadSchema.safeParse(rawPayload);
+  if (!payload.success) {
+    throw new Error(
+      `ERR_TELEPORT_CORRUPT: invalid payload (${payload.error.message})`
+    );
   }
-  return false;
+  return payload.data;
 }
 
-// src/mcp/server.ts
-function text(t, isError = false) {
-  return {
-    content: [{ type: "text", text: t }],
-    ...isError ? { isError: true } : {}
-  };
-}
-function opts(params) {
-  return {
-    scope: params.scope,
-    projectPath: params.projectPath ?? process.cwd(),
-    teamId: params.teamId,
-    orgId: params.orgId,
-    env: params.env,
-    source: "mcp"
-  };
-}
-function enforceToolPolicy(toolName, projectPath) {
-  const decision = checkToolPolicy(toolName, projectPath);
-  if (!decision.allowed) {
-    return text(`Policy Denied: ${decision.reason} (source: ${decision.policySource})`, true);
-  }
-  return null;
-}
-function createMcpServer() {
-  const server2 = new McpServer({
-    name: "q-ring",
-    version: "0.2.0"
-  });
-  const teamIdSchema = z.string().optional().describe("Team identifier for team-scoped secrets");
-  const orgIdSchema = z.string().optional().describe("Org identifier for org-scoped secrets");
-  const scopeSchema = z.enum(["global", "project", "team", "org"]).optional().describe("Scope: global, project, team, or org");
-  const projectPathSchema = z.string().optional().describe("Project root path for project-scoped secrets");
-  const envSchema = z.string().optional().describe("Environment for superposition collapse (e.g., dev, staging, prod)");
+// src/mcp/tools/teleport.ts
+var { teamId: teamId3, orgId: orgId3, scope: scope3, projectPath: projectPath3 } = commonSchemas;
+function registerTeleportTools(server2) {
   server2.tool(
-    "get_secret",
-    "Retrieve a secret by key. Collapses superposition if the secret has multiple environment states. Records access in audit log (observer effect).",
+    "teleport_pack",
+    "[teleport] Pack secrets into an AES-256-GCM encrypted bundle for sharing between machines (quantum teleportation).",
     {
-      key: z.string().describe("The secret key name"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      env: envSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      keys: z5.array(z5.string()).optional().describe("Specific keys to pack (all if omitted)"),
+      passphrase: z5.string().describe("Encryption passphrase"),
+      scope: scope3,
+      projectPath: projectPath3,
+      teamId: teamId3,
+      orgId: orgId3
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("get_secret", params.projectPath);
+      const toolBlock = enforceToolPolicy("teleport_pack", params.projectPath);
       if (toolBlock) return toolBlock;
-      try {
-        const keyBlock = checkKeyReadPolicy(params.key, void 0, params.projectPath);
-        if (!keyBlock.allowed) {
-          return text(`Policy Denied: ${keyBlock.reason}`, true);
+      const o = opts(params);
+      const entries = listSecrets(o);
+      const secrets = [];
+      for (const entry of entries) {
+        if (params.keys && !params.keys.includes(entry.key)) continue;
+        const value = getSecret(entry.key, { ...o, scope: entry.scope });
+        if (value !== null) {
+          secrets.push({ key: entry.key, value, scope: entry.scope });
         }
-        const value = getSecret(params.key, opts(params));
-        if (value === null) return text(`Secret "${params.key}" not found`, true);
-        return text(value);
-      } catch (err) {
-        return text(err instanceof Error ? err.message : String(err), true);
       }
+      if (secrets.length === 0) return text("No secrets to pack", true);
+      const bundle = teleportPack(secrets, params.passphrase);
+      return text(bundle);
     }
   );
   server2.tool(
-    "list_secrets",
-    "List all secret keys with quantum metadata (scope, decay status, superposition states, entanglement, access count). Values are never exposed. Supports filtering by tag, expiry state, and key pattern.",
+    "teleport_unpack",
+    "[teleport] Decrypt and import secrets from a teleport bundle.",
     {
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      tag: z.string().optional().describe("Filter by tag"),
-      expired: z.boolean().optional().describe("Show only expired secrets"),
-      stale: z.boolean().optional().describe("Show only stale secrets (75%+ decay)"),
-      filter: z.string().optional().describe("Glob pattern on key name (e.g., 'API_*')"),
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      bundle: z5.string().describe("Base64-encoded encrypted bundle"),
+      passphrase: z5.string().describe("Decryption passphrase"),
+      scope: scope3.default("global"),
+      projectPath: projectPath3,
+      teamId: teamId3,
+      orgId: orgId3,
+      dryRun: z5.boolean().optional().default(false).describe("Preview without importing")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("list_secrets", params.projectPath);
+      const toolBlock = enforceToolPolicy("teleport_unpack", params.projectPath);
       if (toolBlock) return toolBlock;
-      let entries = listSecrets(opts(params));
-      if (params.tag) {
-        entries = entries.filter(
-          (e) => e.envelope?.meta.tags?.includes(params.tag)
-        );
-      }
-      if (params.expired) {
-        entries = entries.filter((e) => e.decay?.isExpired);
-      }
-      if (params.stale) {
-        entries = entries.filter(
-          (e) => e.decay?.isStale && !e.decay?.isExpired
-        );
-      }
-      if (params.filter) {
-        const regex = new RegExp(
-          "^" + params.filter.replace(/\*/g, ".*") + "$",
-          "i"
-        );
-        entries = entries.filter((e) => regex.test(e.key));
-      }
-      if (entries.length === 0) return text("No secrets found");
-      const lines = entries.map((e) => {
-        const parts = [`[${e.scope}] ${e.key}`];
-        if (e.envelope?.states) {
-          parts.push(`states:[${Object.keys(e.envelope.states).join(",")}]`);
-        }
-        if (e.decay?.isExpired) {
-          parts.push("EXPIRED");
-        } else if (e.decay?.isStale) {
-          parts.push(`stale(${e.decay.lifetimePercent}%)`);
-        }
-        if (e.decay?.timeRemaining && !e.decay.isExpired) {
-          parts.push(`ttl:${e.decay.timeRemaining}`);
-        }
-        if (e.envelope?.meta.entangled?.length) {
-          parts.push(`entangled:${e.envelope.meta.entangled.length}`);
+      try {
+        const payload = teleportUnpack(params.bundle, params.passphrase);
+        if (params.dryRun) {
+          const preview = payload.secrets.map((s) => `${s.key} [${s.scope ?? "global"}]`).join("\n");
+          return text(
+            `Would import ${payload.secrets.length} secrets:
+${preview}`
+          );
         }
-        if (e.envelope && e.envelope.meta.accessCount > 0) {
-          parts.push(`reads:${e.envelope.meta.accessCount}`);
+        const o = opts(params);
+        for (const s of payload.secrets) {
+          setSecret(s.key, s.value, o);
         }
-        return parts.join(" | ");
-      });
-      return text(lines.join("\n"));
+        return text(
+          `Imported ${payload.secrets.length} secret(s) from teleport bundle`
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return text(JSON.stringify({ ok: false, error: { message: msg } }), true);
+      }
     }
   );
+}
+
+// src/mcp/tools/audit.ts
+import { z as z6 } from "zod";
+var { teamId: teamId4, orgId: orgId4, scope: scope4, projectPath: projectPath4 } = commonSchemas;
+function registerAuditTools(server2) {
   server2.tool(
-    "set_secret",
-    "Store a secret with optional quantum metadata: TTL (decay), environment state (superposition), description, tags.",
+    "audit_log",
+    "[audit] Query the audit log for secret access history (observer effect). Shows who accessed what and when.",
     {
-      key: z.string().describe("The secret key name"),
-      value: z.string().describe("The secret value"),
-      scope: scopeSchema.default("global"),
-      projectPath: projectPathSchema,
-      env: z.string().optional().describe("If provided, sets the value for this specific environment (superposition)"),
-      ttlSeconds: z.number().optional().describe("Time-to-live in seconds (quantum decay)"),
-      description: z.string().optional().describe("Human-readable description"),
-      tags: z.array(z.string()).optional().describe("Tags for organization"),
-      rotationFormat: z.enum(["hex", "base64", "alphanumeric", "uuid", "api-key", "token", "password"]).optional().describe("Format for auto-rotation when this secret expires"),
-      rotationPrefix: z.string().optional().describe("Prefix for auto-rotation (e.g. 'sk-')"),
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      key: z6.string().optional().describe("Filter by key"),
+      action: z6.enum([
+        "read",
+        "write",
+        "delete",
+        "list",
+        "export",
+        "generate",
+        "entangle",
+        "tunnel",
+        "teleport",
+        "collapse"
+      ]).optional().describe("Filter by action"),
+      limit: z6.number().optional().default(20).describe("Max events to return")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("set_secret", params.projectPath);
+      const toolBlock = enforceToolPolicy("audit_log");
       if (toolBlock) return toolBlock;
-      const o = opts(params);
-      if (params.env) {
-        const existing = getEnvelope(params.key, o);
-        const states = existing?.envelope?.states ?? {};
-        states[params.env] = params.value;
-        if (existing?.envelope?.value && !states["default"]) {
-          states["default"] = existing.envelope.value;
-        }
-        setSecret(params.key, "", {
-          ...o,
-          states,
-          defaultEnv: existing?.envelope?.defaultEnv ?? params.env,
-          ttlSeconds: params.ttlSeconds,
-          description: params.description,
-          tags: params.tags,
-          rotationFormat: params.rotationFormat,
-          rotationPrefix: params.rotationPrefix
-        });
-        return text(`[${params.scope ?? "global"}] ${params.key} set for env:${params.env}`);
-      }
-      setSecret(params.key, params.value, {
-        ...o,
-        ttlSeconds: params.ttlSeconds,
-        description: params.description,
-        tags: params.tags,
-        rotationFormat: params.rotationFormat,
-        rotationPrefix: params.rotationPrefix
+      const events = queryAudit({
+        key: params.key,
+        action: params.action,
+        limit: params.limit
       });
-      return text(`[${params.scope ?? "global"}] ${params.key} saved`);
+      if (events.length === 0) return text("No audit events found");
+      const lines = events.map((e) => {
+        const parts = [e.timestamp, e.action];
+        if (e.key) parts.push(e.key);
+        if (e.scope) parts.push(`[${e.scope}]`);
+        if (e.env) parts.push(`env:${e.env}`);
+        if (e.detail) parts.push(e.detail);
+        return parts.join(" | ");
+      });
+      return text(lines.join("\n"));
     }
   );
   server2.tool(
-    "delete_secret",
-    "Remove a secret from the keyring.",
+    "detect_anomalies",
+    "[audit] Scan for anomalous secret access patterns: burst reads, unusual-hour access. Returns findings and recommendations.",
     {
-      key: z.string().describe("The secret key name"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      key: z6.string().optional().describe("Check anomalies for a specific key")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("delete_secret", params.projectPath);
+      const toolBlock = enforceToolPolicy("detect_anomalies");
       if (toolBlock) return toolBlock;
-      const deleted = deleteSecret(params.key, opts(params));
-      return text(
-        deleted ? `Deleted "${params.key}"` : `Secret "${params.key}" not found`,
-        !deleted
-      );
+      const anomalies = detectAnomalies(params.key);
+      if (anomalies.length === 0) return text("No anomalies detected");
+      const lines = anomalies.map((a) => `[${a.type}] ${a.description}`);
+      return text(lines.join("\n"));
     }
   );
   server2.tool(
-    "has_secret",
-    "Check if a secret exists. Returns boolean. Never reveals the value. Respects decay \u2014 expired secrets return false.",
+    "health_check",
+    "[health] Run a comprehensive health check on all secrets: decay status, staleness, anomalies, entropy assessment.",
     {
-      key: z.string().describe("The secret key name"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      scope: scope4,
+      projectPath: projectPath4,
+      teamId: teamId4,
+      orgId: orgId4
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("has_secret", params.projectPath);
+      const toolBlock = enforceToolPolicy("health_check", params.projectPath);
       if (toolBlock) return toolBlock;
-      return text(hasSecret(params.key, opts(params)) ? "true" : "false");
+      const entries = listSecrets(opts(params));
+      const anomalies = detectAnomalies();
+      let healthy = 0;
+      let stale = 0;
+      let expired = 0;
+      let noDecay = 0;
+      const issues = [];
+      for (const entry of entries) {
+        if (!entry.decay?.timeRemaining) {
+          noDecay++;
+          continue;
+        }
+        if (entry.decay.isExpired) {
+          expired++;
+          issues.push(`EXPIRED: ${entry.key}`);
+        } else if (entry.decay.isStale) {
+          stale++;
+          issues.push(
+            `STALE: ${entry.key} (${entry.decay.lifetimePercent}%, ${entry.decay.timeRemaining} left)`
+          );
+        } else {
+          healthy++;
+        }
+      }
+      const summary = [
+        `Secrets: ${entries.length} total`,
+        `Healthy: ${healthy} | Stale: ${stale} | Expired: ${expired} | No decay: ${noDecay}`,
+        `Anomalies: ${anomalies.length}`
+      ];
+      if (issues.length > 0) {
+        summary.push("", "Issues:", ...issues);
+      }
+      if (anomalies.length > 0) {
+        summary.push(
+          "",
+          "Anomalies:",
+          ...anomalies.map((a) => `[${a.type}] ${a.description}`)
+        );
+      }
+      return text(summary.join("\n"));
     }
   );
   server2.tool(
-    "export_secrets",
-    "Export secrets as .env or JSON format. Collapses superposition. Supports filtering by specific keys or tags.",
+    "verify_audit_chain",
+    "[audit] Verify the tamper-evident hash chain of the audit log. Returns integrity status and the first break point if tampered.",
+    {},
+    async () => {
+      const toolBlock = enforceToolPolicy("verify_audit_chain");
+      if (toolBlock) return toolBlock;
+      const result = verifyAuditChain();
+      return text(JSON.stringify(result, null, 2));
+    }
+  );
+  server2.tool(
+    "export_audit",
+    "[audit] Export audit events in a portable format (jsonl, json, or csv) with optional time range filtering.",
     {
-      format: z.enum(["env", "json"]).optional().default("env").describe("Output format"),
-      keys: z.array(z.string()).optional().describe("Only export these specific key names"),
-      tags: z.array(z.string()).optional().describe("Only export secrets with any of these tags"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      env: envSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      since: z6.string().optional().describe("Start date (ISO 8601)"),
+      until: z6.string().optional().describe("End date (ISO 8601)"),
+      format: z6.enum(["jsonl", "json", "csv"]).optional().default("jsonl").describe("Output format")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("export_secrets", params.projectPath);
+      const toolBlock = enforceToolPolicy("export_audit");
       if (toolBlock) return toolBlock;
-      const output = exportSecrets({
-        ...opts(params),
-        format: params.format,
-        keys: params.keys,
-        tags: params.tags
+      const output = exportAudit({
+        since: params.since,
+        until: params.until,
+        format: params.format
       });
-      if (!output.trim()) return text("No secrets matched the filters", true);
       return text(output);
     }
   );
+}
+
+// src/mcp/tools/validation.ts
+import { z as z7 } from "zod";
+var { teamId: teamId5, orgId: orgId5, scope: scope5, projectPath: projectPath5 } = commonSchemas;
+function registerValidationTools(server2) {
   server2.tool(
-    "import_dotenv",
-    "Import secrets from .env file content. Parses standard dotenv syntax (comments, quotes, multiline escapes) and stores each key/value pair in q-ring.",
+    "validate_secret",
+    "[validation] Test if a secret is actually valid with its target service (e.g., OpenAI, Stripe, GitHub). Uses provider auto-detection based on key prefixes, or accepts an explicit provider name. Never logs the secret value.",
     {
-      content: z.string().describe("The .env file content to parse and import"),
-      scope: scopeSchema.default("global"),
-      projectPath: projectPathSchema,
-      skipExisting: z.boolean().optional().default(false).describe("Skip keys that already exist in q-ring"),
-      dryRun: z.boolean().optional().default(false).describe("Preview what would be imported without saving")
+      key: z7.string().describe("The secret key name"),
+      provider: z7.string().optional().describe("Force a specific provider (openai, stripe, github, aws, http)"),
+      scope: scope5,
+      projectPath: projectPath5,
+      teamId: teamId5,
+      orgId: orgId5
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("import_dotenv", params.projectPath);
+      const toolBlock = enforceToolPolicy("validate_secret", params.projectPath);
       if (toolBlock) return toolBlock;
-      const result = importDotenv(params.content, {
-        scope: params.scope,
-        projectPath: params.projectPath ?? process.cwd(),
-        source: "mcp",
-        skipExisting: params.skipExisting,
-        dryRun: params.dryRun
-      });
-      const lines = [
-        params.dryRun ? "Dry run \u2014 no changes made" : `Imported ${result.imported.length} secret(s)`
-      ];
-      if (result.imported.length > 0) {
-        lines.push(`Keys: ${result.imported.join(", ")}`);
-      }
-      if (result.skipped.length > 0) {
-        lines.push(`Skipped (existing): ${result.skipped.join(", ")}`);
-      }
-      return text(lines.join("\n"));
+      const value = getSecret(params.key, opts(params));
+      if (value === null) return text(`Secret "${params.key}" not found`, true);
+      const envelope = getEnvelope(params.key, opts(params));
+      const provHint = params.provider ?? envelope?.envelope.meta.provider;
+      const result = await validateSecret(value, { provider: provHint });
+      return text(JSON.stringify(result, null, 2));
     }
   );
   server2.tool(
-    "check_project",
-    "Validate project secrets against the .q-ring.json manifest. Returns which required secrets are present, missing, expired, or stale. Use this to verify project readiness.",
-    {
-      projectPath: projectPathSchema
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("check_project", params.projectPath);
+    "list_providers",
+    "[validation] List all available validation providers for secret liveness testing.",
+    {},
+    async () => {
+      const toolBlock = enforceToolPolicy("list_providers");
       if (toolBlock) return toolBlock;
-      const projectPath = params.projectPath ?? process.cwd();
-      const config = readProjectConfig(projectPath);
-      if (!config?.secrets || Object.keys(config.secrets).length === 0) {
-        return text("No secrets manifest found in .q-ring.json", true);
-      }
-      const results = [];
-      let presentCount = 0;
-      let missingCount = 0;
-      let expiredCount = 0;
-      let staleCount = 0;
-      for (const [key, manifest] of Object.entries(config.secrets)) {
-        const result = getEnvelope(key, { projectPath, source: "mcp" });
-        if (!result) {
-          const status = manifest.required !== false ? "missing" : "optional_missing";
-          if (manifest.required !== false) missingCount++;
-          results.push({ key, status, required: manifest.required !== false, description: manifest.description });
-          continue;
-        }
-        const decay = checkDecay(result.envelope);
-        if (decay.isExpired) {
-          expiredCount++;
-          results.push({ key, status: "expired", timeRemaining: decay.timeRemaining, description: manifest.description });
-        } else if (decay.isStale) {
-          staleCount++;
-          results.push({ key, status: "stale", lifetimePercent: decay.lifetimePercent, timeRemaining: decay.timeRemaining, description: manifest.description });
-        } else {
-          presentCount++;
-          results.push({ key, status: "ok", description: manifest.description });
-        }
-      }
-      const summary = {
-        total: Object.keys(config.secrets).length,
-        present: presentCount,
-        missing: missingCount,
-        expired: expiredCount,
-        stale: staleCount,
-        ready: missingCount === 0 && expiredCount === 0,
-        secrets: results
-      };
-      return text(JSON.stringify(summary, null, 2));
+      const providers = registry2.listProviders().map((p) => ({
+        name: p.name,
+        description: p.description,
+        prefixes: p.prefixes ?? []
+      }));
+      return text(JSON.stringify(providers, null, 2));
     }
   );
   server2.tool(
-    "env_generate",
-    "Generate .env file content from the project manifest (.q-ring.json). Resolves each declared secret from q-ring, collapses superposition, and returns .env formatted output. Warns about missing or expired secrets.",
+    "rotate_secret",
+    "[validation] Attempt issuer-native rotation of a secret via its detected or specified provider. Returns rotation result.",
     {
-      projectPath: projectPathSchema,
-      env: envSchema
+      key: z7.string().describe("The secret key to rotate"),
+      provider: z7.string().optional().describe("Force a specific provider"),
+      scope: scope5,
+      projectPath: projectPath5,
+      teamId: teamId5,
+      orgId: orgId5
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("env_generate", params.projectPath);
+      const toolBlock = enforceToolPolicy("rotate_secret", params.projectPath);
       if (toolBlock) return toolBlock;
-      const projectPath = params.projectPath ?? process.cwd();
-      const config = readProjectConfig(projectPath);
-      if (!config?.secrets || Object.keys(config.secrets).length === 0) {
-        return text("No secrets manifest found in .q-ring.json", true);
-      }
-      const lines = [];
-      const warnings = [];
-      for (const [key, manifest] of Object.entries(config.secrets)) {
-        const value = getSecret(key, {
-          projectPath,
-          env: params.env,
+      const value = getSecret(params.key, opts(params));
+      if (!value) return text(`Secret "${params.key}" not found`, true);
+      const result = await rotateWithProvider(value, params.provider);
+      if (result.rotated && result.newValue) {
+        setSecret(params.key, result.newValue, {
+          scope: params.scope ?? "global",
+          projectPath: params.projectPath,
           source: "mcp"
         });
-        if (value === null) {
-          if (manifest.required !== false) {
-            warnings.push(`MISSING (required): ${key}`);
-          }
-          lines.push(`# ${key}=`);
-          continue;
-        }
-        const result2 = getEnvelope(key, { projectPath, source: "mcp" });
-        if (result2) {
-          const decay = checkDecay(result2.envelope);
-          if (decay.isExpired) warnings.push(`EXPIRED: ${key}`);
-          else if (decay.isStale) warnings.push(`STALE: ${key}`);
-        }
-        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-        lines.push(`${key}="${escaped}"`);
       }
-      const output = lines.join("\n");
-      const result = warnings.length > 0 ? `${output}
-
-# Warnings:
-${warnings.map((w) => `# ${w}`).join("\n")}` : output;
-      return text(result);
+      return text(JSON.stringify(result, null, 2));
     }
   );
   server2.tool(
-    "inspect_secret",
-    "Show full quantum state of a secret: superposition states, decay status, entanglement links, access history. Never reveals the actual value.",
+    "ci_validate_secrets",
+    "[validation] CI-oriented batch validation: validates all accessible secrets against their providers and returns a structured pass/fail report.",
     {
-      key: z.string().describe("The secret key name"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      scope: scope5,
+      projectPath: projectPath5,
+      teamId: teamId5,
+      orgId: orgId5
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("inspect_secret", params.projectPath);
+      const toolBlock = enforceToolPolicy(
+        "ci_validate_secrets",
+        params.projectPath
+      );
       if (toolBlock) return toolBlock;
-      const result = getEnvelope(params.key, opts(params));
-      if (!result) return text(`Secret "${params.key}" not found`, true);
-      const { envelope, scope } = result;
-      const decay = checkDecay(envelope);
-      const info = {
-        key: params.key,
-        scope,
-        type: envelope.states ? "superposition" : "collapsed",
-        created: envelope.meta.createdAt,
-        updated: envelope.meta.updatedAt,
-        accessCount: envelope.meta.accessCount,
-        lastAccessed: envelope.meta.lastAccessedAt ?? "never"
-      };
-      if (envelope.states) {
-        info.environments = Object.keys(envelope.states);
-        info.defaultEnv = envelope.defaultEnv;
-      }
-      if (decay.timeRemaining) {
-        info.decay = {
-          expired: decay.isExpired,
-          stale: decay.isStale,
-          lifetimePercent: decay.lifetimePercent,
-          timeRemaining: decay.timeRemaining
-        };
-      }
-      if (envelope.meta.entangled?.length) {
-        info.entangled = envelope.meta.entangled;
-      }
-      if (envelope.meta.description) info.description = envelope.meta.description;
-      if (envelope.meta.tags?.length) info.tags = envelope.meta.tags;
-      return text(JSON.stringify(info, null, 2));
+      const entries = listSecrets(opts(params));
+      const secrets = entries.map((e) => {
+        const val = getSecret(e.key, {
+          ...opts(params),
+          scope: e.scope,
+          silent: true
+        });
+        if (!val) return null;
+        return {
+          key: e.key,
+          value: val,
+          provider: e.envelope?.meta.provider,
+          validationUrl: e.envelope?.meta.validationUrl
+        };
+      }).filter((s) => s !== null);
+      if (secrets.length === 0) return text("No secrets to validate");
+      const report = await ciValidateBatch(secrets);
+      return text(JSON.stringify(report, null, 2));
     }
   );
+}
+
+// src/mcp/tools/hooks.ts
+import { z as z8 } from "zod";
+function registerHookTools(server2) {
   server2.tool(
-    "detect_environment",
-    "Detect the current environment context (wavefunction collapse). Returns the detected environment and its source (NODE_ENV, git branch, project config, etc.).",
+    "register_hook",
+    "[hooks] Register a webhook/callback that fires when a secret is updated, deleted, or rotated. Supports shell commands, HTTP webhooks, and process signals.",
     {
-      projectPath: projectPathSchema
+      type: z8.enum(["shell", "http", "signal"]).describe("Hook type"),
+      key: z8.string().optional().describe("Trigger on exact key match"),
+      keyPattern: z8.string().optional().describe("Trigger on key glob pattern (e.g. DB_*)"),
+      tag: z8.string().optional().describe("Trigger on secrets with this tag"),
+      scope: z8.enum(["global", "project"]).optional().describe("Trigger only for this scope"),
+      actions: z8.array(z8.enum(["write", "delete", "rotate"])).optional().default(["write", "delete", "rotate"]).describe("Which actions trigger this hook"),
+      command: z8.string().optional().describe("Shell command to execute (for shell type)"),
+      url: z8.string().optional().describe("URL to POST to (for http type)"),
+      signalTarget: z8.string().optional().describe("Process name or PID (for signal type)"),
+      signalName: z8.string().optional().default("SIGHUP").describe("Signal to send (for signal type)"),
+      description: z8.string().optional().describe("Human-readable description")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("detect_environment", params.projectPath);
+      const toolBlock = enforceToolPolicy("register_hook");
       if (toolBlock) return toolBlock;
-      const result = collapseEnvironment({
-        projectPath: params.projectPath ?? process.cwd()
-      });
-      if (!result) {
+      if (!params.key && !params.keyPattern && !params.tag) {
         return text(
-          "No environment detected. Set QRING_ENV, NODE_ENV, or create .q-ring.json"
+          "At least one match criterion required: key, keyPattern, or tag",
+          true
         );
       }
-      return text(JSON.stringify(result, null, 2));
+      const entry = registerHook({
+        type: params.type,
+        match: {
+          key: params.key,
+          keyPattern: params.keyPattern,
+          tag: params.tag,
+          scope: params.scope,
+          action: params.actions
+        },
+        command: params.command,
+        url: params.url,
+        signal: params.signalTarget ? { target: params.signalTarget, signal: params.signalName } : void 0,
+        description: params.description,
+        enabled: true
+      });
+      return text(JSON.stringify(entry, null, 2));
     }
   );
   server2.tool(
-    "generate_secret",
-    "Generate a cryptographic secret (quantum noise). Formats: hex, base64, alphanumeric, uuid, api-key, token, password. Optionally save directly to the keyring.",
-    {
-      format: z.enum(["hex", "base64", "alphanumeric", "uuid", "api-key", "token", "password"]).optional().default("api-key").describe("Output format"),
-      length: z.number().optional().describe("Length in bytes or characters"),
-      prefix: z.string().optional().describe("Prefix for api-key/token format"),
-      saveAs: z.string().optional().describe("If provided, save the generated secret with this key name"),
-      scope: scopeSchema.default("global"),
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("generate_secret", params.projectPath);
+    "list_hooks",
+    "[hooks] List all registered secret change hooks with their match criteria, type, and status.",
+    {},
+    async () => {
+      const toolBlock = enforceToolPolicy("list_hooks");
       if (toolBlock) return toolBlock;
-      const secret = generateSecret({
-        format: params.format,
-        length: params.length,
-        prefix: params.prefix
-      });
-      if (params.saveAs) {
-        setSecret(params.saveAs, secret, {
-          ...opts(params),
-          description: `Generated ${params.format} secret`
-        });
-        const entropy = estimateEntropy(secret);
-        return text(
-          `Generated and saved as "${params.saveAs}" (${params.format}, ~${entropy} bits entropy)`
-        );
-      }
-      return text(secret);
+      const hooks = listHooks();
+      if (hooks.length === 0) return text("No hooks registered");
+      return text(JSON.stringify(hooks, null, 2));
     }
   );
   server2.tool(
-    "entangle_secrets",
-    "Create a quantum entanglement between two secrets. When the source is rotated/updated, the target automatically receives the same value.",
+    "remove_hook",
+    "[hooks] Remove a registered hook by ID.",
     {
-      sourceKey: z.string().describe("Source secret key"),
-      targetKey: z.string().describe("Target secret key"),
-      sourceScope: scopeSchema.default("global"),
-      targetScope: scopeSchema.default("global"),
-      sourceProjectPath: z.string().optional(),
-      targetProjectPath: z.string().optional()
+      id: z8.string().describe("Hook ID to remove")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("entangle_secrets", params.sourceProjectPath);
+      const toolBlock = enforceToolPolicy("remove_hook");
       if (toolBlock) return toolBlock;
-      entangleSecrets(
-        params.sourceKey,
-        {
-          scope: params.sourceScope,
-          projectPath: params.sourceProjectPath ?? process.cwd(),
-          source: "mcp"
-        },
-        params.targetKey,
-        {
-          scope: params.targetScope,
-          projectPath: params.targetProjectPath ?? process.cwd(),
-          source: "mcp"
-        }
+      const removed = removeHook(params.id);
+      return text(
+        removed ? `Removed hook ${params.id}` : `Hook "${params.id}" not found`,
+        !removed
       );
-      return text(`Entangled: ${params.sourceKey} <-> ${params.targetKey}`);
     }
-  );
-  server2.tool(
-    "disentangle_secrets",
-    "Remove a quantum entanglement between two secrets. They will no longer synchronize on rotation.",
-    {
-      sourceKey: z.string().describe("Source secret key"),
-      targetKey: z.string().describe("Target secret key"),
-      sourceScope: scopeSchema.default("global"),
-      targetScope: scopeSchema.default("global"),
-      sourceProjectPath: z.string().optional(),
-      targetProjectPath: z.string().optional()
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("disentangle_secrets", params.sourceProjectPath);
-      if (toolBlock) return toolBlock;
-      disentangleSecrets(
-        params.sourceKey,
-        {
-          scope: params.sourceScope,
-          projectPath: params.sourceProjectPath ?? process.cwd(),
-          source: "mcp"
-        },
-        params.targetKey,
-        {
-          scope: params.targetScope,
-          projectPath: params.targetProjectPath ?? process.cwd(),
-          source: "mcp"
-        }
-      );
-      return text(`Disentangled: ${params.sourceKey} </> ${params.targetKey}`);
+  );
+}
+
+// src/mcp/tools/tooling.ts
+import { z as z9 } from "zod";
+
+// src/utils/colors.ts
+var enabled = process.stdout.isTTY !== false && !process.env.NO_COLOR;
+
+// src/core/agent.ts
+function defaultConfig() {
+  return {
+    intervalSeconds: 60,
+    autoRotate: false,
+    projectPaths: [process.cwd()],
+    verbose: false
+  };
+}
+function runHealthScan(config = {}) {
+  const cfg = { ...defaultConfig(), ...config };
+  const report = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalSecrets: 0,
+    healthy: 0,
+    stale: 0,
+    expired: 0,
+    anomalies: 0,
+    rotated: [],
+    warnings: []
+  };
+  const globalEntries = listSecrets({ scope: "global", source: "agent" });
+  const projectEntries = cfg.projectPaths.flatMap(
+    (pp) => listSecrets({ scope: "project", projectPath: pp, source: "agent" })
+  );
+  const allEntries = [...globalEntries, ...projectEntries];
+  report.totalSecrets = allEntries.length;
+  for (const entry of allEntries) {
+    if (!entry.envelope) continue;
+    const decay = checkDecay(entry.envelope);
+    if (decay.isExpired) {
+      report.expired++;
+      report.warnings.push(
+        `EXPIRED: ${entry.key} [${entry.scope}] \u2014 expired ${decay.timeRemaining}`
+      );
+      if (cfg.autoRotate) {
+        const fmt = entry.envelope?.meta.rotationFormat ?? "api-key";
+        const prefix = entry.envelope?.meta.rotationPrefix;
+        const newValue = generateSecret({ format: fmt, prefix });
+        setSecret(entry.key, newValue, {
+          scope: entry.scope,
+          projectPath: cfg.projectPaths[0],
+          source: "agent"
+        });
+        report.rotated.push(entry.key);
+        logAudit({
+          action: "write",
+          key: entry.key,
+          scope: entry.scope,
+          source: "agent",
+          detail: "auto-rotated by agent (expired)"
+        });
+        fireHooks({
+          action: "rotate",
+          key: entry.key,
+          scope: entry.scope,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          source: "agent"
+        }, entry.envelope?.meta.tags).catch(() => {
+        });
+      }
+    } else if (decay.isStale) {
+      report.stale++;
+      report.warnings.push(
+        `STALE: ${entry.key} [${entry.scope}] \u2014 ${decay.lifetimePercent}% lifetime, ${decay.timeRemaining} remaining`
+      );
+    } else {
+      report.healthy++;
+    }
+  }
+  const anomalies = detectAnomalies();
+  report.anomalies = anomalies.length;
+  for (const a of anomalies) {
+    report.warnings.push(`ANOMALY [${a.type}]: ${a.description}`);
+  }
+  return report;
+}
+
+// src/core/exec.ts
+import { spawn } from "child_process";
+import { Transform } from "stream";
+var BUILTIN_PROFILES = {
+  unrestricted: { name: "unrestricted" },
+  restricted: {
+    name: "restricted",
+    denyCommands: ["curl", "wget", "ssh", "scp", "nc", "netcat", "ncat"],
+    maxRuntimeSeconds: 30,
+    allowNetwork: false,
+    stripEnvVars: ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY"]
+  },
+  ci: {
+    name: "ci",
+    maxRuntimeSeconds: 300,
+    allowNetwork: true,
+    denyCommands: ["rm -rf /", "mkfs", "dd if="]
+  }
+};
+function getProfile(name) {
+  if (!name) return BUILTIN_PROFILES.unrestricted;
+  return BUILTIN_PROFILES[name] ?? { name };
+}
+var RedactionTransform = class extends Transform {
+  patterns = [];
+  tail = "";
+  maxLen = 0;
+  constructor(secretsToRedact) {
+    super();
+    const validSecrets = secretsToRedact.filter((s) => s.length > 5);
+    validSecrets.sort((a, b) => b.length - a.length);
+    this.patterns = validSecrets.map((s) => ({
+      value: s,
+      replacement: "[QRING:REDACTED]"
+    }));
+    if (validSecrets.length > 0) {
+      this.maxLen = validSecrets[0].length;
+    }
+  }
+  _transform(chunk, _encoding, callback) {
+    if (this.patterns.length === 0) {
+      this.push(chunk);
+      return callback();
+    }
+    const text2 = this.tail + chunk.toString();
+    let redacted = text2;
+    for (const { value, replacement } of this.patterns) {
+      redacted = redacted.split(value).join(replacement);
+    }
+    if (redacted.length < this.maxLen) {
+      this.tail = redacted;
+      return callback();
+    }
+    const outputLen = redacted.length - this.maxLen + 1;
+    const output = redacted.slice(0, outputLen);
+    this.tail = redacted.slice(outputLen);
+    this.push(output);
+    callback();
+  }
+  _flush(callback) {
+    if (this.tail) {
+      let final = this.tail;
+      for (const { value, replacement } of this.patterns) {
+        final = final.split(value).join(replacement);
+      }
+      this.push(final);
+    }
+    callback();
+  }
+};
+async function execCommand(opts2) {
+  const profile = getProfile(opts2.profile);
+  const fullCommand = [opts2.command, ...opts2.args].join(" ");
+  const policyDecision = checkExecPolicy(fullCommand, opts2.projectPath);
+  if (!policyDecision.allowed) {
+    throw new Error(`Policy Denied: ${policyDecision.reason}`);
+  }
+  if (profile.denyCommands) {
+    const denied = profile.denyCommands.find((d) => {
+      const pattern = new RegExp(`(^|[\\s/])${d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\s|$)`, "i");
+      return pattern.test(fullCommand);
+    });
+    if (denied) {
+      throw new Error(`Exec profile "${profile.name}" denies command containing "${denied}"`);
+    }
+  }
+  if (profile.allowCommands) {
+    const allowed = profile.allowCommands.some((a) => fullCommand.startsWith(a));
+    if (!allowed) {
+      throw new Error(`Exec profile "${profile.name}" does not allow command "${opts2.command}"`);
+    }
+  }
+  const envMap = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v !== void 0) envMap[k] = v;
+  }
+  if (profile.stripEnvVars) {
+    for (const key of profile.stripEnvVars) {
+      delete envMap[key];
+    }
+  }
+  const secretsToRedact = /* @__PURE__ */ new Set();
+  let entries = listSecrets({
+    scope: opts2.scope,
+    projectPath: opts2.projectPath,
+    source: opts2.source ?? "cli",
+    silent: true
+    // list silently
+  });
+  if (opts2.keys?.length) {
+    const keySet = new Set(opts2.keys);
+    entries = entries.filter((e) => keySet.has(e.key));
+  }
+  if (opts2.tags?.length) {
+    entries = entries.filter(
+      (e) => opts2.tags.some((t) => e.envelope?.meta.tags?.includes(t))
+    );
+  }
+  for (const entry of entries) {
+    if (entry.envelope) {
+      const decay = checkDecay(entry.envelope);
+      if (decay.isExpired) continue;
     }
-  );
-  server2.tool(
-    "tunnel_create",
-    "Create an ephemeral secret that exists only in memory (quantum tunneling). Never persisted to disk. Optional TTL and max-reads for self-destruction.",
-    {
-      value: z.string().describe("The secret value"),
-      ttlSeconds: z.number().optional().describe("Auto-expire after N seconds"),
-      maxReads: z.number().optional().describe("Self-destruct after N reads")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("tunnel_create");
-      if (toolBlock) return toolBlock;
-      const id = tunnelCreate(params.value, {
-        ttlSeconds: params.ttlSeconds,
-        maxReads: params.maxReads
-      });
-      return text(id);
+    const val = getSecret(entry.key, {
+      scope: entry.scope,
+      projectPath: opts2.projectPath,
+      env: opts2.env,
+      source: opts2.source ?? "cli",
+      silent: false
+      // Log access for execution
+    });
+    if (val !== null) {
+      envMap[entry.key] = val;
+      if (val.length > 5) {
+        secretsToRedact.add(val);
+      }
     }
-  );
-  server2.tool(
-    "tunnel_read",
-    "Read an ephemeral tunneled secret by ID. May self-destruct if max-reads is reached.",
-    {
-      id: z.string().describe("Tunnel ID")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("tunnel_read");
-      if (toolBlock) return toolBlock;
-      const value = tunnelRead(params.id);
-      if (value === null) {
-        return text(`Tunnel "${params.id}" not found or expired`, true);
+  }
+  const maxRuntime = profile.maxRuntimeSeconds ?? getExecMaxRuntime(opts2.projectPath);
+  return new Promise((resolve, reject) => {
+    const networkTools = /* @__PURE__ */ new Set([
+      "curl",
+      "wget",
+      "ping",
+      "nc",
+      "netcat",
+      "ssh",
+      "telnet",
+      "ftp",
+      "dig",
+      "nslookup"
+    ]);
+    if (profile.allowNetwork === false && networkTools.has(opts2.command)) {
+      const msg = `[QRING] Execution blocked: network access is disabled for profile "${profile.name}", command "${opts2.command}" is considered network-related`;
+      if (opts2.captureOutput) {
+        return resolve({ code: 126, stdout: "", stderr: msg });
       }
-      return text(value);
+      process.stderr.write(msg + "\n");
+      return resolve({ code: 126, stdout: "", stderr: "" });
     }
-  );
-  server2.tool(
-    "tunnel_list",
-    "List active tunneled secrets (IDs and metadata only, never values).",
-    {},
-    async () => {
-      const toolBlock = enforceToolPolicy("tunnel_list");
-      if (toolBlock) return toolBlock;
-      const tunnels = tunnelList();
-      if (tunnels.length === 0) return text("No active tunnels");
-      const lines = tunnels.map((t) => {
-        const parts = [t.id];
-        parts.push(`reads:${t.accessCount}`);
-        if (t.maxReads) parts.push(`max:${t.maxReads}`);
-        if (t.expiresAt) {
-          const rem = Math.max(0, Math.floor((t.expiresAt - Date.now()) / 1e3));
-          parts.push(`expires:${rem}s`);
-        }
-        return parts.join(" | ");
-      });
-      return text(lines.join("\n"));
+    const child = spawn(opts2.command, opts2.args, {
+      env: envMap,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: false
+    });
+    let timedOut = false;
+    let timer;
+    if (maxRuntime) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGKILL");
+      }, maxRuntime * 1e3);
     }
-  );
-  server2.tool(
-    "tunnel_destroy",
-    "Immediately destroy a tunneled secret.",
-    {
-      id: z.string().describe("Tunnel ID")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("tunnel_destroy");
-      if (toolBlock) return toolBlock;
-      const destroyed = tunnelDestroy(params.id);
-      return text(
-        destroyed ? `Destroyed ${params.id}` : `Tunnel "${params.id}" not found`,
-        !destroyed
-      );
+    const stdoutRedact = new RedactionTransform([...secretsToRedact]);
+    const stderrRedact = new RedactionTransform([...secretsToRedact]);
+    if (child.stdout) child.stdout.pipe(stdoutRedact);
+    if (child.stderr) child.stderr.pipe(stderrRedact);
+    let stdoutStr = "";
+    let stderrStr = "";
+    if (opts2.captureOutput) {
+      stdoutRedact.on("data", (d) => stdoutStr += d.toString());
+      stderrRedact.on("data", (d) => stderrStr += d.toString());
+    } else {
+      stdoutRedact.pipe(process.stdout);
+      stderrRedact.pipe(process.stderr);
     }
-  );
-  server2.tool(
-    "teleport_pack",
-    "Pack secrets into an AES-256-GCM encrypted bundle for sharing between machines (quantum teleportation).",
-    {
-      keys: z.array(z.string()).optional().describe("Specific keys to pack (all if omitted)"),
-      passphrase: z.string().describe("Encryption passphrase"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("teleport_pack", params.projectPath);
-      if (toolBlock) return toolBlock;
-      const o = opts(params);
-      const entries = listSecrets(o);
-      const secrets = [];
-      for (const entry of entries) {
-        if (params.keys && !params.keys.includes(entry.key)) continue;
-        const value = getSecret(entry.key, { ...o, scope: entry.scope });
-        if (value !== null) {
-          secrets.push({ key: entry.key, value, scope: entry.scope });
-        }
+    child.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (timedOut) {
+        resolve({ code: 124, stdout: stdoutStr, stderr: stderrStr + `
+[QRING] Process killed: exceeded ${maxRuntime}s runtime limit` });
+      } else {
+        resolve({ code: code ?? 0, stdout: stdoutStr, stderr: stderrStr });
       }
-      if (secrets.length === 0) return text("No secrets to pack", true);
-      const bundle = teleportPack(secrets, params.passphrase);
-      return text(bundle);
+    });
+    child.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+// src/core/scan.ts
+import { readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+
+// src/core/secrets-detect.ts
+var SECRET_ASSIGNMENT_PATTERN = /((?:api_?key|secret|token|password|auth|credential|access_?key)[a-z0-9_]*)\s*[:=]\s*(['"])([^'"]+)\2/gi;
+function calculateEntropy(str) {
+  if (!str) return 0;
+  const len = str.length;
+  const frequencies = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const char = str[i];
+    frequencies.set(char, (frequencies.get(char) || 0) + 1);
+  }
+  let entropy = 0;
+  for (const count of frequencies.values()) {
+    const p = count / len;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function isPlaceholderValue(value) {
+  const lv = value.toLowerCase();
+  return lv.includes("example") || lv.includes("your_") || lv.includes("placeholder") || lv.includes("replace_me") || lv.includes("xxx");
+}
+function passesSecretHeuristic(value, entropy) {
+  return entropy > 3.5 || value.startsWith("sk-") || value.startsWith("ghp_");
+}
+function findSecretsInLine(line) {
+  if (line.length > 500) return [];
+  const out = [];
+  SECRET_ASSIGNMENT_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = SECRET_ASSIGNMENT_PATTERN.exec(line)) !== null) {
+    const varName = match[1];
+    const quote = match[2];
+    const value = match[3];
+    if (value.length < 8) continue;
+    if (isPlaceholderValue(value)) continue;
+    const entropy = calculateEntropy(value);
+    if (!passesSecretHeuristic(value, entropy)) continue;
+    out.push({ varName, value, quote });
+  }
+  return out;
+}
+
+// src/core/scan.ts
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  ".cursor",
+  "venv",
+  "__pycache__"
+]);
+var IGNORE_EXTS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".svg",
+  ".webp",
+  ".mp4",
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".xz",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".eot",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".lock"
+]);
+function scanCodebase(dir) {
+  const results = [];
+  function walk(currentDir) {
+    let entries;
+    try {
+      entries = readdirSync(currentDir);
+    } catch {
+      return;
     }
-  );
-  server2.tool(
-    "teleport_unpack",
-    "Decrypt and import secrets from a teleport bundle.",
-    {
-      bundle: z.string().describe("Base64-encoded encrypted bundle"),
-      passphrase: z.string().describe("Decryption passphrase"),
-      scope: scopeSchema.default("global"),
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema,
-      dryRun: z.boolean().optional().default(false).describe("Preview without importing")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("teleport_unpack", params.projectPath);
-      if (toolBlock) return toolBlock;
+    for (const entry of entries) {
+      if (IGNORE_DIRS.has(entry)) continue;
+      const fullPath = join2(currentDir, entry);
+      let stat;
       try {
-        const payload = teleportUnpack(params.bundle, params.passphrase);
-        if (params.dryRun) {
-          const preview = payload.secrets.map((s) => `${s.key} [${s.scope ?? "global"}]`).join("\n");
-          return text(`Would import ${payload.secrets.length} secrets:
-${preview}`);
-        }
-        const o = opts(params);
-        for (const s of payload.secrets) {
-          setSecret(s.key, s.value, o);
-        }
-        return text(`Imported ${payload.secrets.length} secret(s) from teleport bundle`);
+        stat = statSync(fullPath);
       } catch {
-        return text("Failed to unpack: wrong passphrase or corrupted bundle", true);
+        continue;
       }
-    }
-  );
-  server2.tool(
-    "audit_log",
-    "Query the audit log for secret access history (observer effect). Shows who accessed what and when.",
-    {
-      key: z.string().optional().describe("Filter by key"),
-      action: z.enum(["read", "write", "delete", "list", "export", "generate", "entangle", "tunnel", "teleport", "collapse"]).optional().describe("Filter by action"),
-      limit: z.number().optional().default(20).describe("Max events to return")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("audit_log");
-      if (toolBlock) return toolBlock;
-      const events = queryAudit({
-        key: params.key,
-        action: params.action,
-        limit: params.limit
-      });
-      if (events.length === 0) return text("No audit events found");
-      const lines = events.map((e) => {
-        const parts = [e.timestamp, e.action];
-        if (e.key) parts.push(e.key);
-        if (e.scope) parts.push(`[${e.scope}]`);
-        if (e.env) parts.push(`env:${e.env}`);
-        if (e.detail) parts.push(e.detail);
-        return parts.join(" | ");
-      });
-      return text(lines.join("\n"));
-    }
-  );
-  server2.tool(
-    "detect_anomalies",
-    "Scan for anomalous secret access patterns: burst reads, unusual-hour access. Returns findings and recommendations.",
-    {
-      key: z.string().optional().describe("Check anomalies for a specific key")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("detect_anomalies");
-      if (toolBlock) return toolBlock;
-      const anomalies = detectAnomalies(params.key);
-      if (anomalies.length === 0) return text("No anomalies detected");
-      const lines = anomalies.map(
-        (a) => `[${a.type}] ${a.description}`
-      );
-      return text(lines.join("\n"));
-    }
-  );
-  server2.tool(
-    "health_check",
-    "Run a comprehensive health check on all secrets: decay status, staleness, anomalies, entropy assessment.",
-    {
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("health_check", params.projectPath);
-      if (toolBlock) return toolBlock;
-      const entries = listSecrets(opts(params));
-      const anomalies = detectAnomalies();
-      let healthy = 0;
-      let stale = 0;
-      let expired = 0;
-      let noDecay = 0;
-      const issues = [];
-      for (const entry of entries) {
-        if (!entry.decay?.timeRemaining) {
-          noDecay++;
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (stat.isFile()) {
+        const ext = fullPath.slice(fullPath.lastIndexOf(".")).toLowerCase();
+        if (IGNORE_EXTS.has(ext) || entry.endsWith(".lock")) continue;
+        let content;
+        try {
+          content = readFileSync3(fullPath, "utf8");
+        } catch {
           continue;
         }
-        if (entry.decay.isExpired) {
-          expired++;
-          issues.push(`EXPIRED: ${entry.key}`);
-        } else if (entry.decay.isStale) {
-          stale++;
-          issues.push(
-            `STALE: ${entry.key} (${entry.decay.lifetimePercent}%, ${entry.decay.timeRemaining} left)`
-          );
-        } else {
-          healthy++;
+        if (content.includes("\0")) continue;
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const matches = findSecretsInLine(line);
+          for (const m of matches) {
+            const entropy = calculateEntropy(m.value);
+            const relPath = fullPath.startsWith(dir) ? fullPath.slice(dir.length).replace(/^[/\\]+/, "") : fullPath;
+            results.push({
+              file: relPath || fullPath,
+              line: i + 1,
+              keyName: m.varName,
+              match: m.value,
+              context: line.trim(),
+              entropy: parseFloat(entropy.toFixed(2))
+            });
+          }
         }
       }
-      const summary = [
-        `Secrets: ${entries.length} total`,
-        `Healthy: ${healthy} | Stale: ${stale} | Expired: ${expired} | No decay: ${noDecay}`,
-        `Anomalies: ${anomalies.length}`
-      ];
-      if (issues.length > 0) {
-        summary.push("", "Issues:", ...issues);
-      }
-      if (anomalies.length > 0) {
-        summary.push(
-          "",
-          "Anomalies:",
-          ...anomalies.map((a) => `[${a.type}] ${a.description}`)
-        );
-      }
-      return text(summary.join("\n"));
-    }
-  );
-  server2.tool(
-    "validate_secret",
-    "Test if a secret is actually valid with its target service (e.g., OpenAI, Stripe, GitHub). Uses provider auto-detection based on key prefixes, or accepts an explicit provider name. Never logs the secret value.",
-    {
-      key: z.string().describe("The secret key name"),
-      provider: z.string().optional().describe("Force a specific provider (openai, stripe, github, aws, http)"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("validate_secret", params.projectPath);
-      if (toolBlock) return toolBlock;
-      const value = getSecret(params.key, opts(params));
-      if (value === null) return text(`Secret "${params.key}" not found`, true);
-      const envelope = getEnvelope(params.key, opts(params));
-      const provHint = params.provider ?? envelope?.envelope.meta.provider;
-      const result = await validateSecret(value, { provider: provHint });
-      return text(JSON.stringify(result, null, 2));
-    }
-  );
-  server2.tool(
-    "list_providers",
-    "List all available validation providers for secret liveness testing.",
-    {},
-    async () => {
-      const toolBlock = enforceToolPolicy("list_providers");
-      if (toolBlock) return toolBlock;
-      const providers = registry2.listProviders().map((p) => ({
-        name: p.name,
-        description: p.description,
-        prefixes: p.prefixes ?? []
-      }));
-      return text(JSON.stringify(providers, null, 2));
-    }
-  );
-  server2.tool(
-    "register_hook",
-    "Register a webhook/callback that fires when a secret is updated, deleted, or rotated. Supports shell commands, HTTP webhooks, and process signals.",
-    {
-      type: z.enum(["shell", "http", "signal"]).describe("Hook type"),
-      key: z.string().optional().describe("Trigger on exact key match"),
-      keyPattern: z.string().optional().describe("Trigger on key glob pattern (e.g. DB_*)"),
-      tag: z.string().optional().describe("Trigger on secrets with this tag"),
-      scope: z.enum(["global", "project"]).optional().describe("Trigger only for this scope"),
-      actions: z.array(z.enum(["write", "delete", "rotate"])).optional().default(["write", "delete", "rotate"]).describe("Which actions trigger this hook"),
-      command: z.string().optional().describe("Shell command to execute (for shell type)"),
-      url: z.string().optional().describe("URL to POST to (for http type)"),
-      signalTarget: z.string().optional().describe("Process name or PID (for signal type)"),
-      signalName: z.string().optional().default("SIGHUP").describe("Signal to send (for signal type)"),
-      description: z.string().optional().describe("Human-readable description")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("register_hook");
-      if (toolBlock) return toolBlock;
-      if (!params.key && !params.keyPattern && !params.tag) {
-        return text("At least one match criterion required: key, keyPattern, or tag", true);
-      }
-      const entry = registerHook({
-        type: params.type,
-        match: {
-          key: params.key,
-          keyPattern: params.keyPattern,
-          tag: params.tag,
-          scope: params.scope,
-          action: params.actions
-        },
-        command: params.command,
-        url: params.url,
-        signal: params.signalTarget ? { target: params.signalTarget, signal: params.signalName } : void 0,
-        description: params.description,
-        enabled: true
-      });
-      return text(JSON.stringify(entry, null, 2));
     }
-  );
-  server2.tool(
-    "list_hooks",
-    "List all registered secret change hooks with their match criteria, type, and status.",
-    {},
-    async () => {
-      const toolBlock = enforceToolPolicy("list_hooks");
-      if (toolBlock) return toolBlock;
-      const hooks = listHooks();
-      if (hooks.length === 0) return text("No hooks registered");
-      return text(JSON.stringify(hooks, null, 2));
+  }
+  walk(dir);
+  return results;
+}
+
+// src/core/linter.ts
+import { readFileSync as readFileSync4, writeFileSync, existsSync } from "fs";
+import { basename, extname } from "path";
+var ENV_REF_BY_EXT = {
+  ".ts": (k) => `process.env.${k}`,
+  ".tsx": (k) => `process.env.${k}`,
+  ".js": (k) => `process.env.${k}`,
+  ".jsx": (k) => `process.env.${k}`,
+  ".mjs": (k) => `process.env.${k}`,
+  ".cjs": (k) => `process.env.${k}`,
+  ".py": (k) => `os.environ["${k}"]`,
+  ".rb": (k) => `ENV["${k}"]`,
+  ".go": (k) => `os.Getenv("${k}")`,
+  ".rs": (k) => `std::env::var("${k}")`,
+  ".java": (k) => `System.getenv("${k}")`,
+  ".kt": (k) => `System.getenv("${k}")`,
+  ".cs": (k) => `Environment.GetEnvironmentVariable("${k}")`,
+  ".php": (k) => `getenv('${k}')`,
+  ".sh": (k) => `\${${k}}`,
+  ".bash": (k) => `\${${k}}`
+};
+function getEnvRef(filePath, keyName) {
+  const ext = extname(filePath).toLowerCase();
+  const formatter = ENV_REF_BY_EXT[ext];
+  return formatter ? formatter(keyName) : `process.env.${keyName}`;
+}
+function lintFiles(files, opts2 = {}) {
+  const results = [];
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+    let content;
+    try {
+      content = readFileSync4(file, "utf8");
+    } catch {
+      continue;
     }
-  );
-  server2.tool(
-    "remove_hook",
-    "Remove a registered hook by ID.",
-    {
-      id: z.string().describe("Hook ID to remove")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("remove_hook");
-      if (toolBlock) return toolBlock;
-      const removed = removeHook(params.id);
-      return text(
-        removed ? `Removed hook ${params.id}` : `Hook "${params.id}" not found`,
-        !removed
-      );
+    if (content.includes("\0")) continue;
+    const lines = content.split(/\r?\n/);
+    const fixes = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const matches = findSecretsInLine(line);
+      for (const m of matches) {
+        const varNameUpper = m.varName.toUpperCase();
+        const entropy = calculateEntropy(m.value);
+        const shouldFix = opts2.fix === true;
+        if (shouldFix) {
+          const envRef = getEnvRef(file, varNameUpper);
+          fixes.push({
+            line: i,
+            original: `${m.quote}${m.value}${m.quote}`,
+            replacement: envRef,
+            keyName: varNameUpper,
+            value: m.value
+          });
+        }
+        results.push({
+          file,
+          line: i + 1,
+          keyName: varNameUpper,
+          match: m.value,
+          context: line.trim(),
+          entropy: parseFloat(entropy.toFixed(2)),
+          fixed: shouldFix
+        });
+      }
     }
-  );
+    if (opts2.fix && fixes.length > 0) {
+      const fixLines = content.split(/\r?\n/);
+      for (const fix of fixes.reverse()) {
+        const lineIdx = fix.line;
+        if (lineIdx >= 0 && lineIdx < fixLines.length) {
+          fixLines[lineIdx] = fixLines[lineIdx].replace(fix.original, fix.replacement);
+        }
+        if (!hasSecret(fix.keyName, { scope: opts2.scope, projectPath: opts2.projectPath })) {
+          setSecret(fix.keyName, fix.value, {
+            scope: opts2.scope ?? "global",
+            projectPath: opts2.projectPath,
+            source: "cli",
+            description: `Auto-imported from ${basename(file)}:${fix.line + 1}`
+          });
+        }
+      }
+      writeFileSync(file, fixLines.join("\n"), "utf8");
+    }
+  }
+  return results;
+}
+
+// src/mcp/tools/tooling.ts
+var { teamId: teamId6, orgId: orgId6, scope: scope6, projectPath: projectPath6 } = commonSchemas;
+function registerToolingTools(server2) {
   server2.tool(
     "exec_with_secrets",
-    "Run a shell command securely. Project secrets are injected into the environment, and any secret values in the output are automatically redacted to prevent leaking into transcripts.",
+    "[exec] Run a shell command securely. Project secrets are injected into the environment, and any secret values in the output are automatically redacted to prevent leaking into transcripts.",
     {
-      command: z.string().describe("Command to run"),
-      args: z.array(z.string()).optional().describe("Command arguments"),
-      keys: z.array(z.string()).optional().describe("Only inject these specific keys"),
-      tags: z.array(z.string()).optional().describe("Only inject secrets with these tags"),
-      profile: z.enum(["unrestricted", "restricted", "ci"]).optional().default("restricted").describe("Exec profile: unrestricted, restricted, or ci"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      command: z9.string().describe("Command to run"),
+      args: z9.array(z9.string()).optional().describe("Command arguments"),
+      keys: z9.array(z9.string()).optional().describe("Only inject these specific keys"),
+      tags: z9.array(z9.string()).optional().describe("Only inject secrets with these tags"),
+      profile: z9.enum(["unrestricted", "restricted", "ci"]).optional().default("restricted").describe("Exec profile: unrestricted, restricted, or ci"),
+      scope: scope6,
+      projectPath: projectPath6,
+      teamId: teamId6,
+      orgId: orgId6
     },
     async (params) => {
       const toolBlock = enforceToolPolicy("exec_with_secrets", params.projectPath);
@@ -2031,15 +2254,18 @@ ${result.stdout}`);
 ${result.stderr}`);
         return text(output.join("\n\n"));
       } catch (err) {
-        return text(`Execution failed: ${err instanceof Error ? err.message : String(err)}`, true);
+        return text(
+          `Execution failed: ${err instanceof Error ? err.message : String(err)}`,
+          true
+        );
       }
     }
   );
   server2.tool(
     "scan_codebase_for_secrets",
-    "Scan a directory for hardcoded secrets using regex heuristics and Shannon entropy analysis. Returns file paths, line numbers, and the matched key/value to help migrate legacy codebases into q-ring.",
+    "[scan] Scan a directory for hardcoded secrets using regex heuristics and Shannon entropy analysis. Returns file paths, line numbers, and the matched key/value to help migrate legacy codebases into q-ring.",
     {
-      dirPath: z.string().describe("Absolute or relative path to the directory to scan")
+      dirPath: z9.string().describe("Absolute or relative path to the directory to scan")
     },
     async (params) => {
       const toolBlock = enforceToolPolicy("scan_codebase_for_secrets");
@@ -2051,82 +2277,23 @@ ${result.stderr}`);
         }
         return text(JSON.stringify(results, null, 2));
       } catch (err) {
-        return text(`Scan failed: ${err instanceof Error ? err.message : String(err)}`, true);
-      }
-    }
-  );
-  server2.tool(
-    "get_project_context",
-    "Get a safe, redacted overview of the project's secrets, environment, manifest, providers, hooks, and recent audit activity. No secret values are ever exposed. Use this to understand what secrets exist before asking to read them.",
-    {
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("get_project_context", params.projectPath);
-      if (toolBlock) return toolBlock;
-      const context = getProjectContext(opts(params));
-      return text(JSON.stringify(context, null, 2));
-    }
-  );
-  server2.tool(
-    "agent_remember",
-    "Store a key-value pair in encrypted agent memory that persists across sessions. Use this to remember decisions, rotation history, or project-specific context.",
-    {
-      key: z.string().describe("Memory key"),
-      value: z.string().describe("Value to store")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("agent_remember");
-      if (toolBlock) return toolBlock;
-      remember(params.key, params.value);
-      return text(`Remembered "${params.key}"`);
-    }
-  );
-  server2.tool(
-    "agent_recall",
-    "Retrieve a value from agent memory, or list all stored keys if no key is provided.",
-    {
-      key: z.string().optional().describe("Memory key to recall (omit to list all)")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("agent_recall");
-      if (toolBlock) return toolBlock;
-      if (!params.key) {
-        const entries = listMemory();
-        if (entries.length === 0) return text("Agent memory is empty");
-        return text(JSON.stringify(entries, null, 2));
+        return text(
+          `Scan failed: ${err instanceof Error ? err.message : String(err)}`,
+          true
+        );
       }
-      const value = recall(params.key);
-      if (value === null) return text(`No memory found for "${params.key}"`, true);
-      return text(value);
-    }
-  );
-  server2.tool(
-    "agent_forget",
-    "Delete a key from agent memory.",
-    {
-      key: z.string().describe("Memory key to forget")
-    },
-    async (params) => {
-      const toolBlock = enforceToolPolicy("agent_forget");
-      if (toolBlock) return toolBlock;
-      const removed = forget(params.key);
-      return text(removed ? `Forgot "${params.key}"` : `No memory found for "${params.key}"`, !removed);
     }
   );
   server2.tool(
     "lint_files",
-    "Scan specific files for hardcoded secrets. Optionally auto-fix by replacing them with process.env references and storing the values in q-ring.",
+    "[scan] Scan specific files for hardcoded secrets. Optionally auto-fix by replacing them with process.env references and storing the values in q-ring.",
     {
-      files: z.array(z.string()).describe("File paths to lint"),
-      fix: z.boolean().optional().default(false).describe("Auto-replace and store secrets"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      files: z9.array(z9.string()).describe("File paths to lint"),
+      fix: z9.boolean().optional().default(false).describe("Auto-replace and store secrets"),
+      scope: scope6,
+      projectPath: projectPath6,
+      teamId: teamId6,
+      orgId: orgId6
     },
     async (params) => {
       const toolBlock = enforceToolPolicy("lint_files", params.projectPath);
@@ -2142,18 +2309,21 @@ ${result.stderr}`);
         }
         return text(JSON.stringify(results, null, 2));
       } catch (err) {
-        return text(`Lint failed: ${err instanceof Error ? err.message : String(err)}`, true);
+        return text(
+          `Lint failed: ${err instanceof Error ? err.message : String(err)}`,
+          true
+        );
       }
     }
   );
   server2.tool(
     "analyze_secrets",
-    "Analyze secret usage patterns and provide optimization suggestions including most accessed, stale, unused, and rotation recommendations.",
+    "[agent] Analyze secret usage patterns and provide optimization suggestions including most accessed, stale, unused, and rotation recommendations.",
     {
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      scope: scope6,
+      projectPath: projectPath6,
+      teamId: teamId6,
+      orgId: orgId6
     },
     async (params) => {
       const toolBlock = enforceToolPolicy("analyze_secrets", params.projectPath);
@@ -2181,28 +2351,32 @@ ${result.stderr}`);
   let dashboardInstance = null;
   server2.tool(
     "status_dashboard",
-    "Launch the quantum status dashboard \u2014 a local web page showing live health, decay timers, superposition states, entanglement graph, tunnels, audit log, and anomaly alerts. Returns the URL to open in a browser.",
+    "[dashboard] Launch the quantum status dashboard \u2014 a local web page showing live health, decay timers, superposition states, entanglement graph, tunnels, audit log, and anomaly alerts. Returns the URL to open in a browser.",
     {
-      port: z.number().optional().default(9876).describe("Port to serve on")
+      port: z9.number().optional().default(9876).describe("Port to serve on")
     },
     async (params) => {
       const toolBlock = enforceToolPolicy("status_dashboard");
       if (toolBlock) return toolBlock;
       if (dashboardInstance) {
-        return text(`Dashboard already running at http://127.0.0.1:${dashboardInstance.port}`);
+        return text(
+          `Dashboard already running at http://127.0.0.1:${dashboardInstance.port}`
+        );
       }
-      const { startDashboardServer } = await import("./dashboard-Q5OQRQCX.js");
+      const { startDashboardServer } = await import("./dashboard-73QYM5FU.js");
       dashboardInstance = startDashboardServer({ port: params.port });
-      return text(`Dashboard started at http://127.0.0.1:${dashboardInstance.port}
-Open this URL in a browser to see live quantum status.`);
+      return text(
+        `Dashboard started at http://127.0.0.1:${dashboardInstance.port}
+Open this URL in a browser to see live quantum status.`
+      );
     }
   );
   server2.tool(
     "agent_scan",
-    "Run an autonomous agent health scan: checks decay, staleness, anomalies, and optionally auto-rotates expired secrets. Returns a structured report.",
+    "[agent] Run an autonomous agent health scan: checks decay, staleness, anomalies, and optionally auto-rotates expired secrets. Returns a structured report.",
     {
-      autoRotate: z.boolean().optional().default(false).describe("Auto-rotate expired secrets with generated values"),
-      projectPaths: z.array(z.string()).optional().describe("Project paths to monitor")
+      autoRotate: z9.boolean().optional().default(false).describe("Auto-rotate expired secrets with generated values"),
+      projectPaths: z9.array(z9.string()).optional().describe("Project paths to monitor")
     },
     async (params) => {
       const toolBlock = enforceToolPolicy("agent_scan");
@@ -2214,100 +2388,194 @@ Open this URL in a browser to see live quantum status.`);
       return text(JSON.stringify(report, null, 2));
     }
   );
+}
+
+// src/mcp/tools/agent.ts
+import { z as z10 } from "zod";
+
+// src/core/memory.ts
+import { existsSync as existsSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { join as join3 } from "path";
+import { homedir, hostname, userInfo } from "os";
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, createHash, randomBytes as randomBytes3 } from "crypto";
+import { Entry } from "@napi-rs/keyring";
+var MEMORY_FILE = "agent-memory.enc";
+var KEYRING_SERVICE = "qring-memory-key";
+var KEYRING_ACCOUNT = "encryption-key";
+function getMemoryDir() {
+  const dir = join3(homedir(), ".config", "q-ring");
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getMemoryPath() {
+  return join3(getMemoryDir(), MEMORY_FILE);
+}
+function deriveLegacyKey() {
+  const fingerprint = `qring-memory:${hostname()}:${userInfo().username}`;
+  return createHash("sha256").update(fingerprint).digest();
+}
+function getOrCreateKey() {
+  try {
+    const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+    const stored = entry.getPassword();
+    if (stored) return Buffer.from(stored, "base64");
+    const key = randomBytes3(32);
+    entry.setPassword(key.toString("base64"));
+    return key;
+  } catch {
+    console.warn("[q-ring] OS keyring unavailable for memory key \u2014 falling back to machine-derived key");
+    return deriveLegacyKey();
+  }
+}
+function encryptWith(data, key) {
+  const iv = randomBytes3(12);
+  const cipher = createCipheriv2("aes-256-gcm", key, iv);
+  const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return `${iv.toString("base64")}:${tag.toString("base64")}:${encrypted.toString("base64")}`;
+}
+function decryptWith(blob, key) {
+  const parts = blob.split(":");
+  if (parts.length !== 3) throw new Error("Invalid encrypted format");
+  const iv = Buffer.from(parts[0], "base64");
+  const tag = Buffer.from(parts[1], "base64");
+  const encrypted = Buffer.from(parts[2], "base64");
+  const decipher = createDecipheriv2("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  return decipher.update(encrypted) + decipher.final("utf8");
+}
+function encrypt(data) {
+  return encryptWith(data, getOrCreateKey());
+}
+function decrypt(blob) {
+  const key = getOrCreateKey();
+  try {
+    return decryptWith(blob, key);
+  } catch {
+    const legacy = deriveLegacyKey();
+    const plain = decryptWith(blob, legacy);
+    writeFileSync2(getMemoryPath(), encryptWith(plain, key), "utf8");
+    return plain;
+  }
+}
+function loadStore() {
+  const path = getMemoryPath();
+  if (!existsSync2(path)) {
+    return { entries: {} };
+  }
+  try {
+    const raw = readFileSync5(path, "utf8");
+    const decrypted = decrypt(raw);
+    return JSON.parse(decrypted);
+  } catch {
+    return { entries: {} };
+  }
+}
+function saveStore(store) {
+  const json = JSON.stringify(store);
+  const encrypted = encrypt(json);
+  writeFileSync2(getMemoryPath(), encrypted, "utf8");
+}
+function remember(key, value) {
+  const store = loadStore();
+  store.entries[key] = {
+    value,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveStore(store);
+}
+function recall(key) {
+  const store = loadStore();
+  return store.entries[key]?.value ?? null;
+}
+function listMemory() {
+  const store = loadStore();
+  return Object.entries(store.entries).map(([key, entry]) => ({
+    key,
+    updatedAt: entry.updatedAt
+  }));
+}
+function forget(key) {
+  const store = loadStore();
+  if (key in store.entries) {
+    delete store.entries[key];
+    saveStore(store);
+    return true;
+  }
+  return false;
+}
+
+// src/mcp/tools/agent.ts
+function registerAgentTools(server2) {
   server2.tool(
-    "verify_audit_chain",
-    "Verify the tamper-evident hash chain of the audit log. Returns integrity status and the first break point if tampered.",
-    {},
-    async () => {
-      const toolBlock = enforceToolPolicy("verify_audit_chain");
-      if (toolBlock) return toolBlock;
-      const result = verifyAuditChain();
-      return text(JSON.stringify(result, null, 2));
-    }
-  );
-  server2.tool(
-    "export_audit",
-    "Export audit events in a portable format (jsonl, json, or csv) with optional time range filtering.",
+    "agent_remember",
+    "[agent] Store a key-value pair in encrypted agent memory that persists across sessions. Use this to remember decisions, rotation history, or project-specific context.",
     {
-      since: z.string().optional().describe("Start date (ISO 8601)"),
-      until: z.string().optional().describe("End date (ISO 8601)"),
-      format: z.enum(["jsonl", "json", "csv"]).optional().default("jsonl").describe("Output format")
+      key: z10.string().describe("Memory key"),
+      value: z10.string().describe("Value to store")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("export_audit");
+      const toolBlock = enforceToolPolicy("agent_remember");
       if (toolBlock) return toolBlock;
-      const output = exportAudit({
-        since: params.since,
-        until: params.until,
-        format: params.format
-      });
-      return text(output);
+      remember(params.key, params.value);
+      return text(`Remembered "${params.key}"`);
     }
   );
   server2.tool(
-    "rotate_secret",
-    "Attempt issuer-native rotation of a secret via its detected or specified provider. Returns rotation result.",
+    "agent_recall",
+    "[agent] Retrieve a value from agent memory, or list all stored keys if no key is provided.",
     {
-      key: z.string().describe("The secret key to rotate"),
-      provider: z.string().optional().describe("Force a specific provider"),
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      key: z10.string().optional().describe("Memory key to recall (omit to list all)")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("rotate_secret", params.projectPath);
+      const toolBlock = enforceToolPolicy("agent_recall");
       if (toolBlock) return toolBlock;
-      const value = getSecret(params.key, opts(params));
-      if (!value) return text(`Secret "${params.key}" not found`, true);
-      const result = await rotateWithProvider(value, params.provider);
-      if (result.rotated && result.newValue) {
-        setSecret(params.key, result.newValue, {
-          scope: params.scope ?? "global",
-          projectPath: params.projectPath,
-          source: "mcp"
-        });
+      if (!params.key) {
+        const entries = listMemory();
+        if (entries.length === 0) return text("Agent memory is empty");
+        return text(JSON.stringify(entries, null, 2));
       }
-      return text(JSON.stringify(result, null, 2));
+      const value = recall(params.key);
+      if (value === null)
+        return text(`No memory found for "${params.key}"`, true);
+      return text(
+        JSON.stringify({ ok: true, data: { key: params.key, value } }, null, 2)
+      );
     }
   );
   server2.tool(
-    "ci_validate_secrets",
-    "CI-oriented batch validation: validates all accessible secrets against their providers and returns a structured pass/fail report.",
+    "agent_forget",
+    "[agent] Delete a key from agent memory.",
     {
-      scope: scopeSchema,
-      projectPath: projectPathSchema,
-      teamId: teamIdSchema,
-      orgId: orgIdSchema
+      key: z10.string().describe("Memory key to forget")
     },
     async (params) => {
-      const toolBlock = enforceToolPolicy("ci_validate_secrets", params.projectPath);
+      const toolBlock = enforceToolPolicy("agent_forget");
       if (toolBlock) return toolBlock;
-      const entries = listSecrets(opts(params));
-      const secrets = entries.map((e) => {
-        const val = getSecret(e.key, { ...opts(params), scope: e.scope, silent: true });
-        if (!val) return null;
-        return {
-          key: e.key,
-          value: val,
-          provider: e.envelope?.meta.provider,
-          validationUrl: e.envelope?.meta.validationUrl
-        };
-      }).filter((s) => s !== null);
-      if (secrets.length === 0) return text("No secrets to validate");
-      const report = await ciValidateBatch(secrets);
-      return text(JSON.stringify(report, null, 2));
+      const removed = forget(params.key);
+      return text(
+        removed ? `Forgot "${params.key}"` : `No memory found for "${params.key}"`,
+        !removed
+      );
     }
   );
+}
+
+// src/mcp/tools/policy.ts
+import { z as z11 } from "zod";
+var { projectPath: projectPath7 } = commonSchemas;
+function registerPolicyTools(server2) {
   server2.tool(
     "check_policy",
-    "Check if an action is allowed by the project's governance policy. Returns the policy decision and source.",
+    "[policy] Check if an action is allowed by the project's governance policy. Returns the policy decision and source.",
     {
-      action: z.enum(["tool", "key_read", "exec"]).describe("Type of policy check"),
-      toolName: z.string().optional().describe("Tool name to check (for action=tool)"),
-      key: z.string().optional().describe("Secret key to check (for action=key_read)"),
-      command: z.string().optional().describe("Command to check (for action=exec)"),
-      projectPath: projectPathSchema
+      action: z11.enum(["tool", "key_read", "exec"]).describe("Type of policy check"),
+      toolName: z11.string().optional().describe("Tool name to check (for action=tool)"),
+      key: z11.string().optional().describe("Secret key to check (for action=key_read)"),
+      command: z11.string().optional().describe("Command to check (for action=exec)"),
+      projectPath: projectPath7
     },
     async (params) => {
       if (params.action === "tool" && params.toolName) {
@@ -2322,20 +2590,51 @@ Open this URL in a browser to see live quantum status.`);
         const d = checkExecPolicy(params.command, params.projectPath);
         return text(JSON.stringify(d, null, 2));
       }
-      return text("Missing required parameter for the selected action type", true);
+      return text(
+        "Missing required parameter for the selected action type",
+        true
+      );
     }
   );
   server2.tool(
     "get_policy_summary",
-    "Get a summary of the project's governance policy configuration.",
+    "[policy] Get a summary of the project's governance policy configuration.",
     {
-      projectPath: projectPathSchema
+      projectPath: projectPath7
     },
     async (params) => {
+      const toolBlock = enforceToolPolicy(
+        "get_policy_summary",
+        params.projectPath
+      );
+      if (toolBlock) return toolBlock;
       const summary = getPolicySummary(params.projectPath);
       return text(JSON.stringify(summary, null, 2));
     }
   );
+}
+
+// src/mcp/tool-registration.ts
+function registerMcpTools(server2) {
+  registerSecretTools(server2);
+  registerProjectTools(server2);
+  registerTunnelTools(server2);
+  registerTeleportTools(server2);
+  registerAuditTools(server2);
+  registerValidationTools(server2);
+  registerHookTools(server2);
+  registerToolingTools(server2);
+  registerAgentTools(server2);
+  registerPolicyTools(server2);
+}
+
+// src/mcp/server.ts
+function createMcpServer() {
+  const server2 = new McpServer({
+    name: "q-ring",
+    version: PACKAGE_VERSION
+  });
+  registerMcpTools(server2);
   return server2;
 }