@codyswann/lisa 4.84.4 → 4.84.6

package/package.json

@@ -189,7 +189,7 @@
     "qs": "^6.16.0"
   },
   "name": "@codyswann/lisa",
-  "version": "4.84.4",
+  "version": "4.84.6",
   "description": "Claude Code governance framework that applies guardrails, guidance, and automated enforcement to projects",
   "main": "dist/index.js",
   "exports": {
@@ -347,7 +347,7 @@
     "test": "tests"
   },
   "types": "./dist/index.d.ts",
-  "lisaReleaseCommit": "62b34bba01794ec866cc2075a66284e06889d296",
-  "gitHead": "62b34bba01794ec866cc2075a66284e06889d296",
-  "lisaReleaseTag": "v4.84.4"
+  "lisaReleaseCommit": "26506db550db7f036466d2978c8a6448fa1f7f89",
+  "gitHead": "26506db550db7f036466d2978c8a6448fa1f7f89",
+  "lisaReleaseTag": "v4.84.6"
 }

package/plugins/lisa/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.84.4",
+  "version": "4.84.6",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.84.4",
+  "version": "4.84.6",
   "description": "Universal governance: agents, skills, commands, hooks, and rules for all projects.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/hooks/block-host-name-leak.mjs

@@ -53,6 +53,24 @@
  * tempted to add it to `plugins/materialized-artifacts.json` should have a
  * reason why a host project should be refused its own name.
  *
