@lazyingart/agintiflow 0.20.330 → 0.20.331

package/docs/supervision-campaign-ledger.md

@@ -721,3 +721,22 @@ repository and report whether a README exists. The scripted DeepSeek-shaped
 response calls `inspect_project` with `reason` plus a real `limit`; the persisted
 runtime dispatches the inspection, records zero tool-contract failures, and
 finishes with the verified README status without mutating the workspace.
+
+### Native tmux recovery from generic shell aliases
+
+`tmux-run-command-native-recovery-094` covers a reusable coordination-tool
+handoff gap seen in recent retained runtime evidence. A normal supervision
+prompt selected the host tmux tool bundle, but the provider tried the native
+tool name `tmux_list_sessions` and later `tmux list-sessions` through
+`run_command`. AgInTiFlow treated those as generic shell commands, producing a
+host permission pause or shell failure instead of using the already offered
+native tmux listing tool.
+
+The runtime now auto-corrects only exact read-only tmux session-list aliases
+from `run_command` to `tmux_list_sessions` before shell guardrails run. It
+records `tool.auto_corrected`, preserves the original requested tool in
+`tool.started`, dispatches no generic shell command, and leaves arbitrary tmux
+startup/send/mutation shell commands blocked by the existing permission policy.
+The focused persisted-runtime regression verifies both exact aliases and the
+negative mutating command case; the tmux guardrail, progressive-tool,
+provider-handoff, syntax, package-audit, dry-pack, and full npm suites pass.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.330",
+  "version": "0.20.331",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/scripts/smoke-truthful-completion.js

@@ -19,6 +19,7 @@ import {
   evaluateSourceFreeResponseClaims,
   finishResultClaimsIncompleteWork,
 } from "../src/scs-evidence.js";
+import { tmuxAvailable } from "../src/tmux-tools.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-truthful-completion-"));
@@ -860,6 +861,118 @@ try {
     "permission blocker triggered an SCS replan instead of waiting for approval"
   );
 
