@sjawhar/pi-legion-envoy 5.17.1 → 5.17.3

package/dist/legion.js

@@ -33473,7 +33473,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "5.17.1",
+  version: "5.17.3",
   type: "module",
   omp: {
     extensions: [
@@ -41507,6 +41507,51 @@ var FILE_COMMANDS = new Set([
   "chgrp"
 ]);
 var SIGNAL_COMMANDS = new Set(["kill", "pkill", "killall", "killall5"]);
+var FIND_VALUED_PREDICATES = new Set([
+  "-amin",
+  "-anewer",
+  "-atime",
+  "-cmin",
+  "-cnewer",
+  "-ctime",
+  "-fls",
+  "-fprint",
+  "-fprint0",
+  "-fprintf",
+  "-fstype",
+  "-gid",
+  "-group",
+  "-ilname",
+  "-iname",
+  "-inum",
+  "-ipath",
+  "-iregex",
+  "-iwholename",
+  "-links",
+  "-lname",
+  "-maxdepth",
+  "-mindepth",
+  "-mmin",
+  "-mtime",
+  "-name",
+  "-newer",
+  "-newerat",
+  "-newerct",
+  "-newermt",
+  "-path",
+  "-perm",
+  "-printf",
+  "-regex",
+  "-regextype",
+  "-samefile",
+  "-size",
+  "-type",
+  "-uid",
+  "-used",
+  "-user",
+  "-wholename",
+  "-xtype"
+]);
 var FUNCTION_OUTPUT_SILENT = {
   ":": true,
   break: true,
@@ -42166,6 +42211,43 @@ function literalText(exp) {
     return;
   return exp.map((piece) => piece.text).join("");
 }
+function readableWord(arg) {
+  const whole = literalText(arg.exp);
+  if (whole !== undefined)
+    return { text: whole, whole: true };
+  let text = "";
+  for (const piece of arg.exp) {
+    if (piece.kind !== "literal")
+      break;
+    text += piece.text;
+  }
+  return { text, whole: false };
+}
+function mayBeOption(arg, matches) {
+  const { text, whole } = readableWord(arg);
+  if (whole)
+    return matches(text);
+  return text === "" || /^--?[a-zA-Z-]*$/.test(text);
+}
+function valueInWord(arg, count) {
+  const pieces = [];
+  let dropped = 0;
+  for (const piece of arg.exp) {
+    if (dropped >= count) {
+      pieces.push(piece);
+      continue;
+    }
+    if (piece.kind !== "literal")
+      return;
+    if (piece.text.length + dropped <= count) {
+      dropped += piece.text.length;
+      continue;
+    }
+    pieces.push({ ...piece, text: piece.text.slice(count - dropped) });
+    dropped = count;
+  }
+  return dropped < count || pieces.length === 0 ? undefined : pieces;
+}
 function visitParts(parts, st, ctx) {
   for (const part of parts ?? []) {
     switch (part.type) {
@@ -42174,9 +42256,11 @@ function visitParts(parts, st, ctx) {
         visitParts(part.parts, st, ctx);
         break;
       case "CommandExpansion":
-      case "ProcessSubstitution":
         walkSubstitution(part.script, part.inner, part.text, st, ctx);
         break;
+      case "ProcessSubstitution":
+        uncertainly(ctx, () => walkSubstitution(part.script, part.inner, part.text, st, ctx));
+        break;
       case "ArithmeticExpansion":
         visitArithmetic(part.expression, st, ctx);
         break;
@@ -42396,10 +42480,47 @@ function merge2(target, branches) {
       if (target.traps.includes(trap))
         continue;
       merged ??= new Map(target.vars);
-      lifted.push({ ...trap, vars: handlerVars(trap, branch.vars), merged });
+      lifted.push({ ...trap, vars: handlerVars(trap, branch.vars), merged, uncertainSet: true });
     }
   }
-  target.traps = [...target.traps, ...lifted];
+  target.traps = [
+    ...target.traps.map((trap) => branches.every((branch) => branch.traps.includes(trap)) ? trap : { ...trap, uncertainSet: true }),
+    ...lifted
+  ];
+}
+function uncertainly(ctx, walk) {
+  ctx.uncertain.depth += 1;
+  try {
+    walk();
+  } finally {
+    ctx.uncertain.depth -= 1;
+  }
+}
+function modelWrite(st, ctx, file2, content) {
+  st.files.set(file2, ctx.uncertain.depth > 0 ? UNCERTAIN_WRITE : content);
+}
+var UNCERTAIN_WRITE = {
+  why: "the write is inside a branch, a loop body, a handler, or a command this shell does not wait " + "for, so the guard cannot know the shell performed it"
+};
+var UNRENDERED_WRITE = {
+  why: "the command writes output the guard cannot render"
+};
+var OVERLONG_WRITE = {
+  why: `the command writes more than the ${MAX_SCRIPT_BYTES} bytes the guard reads of a script`
+};
+var UNREAD_FILE = {
+  why: "the command appends to a file it has not written, whose contents on disk the guard never reads"
+};
+function modelPidFile(st, ctx, file2, pid) {
+  const model = st.pidFiles;
+  const before = model.get(file2);
+  model.delete(file2);
+  if (ctx.uncertain.depth === 0) {
+    if (pid !== undefined)
+      model.set(file2, pid);
+  } else if (pid !== undefined && before !== undefined) {
+    model.set(file2, [unknown2("a pid a branch or loop body wrote to this file", true)]);
+  }
 }
 function handlerVars(trap, vars) {
   const { vars: branch, merged } = trap;
@@ -42444,11 +42565,17 @@ function subshell(st, patch) {
 function runSetTraps(st, ctx) {
   for (const trap of st.traps) {
     const vars = new Map([...handlerVars(trap, st.vars), ...trap.pids ?? []]);
-    try {
-      runText(trap.text, "the EXIT trap", subshell(st, { source: trap.file, vars }), ctx, trap.site);
-    } catch (error48) {
-      locateRefusal(error48, trap.file);
-    }
+    const run = () => {
+      try {
+        runText(trap.text, "the EXIT trap", subshell(st, { source: trap.file, vars }), ctx, trap.site);
+      } catch (error48) {
+        locateRefusal(error48, trap.file);
+      }
+    };
+    if (trap.signals.includes("EXIT") && trap.uncertainSet !== true)
+      run();
+    else
+      uncertainly(ctx, run);
   }
 }
 function walkList(statements, st, ctx) {
@@ -42459,8 +42586,10 @@ var MAX_DECIDED_PASSES = 64;
 function walkLoopAnyPasses(node, st, ctx) {
   const before = st.output;
   const body = clone2(st);
-  walkList(node.clause.commands, body, ctx);
-  walkList(node.body.commands, body, ctx);
+  uncertainly(ctx, () => {
+    walkList(node.clause.commands, body, ctx);
+    walkList(node.body.commands, body, ctx);
+  });
   merge2(st, [clone2(st), body]);
   if (outputChanged(before, body.output))
     st.output = undefined;
@@ -42564,8 +42693,10 @@ function walkNode(node, st, ctx, pipeIn) {
       if (node.background) {
         const before = st.output;
         const child = subshell(st);
-        walkNode(node.command, child, ctx, pipeIn);
-        runSetTraps(child, ctx);
+        uncertainly(ctx, () => {
+          walkNode(node.command, child, ctx, pipeIn);
+          runSetTraps(child, ctx);
+        });
         if (outputChanged(before, child.output))
           st.output = undefined;
         st.backgroundStarted = true;
@@ -42574,7 +42705,7 @@ function walkNode(node, st, ctx, pipeIn) {
       if (node.command.type === "BraceGroup") {
         const written = groupOutputFile(node, st, ctx);
         if (written !== undefined) {
-          st.files.set(written, walkRenderingGroup(node.command, st, ctx));
+          modelWrite(st, ctx, written, walkRenderingGroup(node.command, st, ctx) ?? UNRENDERED_WRITE);
           return;
         }
       }
@@ -42592,20 +42723,38 @@ function walkNode(node, st, ctx, pipeIn) {
       }
       const before = st.output;
       const parts = [];
-      for (const [index, command] of node.commands.entries()) {
-        const part = subshell(st);
-        walkNode(command, part, ctx, index > 0);
-        runSetTraps(part, ctx);
-        parts.push(part);
-      }
+      uncertainly(ctx, () => {
+        for (const [index, command] of node.commands.entries()) {
+          const part = subshell(st);
+          walkNode(command, part, ctx, index > 0);
+          runSetTraps(part, ctx);
+          parts.push(part);
+        }
+      });
       if (parts.some((part) => outputChanged(before, part.output)))
         st.output = undefined;
       return;
     }
-    case "AndOr":
-      for (const command of node.commands)
-        walkNode(command, st, ctx, pipeIn);
+    case "AndOr": {
+      const [first, ...rest] = node.commands;
+      if (first !== undefined)
+        walkNode(first, st, ctx, pipeIn);
+      if (rest.length === 0)
+        return;
+      const before = st.output;
+      const branches = [clone2(st)];
+      const running = clone2(st);
+      uncertainly(ctx, () => {
+        for (const command of rest) {
+          walkNode(command, running, ctx, pipeIn);
+          branches.push(clone2(running));
+        }
+      });
+      merge2(st, branches);
+      if (branches.some((branch) => outputChanged(before, branch.output)))
+        st.output = undefined;
       return;
+    }
     case "CompoundList":
       walkList(node.commands, st, ctx);
       return;
@@ -42626,10 +42775,12 @@ function walkNode(node, st, ctx, pipeIn) {
       walkList(node.clause.commands, st, ctx);
       const clauseOutput = st.output;
       const then = clone2(st);
-      walkList(node.then.commands, then, ctx);
       const otherwise = clone2(st);
-      if (node.else !== undefined)
-        walkNode(node.else, otherwise, ctx, pipeIn);
+      uncertainly(ctx, () => {
+        walkList(node.then.commands, then, ctx);
+        if (node.else !== undefined)
+          walkNode(node.else, otherwise, ctx, pipeIn);
+      });
       merge2(st, [then, otherwise]);
       if (outputChanged(before, clauseOutput) || outputChanged(clauseOutput, then.output) || outputChanged(clauseOutput, otherwise.output)) {
         st.output = undefined;
@@ -42649,7 +42800,7 @@ function walkNode(node, st, ctx, pipeIn) {
         for (const value of known) {
           const body = clone2(st);
           assignScalar(body, name, [literal2(value)]);
-          walkList(node.body.commands, body, ctx);
+          uncertainly(ctx, () => walkList(node.body.commands, body, ctx));
           branches.push(body);
         }
       } else {
@@ -42661,7 +42812,7 @@ function walkNode(node, st, ctx, pipeIn) {
         assignScalar(body, name, signalSafe ? [unknown2(`\`$${name}\`, a loop variable`, true)] : [unknown2(`\`$${name}\`, a loop variable`)]);
         if (node.type === "Select")
           assignScalar(body, "REPLY", [unknown2("`$REPLY`, read from input")]);
-        walkList(node.body.commands, body, ctx);
+        uncertainly(ctx, () => walkList(node.body.commands, body, ctx));
         branches.push(body);
       }
       merge2(st, branches);
@@ -42675,7 +42826,7 @@ function walkNode(node, st, ctx, pipeIn) {
       visitArithmetic(node.test, st, ctx);
       visitArithmetic(node.update, st, ctx);
       const body = clone2(st);
-      walkList(node.body.commands, body, ctx);
+      uncertainly(ctx, () => walkList(node.body.commands, body, ctx));
       merge2(st, [clone2(st), body]);
       if (outputChanged(before, body.output))
         st.output = undefined;
@@ -42702,7 +42853,7 @@ function walkNode(node, st, ctx, pipeIn) {
         for (const word of item.pattern)
           visitWord(word, st, ctx);
         const body = clone2(st);
-        walkList(item.body.commands, body, ctx);
+        uncertainly(ctx, () => walkList(item.body.commands, body, ctx));
         branches.push(body);
       }
       merge2(st, branches);
@@ -42723,8 +42874,10 @@ function walkNode(node, st, ctx, pipeIn) {
     case "Coproc": {
       const before = st.output;
       const child = subshell(st);
-      walkNode(node.body, child, ctx, false);
-      runSetTraps(child, ctx);
+      uncertainly(ctx, () => {
+        walkNode(node.body, child, ctx, false);
+        runSetTraps(child, ctx);
+      });
       if (outputChanged(before, child.output))
         st.output = undefined;
       checkRedirects(node.redirects, undefined, siteOf(node, st), st, ctx);
@@ -42773,12 +42926,10 @@ function checkRedirects(redirects, command, site, st, ctx) {
       } else if (command?.name === "printf") {
         content = printfText(command.args, MAX_SCRIPT_BYTES, true) ?? null;
       }
-      st.pidFiles.delete(file2);
-      const before = appends ? st.files.get(file2) ?? null : "";
-      st.files.set(file2, content === null || before === null ? null : readable(`${before}${content}`));
-      if (writes && !appends && command?.name === "echo" && command.args.length === 1 && command.args[0]?.exp.length > 0 && command.args[0]?.exp.every((piece) => piece.descendantPid)) {
-        st.pidFiles.set(file2, command.args[0].exp);
-      }
+      const before = appends ? st.files.get(file2) ?? UNREAD_FILE : "";
+      modelWrite(st, ctx, file2, content === null ? UNRENDERED_WRITE : typeof before !== "string" ? before : readable(`${before}${content}`) ?? OVERLONG_WRITE);
+      const pidWritten = writes && !appends && command?.name === "echo" && command.args.length === 1 && command.args[0]?.exp.length > 0 && command.args[0].exp.every((piece) => piece.descendantPid);
+      modelPidFile(st, ctx, file2, pidWritten ? command?.args[0]?.exp : undefined);
     }
   }
 }
@@ -43018,6 +43169,7 @@ function operands(list, valued, longValued = []) {
   return { options, operands: found };
 }
 function unwrap2(argv, st, ctx, site) {
+  const alts = [];
   let list = argv;
   let state = st;
   for (let guard = 0;guard < 16; guard += 1) {
@@ -43026,13 +43178,19 @@ function unwrap2(argv, st, ctx, site) {
       break;
     const base = path4.basename(name);
     const rest = list.slice(1);
-    const skip = (valued, longValued = []) => {
+    const skip = (valued, longValued = [], positional = false) => {
       let i = 0;
       for (;i < rest.length; i += 1) {
-        const text = literalText(rest[i]?.exp);
+        const arg = rest[i];
+        const text = literalText(arg.exp);
         if (text === "--")
           return rest.slice(i + 1);
-        if (text === undefined || !text.startsWith("-") || text === "-")
+        if (text === undefined) {
+          if (positional || !mayBeOption(arg, (option) => option.startsWith("-")))
+            break;
+          continue;
+        }
+        if (!text.startsWith("-") || text === "-")
           break;
         if (text.startsWith("--")) {
           if (!text.includes("=") && longValued.includes(text))
@@ -43046,8 +43204,10 @@ function unwrap2(argv, st, ctx, site) {
       }
       return rest.slice(i);
     };
-    if ((base === "busybox" || base === "toybox") && rest[0] !== undefined)
+    if ((base === "busybox" || base === "toybox") && rest[0] !== undefined && literalText(rest[0].exp) !== undefined) {
       list = rest;
+      continue;
+    }
     if (base === "sudo" || base === "doas")
       list = skip("ughpCDrtUT", ["--user", "--group"]);
     else if (base === "nice")
@@ -43059,15 +43219,23 @@ function unwrap2(argv, st, ctx, site) {
     else if (base === "command") {
       const flags = rest.map((arg) => literalText(arg.exp));
       if (flags[0] === "-v" || flags[0] === "-V")
-        return { argv: [], st: state };
+        return { argv: [], st: state, alts };
       list = skip("");
     } else if (base === "stdbuf")
       list = skip("ioe", ["--input", "--output", "--error"]);
     else if (base === "ionice")
       list = skip("cnt", ["--class", "--classdata"]);
     else if (base === "timeout") {
-      const after = skip("sk", ["--signal", "--kill-after"]);
-      list = after.slice(1);
+      const stopped = skip("sk", ["--signal", "--kill-after"], true);
+      list = stopped.slice(1);
+      for (let at = rest.length - stopped.length;at < rest.length; at += 1) {
+        if (literalText(rest[at]?.exp) !== undefined)
+          break;
+        alts.push(rest.slice(at + 1));
+      }
+      const read = skip("sk", ["--signal", "--kill-after"]);
+      if (read.length !== stopped.length)
+        alts.push(read.slice(1));
     } else if (base === "env") {
       let i = 0;
       const overlay = new Map;
@@ -43107,7 +43275,7 @@ function unwrap2(argv, st, ctx, site) {
           overlay.set(arg.exp[0].text.slice(0, arg.exp[0].text.indexOf("=")), [
             unknown2("an `env` assignment")
           ]);
-        } else
+        } else if (text === undefined && mayBeOption(arg, (option) => option.startsWith("-"))) {} else
           break;
       }
       if (i !== -1)
@@ -43124,7 +43292,7 @@ function unwrap2(argv, st, ctx, site) {
     } else
       break;
   }
-  return { argv: list, st: state };
+  return { argv: list, st: state, alts };
 }
 function runFunction(name, definition, args2, outer, ctx) {
   if (outer.runningFunctions.has(name))
@@ -43209,6 +43377,9 @@ function dispatch(invocation, outer, ctx) {
   const unwrapped = unwrap2(invocation.args, outer, ctx, invocation.site);
   const argv = unwrapped.argv;
   const st = unwrapped.st;
+  for (const other of unwrapped.alts) {
+    dispatch({ ...invocation, args: other }, clone2(outer), ctx);
+  }
   const name = literalText(argv[0]?.exp);
   if (name === undefined)
     return;
@@ -43222,15 +43393,18 @@ function dispatch(invocation, outer, ctx) {
       runFunction(base, only, rest, outer, ctx);
       return;
     }
-    const runs = callee.map((definition) => {
-      const run = clone2(outer);
-      if (definition !== undefined)
-        runFunction(base, definition, rest, run, ctx);
-      else {
-        run.functions.delete(base);
-        dispatch(invocation, run, ctx);
+    const runs = [];
+    uncertainly(ctx, () => {
+      for (const definition of callee) {
+        const run = clone2(outer);
+        if (definition !== undefined)
+          runFunction(base, definition, rest, run, ctx);
+        else {
+          run.functions.delete(base);
+          dispatch(invocation, run, ctx);
+        }
+        runs.push(run);
       }
-      return run;
     });
     merge2(outer, runs);
     return;
@@ -43353,15 +43527,21 @@ function dispatch(invocation, outer, ctx) {
       const leading = head[0];
       const spaced = literalText(head) === "-v";
       const joined = !spaced && leading?.kind === "literal" && leading.text.startsWith("-v") && (leading.text.length > 2 || head.length > 1);
-      if (spaced || joined) {
-        const variable = spaced ? literalText(rest[1]?.exp) : literalText([
+      const first = rest[0];
+      const mayBeV = !spaced && !joined && first !== undefined && rest[1] !== undefined && mayBeOption(first, (text) => text.startsWith("-v"));
+      if (spaced || joined || mayBeV) {
+        const variable = spaced || mayBeV ? literalText(rest[1]?.exp) : literalText([
           { ...leading, text: leading?.text.slice(2) ?? "" },
           ...head.slice(1)
         ]);
-        const printed = rest.slice(spaced ? 2 : 1);
+        const printed = rest.slice(spaced || mayBeV ? 2 : 1);
         const [format, value, ...others] = printed;
         let assigned;
-        if (literalText(format?.exp) === "%s" && value !== undefined && others.length === 0) {
+        if (mayBeV) {
+          assigned = [
+            unknown2(`\`$${variable ?? "?"}\` (printf with an option word the guard cannot read, which may be \`-v\`)`)
+          ];
+        } else if (literalText(format?.exp) === "%s" && value !== undefined && others.length === 0) {
           assigned = value.exp;
         } else {
           const text = printfText(printed, MAX_VALUE_LENGTH);
@@ -43410,11 +43590,24 @@ function dispatch(invocation, outer, ctx) {
           pids.set(name2, [piece]);
           return `\${${name2}}`;
         }).join("");
-        outer.traps = [...outer.traps, { text: handlerText, site, signals: handled, file: file2, pids }];
+        outer.traps = [
+          ...outer.traps,
+          {
+            text: handlerText,
+            site,
+            signals: handled,
+            file: file2,
+            pids,
+            uncertainSet: ctx.uncertain.depth > 0
+          }
+        ];
       } else if (text === undefined) {
         throw new Refusal(site.snippet, site.line, `the guard cannot read the handler this \`trap\` sets, \`${handler.text}\` (${handler.exp.find((piece) => piece.kind !== "literal")?.why ?? "a value the guard cannot know"}), so it cannot check what runs when this shell exits; write the handler out, or put it in a function`);
       } else if (!text.startsWith("-")) {
-        outer.traps = [...outer.traps, { text, site, signals: handled, file: file2 }];
+        outer.traps = [
+          ...outer.traps,
+          { text, site, signals: handled, file: file2, uncertainSet: ctx.uncertain.depth > 0 }
+        ];
       }
       return;
     }
@@ -43479,22 +43672,29 @@ function dispatch(invocation, outer, ctx) {
     case "tar":
     case "unzip": {
       const extracting = base === "unzip" || rest.some((arg, index) => {
-        const text = literalText(arg.exp);
-        return text === "--extract" || text === "--get" || text?.startsWith("-") === true && !text.startsWith("--") && text.includes("x") || index === 0 && /^[A-Za-z]*x[A-Za-z]*$/.test(text ?? "");
+        const { text, whole } = readableWord(arg);
+        if (!whole && index === 0 && /^[A-Za-z]*$/.test(text))
+          return true;
+        return mayBeOption(arg, (mode) => mode === "--extract" || mode === "--get" || mode.startsWith("-") && !mode.startsWith("--") && mode.includes("x") || index === 0 && /^[A-Za-z]*x[A-Za-z]*$/.test(mode));
       });
       if (!extracting)
         return;
       const targetDirectories = [];
       const short = base === "tar" ? "-C" : "-d";
       const long = base === "tar" ? "--directory" : "--destination";
+      const letter = short.slice(1);
       for (const [index, arg] of rest.entries()) {
-        const text = literalText(arg.exp);
-        if (text === short || text === long) {
+        const { text, whole } = readableWord(arg);
+        const clusterAt = text.startsWith("-") && !text.startsWith("--") ? text.indexOf(letter, 1) : -1;
+        const carried = text.startsWith(`${long}=`) ? valueInWord(arg, long.length + 1) : clusterAt !== -1 && (!whole || text.length > clusterAt + 1) ? valueInWord(arg, clusterAt + 1) : undefined;
+        if (carried !== undefined) {
+          targetDirectories.push({ text: arg.text, exp: carried });
+          continue;
+        }
+        if (clusterAt !== -1 || mayBeOption(arg, (option) => option === short || option === long)) {
           const target = rest[index + 1];
           if (target !== undefined)
             targetDirectories.push(target);
-        } else if (text?.startsWith(`${long}=`)) {
-          targetDirectories.push({ text: arg.text, exp: [literal2(text.slice(long.length + 1))] });
         }
       }
       checkTargets(base, "extract and overwrite in", targetDirectories, true, st, ctx, site);
@@ -43530,7 +43730,7 @@ function dispatch(invocation, outer, ctx) {
           const file2 = path4.resolve(st.cwd, target);
           st.pidFiles.delete(file2);
           const text = heredoc === undefined ? null : heredocText(heredoc);
-          st.files.set(file2, append || text === null ? null : readable(text));
+          modelWrite(st, ctx, file2, append ? UNREAD_FILE : text === null ? UNRENDERED_WRITE : readable(text) ?? OVERLONG_WRITE);
         }
       }
       return;
@@ -43542,41 +43742,73 @@ function dispatch(invocation, outer, ctx) {
     case "killall":
     case "killall5":
       throw new Refusal(site.snippet, site.line, `${base} selects processes by name or pattern, which reaches other agents' processes on a ` + "shared machine; a pane signals only processes it started. Stop a process you started " + 'with the hub tool (`op: "stop"`), or `kill` the pid of a child you started from this pane');
-    case "fuser":
-      if (rest.some((arg) => /^-[a-zA-Z]*k/.test(literalText(arg.exp) ?? ""))) {
+    case "fuser": {
+      const kills = rest.some((arg) => mayBeOption(arg, (text) => /^-[a-zA-Z]*k/.test(text) || text === "--kill"));
+      const readable2 = rest.every((arg) => literalText(arg.exp) !== undefined);
+      const mayBeSeveral = rest.some((arg) => arg.fields === "unknown");
+      if (kills && (readable2 || mayBeSeveral || rest.length > 1)) {
         throw new Refusal(site.snippet, site.line, "`fuser -k` kills every process using a file, other agents' included; a pane signals only " + "processes it started");
       }
       return;
+    }
     case "tmux": {
       let socket;
       let socketIsPath = false;
-      for (let i = 0;i < rest.length; i += 1) {
-        const text = literalText(rest[i]?.exp);
-        if (text === "-L" || text === "-S" || text === "--socket") {
-          socket = rest[i + 1];
-          socketIsPath = text !== "-L";
-          i += 1;
-        } else if (text?.startsWith("--socket=")) {
-          socket = { text, exp: [literal2(text.slice(9))] };
-          socketIsPath = true;
+      let current = { words: [], speculative: false };
+      const segments = [current];
+      for (const arg of rest) {
+        const word = literalText(arg.exp);
+        const trailing = word !== ";" && word !== undefined && word.endsWith(";");
+        if (trailing)
+          current.words.push({ text: arg.text, exp: [literal2(word.slice(0, -1))] });
+        else if (word !== ";")
+          current.words.push(arg);
+        if (word === ";" || trailing) {
+          current = { words: [], speculative: false };
+          segments.push(current);
+        } else if (word === undefined || arg.fields === "unknown") {
+          current = { words: [], speculative: true };
+          segments.push(current);
         }
       }
       const killCommands = ["kill-server", "kill-session", "kill-window", "kill-pane"];
       const respawnCommands = ["respawn-pane", "respawn-window"];
-      const respawning = rest.some((arg) => {
-        const text = literalText(arg.exp);
-        if (text === undefined)
-          return false;
-        const compact = text.replace("-", "");
-        return respawnCommands.filter((command) => command.replace("-", "").startsWith(compact)).length === 1;
-      }) && rest.some((arg) => literalText(arg.exp) === "-k");
-      const killing = rest.find((arg) => {
-        const text = literalText(arg.exp);
-        if (text === undefined)
+      const names = (word, commands) => {
+        if (word === undefined)
           return false;
+        const { text, whole } = readableWord(word);
         const compact = text.replace("-", "");
-        return killCommands.filter((command) => command.replace("-", "").startsWith(compact)).length === 1 || respawning;
-      });
+        const reachable = commands.filter((command) => command.replace("-", "").startsWith(compact));
+        return whole ? reachable.length === 1 : reachable.length > 0;
+      };
+      let killing;
+      for (const segment of segments) {
+        const words = segment.words;
+        let subcommand;
+        for (let i = 0;i < words.length; i += 1) {
+          const arg = words[i];
+          const { text, whole } = readableWord(arg);
+          const attached = (option) => text.startsWith(option) && (!whole || text.length > option.length) ? valueInWord(arg, option.length) : undefined;
+          const carried = attached("-L") ?? attached("-S") ?? attached("--socket=");
+          if (carried !== undefined) {
+            socket = { text: arg.text, exp: carried };
+            socketIsPath = !text.startsWith("-L");
+          } else if (text === "-L" || text === "-S" || text === "--socket") {
+            socket = words[i + 1];
+            socketIsPath = text !== "-L";
+            i += 1;
+          } else if (text === "-f" || text === "-T") {
+            i += 1;
+          } else if (subcommand === undefined && !text.startsWith("-")) {
+            subcommand = arg;
+          }
+        }
+        if (segment.speculative && (subcommand === undefined || readableWord(subcommand).text === ""))
+          continue;
+        const respawning = names(subcommand, respawnCommands) && words.some((arg) => mayBeOption(arg, (text) => text === "-k"));
+        if (names(subcommand, killCommands) || respawning)
+          killing ??= subcommand;
+      }
       if (killing === undefined)
         return;
       let resolvedSocket;
@@ -43600,13 +43832,19 @@ function dispatch(invocation, outer, ctx) {
       if (resolvedSocket !== undefined && judgePath(resolvedSocket, st, ctx, { follow: true, overwrite: false }).ok) {
         return;
       }
-      throw new Refusal(site.snippet, site.line, `\`tmux ${literalText(killing.exp)}\` needs a socket path inside this pane's roots; the ` + "resolved socket can end panes and processes this pane did not start");
+      throw new Refusal(site.snippet, site.line, `\`tmux ${killing.text}\` needs a socket path inside this pane's roots; the ` + "resolved socket can end panes and processes this pane did not start");
+    }
+    case "busybox":
+    case "toybox": {
+      if (rest.length === 0)
+        return;
+      throw new Refusal(site.snippet, site.line, `the guard cannot read the applet \`${rest[0].text}\` ${base} would run, and the ` + "applets it carries include `rm`, `sh` and `killall`, which reach paths and processes " + `this pane did not start; name the applet (\`${base} rm \u2026\`) so it can be checked`);
     }
     default:
       break;
   }
-  if (SHELLS.has(base) || base === "busybox" && SHELLS.has(literalText(rest[0]?.exp) ?? "")) {
-    runShell(base === "busybox" ? rest.slice(1) : rest, invocation, st, ctx);
+  if (SHELLS.has(base)) {
+    runShell(rest, invocation, st, ctx);
     return;
   }
   const interpreter = interpreterLanguage(base);
@@ -43636,8 +43874,9 @@ function changeDirectory(target, st, ctx) {
 function declaration(builtin, list, st, ctx, site) {
   const options = list.map((arg) => literalText(arg.exp) ?? "").filter((text) => /^[-+][a-zA-Z]+$/.test(text));
   const option = (letter) => options.some((text) => text.startsWith("-") && text.includes(letter));
-  if (builtin !== "export" && option("n")) {
-    throw new Refusal(site.snippet, site.line, "the guard does not follow a nameref (`declare -n`), whose writes land in the variable it names");
+  const mayBeNameref = list.some((arg) => mayBeOption(arg, (text) => /^-[a-zA-Z]*n/.test(text)));
+  if (builtin !== "export" && mayBeNameref) {
+    throw new Refusal(site.snippet, site.line, option("n") ? "the guard does not follow a nameref (`declare -n`), whose writes land in the variable it names" : `an option word \`${builtin}\` carries that the guard cannot read may be \`-n\`, a nameref ` + "whose writes land in the variable it names and which the guard does not follow; write " + "the option as a literal");
   }
   if (option("f") || option("F"))
     return;
@@ -43822,11 +44061,20 @@ function checkRecursiveMode(program, list, st, ctx, site) {
     }
     found.push(arg);
   }
-  if (!recursive)
-    return;
-  const targets = reference ? found : found.slice(1);
   const verb = program === "chmod" ? "recursively change the mode of" : "recursively change the owner of";
-  checkTargets(`${program} -R`, verb, targets, true, st, ctx, site);
+  if (recursive) {
+    checkTargets(`${program} -R`, verb, reference ? found : found.slice(1), true, st, ctx, site);
+    return;
+  }
+  for (const [index, arg] of found.entries()) {
+    if (!mayBeOption(arg, (text) => /^-[A-Za-z]*R/.test(text)))
+      continue;
+    const others = arg.fields === "unknown" ? found : found.filter((_, at) => at !== index);
+    const targets = reference || arg.fields === "unknown" ? others : others.slice(1);
+    if (targets.length === 0)
+      continue;
+    checkTargets(`${program} -R`, verb, targets, true, st, ctx, site);
+  }
 }
 function checkFind(list, st, ctx, site) {
   let i = 0;
@@ -43841,17 +44089,27 @@ function checkFind(list, st, ctx, site) {
     break;
   }
   const starts = [];
+  let rootsBeforePredicate;
   for (;i < list.length; i += 1) {
-    const text = literalText(list[i]?.exp);
+    const arg = list[i];
+    const text = literalText(arg.exp);
     if (text !== undefined && (text.startsWith("-") || text === "(" || text === "!" || text === ")"))
       break;
-    starts.push(list[i]);
+    if (rootsBeforePredicate === undefined && mayBeOption(arg, (option) => option.startsWith("-"))) {
+      rootsBeforePredicate = [...starts];
+    }
+    starts.push(arg);
   }
   const targets = starts.length > 0 ? starts : [{ text: ".", exp: [literal2(".")] }];
   const expression = list.slice(i).map((arg) => literalText(arg.exp));
   let action;
   let shell;
+  let consumedByPredicate = false;
   for (const [index, word] of expression.entries()) {
+    const isValue = consumedByPredicate;
+    consumedByPredicate = word !== undefined && FIND_VALUED_PREDICATES.has(word);
+    if (word === undefined && !isValue)
+      action ??= "find with a predicate the guard cannot read";
     if (word === "-delete")
       action = "find -delete";
     if (word !== "-exec" && word !== "-execdir" && word !== "-ok" && word !== "-okdir")
@@ -43868,8 +44126,13 @@ function checkFind(list, st, ctx, site) {
       shell = inner.argv;
     }
   }
-  if (action === undefined)
+  if (action === undefined) {
+    if (rootsBeforePredicate === undefined)
+      return;
+    const under = rootsBeforePredicate.length > 0 ? rootsBeforePredicate : [{ text: ".", exp: [literal2(".")] }];
+    checkTargets("find with a root the guard cannot read, which may be a predicate", "delete or change what it finds under", under, false, st, ctx, site);
     return;
+  }
   checkTargets(action, "delete or change what it finds under", targets, false, st, ctx, site);
   if (shell === undefined)
     return;
@@ -44146,7 +44409,7 @@ function runInterpreter(base, language, list, invocation, st, ctx) {
   for (;i < words.length; i += 1) {
     const word = words[i];
     if (word === undefined)
-      return;
+      continue;
     if (codeFlags.includes(word)) {
       runCode(language, list[i + 1], invocation, st, ctx, site);
       return;
@@ -44195,8 +44458,8 @@ function runFile(file2, positional, st, ctx, site, kind, source = false) {
   let content;
   if (st.files.has(abs)) {
     const written = st.files.get(abs);
-    if (written === null || written === undefined) {
-      throw new Refusal(site.snippet, site.line, `this command writes ${abs} in a way the guard cannot read before running it (output it cannot render, or more than the ${MAX_SCRIPT_BYTES} bytes it reads of a script); write the script with the write tool first`);
+    if (written === undefined || typeof written !== "string") {
+      throw new Refusal(site.snippet, site.line, `this command may write ${abs} in a way the guard cannot read before running it (${written?.why ?? "the guard cannot say what it holds"}); write the script with the write tool first`);
     }
     content = written;
   } else {
@@ -44389,7 +44652,8 @@ function createPaneGuard(options) {
     env,
     ompPid: options.ompPid,
     parentOf: options.parentOf ?? procParent,
-    steps: { count: 0 }
+    steps: { count: 0 },
+    uncertain: { depth: 0 }
   });
   const initial = (cwd, source) => ({
     vars: new Map,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "5.17.1",
+  "version": "5.17.3",
   "type": "module",
   "omp": {
     "extensions": [