@i4ctime/q-ring 0.3.2 → 0.9.1

package/dist/mcp.js

@@ -1,22 +1,38 @@
 #!/usr/bin/env node
 import {
   checkDecay,
+  checkExecPolicy,
+  checkKeyReadPolicy,
+  checkToolPolicy,
   collapseEnvironment,
   deleteSecret,
   detectAnomalies,
+  disentangleSecrets,
   entangleSecrets,
+  exportAudit,
+  exportSecrets,
+  fireHooks,
   getEnvelope,
+  getExecMaxRuntime,
+  getPolicySummary,
   getSecret,
   hasSecret,
+  httpRequest_,
+  listHooks,
   listSecrets,
   logAudit,
   queryAudit,
+  readProjectConfig,
+  registerHook,
+  registry,
+  removeHook,
   setSecret,
   tunnelCreate,
   tunnelDestroy,
   tunnelList,
-  tunnelRead
-} from "./chunk-3WTTWJYU.js";
+  tunnelRead,
+  verifyAuditChain
+} from "./chunk-5JBU7TWN.js";
 
 // src/mcp.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -147,7 +163,9 @@ function runHealthScan(config = {}) {
         `EXPIRED: ${entry.key} [${entry.scope}] \u2014 expired ${decay.timeRemaining}`
       );
       if (cfg.autoRotate) {
-        const newValue = generateSecret({ format: "api-key" });
+        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],
@@ -161,6 +179,14 @@ function runHealthScan(config = {}) {
           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++;
@@ -240,6 +266,858 @@ function teleportUnpack(encoded, passphrase) {
   return JSON.parse(decrypted.toString("utf8"));
 }
 
+// src/core/import.ts
+import { readFileSync } from "fs";
+function parseDotenv(content) {
+  const result = /* @__PURE__ */ new Map();
+  const lines = content.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith("#")) continue;
+    const eqIdx = line.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = line.slice(0, eqIdx).trim();
+    let value = line.slice(eqIdx + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\\\/g, "\\").replace(/\\"/g, '"');
+    if (value.includes("#") && !line.includes('"') && !line.includes("'")) {
+      value = value.split("#")[0].trim();
+    }
+    if (key) result.set(key, value);
+  }
+  return result;
+}
+function importDotenv(filePathOrContent, options = {}) {
+  let content;
+  try {
+    content = readFileSync(filePathOrContent, "utf8");
+  } catch {
+    content = filePathOrContent;
+  }
+  const pairs = parseDotenv(content);
+  const result = {
+    imported: [],
+    skipped: [],
+    total: pairs.size
+  };
+  for (const [key, value] of pairs) {
+    if (options.skipExisting && hasSecret(key, {
+      scope: options.scope,
+      projectPath: options.projectPath,
+      source: options.source ?? "cli"
+    })) {
+      result.skipped.push(key);
+      continue;
+    }
+    if (options.dryRun) {
+      result.imported.push(key);
+      continue;
+    }
+    const setOpts = {
+      scope: options.scope ?? "global",
+      projectPath: options.projectPath ?? process.cwd(),
+      source: options.source ?? "cli"
+    };
+    setSecret(key, value, setOpts);
+    result.imported.push(key);
+  }
+  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 };
+}
+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) => 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);
+      }
+    }
+  }
+  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 });
+      }
+      process.stderr.write(msg + "\n");
+      return resolve({ code: 126, stdout: "", stderr: "" });
+    }
+    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);
+    }
+    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);
+    }
+    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;
+    }
+    for (const entry of entries) {
+      if (IGNORE_DIRS.has(entry)) continue;
+      const fullPath = join(currentDir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      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))
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  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;
+    }
+    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
+        });
+      }
+    }
+    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;
+}
+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 });
+}
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    this.providers.set(provider.name, provider);
+  }
+  get(name) {
+    return this.providers.get(name);
+  }
+  detectProvider(value, hints) {
+    if (hints?.provider) {
+      return this.providers.get(hints.provider);
+    }
+    for (const provider of this.providers.values()) {
+      if (provider.prefixes) {
+        for (const pfx of provider.prefixes) {
+          if (value.startsWith(pfx)) return provider;
+        }
+      }
+    }
+    return void 0;
+  }
+  listProviders() {
+    return [...this.providers.values()];
+  }
+};
+var openaiProvider = {
+  name: "openai",
+  description: "OpenAI API key validation",
+  prefixes: ["sk-"],
+  async validate(value) {
+    const start = Date.now();
+    try {
+      const { statusCode } = await makeRequest(
+        "https://api.openai.com/v1/models?limit=1",
+        {
+          Authorization: `Bearer ${value}`,
+          "User-Agent": "q-ring-validator/1.0"
+        }
+      );
+      const latencyMs = Date.now() - start;
+      if (statusCode === 200)
+        return { valid: true, status: "valid", message: "API key is valid", latencyMs, provider: "openai" };
+      if (statusCode === 401)
+        return { valid: false, status: "invalid", message: "Invalid or revoked API key", latencyMs, provider: "openai" };
+      if (statusCode === 429)
+        return { valid: true, status: "error", message: "Rate limited \u2014 key may be valid", latencyMs, provider: "openai" };
+      return { valid: false, status: "error", message: `Unexpected status ${statusCode}`, latencyMs, provider: "openai" };
+    } catch (err) {
+      return { valid: false, status: "error", message: `${err instanceof Error ? err.message : "Network error"}`, latencyMs: Date.now() - start, provider: "openai" };
+    }
+  }
+};
+var stripeProvider = {
+  name: "stripe",
+  description: "Stripe API key validation",
+  prefixes: ["sk_live_", "sk_test_", "rk_live_", "rk_test_", "pk_live_", "pk_test_"],
+  async validate(value) {
+    const start = Date.now();
+    try {
+      const { statusCode } = await makeRequest(
+        "https://api.stripe.com/v1/balance",
+        {
+          Authorization: `Bearer ${value}`,
+          "User-Agent": "q-ring-validator/1.0"
+        }
+      );
+      const latencyMs = Date.now() - start;
+      if (statusCode === 200)
+        return { valid: true, status: "valid", message: "API key is valid", latencyMs, provider: "stripe" };
+      if (statusCode === 401)
+        return { valid: false, status: "invalid", message: "Invalid or revoked API key", latencyMs, provider: "stripe" };
+      if (statusCode === 429)
+        return { valid: true, status: "error", message: "Rate limited \u2014 key may be valid", latencyMs, provider: "stripe" };
+      return { valid: false, status: "error", message: `Unexpected status ${statusCode}`, latencyMs, provider: "stripe" };
+    } catch (err) {
+      return { valid: false, status: "error", message: `${err instanceof Error ? err.message : "Network error"}`, latencyMs: Date.now() - start, provider: "stripe" };
+    }
+  }
+};
+var githubProvider = {
+  name: "github",
+  description: "GitHub token validation",
+  prefixes: ["ghp_", "gho_", "ghu_", "ghs_", "ghr_", "github_pat_"],
+  async validate(value) {
+    const start = Date.now();
+    try {
+      const { statusCode } = await makeRequest(
+        "https://api.github.com/user",
+        {
+          Authorization: `token ${value}`,
+          "User-Agent": "q-ring-validator/1.0",
+          Accept: "application/vnd.github+json"
+        }
+      );
+      const latencyMs = Date.now() - start;
+      if (statusCode === 200)
+        return { valid: true, status: "valid", message: "Token is valid", latencyMs, provider: "github" };
+      if (statusCode === 401)
+        return { valid: false, status: "invalid", message: "Invalid or expired token", latencyMs, provider: "github" };
+      if (statusCode === 403)
+        return { valid: false, status: "invalid", message: "Token lacks required permissions", latencyMs, provider: "github" };
+      if (statusCode === 429)
+        return { valid: true, status: "error", message: "Rate limited \u2014 token may be valid", latencyMs, provider: "github" };
+      return { valid: false, status: "error", message: `Unexpected status ${statusCode}`, latencyMs, provider: "github" };
+    } catch (err) {
+      return { valid: false, status: "error", message: `${err instanceof Error ? err.message : "Network error"}`, latencyMs: Date.now() - start, provider: "github" };
+    }
+  }
+};
+var awsProvider = {
+  name: "aws",
+  description: "AWS access key validation (checks key format only \u2014 full STS validation requires secret key + region)",
+  prefixes: ["AKIA", "ASIA"],
+  async validate(value) {
+    const start = Date.now();
+    const latencyMs = Date.now() - start;
+    if (/^(AKIA|ASIA)[A-Z0-9]{16}$/.test(value)) {
+      return { valid: true, status: "unknown", message: "Valid AWS access key format (STS validation requires secret key)", latencyMs, provider: "aws" };
+    }
+    return { valid: false, status: "invalid", message: "Invalid AWS access key format", latencyMs, provider: "aws" };
+  }
+};
+var httpProvider = {
+  name: "http",
+  description: "Generic HTTP endpoint validation",
+  async validate(value, url) {
+    const start = Date.now();
+    if (!url) {
+      return { valid: false, status: "unknown", message: "No validation URL configured", latencyMs: 0, provider: "http" };
+    }
+    try {
+      const { statusCode } = await makeRequest(url, {
+        Authorization: `Bearer ${value}`,
+        "User-Agent": "q-ring-validator/1.0"
+      });
+      const latencyMs = Date.now() - start;
+      if (statusCode >= 200 && statusCode < 300)
+        return { valid: true, status: "valid", message: `Endpoint returned ${statusCode}`, latencyMs, provider: "http" };
+      if (statusCode === 401 || statusCode === 403)
+        return { valid: false, status: "invalid", message: `Authentication failed (${statusCode})`, latencyMs, provider: "http" };
+      return { valid: false, status: "error", message: `Unexpected status ${statusCode}`, latencyMs, provider: "http" };
+    } catch (err) {
+      return { valid: false, status: "error", message: `${err instanceof Error ? err.message : "Network error"}`, latencyMs: Date.now() - start, provider: "http" };
+    }
+  }
+};
+var registry2 = new ProviderRegistry();
+registry2.register(openaiProvider);
+registry2.register(stripeProvider);
+registry2.register(githubProvider);
+registry2.register(awsProvider);
+registry2.register(httpProvider);
+async function validateSecret(value, opts2) {
+  const provider = opts2?.provider ? registry2.get(opts2.provider) : registry2.detectProvider(value);
+  if (!provider) {
+    return {
+      valid: false,
+      status: "unknown",
+      message: "No provider detected \u2014 set a provider in the manifest or secret metadata",
+      latencyMs: 0,
+      provider: "none"
+    };
+  }
+  if (provider.name === "http" && opts2?.validationUrl) {
+    return provider.validate(value, opts2.validationUrl);
+  }
+  return provider.validate(value);
+}
+async function rotateWithProvider(value, providerName) {
+  const provider = providerName ? registry2.get(providerName) : registry2.detectProvider(value);
+  if (!provider) {
+    return { rotated: false, provider: "none", message: "No provider detected for rotation" };
+  }
+  const rotatable = provider;
+  if (rotatable.supportsRotation && rotatable.rotate) {
+    return rotatable.rotate(value);
+  }
+  const format = "api-key";
+  const newValue = generateSecret({ format, length: 48 });
+  return {
+    rotated: true,
+    provider: provider.name,
+    message: `Provider "${provider.name}" does not support native rotation \u2014 generated new value locally`,
+    newValue
+  };
+}
+async function ciValidateBatch(secrets) {
+  const results = [];
+  for (const s of secrets) {
+    const validation = await validateSecret(s.value, {
+      provider: s.provider,
+      validationUrl: s.validationUrl
+    });
+    results.push({
+      key: s.key,
+      validation,
+      requiresRotation: validation.status === "invalid"
+    });
+  }
+  const failCount = results.filter((r) => !r.validation.valid).length;
+  return { results, allValid: failCount === 0, failCount };
+}
+
+// src/core/context.ts
+function getProjectContext(opts2 = {}) {
+  const projectPath = opts2.projectPath ?? process.cwd();
+  const envResult = collapseEnvironment({ projectPath });
+  const secretsList = listSecrets({
+    ...opts2,
+    projectPath,
+    silent: true
+  });
+  let expiredCount = 0;
+  let staleCount = 0;
+  let protectedCount = 0;
+  const secrets = secretsList.map((entry) => {
+    const meta = entry.envelope?.meta;
+    const decay = entry.decay;
+    if (decay?.isExpired) expiredCount++;
+    if (decay?.isStale) staleCount++;
+    if (meta?.requiresApproval) protectedCount++;
+    return {
+      key: entry.key,
+      scope: entry.scope,
+      tags: meta?.tags,
+      description: meta?.description,
+      provider: meta?.provider,
+      requiresApproval: meta?.requiresApproval,
+      jitProvider: meta?.jitProvider,
+      hasStates: !!(entry.envelope?.states && Object.keys(entry.envelope.states).length > 0),
+      isExpired: decay?.isExpired ?? false,
+      isStale: decay?.isStale ?? false,
+      timeRemaining: decay?.timeRemaining ?? null,
+      accessCount: meta?.accessCount ?? 0,
+      lastAccessed: meta?.lastAccessedAt ?? null,
+      rotationFormat: meta?.rotationFormat
+    };
+  });
+  let manifest = null;
+  const config = readProjectConfig(projectPath);
+  if (config?.secrets) {
+    const declaredKeys = Object.keys(config.secrets);
+    const existingKeys = new Set(secrets.map((s) => s.key));
+    const missing = declaredKeys.filter((k) => !existingKeys.has(k));
+    manifest = { declared: declaredKeys.length, missing };
+  }
+  const recentEvents = queryAudit({ limit: 20 });
+  const recentActions = recentEvents.map((e) => ({
+    action: e.action,
+    key: e.key,
+    source: e.source,
+    timestamp: e.timestamp
+  }));
+  return {
+    projectPath,
+    environment: envResult ? { env: envResult.env, source: envResult.source } : null,
+    secrets,
+    totalSecrets: secrets.length,
+    expiredCount,
+    staleCount,
+    protectedCount,
+    manifest,
+    validationProviders: registry2.listProviders().map((p) => p.name),
+    jitProviders: registry.listProviders().map((p) => p.name),
+    hooksCount: listHooks().length,
+    recentActions
+  };
+}
+
+// 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();
+}
+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()]);
+  const tag = cipher.getAuthTag();
+  return `${iv.toString("base64")}:${tag.toString("base64")}:${encrypted.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);
+  decipher.setAuthTag(tag);
+  return decipher.update(encrypted) + decipher.final("utf8");
+}
+function loadStore() {
+  const path = getMemoryPath();
+  if (!existsSync2(path)) {
+    return { entries: {} };
+  }
+  try {
+    const raw = readFileSync4(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/server.ts
 function text(t, isError = false) {
   return {
@@ -251,16 +1129,27 @@ 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 scopeSchema = z.enum(["global", "project"]).optional().describe("Scope: global or project");
+  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)");
   server2.tool(
@@ -270,23 +1159,63 @@ function createMcpServer() {
       key: z.string().describe("The secret key name"),
       scope: scopeSchema,
       projectPath: projectPathSchema,
-      env: envSchema
+      env: envSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
     },
     async (params) => {
-      const value = getSecret(params.key, opts(params));
-      if (value === null) return text(`Secret "${params.key}" not found`, true);
-      return text(value);
+      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(value);
+      } catch (err) {
+        return text(err instanceof Error ? err.message : String(err), true);
+      }
     }
   );
   server2.tool(
     "list_secrets",
-    "List all secret keys with quantum metadata (scope, decay status, superposition states, entanglement, access count). Values are never exposed.",
+    "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: scopeSchema,
-      projectPath: projectPathSchema
+      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
     },
     async (params) => {
-      const entries = listSecrets(opts(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) {
+        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}`];
@@ -323,9 +1252,15 @@ function createMcpServer() {
       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")
+      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
     },
     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);
