@zaip-ai/cli 5.2.0 → 5.4.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.2.0";
+export declare const ADAPTERS_VERSION = "5.4.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.2.0";
+export const ADAPTERS_VERSION = "5.4.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-literal-read-sequence-template.d.ts

@@ -0,0 +1,2 @@
+export declare const CODEX_LITERAL_READ_SEQUENCE: string;
+//# sourceMappingURL=codex-literal-read-sequence-template.d.ts.map

package/dist/services/codex-literal-read-sequence-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-literal-read-sequence-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-literal-read-sequence-template.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QAyFvC,CAAC"}

package/dist/services/codex-literal-read-sequence-template.js

@@ -0,0 +1,91 @@
+export const CODEX_LITERAL_READ_SEQUENCE = String.raw `export function createLiteralReadSequence({ shellSyntax, tokenizeLiteralCommand }) {
+// 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));
+}
+function isLiteralReadSequence(command) {
+  const syntax = shellSyntax(command);
+  if (syntax.interpolation || syntax.redirection || syntax.grouping) return false;
+  const parts = [];
+  let start = 0, quote = null;
+  for (let index = 0; index < command.length; index++) {
+    const char = command[index];
+    if (quote !== null) {
+      if (char === quote) {
+        if (quote === "'" && command[index + 1] === "'" && process.platform === "win32") index++;
+        else quote = null;
+      }
+    } else if (char === "'" || char === '"') quote = char;
+    else if (char === ";" || char === "|") { parts.push(command.slice(start, index)); start = index + 1; }
+  }
+  if (quote !== null) return false;
+  parts.push(command.slice(start));
+  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];
+      return args.length === (args[0] === "-LiteralPath" ? 2 : 1) &&
+        !!path && !/^(?:[a-z][\w-]*:)(?![\/])/i.test(path) && !/[*?]/.test(path);
+    }
+    if (/^Select-Object$/i.test(values[0])) {
+      const args = values.slice(1);
+      const metadata = /^(?:Name|FullName|Length|LastWriteTime|LastWriteTimeUtc|CreationTime|Attributes|IsReadOnly|LinkType|Target)(?:,(?:Name|FullName|Length|LastWriteTime|LastWriteTimeUtc|CreationTime|Attributes|IsReadOnly|LinkType|Target))*$/i;
+      const slice = args.length > 0 && args.length % 2 === 0 && args.every((value, index) =>
+        index % 2 === 0 ? /^(?:-First|-Last|-Skip)$/i.test(value) : /^\d+$/.test(value));
+      return slice ||
+        (args.length === 2 && args[0] === "-ExpandProperty" && args[1] === "Target") ||
+        (args.length === 2 && args[0] === "-Property" && metadata.test(args[1])) ||
+        (args.length === 1 && metadata.test(args[0]));
+    }
+    if (/^Select-String$/i.test(values[0])) {
+      const flags = /^(?:-SimpleMatch|-CaseSensitive|-Quiet|-List|-AllMatches|-NotMatch|-Raw)$/i;
+      const valued = /^(?:-Pattern|-Path|-LiteralPath|-Context|-Encoding)$/i;
+      for (let index = 1; index < values.length; index++) {
+        const value = values[index];
+        if (flags.test(value)) continue;
+        if (valued.test(value) && values[index + 1] !== undefined) { index++; continue; }
+        return false;
+      }
+      return values.length > 1;
+    }
+    if (/^(?:gh|gh\.exe)$/i.test(values[0])) {
+      if (!["run", "release"].includes(values[1]) || values[2] !== "view") return false;
+      const args = values.slice(3);
+      if (args[0] && /^[A-Za-z0-9._-]+$/.test(args[0]) && !args[0].startsWith("-")) args.shift();
+      for (let index = 0; index < args.length; index += 2) {
+        if (!["--json", "--jq"].includes(args[index]) || !args[index + 1]) return false;
+      }
+      return true;
+    }
+    if (/^(?:Get-Content|Measure-Object)$/i.test(values[0])) return true;
+    if (!/^(?:rg|rg\.exe)$/i.test(values[0])) return false;
+    return !values.slice(1).some(value => /^--(?:pre|hostname-bin)(?:=|$)/i.test(value));
+  });
+}
+
+return isLiteralReadSequence;
+}
+`;
+//# sourceMappingURL=codex-literal-read-sequence-template.js.map

