@zaip-ai/cli 5.1.0 → 5.2.0

package/dist/services/adapters.d.ts

@@ -1,6 +1,6 @@
 import { type PublicAgentCatalog } from "./agent-adapters.js";
 export { isManagedAdapter } from "./managed-adapter.js";
-export declare const ADAPTERS_VERSION = "5.1.0";
+export declare const ADAPTERS_VERSION = "5.2.0";
 export interface AdapterFile {
     path: string;
     content: string;

package/dist/services/adapters.js

@@ -11,7 +11,7 @@ export { isManagedAdapter } from "./managed-adapter.js";
 import { CODEX_GITHUB_DEPLOY_RULES, CODEX_SECURITY_RULES } from "./codex-rules.js";
 import { codexWindowsHookCommand } from "./codex-windows-hook-command.js";
 import { applyTransactionalChanges, assertSafeDestination } from "./transactional-files.js";
-export const ADAPTERS_VERSION = "5.1.0";
+export const ADAPTERS_VERSION = "5.2.0";
 const ROOT_GUIDANCE = `# ZAIP-AIOS
 
 Read \`.agents/config/project.yaml\` first. Apply ZAIP only for literal boolean \`zaip.enabled: true\`, except framework maintenance or \`zaip enable\`. \`AGENTS.md\` is a bootstrap; canonical guidance lives in \`.agents/\`.

package/dist/services/codex-native-tool-authority-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-native-tool-authority-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-native-tool-authority-template.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gCAAgC,QA0QT,CAAC"}
+{"version":3,"file":"codex-native-tool-authority-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-native-tool-authority-template.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gCAAgC,QAiRT,CAAC"}

package/dist/services/codex-native-tool-authority-template.js

@@ -1,5 +1,7 @@
 import { CODEX_VALIDATION_RUNTIME_SUPPORT } from "./codex-validation-runtime-template.js";
-export const CODEX_NATIVE_TOOL_AUTHORITY_HOOK = String.raw `import { execFileSync } from "node:child_process";
+export const CODEX_NATIVE_TOOL_AUTHORITY_HOOK = String.raw `import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const executeGit = promisify(execFile);
 import { createHash } from "node:crypto";
 import { lstat, readFile, realpath } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
@@ -223,16 +225,21 @@ export async function hasCurrentTaskOrchestratorRun(event, installedRoot, bounde
 }
 
 /** A Task's product writer is claimed centrally before any edit. */
-function isolatedGitMatchesClaim(repositoryRoot, authorityRoot, claim) {
-  const git = (root, args) => execFileSync("git", ["-C", root, ...args], {
-    encoding: "utf8", windowsHide: true, timeout: 15000,
-    env: Object.fromEntries(Object.entries(process.env).filter(([key]) => !/^(GIT_|NODE_OPTIONS$)/i.test(key))),
-  }).trim();
-  if (resolve(git(repositoryRoot, ["rev-parse", "--show-toplevel"])) !== resolve(repositoryRoot) ||
-      git(repositoryRoot, ["branch", "--show-current"]) !== claim.branch) return false;
-  const head = git(repositoryRoot, ["rev-parse", "HEAD"]);
-  if (head !== git(authorityRoot, ["rev-parse", claim.branch])) return false;
-  return git(authorityRoot, ["worktree", "list", "--porcelain"]).split(/\r?\n\r?\n/).some(block => {
+async function isolatedGitMatchesClaim(repositoryRoot, authorityRoot, claim) {
+  const deadline = performance.now() + 3500;
+  const git = async (root, args) => {
+    const remaining = Math.floor(deadline - performance.now());
+    if (remaining <= 0) throw new Error("writer_validation_budget_exhausted");
+    return (await executeGit("git", ["-C", root, ...args], {
+      encoding: "utf8", windowsHide: true, timeout: Math.min(1500, remaining), maxBuffer: 1048576,
+      env: Object.fromEntries(Object.entries(process.env).filter(([key]) => !/^(GIT_|NODE_OPTIONS$)/i.test(key))),
+    })).stdout.trim();
+  };
+  if (resolve(await git(repositoryRoot, ["rev-parse", "--show-toplevel"])) !== resolve(repositoryRoot) ||
+      await git(repositoryRoot, ["branch", "--show-current"]) !== claim.branch) return false;
+  const head = await git(repositoryRoot, ["rev-parse", "HEAD"]);
+  if (head !== await git(authorityRoot, ["rev-parse", claim.branch])) return false;
+  return (await git(authorityRoot, ["worktree", "list", "--porcelain"])).split(/\r?\n\r?\n/).some(block => {
     const lines = block.split(/\r?\n/);
     return lines.some(line => line.startsWith("worktree ") && resolve(line.slice(9)) === resolve(repositoryRoot)) &&
       lines.includes("HEAD " + head) && lines.includes("branch refs/heads/" + claim.branch);
@@ -261,7 +268,7 @@ export async function hasClaimedTaskWriter(event, repositoryRoot, boundedRead, d
       typeof isolated.branch === "string" && isolated.branch.startsWith("codex/") &&
       resolve(isolated.path) === resolve(repositoryRoot) &&
       resolve(isolated.canonical_workspace) === resolve(authorityRoot) &&
-      isolatedGitMatchesClaim(repositoryRoot, authorityRoot, isolated);
+      await isolatedGitMatchesClaim(repositoryRoot, authorityRoot, isolated);
   } catch { return false; }
 }
 ` + CODEX_VALIDATION_RUNTIME_SUPPORT;

package/dist/services/codex-native-tool-authority-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex-native-tool-authority-template.js","sourceRoot":"","sources":["../../src/services/codex-native-tool-authority-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAC1F,MAAM,CAAC,MAAM,gCAAgC,GAC3C,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyQX,GAAG,gCAAgC,CAAC"}
+{"version":3,"file":"codex-native-tool-authority-template.js","sourceRoot":"","sources":["../../src/services/codex-native-tool-authority-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAC1F,MAAM,CAAC,MAAM,gCAAgC,GAC3C,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgRX,GAAG,gCAAgC,CAAC"}

package/dist/services/codex-pre-tool-hook-template.js

@@ -5,9 +5,9 @@ import { lstat, readFile, realpath } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { captureCliTurn, checkDestructivePatterns, configuredDeploymentBranches, configuredPermissionProfile, gitInvocation, inside, isLiteralReadSequence, parseHookEvent, readBoundedCanonicalText, requiresShellMutationRun, reviewedContextReadPaths, reviewedReleasePaths, rewriteCliInput, selectHookExecutionWorkspace, selectHookRepositoryRoot, shellSyntax, tokenizeLiteralCommand, validateInlineExecution } from "./zaip-pre-tool-support.mjs";
+import { captureCliTurn, createHookBudget, checkDestructivePatterns, configuredDeploymentBranches, configuredPermissionProfile, gitInvocation, inside, isLiteralReadSequence, readBoundedCanonicalText, requiresShellMutationRun, reviewedContextReadPaths, reviewedReleasePaths, rewriteCliInput, selectHookExecutionWorkspace, selectHookRepositoryRoot, shellSyntax, tokenizeLiteralCommand, validateInlineExecution } from "./zaip-pre-tool-support.mjs";
 import { createCloudValidators } from "./zaip-pre-tool-cloud.mjs";
-const execute = promisify(execFile);
+const { execute, parseEvent } = createHookBudget(promisify(execFile));
 const nativeAuthority = await import("./zaip-native-tool-authority.mjs").catch(() => null);
 const activation = await import("./zaip-hook-activation.mjs").catch(() => null);
 const installedRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
@@ -133,8 +133,8 @@ const destructivePatterns = [
   },
 ];
 
-function deny(reason) {
-  activation?.recordActivation(repositoryRoot, event, "denied");
+function deny(reason, record = true) {
+  if (record) activation?.recordActivation(repositoryRoot, event, "denied");
   writeSync(
     1,
     JSON.stringify({
@@ -195,7 +195,7 @@ async function validateExplicitFilesystemReferences(command, cwd, reviewedPaths
   if (homeReferencePattern.test(checked)) {
     deny("Direct user-profile path references are blocked; use repository-scoped paths.");
   }
-  if (credentialReferencePattern.test(checked) || sensitiveEnvironmentPattern.test(checked)) {
+  if (credentialReferencePattern.test(checked.replace(/[;|&()]/g, " ")) || sensitiveEnvironmentPattern.test(checked)) {
     deny("Direct credential and secret access is blocked.");
   }
   if (/\b(?:Get-ChildItem|gci|dir|Get-Item|gi)(?:\s+-(?:LiteralPath|Path))?\s+(?:Env|Variable|Function|Alias):|\b(?:printenv|set)\s*$/i.test(checked) || /GetEnvironmentVariables\s*\(/i.test(checked)) {
@@ -535,7 +535,7 @@ let raw = "";
 for await (const chunk of process.stdin) raw += chunk;
 
 let event;
-event = parseHookEvent(raw, deny);
+event = parseEvent(raw, deny);
 
 const toolInput = event?.tool_input;
 const candidateWorkdir = typeof toolInput?.workdir === "string" && isAbsolute(toolInput.workdir) ? toolInput.workdir : event.cwd;

package/dist/services/codex-pre-tool-host-context-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-pre-tool-host-context-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-pre-tool-host-context-template.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC,QAyI5C,CAAC"}
+{"version":3,"file":"codex-pre-tool-host-context-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-pre-tool-host-context-template.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC,QAwK5C,CAAC"}

package/dist/services/codex-pre-tool-host-context-template.js

@@ -5,7 +5,28 @@ import { promisify } from "node:util";
 const execute = promisify(execFile);
 const pathIdentity = value => process.platform === "win32" ? toNamespacedPath(resolve(value)).toLowerCase() : resolve(value);
 
+export function createHookBudget(executeFile) {
+  const deadline = performance.now() + 6500;
+  return {
+    execute(file, args, options = {}) {
+      const remaining = Math.floor(deadline - performance.now());
+      if (remaining <= 0) throw new Error("Hook validation budget exhausted; inspect the slow dependency before retrying.");
+      return executeFile(file, args, { ...options, timeout: Math.min(options.timeout ?? remaining, remaining) });
+    },
+    parseEvent(raw, deny) {
+      let event; try { event = JSON.parse(raw); } catch { deny("Malformed hook input was rejected."); }
+      // Headroom for the Windows launcher; a stalled dependency never grants authority.
+      const timer = setTimeout(() => deny("Hook validation budget exhausted. Inspect the slow Git/filesystem dependency before retrying; authorization was not granted.", false), Math.max(1, deadline - performance.now()));
+      timer.unref();
+      return event;
+    },
+  };
+}
+
 export function createHostContext({ inside, readBoundedCanonicalText }) {
+// One hook invocation only: never reuse filesystem authority across tool calls.
+const roots = new Map();
+const deadline = performance.now() + 6000;
 /** Project configuration selects ZAIP policy; the host still enforces effective ACLs. */
 async function configuredPermissionProfile(installedRoot) {
   const restricted = { filesystem: false, network: false };
@@ -82,6 +103,11 @@ async function configuredPermissionProfile(installedRoot) {
 }
 
 async function selectHookRepositoryRoot(installedRoot, cwd) {
+  const key = JSON.stringify([installedRoot, cwd]);
+  if (!roots.has(key)) roots.set(key, resolveHookRepositoryRoot(installedRoot, cwd));
+  return roots.get(key);
+}
+async function resolveHookRepositoryRoot(installedRoot, cwd) {
   if (typeof cwd !== "string") throw new Error("Tool execution without a workspace is blocked.");
   const physicalCwd = await realpath(cwd).catch(() => null);
   if (!physicalCwd || pathIdentity(physicalCwd) !== pathIdentity(cwd)) {
@@ -95,13 +121,18 @@ async function selectHookRepositoryRoot(installedRoot, cwd) {
     if (cursor.toLowerCase() === installedRoot.toLowerCase()) return installedRoot;
   }
   try {
-    const git = async (path, ...args) => (await execute("git", ["-C", path, ...args], {
-      encoding: "utf8", windowsHide: true, timeout: 5000, maxBuffer: 1048576,
-    })).stdout.trim();
+    const git = async (path, ...args) => {
+      const remaining = Math.floor(deadline - performance.now());
+      if (remaining <= 0) throw new Error("workspace_validation_budget_exhausted");
+      return (await execute("git", ["-C", path, ...args], {
+        encoding: "utf8", windowsHide: true, timeout: Math.min(2000, remaining), maxBuffer: 1048576,
+      })).stdout.trim();
+    };
     const primary = await git(installedRoot, "rev-parse", "--show-toplevel");
     if ((await realpath(primary)).toLowerCase() !== installedRoot.toLowerCase()) throw new Error("primary_not_root");
     const worktrees = await git(installedRoot, "worktree", "list", "--porcelain", "-z");
     const registered = worktrees.split("\0").filter(line => line.startsWith("worktree ")).map(line => line.slice(9));
+    if (!registered.some(path => inside(cwd, resolve(path)))) throw new Error("worktree_not_registered");
     const candidate = await realpath(await git(cwd, "rev-parse", "--show-toplevel"));
     if (!registered.some(path => resolve(path).toLowerCase() === candidate.toLowerCase()) || !inside(cwd, candidate)) {
       throw new Error("worktree_not_registered");

package/dist/services/codex-pre-tool-host-context-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex-pre-tool-host-context-template.js","sourceRoot":"","sources":["../../src/services/codex-pre-tool-host-context-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gCAAgC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyIzD,CAAC"}
+{"version":3,"file":"codex-pre-tool-host-context-template.js","sourceRoot":"","sources":["../../src/services/codex-pre-tool-host-context-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gCAAgC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwKzD,CAAC"}

package/dist/services/codex-pre-tool-support-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-pre-tool-support-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-pre-tool-support-template.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QAqXvC,CAAC"}
+{"version":3,"file":"codex-pre-tool-support-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-pre-tool-support-template.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QA6YvC,CAAC"}

package/dist/services/codex-pre-tool-support-template.js

@@ -24,6 +24,8 @@ export function parseHookEvent(raw, deny) {
   catch { deny("Malformed hook input was rejected."); }
 }
 
+export { createHookBudget } from "./zaip-pre-tool-host-context.mjs";
+
 export const { configuredPermissionProfile, selectHookRepositoryRoot, selectHookExecutionWorkspace } = createHostContext({ inside, readBoundedCanonicalText });
 
 export function tokenizeLiteralCommand(command) {
@@ -99,6 +101,27 @@ export function requiresShellMutationRun(command, tokens, cwd, repositoryRoot) {
 
 // Recognize only literal read-only pipelines/sequences. Quoted search text is data,
 // not a PowerShell alias (for example the AC prefix in acceptance-criterion IDs).
+function isLiteralGitRead(values) {
+  if (!/^(?:git|git\.exe)$/i.test(values[0])) return false;
+  // Deliberately narrow: only the fixed fsmonitor=false override, no aliases, routing, pagers, external diff,
+  // textconv, output files, or mutating subcommands in a read sequence.
+  const args = values.slice(1);
+  if (args.shift() !== "--no-pager" || args.shift() !== "-c" || args.shift() !== "core.fsmonitor=false") return false;
+  const subcommand = args.shift();
+  if (!["status", "log", "rev-parse", "diff"].includes(subcommand)) return false;
+  if (["diff", "log"].includes(subcommand) && !["--no-ext-diff", "--no-textconv"].every(flag => args.includes(flag))) return false;
+  if (subcommand === "log" && !["--no-patch", "--no-show-signature"].every(flag => args.includes(flag))) return false;
+  if (subcommand === "diff" && !["--name-only", "--name-status", "--stat", "--check"].some(flag => args.includes(flag))) return false;
+  const options = {
+    status: /^(?:-s|-b|--short|--branch|--porcelain(?:=v?[12])?|--untracked-files(?:=(?:no|normal|all))?|--ignored(?:=(?:traditional|matching|no))?)$/,
+    log: /^(?:--no-ext-diff|--no-textconv|--no-patch|--no-show-signature|--oneline|--all|--decorate(?:=(?:short|full|no))?|--no-decorate|--date-order|--topo-order|--reverse|--no-merges|--merges|--max-count=\d+|-\d+|--format=(?:%H|%h|%s|%H%x09%s))$/,
+    "rev-parse": /^(?:--show-toplevel|--git-common-dir|--absolute-git-dir|--is-inside-work-tree|--show-prefix|--verify|--short(?:=\d+)?|--symbolic-full-name|--abbrev-ref|--end-of-options)$/,
+    diff: /^(?:--name-only|--name-status|--stat|--check|--cached|--staged|--no-ext-diff|--no-textconv|--exit-code|--quiet)$/,
+  };
+  return args.every(value => value.startsWith("-") ? options[subcommand].test(value) :
+    // Plain revisions/pathspecs only; shell syntax was already parsed separately.
+    /^[A-Za-z0-9_./@~^:\\-]+$/.test(value));
+}
 export function isLiteralReadSequence(command) {
   const syntax = shellSyntax(command);
   if (syntax.interpolation || syntax.redirection || syntax.grouping) return false;
@@ -119,6 +142,7 @@ export function isLiteralReadSequence(command) {
   return parts.every(part => {
     const values = tokenizeLiteralCommand(part);
     if (!values?.length) return false;
+    if (isLiteralGitRead(values)) return true;
     if (/^Get-Item$/i.test(values[0])) {
       const args = values.slice(1);
       const path = args[0] === "-LiteralPath" ? args[1] : args[0];

package/dist/services/codex-pre-tool-support-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex-pre-tool-support-template.js","sourceRoot":"","sources":["../../src/services/codex-pre-tool-support-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqXpD,CAAC"}
+{"version":3,"file":"codex-pre-tool-support-template.js","sourceRoot":"","sources":["../../src/services/codex-pre-tool-support-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6YpD,CAAC"}

package/dist/services/codex-windows-hook-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-windows-hook-command.d.ts","sourceRoot":"","sources":["../../src/services/codex-windows-hook-command.ts"],"names":[],"mappings":"AAEA,wEAAwE;AACxE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAQpF"}
+{"version":3,"file":"codex-windows-hook-command.d.ts","sourceRoot":"","sources":["../../src/services/codex-windows-hook-command.ts"],"names":[],"mappings":"AAEA,wEAAwE;AACxE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CA2BpF"}

package/dist/services/codex-windows-hook-command.js

@@ -3,10 +3,29 @@ import { resolve } from "node:path";
 export function codexWindowsHookCommand(hook, workspaceRoot) {
     if (!/^zaip-[a-z-]+\.mjs$/.test(hook))
         throw new Error(`Invalid ZAIP hook name: ${hook}`);
-    const literalRoot = workspaceRoot === undefined
+    const search = workspaceRoot === undefined
         ? "(Get-Location)"
         : `'${resolve(workspaceRoot).replaceAll("'", "''")}'`;
-    const script = `$ProgressPreference = 'SilentlyContinue'; $search = ${literalRoot}; $git = $null; while ($search) { $candidate = Join-Path $search '.local/git/cmd/git.exe'; if (Test-Path -LiteralPath $candidate -PathType Leaf) { $git = $candidate; break }; $parent = Split-Path -Path $search -Parent; if (!$parent -or $parent -eq $search) { break }; $search = $parent }; if (!$git) { $git = (Get-Command git -ErrorAction SilentlyContinue).Source }; if (!$git) { exit 0 }; $root = & $git rev-parse --show-toplevel 2>$null; if ($LASTEXITCODE -ne 0 -or !$root) { exit 0 }; $hook = Join-Path $root '.codex/hooks/${hook}'; if (!(Test-Path -LiteralPath $hook -PathType Leaf)) { exit 0 }; & node $hook; exit $LASTEXITCODE`;
+    const script = [
+        "$ProgressPreference = 'SilentlyContinue'",
+        `$search = ${search}`,
+        "$git = $null",
+        "while ($search) { $candidate = Join-Path $search '.local/git/cmd/git.exe'; if (Test-Path -LiteralPath $candidate -PathType Leaf) { $git = $candidate; break }; $parent = Split-Path -Path $search -Parent; if (!$parent -or $parent -eq $search) { break }; $search = $parent }",
+        "if (!$git) { $git = (Get-Command git -ErrorAction SilentlyContinue).Source }",
+        "if (!$git) { exit 0 }",
+        "$probe = New-Object System.Diagnostics.Process",
+        "$probe.StartInfo.FileName = $git",
+        "$probe.StartInfo.Arguments = 'rev-parse --show-toplevel'",
+        "$probe.StartInfo.UseShellExecute = $false",
+        "$probe.StartInfo.CreateNoWindow = $true",
+        "$probe.StartInfo.RedirectStandardOutput = $true",
+        "$probe.StartInfo.RedirectStandardError = $true",
+        "try { if (!$probe.Start()) { throw 'git discovery failed' }; $output = $probe.StandardOutput.ReadToEndAsync(); $errors = $probe.StandardError.ReadToEndAsync(); if (!$probe.WaitForExit(1500)) { $probe.Kill(); [Console]::Error.WriteLine('ZAIP hook: Git discovery exceeded 1500ms; retry after checking Git availability.'); exit 2 }; $root = $output.GetAwaiter().GetResult().Trim(); if ($probe.ExitCode -ne 0 -or !$root) { exit 0 } } catch { [Console]::Error.WriteLine('ZAIP hook: Git discovery failed.'); exit 2 } finally { $probe.Dispose() }",
+        `$hook = Join-Path $root '.codex/hooks/${hook}'`,
+        "if (!(Test-Path -LiteralPath $hook -PathType Leaf)) { exit 0 }",
+        "& node $hook",
+        "exit $LASTEXITCODE",
+    ].join("; ");
     return `powershell -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(script, "utf16le").toString("base64")}`;
 }
 //# sourceMappingURL=codex-windows-hook-command.js.map

package/dist/services/codex-windows-hook-command.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex-windows-hook-command.js","sourceRoot":"","sources":["../../src/services/codex-windows-hook-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,wEAAwE;AACxE,MAAM,UAAU,uBAAuB,CAAC,IAAY,EAAE,aAAsB;IAC1E,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,EAAE,CAAC,CAAC;IAC1F,MAAM,WAAW,GACf,aAAa,KAAK,SAAS;QACzB,CAAC,CAAC,gBAAgB;QAClB,CAAC,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;IAC1D,MAAM,MAAM,GAAG,uDAAuD,WAAW,ihBAAihB,IAAI,qGAAqG,CAAC;IAC5sB,OAAO,yDAAyD,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;AACtH,CAAC"}
+{"version":3,"file":"codex-windows-hook-command.js","sourceRoot":"","sources":["../../src/services/codex-windows-hook-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,wEAAwE;AACxE,MAAM,UAAU,uBAAuB,CAAC,IAAY,EAAE,aAAsB;IAC1E,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,EAAE,CAAC,CAAC;IAC1F,MAAM,MAAM,GACV,aAAa,KAAK,SAAS;QACzB,CAAC,CAAC,gBAAgB;QAClB,CAAC,CAAC,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC;IAC1D,MAAM,MAAM,GAAG;QACb,0CAA0C;QAC1C,aAAa,MAAM,EAAE;QACrB,cAAc;QACd,iRAAiR;QACjR,8EAA8E;QAC9E,uBAAuB;QACvB,gDAAgD;QAChD,kCAAkC;QAClC,0DAA0D;QAC1D,2CAA2C;QAC3C,yCAAyC;QACzC,iDAAiD;QACjD,gDAAgD;QAChD,6hBAA6hB;QAC7hB,yCAAyC,IAAI,GAAG;QAChD,gEAAgE;QAChE,cAAc;QACd,oBAAoB;KACrB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACb,OAAO,yDAAyD,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;AACtH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/cli",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "CLI oficial para instalar e configurar o ZAIP-AIOS em qualquer repositório",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",

package/templates/.agents/README-ENG.md

@@ -12,6 +12,16 @@ test reuse, content-based Dashboard builds and separate npm confirmation.
 Authorized maintenance suspends governance while keeping telemetry active;
 governance is restored and hooks are checked when maintenance ends.
 
+The [hook repair guide](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/hooks-leitura-e-orcamento.md) describes
+permitted Git read sequences, validation time budgets, and retained protections.
+Git read sequences use `git --no-pager -c core.fsmonitor=false` and the documented
+safe options; Git mutations still require separate commands.
+
+The [v5.2 reliability plan](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v52-confiabilidade-e-eficiencia.md)
+records bounded Git discovery in the Windows launcher, observation recovery
+after maintenance, thread-scoped Run queries, and validation cache measurements.
+Evidence distinguishes local tests, independent review, and package publication.
+
 > **Source, candidate, and publication:** this README describes the checkout's
 > contracts and features. The [evolution matrix](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v50-documentacao-editorial.md)
 > identifies implementation and evidence. Local qualification, consumer hook

package/templates/.agents/README.md

@@ -12,6 +12,17 @@ o reuso conservador de testes, o build do Dashboard por conteúdo e a confirmaç
 separada do npm. Manutenção autorizada suspende a governança com telemetria ativa;
 ao terminar, a governança é reativada e os hooks são verificados.
 
+O [guia de correção dos hooks](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/hooks-leitura-e-orcamento.md) descreve
+as sequências Git de leitura permitidas, os limites de tempo da validação e as
+proteções preservadas. Sequências Git de leitura usam o prefixo
+`git --no-pager -c core.fsmonitor=false` e as opções seguras documentadas;
+alterações Git continuam exigindo comandos separados.
+
+O [plano de confiabilidade da v5.2](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v52-confiabilidade-e-eficiencia.md)
+registra a descoberta Git limitada no launcher Windows, a retomada da observação
+após manutenção, a consulta de Runs por chat e a medição do cache de validação.
+As evidências distinguem testes locais, revisão e publicação do pacote.
+
 > **Fonte, candidato e publicação:** este README descreve os contratos e recursos
 > do checkout. A [matriz de evolução](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v50-documentacao-editorial.md)
 > identifica a implementação e suas provas. Qualificação local, ativação dos

package/templates/.agents/config/agents/discovery.json

@@ -1,5 +1,5 @@
 {
-  "_zaip_managed": "zaip-managed generated-do-not-edit source=agent-discovery version=5.1.0 sha256=3def7a2b43c1a751f8e68754ef94cb107a80b5d26e11f065af2b4cc145fc8897",
+  "_zaip_managed": "zaip-managed generated-do-not-edit source=agent-discovery version=5.2.0 sha256=3def7a2b43c1a751f8e68754ef94cb107a80b5d26e11f065af2b4cc145fc8897",
   "schema_version": 1,
   "source": {
     "path": ".agents/config/agents/catalog.yaml",

package/templates/.agents/dashboard/.zaip-managed.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "5.1.0",
+  "version": "5.2.0",
   "files": [
     {
       "path": "DATA-DICTIONARY.md",
@@ -15,28 +15,28 @@
       "sha256": "d0366ee0d847fe681de0971a14c80ee3a6af1430c0e9c5eb4f84f14a4b734b82"
     },
     {
-      "path": "apps/frontend/dist/assets/DashboardHelpDialog-CngnpoLL.js",
-      "sha256": "a8c7d74bc4fae10e94b44ce281bf252a7a4442e284048947a2050616baa3ed9b"
+      "path": "apps/frontend/dist/assets/DashboardHelpDialog-CDUKVlrH.js",
+      "sha256": "bbf13f0ff0788e92a3497eebfbf55ba50d4d5049a232ce8a1bf76eddf5ce2f27"
     },
     {
       "path": "apps/frontend/dist/assets/DashboardHelpDialog-DRI_XwUf.css",
       "sha256": "95dbb5c26ad73831f36f2a51d5e08ef5eee7ca85190764a3e63bf1e700fbadf8"
     },
     {
-      "path": "apps/frontend/dist/assets/PricingSettingsDialog-Bszw3ekd.js",
-      "sha256": "28e93106ed563b43e17d8b4cb46aa027acc9d0971f3abbcd48b9305dd20ca411"
+      "path": "apps/frontend/dist/assets/PricingSettingsDialog-Czs55K79.js",
+      "sha256": "a7b033808de2f224ef57a25f54cd010248409aee921739d8d9aaf2c0350a3866"
     },
     {
       "path": "apps/frontend/dist/assets/ProjectSettingsPage-CQMhvzvJ.css",
       "sha256": "10e875c4e3ab6c252983822e25a85db3d707d903c0fcf39812909fdd1d013f48"
     },
     {
-      "path": "apps/frontend/dist/assets/ProjectSettingsPage-IJ1znG4w.js",
-      "sha256": "77a45822737013dfedc0853315f5c65f9416be5fe368683a3ae0e8d804a6eb80"
+      "path": "apps/frontend/dist/assets/ProjectSettingsPage-DhpaKwjC.js",
+      "sha256": "1a5c8c57b23ab8348c5538644dbb3b7067e8c17db6207a3b8ab473d16abe458e"
     },
     {
-      "path": "apps/frontend/dist/assets/TraceabilityWorkspace-CsBpHqq_.js",
-      "sha256": "27c290e52dc498fc7a6e19af5ef1e765ab52187b372ea851767fe4a80533d2bd"
+      "path": "apps/frontend/dist/assets/TraceabilityWorkspace-DPxfH469.js",
+      "sha256": "869219fb3134c6bedc64160bb34dd9ae3e08b10d5026b3e6744d423dd0967d44"
     },
     {
       "path": "apps/frontend/dist/assets/TraceabilityWorkspace-DvvavDLY.css",
@@ -51,16 +51,16 @@
       "sha256": "90be9550e3b6719ffc7a029ac35a93a4f14e95263b3996ad6c06dbfc0490f307"
     },
     {
-      "path": "apps/frontend/dist/assets/dashboard-localization-D41g5rdo.js",
-      "sha256": "0e58b64d2b946aacef31df14c6e23c3ec1b2036b23fbf7951f40fa08b0bc5719"
+      "path": "apps/frontend/dist/assets/dashboard-localization-BE_Zqtym.js",
+      "sha256": "ca81cef8daca1266f83cc5eaeb114418031b51b531c7ecc9725d29c508f713f1"
     },
     {
       "path": "apps/frontend/dist/assets/icons-vendor-CjGGux6h.js",
       "sha256": "0f615bc6eaeb21d12fc0457867d6acbfe9434ebae0ebecea9444262e46b972e9"
     },
     {
-      "path": "apps/frontend/dist/assets/index-Bedlm0f7.js",
-      "sha256": "087525933cf4d8aca1cfcd0d94cd79154272ef868ab6a6769c5b2586da063cea"
+      "path": "apps/frontend/dist/assets/index-D5HmMZ27.js",
+      "sha256": "116813c811425cbddd8daeaf10f685529bd39f1addf13ad0817e200eb92e4da4"
     },
     {
       "path": "apps/frontend/dist/assets/index-DZhppOIk.css",
@@ -92,7 +92,7 @@
     },
     {
       "path": "apps/frontend/dist/index.html",
-      "sha256": "cde12e53cc862430be3d8e2e59715baef397f7185459e2b0187dcc503d106824"
+      "sha256": "afa794b12e75a74533290aaacad53a7cedf0195915b59adf97c66614ab200df2"
     },
     {
       "path": "apps/frontend/dist/logo_novo_azul.png",
@@ -104,7 +104,7 @@
     },
     {
       "path": "apps/frontend/package.json",
-      "sha256": "89326100d94b5b296a7b1c4a19aa53bbbdf7de7cd6448e55274c1ba71eb8ca56"
+      "sha256": "4d7ac554045ecc7a746ca6ab08ba7e648937d287e63b7de3ce168c0f5ed5dd41"
     },
     {
       "path": "apps/frontend/playwright.dom.config.ts",
@@ -600,7 +600,7 @@
     },
     {
       "path": "modules/cost-monitor/package.json",
-      "sha256": "ec8df0424bec8360e085541b08dfee5187230222c97a42a9b4c1b2f50e597ad3"
+      "sha256": "cb6e9ea88e67bc2d995ab1f8e3e5b094cef307789767565ac8aaafd5863d3413"
     },
     {
       "path": "modules/cost-monitor/src/agent-groups.test.ts",
@@ -1012,7 +1012,7 @@
     },
     {
       "path": "modules/operations/package.json",
-      "sha256": "c6a0b5ae18d3e04f982e8a5f35715c786b38bd8b70b020e094ce6f9ef867f09c"
+      "sha256": "1cdade9fcf22258e1d3a381cc44b296b85c0fa470ef735fdf013bf6b912f7783"
     },
     {
       "path": "modules/operations/src/contracts.ts",
@@ -1752,7 +1752,7 @@
     },
     {
       "path": "modules/traceability/package.json",
-      "sha256": "61836c03c6f44861d19fb5c01b9ab7aba51779d2386d8071ba7b784e8765a520"
+      "sha256": "a567d3b79ed93f40f32b8e869abae93b839588c3d376f985a41f8e070a17a032"
     },
     {
       "path": "modules/traceability/src/contracts.ts",
@@ -1824,7 +1824,7 @@
     },
     {
       "path": "packages/branding/package.json",
-      "sha256": "c2bed43b93cc5828d28b4d0db5f670fc21134c02613f294676f8a2065bea4b75"
+      "sha256": "c87a2648416f60079b50642a5eda2522b6166b2215e2bbfe0d3f204e2aa34828"
     },
     {
       "path": "packages/branding/src/index.ts",
@@ -1836,7 +1836,7 @@
     },
     {
       "path": "packages/contracts/package.json",
-      "sha256": "b9bc011a19137028164eed2080f7a61c88bbc83622c7ec38e534e03d4f82bb18"
+      "sha256": "e92b8965d8158388abb46266bab5dd8b9f3f9cffe1ea4fa11f0730b38fdf1c72"
     },
     {
       "path": "packages/contracts/src/export.ts",
@@ -1856,7 +1856,7 @@
     },
     {
       "path": "packages/data-export/package.json",
-      "sha256": "a65511530a0006eaf112d3a55b715f3cac438970861720ccfba2ecca532a3704"
+      "sha256": "5f964cfadd84f8b2acd652ef30fe9994eedb95c3d9882eb8f0fab4748c9ae161"
     },
     {
       "path": "packages/data-export/src/index.test.ts",
@@ -1904,15 +1904,15 @@
     },
     {
       "path": "packages/local-runtime/dist/server.cjs",
-      "sha256": "664e35c29f948afbba1c97911117ede28702d5ce2e6287f8343732251e06099c"
+      "sha256": "b120e6413f119dbb495680c4656d794951049d6b4800f6df4d6be882778dafbe"
     },
     {
       "path": "packages/local-runtime/dist/sqlite-read-model.cjs",
-      "sha256": "e2b0915ff5050d927e66e24494f6b0a1d704e3456705fb25297dc36168391025"
+      "sha256": "3a39825058ef54ddf71b1d4c9234b25a97ae8135b58ca1467e20d9dbe6d4dab3"
     },
     {
       "path": "packages/local-runtime/package.json",
-      "sha256": "4a5e42396694432911e0d2a824c99c77cb92bcfcf094a143583c3f9291d4117f"
+      "sha256": "8da451715ec125a910f6982fde8f70ff001c0e91deeb97022dddcd373b5eb2c2"
     },
     {
       "path": "packages/local-runtime/scripts/build-frontend.mjs",
@@ -1968,7 +1968,7 @@
     },
     {
       "path": "packages/local-runtime/server.mjs",
-      "sha256": "02222c7a208ecd434849d65a5822859883e3b38a59d078b6b4281228f926ea48"
+      "sha256": "034097a697015e5c364f6f9714484e40797b5c407e36049c15b5f8950a0912c7"
     },
     {
       "path": "packages/local-runtime/src/active-capture-failure.test.ts",
@@ -2836,7 +2836,7 @@
     },
     {
       "path": "packages/local-runtime/start-dashboard.test.mjs",
-      "sha256": "1b28194dca79ec9f32edb0f7a68adbb5fa7b8ecbe5c2a78d529092e16d454709"
+      "sha256": "2bced928062f23b88e2aedc25b41ce5639a21ba05154261c2e0db192fead7875"
     },
     {
       "path": "packages/local-runtime/tsconfig.json",
@@ -2848,7 +2848,7 @@
     },
     {
       "path": "packages/ui/package.json",
-      "sha256": "d3b48ecb1d824b59cd71a9253452c50938b1e7baafd24618bc5f4441a71e5e76"
+      "sha256": "02b9926927d97b3c09b1676c42f83a938082dae5f46f2d5b02e6ecddce7e4935"
     },
     {
       "path": "packages/ui/src/DashboardHeader.test.mjs",
@@ -2956,7 +2956,7 @@
     },
     {
       "path": "tests/e2e/package.json",
-      "sha256": "c92220bdc38b680f170865ec95a9d22f1619c9ef1e97262c408d8f945aa9c359"
+      "sha256": "c0239143bafab4cafcae58d1224748fecd0ab4d6270b753bc6ab718b0b2b20d5"
     },
     {
       "path": "tests/e2e/playwright.config.ts",

package/templates/.agents/dashboard/apps/frontend/dist/assets/{DashboardHelpDialog-CngnpoLL.js → DashboardHelpDialog-CDUKVlrH.js}

@@ -1,4 +1,4 @@
-import{n as e}from"./rolldown-runtime-Bh1tDfsg.js";import{E as t,w as n}from"./cost-monitor-B0Jwz_rk.js";import{t as r}from"./dashboard-localization-D41g5rdo.js";var i=`# Primeiros passos
+import{n as e}from"./rolldown-runtime-Bh1tDfsg.js";import{E as t,w as n}from"./cost-monitor-B0Jwz_rk.js";import{t as r}from"./dashboard-localization-BE_Zqtym.js";var i=`# Primeiros passos
 
 1. Leia \`.agents/config/project.yaml\` e \`.agents/rules/core.md\`.
 2. Consulte \`.agents/records/lifecycle/\` para descobrir o estado atual pelos manifests canônicos.
@@ -2349,6 +2349,17 @@ o reuso conservador de testes, o build do Dashboard por conteúdo e a confirmaç
 separada do npm. Manutenção autorizada suspende a governança com telemetria ativa;
 ao terminar, a governança é reativada e os hooks são verificados.
 
+O [guia de correção dos hooks](docs/quality/hooks-leitura-e-orcamento.md) descreve
+as sequências Git de leitura permitidas, os limites de tempo da validação e as
+proteções preservadas. Sequências Git de leitura usam o prefixo
+\`git --no-pager -c core.fsmonitor=false\` e as opções seguras documentadas;
+alterações Git continuam exigindo comandos separados.
+
+O [plano de confiabilidade da v5.2](docs/quality/v52-confiabilidade-e-eficiencia.md)
+registra a descoberta Git limitada no launcher Windows, a retomada da observação
+após manutenção, a consulta de Runs por chat e a medição do cache de validação.
+As evidências distinguem testes locais, revisão e publicação do pacote.
+
 > **Fonte, candidato e publicação:** este README descreve os contratos e recursos
 > do checkout. A [matriz de evolução](docs/quality/v50-documentacao-editorial.md)
 > identifica a implementação e suas provas. Qualificação local, ativação dos

package/templates/.agents/dashboard/apps/frontend/dist/assets/{PricingSettingsDialog-Bszw3ekd.js → PricingSettingsDialog-Czs55K79.js}

@@ -1 +1 @@
-import{n as e}from"./rolldown-runtime-Bh1tDfsg.js";import{E as t,w as n}from"./cost-monitor-B0Jwz_rk.js";import{n as r}from"./dashboard-localization-D41g5rdo.js";var i=e(t(),1),a=n();function o({catalog:e,fxRate:t,locale:n,onClose:o,onSave:c,onSaveFxRate:l}){let u=r[n],[d,f]=(0,i.useState)(e),[p,m]=(0,i.useState)(t?.rate??0),[h,g]=(0,i.useState)(!1),_=(e,t)=>f(n=>({...n,models:n.models.map((n,r)=>r===e?{...n,...t}:n)})),v=e=>Math.max(0,Number(e)||0);return(0,a.jsx)(`main`,{className:`pricing-backdrop`,children:(0,a.jsxs)(`section`,{"aria-labelledby":`pricing-page-title`,className:`pricing-dialog`,children:[(0,a.jsxs)(`header`,{children:[(0,a.jsxs)(`div`,{children:[(0,a.jsx)(`small`,{children:u.eyebrow}),(0,a.jsx)(`h1`,{id:`pricing-page-title`,children:u.title}),(0,a.jsx)(`p`,{children:u.description})]}),(0,a.jsxs)(`button`,{className:`pricing-back-button`,onClick:o,type:`button`,children:[(0,a.jsx)(`span`,{"aria-hidden":`true`,children:`←`}),` `,u.back]})]}),(0,a.jsxs)(`div`,{className:`pricing-fx-settings`,children:[(0,a.jsxs)(`div`,{className:`pricing-fx-copy`,children:[(0,a.jsx)(`strong`,{children:u.fxTitle}),(0,a.jsx)(`p`,{children:u.fxDescription})]}),(0,a.jsxs)(`label`,{children:[(0,a.jsx)(`span`,{children:u.fxLabel}),(0,a.jsxs)(`div`,{className:`pricing-fx-input`,children:[(0,a.jsx)(`span`,{children:`R$`}),(0,a.jsx)(`input`,{"aria-label":u.fxAriaLabel,min:`0.0001`,onChange:e=>m(Math.max(1e-4,Number(e.target.value)||0)),step:`0.0001`,type:`number`,value:p})]})]})]}),(0,a.jsxs)(`div`,{className:`pricing-table-heading`,children:[(0,a.jsxs)(`div`,{children:[(0,a.jsx)(`strong`,{children:u.catalog}),(0,a.jsx)(`p`,{children:u.pricesPerMillion})]}),(0,a.jsxs)(`span`,{children:[d.models.length,` `,u.models]})]}),(0,a.jsx)(`div`,{className:`pricing-table-wrap`,children:(0,a.jsxs)(`table`,{children:[(0,a.jsx)(`thead`,{children:(0,a.jsxs)(`tr`,{children:[(0,a.jsx)(`th`,{children:u.model}),(0,a.jsx)(`th`,{children:u.provider}),(0,a.jsx)(`th`,{children:u.input}),(0,a.jsx)(`th`,{children:u.cache}),(0,a.jsx)(`th`,{children:u.output}),(0,a.jsx)(`th`,{children:u.reasoning}),(0,a.jsx)(`th`,{children:u.priorityInput}),(0,a.jsx)(`th`,{children:u.priorityCache}),(0,a.jsx)(`th`,{children:u.priorityOutput}),(0,a.jsx)(`th`,{children:u.priorityReasoning}),(0,a.jsx)(`th`,{children:u.contextLimit}),(0,a.jsx)(`th`,{children:u.inputMultiplier}),(0,a.jsx)(`th`,{children:u.outputMultiplier}),(0,a.jsx)(`th`,{})]})}),(0,a.jsx)(`tbody`,{children:d.models.map((e,t)=>(0,a.jsxs)(`tr`,{children:[(0,a.jsxs)(`td`,{children:[(0,a.jsx)(`input`,{"aria-label":u.model,onChange:e=>_(t,{id:e.target.value}),value:e.id}),(0,a.jsx)(`small`,{children:e.aliases.join(`, `)||u.noAliases})]}),(0,a.jsx)(`td`,{children:(0,a.jsxs)(`select`,{onChange:e=>_(t,{provider:e.target.value}),value:e.provider,children:[(0,a.jsx)(`option`,{value:`openai`,children:`OpenAI`}),(0,a.jsx)(`option`,{value:`anthropic`,children:`Anthropic`})]})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{input_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.input_per_million_usd})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{cached_input_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.cached_input_per_million_usd??0})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{output_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.output_per_million_usd})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{reasoning_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.reasoning_per_million_usd??0})}),[`priority_input_per_million_usd`,`priority_cached_input_per_million_usd`,`priority_output_per_million_usd`,`priority_reasoning_per_million_usd`].map(n=>(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{[n]:v(e.target.value)}),step:`0.001`,type:`number`,value:e[n]??0})},n)),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{long_context_threshold_tokens:v(e.target.value)||null}),step:`1`,type:`number`,value:e.long_context_threshold_tokens??0})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0.001`,onChange:e=>_(t,{long_context_input_multiplier:Math.max(.001,Number(e.target.value)||1)}),step:`0.1`,type:`number`,value:e.long_context_input_multiplier})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0.001`,onChange:e=>_(t,{long_context_output_multiplier:Math.max(.001,Number(e.target.value)||1)}),step:`0.1`,type:`number`,value:e.long_context_output_multiplier})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`button`,{"aria-label":u.removeModel,onClick:()=>f(e=>({...e,models:e.models.filter((e,n)=>n!==t)})),type:`button`,children:`×`})})]},e.id))})]})}),(0,a.jsxs)(`footer`,{children:[(0,a.jsxs)(`button`,{onClick:()=>f(e=>({...e,models:[...e.models,s(n)]})),type:`button`,children:[`+ `,u.addModel]}),(0,a.jsxs)(`div`,{children:[(0,a.jsx)(`button`,{onClick:o,type:`button`,children:u.cancel}),(0,a.jsx)(`button`,{disabled:h,onClick:async()=>{g(!0);try{await c(d),await l(p),o()}finally{g(!1)}},type:`button`,children:h?u.saving:u.save})]})]})]})})}function s(e=`pt-BR`){let t=r[e];return{id:t.newModel,provider:`openai`,aliases:[],input_per_million_usd:0,cached_input_per_million_usd:0,output_per_million_usd:0,reasoning_per_million_usd:0,priority_input_per_million_usd:null,priority_cached_input_per_million_usd:null,priority_output_per_million_usd:null,priority_reasoning_per_million_usd:null,reasoning_billed_separately:!1,long_context_threshold_tokens:null,long_context_input_multiplier:1,long_context_output_multiplier:1,source_label:t.manualOverride,source_url:`https://developers.openai.com/api/docs/pricing`,notes:[t.editedNote]}}export{o as PricingSettingsPage};
+import{n as e}from"./rolldown-runtime-Bh1tDfsg.js";import{E as t,w as n}from"./cost-monitor-B0Jwz_rk.js";import{n as r}from"./dashboard-localization-BE_Zqtym.js";var i=e(t(),1),a=n();function o({catalog:e,fxRate:t,locale:n,onClose:o,onSave:c,onSaveFxRate:l}){let u=r[n],[d,f]=(0,i.useState)(e),[p,m]=(0,i.useState)(t?.rate??0),[h,g]=(0,i.useState)(!1),_=(e,t)=>f(n=>({...n,models:n.models.map((n,r)=>r===e?{...n,...t}:n)})),v=e=>Math.max(0,Number(e)||0);return(0,a.jsx)(`main`,{className:`pricing-backdrop`,children:(0,a.jsxs)(`section`,{"aria-labelledby":`pricing-page-title`,className:`pricing-dialog`,children:[(0,a.jsxs)(`header`,{children:[(0,a.jsxs)(`div`,{children:[(0,a.jsx)(`small`,{children:u.eyebrow}),(0,a.jsx)(`h1`,{id:`pricing-page-title`,children:u.title}),(0,a.jsx)(`p`,{children:u.description})]}),(0,a.jsxs)(`button`,{className:`pricing-back-button`,onClick:o,type:`button`,children:[(0,a.jsx)(`span`,{"aria-hidden":`true`,children:`←`}),` `,u.back]})]}),(0,a.jsxs)(`div`,{className:`pricing-fx-settings`,children:[(0,a.jsxs)(`div`,{className:`pricing-fx-copy`,children:[(0,a.jsx)(`strong`,{children:u.fxTitle}),(0,a.jsx)(`p`,{children:u.fxDescription})]}),(0,a.jsxs)(`label`,{children:[(0,a.jsx)(`span`,{children:u.fxLabel}),(0,a.jsxs)(`div`,{className:`pricing-fx-input`,children:[(0,a.jsx)(`span`,{children:`R$`}),(0,a.jsx)(`input`,{"aria-label":u.fxAriaLabel,min:`0.0001`,onChange:e=>m(Math.max(1e-4,Number(e.target.value)||0)),step:`0.0001`,type:`number`,value:p})]})]})]}),(0,a.jsxs)(`div`,{className:`pricing-table-heading`,children:[(0,a.jsxs)(`div`,{children:[(0,a.jsx)(`strong`,{children:u.catalog}),(0,a.jsx)(`p`,{children:u.pricesPerMillion})]}),(0,a.jsxs)(`span`,{children:[d.models.length,` `,u.models]})]}),(0,a.jsx)(`div`,{className:`pricing-table-wrap`,children:(0,a.jsxs)(`table`,{children:[(0,a.jsx)(`thead`,{children:(0,a.jsxs)(`tr`,{children:[(0,a.jsx)(`th`,{children:u.model}),(0,a.jsx)(`th`,{children:u.provider}),(0,a.jsx)(`th`,{children:u.input}),(0,a.jsx)(`th`,{children:u.cache}),(0,a.jsx)(`th`,{children:u.output}),(0,a.jsx)(`th`,{children:u.reasoning}),(0,a.jsx)(`th`,{children:u.priorityInput}),(0,a.jsx)(`th`,{children:u.priorityCache}),(0,a.jsx)(`th`,{children:u.priorityOutput}),(0,a.jsx)(`th`,{children:u.priorityReasoning}),(0,a.jsx)(`th`,{children:u.contextLimit}),(0,a.jsx)(`th`,{children:u.inputMultiplier}),(0,a.jsx)(`th`,{children:u.outputMultiplier}),(0,a.jsx)(`th`,{})]})}),(0,a.jsx)(`tbody`,{children:d.models.map((e,t)=>(0,a.jsxs)(`tr`,{children:[(0,a.jsxs)(`td`,{children:[(0,a.jsx)(`input`,{"aria-label":u.model,onChange:e=>_(t,{id:e.target.value}),value:e.id}),(0,a.jsx)(`small`,{children:e.aliases.join(`, `)||u.noAliases})]}),(0,a.jsx)(`td`,{children:(0,a.jsxs)(`select`,{onChange:e=>_(t,{provider:e.target.value}),value:e.provider,children:[(0,a.jsx)(`option`,{value:`openai`,children:`OpenAI`}),(0,a.jsx)(`option`,{value:`anthropic`,children:`Anthropic`})]})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{input_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.input_per_million_usd})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{cached_input_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.cached_input_per_million_usd??0})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{output_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.output_per_million_usd})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{reasoning_per_million_usd:v(e.target.value)}),step:`0.001`,type:`number`,value:e.reasoning_per_million_usd??0})}),[`priority_input_per_million_usd`,`priority_cached_input_per_million_usd`,`priority_output_per_million_usd`,`priority_reasoning_per_million_usd`].map(n=>(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{[n]:v(e.target.value)}),step:`0.001`,type:`number`,value:e[n]??0})},n)),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0`,onChange:e=>_(t,{long_context_threshold_tokens:v(e.target.value)||null}),step:`1`,type:`number`,value:e.long_context_threshold_tokens??0})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0.001`,onChange:e=>_(t,{long_context_input_multiplier:Math.max(.001,Number(e.target.value)||1)}),step:`0.1`,type:`number`,value:e.long_context_input_multiplier})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`input`,{min:`0.001`,onChange:e=>_(t,{long_context_output_multiplier:Math.max(.001,Number(e.target.value)||1)}),step:`0.1`,type:`number`,value:e.long_context_output_multiplier})}),(0,a.jsx)(`td`,{children:(0,a.jsx)(`button`,{"aria-label":u.removeModel,onClick:()=>f(e=>({...e,models:e.models.filter((e,n)=>n!==t)})),type:`button`,children:`×`})})]},e.id))})]})}),(0,a.jsxs)(`footer`,{children:[(0,a.jsxs)(`button`,{onClick:()=>f(e=>({...e,models:[...e.models,s(n)]})),type:`button`,children:[`+ `,u.addModel]}),(0,a.jsxs)(`div`,{children:[(0,a.jsx)(`button`,{onClick:o,type:`button`,children:u.cancel}),(0,a.jsx)(`button`,{disabled:h,onClick:async()=>{g(!0);try{await c(d),await l(p),o()}finally{g(!1)}},type:`button`,children:h?u.saving:u.save})]})]})]})})}function s(e=`pt-BR`){let t=r[e];return{id:t.newModel,provider:`openai`,aliases:[],input_per_million_usd:0,cached_input_per_million_usd:0,output_per_million_usd:0,reasoning_per_million_usd:0,priority_input_per_million_usd:null,priority_cached_input_per_million_usd:null,priority_output_per_million_usd:null,priority_reasoning_per_million_usd:null,reasoning_billed_separately:!1,long_context_threshold_tokens:null,long_context_input_multiplier:1,long_context_output_multiplier:1,source_label:t.manualOverride,source_url:`https://developers.openai.com/api/docs/pricing`,notes:[t.editedNote]}}export{o as PricingSettingsPage};