@@ -340,7 +1275,9 @@ function createMcpServer() {
           defaultEnv: existing?.envelope?.defaultEnv ?? params.env,
           ttlSeconds: params.ttlSeconds,
           description: params.description,
-          tags: params.tags
+          tags: params.tags,
+          rotationFormat: params.rotationFormat,
+          rotationPrefix: params.rotationPrefix
         });
         return text(`[${params.scope ?? "global"}] ${params.key} set for env:${params.env}`);
       }
@@ -348,7 +1285,9 @@ function createMcpServer() {
         ...o,
         ttlSeconds: params.ttlSeconds,
         description: params.description,
-        tags: params.tags
+        tags: params.tags,
+        rotationFormat: params.rotationFormat,
+        rotationPrefix: params.rotationPrefix
       });
       return text(`[${params.scope ?? "global"}] ${params.key} saved`);
     }
@@ -359,9 +1298,13 @@ function createMcpServer() {
     {
       key: z.string().describe("The secret key name"),
       scope: scopeSchema,
-      projectPath: projectPathSchema
+      projectPath: projectPathSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
     },
     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`,
@@ -375,21 +1318,185 @@ function createMcpServer() {
     {
       key: z.string().describe("The secret key name"),
       scope: scopeSchema,
-      projectPath: projectPathSchema
+      projectPath: projectPathSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
     },
     async (params) => {
+      const toolBlock = enforceToolPolicy("has_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
       return text(hasSecret(params.key, opts(params)) ? "true" : "false");
     }
   );
+  server2.tool(
+    "export_secrets",
+    "Export secrets as .env or JSON format. Collapses superposition. Supports filtering by specific keys or tags.",
+    {
+      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
+    },
+    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);
+    }
+  );
+  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.",
+    {
+      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")
+    },
+    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 (result.skipped.length > 0) {
+        lines.push(`Skipped (existing): ${result.skipped.join(", ")}`);
+      }
+      return text(lines.join("\n"));
+    }
+  );
+  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);
+      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));
+    }
+  );
+  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.",
+    {
+      projectPath: projectPathSchema,
+      env: envSchema
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("env_generate", 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,
+          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);
+    }
+  );
   server2.tool(
     "inspect_secret",
     "Show full quantum state of a secret: superposition states, decay status, entanglement links, access history. Never reveals the actual value.",
     {
       key: z.string().describe("The secret key name"),
       scope: scopeSchema,
-      projectPath: projectPathSchema
+      projectPath: projectPathSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
     },
     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 } = result;
@@ -430,6 +1537,8 @@ function createMcpServer() {
       projectPath: projectPathSchema
     },
     async (params) => {
+      const toolBlock = enforceToolPolicy("detect_environment", params.projectPath);
+      if (toolBlock) return toolBlock;
       const result = collapseEnvironment({
         projectPath: params.projectPath ?? process.cwd()
       });
@@ -450,9 +1559,13 @@ function createMcpServer() {
       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
+      projectPath: projectPathSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
     },
     async (params) => {
+      const toolBlock = enforceToolPolicy("generate_secret", params.projectPath);
+      if (toolBlock) return toolBlock;
       const secret = generateSecret({
         format: params.format,
         length: params.length,
@@ -483,6 +1596,8 @@ function createMcpServer() {
       targetProjectPath: z.string().optional()
     },
     async (params) => {
+      const toolBlock = enforceToolPolicy("entangle_secrets", params.sourceProjectPath);
+      if (toolBlock) return toolBlock;
       entangleSecrets(
         params.sourceKey,
         {
@@ -500,6 +1615,37 @@ function createMcpServer() {
       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}`);