+  if (await tmuxAvailable()) {
+    const tmuxAliasRecovery = await runCase({
+      id: "tmux-shell-alias-recovery",
+      goal: "Check durable host tmux sessions and report whether any sessions exist.",
+      taskProfile: "auto",
+      executionTier: "focused",
+      allowShellTool: true,
+      responses: [
+        assistant("", [toolCall("tmux-as-shell", "run_command", { command: "tmux_list_sessions" })]),
+        assistant("", [
+          toolCall("finish-tmux-alias", "finish", {
+            result: "Checked durable host tmux sessions through the native tmux listing tool.",
+          }),
+        ]),
+      ],
+    });
+    assert.equal(tmuxAliasRecovery.calls.length, 2);
+    assert.equal(tmuxAliasRecovery.result.stopped, undefined);
+    assert(
+      tmuxAliasRecovery.events.some(
+        (event) =>
+          event.type === "tool.auto_corrected" &&
+          event.data?.requestedToolName === "run_command" &&
+          event.data?.toolName === "tmux_list_sessions" &&
+          event.data?.originalCommand === "tmux_list_sessions"
+      ),
+      "run_command tmux_list_sessions alias was not recovered to the native tmux tool"
+    );
+    assert(
+      tmuxAliasRecovery.events.some(
+        (event) =>
+          event.type === "tool.started" &&
+          event.data?.toolName === "tmux_list_sessions" &&
+          event.data?.requestedToolName === "run_command"
+      ),
+      "native tmux listing was not started with original requested tool evidence"
+    );
+    assert(
+      tmuxAliasRecovery.events.some(
+        (event) =>
+          event.type === "tool.completed" &&
+          event.data?.toolName === "tmux_list_sessions"
+      ),
+      "native tmux listing did not complete after alias recovery"
+    );
+    assert(
+      !tmuxAliasRecovery.events.some(
+        (event) => event.type === "tool.started" && event.data?.toolName === "run_command"
+      ),
+      "tmux alias recovery still dispatched the generic shell command"
+    );
+    assert(
+      !tmuxAliasRecovery.events.some(
+        (event) => event.type === "session.stopped" && event.data?.reason === "permission_required"
+      ),
+      "tmux alias recovery still paused on shell permission"
+    );
+
+    const tmuxReadonlyCommandRecovery = await runCase({
+      id: "tmux-readonly-command-recovery",
+      goal: "List durable host tmux sessions using the available coordination tool.",
+      taskProfile: "auto",
+      executionTier: "focused",
+      allowShellTool: true,
+      responses: [
+        assistant("", [toolCall("tmux-command-as-shell", "run_command", { command: "tmux list-sessions" })]),
+        assistant("", [
+          toolCall("finish-tmux-command", "finish", {
+            result: "Checked durable host tmux sessions through the native tmux listing tool.",
+          }),
+        ]),
+      ],
+    });
+    assert.equal(tmuxReadonlyCommandRecovery.result.stopped, undefined);
+    assert(
+      tmuxReadonlyCommandRecovery.events.some(
+        (event) =>
+          event.type === "tool.auto_corrected" &&
+          event.data?.toolName === "tmux_list_sessions" &&
+          event.data?.originalCommand === "tmux list-sessions"
+      ),
+      "exact tmux list-sessions shell command was not recovered"
+    );
+    assert(
+      !tmuxReadonlyCommandRecovery.events.some(
+        (event) => event.type === "tool.started" && event.data?.toolName === "run_command"
+      ),
+      "exact tmux list-sessions recovery still dispatched run_command"
+    );
+
+    const tmuxMutationStillBlocked = await runCase({
+      id: "tmux-mutating-command-still-blocked",
+      goal: "Try to create a tmux session through the generic shell.",
+      taskProfile: "auto",
+      executionTier: "focused",
+      allowShellTool: true,
+      responses: [
+        assistant("", [
+          toolCall("tmux-mutating-shell", "run_command", {
+            command: "tmux new-session -d -s should-not-autocorrect",
+          }),
+        ]),
+      ],
+    });
+    assert.equal(tmuxMutationStillBlocked.result.stopped, true);
+    assert.equal(tmuxMutationStillBlocked.result.reason, "permission_required");
+    assert(
+      !tmuxMutationStillBlocked.events.some((event) => event.type === "tool.auto_corrected"),
+      "mutating tmux shell command was incorrectly auto-corrected"
+    );
+  }
+
   const reasoningTruncation = await runCase({
     id: "reasoning-only-tool-continuation",
     goal: "Run pwd and report the verified working directory.",

package/src/agent-runner.js

@@ -5058,6 +5058,58 @@ export function normalizeNoMatchQueryResult(result = {}, policy = {}) {
   };
 }
 
+function runtimeFlagDisabled(value) {
+  if (value === false || value === 0) return true;
+  return /^(false|off|no|0)$/i.test(String(value ?? "").trim());
+}
+
+function exactTmuxListSessionsShellAlias(command = "") {
+  const canonical = canonicalizeShellCommand(command);
+  if (!canonical || canonical.includes("\n")) return null;
+  const sequence = parseTopLevelShellSequence(canonical);
+  if (
+    sequence.openQuote ||
+    sequence.trailingEscape ||
+    sequence.trailingSeparator ||
+    sequence.commands.length !== 1
+  ) {
+    return null;
+  }
+  const tokens = tokenizeShellWords(sequence.commands[0]).map((token) =>
+    String(token || "")
+  );
+  if (tokens.length === 1 && tokens[0] === "tmux_list_sessions") {
+    return { command: canonical, alias: "tool-name-as-shell-command" };
+  }
+  if (
+    tokens.length === 2 &&
+    tokens[0] === "tmux" &&
+    (tokens[1] === "list-sessions" || tokens[1] === "ls")
+  ) {
+    return { command: canonical, alias: "tmux-readonly-list-command" };
+  }
+  return null;
+}
+
+function recoverRunCommandTmuxListAlias(requestedToolName, args = {}, config = {}) {
+  if (requestedToolName !== "run_command") return null;
+  if (
+    runtimeFlagDisabled(config.allowShellTool) ||
+    runtimeFlagDisabled(config.allowTmuxTools) ||
+    runtimeFlagDisabled(config.allowCoordinationTools)
+  ) {
+    return null;
+  }
+  const alias = exactTmuxListSessionsShellAlias(args.command);
+  if (!alias) return null;
+  return {
+    requestedToolName,
+    toolName: "tmux_list_sessions",
+    reason: alias.alias,
+    originalCommand: alias.command,
+  };
+}
+
 function hashForLog(value) {
   return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
 }
@@ -20506,6 +20558,14 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
           prompt: "Inspect this exact generated image as verification evidence. Describe the visible content, readability, clipping, labels, scale, and any defects that require repair.",
         };
   }
+  const tmuxListAliasCorrection = !autoCorrection
+    ? recoverRunCommandTmuxListAlias(requestedToolName, args, config)
+    : null;
+  if (tmuxListAliasCorrection) {
+    toolName = tmuxListAliasCorrection.toolName;
+    args = { includePanes: true };
+    autoCorrection = tmuxListAliasCorrection;
+  }
   const repositoryCommitPaths = [
     ...(Array.isArray(config.repositoryStateRepairCommitPaths)
       ? config.repositoryStateRepairCommitPaths