@i4ctime/q-ring 0.10.1 → 0.11.5

package/dist/{chunk-LLMO64FE.js → chunk-A4RZVP3P.js}

@@ -1,5 +1,22 @@
 #!/usr/bin/env node
 
+// 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/core/envelope.ts
 import { z } from "zod";
 var EntanglementLinkSchema = z.object({
@@ -162,8 +179,8 @@ function recordAccess(envelope) {
 
 // src/core/collapse.ts
 import { execSync } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 var BRANCH_ENV_MAP = {
   main: "prod",
   master: "prod",
@@ -190,10 +207,10 @@ function detectGitBranch(cwd) {
   }
 }
 function readProjectConfig(projectPath) {
-  const configPath = join(projectPath ?? process.cwd(), ".q-ring.json");
+  const configPath = join2(projectPath ?? process.cwd(), ".q-ring.json");
   try {
     if (existsSync(configPath)) {
-      return JSON.parse(readFileSync(configPath, "utf8"));
+      return JSON.parse(readFileSync2(configPath, "utf8"));
     }
   } catch {
   }
@@ -254,14 +271,14 @@ import {
   existsSync as existsSync2,
   mkdirSync,
   appendFileSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   openSync,
   fstatSync,
   readSync,
   closeSync,
   statSync
 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { homedir } from "os";
 import { createHash } from "crypto";
 function getAuditDir() {
@@ -271,14 +288,14 @@ function getAuditDir() {
     }
     return process.env.QRING_AUDIT_DIR;
   }
-  const dir = join2(homedir(), ".config", "q-ring");
+  const dir = join3(homedir(), ".config", "q-ring");
   if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getAuditPath() {
-  return join2(getAuditDir(), "audit.jsonl");
+  return join3(getAuditDir(), "audit.jsonl");
 }
 function getLastLineHash() {
   const path = getAuditPath();
@@ -363,7 +380,7 @@ function verifyAuditChain() {
   if (!existsSync2(path)) {
     return { totalEvents: 0, validEvents: 0, intact: true };
   }
-  const lines = readFileSync2(path, "utf8").split("\n").filter((l) => l.trim());
+  const lines = readFileSync3(path, "utf8").split("\n").filter((l) => l.trim());
   if (lines.length === 0) {
     return { totalEvents: 0, validEvents: 0, intact: true };
   }
@@ -401,7 +418,7 @@ function verifyAuditChain() {
 function exportAudit(opts = {}) {
   const path = getAuditPath();
   if (!existsSync2(path)) return opts.format === "json" ? "[]" : "";
-  const lines = readFileSync2(path, "utf8").split("\n").filter((l) => l.trim());
+  const lines = readFileSync3(path, "utf8").split("\n").filter((l) => l.trim());
   let events = lines.map((l) => {
     try {
       return JSON.parse(l);
@@ -466,15 +483,15 @@ function detectAnomalies(key) {
 }
 
 // src/core/entanglement.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 function getRegistryPath() {
-  const dir = join3(homedir2(), ".config", "q-ring");
+  const dir = join4(homedir2(), ".config", "q-ring");
   if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  return join3(dir, "entanglement.json");
+  return join4(dir, "entanglement.json");
 }
 function loadRegistry() {
   const path = getRegistryPath();
@@ -482,7 +499,7 @@ function loadRegistry() {
     return { pairs: [] };
   }
   try {
-    return JSON.parse(readFileSync3(path, "utf8"));
+    return JSON.parse(readFileSync4(path, "utf8"));
   } catch {
     return { pairs: [] };
   }
@@ -528,67 +545,9 @@ function listEntanglements() {
   return loadRegistry().pairs;
 }
 
-// src/core/keyring.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, unlinkSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
-import { Entry, findCredentials } from "@napi-rs/keyring";
-
-// src/utils/hash.ts
-import { createHash as createHash2 } from "crypto";
-function hashProjectPath(projectPath) {
-  return createHash2("sha256").update(projectPath).digest("hex").slice(0, 12);
-}
-
-// src/core/scope.ts
-var SERVICE_PREFIX = "q-ring";
-function globalService() {
-  return `${SERVICE_PREFIX}:global`;
-}
-function projectService(projectPath) {
-  const hash = hashProjectPath(projectPath);
-  return `${SERVICE_PREFIX}:project:${hash}`;
-}
-function teamService(teamId) {
-  return `${SERVICE_PREFIX}:team:${teamId}`;
-}
-function orgService(orgId) {
-  return `${SERVICE_PREFIX}:org:${orgId}`;
-}
-function resolveScope(opts) {
-  const { scope, projectPath, teamId, orgId } = opts;
-  if (scope === "global") {
-    return [{ scope: "global", service: globalService() }];
-  }
-  if (scope === "project") {
-    if (!projectPath) throw new Error("Project path is required for project scope");
-    return [{ scope: "project", service: projectService(projectPath), projectPath }];
-  }
-  if (scope === "team") {
-    if (!teamId) throw new Error("Team ID is required for team scope");
-    return [{ scope: "team", service: teamService(teamId), teamId }];
-  }
-  if (scope === "org") {
-    if (!orgId) throw new Error("Org ID is required for org scope");
-    return [{ scope: "org", service: orgService(orgId), orgId }];
-  }
-  const chain = [];
-  if (projectPath) {
-    chain.push({ scope: "project", service: projectService(projectPath), projectPath });
-  }
-  if (teamId) {
-    chain.push({ scope: "team", service: teamService(teamId), teamId });
-  }
-  if (orgId) {
-    chain.push({ scope: "org", service: orgService(orgId), orgId });
-  }
-  chain.push({ scope: "global", service: globalService() });
-  return chain;
-}
-
 // src/core/hooks.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 import { execFile, spawn } from "child_process";
 import { randomUUID } from "crypto";
@@ -678,16 +637,16 @@ function httpRequest(opts) {
 import { lookup } from "dns/promises";
 import * as dns from "dns";
 import { isIPv4, isIPv6 } from "net";
-function lookupAddressesSync(hostname) {
+function lookupAddressesSync(hostname2) {
   const lookupSync2 = dns.lookupSync;
-  return lookupSync2(hostname, { all: true });
+  return lookupSync2(hostname2, { all: true });
 }
-function isHostnameIpLiteral(hostname) {
-  if (isIPv4(hostname)) return true;
-  if (hostname.startsWith("[") && hostname.endsWith("]")) {
-    return isIPv6(hostname.slice(1, -1));
+function isHostnameIpLiteral(hostname2) {
+  if (isIPv4(hostname2)) return true;
+  if (hostname2.startsWith("[") && hostname2.endsWith("]")) {
+    return isIPv6(hostname2.slice(1, -1));
   }
-  return isIPv6(hostname);
+  return isIPv6(hostname2);
 }
 function isPrivateIP(ip) {
   const octet = "(?:25[0-5]|2[0-4]\\d|1?\\d{1,2})";
@@ -709,14 +668,14 @@ async function checkSSRF(url) {
   if (process.env.Q_RING_ALLOW_PRIVATE_HOOKS === "1") return null;
   try {
     const parsed = new URL(url);
-    const hostname = parsed.hostname.replace(/^\[|\]$/g, "");
-    if (isPrivateIP(hostname)) {
-      return `Blocked: URL resolves to private address (${hostname}). Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
+    const hostname2 = parsed.hostname.replace(/^\[|\]$/g, "");
+    if (isPrivateIP(hostname2)) {
+      return `Blocked: URL resolves to private address (${hostname2}). Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
     }
-    const results = await lookup(hostname, { all: true });
+    const results = await lookup(hostname2, { all: true });
     for (const { address } of results) {
       if (isPrivateIP(address)) {
-        return `Blocked: URL "${hostname}" resolves to private address ${address}. Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
+        return `Blocked: URL "${hostname2}" resolves to private address ${address}. Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
       }
     }
   } catch {
@@ -730,28 +689,28 @@ function checkJitHttpProvisionUrl(url) {
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
       return "Blocked: JIT HTTP provider only allows http: or https: URLs.";
     }
-    const hostname = parsed.hostname.replace(/^\[|\]$/g, "");
-    if (!hostname) {
+    const hostname2 = parsed.hostname.replace(/^\[|\]$/g, "");
+    if (!hostname2) {
       return "Blocked: empty hostname in JIT URL.";
     }
-    if (isPrivateIP(hostname)) {
-      return `Blocked: URL resolves to private address (${hostname}). Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
+    if (isPrivateIP(hostname2)) {
+      return `Blocked: URL resolves to private address (${hostname2}). Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
     }
-    if (isHostnameIpLiteral(hostname)) {
+    if (isHostnameIpLiteral(hostname2)) {
       return null;
     }
     let results;
     try {
-      results = lookupAddressesSync(hostname);
+      results = lookupAddressesSync(hostname2);
     } catch {
-      return `Blocked: DNS resolution failed for "${hostname}" (JIT HTTP provisioning fails closed).`;
+      return `Blocked: DNS resolution failed for "${hostname2}" (JIT HTTP provisioning fails closed).`;
     }
     if (!results.length) {
-      return `Blocked: DNS returned no addresses for "${hostname}".`;
+      return `Blocked: DNS returned no addresses for "${hostname2}".`;
     }
     for (const { address } of results) {
       if (isPrivateIP(address)) {
-        return `Blocked: URL "${hostname}" resolves to private address ${address}. Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
+        return `Blocked: URL "${hostname2}" resolves to private address ${address}. Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
       }
     }
   } catch {
@@ -762,11 +721,11 @@ function checkJitHttpProvisionUrl(url) {
 
 // src/core/hooks.ts
 function getRegistryPath2() {
-  const dir = join4(homedir3(), ".config", "q-ring");
+  const dir = join5(homedir3(), ".config", "q-ring");
   if (!existsSync4(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
-  return join4(dir, "hooks.json");
+  return join5(dir, "hooks.json");
 }
 function loadRegistry2() {
   const path = getRegistryPath2();
@@ -774,7 +733,7 @@ function loadRegistry2() {
     return { hooks: [] };
   }
   try {
-    return JSON.parse(readFileSync4(path, "utf8"));
+    return JSON.parse(readFileSync5(path, "utf8"));
   } catch {
     return { hooks: [] };
   }
@@ -1043,16 +1002,16 @@ async function fireHooks(payload, tags) {
 }
 
 // src/core/approval.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir4 } from "os";
 import { createHmac, randomBytes, timingSafeEqual } from "crypto";
 function getHmacSecret() {
-  const dir = join5(homedir4(), ".config", "q-ring");
-  const secretPath = join5(dir, ".approval-key");
+  const dir = join6(homedir4(), ".config", "q-ring");
+  const secretPath = join6(dir, ".approval-key");
   if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true, mode: 448 });
   if (existsSync5(secretPath)) {
-    return readFileSync5(secretPath, "utf8").trim();
+    return readFileSync6(secretPath, "utf8").trim();
   }
   const secret = randomBytes(32).toString("hex");
   writeFileSync3(secretPath, secret, { mode: 384 });
@@ -1084,11 +1043,11 @@ function verifyHmac(entry) {
   }
 }
 function getRegistryPath3() {
-  const dir = join5(homedir4(), ".config", "q-ring");
+  const dir = join6(homedir4(), ".config", "q-ring");
   if (!existsSync5(dir)) {
     mkdirSync4(dir, { recursive: true, mode: 448 });
   }
-  return join5(dir, "approvals.json");
+  return join6(dir, "approvals.json");
 }
 function loadRegistry3() {
   const path = getRegistryPath3();
@@ -1096,7 +1055,7 @@ function loadRegistry3() {
     return { approvals: [] };
   }
   try {
-    return JSON.parse(readFileSync5(path, "utf8"));
+    return JSON.parse(readFileSync6(path, "utf8"));
   } catch {
     return { approvals: [] };
   }
@@ -1168,6 +1127,176 @@ function listApprovals() {
   }));
 }
 
+// src/core/policy.ts
+var cachedPolicy = null;
+function loadPolicy(projectPath) {
+  const pp = projectPath ?? process.cwd();
+  if (cachedPolicy && cachedPolicy.path === pp) {
+    return cachedPolicy.policy;
+  }
+  const config = readProjectConfig(pp);
+  const policy = config?.policy ?? {};
+  cachedPolicy = { path: pp, policy };
+  return policy;
+}
+function checkSecretLifecyclePolicy(input, projectPath) {
+  const policy = loadPolicy(projectPath);
+  if (!policy.secrets) return { allowed: true, policySource: "no-policy" };
+  const s = policy.secrets;
+  if (s.maxTtlSeconds != null && input.ttlSeconds != null && input.ttlSeconds > s.maxTtlSeconds) {
+    return {
+      allowed: false,
+      reason: `TTL ${input.ttlSeconds}s exceeds policy maximum ${s.maxTtlSeconds}s`,
+      policySource: ".q-ring.json policy.secrets.maxTtlSeconds"
+    };
+  }
+  if (s.requireApprovalForTags?.length && input.tags?.length) {
+    const hit = input.tags.find((t) => s.requireApprovalForTags.includes(t));
+    if (hit && !input.requiresApproval) {
+      return {
+        allowed: false,
+        reason: `Tag "${hit}" requires explicit approval metadata (set requiresApproval / --requires-approval)`,
+        policySource: ".q-ring.json policy.secrets.requireApprovalForTags"
+      };
+    }
+  }
+  if (s.requireRotationFormatForTags?.length && input.tags?.length) {
+    const hit = input.tags.find((t) => s.requireRotationFormatForTags.includes(t));
+    if (hit && !input.rotationFormat) {
+      return {
+        allowed: false,
+        reason: `Tag "${hit}" requires a rotationFormat to be set`,
+        policySource: ".q-ring.json policy.secrets.requireRotationFormatForTags"
+      };
+    }
+  }
+  return { allowed: true, policySource: ".q-ring.json" };
+}
+function checkKeyReadPolicy(key, tags, projectPath) {
+  const policy = loadPolicy(projectPath);
+  if (!policy.mcp) return { allowed: true, policySource: "no-policy" };
+  if (policy.mcp.deniedKeys?.includes(key)) {
+    return {
+      allowed: false,
+      reason: `Key "${key}" is denied by project policy`,
+      policySource: ".q-ring.json policy.mcp.deniedKeys"
+    };
+  }
+  if (policy.mcp.readableKeys && !policy.mcp.readableKeys.includes(key)) {
+    return {
+      allowed: false,
+      reason: `Key "${key}" is not in the readable keys allowlist`,
+      policySource: ".q-ring.json policy.mcp.readableKeys"
+    };
+  }
+  if (tags && policy.mcp.deniedTags) {
+    const blocked = tags.find((t) => policy.mcp.deniedTags.includes(t));
+    if (blocked) {
+      return {
+        allowed: false,
+        reason: `Tag "${blocked}" is denied by project policy`,
+        policySource: ".q-ring.json policy.mcp.deniedTags"
+      };
+    }
+  }
+  return { allowed: true, policySource: ".q-ring.json" };
+}
+function checkExecPolicy(command, projectPath) {
+  const policy = loadPolicy(projectPath);
+  if (!policy.exec) return { allowed: true, policySource: "no-policy" };
+  if (policy.exec.denyCommands) {
+    const denied = policy.exec.denyCommands.find((d) => command.includes(d));
+    if (denied) {
+      return {
+        allowed: false,
+        reason: `Command containing "${denied}" is denied by project policy`,
+        policySource: ".q-ring.json policy.exec.denyCommands"
+      };
+    }
+  }
+  if (policy.exec.allowCommands) {
+    const allowed = policy.exec.allowCommands.some((a) => command.startsWith(a));
+    if (!allowed) {
+      return {
+        allowed: false,
+        reason: `Command "${command}" is not in the exec allowlist`,
+        policySource: ".q-ring.json policy.exec.allowCommands"
+      };
+    }
+  }
+  return { allowed: true, policySource: ".q-ring.json" };
+}
+function getExecMaxRuntime(projectPath) {
+  return loadPolicy(projectPath).exec?.maxRuntimeSeconds;
+}
+function getPolicySummary(projectPath) {
+  const policy = loadPolicy(projectPath);
+  return {
+    hasMcpPolicy: !!policy.mcp,
+    hasExecPolicy: !!policy.exec,
+    hasSecretPolicy: !!policy.secrets,
+    details: policy
+  };
+}
+
+// src/core/keyring.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, unlinkSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join7 } from "path";
+import { Entry, findCredentials } from "@napi-rs/keyring";
+
+// src/utils/hash.ts
+import { createHash as createHash2 } from "crypto";
+function hashProjectPath(projectPath) {
+  return createHash2("sha256").update(projectPath).digest("hex").slice(0, 12);
+}
+
+// src/core/scope.ts
+var SERVICE_PREFIX = "q-ring";
+function globalService() {
+  return `${SERVICE_PREFIX}:global`;
+}
+function projectService(projectPath) {
+  const hash = hashProjectPath(projectPath);
+  return `${SERVICE_PREFIX}:project:${hash}`;
+}
+function teamService(teamId) {
+  return `${SERVICE_PREFIX}:team:${teamId}`;
+}
+function orgService(orgId) {
+  return `${SERVICE_PREFIX}:org:${orgId}`;
+}
+function resolveScope(opts) {
+  const { scope, projectPath, teamId, orgId } = opts;
+  if (scope === "global") {
+    return [{ scope: "global", service: globalService() }];
+  }
+  if (scope === "project") {
+    if (!projectPath) throw new Error("Project path is required for project scope");
+    return [{ scope: "project", service: projectService(projectPath), projectPath }];
+  }
+  if (scope === "team") {
+    if (!teamId) throw new Error("Team ID is required for team scope");
+    return [{ scope: "team", service: teamService(teamId), teamId }];
+  }
+  if (scope === "org") {
+    if (!orgId) throw new Error("Org ID is required for org scope");
+    return [{ scope: "org", service: orgService(orgId), orgId }];
+  }
+  const chain = [];
+  if (projectPath) {
+    chain.push({ scope: "project", service: projectService(projectPath), projectPath });
+  }
+  if (teamId) {
+    chain.push({ scope: "team", service: teamService(teamId), teamId });
+  }
+  if (orgId) {
+    chain.push({ scope: "org", service: orgService(orgId), orgId });
+  }
+  chain.push({ scope: "global", service: globalService() });
+  return chain;
+}
+
 // src/core/provision.ts
 import { execFileSync, spawnSync } from "child_process";
 import { z as z2 } from "zod";
@@ -1315,124 +1444,12 @@ var registry = new ProvisionRegistry();
 registry.register(awsStsProvider);
 registry.register(httpProvider);
 
-// src/core/policy.ts
-var cachedPolicy = null;
-function loadPolicy(projectPath) {
-  const pp = projectPath ?? process.cwd();
-  if (cachedPolicy && cachedPolicy.path === pp) {
-    return cachedPolicy.policy;
-  }
-  const config = readProjectConfig(pp);
-  const policy = config?.policy ?? {};
-  cachedPolicy = { path: pp, policy };
-  return policy;
-}
-function checkSecretLifecyclePolicy(input, projectPath) {
-  const policy = loadPolicy(projectPath);
-  if (!policy.secrets) return { allowed: true, policySource: "no-policy" };
-  const s = policy.secrets;
-  if (s.maxTtlSeconds != null && input.ttlSeconds != null && input.ttlSeconds > s.maxTtlSeconds) {
-    return {
-      allowed: false,
-      reason: `TTL ${input.ttlSeconds}s exceeds policy maximum ${s.maxTtlSeconds}s`,
-      policySource: ".q-ring.json policy.secrets.maxTtlSeconds"
-    };
-  }
-  if (s.requireApprovalForTags?.length && input.tags?.length) {
-    const hit = input.tags.find((t) => s.requireApprovalForTags.includes(t));
-    if (hit && !input.requiresApproval) {
-      return {
-        allowed: false,
-        reason: `Tag "${hit}" requires explicit approval metadata (set requiresApproval / --requires-approval)`,
-        policySource: ".q-ring.json policy.secrets.requireApprovalForTags"
-      };
-    }
-  }
-  if (s.requireRotationFormatForTags?.length && input.tags?.length) {
-    const hit = input.tags.find((t) => s.requireRotationFormatForTags.includes(t));
-    if (hit && !input.rotationFormat) {
-      return {
-        allowed: false,
-        reason: `Tag "${hit}" requires a rotationFormat to be set`,
-        policySource: ".q-ring.json policy.secrets.requireRotationFormatForTags"
-      };
-    }
-  }
-  return { allowed: true, policySource: ".q-ring.json" };
-}
-function checkKeyReadPolicy(key, tags, projectPath) {
-  const policy = loadPolicy(projectPath);
-  if (!policy.mcp) return { allowed: true, policySource: "no-policy" };
-  if (policy.mcp.deniedKeys?.includes(key)) {
-    return {
-      allowed: false,
-      reason: `Key "${key}" is denied by project policy`,
-      policySource: ".q-ring.json policy.mcp.deniedKeys"
-    };
-  }
-  if (policy.mcp.readableKeys && !policy.mcp.readableKeys.includes(key)) {
-    return {
-      allowed: false,
-      reason: `Key "${key}" is not in the readable keys allowlist`,
-      policySource: ".q-ring.json policy.mcp.readableKeys"
-    };
-  }
-  if (tags && policy.mcp.deniedTags) {
-    const blocked = tags.find((t) => policy.mcp.deniedTags.includes(t));
-    if (blocked) {
-      return {
-        allowed: false,
-        reason: `Tag "${blocked}" is denied by project policy`,
-        policySource: ".q-ring.json policy.mcp.deniedTags"
-      };
-    }
-  }
-  return { allowed: true, policySource: ".q-ring.json" };
-}
-function checkExecPolicy(command, projectPath) {
-  const policy = loadPolicy(projectPath);
-  if (!policy.exec) return { allowed: true, policySource: "no-policy" };
-  if (policy.exec.denyCommands) {
-    const denied = policy.exec.denyCommands.find((d) => command.includes(d));
-    if (denied) {
-      return {
-        allowed: false,
-        reason: `Command containing "${denied}" is denied by project policy`,
-        policySource: ".q-ring.json policy.exec.denyCommands"
-      };
-    }
-  }
-  if (policy.exec.allowCommands) {
-    const allowed = policy.exec.allowCommands.some((a) => command.startsWith(a));
-    if (!allowed) {
-      return {
-        allowed: false,
-        reason: `Command "${command}" is not in the exec allowlist`,
-        policySource: ".q-ring.json policy.exec.allowCommands"
-      };
-    }
-  }
-  return { allowed: true, policySource: ".q-ring.json" };
-}
-function getExecMaxRuntime(projectPath) {
-  return loadPolicy(projectPath).exec?.maxRuntimeSeconds;
-}
-function getPolicySummary(projectPath) {
-  const policy = loadPolicy(projectPath);
-  return {
-    hasMcpPolicy: !!policy.mcp,
-    hasExecPolicy: !!policy.exec,
-    hasSecretPolicy: !!policy.secrets,
-    details: policy
-  };
-}
-
 // src/core/keyring.ts
 function withJitEnvelopeLock(service, key, fn) {
-  const dir = join6(homedir5(), ".config", "q-ring", "jit-locks");
+  const dir = join7(homedir5(), ".config", "q-ring", "jit-locks");
   mkdirSync5(dir, { recursive: true });
   const safe = Buffer.from(`${service}\0${key}`, "utf8").toString("base64url");
-  const lockPath = join6(dir, `${safe}.lock`);
+  const lockPath = join7(dir, `${safe}.lock`);
   const deadline = Date.now() + 8e3;
   while (Date.now() < deadline) {
     try {
@@ -1945,7 +1962,125 @@ function tunnelList() {
   return result;
 }
 
+// src/core/memory.ts
+import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir6, hostname, userInfo } from "os";
+import { createCipheriv, createDecipheriv, createHash as createHash3, randomBytes as randomBytes3 } from "crypto";
+import { Entry as Entry2 } 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 = join8(homedir6(), ".config", "q-ring");
+  if (!existsSync6(dir)) {
+    mkdirSync6(dir, { recursive: true });
+  }
+  return dir;
+}
+function getMemoryPath() {
+  return join8(getMemoryDir(), MEMORY_FILE);
+}
+function deriveLegacyKey() {
+  const fingerprint = `qring-memory:${hostname()}:${userInfo().username}`;
+  return createHash3("sha256").update(fingerprint).digest();
+}
+function getOrCreateKey() {
+  try {
+    const entry = new Entry2(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 = createCipheriv("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 = createDecipheriv("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);
+    writeFileSync5(getMemoryPath(), encryptWith(plain, key), "utf8");
+    return plain;
+  }
+}
+function loadStore() {
+  const path = getMemoryPath();
+  if (!existsSync6(path)) {
+    return { entries: {} };
+  }
+  try {
+    const raw = readFileSync7(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);
+  writeFileSync5(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;
+}
+function clearMemory() {
+  saveStore({ entries: {} });
+}
+
 export {
+  PACKAGE_VERSION,
   checkDecay,
   readProjectConfig,
   collapseEnvironment,
@@ -1982,6 +2117,11 @@ export {
   tunnelCreate,
   tunnelRead,
   tunnelDestroy,
-  tunnelList
+  tunnelList,
+  remember,
+  recall,
+  listMemory,
+  forget,
+  clearMemory
 };
-//# sourceMappingURL=chunk-LLMO64FE.js.map
+//# sourceMappingURL=chunk-A4RZVP3P.js.map