+    }
+  );
   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.",
@@ -509,6 +1655,8 @@ function createMcpServer() {
       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
@@ -523,6 +1671,8 @@ function createMcpServer() {
       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);
@@ -535,6 +1685,8 @@ function createMcpServer() {
     "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) => {
@@ -557,6 +1709,8 @@ function createMcpServer() {
       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`,
@@ -571,9 +1725,13 @@ function createMcpServer() {
       keys: z.array(z.string()).optional().describe("Specific keys to pack (all if omitted)"),
       passphrase: z.string().describe("Encryption passphrase"),
       scope: scopeSchema,
-      projectPath: projectPathSchema
+      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 = [];
@@ -597,9 +1755,13 @@ function createMcpServer() {
       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;
       try {
         const payload = teleportUnpack(params.bundle, params.passphrase);
         if (params.dryRun) {
@@ -626,6 +1788,8 @@ ${preview}`);
       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,
@@ -650,6 +1814,8 @@ ${preview}`);
       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(
@@ -663,9 +1829,13 @@ ${preview}`);
     "Run a comprehensive health check on all secrets: decay status, staleness, anomalies, entropy assessment.",
     {
       scope: scopeSchema,
-      projectPath: projectPathSchema
+      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;
@@ -708,6 +1878,299 @@ ${preview}`);
       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));
+    }
+  );
+  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
+      );
+    }
+  );
+  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.",
+    {
+      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
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("exec_with_secrets", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const execBlock = checkExecPolicy(params.command, params.projectPath);
+      if (!execBlock.allowed) {
+        return text(`Policy Denied: ${execBlock.reason}`, true);
+      }
+      try {
+        const result = await execCommand({
+          command: params.command,
+          args: params.args ?? [],
+          keys: params.keys,
+          tags: params.tags,
+          profile: params.profile,
+          scope: params.scope,
+          projectPath: params.projectPath,
+          source: "mcp",
+          captureOutput: true
+        });
+        const output = [];
+        output.push(`Exit code: ${result.code}`);
+        if (result.stdout) output.push(`STDOUT:
+${result.stdout}`);
+        if (result.stderr) output.push(`STDERR:
+${result.stderr}`);
+        return text(output.join("\n\n"));
+      } catch (err) {
+        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.",
+    {
+      dirPath: z.string().describe("Absolute or relative path to the directory to scan")
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("scan_codebase_for_secrets");
+      if (toolBlock) return toolBlock;
+      try {
+        const results = scanCodebase(params.dirPath);
+        if (results.length === 0) {
+          return text("No hardcoded secrets found in the specified directory.");
+        }
+        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));
+      }
+      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.",
+    {
+      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
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("lint_files", params.projectPath);
+      if (toolBlock) return toolBlock;
+      try {
+        const results = lintFiles(params.files, {
+          fix: params.fix,
+          scope: params.scope,
+          projectPath: params.projectPath
+        });
+        if (results.length === 0) {
+          return text("No hardcoded secrets found in the specified files.");
+        }
+        return text(JSON.stringify(results, null, 2));
+      } catch (err) {
+        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.",
+    {
+      scope: scopeSchema,
+      projectPath: projectPathSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("analyze_secrets", params.projectPath);
+      if (toolBlock) return toolBlock;
+      const o = opts(params);
+      const entries = listSecrets({ ...o, silent: true });
+      const audit = queryAudit({ limit: 500 });
+      const accessMap = /* @__PURE__ */ new Map();
+      for (const e of audit) {
+        if (e.action === "read" && e.key) {
+          accessMap.set(e.key, (accessMap.get(e.key) || 0) + 1);
+        }
+      }
+      const analysis = {
+        total: entries.length,
+        expired: entries.filter((e) => e.decay?.isExpired).length,
+        stale: entries.filter((e) => e.decay?.isStale && !e.decay?.isExpired).length,
+        neverAccessed: entries.filter((e) => (e.envelope?.meta.accessCount ?? 0) === 0).map((e) => e.key),
+        noRotationFormat: entries.filter((e) => !e.envelope?.meta.rotationFormat).map((e) => e.key),
+        mostAccessed: [...accessMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([key, count]) => ({ key, reads: count }))
+      };
+      return text(JSON.stringify(analysis, null, 2));
+    }
+  );
   let dashboardInstance = null;
   server2.tool(
     "status_dashboard",
@@ -716,10 +2179,12 @@ ${preview}`);
       port: z.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}`);
       }
-      const { startDashboardServer } = await import("./dashboard-QQWKOOI5.js");
+      const { startDashboardServer } = await import("./dashboard-Q5OQRQCX.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.`);
@@ -733,6 +2198,8 @@ Open this URL in a browser to see live quantum status.`);
       projectPaths: z.array(z.string()).optional().describe("Project paths to monitor")
     },
     async (params) => {
+      const toolBlock = enforceToolPolicy("agent_scan");
+      if (toolBlock) return toolBlock;
       const report = runHealthScan({
         autoRotate: params.autoRotate,
         projectPaths: params.projectPaths ?? [process.cwd()]
@@ -740,6 +2207,128 @@ Open this URL in a browser to see live quantum status.`);
       return text(JSON.stringify(report, null, 2));
     }
   );
