@astrasyncai/verification-gateway 3.10.0 → 3.11.0

package/dist/bin/astrasync.js

@@ -4543,7 +4543,9 @@ var init_types = __esm({
       "git push",
       "npm publish",
       "docker",
-      "kubectl"
+      "kubectl",
+      "gh pr create",
+      "gh pr merge"
     ];
     SENSITIVE_PATHS = [
       ".ssh",
@@ -4564,12 +4566,178 @@ var init_types = __esm({
   }
 });
 
+// src/local-evaluator/command-matcher.ts
+function buildRiskList(entries) {
+  const singleWord = /* @__PURE__ */ new Set();
+  const multiWord = [];
+  for (const entry of entries) {
+    const words = entry.toLowerCase().trim().split(/\s+/);
+    if (words.length === 1) singleWord.add(words[0]);
+    else multiWord.push(words);
+  }
+  multiWord.sort((a, b) => b.length - a.length);
+  return { singleWord, multiWord };
+}
+function stripHeredocBodies(text) {
+  const lines = text.split("\n");
+  const kept = [];
+  let terminator = null;
+  for (const line of lines) {
+    if (terminator !== null) {
+      if (line.trim() === terminator) terminator = null;
+      continue;
+    }
+    kept.push(line);
+    const heredoc = line.match(/<<-?\s*['"]?(\w+)['"]?/);
+    if (heredoc) terminator = heredoc[1];
+  }
+  return kept.join("\n");
+}
+function extractDollarSubstitutions(text, collect) {
+  let result = text;
+  let start = result.indexOf("$(");
+  let iterations = 0;
+  while (start !== -1 && iterations < 50) {
+    iterations++;
+    let depth = 0;
+    let end = result.length;
+    for (let i = start + 1; i < result.length; i++) {
+      if (result[i] === "(") depth++;
+      else if (result[i] === ")") {
+        depth--;
+        if (depth === 0) {
+          end = i;
+          break;
+        }
+      }
+    }
+    collect(result.slice(start + 2, end));
+    result = `${result.slice(0, start)} ${result.slice(Math.min(end + 1, result.length))}`;
+    start = result.indexOf("$(");
+  }
+  return result;
+}
+function extractBacktickSubstitutions(text, collect) {
+  if (!text.includes("`")) return text;
+  const chunks = text.split("`");
+  const kept = [];
+  for (let i = 0; i < chunks.length; i++) {
+    if (i % 2 === 1) collect(chunks[i]);
+    else kept.push(chunks[i]);
+  }
+  return kept.join(" ");
+}
+function basename(token) {
+  const slash = token.lastIndexOf("/");
+  return slash === -1 ? token : token.slice(slash + 1);
+}
+function matchSegment(segment, list) {
+  const tokens = segment.split(/\s+/).filter((t) => /[a-z0-9]/.test(t));
+  let i = 0;
+  let hops = 0;
+  while (i < tokens.length) {
+    while (i < tokens.length && (tokens[i] === "export" || ASSIGN_RE.test(tokens[i]))) i++;
+    if (i >= tokens.length) return null;
+    const cmd = basename(tokens[i]);
+    const significant = [cmd, ...tokens.slice(i + 1).filter((t) => !t.startsWith("-"))];
+    for (const entry of list.multiWord) {
+      if (entry.length <= significant.length && entry.every((w, j) => significant[j] === w)) {
+        return entry.join(" ");
+      }
+    }
+    if (list.singleWord.has(cmd)) return cmd;
+    if (WRAPPERS.has(cmd) && hops < MAX_WRAPPER_HOPS) {
+      hops++;
+      i++;
+      while (i < tokens.length && (tokens[i].startsWith("-") || ASSIGN_RE.test(tokens[i]))) i++;
+      continue;
+    }
+    return null;
+  }
+  return null;
+}
+function collectMatches(command, list, matches, depth) {
+  if (depth > MAX_RECURSION_DEPTH || command.length > MAX_COMMAND_LENGTH) return;
+  let text = command.toLowerCase();
+  text = stripHeredocBodies(text);
+  const recurse = (inner) => collectMatches(inner, list, matches, depth + 1);
+  text = extractDollarSubstitutions(text, recurse);
+  text = extractBacktickSubstitutions(text, recurse);
+  text = text.replace(/'[^']*'/g, " ").replace(/"[^"]*"/g, " ");
+  text = text.replace(/(^|\s)#[^\n]*/g, " ");
+  const segments = text.split(/\|\||&&|[;|&\n]|[({]/);
+  for (const segment of segments) {
+    const matched = matchSegment(segment, list);
+    if (matched) matches.add(matched);
+  }
+}
+function matchHighRiskCommands(command, highRiskCommands = HIGH_RISK_COMMANDS) {
+  if (!command) return [];
+  const matches = /* @__PURE__ */ new Set();
+  collectMatches(command, buildRiskList(highRiskCommands), matches, 0);
+  return [...matches];
+}
+function isLocalhostOnlyNetworkCommand(command) {
+  const text = command.toLowerCase();
+  const tokens = text.split(/\s+/).map((t) => t.replace(/^["'`]+|["'`,;)]+$/g, ""));
+  let localCount = 0;
+  for (const token of tokens) {
+    let host = null;
+    if (token.includes("://")) {
+      let rest = token.slice(token.indexOf("://") + 3);
+      const at = rest.indexOf("@");
+      if (at !== -1) rest = rest.slice(at + 1);
+      host = rest.split(/[/?#]/)[0];
+    } else if (/^[a-z0-9.[\]:-]+:\d+(\/.*)?$/.test(token)) {
+      host = token.split("/")[0];
+    } else if (/^(localhost|127\.0\.0\.1|\[?::1\]?)(\/.*)?$/.test(token)) {
+      host = token.split("/")[0];
+    }
+    if (host === null) continue;
+    const bare = host.replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+    if (LOCAL_HOST_RE.test(bare)) {
+      localCount++;
+    } else {
+      return false;
+    }
+  }
+  return localCount > 0;
+}
+var WRAPPERS, ASSIGN_RE, MAX_WRAPPER_HOPS, MAX_RECURSION_DEPTH, MAX_COMMAND_LENGTH, LOCAL_HOST_RE;
+var init_command_matcher = __esm({
+  "src/local-evaluator/command-matcher.ts"() {
+    "use strict";
+    init_types();
+    WRAPPERS = /* @__PURE__ */ new Set([
+      "sudo",
+      "doas",
+      "env",
+      "nohup",
+      "time",
+      "timeout",
+      "nice",
+      "ionice",
+      "stdbuf",
+      "xargs",
+      "command",
+      "exec",
+      "builtin"
+    ]);
+    ASSIGN_RE = /^[a-z_][a-z0-9_]*=/;
+    MAX_WRAPPER_HOPS = 4;
+    MAX_RECURSION_DEPTH = 3;
+    MAX_COMMAND_LENGTH = 1e5;
+    LOCAL_HOST_RE = /^(localhost|127\.0\.0\.1|::1|[a-z0-9.-]*\.localhost)$/;
+  }
+});
+
 // src/local-evaluator/evaluator.ts
 var LocalEvaluator;
 var init_evaluator = __esm({
   "src/local-evaluator/evaluator.ts"() {
     "use strict";
     init_types();
+    init_command_matcher();
     LocalEvaluator = class {
       constructor(policy) {
         this.requestCounts = /* @__PURE__ */ new Map();
@@ -4719,12 +4887,10 @@ var init_evaluator = __esm({
           return score;
         }
         if (context.purpose === "shell.exec" && context.target) {
-          const targetLower = context.target.toLowerCase();
-          for (const cmd of HIGH_RISK_COMMANDS) {
-            if (targetLower.startsWith(cmd) || targetLower.includes(` ${cmd} `) || targetLower.includes(` ${cmd}`)) {
-              score = Math.max(score, 80);
-              break;
-            }
+          const matched = matchHighRiskCommands(context.target);
+          const localProbeOnly = matched.length > 0 && matched.every((cmd) => cmd === "curl" || cmd === "wget") && isLocalhostOnlyNetworkCommand(context.target);
+          if (matched.length > 0 && !localProbeOnly) {
+            score = Math.max(score, 80);
           }
         }
         if ((context.purpose === "file.read" || context.purpose === "file.write" || context.purpose === "file.delete") && context.target) {
@@ -4823,7 +4989,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    SDK_VERSION = "3.10.0";
+    SDK_VERSION = "3.11.0";
   }
 });
 
@@ -5793,10 +5959,12 @@ function toGatewayConfig(config) {
   };
 }
 function toVerificationRequest(context, astraId) {
+  const dotIndex = context.purpose.indexOf(".");
+  const dotted = dotIndex > 0;
   return {
     credentials: { astraId },
-    purpose: context.purpose,
-    action: context.action,
+    purpose: dotted ? context.purpose.slice(0, dotIndex) : context.purpose,
+    action: dotted ? context.purpose : context.action,
     resourceType: context.resourceType,
     resource: context.target,
     transactionValue: context.transactionValue,
@@ -5839,21 +6007,93 @@ var init_online = __esm({
   }
 });
 
+// src/gateway/redact.ts
+function redactSecrets(text) {
+  let result = text;
+  for (const { type: type2, re, replacement } of REDACTION_PATTERNS) {
+    result = result.replace(re, replacement ?? marker(type2));
+  }
+  return result;
+}
+function redactDeep(value) {
+  if (typeof value === "string") {
+    return redactSecrets(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactDeep(item));
+  }
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = redactDeep(v);
+    }
+    return out;
+  }
+  return value;
+}
+var marker, REDACTION_PATTERNS;
+var init_redact = __esm({
+  "src/gateway/redact.ts"() {
+    "use strict";
+    marker = (type2) => `[REDACTED:${type2}]`;
+    REDACTION_PATTERNS = [
+      // Multi-line blocks first so later single-line patterns don't shred them.
+      {
+        type: "private-key",
+        re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z ]*PRIVATE KEY-----|$)/g
+      },
+      // URL userinfo credentials (https://user:pass@, x-access-token:ghp_…@).
+      {
+        type: "url-credentials",
+        re: /([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+:[^\s/@]+@/gi,
+        replacement: `$1${marker("url-credentials")}@`
+      },
+      // Known token formats.
+      { type: "github-token", re: /\bgh[pousr]_[A-Za-z0-9]{20,255}\b/g },
+      { type: "github-token", re: /\bgithub_pat_[A-Za-z0-9_]{20,255}\b/g },
+      { type: "astrasync-key", re: /\bkya_[A-Fa-f0-9]{32,128}\b/g },
+      { type: "openai-key", re: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
+      { type: "aws-access-key-id", re: /\bAKIA[0-9A-Z]{16}\b/g },
+      { type: "jwt", re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
+      // Bearer/token headers.
+      {
+        type: "bearer-token",
+        re: /\b(bearer\s+)[a-z0-9._~+/=-]{16,}/gi,
+        replacement: `$1${marker("bearer-token")}`
+      },
+      // Generic KEY=value / key: value assignments with secret-ish names.
+      {
+        type: "assigned-secret",
+        re: /\b((?:password|passwd|secret|token|api[_-]?key|apikey|access[_-]?key|client[_-]?secret|private[_-]?key)\s*[=:]\s*)(['"]?)[^\s'"&;]{8,}\2/gi,
+        replacement: `$1$2${marker("assigned-secret")}$2`
+      }
+    ];
+  }
+});
+
 // src/gateway/modes/hybrid.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(FLUSH_TIMEOUT), ms);
+    if (typeof timer.unref === "function") timer.unref();
+  });
+}
 function verifyHybrid(evaluator, syncQueue, context) {
   const decision = evaluator.evaluate(context);
   syncQueue.enqueue(context, decision);
   return decision;
 }
-var import_fs2, import_path, MAX_QUEUE_SIZE, MAX_RETRIES, HybridSyncQueue;
+var import_fs2, import_path, MAX_QUEUE_SIZE, MAX_RETRIES, FLUSH_TIMEOUT, HybridSyncQueue;
 var init_hybrid = __esm({
   "src/gateway/modes/hybrid.ts"() {
     "use strict";
     import_fs2 = require("fs");
     import_path = require("path");
     init_online();
+    init_redact();
     MAX_QUEUE_SIZE = 1e3;
     MAX_RETRIES = 3;
+    FLUSH_TIMEOUT = /* @__PURE__ */ Symbol("flush-timeout");
     HybridSyncQueue = class {
       constructor(config, persistPath) {
         this.queue = [];
@@ -5874,12 +6114,12 @@ var init_hybrid = __esm({
       /**
        * Stop periodic sync and flush remaining entries.
        */
-      async stop() {
+      async stop(flushOptions = {}) {
         if (this.timer) {
           clearInterval(this.timer);
           this.timer = null;
         }
-        await this.flush();
+        await this.flush(flushOptions);
         this.saveToDisk();
       }
       /**
@@ -5891,8 +6131,8 @@ var init_hybrid = __esm({
         }
         this.queue.push({
           id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-          context,
-          decision,
+          context: redactDeep(context),
+          decision: redactDeep(decision),
           timestamp: /* @__PURE__ */ new Date(),
           retryCount: 0,
           status: "pending"
@@ -5902,16 +6142,21 @@ var init_hybrid = __esm({
       /**
        * Flush pending entries to the API.
        */
-      async flush() {
+      async flush(options = {}) {
         if (this.processing) return;
         this.processing = true;
         try {
           const pending = this.queue.filter((e) => e.status === "pending");
-          for (const entry of pending) {
-            try {
-              await verifyOnline(this.config, entry.context);
+          const batch = typeof options.limit === "number" ? pending.slice(0, options.limit) : pending;
+          for (const entry of batch) {
+            const attempt = verifyOnline(this.config, entry.context, this.config.agentId).then(() => "synced").catch(() => "error");
+            const result = options.perEntryTimeoutMs ? await Promise.race([attempt, delay(options.perEntryTimeoutMs)]) : await attempt;
+            if (result === FLUSH_TIMEOUT) {
+              break;
+            }
+            if (result === "synced") {
               entry.status = "synced";
-            } catch {
+            } else {
               entry.retryCount++;
               if (entry.retryCount >= MAX_RETRIES) {
                 entry.status = "failed";
@@ -5970,6 +6215,7 @@ var init_trace_logger = __esm({
     "use strict";
     import_fs3 = require("fs");
     import_path2 = require("path");
+    init_redact();
     MAX_FILE_SIZE = 10 * 1024 * 1024;
     MAX_FILES = 10;
     TraceLogger = class {
@@ -5989,8 +6235,22 @@ var init_trace_logger = __esm({
           id: this.generateId(),
           timestamp: /* @__PURE__ */ new Date(),
           type: "evaluation",
-          context,
-          decision
+          context: redactDeep(context),
+          decision: redactDeep(decision)
+        });
+      }
+      /**
+       * Log a tool call the guard saw but did not govern. One line per skip
+       * keeps coverage holes (unmapped platform tools) visible in the traces
+       * instead of silently indistinguishable from ALLOW.
+       */
+      logSkipped(toolName, reason) {
+        if (!this.enabled) return;
+        this.write({
+          id: this.generateId(),
+          timestamp: /* @__PURE__ */ new Date(),
+          type: "skipped",
+          metadata: { toolName, reason }
         });
       }
       /**
@@ -6118,10 +6378,12 @@ var init_gateway = __esm({
       }
       /**
        * Graceful shutdown. Flushes sync queue and cleans up resources.
+       * Stateless callers (hooks) pass bounded flush options so sync never
+       * sits on a tool call's critical path.
        */
-      async shutdown() {
+      async shutdown(options) {
         if (this.syncQueue) {
-          await this.syncQueue.stop();
+          await this.syncQueue.stop(options?.syncFlush ?? {});
           this.syncQueue = null;
         }
         this.evaluator = null;
@@ -6144,7 +6406,7 @@ var init_gateway = __esm({
         let decision;
         switch (this.config.mode) {
           case "online":
-            decision = await verifyOnline(this.config, context, astraId);
+            decision = await verifyOnline(this.config, context, astraId ?? this.config.agentId);
             break;
           case "local":
             if (!this.evaluator) throw new Error("Local evaluator not initialized");
@@ -6199,6 +6461,13 @@ var init_gateway = __esm({
       getSyncStatus() {
         return this.syncQueue?.getStatus() || null;
       }
+      /**
+       * Record a tool call the calling adapter saw but did not govern
+       * (unmapped tool, skipTools, MCP with governMcp off). Trace-only.
+       */
+      logSkippedTool(toolName, reason) {
+        this.traceLogger?.logSkipped(toolName, reason);
+      }
     };
   }
 });
@@ -6333,9 +6602,9 @@ var init_git_hooks = __esm({
 });
 
 // src/claude-code/settings-installer.ts
-function isGuardEntry(entry) {
+function isGuardEntry(entry, marker2) {
   return (entry.hooks ?? []).some(
-    (h) => typeof h.command === "string" && h.command.includes(ASTRASYNC_HOOK_MARKER)
+    (h) => typeof h.command === "string" && h.command.includes(marker2)
   );
 }
 function readSettings(settingsPath) {
@@ -6349,24 +6618,26 @@ function writeSettings(settingsPath, settings) {
   (0, import_fs5.writeFileSync)(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
 }
-function buildHookEntry(hookCommand) {
+function buildHookEntry(hookCommand, matcher = HOOK_MATCHER, extraHookFields = {}) {
   return {
-    matcher: HOOK_MATCHER,
-    hooks: [{ type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_SECONDS }]
+    matcher,
+    hooks: [
+      { type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_SECONDS, ...extraHookFields }
+    ]
   };
 }
-function installClaudeHooks(settingsPath, hookCommand) {
-  if (!hookCommand.includes(ASTRASYNC_HOOK_MARKER)) {
+function installClaudeHooks(settingsPath, hookCommand, marker2 = ASTRASYNC_HOOK_MARKER, matcher = HOOK_MATCHER, extraHookFields = {}) {
+  if (!hookCommand.includes(marker2)) {
     throw new Error(
-      `Hook command must reference ${ASTRASYNC_HOOK_MARKER} (got: ${hookCommand}) \u2014 the marker is how install/uninstall identify the guard entry.`
+      `Hook command must reference ${marker2} (got: ${hookCommand}) \u2014 the marker is how install/uninstall identify the guard entry.`
     );
   }
   const settings = readSettings(settingsPath);
   settings.hooks = settings.hooks ?? {};
   const preToolUse = settings.hooks.PreToolUse = settings.hooks.PreToolUse ?? [];
-  const existing = preToolUse.find(isGuardEntry);
+  const existing = preToolUse.find((entry) => isGuardEntry(entry, marker2));
   if (existing) {
-    const fresh = buildHookEntry(hookCommand);
+    const fresh = buildHookEntry(hookCommand, matcher, extraHookFields);
     const changed = JSON.stringify(existing) !== JSON.stringify(fresh);
     if (changed) {
       preToolUse[preToolUse.indexOf(existing)] = fresh;
@@ -6374,11 +6645,11 @@ function installClaudeHooks(settingsPath, hookCommand) {
     }
     return { installed: false, alreadyPresent: true, updated: changed };
   }
-  preToolUse.push(buildHookEntry(hookCommand));
+  preToolUse.push(buildHookEntry(hookCommand, matcher, extraHookFields));
   writeSettings(settingsPath, settings);
   return { installed: true, alreadyPresent: false, updated: false };
 }
-function uninstallClaudeHooks(settingsPath) {
+function uninstallClaudeHooks(settingsPath, marker2 = ASTRASYNC_HOOK_MARKER) {
   if (!(0, import_fs5.existsSync)(settingsPath)) return false;
   let settings;
   try {
@@ -6388,7 +6659,7 @@ function uninstallClaudeHooks(settingsPath) {
   }
   const preToolUse = settings.hooks?.PreToolUse;
   if (!preToolUse) return false;
-  const remaining = preToolUse.filter((entry) => !isGuardEntry(entry));
+  const remaining = preToolUse.filter((entry) => !isGuardEntry(entry, marker2));
   if (remaining.length === preToolUse.length) return false;
   if (remaining.length > 0) {
     settings.hooks.PreToolUse = remaining;
@@ -6452,16 +6723,44 @@ var init_settings_installer = __esm({
     init_wizard();
     init_pdlss_parser();
     ASTRASYNC_HOOK_MARKER = "astrasync-claude-hook";
-    HOOK_MATCHER = "Bash|Write|Edit|MultiEdit|NotebookEdit|Read|Glob|Grep|WebFetch|WebSearch|Task|Agent|mcp__.*";
+    HOOK_MATCHER = "Bash|PowerShell|Write|Edit|MultiEdit|NotebookEdit|Read|Glob|Grep|WebFetch|WebSearch|Task|Agent|mcp__.*";
     HOOK_TIMEOUT_SECONDS = 10;
     GUARD_SELF_PROTECTION_PATTERNS = [
       "**/.claude/settings.json",
       "**/.claude/settings.local.json",
-      "**/.astrasync/**"
+      "**/.astrasync/**",
+      "**/.codex/hooks.json",
+      "**/.codex/config.toml"
     ];
   }
 });
 
+// src/codex/settings-installer.ts
+function installCodexHooks(hooksPath, hookCommand) {
+  return installClaudeHooks(
+    hooksPath,
+    hookCommand,
+    ASTRASYNC_CODEX_HOOK_MARKER,
+    CODEX_HOOK_MATCHER,
+    {
+      statusMessage: CODEX_STATUS_MESSAGE
+    }
+  );
+}
+function uninstallCodexHooks(hooksPath) {
+  return uninstallClaudeHooks(hooksPath, ASTRASYNC_CODEX_HOOK_MARKER);
+}
+var ASTRASYNC_CODEX_HOOK_MARKER, CODEX_HOOK_MATCHER, CODEX_STATUS_MESSAGE;
+var init_settings_installer2 = __esm({
+  "src/codex/settings-installer.ts"() {
+    "use strict";
+    init_settings_installer();
+    ASTRASYNC_CODEX_HOOK_MARKER = "astrasync-codex-hook";
+    CODEX_HOOK_MATCHER = "Bash|apply_patch|Edit|Write|web_search|mcp__.*";
+    CODEX_STATUS_MESSAGE = "AstraSync Local Guard";
+  }
+});
+
 // src/cli/guard.ts
 var guard_exports = {};
 function createPrompt() {
@@ -6626,6 +6925,7 @@ async function cmdStatus() {
     console.log('  Policy:   not found \u2014 run "astrasync guard setup"');
   }
   printClaudeCodeStatus();
+  printCodexStatus();
   console.log("");
 }
 async function cmdCheck() {
@@ -6712,7 +7012,7 @@ async function cmdUninstallHooks() {
 function resolveClaudeHookCommand() {
   const sibling = path.join(__dirname, "astrasync-claude-hook.js");
   if (fs.existsSync(sibling)) {
-    return `node "${sibling}"`;
+    return `"${process.execPath}" "${sibling}"`;
   }
   return "astrasync-claude-hook";
 }
@@ -6804,6 +7104,108 @@ async function cmdUninstallClaudeCode() {
     `[AstraSync] Policy and traces left in place at ${astrasyncDir} \u2014 delete manually if unwanted.`
   );
 }
+function resolveCodexHookCommand() {
+  const sibling = path.join(__dirname, "astrasync-codex-hook.js");
+  if (fs.existsSync(sibling)) {
+    return `"${process.execPath}" "${sibling}"`;
+  }
+  return "astrasync-codex-hook";
+}
+function codexPaths(project) {
+  const root = project ? process.cwd() : os.homedir();
+  return {
+    hooksPath: path.join(root, ".codex", "hooks.json"),
+    astrasyncDir: path.join(root, ".astrasync")
+  };
+}
+async function cmdInstallCodex() {
+  const flags = parseClaudeCodeFlags();
+  const { hooksPath, astrasyncDir } = codexPaths(flags.project);
+  const policyPath = flags.policyOverride || path.join(astrasyncDir, "policy.yaml");
+  const guardJsonPath = path.join(astrasyncDir, "guard.json");
+  console.log("\nAstraSync Local Guard for Codex CLI \u2014 install\n");
+  if (fs.existsSync(policyPath)) {
+    console.log(`  Policy:   using existing ${policyPath} (shared across adapters)`);
+    if (ensureGuardSelfProtection(policyPath)) {
+      console.log("            added guard self-protection patterns to file.write");
+    }
+  } else if (flags.wizard) {
+    const prompt = createPrompt();
+    try {
+      fs.mkdirSync(path.dirname(policyPath), { recursive: true });
+      const wizard = new SetupWizard(prompt);
+      await wizard.runAndSave(policyPath);
+    } finally {
+      prompt.close();
+    }
+    ensureGuardSelfProtection(policyPath);
+    console.log(`  Policy:   created via wizard at ${policyPath}`);
+  } else {
+    fs.mkdirSync(path.dirname(policyPath), { recursive: true });
+    fs.writeFileSync(policyPath, toYaml(buildDefaultClaudeCodePolicy()), "utf-8");
+    console.log(`  Policy:   default coding-agent policy written to ${policyPath}`);
+    console.log("            (re-run with --wizard for the interactive setup instead)");
+  }
+  if (!fs.existsSync(guardJsonPath)) {
+    const guardSettings = {
+      posture: flags.active ? "active" : "passive",
+      governMcp: false
+    };
+    fs.writeFileSync(guardJsonPath, `${JSON.stringify(guardSettings, null, 2)}
+`, "utf-8");
+    console.log(
+      `  Guard:    ${guardJsonPath} (posture: ${guardSettings.posture}, governMcp: false)`
+    );
+  } else {
+    console.log(`  Guard:    using existing ${guardJsonPath}`);
+  }
+  const hookCommand = resolveCodexHookCommand();
+  const result = installCodexHooks(hooksPath, hookCommand);
+  if (result.installed) {
+    console.log(`  Hook:     installed in ${hooksPath}`);
+  } else if (result.updated) {
+    console.log(`  Hook:     updated in ${hooksPath}`);
+  } else {
+    console.log(`  Hook:     already present in ${hooksPath}`);
+  }
+  console.log("\n  Next steps:");
+  console.log("    1. Start a NEW Codex session (hooks load at startup; /hooks to inspect).");
+  console.log(`    2. Watch decisions: tail -f ${path.join(astrasyncDir, "traces")}/*.jsonl`);
+  console.log(`    3. When the traces look right, set "posture": "active" in ${guardJsonPath}.`);
+  console.log("       Denies block; approvals fall through to Codex's own prompt \u2014");
+  console.log("       except in dontAsk/bypassPermissions modes, where they deny.");
+  console.log("    4. Note: Codex fails OPEN if the hook itself times out; the guard");
+  console.log("       fails closed on every failure it can see.\n");
+}
+async function cmdUninstallCodex() {
+  const flags = parseClaudeCodeFlags();
+  const { hooksPath, astrasyncDir } = codexPaths(flags.project);
+  const removed = uninstallCodexHooks(hooksPath);
+  if (removed) {
+    console.log(`[AstraSync] Removed Codex hook from ${hooksPath}`);
+  } else {
+    console.log(`[AstraSync] No AstraSync hook found in ${hooksPath}`);
+  }
+  console.log(
+    `[AstraSync] Policy and traces left in place at ${astrasyncDir} \u2014 delete manually if unwanted.`
+  );
+}
+function printCodexStatus() {
+  for (const scope of ["user", "project"]) {
+    const { hooksPath, astrasyncDir } = codexPaths(scope === "project");
+    let hookInstalled = false;
+    try {
+      const content = fs.readFileSync(hooksPath, "utf-8");
+      hookInstalled = content.includes(ASTRASYNC_CODEX_HOOK_MARKER);
+    } catch {
+    }
+    if (hookInstalled) {
+      const policyPath = path.join(astrasyncDir, "policy.yaml");
+      const policy = fs.existsSync(policyPath) ? `policy: ${policyPath}` : "policy: missing";
+      console.log(`  Codex CLI (${scope}): hook installed, ${policy}`);
+    }
+  }
+}
 function printClaudeCodeStatus() {
   for (const scope of ["user", "project"]) {
     const { settingsPath, astrasyncDir } = claudeCodePaths(scope === "project");
@@ -6861,6 +7263,12 @@ async function main() {
     case "uninstall-claude-code":
       await cmdUninstallClaudeCode();
       break;
+    case "install-codex":
+      await cmdInstallCodex();
+      break;
+    case "uninstall-codex":
+      await cmdUninstallCodex();
+      break;
     default:
       console.log("AstraSync Local Guard\n");
       console.log("Usage: astrasync guard <command>\n");
@@ -6878,6 +7286,9 @@ async function main() {
       console.log(
         "  uninstall-claude-code  Remove the Claude Code hook (--project for project scope)"
       );
+      console.log("  install-codex          Install the Local Guard hook for OpenAI Codex CLI");
+      console.log("                         (same flags; policy shared with Claude Code)");
+      console.log("  uninstall-codex        Remove the Codex hook (--project for project scope)");
       console.log("");
       process.exit(command ? 1 : 0);
   }
@@ -6897,6 +7308,7 @@ var init_guard = __esm({
     init_pdlss_parser();
     init_git_hooks();
     init_settings_installer();
+    init_settings_installer2();
     DEFAULT_POLICY_PATH = "./local-policy.yaml";
     DEFAULT_CONFIG_DIR = ".astrasync";
     main().catch((err) => {