@lazyingart/agintiflow 0.20.118 → 0.20.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.118",
+  "version": "0.20.119",
   "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-coding-tools.js

@@ -9,6 +9,7 @@ import {
   runAgent,
   sanitizeToolResult,
   shouldShortCircuitToolBatch,
+  shellDiagnosticHint,
   skippedAfterBlockedToolResult,
 } from "../src/agent-runner.js";
 import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
@@ -410,6 +411,13 @@ try {
     quotedDangerSearchPolicy.category !== "destructive",
     "quoted destructive strings in grep pattern should not classify as a destructive command"
   );
+  const grepCountHint = shellDiagnosticHint("grep -c 'Fatal\\|Emergency' article.log && echo done", {
+    ok: false,
+    exitCode: 1,
+    stdout: "0\n",
+    stderr: "",
+  });
+  assert(grepCountHint.includes("grep -c exits 1"), "failed grep-count validation should explain clean zero-match exit behavior");
   const actualDangerAfterQuotePolicy = evaluateCommandPolicy('echo "rm -rf is text" && rm -rf reports', dockerWorkspacePolicy);
   assert(!actualDangerAfterQuotePolicy.allowed, "actual destructive command after quoted text should still be blocked");
   assert(actualDangerAfterQuotePolicy.category === "destructive", "actual destructive command after quoted text was not classified as destructive");

package/scripts/smoke-toolchain-docker.js