+  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.",
+    {
+      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")
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("export_audit");
+      if (toolBlock) return toolBlock;
+      const output = exportAudit({
+        since: params.since,
+        until: params.until,
+        format: params.format
+      });
+      return text(output);
+    }
+  );
+  server2.tool(
+    "rotate_secret",
+    "Attempt issuer-native rotation of a secret via its detected or specified provider. Returns rotation result.",
+    {
+      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
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("rotate_secret", params.projectPath);
+      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"
+        });
+      }
+      return text(JSON.stringify(result, 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.",
+    {
+      scope: scopeSchema,
+      projectPath: projectPathSchema,
+      teamId: teamIdSchema,
+      orgId: orgIdSchema
+    },
+    async (params) => {
+      const toolBlock = enforceToolPolicy("ci_validate_secrets", params.projectPath);
+      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));
+    }
+  );
+  server2.tool(
+    "check_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
+    },
+    async (params) => {
+      if (params.action === "tool" && params.toolName) {
+        const d = checkToolPolicy(params.toolName, params.projectPath);
+        return text(JSON.stringify(d, null, 2));
+      }
+      if (params.action === "key_read" && params.key) {
+        const d = checkKeyReadPolicy(params.key, void 0, params.projectPath);
+        return text(JSON.stringify(d, null, 2));
+      }
+      if (params.action === "exec" && params.command) {
+        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);
+    }
+  );
+  server2.tool(
+    "get_policy_summary",
+    "Get a summary of the project's governance policy configuration.",
+    {
+      projectPath: projectPathSchema
+    },
+    async (params) => {
+      const summary = getPolicySummary(params.projectPath);
+      return text(JSON.stringify(summary, null, 2));
+    }
+  );
   return server2;
 }