package/dist/services/codex-literal-read-sequence-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-literal-read-sequence-template.js","sourceRoot":"","sources":["../../src/services/codex-literal-read-sequence-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFpD,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"codex-pre-tool-hook-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-pre-tool-hook-template.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,QA+mB/B,CAAC"}
+{"version":3,"file":"codex-pre-tool-hook-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-pre-tool-hook-template.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB,QAspB/B,CAAC"}

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

@@ -214,8 +214,11 @@ async function validateExplicitFilesystemReferences(command, cwd, reviewedPaths
     if (jsonPath) { if (path.includes("\\") || !isWithinRepository(resolve(path))) deny("Explicit filesystem path escapes the repository boundary."); continue; }
     if (path.includes("\\") || !isWithinRepository(resolve(path)) || (match[2] && before && !(/\s/.test(before) || before === "=" || jsonPath)) || (after && !/\s/.test(after) && !jsonPath)) deny("Explicit operating-system paths outside the repository are blocked.");
   }
-  if (process.platform === "win32" && /(?:^|[\s"'=(,])\\(?!\\)[^\s\\/"'<>|;]+(?:\\[^\s"'<>|;]+|\.[A-Za-z0-9]{1,10})/.test(checked)) {
-    deny("Drive-rooted filesystem paths outside the repository are blocked.");
+  if (process.platform === "win32") {
+    for (const match of checked.matchAll(/(?:^|[\s"'=(,])(\\(?!\\)[^\s\\/"'<>|;]+(?:\\[^\s"'<>|;]+|\.[A-Za-z0-9]{1,10}))/g)) {
+      if (principalFullAccess) { await assertCanonicalLiteralPath(match[1], cwd); continue; }
+      deny("Drive-rooted filesystem paths outside the repository are blocked.");
+    }
   }
   for (const candidate of explicitPathCandidates(checked)) {
     if (principalFullAccess) { await assertCanonicalLiteralPath(candidate, cwd); continue; }
@@ -302,6 +305,41 @@ async function validateGitPublication(command) {
   }
 }
 
