@zaip-ai/cli 6.3.0 → 7.6.0

package/dist/services/codex-hook-activation.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex-hook-activation.js","sourceRoot":"","sources":["../../src/services/codex-hook-activation.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,YAAY;IACZ,eAAe;IACf,cAAc;IACd,MAAM;CACE,CAAC;AACX,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,oBAAoB;IACpB,oCAAoC;IACpC,wCAAwC;IACxC,+CAA+C;IAC/C,sCAAsC;IACtC,6CAA6C;IAC7C,4CAA4C;IAC5C,6CAA6C;IAC7C,0CAA0C;IAC1C,8CAA8C;IAC9C,uCAAuC;CAC/B,CAAC;AAEX,+FAA+F;AAC/F,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;gBAI/B,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;iBACpC,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4JtD,CAAC"}
+{"version":3,"file":"codex-hook-activation.js","sourceRoot":"","sources":["../../src/services/codex-hook-activation.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,YAAY;IACZ,eAAe;IACf,cAAc;IACd,MAAM;CACE,CAAC;AACX,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,oBAAoB;IACpB,oCAAoC;IACpC,wCAAwC;IACxC,+CAA+C;IAC/C,sCAAsC;IACtC,6CAA6C;IAC7C,6CAA6C;IAC7C,4CAA4C;IAC5C,6CAA6C;IAC7C,+CAA+C;IAC/C,uCAAuC;IACvC,uCAAuC;IACvC,0CAA0C;IAC1C,+CAA+C;IAC/C,0CAA0C;IAC1C,8CAA8C;IAC9C,uCAAuC;CAC/B,CAAC;AAEX,+FAA+F;AAC/F,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;gBAI/B,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC;iBACpC,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmMtD,CAAC"}

package/dist/services/codex-host-diagnostic.d.ts

@@ -0,0 +1,10 @@
+import type { CodexProjectTrustResult } from "./global-codex-project-trust.js";
+import type { HookReadinessSummary } from "./hook-readiness.js";
+export interface CodexHostDiagnostic {
+    projectTrust: CodexProjectTrustResult | null;
+    hooks: HookReadinessSummary;
+    loadedAgents: "unverified";
+}
+/** Installed profiles and project trust cannot prove what the current host loaded. */
+export declare function codexHostDiagnostic(hooks: HookReadinessSummary, projectTrust?: CodexProjectTrustResult | null): CodexHostDiagnostic;
+//# sourceMappingURL=codex-host-diagnostic.d.ts.map

package/dist/services/codex-host-diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-host-diagnostic.d.ts","sourceRoot":"","sources":["../../src/services/codex-host-diagnostic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAC7C,KAAK,EAAE,oBAAoB,CAAC;IAC5B,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED,sFAAsF;AACtF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,oBAAoB,EAC3B,YAAY,GAAE,uBAAuB,GAAG,IAAW,GAClD,mBAAmB,CAErB"}

package/dist/services/codex-host-diagnostic.js

@@ -0,0 +1,5 @@
+/** Installed profiles and project trust cannot prove what the current host loaded. */
+export function codexHostDiagnostic(hooks, projectTrust = null) {
+    return { projectTrust, hooks, loadedAgents: "unverified" };
+}
+//# sourceMappingURL=codex-host-diagnostic.js.map

package/dist/services/codex-host-diagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-host-diagnostic.js","sourceRoot":"","sources":["../../src/services/codex-host-diagnostic.ts"],"names":[],"mappings":"AASA,sFAAsF;AACtF,MAAM,UAAU,mBAAmB,CACjC,KAA2B,EAC3B,YAAY,GAAmC,IAAI;IAEnD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;AAC7D,CAAC"}

package/dist/services/codex-host-diagnostic.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codex-host-diagnostic.test.d.ts.map

package/dist/services/codex-host-diagnostic.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-host-diagnostic.test.d.ts","sourceRoot":"","sources":["../../src/services/codex-host-diagnostic.test.ts"],"names":[],"mappings":""}

package/dist/services/codex-host-diagnostic.test.js

@@ -0,0 +1,24 @@
+import { expect, it } from "vitest";
+import { codexHostDiagnostic } from "./codex-host-diagnostic.js";
+it("does not infer approved hooks or loaded agents from verified project trust", () => {
+    expect(codexHostDiagnostic({ state: "activation_unverified", full_integration: false }, {
+        state: "trusted",
+        project: "/current",
+        path: "/home/config.toml",
+        changed: true,
+        backupPath: null,
+        reason: null,
+    })).toMatchObject({
+        projectTrust: { state: "trusted" },
+        hooks: { full_integration: false },
+        loadedAgents: "unverified",
+    });
+});
+it("validated hook events still do not prove which agents the host loaded", () => {
+    expect(codexHostDiagnostic({ state: "validated", full_integration: true })).toMatchObject({
+        projectTrust: null,
+        hooks: { full_integration: true },
+        loadedAgents: "unverified",
+    });
+});
+//# sourceMappingURL=codex-host-diagnostic.test.js.map

package/dist/services/codex-host-diagnostic.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-host-diagnostic.test.js","sourceRoot":"","sources":["../../src/services/codex-host-diagnostic.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,EAAE,CAAC,4EAA4E,EAAE,GAAG,EAAE;IACpF,MAAM,CACJ,mBAAmB,CACjB,EAAE,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,KAAK,EAAE,EAC3D;QACE,KAAK,EAAE,SAAS;QAChB,OAAO,EAAE,UAAU;QACnB,IAAI,EAAE,mBAAmB;QACzB,OAAO,EAAE,IAAI;QACb,UAAU,EAAE,IAAI;QAChB,MAAM,EAAE,IAAI;KACb,CACF,CACF,CAAC,aAAa,CAAC;QACd,YAAY,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAClC,KAAK,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE;QAClC,YAAY,EAAE,YAAY;KAC3B,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,EAAE,CAAC,uEAAuE,EAAE,GAAG,EAAE;IAC/E,MAAM,CAAC,mBAAmB,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;QACxF,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAE;QACjC,YAAY,EAAE,YAAY;KAC3B,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

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

@@ -1 +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"}
+{"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,QAoLvC,CAAC"}

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

@@ -9,18 +9,23 @@ function isLiteralGitRead(values) {
   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 delimiter = args.indexOf("--");
+  const beforePaths = delimiter < 0 ? args : args.slice(0, delimiter);
+  const paths = delimiter < 0 ? [] : args.slice(delimiter + 1);
+  // Protection flags after the delimiter are filenames, never Git options.
+  if (["diff", "log"].includes(subcommand) && !["--no-ext-diff", "--no-textconv"].every(flag => beforePaths.includes(flag))) return false;
+  if (subcommand === "log" && !["--no-patch", "--no-show-signature"].every(flag => beforePaths.includes(flag))) return false;
+  if (subcommand === "diff" && !["--name-only", "--name-status", "--stat", "--check"].some(flag => beforePaths.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) :
+  const literalPath = value => /^[A-Za-z0-9_./@~^:\\-]+$/.test(value);
+  return paths.every(literalPath) && beforePaths.every(value => value.startsWith("-") ? options[subcommand].test(value) :
     // Plain revisions/pathspecs only; shell syntax was already parsed separately.
-    /^[A-Za-z0-9_./@~^:\\-]+$/.test(value));
+    literalPath(value));
 }
 function isLiteralReadSequence(command) {
   const syntax = shellSyntax(command);
@@ -43,7 +48,7 @@ function isLiteralReadSequence(command) {
     const values = tokenizeLiteralCommand(part);
     if (!values?.length) return false;
     if (isLiteralGitRead(values)) return true;
-    if (/^Get-Item$/i.test(values[0])) {
+    if (/^(?:Get-Item|Test-Path)$/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) &&
@@ -87,5 +92,91 @@ function isLiteralReadSequence(command) {
 
 return isLiteralReadSequence;
 }
+
+export function withoutLiteralSearchPatterns(command, tokenizeLiteralCommand) {
+  const values = tokenizeLiteralCommand(command);
+  if (!values || !/^(?:rg(?:\.exe)?|Select-String)$/i.test(values[0])) return command;
+  const spans = [...command.matchAll(/"[^"\r\n]*"|'[^'\r\n]*'|[^\s"']+/g)];
+  // Ambiguous quoting/concatenation retains the conservative filesystem check.
+  if (spans.length !== values.length || spans.some((span, index) => {
+    const literal = tokenizeLiteralCommand(span[0]);
+    return literal?.length !== 1 || literal[0] !== values[index];
+  })) return command;
+  const patterns = new Set();
+  if (/^Select-String$/i.test(values[0])) {
+    for (let index = 1; index < values.length; index++) {
+      if (/^-(?:SimpleMatch|CaseSensitive|Quiet|List|AllMatches|NotMatch|Raw)$/i.test(values[index])) continue;
+      if (!/^-(?:Pattern|Path|LiteralPath|Context|Encoding)$/i.test(values[index]) || values[index + 1] === undefined) return command;
+      if (/^-Pattern$/i.test(values[index])) patterns.add(index + 1);
+      index++;
+    }
+  } else {
+    const positional = [];
+    let literal = false;
+    for (let index = 1; index < values.length; index++) {
+      const value = values[index];
+      if (literal) { positional.push(index); continue; }
+      if (value === "--") { literal = true; continue; }
+      if (/^(?:-e|--regexp)$/.test(value) && values[index + 1] !== undefined) { patterns.add(++index); continue; }
+      if (/^(?:-g|--glob|-t|--type|-T|--type-not|-m|--max-count|-A|-B|-C|--after-context|--before-context|--context)$/.test(value) && values[index + 1] !== undefined) { index++; continue; }
+      if (/^(?:-[niwFxqlso]+|--only-matching|--line-number|--ignore-case|--fixed-strings|--hidden|--no-heading|--files-with-matches|--count)$/.test(value)) continue;
+      if (value.startsWith("-")) return command;
+      positional.push(index);
+    }
+    if (patterns.size === 0 && positional.length > 0) patterns.add(positional[0]);
+  }
+  // Replace only the parsed pattern spans, never equal-looking path operands.
+  for (const index of [...patterns].sort((a, b) => b - a)) {
+    const span = spans[index];
+    command = command.slice(0, span.index) + "LITERAL_SEARCH_PATTERN" + command.slice(span.index + span[0].length);
+  }
+  return command;
+}
+
+/** Name discovery only. Null means unrelated; false means an unsafe listing attempt. */
+export function createDotenvFileDiscovery({ shellSyntax, tokenizeLiteralCommand, inside, resolve, dirname, lstat, realpath }) {
+return async function reviewedDotenvFileListing(command, cwd, root) {
+  if (/[\r\n]/.test(command)) return command.includes("--files") && command.includes(".env") ? false : null;
+  const values = tokenizeLiteralCommand(command);
+  if (!values) return /^\s*(?:&\s*)?rg(?:\.exe)?\s/.test(command) && command.includes("--files") && command.includes(".env") ? false : null;
+  if (!/^(?:rg|rg\.exe)$/.test(values[0]) || !values.includes("--files") || !values.some(value => value.includes(".env"))) return null;
+  const syntax = shellSyntax(command);
+  if (syntax.interpolation || syntax.redirection || syntax.grouping || /^\s*&/.test(command) || command.length > 4096 || values.length > 48) return false;
+  const flags = new Set(), globs = new Set();
+  const exclusions = new Set(["!**/node_modules/**", "!**/.git/**", "!**/dist/**", "!**/build/**", "!**/.cache/**", "!.local/**", "!.agents/private/**"]);
+  let positive = 0, target = null;
+  for (let index = 1; index < values.length; index++) {
+    const value = values[index];
+    if (["--files", "--no-config", "--hidden", "--no-ignore"].includes(value)) {
+      if (flags.has(value)) return false;
+      flags.add(value); continue;
+    }
+    if (value === "-g") {
+      const glob = values[++index];
+      if (!glob || globs.has(glob) || globs.size >= 16) return false;
+      if (/^\.env(?:\.[A-Za-z0-9_-]+)*$/.test(glob)) positive++;
+      else if (!exclusions.has(glob)) return false;
+      globs.add(glob); continue;
+    }
+    if (value.startsWith("-") || target !== null) return false;
+    target = value;
+  }
+  if (!flags.has("--no-config") || positive === 0) return false;
+  target ??= ".";
+  if (!target || !/^[A-Za-z0-9_. /\\-]+$/.test(target) || target.startsWith("/") || target.startsWith("\\") || target.split(/[\\/]/).includes("..") || (process.platform !== "win32" && target.includes("\\"))) return false;
+  const identity = value => process.platform === "win32" ? resolve(value).toLowerCase() : resolve(value);
+  if (!inside(cwd, root)) return false;
+  try {
+    // Explicit operands must be directories, with no aliases anywhere up to the repository root.
+    for (let cursor = resolve(cwd, target);; cursor = dirname(cursor)) {
+      if (!inside(cursor, root)) return false;
+      const info = await lstat(cursor);
+      if (!info.isDirectory() || info.isSymbolicLink() || identity(await realpath(cursor)) !== identity(cursor)) return false;
+      if (identity(cursor) === identity(root)) break;
+    }
+    return true;
+  } catch { return false; }
+};
+}
 `;
 //# sourceMappingURL=codex-literal-read-sequence-template.js.map

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoLpD,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const CODEX_NATIVE_AUTHORITY_POLICY: string;
+//# sourceMappingURL=codex-native-authority-policy-template.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex-native-authority-policy-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-native-authority-policy-template.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,QAkIzC,CAAC"}

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

@@ -0,0 +1,132 @@
+export const CODEX_NATIVE_AUTHORITY_POLICY = String.raw `import { createHash } from "node:crypto";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+export function checkDestructivePatterns(command, patterns, deny) {
+  if (/^(?:Write-Output|echo|printf)\s+'(?:[^']|'')*'\s*$/i.test(command)) return;
+  for (const entry of patterns) if (entry.pattern.test(command)) deny(entry.reason);
+}
+export async function configuredDeploymentBranches(repositoryRoot, deny) {
+  const defaults = { applicationBranches: ["beta"], scopeBranches: { frontend: "beta", backend: "beta" }, productionBranch: "main" };
+  let source;
+  try {
+    source = await readFile(resolve(repositoryRoot, ".agents/config/project.yaml"), "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return defaults;
+    deny("Could not read project.yaml deploy policy.");
+  }
+  let document;
+  try {
+    const parser = await import(
+      pathToFileURL(
+        resolve(repositoryRoot, ".agents/skills/zaip-skill-github-deploy/scripts/yaml-parser.mjs"),
+      ).href,
+    );
+    document = parser.parseDocument(source, { strict: true, uniqueKeys: true });
+  } catch {
+    deny("Canonical deploy YAML parser is unavailable.");
+  }
+  if (document.errors.length > 0) deny("project.yaml deploy policy is malformed.");
+  const config = document.toJS();
+  if (config === null || typeof config !== "object" || Array.isArray(config)) {
+    deny("project.yaml must contain a mapping.");
+  }
+  const deploy = config.deploy;
+  if (deploy === undefined) return defaults;
+  if (deploy === null || typeof deploy !== "object" || Array.isArray(deploy)) {
+    deny("project.yaml deploy must be a mapping.");
+  }
+  if (!Object.keys(deploy).every((key) => ["branch", "production_branch", "allow_production", "frontend", "backend", "database"].includes(key))) {
+    deny("project.yaml deploy has unsupported keys.");
+  }
+  for (const key of ["frontend", "backend", "database"]) {
+    if (deploy[key] !== undefined && (deploy[key] === null || typeof deploy[key] !== "object" || Array.isArray(deploy[key]) || !Object.keys(deploy[key]).every((nested) => nested === "branch"))) deny("project.yaml deploy scope is invalid.");
+  }
+  const productionBranch = Object.hasOwn(deploy, "production_branch")
+    ? deploy.production_branch
+    : defaults.productionBranch;
+  const frontend = deploy.frontend !== undefined && Object.hasOwn(deploy.frontend, "branch") ? deploy.frontend.branch : "beta";
+  const backend = deploy.backend !== undefined && Object.hasOwn(deploy.backend, "branch") ? deploy.backend.branch : "beta";
+  const database = deploy.database !== undefined && Object.hasOwn(deploy.database, "branch") ? deploy.database.branch : "beta";
+  if (database !== "beta") deny("project.yaml deploy.database.branch must be beta.");
+  if (
+    !isSafeBranchName(frontend) ||
+    !isSafeBranchName(backend) ||
+    !isSafeBranchName(productionBranch) ||
+    (frontend !== "main" && frontend === productionBranch) ||
+    (backend !== "main" && backend === productionBranch)
+  ) {
+    deny("project.yaml application deploy policy is invalid.");
+  }
+  return { applicationBranches: [...new Set([frontend, backend])], scopeBranches: { frontend, backend }, productionBranch };
+}
+function isSafeBranchName(branch) {
+  return typeof branch === "string" && branch.length <= 255 && /^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(branch) && !branch.includes("..") && !branch.includes("//") && !branch.includes("@{") && !branch.endsWith(".") && !branch.endsWith("/") && !branch.split("/").some((segment) => segment.startsWith(".") || segment.endsWith(".lock"));
+}
+export async function authenticatedSubagentTurn(child, binding, authorityRoot, boundedRead) {
+  const sha = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+  const directory = ".agents/private/state/codex-subagent-continuations/v1/" + sha(child.run_id);
+  let files;
+  try { files = await readdir(resolve(authorityRoot, directory)); }
+  catch (error) { if (error.code !== "ENOENT") throw error; files = []; }
+  if (!files.length) return binding.continuation_receipt === undefined ? child.client_turn_id : null;
+  if (files.length > 64 || files.some(file => !/^[a-f0-9]{64}\.json$/.test(file))) return null;
+  const receipts = [];
+  for (const file of files) {
+    const value = JSON.parse(await boundedRead(resolve(authorityRoot, directory, file), 8192, authorityRoot));
+    if (value.schema_version !== 1 || value.run_id !== child.run_id || value.parent_run_id !== child.parent_run_id ||
+        value.run_header_sha256 !== sha(child) || value.original_turn_id !== child.client_turn_id ||
+        value.native_session_id !== binding.native_session_id || ![value.native_session_id, value.agent_path].includes(child.client_thread_id) ||
+        value.agent_type !== child.agent_name || value.model !== child.model || value.reasoning_effort !== child.reasoning_effort ||
+        value.task_id !== child.task_id || value.change_id !== child.change_id || value.execution_id !== child.execution_id ||
+        value.spec_id !== child.spec_id || value.prd_id !== child.prd_id ||
+        !["interrupted", "completed"].includes(value.previous_native_status) || !/^[a-f0-9]{64}$/.test(value.native_context_sha256) ||
+        file !== sha([binding.native_session_id, value.turn_id]) + ".json") return null;
+    receipts.push(value);
+  }
+  let turn = child.client_turn_id, selected = null;
+  const seen = new Set();
+  while (true) {
+    const next = receipts.filter(value => value.previous_turn_id === turn);
+    if (next.length > 1) return null;
+    if (!next.length) break;
+    if (seen.has(next[0])) return null;
+    seen.add(next[0]); selected = next[0]; turn = selected.turn_id;
+  }
+  if (seen.size !== receipts.length || !selected || binding.continuation_receipt !== directory + "/" + sha([binding.native_session_id, turn]) + ".json") return null;
+  return turn;
+}
+const inside = (path, root) => { const scoped = relative(root, resolve(path)); return scoped === "" || (!scoped.startsWith("..") && !isAbsolute(scoped)); };
+/** Inspect existing ancestors too: a missing destination can still traverse a junction. */
+export async function isSafePatchPath(target, root) {
+  if (!inside(target, root)) return false;
+  for (let path = resolve(target);; path = dirname(path)) {
+    try {
+      const info = await lstat(path);
+      if (info.isSymbolicLink() || (info.isFile() && info.nlink !== 1)) return false;
+    } catch (error) { if (error.code !== "ENOENT") return false; }
+    if (path === resolve(root)) return true;
+    if (dirname(path) === path) return false;
+  }
+}
+/** Validate only this native child's patch scope and its still-active canonical ancestry. */
+export function nativePatchScopeMatches(scope, path) {
+  if (typeof path !== "string" || !path || isAbsolute(path) || /[\\:\x00]/.test(path) ||
+      path.split("/").some(part => !part || part === "." || part === "..")) return false;
+  if (typeof scope !== "string" || !scope || isAbsolute(scope) || /[\\:\x00]/.test(scope) ||
+      scope.split("/").some(part => !part || part === "." || part === "..") ||
+      scope.replace(/\/\*\*$/, "").includes("**")) return false;
+  const recursive = scope.endsWith("/**");
+  const base = recursive ? scope.slice(0, -3) : scope;
+  // Literal directory scopes retain their existing descendant semantics.
+  if (!scope.includes("*")) {
+    const literalScope = process.platform === "win32" ? scope.toLowerCase() : scope;
+    const literalPath = process.platform === "win32" ? path.toLowerCase() : path;
+    return literalPath === literalScope || literalPath.startsWith(literalScope + "/");
+  }
+  let pattern = "";
+  for (const char of base) pattern += char === "*" ? "[^/]*" : /[\^$+?.()|{}\[\]]/.test(char) ? "\\" + char : char;
+  return new RegExp("^" + pattern + (recursive ? "(?:/.*)?" : "") + "$", process.platform === "win32" ? "i" : "").test(path);
+}
+`;
+//# sourceMappingURL=codex-native-authority-policy-template.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex-native-authority-policy-template.js","sourceRoot":"","sources":["../../src/services/codex-native-authority-policy-template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkItD,CAAC"}

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,QAiRT,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,QAmR5C,CAAC"}