@lazyingart/agintiflow 0.20.296 → 0.20.298

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.296",
+  "version": "0.20.298",
   "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-dynamic-step-budget.js

@@ -5800,6 +5800,167 @@ try {
       evaluateScsEvidence(privateEvidenceContract, privateEvidenceLedger).ok,
     "ignored private verification evidence invalidated a successful canonical build"
   );
+  const scopedTaskRoot = path.join(workspace, "output", "agent-task-1");
+  const scopedTaskGoal = [
+    "Create and verify output/result.json.",
+    `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+      mode: "task",
+      request: "Create and verify output/result.json.",
+      artifact_root: scopedTaskRoot,
+    })}`,
+  ].join("\n");
+  const scopedTaskState = {
+    goal: scopedTaskGoal,
+    commandCwd: workspace,
+    meta: {
+      goalContract: {
+        revision: 1,
+        taskGoal: scopedTaskGoal,
+        currentRequest: "Create and verify output/result.json.",
+      },
+    },
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    {
+      toolName: "write_file",
+      ok: true,
+      path: "output/result.json",
+      changes: [
+        {
+          path: "output/result.json",
+          created: true,
+          beforeHash: "",
+          afterHash: "requested-output",
+        },
+      ],
+    },
+    { commandCwd: workspace, taskProfile: "auto" }
+  );
+  const requestedOutputRevision =
+    scopedTaskState.meta.projectVerification?.mutationRevision;
+  const readOnlyArtifactValidation = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command:
+        "python3 -c \"import json; d=json.load(open('output/result.json')); assert d; print('PASS valid JSON')\"",
+    },
+    projectMutationPaths: [],
+    stdout: "PASS valid JSON\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    readOnlyArtifactValidation,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    {
+      toolName: "write_file",
+      ok: true,
+      path: path.join(scopedTaskRoot, "agent-result.json"),
+      changes: [
+        {
+          path: path.join(scopedTaskRoot, "agent-result.json"),
+          created: true,
+          beforeHash: "",
+          afterHash: "delivery-manifest",
+        },
+      ],
+    },
+    { commandCwd: workspace, taskProfile: "auto" }
+  );
+  const scopedManifestCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: `printf '%s\\n' '{}' > ${JSON.stringify(
+        path.join(scopedTaskRoot, "agent-result.json")
+      )}`,
+    },
+    stdout: "",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    scopedManifestCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  const pythonScopedManifestCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: [
+        "python3 - <<'PY'",
+        `out = ${JSON.stringify(path.join(scopedTaskRoot, "agent-result.json"))}`,
+        "with open(out, 'w', encoding='utf-8') as handle:",
+        "    handle.write('{}')",
+        "PY",
+      ].join("\n"),
+    },
+    projectMutationPaths: [],
+    stdout: "",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    pythonScopedManifestCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  assert(
+    requestedOutputRevision === 1 &&
+      scopedTaskState.meta.projectVerification?.mutationRevision === 1 &&
+      readOnlyArtifactValidation.readOnlyArtifactValidation === true &&
+      scopedManifestCommand.scopedTaskArtifactWrite === true &&
+      pythonScopedManifestCommand.scopedTaskArtifactWrite === true,
+    "task-scoped delivery bookkeeping invalidated requested artifact evidence"
+  );
+  const mutatingInlinePython = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: "python3 -c \"open('output/side.txt','w').write('changed')\"",
+    },
+    projectMutationPaths: [],
+    stdout: "",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    mutatingInlinePython,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  assert(
+    scopedTaskState.meta.projectVerification?.mutationRevision === 2 &&
+      mutatingInlinePython.readOnlyArtifactValidation !== true,
+    "write-capable inline Python was incorrectly classified as read-only validation"
+  );
   const privateVerifierCommand =
     "python3 .aginti/verification/lifecycle/smoke_test.py";
   const privateVerifierState = {
@@ -8080,6 +8241,34 @@ try {
       sourceGroundingRefreshState.meta.activeExecutionContract.requiresSourceGrounding === true,
     "a concrete file correction did not require current source grounding"
   );
+  const scopedStaticArtifactRequest =
+    "Create and verify output/parity/result.json with one JSON object. Read it back and finish.";
+  const scopedStaticArtifactGoal = [
+    "You are the persistent LabCanvas agent.",
+    `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+      mode: "task",
+      request: scopedStaticArtifactRequest,
+      artifact_root: "/tmp/labcanvas-task-1",
+    })}`,
+    "Read AGENTS.md and inspect implementation before editing.",
+  ].join("\n\n");
+  const scopedStaticArtifactState = {
+    goal: scopedStaticArtifactGoal,
+    meta: {
+      taskProfile: "auto",
+      goalContract: {
+        revision: 10,
+        currentRequest: scopedStaticArtifactGoal,
+      },
+      projectVerification: { mutationRevision: 0 },
+    },
+  };
+  resetSameTaskExecutionContract(scopedStaticArtifactState, 10);
+  assert(
+    scopedStaticArtifactState.meta.activeExecutionContract.requiresFileMutation === true &&
+      scopedStaticArtifactState.meta.activeExecutionContract.requiresSourceGrounding === false,
+    "LabCanvas wrapper instructions leaked into the scoped static-artifact execution contract"
+  );
   const concreteBudgetConfig = { maxSteps: 81, resetStepBudget: false };
   assert(
     applyConcreteContinuationStepBudgetBoundary(
@@ -11426,6 +11615,29 @@ try {
   );
   assert(artifactProgress.justActivated, "exact output mutation did not activate artifact validation");
   assert(artifactState.meta.artifactProgress.complete, "exact output progress was not persisted");
+  const commandArtifactState = {
+    meta: {
+      scs: {
+        taskContract: {
+          exactOutputPaths: ["output/generated.json"],
+        },
+      },
+    },
+  };
+  const commandArtifactProgress = recordExactOutputProgress(
+    commandArtifactState,
+    {
+      ok: true,
+      toolName: "run_command",
+      verifiedGeneratedOutputPaths: ["output/generated.json"],
+    },
+    { commandCwd: workspace }
+  );
+  assert(
+    commandArtifactProgress.justActivated &&
+      commandArtifactState.meta.artifactProgress.complete,
+    "snapshot-verified shell output did not activate exact artifact progress"
+  );
   assert(
     nextStepRuntimeConfig({ provider: "localllm" }, artifactState).artifactValidationPhase === true,
     "next step did not enter artifact validation mode"

package/scripts/smoke-execution-policy.js

@@ -15,6 +15,8 @@ import {
 } from "../src/context-budget-controller.js";
 import { maxStepsForExecutionPolicy, selectExecutionPolicy } from "../src/execution-policy.js";
 import { SessionStore } from "../src/session-store.js";
+import { selectSkillsForGoal } from "../src/skill-library.js";
+import { scopedChatopsEvidenceGoal } from "../src/scs-evidence.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-execution-policy-"));
@@ -97,6 +99,46 @@ try {
   assert(responseOnlyConfig.executionTier === "focused", "response-only runtime did not select focused execution");
   assert(!responseOnlyConfig.executionPolicy.requiresPlan, "response-only runtime still requires a plan");
 
+  const scopedArtifactGoal = [
+    "LabCanvas host wrapper: use browser automation, deep research, source ingestion, and recovery skills when relevant.",
+    "General host guidance: inspect complex repositories carefully and create a plan for difficult work.",
+    `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+      mode: "task",
+      request: "Create and verify output/parity/scoped-artifact.json with one valid JSON object.",
+    })}`,
+  ].join("\n");
+  const scopedArtifactConfig = resolveRuntimeConfig(
+    {
+      provider: "mock",
+      routingMode: "smart",
+      model: "mock-agent",
+      goal: scopedArtifactGoal,
+      taskProfile: "auto",
+      enableScs: "auto",
+    },
+    {
+      baseDir: runtimeDir,
+      packageDir: repoRoot,
+      provider: "mock",
+      routingMode: "smart",
+      model: "mock-agent",
+    }
+  );
+  assert(
+    scopedArtifactConfig.executionTier === "focused" && !scopedArtifactConfig.executionPolicy.requiresPlan,
+    "host wrapper keywords inflated a scoped static-artifact task into planned execution"
+  );
+  assert(!scopedArtifactConfig.scsActive, "host wrapper keywords incorrectly activated SCS for a scoped static artifact");
+  const scopedSkillIds = selectSkillsForGoal(
+    scopedChatopsEvidenceGoal(scopedArtifactGoal, "auto"),
+    { taskProfile: "auto", limit: 6, projectRoot: workspace }
+  ).map((skill) => skill.id);
+  assert(scopedSkillIds.includes("structured-json"), "scoped JSON task did not retain its relevant structured-data skill");
+  assert(
+    !scopedSkillIds.some((id) => ["source-ingestion", "autonomous-artifact-pipeline", "wechat-labcanvas-chatops"].includes(id)),
+    `literal paths or payload values selected unrelated skills: ${scopedSkillIds.join(", ")}`
+  );
+
   const simpleConfig = resolveRuntimeConfig(
     {
       provider: "mock",

package/scripts/smoke-model-roles.js

@@ -807,6 +807,17 @@ const readinessOnlyContract = deriveScsTaskContract({
   ].join("\n"),
   taskProfile: "auto",
 });
+const releaseProofFilenameContract = deriveScsTaskContract({
+  goal: [
+    'AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create a task-owned plain-text artifact named scoped-path-release-proof.txt, read it back, and finish without external actions."}',
+    "The host writes a final task record after the agent finishes.",
+  ].join("\n"),
+  taskProfile: "auto",
+});
+const explicitPackageReleaseContract = deriveScsTaskContract({
+  goal: "Release the package to npm and verify the published version.",
+  taskProfile: "auto",
+});
 assert(
   readinessOnlyContract.requiredEvidence.some((item) => item.category === "file") &&
     readinessOnlyContract.requiredEvidence.some((item) => item.category === "command"),
@@ -816,6 +827,15 @@ assert(
   !readinessOnlyContract.requiredEvidence.some((item) => ["publish", "browser", "visual", "artifact"].includes(item.category)),
   "read-only readiness contract required a forbidden external action or target artifact"
 );
+assert(
+  releaseProofFilenameContract.requiredEvidence.some((item) => item.category === "file") &&
+    !releaseProofFilenameContract.requiredEvidence.some((item) => item.category === "publish"),
+  "a release-like artifact filename fabricated an external publication obligation"
+);
+assert(
+  explicitPackageReleaseContract.requiredEvidence.some((item) => item.category === "publish"),
+  "an explicit package release lost its publication evidence obligation"
+);
 assert(
   uploadContract.exactInputPaths.includes("/tmp/reference-a.png") &&
     uploadContract.exactInputPaths.includes("/tmp/reference-b.png") &&
@@ -1131,6 +1151,13 @@ const canvasArtifactContract = deriveScsTaskContract({
 const jsonObjectContract = deriveScsTaskContract({
   goal: "Extract a valid JSON object with schema from this text.",
 });
+const scopedStaticJsonContract = deriveScsTaskContract({
+  goal: [
+    "Host wrapper: validate code, run commands, inspect browsers, and perform deep research when the request needs them.",
+    'AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create and verify output/parity/aginti_verified_artifact.json with one valid JSON object, then read it back."}',
+  ].join("\n"),
+  taskProfile: "code",
+});
 const virtualFileContract = deriveScsTaskContract({
   goal: "Create file: /workspace/virtual-output.txt with virtual Docker path support.",
 });
@@ -1210,6 +1237,20 @@ assert(
   !jsonObjectContract.requiredEvidence.some((item) => item.category === "file"),
   "JSON object extraction should not be treated as a workspace file requirement without an explicit file/path"
 );
+assert(
+  scopedStaticJsonContract.requiredEvidence.some((item) => item.category === "file") &&
+    !scopedStaticJsonContract.requiredEvidence.some((item) => item.category === "command"),
+  "a scoped standalone JSON artifact should require file evidence without an unrelated shell command"
+);
+assert(
+  scopedStaticJsonContract.exactOutputPaths.includes("output/parity/aginti_verified_artifact.json") &&
+    !scopedStaticJsonContract.exactInputPaths.includes("output/parity/aginti_verified_artifact.json"),
+  "create-and-verify should retain the structured-data path as an output rather than an input"
+);
+assert(
+  scopedStaticJsonContract.requiredExecutableTerms.length === 0,
+  "a required JSON boolean value was misclassified as executable production-source syntax"
+);
 assert(
   virtualFileContract.requiredEvidence.some((item) => item.category === "file") &&
     !virtualFileContract.requiredEvidence.some((item) => item.category === "artifact"),

package/src/agent-runner.js

@@ -364,11 +364,14 @@ function textToolRetryInstruction(response) {
 
 function buildScsRuntimeContext(config = {}, state = {}, extra = {}) {
   const projectRoot = config.commandCwd || config.baseDir || process.cwd();
-  const selectedSkills = isRetainedWorkspaceProfile(config) ? [] : selectSkillsForGoal(state.goal || config.goal || "", {
-    taskProfile: config.taskProfile,
-    limit: 6,
-    projectRoot,
-  });
+  const selectedSkills = isRetainedWorkspaceProfile(config) ? [] : selectSkillsForGoal(
+    scopedChatopsEvidenceGoal(state.goal || config.goal || "", config.taskProfile),
+    {
+      taskProfile: config.taskProfile,
+      limit: 6,
+      projectRoot,
+    }
+  );
   const verification = state.meta?.projectVerification || {};
   const mutationRevision = Number(verification.mutationRevision || 0);
   const privateMutationRevision = Number(verification.privateMutationRevision || 0);
@@ -435,11 +438,14 @@ function buildScsRuntimeContext(config = {}, state = {}, extra = {}) {
 
 function withSelectedSkillReadOnlyRoots(config = {}, state = {}) {
   const projectRoot = config.commandCwd || config.baseDir || process.cwd();
-  const selectedSkills = isRetainedWorkspaceProfile(config) ? [] : selectSkillsForGoal(state.goal || config.goal || "", {
-    taskProfile: config.taskProfile,
-    limit: 6,
-    projectRoot,
-  });
+  const selectedSkills = isRetainedWorkspaceProfile(config) ? [] : selectSkillsForGoal(
+    scopedChatopsEvidenceGoal(state.goal || config.goal || "", config.taskProfile),
+    {
+      taskProfile: config.taskProfile,
+      limit: 6,
+      projectRoot,
+    }
+  );
   const skillReadOnlyRoots = [
     ...(Array.isArray(config.skillReadOnlyRoots) ? config.skillReadOnlyRoots : []),
     ...selectedSkills.map((skill) => skill.path).filter(Boolean),
@@ -2891,7 +2897,11 @@ async function createInitialState(config, sessionId) {
   const projectRoot = config.commandCwd || config.baseDir || process.cwd();
   const selectedSkills = isRetainedWorkspaceProfile(config)
     ? []
-    : selectSkillsForGoal(config.goal, { taskProfile: config.taskProfile, limit: 6, projectRoot });
+    : selectSkillsForGoal(scopedChatopsEvidenceGoal(config.goal, config.taskProfile), {
+        taskProfile: config.taskProfile,
+        limit: 6,
+        projectRoot,
+      });
   const skillContext = formatSkillsForPrompt(selectedSkills);
   const projectInstructions = await readProjectInstructions(config.baseDir || config.commandCwd || process.cwd());
   const projectInstructionContext = formatProjectInstructions(projectInstructions);
@@ -4050,9 +4060,12 @@ export function resetSameTaskExecutionContract(state = {}, revision = 0) {
   refreshPersistedProjectAcceptance(state);
   const activeRevision = Math.max(0, Number(revision || state.meta?.goalContract?.revision || 0));
   const currentRequest = String(state.meta?.goalContract?.currentRequest || state.goal || "").trim();
+  const taskProfile = state.meta?.taskProfile || "auto";
+  const scopedCurrentRequest =
+    scopedChatopsEvidenceGoal(currentRequest, taskProfile) || currentRequest;
   const currentTurnContract = deriveScsTaskContract({
-    goal: currentRequest,
-    taskProfile: state.meta?.taskProfile || "auto",
+    goal: scopedCurrentRequest,
+    taskProfile,
   });
   const currentTurnCommands = normalizedRequiredProjectCommands(
     currentTurnContract.requiredProjectCommands
@@ -4094,7 +4107,7 @@ export function resetSameTaskExecutionContract(state = {}, revision = 0) {
       currentTurnContract.requiresSourceGrounding === true ||
         (
           currentTurnContract.requiresFileMutation === true &&
-          goalClearlyAllowsOverwrite(currentRequest)
+          goalClearlyAllowsOverwrite(scopedCurrentRequest)
         )
     ),
     requiredProjectCommands: currentTurnCommands,
@@ -4208,7 +4221,11 @@ async function applyContinuationPrompt(state, config, observers) {
   const projectRoot = config.commandCwd || config.baseDir || process.cwd();
   const selectedSkills = isRetainedWorkspaceProfile(config)
     ? []
-    : selectSkillsForGoal(config.goal, { taskProfile: config.taskProfile, limit: 6, projectRoot });
+    : selectSkillsForGoal(scopedChatopsEvidenceGoal(config.goal, config.taskProfile), {
+        taskProfile: config.taskProfile,
+        limit: 6,
+        projectRoot,
+      });
   const skillContext = formatSkillsForPrompt(selectedSkills);
   const projectInstructions = await readProjectInstructions(config.baseDir || config.commandCwd || process.cwd());
   state.meta = state.meta || {};
@@ -6384,9 +6401,9 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
     }
   }
 
-  const projectMutationPaths = successfulProjectMutationPaths(toolResult);
+  const projectMutationPaths = successfulProjectMutationPaths(toolResult, state, config);
   const privateMutationPaths = successfulPrivateVerificationMutationPaths(toolResult);
-  const materialMutationPaths = materialProjectMutationPaths(toolResult);
+  const materialMutationPaths = materialProjectMutationPaths(toolResult, state, config);
   if (["write_file", "apply_patch"].includes(toolName) && privateMutationPaths.length) {
     delete state.meta.verifiedCompletionCandidate;
     verification.privateMutationRevision += 1;
@@ -6549,12 +6566,23 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
         config,
         { verificationCommand }
       );
+    const scopedTaskArtifactWrite = commandWritesOnlyScopedTaskArtifacts(
+      mutationCommand,
+      state,
+      config
+    );
+    const readOnlyArtifactValidation = Boolean(
+      commandMutationPaths.length === 0 &&
+        commandIsBoundedReadOnlyArtifactValidation(mutationCommand)
+    );
     const projectContentMutation = Boolean(
       command &&
         toolResult.blocked !== true &&
         !retainedExactVerification &&
         !disposableGeneratedCleanup &&
         !disposableGeneratedVerificationSideEffects &&
+        !scopedTaskArtifactWrite &&
+        !readOnlyArtifactValidation &&
         (commandSucceeded || commandMutationPaths.length > 0) &&
         (
           commandCanMutateProjectContent(mutationCommand, commandPolicy) ||
@@ -6569,6 +6597,12 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
       toolResult.disposableGeneratedVerificationSideEffects = true;
       toolResult.disposableGeneratedVerificationPaths = commandMutationPaths;
     }
+    if (scopedTaskArtifactWrite) {
+      toolResult.scopedTaskArtifactWrite = true;
+    }
+    if (readOnlyArtifactValidation) {
+      toolResult.readOnlyArtifactValidation = true;
+    }
     let requiredBatch = currentRequiredCommandBatch(verification, requiredCommands);
     const activeExecutionContract = state.meta?.activeExecutionContract;
     const activeTurnCommands =
@@ -12084,7 +12118,27 @@ function isPrivateVerificationEvidencePath(value = "") {
   );
 }
 
-function commandWritesOnlyPrivateVerificationEvidence(command = "") {
+function isScopedTaskArtifactEvidencePath(value = "", state = {}, config = {}) {
+  const artifactRoot = scopedArtifactRoot(completionContractGoal(config, state));
+  if (!artifactRoot) return false;
+  const raw = String(value || "")
+    .trim()
+    .replace(/^(["'])|(["'])$/g, "")
+    .replace(/\\/g, "/");
+  if (!raw || raw.includes("\0") || /^https?:\/\//i.test(raw)) return false;
+  const commandCwd = path.resolve(
+    config.commandCwd || state.commandCwd || process.cwd()
+  );
+  const absoluteRoot = path.resolve(commandCwd, artifactRoot);
+  const absoluteCandidate = path.resolve(commandCwd, raw);
+  const relative = path.relative(absoluteRoot, absoluteCandidate);
+  return Boolean(
+    relative === "" ||
+      (!relative.startsWith("..") && !path.isAbsolute(relative))
+  );
+}
+
+function commandWritesOnlyEvidenceMatching(command = "", pathMatches = () => false) {
   const normalized = String(command || "").trim();
   if (!normalized) return false;
   const tokens = tokenizeShellWords(normalized);
@@ -12093,27 +12147,97 @@ function commandWritesOnlyPrivateVerificationEvidence(command = "") {
     if (["-a", "--append"].includes(tokens[index])) index += 1;
     if (tokens[index] === "--") index += 1;
     const targets = tokens.slice(index);
-    return targets.length > 0 && targets.every(isPrivateVerificationEvidencePath);
+    return targets.length > 0 && targets.every(pathMatches);
   }
   if (tokens[0] === "mkdir") {
     const targets = tokens.slice(1).filter((token) => token !== "-p" && token !== "--");
-    return targets.length > 0 && targets.every(isPrivateVerificationEvidencePath);
+    return targets.length > 0 && targets.every(pathMatches);
   }
 
-  let strippedPrivateRedirect = false;
-  const withoutPrivateRedirects = normalized.replace(
+  let strippedEvidenceRedirect = false;
+  const withoutEvidenceRedirects = normalized.replace(
     /(^|\s)(?:\d*>>?|&>>?)\s*("[^"]+"|'[^']+'|[^\s;&|]+)/g,
     (match, prefix, target) => {
-      if (!isPrivateVerificationEvidencePath(target)) return match;
-      strippedPrivateRedirect = true;
+      if (!pathMatches(target)) return match;
+      strippedEvidenceRedirect = true;
       return prefix;
     }
   ).trim();
-  if (!strippedPrivateRedirect || !withoutPrivateRedirects) return false;
-  const underlyingPolicy = classifyCommand(withoutPrivateRedirects);
+  if (!strippedEvidenceRedirect || !withoutEvidenceRedirects) return false;
+  const underlyingPolicy = classifyCommand(withoutEvidenceRedirects);
   return underlyingPolicy.writesWorkspace !== true && underlyingPolicy.mayMutateProject !== true;
 }
 
+function commandWritesOnlyPrivateVerificationEvidence(command = "") {
+  return commandWritesOnlyEvidenceMatching(
+    command,
+    isPrivateVerificationEvidencePath
+  );
+}
+
+function commandWritesOnlyScopedTaskArtifacts(command = "", state = {}, config = {}) {
+  if (commandWritesOnlyEvidenceMatching(
+    command,
+    (candidate) => isScopedTaskArtifactEvidencePath(candidate, state, config)
+  )) {
+    return true;
+  }
+  const normalized = String(command || "").trim();
+  const artifactRoot = scopedArtifactRoot(completionContractGoal(config, state));
+  if (!normalized || !artifactRoot) return false;
+  const assignments = new Map();
+  for (const match of normalized.matchAll(
+    /\b([A-Za-z_]\w*)\s*=\s*("[^"\n]+"|'[^'\n]+')/g
+  )) {
+    assignments.set(match[1], match[2]);
+  }
+  const writeTargets = [];
+  for (const match of normalized.matchAll(
+    /\bopen\s*\(\s*([^,\n]+)\s*,\s*(["'][^"']*[wax+][^"']*["'])/gi
+  )) {
+    const operand = String(match[1] || "").trim();
+    const target = assignments.get(operand) || operand;
+    if (!/^(?:"[^"\n]+"|'[^'\n]+')$/.test(target)) return false;
+    writeTargets.push(target);
+  }
+  return Boolean(
+    writeTargets.length > 0 &&
+      writeTargets.every((candidate) =>
+        isScopedTaskArtifactEvidencePath(candidate, state, config)
+      )
+  );
+}
+
+function commandIsBoundedReadOnlyArtifactValidation(command = "") {
+  const normalized = String(command || "").trim();
+  if (!normalized) return false;
+  if (
+    !/\bassert\b|\bjson\.(?:load|loads)\s*\(|\bJSON\.parse\s*\(|\bjq\b|\bsha256sum\b|\bmd5sum\b|\b(?:valid|pass|verified?)\b/i.test(
+      normalized
+    )
+  ) {
+    return false;
+  }
+  // Heredoc input (`<<`) is compatible with read-only validation. Any output
+  // redirection or known mutator keeps conservative project revision tracking.
+  if (/(^|[^<])>{1,2}(?!=)/m.test(normalized)) return false;
+  if (
+    /\b(?:cp|install|mkdir|mv|rm|rmdir|tee|touch|truncate)\b|\bsed\s+-i\b|\bperl\s+-pi\b/i.test(
+      normalized
+    )
+  ) {
+    return false;
+  }
+  if (
+    /\bopen\s*\([^\n)]*,\s*["'][^"']*[wax+][^"']*["']|\.(?:append|mkdir|rename|replace|rmdir|touch|unlink|write|write_bytes|write_text)\s*\(|\b(?:os\.(?:makedirs|mkdir|remove|rename|replace|rmdir|system|unlink)|shutil\.|subprocess\.)/i.test(
+      normalized
+    )
+  ) {
+    return false;
+  }
+  return true;
+}
+
 const DISPOSABLE_GENERATED_PATH_SEGMENTS = new Set([
   ".build",
   ".gradle",
@@ -12974,6 +13098,17 @@ export function canonicalizeVerifiedArtifactCompletion(state = {}, result = "")
 function successfulMutationPaths(toolResult = {}) {
   if (!toolResult || toolResult.ok === false || toolResult.blocked || toolResult.skipped) return [];
   if (toolResult.toolName === "deep_research" && toolResult.reportPath) return [toolResult.reportPath];
+  if (toolResult.toolName === "run_command") {
+    return [
+      ...new Set(
+        (Array.isArray(toolResult.verifiedGeneratedOutputPaths)
+          ? toolResult.verifiedGeneratedOutputPaths
+          : [])
+          .map((item) => String(item || "").trim())
+          .filter(Boolean)
+      ),
+    ];
+  }
   if (!["write_file", "apply_patch"].includes(String(toolResult.toolName || ""))) return [];
   const changes = [
     ...(Array.isArray(toolResult.changes) ? toolResult.changes : []),
@@ -13026,9 +13161,11 @@ function successfulWorkspaceMutationPaths(toolResult = {}) {
   ];
 }
 
-function successfulProjectMutationPaths(toolResult = {}) {
+function successfulProjectMutationPaths(toolResult = {}, state = {}, config = {}) {
   return successfulWorkspaceMutationPaths(toolResult).filter(
-    (candidate) => !isPrivateVerificationEvidencePath(candidate)
+    (candidate) =>
+      !isPrivateVerificationEvidencePath(candidate) &&
+      !isScopedTaskArtifactEvidencePath(candidate, state, config)
   );
 }
 
@@ -13052,7 +13189,7 @@ function diffHasMaterialContentChange(diff = "") {
   return JSON.stringify(compactRemoved) !== JSON.stringify(compactAdded);
 }
 
-function materialProjectMutationPaths(toolResult = {}) {
+function materialProjectMutationPaths(toolResult = {}, state = {}, config = {}) {
   if (!toolResult || toolResult.blocked || toolResult.skipped) {
     return [];
   }
@@ -13065,7 +13202,13 @@ function materialProjectMutationPaths(toolResult = {}) {
   ];
   const paths = [];
   for (const change of changes) {
-    if (!change || isPrivateVerificationEvidencePath(change.path)) continue;
+    if (
+      !change ||
+      isPrivateVerificationEvidencePath(change.path) ||
+      isScopedTaskArtifactEvidencePath(change.path, state, config)
+    ) {
+      continue;
+    }
     if (
       change.created === true ||
       change.deleted === true ||
@@ -18472,7 +18615,7 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         const isRequiredCommand = requiredCommands.some((candidate) =>
           projectCommandsEquivalent(candidate, observedInnerCommand, config)
         );
-        const exactOutputSnapshotsBefore = isRequiredCommand && policy.writesWorkspace
+        const exactOutputSnapshotsBefore = policy.writesWorkspace && exactOutputPathsForState(state).length
           ? await captureExactOutputSnapshots(state, config)
           : [];
         const gitWorktreeBefore = captureMutationScope
@@ -18562,6 +18705,16 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         const eventResult = sanitizeToolResult(result);
         await store.appendEvent("tool.completed", eventResult);
         observers.event("tool.completed", eventResult);
+        for (const generatedPath of generatedOutputPaths) {
+          const change = {
+            path: generatedPath,
+            toolName: "run_command",
+            commandCwd: config.commandCwd,
+            generatedByCommand: true,
+          };
+          await store.appendEvent("file.changed", change);
+          observers.event("file.changed", change);
+        }
         return result;
       }
       case "tmux_list_sessions": {
@@ -19848,6 +20001,11 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
   const blocker = deterministicFinishBlocker(assessment.contract, assessment.ledger, assessment.evaluation);
   const verificationDeficits = projectVerificationDeficits(state, config);
   const requiredEvidence = (assessment.contract.requiredEvidence || []).map((item) => item.category);
+  const requiresProjectTestEvidence = Boolean(
+    requiredEvidence.includes("test") ||
+      projectTestBlock ||
+      verificationDeficits.failedTestRun
+  );
   const presentEvidence = assessment.ledger.categories || [];
   const progressCount = Number(assessment.progressCount || 0);
   const semanticFailureReason = assessment.semantic.checked && !assessment.semantic.ok
@@ -19881,8 +20039,13 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
       freshMutationRequirement.artifactQualityRepairRequired,
     missingToolCalls: assessment.evaluation.missingToolCalls || [],
     pendingProjectCommands: verificationDeficits.pendingCommands,
-    pendingProjectTests: verificationDeficits.testsCurrent ? [] : verificationDeficits.discoveredTests,
-    suggestedTestCommands: verificationDeficits.suggestedTestCommands,
+    pendingProjectTests:
+      requiresProjectTestEvidence && !verificationDeficits.testsCurrent
+        ? verificationDeficits.discoveredTests
+        : [],
+    suggestedTestCommands: requiresProjectTestEvidence
+      ? verificationDeficits.suggestedTestCommands
+      : [],
     projectMutationRevision: verificationDeficits.revision,
     failedProjectTestCommand: verificationDeficits.failedTestRun?.command || "",
     failedProjectTestSignature: verificationDeficits.failedTestRun?.failureSignature || "",
@@ -23182,7 +23345,7 @@ async function runAgentOnceUnlocked(config) {
 
   try {
     throwIfAborted(config);
-    const goalIntent = classifyGoalIntent(config.goal);
+    const goalIntent = classifyGoalIntent(scopedChatopsEvidenceGoal(config.goal, config.taskProfile));
     const canFinishDirectly =
       !config.resume && !state.plan && Number(state.stepsCompleted || 0) === 0 && isDirectAnswerIntent(goalIntent);
     if (canFinishDirectly) {

package/src/config.js

@@ -25,7 +25,7 @@ import { normalizeDynamicStepsMode } from "./step-budget-controller.js";
 import { maxStepsForExecutionPolicy, selectExecutionPolicy } from "./execution-policy.js";
 import { normalizeContextBudgetMode } from "./context-budget-controller.js";
 import { BASELINE_PROVIDER, normalizeProviderBaseURL, normalizeProviderId } from "./provider-contract.js";
-import { isResponseOnlyEvidenceScope } from "./scs-evidence.js";
+import { isResponseOnlyEvidenceScope, scopedChatopsEvidenceGoal } from "./scs-evidence.js";
 
 function parseBoolean(value, fallback) {
   if (value === undefined) return fallback;
@@ -101,6 +101,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
   const requestedProvider = resolveRequestedProvider(overrides, args);
   const routingMode = normalizeRoutingMode(overrides.routingMode || args.routingMode || process.env.AGENT_ROUTING_MODE || "smart");
   const taskProfile = normalizeTaskProfile(overrides.taskProfile || args.taskProfile || process.env.AGINTI_TASK_PROFILE || "auto");
+  const taskSelectionGoal = scopedChatopsEvidenceGoal(args.goal || "", taskProfile);
   const language = resolveLanguage(overrides.language || args.language || process.env.AGINTI_LANGUAGE || "");
   // Capability/resource snapshots are trusted runtime inputs. They are deliberately
   // not inferred from ambient cloud credentials or optimistic environment flags.
@@ -141,7 +142,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     routingMode: sessionModelLocked ? "manual" : routingMode,
     provider: requestedProvider,
     model: requestedModel,
-    goal: args.goal || "",
+    goal: taskSelectionGoal,
     taskProfile,
     routeProvider,
     routeModel: overrides.routeModel || args.routeModel || process.env.AGINTI_ROUTE_MODEL || "",
@@ -190,7 +191,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     overrides.scsValidationMode ?? args.scsValidationMode ?? process.env.AGINTI_SCS_VALIDATION_MODE ?? "auto"
   );
   const scsActive = shouldActivateScs(scsMode, {
-    goal: args.goal || "",
+    goal: taskSelectionGoal,
     taskProfile,
     complexityScore: route.complexityScore,
   });
@@ -226,7 +227,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
       ? normalizeProviderBaseURL(activeProvider, overrides.baseURL || defaults.baseURL)
       : overrides.baseURL || defaults.baseURL;
   const defaultMaxSteps = recommendedMaxStepsForTask({
-    goal: args.goal || "",
+    goal: taskSelectionGoal,
     taskProfile,
     complexityScore: route.complexityScore,
   });

package/src/model-client.js

@@ -31,6 +31,7 @@ import {
   estimateToolSchemaTokens,
 } from "./context-budget-controller.js";
 import { attachToolContract } from "./tool-contract.js";
+import { scopedChatopsEvidenceGoal } from "./scs-evidence.js";
 
 function isRetainedWorkspaceProfile(config = {}) {
   return config.integrationSessionProfile === INTEGRATION_TEXT_WORKSPACE_PROFILE_ID ||
@@ -1241,11 +1242,14 @@ export async function createPlan(client, config, state) {
   const engineeringGuidance = isRetainedWorkspaceProfile(config)
     ? ""
     : engineeringGuidanceForTask(state.goal, config.taskProfile);
-  const selectedSkills = isRetainedWorkspaceProfile(config) ? [] : selectSkillsForGoal(state.goal, {
-    taskProfile: config.taskProfile,
-    limit: 5,
-    projectRoot: config.commandCwd || config.baseDir || process.cwd(),
-  });
+  const selectedSkills = isRetainedWorkspaceProfile(config) ? [] : selectSkillsForGoal(
+    scopedChatopsEvidenceGoal(state.goal, config.taskProfile),
+    {
+      taskProfile: config.taskProfile,
+      limit: 5,
+      projectRoot: config.commandCwd || config.baseDir || process.cwd(),
+    }
+  );
   const skillContext = formatSkillsForPrompt(selectedSkills);
   const projectInstructions = state.meta?.projectInstructions;
   const platform = platformInfo();

package/src/scs-controller.js

@@ -277,6 +277,15 @@ export function shouldActivateScs(mode = "off", context = {}) {
   const profile = String(context.taskProfile || "").toLowerCase();
   const goal = String(context.goal || "");
   if (SCS_AUTO_PROFILES.has(profile)) return true;
+  const staticDataPaths = goal.match(/(?:^|[\s`'"(])[^\s`'"()]+\.(?:csv|json|toml|ya?ml)\b/gi) || [];
+  const simpleStaticDataWrite =
+    staticDataPaths.length === 1 &&
+    /\b(?:create|emit|generate|save|write)\b/i.test(goal) &&
+    !/\b(?:app|application|build|cli|code|codebase|compile|database|dataset|deploy|implement|library|migrate|package|publish|refactor|release|repository|script|server|source|test|upload)\b/i.test(
+      goal
+    ) &&
+    Number(context.complexityScore || 0) < 3;
+  if (simpleStaticDataWrite) return false;
   if (SCS_AUTO_HINTS.some((hint) => hint.test(goal))) return true;
   return Number(context.complexityScore || 0) >= 5;
 }

package/src/scs-evidence.js

@@ -538,7 +538,10 @@ function inferExactOutputPaths(goal = "") {
     if (!isOutputListItem && !hasDirectOutputAction) continue;
     const sourceLine = !isOutputListItem && hasDirectOutputAction ? line.slice(directOutputIndex) : line;
     if (!isOutputListItem && negatedOutputLine.test(sourceLine)) continue;
-    if (!isOutputListItem && nonOutputToolLine.test(sourceLine)) continue;
+    const verifierIndex = line.search(/\b(?:validate|verify|check|compile|run|execute)\b/i);
+    if (!isOutputListItem && nonOutputToolLine.test(line) && verifierIndex >= 0 && verifierIndex < directOutputIndex) {
+      continue;
+    }
     if (!isOutputListItem && /\boutput\s+(?:subfolders?|directories|folders?|paths?)\b/i.test(sourceLine)) continue;
     const outputDirMatch = sourceLine.match(/(?:to|at|in|under|到|至|在)\s*([^\s，,、；;。]+\/)/i);
     activeOutputDir = outputDirMatch?.[1] || "";
@@ -962,6 +965,12 @@ export function inferRequiredExecutableTerms(goal = "") {
     if (executableRequirementIsNegated(source, index)) continue;
     if (indexFallsInsideInlineCommand(source, index)) continue;
     const window = source.slice(Math.max(0, index - 180), Math.min(source.length, index + match[0].length + 220));
+    const structuredDataLiteral =
+      /\b(?:csv|json|toml|ya?ml)\b/i.test(window) &&
+      !/\b(?:actual|canonical|executable|implementation|source\s+code|function|call|argument|parameter|repair|fix|replace)\b/i.test(
+        window
+      );
+    if (structuredDataLiteral) continue;
     const implementationRequirement =
       /\b(?:actual|canonical|executable|implementation|source|code|call|argument|keyword|parameter|repair|fix|correct|replace|add|set|pass|use|must|required)\b/iu.test(window) ||
       /实际|實際|实现|實現|源码|源碼|代码|代碼|调用|調用|参数|參數|修复|修復|改正|替换|替換|添加|设置|設定|使用|必须|必須|実装|ソース|コード|呼び出し|引数|修正|置換|追加|設定|使用/.test(window);
@@ -1229,12 +1238,22 @@ function codeProfileRequiresCommand(goal = "") {
     /\b(?:note|notes?|markdown|readme|documentation|text file)\b/.test(text) ||
     /\bnotes?\/[^\s]+\.(?:md|txt)\b/.test(text) ||
     /\.(?:md|txt)\b/.test(text);
+  const structuredDataProse = text.replace(
+    /(?:^|[\s`'"(])[^\s`'"()]+\.(?:csv|json|toml|ya?ml)\b/g,
+    " "
+  );
+  const simpleStructuredDataWrite =
+    /\.(?:csv|json|toml|ya?ml)\b/.test(text) &&
+    /\b(?:create|emit|generate|save|write)\b/.test(text) &&
+    !/\b(?:app|application|build|cli|code|codebase|compile|execute|function|implement|library|lint|package|refactor|run|script|server|source|test|typecheck)\b/.test(
+      structuredDataProse
+    );
   const substantiveCodeWork =
     /\b(?:fix|repair|bug|implement|feature|refactor|test|run|build|compile|lint|typecheck|verify|validate|package|library|cli|api server|app|application|script|codebase|src\/|source code)\b/.test(
       text
     ) ||
     /\.(?:js|jsx|ts|tsx|mjs|cjs|py|rs|go|java|kt|swift|rb|php|cs|cpp|c|h|hpp|sh)\b/.test(text);
-  return substantiveCodeWork && !simpleDocumentWrite;
+  return substantiveCodeWork && !simpleDocumentWrite && !simpleStructuredDataWrite;
 }
 
 function goalRequestsExplicitTestMutation(text = "") {
@@ -1439,7 +1458,17 @@ function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCrite
   ) {
     categories.add("visual");
   }
-  if (textHas(text, /\b(publish|deploy|submit|upload to|generate video|external service|npm publish|release)\b/) || /发布|部署|提交|生成视频|外部服务/.test(text)) {
+  const explicitPublishAction =
+    textHas(
+      text,
+      /\b(?:publish|deploy|submit|upload to|generate video|external service|npm publish)\b/
+    ) ||
+    textHas(
+      text,
+      /\b(?:release|ship)\s+(?:(?:the|this|that|a|an)\s+)?(?:package|version|build|app|application|software|library|plugin|extension|product)\b|\b(?:release|ship)\s+(?:to|on|via|through)\b|\bcut\s+(?:a\s+)?release\b/
+    ) ||
+    /发布|部署|提交|生成视频|外部服务/.test(text);
+  if (explicitPublishAction) {
     categories.add("publish");
   }
 

package/src/skill-library.js

@@ -482,6 +482,7 @@ const GENERIC_ROUTING_TERMS = new Set([
   "analysis",
   "app",
   "application",
+  "artifact",
   "code",
   "commit",
   "data",
@@ -498,6 +499,18 @@ const GENERIC_ROUTING_TERMS = new Set([
   "work",
 ]);
 
+function normalizedSkillRoutingText(goal = "") {
+  return String(goal || "")
+    .toLowerCase()
+    .replace(
+      /(?:^|[\s`'"(])(?:~|\.{1,2}|\/|[a-z0-9_-])[a-z0-9_./~-]*\.([a-z0-9]{1,12})\b/gi,
+      (_match, extension) => ` file.${String(extension || "").toLowerCase()} `
+    )
+    .replace(/\b[a-z_][a-z0-9_.-]*\s*=\s*[a-z0-9_.-]+\b/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
 function descriptionTerms(value = "") {
   return [
     ...new Set(
@@ -564,7 +577,7 @@ function textHasTrigger(text, needle) {
 }
 
 export function selectSkillsForGoal(goal = "", { taskProfile = "auto", limit = 6, includeBody = true, projectRoot = process.cwd() } = {}) {
-  const goalText = String(goal || "").toLowerCase();
+  const goalText = normalizedSkillRoutingText(goal);
   const text = goalText;
   const skills = listSkills({ includeBody, projectRoot });
   const ranked = skills