+// These CLI values are data, never shell programs. Only one literal invocation of
+// the canonical runtime qualifies; interpolation, pipelines and other scripts do not.
+function executionPolicyCommand(command) {
+  const tokens = tokenizeLiteralCommand(command);
+  if (!tokens || !/^(?:.*[\\/])?node(?:\.exe)?$/i.test(tokens[0] ?? "") ||
+      resolve(event.cwd, tokens[1] ?? "") !== resolve(repositoryRoot, ".agents/runtime/bin/zaip.mjs") ||
+      tokens[2] !== "conversation" || tokens[3] !== "finish") return command;
+  const result = [...tokens];
+  for (let index = 4; index < result.length; index++) {
+    if (result[index] === "--summary" && index + 1 < result.length) result[++index] = "literal-summary";
+    else if (result[index].startsWith("--summary=")) result[index] = "--summary=literal-summary";
+  }
+  return result.map(token => JSON.stringify(token)).join(" ");
+}
+
+async function isCurrentRepositoryRead(command) {
+  const tokens = tokenizeLiteralCommand(command);
+  if (!tokens || !/^gh(?:\.exe)?$/i.test(tokens[0] ?? "")) return false;
+  const rest = [], repositories = [];
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token === "--repo" || token === "-R") repositories.push(tokens[++index]);
+    else if (token.startsWith("--repo=")) repositories.push(token.slice(7));
+    else if (token.startsWith("-R") && token.length > 2) repositories.push(token.slice(2));
+    else rest.push(token);
+  }
+  if (repositories.length !== 1 || !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repositories[0] ?? "") ||
+      rest.some(token => token.includes("'")) || !isLiteralReadSequence(rest.map(token => "'" + token + "'").join(" "))) return false;
+  try {
+    const origin = (await execute("git", ["remote", "get-url", "origin"], { cwd: repositoryRoot, encoding: "utf8", windowsHide: true })).stdout.trim();
+    const match = /^(?:git@github\.com:|https:\/\/github\.com\/|ssh:\/\/git@github\.com\/)([^/]+\/[^/]+?)\.git$|^(?:git@github\.com:|https:\/\/github\.com\/|ssh:\/\/git@github\.com\/)([^/]+\/[^/]+?)\/?$/.exec(origin);
+    return !!match && (match[1] ?? match[2]).toLowerCase() === repositories[0].toLowerCase();
+  } catch { return false; }
+}
+
 function validateHashicorpRead(command) {
   const tokens = tokenizeLiteralCommand(command);
   if (!tokens || !/^(?:curl(?:\.exe)?|Invoke-WebRequest|Invoke-RestMethod|iwr|irm)$/i.test(tokens[0]))
@@ -609,14 +647,15 @@ else {
     ...await reviewedContextReadPaths(command, credentialReferencePattern, installedRoot), ...await (nativeAuthority?.reviewedValidationRuntimePaths?.(command, tokenizeLiteralCommand, repositoryRoot) ?? []),
   ];
   await validateExplicitFilesystemReferences(command, event.cwd, reviewedPaths);
-  validateInlineExecution(command, deny);
-  if (!isLiteralReadSequence(command)) {
-  await validateGitPublication(command);
-  await validateCloudRunner(command);
-  validateDirectCloudProviderMutation(command);
-  validateExplicitNetwork(command);
-  await validateShellDeletion(command, event.cwd);
-  checkDestructivePatterns(command, destructivePatterns, deny);
+  const policyCommand = executionPolicyCommand(command);
+  validateInlineExecution(policyCommand, deny);
+  if (!isLiteralReadSequence(policyCommand) && !await isCurrentRepositoryRead(policyCommand)) {
+  await validateGitPublication(policyCommand);
+  await validateCloudRunner(policyCommand);
+  validateDirectCloudProviderMutation(policyCommand);
+  validateExplicitNetwork(policyCommand);
+  await validateShellDeletion(policyCommand, event.cwd);
+  checkDestructivePatterns(policyCommand, destructivePatterns, deny);
   }
   try { const updated = await captureCliTurn(repositoryRoot, event, command); if (updated) writeSync(1, JSON.stringify(rewriteCliInput(toolInput, updated, commandFromCmd)) + "\n"); }
   catch (error) { deny(error.message); }

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

@@ -1 +1 @@
-{"version":3,"file":"codex-pre-tool-hook-template.js","sourceRoot":"","sources":["../../src/services/codex-pre-tool-hook-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0W3C,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqQ5B,CAAC"}
+{"version":3,"file":"codex-pre-tool-hook-template.js","sourceRoot":"","sources":["../../src/services/codex-pre-tool-hook-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgZ3C,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsQ5B,CAAC"}

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,QAwK5C,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":"AAEA,eAAO,MAAM,gCAAgC,QAyK5C,CAAC"}

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

@@ -1,3 +1,4 @@
+import { CODEX_LITERAL_READ_SEQUENCE } from "./codex-literal-read-sequence-template.js";
 export const CODEX_PRE_TOOL_HOST_CONTEXT_HOOK = String.raw `import { execFile } from "node:child_process";
 import { lstat, realpath } from "node:fs/promises";
 import { dirname, isAbsolute, resolve, toNamespacedPath } from "node:path";
@@ -166,5 +167,6 @@ async function selectHookExecutionWorkspace(installedRoot, event, allowExternal
 
 return { configuredPermissionProfile, selectHookRepositoryRoot, selectHookExecutionWorkspace };
 }
+${CODEX_LITERAL_READ_SEQUENCE}
 `;
 //# sourceMappingURL=codex-pre-tool-host-context-template.js.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwKzD,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,OAAO,EAAE,2BAA2B,EAAE,MAAM,2CAA2C,CAAC;AAExF,MAAM,CAAC,MAAM,gCAAgC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwKxD,2BAA2B;CAC5B,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,QA6YvC,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,QA8UvC,CAAC"}

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

@@ -1,7 +1,7 @@
 export const CODEX_PRE_TOOL_SUPPORT_HOOK = String.raw `import { lstat, readFile, realpath } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve, toNamespacedPath } from "node:path";
 import { homedir } from "node:os";
-import { createHostContext } from "./zaip-pre-tool-host-context.mjs";
+import { createHostContext, createLiteralReadSequence } from "./zaip-pre-tool-host-context.mjs";
 import { createCliTurnCapture } from "./zaip-pre-tool-cli-capture.mjs";
 export { readAuthorityRunRecords, checkDestructivePatterns, configuredDeploymentBranches } from "./zaip-native-tool-authority.mjs";
 const pathIdentity = value => process.platform === "win32" ? toNamespacedPath(resolve(value)).toLowerCase() : resolve(value);
@@ -99,70 +99,7 @@ export function requiresShellMutationRun(command, tokens, cwd, repositoryRoot) {
   return (tokens && isSedMutation(tokens)) || shellMutationPattern.test(command) || syntax.redirection;
 }
 
-// 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;
-  const parts = [];
-  let start = 0, quote = null;
-  for (let index = 0; index < command.length; index++) {
-    const char = command[index];
-    if (quote !== null) {
-      if (char === quote) {
-        if (quote === "'" && command[index + 1] === "'" && process.platform === "win32") index++;
-        else quote = null;
-      }
-    } else if (char === "'" || char === '"') quote = char;
-    else if (char === ";" || char === "|") { parts.push(command.slice(start, index)); start = index + 1; }
-  }
-  if (quote !== null) return false;
-  parts.push(command.slice(start));
-  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];
-      return args.length === (args[0] === "-LiteralPath" ? 2 : 1) &&
-        !!path && !/^(?:[a-z][\w-]*:)(?![\/])/i.test(path) && !/[*?]/.test(path);
-    }
-    if (/^Select-Object$/i.test(values[0])) {
-      const args = values.slice(1);
-      const metadata = /^(?:Name|FullName|Length|LastWriteTime|LastWriteTimeUtc|CreationTime|Attributes|IsReadOnly|LinkType|Target)(?:,(?:Name|FullName|Length|LastWriteTime|LastWriteTimeUtc|CreationTime|Attributes|IsReadOnly|LinkType|Target))*$/i;
-      return (args.length === 2 && args[0] === "-First" && /^\d+$/.test(args[1])) ||
-        (args.length === 2 && args[0] === "-ExpandProperty" && args[1] === "Target") ||
-        (args.length === 2 && args[0] === "-Property" && metadata.test(args[1])) ||
-        (args.length === 1 && metadata.test(args[0]));
-    }
-    if (/^(?:Get-Content|Measure-Object)$/i.test(values[0])) return true;
-    if (!/^(?:rg|rg\.exe)$/i.test(values[0])) return false;
-    return !values.slice(1).some(value => /^--(?:pre|hostname-bin)(?:=|$)/i.test(value));
-  });
-}
-
+export const isLiteralReadSequence = createLiteralReadSequence({ shellSyntax, tokenizeLiteralCommand });
 function isSedMutation(tokens) {
   const executable = ((tokens[0] ?? "").split(/[\\/]/).pop() ?? "").replace(/\.(?:exe|cmd|bat)$/i, "");
   return /^sed$/i.test(executable) && tokens.slice(1).some((token) =>

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6YpD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8UpD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/cli",
-  "version": "5.2.0",
+  "version": "5.4.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

@@ -6,6 +6,12 @@ English | [Português](README.md)
 
 ## Quick overview
 
+The [v5.4 guide](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v54-fechamento-cache-hooks.md) describes restricted
+administrative closure after publication, the distinction between text and commands
+in hooks, GitHub queries targeting the current repository, and objective acceptance
+criteria. Partial evidence and historical outcomes remain visible; tests are rerun
+when a change or finding invalidates the corresponding proof.
+
 The [rework prevention guide](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v51-eficiencia-e-publicacao.md)
 documents complete checks before finalization, bounded Run reads, conservative
 test reuse, content-based Dashboard builds and separate npm confirmation.
@@ -22,6 +28,19 @@ 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.
 
+The [v5.3 governance and recovery contract](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v53-governanca-e-retomada.md)
+defines recovery for published Task-first deliveries, Run continuity,
+authenticated remote resumption, and criteria for measuring actual test savings.
+Legacy failure reconciliation uses complete signed reruns, preserves history,
+and prevents resolved failures from imposing indefinite retests. It does not
+waive impact checks or turn an unverified installation into a cache HIT.
+Literal audit queries using `Select-String`, numeric `Select-Object` slices,
+and `gh run view`/`gh release view` are reads; interpolation, remote writes,
+redirection, and secret access retain their controls.
+On Windows, rooted paths used by the principal in `zaip-aios-full-access` undergo
+canonical validation; literal search patterns are not blocked merely because
+they contain a backslash. Traversal and protected destinations remain denied.
+
 > **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

@@ -6,6 +6,12 @@
 
 ## Visão rápida
 
+O [guia da v5.4](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v54-fechamento-cache-hooks.md) descreve o fechamento
+administrativo restrito após publicação, a distinção entre texto e comandos nos
+hooks, consultas GitHub ao repositório atual e os critérios objetivos de aceite.
+Evidências parciais e estados históricos permanecem visíveis; testes são repetidos
+quando uma mudança ou finding invalida a prova correspondente.
+
 O [guia de prevenção de retrabalho](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v51-eficiencia-e-publicacao.md)
 documenta o pré-check completo antes da finalização, as leituras limitadas de Runs,
 o reuso conservador de testes, o build do Dashboard por conteúdo e a confirmação
@@ -23,6 +29,19 @@ registra a descoberta Git limitada no launcher Windows, a retomada da observaç
 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.
 
+O [contrato de governança e retomada da v5.3](https://github.com/zaip-ai/zaip-aios/blob/main/docs/quality/v53-governanca-e-retomada.md)
+define a recuperação de entregas Task-first publicadas, a continuidade de Runs,
+a retomada remota autenticada e os critérios para medir economia real de testes.
+A reconciliação de falhas antigas usa reexecuções completas e assinadas, preserva
+o histórico e evita que uma falha já resolvida imponha retestes indefinidamente.
+Isso não dispensa os testes por impacto nem transforma uma instalação não verificada em HIT.
+Consultas literais de auditoria com `Select-String`, recortes numéricos de
+`Select-Object` e `gh run view`/`gh release view` são leituras; interpolação,
+escrita remota, redirecionamento e acesso a segredos conservam seus controles.
+No Windows, caminhos rooted do principal em `zaip-aios-full-access` passam pela
+validação canônica; padrões literais de busca não causam bloqueio apenas por
+conter uma barra invertida. Travessia e destinos protegidos continuam recusados.
+
 > **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.2.0 sha256=3def7a2b43c1a751f8e68754ef94cb107a80b5d26e11f065af2b4cc145fc8897",
+  "_zaip_managed": "zaip-managed generated-do-not-edit source=agent-discovery version=5.4.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.2.0",
+  "version": "5.4.0",
   "files": [
     {
       "path": "DATA-DICTIONARY.md",
@@ -15,28 +15,28 @@
       "sha256": "d0366ee0d847fe681de0971a14c80ee3a6af1430c0e9c5eb4f84f14a4b734b82"
     },
     {
-      "path": "apps/frontend/dist/assets/DashboardHelpDialog-CDUKVlrH.js",
-      "sha256": "bbf13f0ff0788e92a3497eebfbf55ba50d4d5049a232ce8a1bf76eddf5ce2f27"
+      "path": "apps/frontend/dist/assets/DashboardHelpDialog-Bw42VT15.js",
+      "sha256": "a783e3da41818c3b756f52ca13b5055cff73c128476e8774bb388cbf450acb3b"
     },
     {
       "path": "apps/frontend/dist/assets/DashboardHelpDialog-DRI_XwUf.css",
       "sha256": "95dbb5c26ad73831f36f2a51d5e08ef5eee7ca85190764a3e63bf1e700fbadf8"
     },
     {
-      "path": "apps/frontend/dist/assets/PricingSettingsDialog-Czs55K79.js",
-      "sha256": "a7b033808de2f224ef57a25f54cd010248409aee921739d8d9aaf2c0350a3866"
+      "path": "apps/frontend/dist/assets/PricingSettingsDialog-C3Y-jqQe.js",
+      "sha256": "378ef7877d5a017d95fae04687ce72a3795e943992d959552bf475c0101bd54d"
     },
     {
-      "path": "apps/frontend/dist/assets/ProjectSettingsPage-CQMhvzvJ.css",
-      "sha256": "10e875c4e3ab6c252983822e25a85db3d707d903c0fcf39812909fdd1d013f48"
+      "path": "apps/frontend/dist/assets/ProjectSettingsPage-Bx54lj7x.js",
+      "sha256": "a5902a5abf2437bbf7d1883419fde1bd62070e53d83bc9e04c3e0cb9d5b9eb6d"
     },
     {
-      "path": "apps/frontend/dist/assets/ProjectSettingsPage-DhpaKwjC.js",
-      "sha256": "1a5c8c57b23ab8348c5538644dbb3b7067e8c17db6207a3b8ab473d16abe458e"
+      "path": "apps/frontend/dist/assets/ProjectSettingsPage-CQMhvzvJ.css",
+      "sha256": "10e875c4e3ab6c252983822e25a85db3d707d903c0fcf39812909fdd1d013f48"
     },
     {
-      "path": "apps/frontend/dist/assets/TraceabilityWorkspace-DPxfH469.js",
-      "sha256": "869219fb3134c6bedc64160bb34dd9ae3e08b10d5026b3e6744d423dd0967d44"
+      "path": "apps/frontend/dist/assets/TraceabilityWorkspace-BNxFpGCt.js",
+      "sha256": "51899fe52c732793df9cb29379931176c509018b48668f55dc642e3613da2a2d"
     },
     {
       "path": "apps/frontend/dist/assets/TraceabilityWorkspace-DvvavDLY.css",
@@ -51,16 +51,16 @@
       "sha256": "90be9550e3b6719ffc7a029ac35a93a4f14e95263b3996ad6c06dbfc0490f307"
     },
     {
-      "path": "apps/frontend/dist/assets/dashboard-localization-BE_Zqtym.js",
-      "sha256": "ca81cef8daca1266f83cc5eaeb114418031b51b531c7ecc9725d29c508f713f1"
+      "path": "apps/frontend/dist/assets/dashboard-localization-BQDxpGq0.js",
+      "sha256": "0bba0031539780611dcb2d6013975d28afffe14d36adb48d899976f72764c886"
     },
     {
       "path": "apps/frontend/dist/assets/icons-vendor-CjGGux6h.js",
       "sha256": "0f615bc6eaeb21d12fc0457867d6acbfe9434ebae0ebecea9444262e46b972e9"
     },
     {
-      "path": "apps/frontend/dist/assets/index-D5HmMZ27.js",
-      "sha256": "116813c811425cbddd8daeaf10f685529bd39f1addf13ad0817e200eb92e4da4"
+      "path": "apps/frontend/dist/assets/index-CsSv72iu.js",
+      "sha256": "b77d3ec46eb6ef76265b8435b60237f71615dba33eb977e32d1c20a8fa1a92f5"
     },
     {
       "path": "apps/frontend/dist/assets/index-DZhppOIk.css",
@@ -92,7 +92,7 @@
     },
     {
       "path": "apps/frontend/dist/index.html",
-      "sha256": "afa794b12e75a74533290aaacad53a7cedf0195915b59adf97c66614ab200df2"
+      "sha256": "131bba5c5dd50297a046ef0ae1794540fe8db8b8e8526e50f9d828d4a345b13f"
     },
     {
       "path": "apps/frontend/dist/logo_novo_azul.png",
@@ -104,7 +104,7 @@
     },
     {
       "path": "apps/frontend/package.json",
-      "sha256": "4d7ac554045ecc7a746ca6ab08ba7e648937d287e63b7de3ce168c0f5ed5dd41"
+      "sha256": "8e6978a93314bf237edfa58a5e74a29e3f9a426c31078d154b293e49c8dbb62d"
     },
     {
       "path": "apps/frontend/playwright.dom.config.ts",
@@ -600,7 +600,7 @@
     },
     {
       "path": "modules/cost-monitor/package.json",
-      "sha256": "cb6e9ea88e67bc2d995ab1f8e3e5b094cef307789767565ac8aaafd5863d3413"
+      "sha256": "ee000ea96ddda721096ac3814301a947786aaa82121af3e1bdecde099a78e719"
     },
     {
       "path": "modules/cost-monitor/src/agent-groups.test.ts",
@@ -1012,7 +1012,7 @@
     },
     {
       "path": "modules/operations/package.json",
-      "sha256": "1cdade9fcf22258e1d3a381cc44b296b85c0fa470ef735fdf013bf6b912f7783"
+      "sha256": "825b2668a3836982e80d19c0b7acead8bd89f5d50a790687745a9a46a1ea4660"
     },
     {
       "path": "modules/operations/src/contracts.ts",
@@ -1752,7 +1752,7 @@
     },
     {
       "path": "modules/traceability/package.json",
-      "sha256": "a567d3b79ed93f40f32b8e869abae93b839588c3d376f985a41f8e070a17a032"
+      "sha256": "77d2707dc0116c0bbca917a1886f6fc07fc654410a2043d8ffacb006aa04af21"
     },
     {
       "path": "modules/traceability/src/contracts.ts",
@@ -1824,7 +1824,7 @@
     },
     {
       "path": "packages/branding/package.json",
-      "sha256": "c87a2648416f60079b50642a5eda2522b6166b2215e2bbfe0d3f204e2aa34828"
+      "sha256": "451eba3b4f2ebc0d2c3094bf25bbf7098373e820b7d2eec9e7e6df857b182264"
     },
     {
       "path": "packages/branding/src/index.ts",
@@ -1836,7 +1836,7 @@
     },
     {
       "path": "packages/contracts/package.json",
-      "sha256": "e92b8965d8158388abb46266bab5dd8b9f3f9cffe1ea4fa11f0730b38fdf1c72"
+      "sha256": "5beb981d7c1f4d448ef584fa93237dce7b1d85ff16d3b01dc6ce51d3f9890552"
     },
     {
       "path": "packages/contracts/src/export.ts",
@@ -1856,7 +1856,7 @@
     },
     {
       "path": "packages/data-export/package.json",
-      "sha256": "5f964cfadd84f8b2acd652ef30fe9994eedb95c3d9882eb8f0fab4748c9ae161"
+      "sha256": "e61913ebcd0508e883b5e3576732a6781ed97aebed2151abd44223eea905a03d"
     },
     {
       "path": "packages/data-export/src/index.test.ts",
@@ -1904,15 +1904,15 @@
     },
     {
       "path": "packages/local-runtime/dist/server.cjs",
-      "sha256": "b120e6413f119dbb495680c4656d794951049d6b4800f6df4d6be882778dafbe"
+      "sha256": "cda7a18aa202d782aa6168064bb3b05c765df8991c07f960669b101efd1c64c4"
     },
     {
       "path": "packages/local-runtime/dist/sqlite-read-model.cjs",
-      "sha256": "3a39825058ef54ddf71b1d4c9234b25a97ae8135b58ca1467e20d9dbe6d4dab3"
+      "sha256": "76d6bbfa4712f1bfb22faf0bd83886db06fbcdc3efae913e7988c832b77a86a0"
     },
     {
       "path": "packages/local-runtime/package.json",
-      "sha256": "8da451715ec125a910f6982fde8f70ff001c0e91deeb97022dddcd373b5eb2c2"
+      "sha256": "ece14cb50871d8b14559061627ba748e4ece7e5b035551f147a57432b67efce4"
     },
     {
       "path": "packages/local-runtime/scripts/build-frontend.mjs",
@@ -1968,7 +1968,7 @@
     },
     {
       "path": "packages/local-runtime/server.mjs",
-      "sha256": "034097a697015e5c364f6f9714484e40797b5c407e36049c15b5f8950a0912c7"
+      "sha256": "40f1234a02292f13e6f552e70b7c8d0c0a9a1e471b1721a3d7f733f6a26dd587"
     },
     {
       "path": "packages/local-runtime/src/active-capture-failure.test.ts",
@@ -2848,7 +2848,7 @@
     },
     {
       "path": "packages/ui/package.json",
-      "sha256": "02b9926927d97b3c09b1676c42f83a938082dae5f46f2d5b02e6ecddce7e4935"
+      "sha256": "01f16550fe270897d2fdb33c0cc00e2e6bfd1d43b8a3003c11120f7e0aa93b68"
     },
     {
       "path": "packages/ui/src/DashboardHeader.test.mjs",
@@ -2956,7 +2956,7 @@
     },
     {
       "path": "tests/e2e/package.json",
-      "sha256": "c0239143bafab4cafcae58d1224748fecd0ab4d6270b753bc6ab718b0b2b20d5"
+      "sha256": "06416ed38e888fdbc6e4870600bbc4725bcb917d17014c647ef808dd80daf849"
     },
     {
       "path": "tests/e2e/playwright.config.ts",