+ * WHERE IT APPLIES: THE TARGET, NOT THE CHECKOUT (#4462)
+ *
+ * Not materializing it was not enough. The guard is registered by the PLUGIN,
+ * so it runs in every project the plugin is enabled in, and every host has the
+ * denylist at `node_modules/@codyswann/lisa/dist/`. Inside a host it refused
+ * that host's own tracker writes — including the `Work-Item: <owner>/<repo>#<n>`
+ * line the work-item gate REQUIRES in every pull-request body, so the two Lisa
+ * guards contradicted each other and every agent-opened host PR failed
+ * traceability.
+ *
+ * So the guard resolves the active gh call's explicit repository or API
+ * endpoint, then GH_REPO, the locally selected gh default, or one unambiguous
+ * Git remote. Literal cd and environment assignments use the command's actual
+ * directory; the project root still locates the detector. Body text is never
+ * routing. Unsupported shell syntax, unresolved expansions and ambiguous
+ * repositories earn no host exemption. This is bounded command inspection,
+ * not shell execution or a claim to close every shell/identity leak class.
+ *
  * FAILING OPEN, LOUDLY
  *
  * When the denylist cannot be loaded this permits the write and says so on
@@ -65,6 +83,13 @@
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import {
+  commandRepository,
+  ghCommands,
+  repositoryFromSpec,
+} from "./host-name-command-context.mjs";
+
+export { repositoryFromSpec };
 
 /** Claude Code's refusal code. Every other non-zero exit is a hook error. */
 const EXIT_BLOCKED = 2;
@@ -110,10 +135,17 @@ const TEXT_FLAGS = new Set([
   "-m",
 ]);
 /** `gh api` field flags: `key=value`, or `key=@path` to read a file. */
-const FIELD_FLAGS = new Set(["-f", "--field", "--raw-field"]);
+const FIELD_FLAGS = new Set(["-f", "-F", "--field", "--raw-field"]);
 /** Field names whose value is published prose rather than metadata. */
 const PROSE_FIELDS = new Set(["body", "title", "text", "message"]);
 
+/**
+ * The repositories this guard protects, lowercased `owner/repo`.
+ *
+ * Only this one: it is public and ships `dist/` to npm. A host's own tracker
+ * is not on the list, which is the point (#4462).
+ */
+const GUARDED_REPOSITORIES = new Set(["codyswanngt/lisa"]);
 /**
  * Vendor endpoints quoted from guard source, which are not host identities.
  *
@@ -173,30 +205,10 @@ export function tokenize(command) {
  * @returns True when the command publishes text.
  */
 export function isOutboundTrackerWrite(tokens) {
-  const gh = tokens.indexOf("gh");
-  if (gh === -1) return false;
-  const rest = tokens.slice(gh + 1).filter(token => !token.startsWith("-"));
-  const [noun, verb] = rest;
-  if (noun === "api") return isMutatingApiCall(tokens);
-  return WRITE_NOUNS.has(noun ?? "") && WRITE_VERBS.has(verb ?? "");
-}
-
-/**
- * Whether a `gh api` call mutates.
- *
- * `gh api` defaults to GET, and to POST when any field flag is present — so a
- * field flag alone makes it a write even with no explicit method.
- * @param tokens - Command tokens.
- * @returns True when the call changes state.
- */
-function isMutatingApiCall(tokens) {
-  const method = tokens.findIndex(
-    token => token === "-X" || token === "--method"
-  );
-  if (method !== -1) {
-    return MUTATING_METHODS.has((tokens[method + 1] ?? "").toUpperCase());
-  }
-  return tokens.some(token => FIELD_FLAGS.has(token));
+  return ghCommands(
+    tokens.map(token => JSON.stringify(token)).join(" "),
+    process.cwd()
+  ).some(context => context.writes);
 }
 
 /**
@@ -212,6 +224,32 @@ function valueAt(tokens, index) {
   return tokens[index + 1] ?? "";
 }
 
+/**
+ * Resolve the target of one tokenized command without treating prose as routing.
+ * @param tokens Command tokens.
+ * @param cwd Actual command working directory.
+ * @returns Verified owner/repository, or unknown.
+ */
+export function targetRepository(tokens, cwd) {
+  const context = ghCommands(
+    tokens.map(token => JSON.stringify(token)).join(" "),
+    cwd
+  )[0];
+  return context === undefined ? undefined : commandRepository(context);
+}
+
+/**
+ * Whether the guard applies to a write landing in this repository.
+ *
+ * An undetermined target is guarded: not knowing where text is going is no
+ * reason to stop protecting the one place it must not go.
+ * @param target - `owner/repo`, or undefined.
+ * @returns True when the write must be checked.
+ */
+export function isGuardedTarget(target) {
+  return target === undefined || GUARDED_REPOSITORIES.has(target);
+}
+
 /**
  * Read a file the command names, if it is readable.
  * @param candidate - Path as written on the command line.
@@ -236,16 +274,22 @@ function readIfPresent(candidate, cwd) {
  * from so the refusal can point at the thing to edit.
  * @param tokens - Command tokens.
  * @param cwd - Directory the command runs in.
+ * @param noun - The active gh noun, so api fields retain their own meaning.
  * @returns Sources of publishable text.
  */
-export function publishableText(tokens, cwd) {
+export function publishableText(tokens, cwd, noun) {
   return tokens.flatMap((token, index) => {
     const bare = token.startsWith("-") ? token.split("=")[0] : token;
-    if (TEXT_FLAGS.has(bare)) {
+    if (noun !== "api" && TEXT_FLAGS.has(bare)) {
       return [{ origin: bare, text: valueAt(tokens, index) }];
     }
     if (FILE_FLAGS.has(bare)) {
-      const file = valueAt(tokens, index).replace(/^@/u, "");
+      const value = valueAt(tokens, index);
+      // On `gh api`, `-F` is `--field`: `key=@path` or `key=value`. Read as a
+      // bare path, `body=@file` named no file and published unchecked (#4462).
+      if (noun === "api" && /^[\w.[\]-]+=/u.test(value))
+        return [fieldSource(value, cwd)];
+      const file = value.replace(/^@/u, "");
       return [{ origin: file, text: readIfPresent(file, cwd) }];
     }
     if (FIELD_FLAGS.has(bare))
@@ -353,19 +397,53 @@ means "no known name appeared", not "this text is safe".`;
  * @returns The exit code and any message.
  */
 export async function evaluate(command, projectDir) {
-  const tokens = tokenize(command);
-  if (!isOutboundTrackerWrite(tokens)) return { code: EXIT_ALLOWED };
-  const detector = await loadDetector(projectDir);
-  if (detector === undefined) {
-    return {
-      code: EXIT_ALLOWED,
-      warning:
-        "block-host-name-leak: host-name denylist not found (no built dist/ or installed package); host-identity enforcement is NOT active",
-    };
+  let detector;
+  const findings = [];
+  for (const context of ghCommands(command, process.cwd())) {
+    if (!context.writes || !isGuardedTarget(commandRepository(context)))
+      continue;
+    detector ??= await loadDetector(projectDir);
+    if (detector === undefined) {
+      return {
+        code: EXIT_ALLOWED,
+        warning:
+          "block-host-name-leak: host-name denylist not found (no built dist/ or installed package); host-identity enforcement is NOT active",
+      };
+    }
+    // Without a known cwd a relative file cannot be inspected honestly. Keep
+    // protection, and name the unread input instead of claiming the text clean.
+    if (
+      context.cwd === undefined &&
+      [...context.flags].some(([flag, item]) => {
+        const field =
+          context.noun === "api" && FIELD_FLAGS.has(flag)
+            ? /^([^=]+)=@(.+)$/u.exec(item.value)
+            : null;
+        const file =
+          field !== null
+            ? PROSE_FIELDS.has(field[1])
+              ? field[2]
+              : undefined
+            : FILE_FLAGS.has(flag)
+              ? item.value.replace(/^@/, "")
+              : undefined;
+        return file !== undefined && !path.isAbsolute(file);
+      })
+    ) {
+      return {
+        code: EXIT_BLOCKED,
+        message:
+          "BLOCKED: the working directory for this tracker write's body file could not be resolved. Use a literal directory and readable body file so the host-name guard can inspect it.",
+      };
+    }
+    findings.push(
+      ...publishableText(
+        context.tokens,
+        context.cwd ?? projectDir,
+        context.noun
+      ).flatMap(source => findingsIn(source, detector))
+    );
   }
-  const findings = publishableText(tokens, projectDir).flatMap(source =>
-    findingsIn(source, detector)
-  );
   if (findings.length === 0) return { code: EXIT_ALLOWED };
   return { code: EXIT_BLOCKED, message: formatRefusal(findings) };
 }

package/plugins/lisa/hooks/block-host-name-leak.sh

@@ -56,6 +56,11 @@ if [ ! -r "$classifier" ]; then
   exit 0
 fi
 
+if [ ! -r "$hook_dir/host-name-command-context.mjs" ]; then
+  printf 'block-host-name-leak: command-context helper missing; host-identity enforcement is NOT active\n' >&2
+  exit 0
+fi
+
 status=0
 node "$classifier" "$command_str" "$project_dir" || status=$?
 exit "$status"

package/plugins/lisa/hooks/host-name-command-context.mjs

@@ -0,0 +1,397 @@
+/** Bounded literal command/target resolution for the host-name guard; never a shell. */
+import { execFileSync } from "node:child_process";
+import { statSync } from "node:fs";
+import path from "node:path";
+
+const VALUE_FLAGS = new Set([
+  "--repo",
+  "-R",
+  "--body",
+  "-b",
+  "--title",
+  "-t",
+  "--message",
+  "-m",
+  "--body-file",
+  "--input",
+  "-f",
+  "-F",
+  "--field",
+  "--raw-field",
+  "-X",
+  "--method",
+  "-H",
+  "--header",
+  "--hostname",
+  "-q",
+  "--jq",
+  "--template",
+  "-p",
+  "--preview",
+  "--base",
+  "--head",
+  "--assignee",
+  "--label",
+  "--milestone",
+  "--project",
+  "--reviewer",
+]);
+const FIELD_FLAGS = new Set(["-f", "-F", "--field", "--raw-field"]);
+const METHODS = new Set(["POST", "PATCH", "PUT"]);
+const SHORT_VALUES = /^(-[RbBtTmMfFXHqp])(.+)$/u;
+
+/**
+ * Read literal words and command separators, retaining expansion uncertainty.
+ * @param {string} command Raw Bash command.
+ * @returns {object[]} Literal words and separators.
+ */
+function words(command) {
+  const result = [];
+  let value = "",
+    quote = "",
+    literal = true,
+    started = false;
+  const flush = () => {
+    if (started) result.push({ value, literal });
+    value = "";
+    literal = true;
+    started = false;
+  };
+  for (let i = 0; i < command.length; i += 1) {
+    const char = command[i];
+    if (char === "\\" && quote !== "'") {
+      const next = command[++i];
+      if (next === undefined) literal = false;
+      else if (next !== "\n") {
+        if (quote === '"' && !/[$`"\\]/u.test(next)) value += "\\";
+        value += next;
+      }
+      if (next !== "\n") started = true;
+    } else if (quote !== "") {
+      if (char === quote) quote = "";
+      else {
+        value += char;
+        if (quote === '"' && /[$`]/u.test(char)) literal = false;
+      }
+      started = true;
+    } else if (char === '"' || char === "'") {
+      quote = char;
+      started = true;
+    } else if (/[;&|\n()<>]/u.test(char)) {
+      flush();
+      const operator =
+        char === command[i + 1] && /[&|]/u.test(char)
+          ? char + command[++i]
+          : char;
+      result.push({ operator });
+    } else if (/\s/u.test(char)) flush();
+    else {
+      value += char;
+      started = true;
+      if (/[$`*?[\]~]/u.test(char)) literal = false;
+    }
+  }
+  if (quote !== "") literal = false;
+  flush();
+  return result;
+}
+
+/**
+ * Split option values without treating body text as a second option/endpoint.
+ * @param {object[]} input Active gh arguments only.
+ * @returns {object} Parsed flags, positional words and normalized tokens.
+ */
+function argumentsOf(input) {
+  const flags = new Map(),
+    positional = [],
+    tokens = [];
+  // Any expansion can add/replace routing arguments after shell word splitting.
+  // Never evaluate it or certify a target from the remaining literal words.
+  let certain = input.every(word => word.literal);
+  for (let i = 0; i < input.length; i += 1) {
+    const word = input[i];
+    if (word.value === "--") {
+      positional.push(...input.slice(i + 1));
+      tokens.push(...input.slice(i).map(item => item.value));
+      break;
+    }
+    const equals = word.value.indexOf("=");
+    const directFlag = equals > 0 ? word.value.slice(0, equals) : word.value;
+    const attached = VALUE_FLAGS.has(directFlag)
+      ? null
+      : SHORT_VALUES.exec(word.value);
+    const flag =
+      attached?.[1] ??
+      (equals > 0 && word.value.startsWith("-") ? directFlag : word.value);
+    tokens.push(flag);
+    if (VALUE_FLAGS.has(flag)) {
+      const value = attached
+        ? { ...word, value: attached[2] }
+        : equals > 0
+          ? { ...word, value: word.value.slice(equals + 1) }
+          : input[++i];
+      if (value === undefined) {
+        certain = false;
+        continue;
+      }
+      // Alias spellings share one Cobra option; the last occurrence wins.
+      flags.set(
+        flag === "-R" ? "--repo" : flag === "-X" ? "--method" : flag,
+        value
+      );
+      tokens.push(value.value);
+    } else if (!word.value.startsWith("-")) positional.push(word);
+    else if (!word.literal) certain = false;
+  }
+  const noun = positional[0]?.value,
+    verb = positional[1]?.value;
+  const method = flags.get("--method");
+  const writes =
+    noun === "api"
+      ? method
+        ? !method.literal || METHODS.has(method.value.toUpperCase())
+        : [...FIELD_FLAGS].some(flag => flags.has(flag)) ||
+          Boolean(flags.get("--input")?.value)
+      : ["issue", "pr"].includes(noun) &&
+        ["create", "comment", "edit"].includes(verb);
+  return {
+    flags,
+    positional,
+    tokens: ["gh", ...tokens],
+    noun,
+    writes,
+    certain,
+  };
+}
+
+/**
+ * Normalize only repository shapes gh/git actually accept; unresolved syntax is unknown.
+ * @param {string} spec Repository argument, URL or Git remote.
+ * @returns {string|undefined} Lowercased owner/repository, or unknown.
+ */
+export function repositoryFromSpec(spec) {
+  if (typeof spec !== "string" || /[\s${}`*?#[\]]/u.test(spec))
+    return undefined;
+  const normalized = spec
+    .trim()
+    .replace(/\.git\/?$/u, "")
+    .replace(/\/$/u, "");
+  const matched =
+    /^(?:(?:https?:\/\/|ssh:\/\/git@)[^/]+\/|git@[^:]+:|[^/:]+\/)?([\w.-]+)\/([\w.-]+)$/u.exec(
+      normalized
+    );
+  return matched ? `${matched[1]}/${matched[2]}`.toLowerCase() : undefined;
+}
+
+/**
+ * Resolve literal cd and leading environment assignments across simple command lists.
+ * Pipelines, conditionals and other shell syntax never earn a target exemption.
+ * @param {string} command Raw Bash command.
+ * @param {string} initialCwd The actual hook process cwd, separate from detector root.
+ * @param {object} env The actual inherited environment.
+ * @returns {object[]} Active gh calls with their bounded command contexts.
+ */
+export function ghCommands(command, initialCwd, env = process.env) {
+  const calls = [];
+  const inherited = { ...env };
+  let cwd = initialCwd,
+    segment = [],
+    uncertain = false;
+  const consume = () => {
+    if (segment.length === 0) return;
+    const local = { ...inherited };
+    let index = segment[0].value === "env" ? 1 : 0;
+    while (/^[A-Za-z_][A-Za-z_0-9]*=/u.test(segment[index]?.value ?? "")) {
+      const item = segment[index++],
+        split = item.value.indexOf("=");
+      local[item.value.slice(0, split)] = item.literal
+        ? item.value.slice(split + 1)
+        : undefined;
+      if (!item.literal) uncertain = true;
+    }
+    const executable = segment[index]?.value;
+    if (executable === "cd") {
+      const args = segment.slice(index + 1).filter(item => item.value !== "--");
+      const directory =
+        args.length === 1 && args[0].literal && !args[0].value.startsWith("-")
+          ? args[0].value
+          : undefined;
+      try {
+        const resolved =
+          directory === undefined ||
+          (!path.isAbsolute(directory) &&
+            !/^\.\.?(?:\/|$)/u.test(directory) &&
+            (uncertain || local.CDPATH))
+            ? undefined
+            : path.isAbsolute(directory)
+              ? directory
+              : cwd === undefined
+                ? undefined
+                : path.resolve(cwd, directory);
+        cwd =
+          resolved !== undefined && statSync(resolved).isDirectory()
+            ? resolved
+            : undefined;
+      } catch {
+        cwd = undefined;
+      }
+    } else if (executable === "export") {
+      for (const item of segment.slice(index + 1)) {
+        const split = item.value.indexOf("=");
+        if (split < 1 || !item.literal) {
+          uncertain = true;
+          continue;
+        }
+        inherited[item.value.slice(0, split)] = item.value.slice(split + 1);
+      }
+    } else if (executable !== undefined && path.basename(executable) === "gh") {
+      calls.push({
+        ...argumentsOf(segment.slice(index + 1)),
+        cwd,
+        env: local,
+        certainContext: !uncertain,
+      });
+    } else {
+      // A function/source/pushd or unsupported launcher may change the shell
+      // context. Do not grant later writes an exemption based on the old cwd.
+      uncertain = true;
+      cwd = undefined;
+      const nested = segment.findIndex(item => item.value === "gh");
+      if (nested !== -1)
+        calls.push({
+          ...argumentsOf(segment.slice(nested + 1)),
+          cwd,
+          env: local,
+          certainContext: false,
+        });
+    }
+    segment = [];
+  };
+  for (const word of words(command)) {
+    if (word.operator === undefined) segment.push(word);
+    else {
+      consume();
+      if (!["&&", ";", "\n"].includes(word.operator)) {
+        uncertain = true;
+        cwd = undefined;
+      }
+    }
+  }
+  consume();
+  return calls;
+}
+
+/**
+ * Read gh's local selected default, falling back only to one unambiguous remote.
+ * All reads share a five-second ceiling and execute no shell or network query.
+ * @param {object} context One gh command context.
+ * @returns {string|undefined} Verified repository, or unknown.
+ */
+function localRepository(context) {
+  if (!context.certainContext) return undefined;
+  if (context.env.GH_REPO) return repositoryFromSpec(context.env.GH_REPO);
+  if (context.cwd === undefined) return undefined;
+  const deadline = Date.now() + 5000;
+  const read = (command, args) => {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) throw new Error("Repository lookup deadline expired");
+    return execFileSync(command, args, {
+      cwd: context.cwd,
+      env: { ...context.env, GH_PROMPT_DISABLED: "1" },
+      timeout: remaining,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  };
+  try {
+    const selected = read("gh", ["repo", "set-default", "--view"]);
+    if (selected !== "") return repositoryFromSpec(selected);
+    const remotes = read("git", ["remote"]).split("\n").filter(Boolean);
+    if (remotes.length !== 1) return undefined;
+    return repositoryFromSpec(read("git", ["remote", "get-url", remotes[0]]));
+  } catch {
+    // probe-direction: fail-closed — failed lookup grants no host exemption;
+    // the caller retains its inspection path for an undetermined target.
+    return undefined;
+  }
+}
+
+/**
+ * Resolve only active command arguments; prose cannot masquerade as routing.
+ * @param {object} context One parsed gh call.
+ * @returns {string|undefined} Verified owner/repository, or unknown.
+ */
+export function commandRepository(context) {
+  if (!context.certain || !context.certainContext) return undefined;
+  if (context.noun !== "api") {
+    // gh 2.88.1 issue comment/edit and PR finder resolve a URL selector before
+    // BaseRepo (--repo/GH_REPO/local default). Body option values are not here.
+    const selectors = context.positional.slice(2);
+    const batch =
+      context.noun === "issue" && context.positional[1]?.value === "edit";
+    if (
+      (batch && selectors.length > 1) ||
+      (["comment", "edit"].includes(context.positional[1]?.value) &&
+        selectors.some(item => /^https?:\/\//u.test(item.value)))
+    ) {
+      if (!batch && selectors.length !== 1) return undefined;
+      let repository, identity;
+      for (const item of selectors) {
+        // ParseIssuesFromArgs lets numeric selectors inherit the common URL repo.
+        if (batch && /^#?[+-]?\d+$/u.test(item.value)) {
+          const number = BigInt(item.value.replace(/^#/u, ""));
+          if (BigInt.asIntN(64, number) !== number) return undefined;
+          continue;
+        }
+        const selected =
+          /^https?:\/\/[^/]+\/([\w.-]+)\/([\w.-]+)\/(issues|pull)\/\d+(?:[/?#].*)?$/u.exec(
+            item.value
+          );
+        if (!selected || (context.noun === "pr" && selected[3] !== "pull"))
+          return undefined;
+        try {
+          const host = new URL(item.value).hostname
+            .replace(/^www\./u, "")
+            .toLowerCase();
+          const repo = batch
+            ? `${selected[1]}/${selected[2]}`.toLowerCase()
+            : repositoryFromSpec(`${selected[1]}/${selected[2]}`);
+          const current = `${host}/${repo}`;
+          if (
+            !host ||
+            !repo ||
+            (identity !== undefined && identity !== current)
+          )
+            return undefined;
+          identity = current;
+          repository = repo;
+        } catch {
+          // probe-direction: fail-closed — invalid URL grants no host exemption;
+          // the caller retains its inspection path for an undetermined target.
+          return undefined;
+        }
+      }
+      if (repository !== undefined) return repository;
+    }
+    const explicit = context.flags.get("--repo") ?? context.flags.get("-R");
+    return explicit
+      ? explicit.literal
+        ? repositoryFromSpec(explicit.value)
+        : undefined
+      : localRepository(context);
+  }
+  const endpoint = context.positional[1];
+  if (!endpoint?.literal) return undefined;
+  let value = endpoint.value;
+  if (/\{(?:owner|repo)\}/u.test(value)) {
+    const repository = localRepository(context);
+    if (repository === undefined) return undefined;
+    const [owner, repo] = repository.split("/");
+    value = value.replaceAll("{owner}", owner).replaceAll("{repo}", repo);
+  }
+  const found =
+    /^(?:https?:\/\/[^/]+\/)?\/?repos\/([\w.-]+)\/([\w.-]+)(?:\/|$)/u.exec(
+      value
+    );
+  return found ? repositoryFromSpec(`${found[1]}/${found[2]}`) : undefined;
+}