@@ -65,6 +65,25 @@ try {
   const outsideRead = await runToolchainCommand(`cat ${path.join(outsideData, "source-note.txt")}`, config);
   assert(outsideRead.stdout.includes("READ_ONLY_HOST_MOUNT_OK"), "Docker normal mode could not read the configured outside data root");
 
+  const abortController = new AbortController();
+  const abortCommand = `python3 -c 'import time; time.sleep(20)'`;
+  const abortPolicy = evaluateCommandPolicy(abortCommand, { ...config, packageInstallPolicy: "allow" });
+  assert(abortPolicy.allowed, "long-running Docker command should be allowed for interrupt smoke");
+  const abortStartedAt = Date.now();
+  const abortRun = runDockerSandboxCommand(abortCommand, { ...config, packageInstallPolicy: "allow" }, abortPolicy, {
+    signal: abortController.signal,
+  });
+  setTimeout(() => abortController.abort(new Error("smoke interrupt")), 500);
+  let interrupted = false;
+  try {
+    await abortRun;
+  } catch (error) {
+    interrupted = /abort|interrupt|cancel/i.test(String(error?.name || "")) || /abort|interrupt|cancel/i.test(String(error?.message || ""));
+  }
+  const abortElapsed = Date.now() - abortStartedAt;
+  assert(interrupted, "Docker command did not reject as interrupted after AbortController abort");
+  assert(abortElapsed < 8000, `Docker interrupt took too long: ${abortElapsed}ms`);
+
   await fs.writeFile(
     path.join(workspace, "plot_fx.py"),
     [

package/src/agent-runner.js

@@ -2,9 +2,8 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
-import { exec as execCallback, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { promisify } from "node:util";
 import { chromium } from "playwright";
 import { createClient, createPlan, requestNextStep } from "./model-client.js";
 import { SessionStore } from "./session-store.js";
@@ -54,7 +53,6 @@ import {
   serializeStepBudgetState,
 } from "./step-budget-controller.js";
 
-const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "open_workspace_file", "preview_workspace", "click", "type", "scroll", "press", "back"]);
 const WORKSPACE_TOOLS = new Set(WORKSPACE_TOOL_NAMES);
 const STATIC_PREVIEW_SERVER_PATH = fileURLToPath(new URL("./static-preview-server.js", import.meta.url));
@@ -585,6 +583,7 @@ async function createInitialState(config, sessionId) {
             : "No shell command tool is available.",
           `Permission contract: permission mode is ${config.permissionMode || "normal"}. Safe mode asks before workspace writes/setup. Normal mode allows current-project writes, read-only inspection of visible host paths, and approved Docker setup, but outside-workspace writes and host-system changes require approval. Danger mode is trusted host/full-access mode. Do not bypass blockers by retrying variants. If a tool result includes permissionAdvice or suggestedCommand, stop, explain the blocker, copy the exact suggestedCommand when giving a rerun path, and ask the user to approve/rerun that mode or choose a safer workspace-relative path. Never invent legacy AgInTi syntax such as \`aginti run --sandbox host\`; use the exact flags from permissionAdvice.`,
           "If an operation fails but a directory, artifact, or file already exists, treat it as pre-existing unless you have evidence this run created or updated it. Verify expected outputs before claiming success.",
+          "For validation/evidence commands, remember that grep exits 1 on zero matches. If zero matches is the expected clean result, use `grep -c PATTERN file || true`, split evidence checks into independent commands, or use awk/python so a clean zero count does not stop an `&&` chain.",
           config.allowShellTool
         ? "Host tmux tools are available for long-running terminals: list sessions, capture panes, send safe keys/text, and start detached sessions. Prefer these tools for monitoring long installs/tests/dev servers without blocking; capture before sending input and never send secrets or sudo passwords. Do not start or install tmux inside Docker run_command containers because those containers are short-lived. In Docker sandbox mode, tmux start/send commands must stay workspace-write-bound; prefer run_command for read-only host absolute path inspection through read-only mounts, and ask for --sandbox-mode host for trusted whole-host write/system work."
         + " For one-shot tmux commands, redirect stdout/stderr and exit status to a durable workspace log or keep the pane alive for capture; if capture fails because the session ended, do not infer output or exit status."
@@ -1006,6 +1005,7 @@ async function applyContinuationPrompt(state, config, observers) {
       temporalContext,
       config.startUrl ? `Suggested start URL: ${config.startUrl}` : "",
       config.allowedDomains.length > 0 ? `Allowed domains: ${config.allowedDomains.join(", ")}` : "",
+      "Validation reminder: grep exits 1 on zero matches. For clean-zero checks, guard `grep -c` with `|| true` or split evidence commands so the validation can continue.",
       config.allowShellTool
         ? config.useDockerSandbox
           ? `Shell working directory mounted into Docker as /workspace from ${config.commandCwd}. Use relative paths or /workspace paths for outputs/writes; common host data roots are read-only at original absolute paths for inspection. Persistent Docker env: /aginti-env, caches: /aginti-cache. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
@@ -1076,6 +1076,112 @@ function safeExecutionEnv() {
   };
 }
 
+function trimOutput(value = "", limit = 8000) {
+  const text = redactSensitiveText(String(value || ""));
+  return text.trim().slice(0, limit);
+}
+
+function killChildTree(child, signal = "SIGTERM") {
+  if (!child || child.killed) return;
+  try {
+    if (process.platform === "win32") child.kill(signal);
+    else process.kill(-child.pid, signal);
+  } catch {
+    try {
+      child.kill(signal);
+    } catch {
+      // Best effort; process may already be gone.
+    }
+  }
+}
+
+function runHostShellCommand(command, config) {
+  return new Promise((resolve, reject) => {
+    const shell = hostShellOption();
+    const child = spawn(String(command || ""), {
+      cwd: config.commandCwd,
+      env: safeExecutionEnv(),
+      shell,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    const timeoutMs = Number(config.shellTimeoutMs || process.env.AGINTI_SHELL_TIMEOUT_MS || 30000);
+    const maxStdout = 220 * 1024;
+    const maxStderr = 120 * 1024;
+
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (config.abortSignal && onAbort) config.abortSignal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      killChildTree(child, "SIGTERM");
+      setTimeout(() => killChildTree(child, "SIGKILL"), 1200).unref?.();
+      const error = new Error("Run interrupted by user.");
+      error.name = "AbortError";
+      error.code = "ABORT_ERR";
+      settle(() => reject(error));
+    };
+    const timer =
+      Number.isFinite(timeoutMs) && timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            killChildTree(child, "SIGTERM");
+            setTimeout(() => killChildTree(child, "SIGKILL"), 1200).unref?.();
+          }, timeoutMs)
+        : null;
+    timer?.unref?.();
+
+    if (config.abortSignal?.aborted) return onAbort();
+    if (config.abortSignal) config.abortSignal.addEventListener("abort", onAbort, { once: true });
+
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < maxStdout) stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < maxStderr) stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      settle(() =>
+        resolve({
+          ok: false,
+          exitCode: 1,
+          stdout,
+          stderr: `${stderr}${stderr ? "\n" : ""}${error instanceof Error ? error.message : String(error)}`,
+        })
+      );
+    });
+    child.on("close", (code, signalName) => {
+      settle(() =>
+        resolve({
+          ok: !timedOut && Number(code || 0) === 0,
+          exitCode: timedOut ? 124 : Number.isInteger(code) ? code : signalName ? 130 : 1,
+          stdout,
+          stderr: `${stderr}${timedOut ? `\nCommand timed out after ${timeoutMs}ms.` : ""}`,
+        })
+      );
+    });
+  });
+}
+
+export function shellDiagnosticHint(command = "", result = {}) {
+  if (result?.ok !== false) return "";
+  const text = String(command || "");
+  if (/\bgrep\b[\s\S]*\s-c\b|\bgrep\s+-c\b/.test(text)) {
+    return "grep -c exits 1 when it finds zero matches even though it prints 0. For count-only validation, use `grep -c PATTERN file || true`, split evidence commands, or use awk/python when zero matches is the expected clean state.";
+  }
+  if (/\bgrep\b/.test(text) && /&&/.test(text)) {
+    return "grep exits 1 when it finds no matches, so an `&&` evidence chain can stop early. If no matches is acceptable, guard that grep with `|| true` or run independent validation commands.";
+  }
+  return "";
+}
+
 function hashForLog(value) {
   return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
 }
@@ -1261,29 +1367,26 @@ async function runShellCommand(command, config, policy = evaluateCommandPolicy(c
     throwIfAborted(config);
     const result = config.useDockerSandbox
       ? await runDockerSandboxCommand(command, config, policy, { signal: config.abortSignal })
-      : await exec(command, {
-          cwd: config.commandCwd,
-          timeout: 30000,
-          maxBuffer: 200 * 1024,
-          shell: hostShellOption(),
-          env: safeExecutionEnv(),
-          signal: config.abortSignal,
-        });
+      : await runHostShellCommand(command, config);
+    const diagnosticHint = shellDiagnosticHint(command, result);
 
     return {
-      ok: true,
-      exitCode: 0,
-      stdout: redactSensitiveText(result.stdout).trim().slice(0, 8000),
-      stderr: redactSensitiveText(result.stderr).trim().slice(0, 4000),
+      ok: result.ok !== false,
+      exitCode: Number.isInteger(result.exitCode) ? result.exitCode : 0,
+      stdout: trimOutput(result.stdout, 8000),
+      stderr: trimOutput(result.stderr, 4000),
+      ...(diagnosticHint ? { diagnosticHint } : {}),
     };
   } catch (error) {
     if (isAbortError(error, config)) throw error;
-    return {
+    const failedResult = {
       ok: false,
       exitCode: Number.isInteger(error?.code) ? error.code : 1,
-      stdout: redactSensitiveText(String(error?.stdout || "")).trim().slice(0, 8000),
-      stderr: redactSensitiveText(String(error?.stderr || error?.message || "")).trim().slice(0, 4000),
+      stdout: trimOutput(error?.stdout || "", 8000),
+      stderr: trimOutput(error?.stderr || error?.message || "", 4000),
     };
+    const diagnosticHint = shellDiagnosticHint(command, failedResult);
+    return diagnosticHint ? { ...failedResult, diagnosticHint } : failedResult;
   }
 }
 
@@ -1295,6 +1398,7 @@ async function captureSyntheticSnapshot(store, step, config) {
     pageText: [
       "No browser page is currently open.",
       config.startUrl ? `Suggested start URL: ${config.startUrl}` : "",
+      "Validation reminder: grep exits 1 on zero matches; guard expected clean-zero grep checks or split evidence commands.",
       config.allowShellTool
         ? config.useDockerSandbox
           ? `Shell tool available in Docker with mounted workspace /workspace from ${config.commandCwd}. Use relative paths or /workspace paths for outputs/writes; common host data roots are read-only at original absolute paths for inspection. Persistent Docker env: /aginti-env, caches: /aginti-cache. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
@@ -2377,6 +2481,7 @@ export async function runAgent(config) {
             command: redactSensitiveText(toolResult.args?.command || ""),
             stdout: toolResult.stdout || "",
             stderr: toolResult.stderr || "",
+            diagnosticHint: toolResult.diagnosticHint || "",
             commandPolicy: toolResult.commandPolicy,
             blocked: Boolean(toolResult.blocked),
             error: toolResult.error || toolResult.reason || "",

package/src/docker-sandbox.js

@@ -1,3 +1,4 @@
+import crypto from "node:crypto";
 import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -63,6 +64,23 @@ async function execDocker(args, options = {}) {
     signal: options.signal,
   };
   recordSandboxLog("docker.command", { args });
+  const containerName = options.containerName || "";
+  let abortHandler = null;
+  if (options.signal && containerName) {
+    abortHandler = () => {
+      void execFile("docker", ["kill", containerName], {
+        timeout: 8000,
+        maxBuffer: 32 * 1024,
+      }).catch((error) => {
+        recordSandboxLog("docker.kill.failed", {
+          containerName,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
+    };
+    if (options.signal.aborted) abortHandler();
+    else options.signal.addEventListener("abort", abortHandler, { once: true });
+  }
 
   try {
     const result = await execFile("docker", args, execOptions);
@@ -81,6 +99,8 @@ async function execDocker(args, options = {}) {
       stdout: redactSensitiveText(result.stdout),
       stderr: redactSensitiveText(result.stderr),
     };
+  } finally {
+    if (options.signal && abortHandler) options.signal.removeEventListener("abort", abortHandler);
   }
 }
 
@@ -282,7 +302,11 @@ function dockerCommand(command, policy) {
   return [...envLines, dockerUserCommand(command, policy)].join("\n");
 }
 
-function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command, config), persistentDirs = persistentDockerDirs(config)) {
+function dockerContainerName() {
+  return `aginti-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`.slice(0, 63);
+}
+
+function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command, config), persistentDirs = persistentDockerDirs(config), options = {}) {
   const uid = typeof process.getuid === "function" ? String(process.getuid()) : "";
   const gid = typeof process.getgid === "function" ? String(process.getgid()) : "";
   const userArgs = uid && gid && !policy.requiresDockerRoot ? ["--user", `${uid}:${gid}`] : [];
@@ -299,6 +323,7 @@ function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command,
   return [
     "run",
     "--rm",
+    ...(options.containerName ? ["--name", options.containerName] : []),
     "--network",
     networkMode,
     "--cap-drop",
@@ -337,10 +362,12 @@ function dockerRunArgs(command, config, policy = evaluateCommandPolicy(command,
 
 export async function runDockerSandboxCommand(command, config, policy = evaluateCommandPolicy(command, config), options = {}) {
   const persistentDirs = await ensurePersistentDockerDirs(config);
-  const result = await execDocker(dockerRunArgs(command, config, policy, persistentDirs), {
+  const containerName = dockerContainerName();
+  const result = await execDocker(dockerRunArgs(command, config, policy, persistentDirs, { containerName }), {
     timeout: dockerExecTimeoutMs(policy),
     maxBuffer: 300 * 1024,
     signal: options.signal,
+    containerName,
   });
 
   const payload = {

package/src/interactive-cli.js

@@ -720,6 +720,9 @@ function printCommandOutputLog(data = {}) {
     if (advice.suggestedCommand) outputLine(`${color(" | ", ansi.red)} rerun: ${compactLine(advice.suggestedCommand, 120)}`);
     if (advice.trustedHostCommand) outputLine(`${color(" | ", ansi.red)} host: ${compactLine(advice.trustedHostCommand, 120)}`);
   }
+  if (data.diagnosticHint) {
+    outputLine(`${label("hint", ansi.yellow)} ${compactLine(data.diagnosticHint, 112)}`);
+  }
 }
 
 function printHeading(text) {
@@ -1675,7 +1678,8 @@ class LiveRunInput {
 
   handleKey(str = "", key = {}) {
     if (key.ctrl && key.name === "c") {
-      this.controller.abort(new Error("Interrupted by ctrl-c."));
+      this.setStatus("stopping · ctrl-c");
+      this.controller.abort(createAbortError("Interrupted by ctrl-c."));
       return;
     }
     if (key.name === "escape") {
@@ -1686,7 +1690,8 @@ class LiveRunInput {
         this.redraw();
         return;
       }
-      this.controller.abort(new Error("Interrupted by escape."));
+      this.setStatus("stopping · escape");
+      this.controller.abort(createAbortError("Interrupted by escape."));
       return;
     }
     if (key.meta && key.name === "up") {
@@ -1784,7 +1789,9 @@ function printStatus(state) {
   printSystemLine(`project=${process.cwd()}`);
   printSystemLine(`cwd=${state.commandCwd || process.cwd()}`);
   printSystemLine(`session=${state.sessionId || "new"}`);
-  printSystemLine(`status=${state.status || "idle"}${state.activeGoal ? ` workingOn=${state.activeGoal}` : ""}`);
+  const progress =
+    state.currentStep && state.currentMaxSteps ? ` progress=${state.currentStep}/${state.currentMaxSteps}` : state.currentStep ? ` progress=${state.currentStep}` : "";
+  printSystemLine(`status=${state.status || "idle"}${progress}${state.activeGoal ? ` workingOn=${state.activeGoal}` : ""}`);
   printSystemLine(`language=${state.language || cliLanguage} (${languageLabel(state.language || cliLanguage)})`);
   if (state.lastEvent) printSystemLine(`last=${state.lastEvent}`);
   printSystemLine(`provider=${state.provider || "auto"} routing=${state.routingMode} model=${state.model || "auto"}`);
@@ -1954,9 +1961,26 @@ async function printResumeHistory(state, { limit = 0 } = {}) {
   for (const entry of shown) printHistoryEntry(entry);
 }
 
-function printStatusEvent(state, label, details = "") {
+function toolStatusDetails(data = {}) {
+  const tool = data.toolName || "unknown";
+  const args = data.args || {};
+  if (tool === "run_command" && args.command) return `${tool}: ${compactLine(args.command, 58)}`;
+  if ((tool === "write_file" || tool === "apply_patch" || tool === "read_file" || tool === "open_workspace_file") && args.path) {
+    return `${tool}: ${compactLine(args.path, 58)}`;
+  }
+  if ((tool === "open_url" || tool === "web_research" || tool === "web_search") && (args.url || args.query || args.q)) {
+    return `${tool}: ${compactLine(args.url || args.query || args.q, 58)}`;
+  }
+  return tool;
+}
+
+function printStatusEvent(state, label, details = "", meta = {}) {
   const safeDetails = compactLine(details, 72);
-  state.lastEvent = safeDetails ? `${label}: ${safeDetails}` : label;
+  if (meta.step) state.currentStep = meta.step;
+  if (meta.maxSteps) state.currentMaxSteps = meta.maxSteps;
+  const progress =
+    state.currentStep && state.currentMaxSteps ? `step ${state.currentStep}/${state.currentMaxSteps} · ` : state.currentStep ? `step ${state.currentStep} · ` : "";
+  state.lastEvent = `${progress}${safeDetails ? `${label}: ${safeDetails}` : label}`;
   const statusText = `${state.status || "running"} · ${state.lastEvent}`;
   if (activeRunInput) {
     activeRunInput.setStatus(statusText);
@@ -1979,7 +2003,7 @@ function attachRunInterrupts(controller) {
     if (controller.signal.aborted) return;
     const reason = isEscape ? "escape" : "ctrl-c";
     printSystemLine(`status=stopping reason=${reason}`);
-    controller.abort(new Error(`Interrupted by ${reason}.`));
+    controller.abort(createAbortError(`Interrupted by ${reason}.`));
   };
   input.on("keypress", handler);
   return () => {
@@ -3613,12 +3637,18 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
       onEvent: (type, data = {}) => {
         if (type === "plan.created") {
           printStatusEvent(state, "planned");
+        } else if (type === "budget.initialized") {
+          state.currentMaxSteps = data.currentMaxSteps || data.initialMaxSteps || state.maxSteps;
+          printStatusEvent(state, "budget", `${state.currentMaxSteps} steps`);
         } else if (type === "model.requested") {
-          printStatusEvent(state, "model_wait", `${data.provider || "model"}/${data.model || ""}`);
+          printStatusEvent(state, "model_wait", `${data.provider || "model"}/${data.model || ""}`, {
+            step: data.step,
+            maxSteps: state.currentMaxSteps,
+          });
         } else if (type === "tool.started") {
-          printStatusEvent(state, "tool", data.toolName || "unknown");
-        } else if (type === "tool.completed") {
-          printStatusEvent(state, "tool_done", data.toolName || "unknown");
+          printStatusEvent(state, "tool", toolStatusDetails(data));
+        } else if (type === "tool.completed" || type === "tool.failed") {
+          printStatusEvent(state, type === "tool.failed" || data.ok === false ? "tool_failed" : "tool_done", toolStatusDetails(data));
         } else if (type === "file.changed") {
           printWorkspaceChange(data);
         } else if (type === "tool.blocked") {
@@ -3643,7 +3673,10 @@ async function runPrompt(prompt, state, packageDir, { approvalDepth = 0 } = {})
         } else if (type === "session.stopped") {
           printStatusEvent(state, "stopped", data.reason || "");
         } else if (type === "model.responded") {
-          printStatusEvent(state, "model_responded", data.content ? data.content.slice(0, 80).replace(/\s+/g, " ") : "");
+          printStatusEvent(state, "model_responded", data.content ? data.content.slice(0, 80).replace(/\s+/g, " ") : "", {
+            step: data.step,
+            maxSteps: state.currentMaxSteps,
+          });
         }
       },
     });