@lazyingart/agintiflow 0.20.312 → 0.20.314

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.312",
+  "version": "0.20.314",
   "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-planning-timeout-recovery.js

@@ -11,6 +11,7 @@ import {
   modelPlanningTimeoutRetryRoute,
   nextStepRuntimeConfig,
   recordAlreadyCommittedRepositoryRepair,
+  recordProjectVerificationOutcome,
   runAgent,
 } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
@@ -155,43 +156,42 @@ try {
       artifact_root: scopedArtifactRoot,
     })}`,
   ].join("\n");
-  const scopedRuntime = nextStepRuntimeConfig(
-    { commandCwd: scopedRepairRoot, goal: scopedGoal },
-    {
-      goal: scopedGoal,
-      commandCwd: scopedRepairRoot,
-      meta: {
-        goalContract: {
-          revision: 1,
-          currentRequest: scopedGoal,
-          currentHash: "scoped-repair",
-        },
-        activeExecutionContract: {
-          revision: 1,
-          refreshedAt,
-          startedMutationRevision: 0,
-          requiresWorkspaceMutation: true,
-          requiresFileMutation: true,
-          requiresSourceGrounding: true,
-        },
-        projectVerification: {
-          mutationRevision: 0,
-          mutationHistory: [],
-          testRuns: [],
-          discoveredTests: [],
-        },
-        toolLoop: {
-          recent: [{
-            toolName: "read_file",
-            ok: true,
-            blocked: false,
-            path: scopedSource,
-            at: groundedAt,
-          }],
-        },
+  const scopedState = {
+    goal: scopedGoal,
+    commandCwd: scopedRepairRoot,
+    meta: {
+      goalContract: {
+        revision: 1,
+        currentRequest: scopedGoal,
+        currentHash: "scoped-repair",
       },
-    }
-  );
+      activeExecutionContract: {
+        revision: 1,
+        refreshedAt,
+        startedMutationRevision: 0,
+        requiresWorkspaceMutation: true,
+        requiresFileMutation: true,
+        requiresSourceGrounding: true,
+      },
+      projectVerification: {
+        mutationRevision: 0,
+        mutationHistory: [],
+        testRuns: [],
+        discoveredTests: [],
+      },
+      toolLoop: {
+        recent: [{
+          toolName: "read_file",
+          ok: true,
+          blocked: false,
+          path: scopedSource,
+          at: groundedAt,
+        }],
+      },
+    },
+  };
+  const scopedConfig = { commandCwd: scopedRepairRoot, goal: scopedGoal };
+  const scopedRuntime = nextStepRuntimeConfig(scopedConfig, scopedState);
   assert.equal(scopedRuntime.scopedArtifactTask, true);
   assert.equal(
     scopedRuntime.completionFreshMutationRequired,
@@ -200,6 +200,34 @@ try {
   );
   assert.deepEqual(scopedRuntime.completionFreshMutationPaths, [scopedSource]);
   assert.equal(scopedRuntime.completionFreshMutationNeedsSourceRead, false);
+  recordProjectVerificationOutcome(
+    scopedState,
+    {
+      toolName: "write_file",
+      ok: true,
+      path: scopedSource,
+      args: { path: scopedSource },
+      change: {
+        path: scopedSource,
+        beforeHash: "rejected-report",
+        afterHash: "corrected-report",
+        beforeBytes: 18,
+        afterBytes: 96,
+      },
+    },
+    { ...scopedConfig, ...scopedRuntime }
+  );
+  assert.deepEqual(
+    scopedState.meta.activeExecutionContract.scopedArtifactMutationPaths,
+    [scopedSource],
+    "a successful scoped artifact write did not persist its current-turn mutation"
+  );
+  const scopedRuntimeAfterWrite = nextStepRuntimeConfig(scopedConfig, scopedState);
+  assert.equal(
+    scopedRuntimeAfterWrite.completionFreshMutationRequired,
+    undefined,
+    "a successful current-turn scoped artifact write remained trapped in source-mutation recovery"
+  );
 } finally {
   await fs.rm(scopedRepairRoot, { recursive: true, force: true });
 }

package/scripts/smoke-scs-evidence-visibility.js

@@ -33,6 +33,19 @@ const groupBriefingContract = deriveScsTaskContract({
   ].join(" "),
   taskProfile: "research",
 });
+const sourceIntakeAuditContract = deriveScsTaskContract({
+  goal: [
+    "Create one concise coherent Markdown report with exactly five numbered cases:",
+    "(1) a bare video has no publication;",
+    "(2) a current same-chat publish request authorizes only the exact referenced video through autopublish-video plus LazyEdit, while this audit performs no external action;",
+    "(3) Finder recovery remains evidence-limited;",
+    "(4) mp.weixin recovery never asks for browser verification;",
+    "(5) PDF/archive intake uses the guarded document reader.",
+    "Run only the focused existing unit test and write agent-result.json.",
+    "Do not send, publish, submit, upload, alter queues, or open a GUI.",
+  ].join(" "),
+  taskProfile: "auto",
+});
 const scopedReadThenWriteRoot = fs.mkdtempSync(
   path.join(os.tmpdir(), "aginti-scoped-read-then-write-")
 );
@@ -83,6 +96,16 @@ assert.deepEqual(
   ["format:.pdf"],
   "an ordinary chat answer was incorrectly converted into a separate answer-key artifact"
 );
+assert.deepEqual(
+  sourceIntakeAuditContract.requiredArtifactKinds.map((item) => item.id),
+  ["format:.md"],
+  "a Markdown-only audit inferred PDF from a described PDF intake case"
+);
+assert.equal(
+  sourceIntakeAuditContract.requiredEvidence.some((item) => item.category === "publish"),
+  false,
+  "a read-only audit of a publish contract fabricated a publish action obligation"
+);
 assert.deepEqual(
   educationArtifactContract.requiredArtifactKinds.map((item) => item.id).sort(),
   [

package/src/agent-runner.js

@@ -6622,6 +6622,28 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
   const projectMutationPaths = successfulProjectMutationPaths(toolResult, state, config);
   const privateMutationPaths = successfulPrivateVerificationMutationPaths(toolResult);
   const materialMutationPaths = materialProjectMutationPaths(toolResult, state, config);
+  const scopedArtifactMutationPaths = successfulScopedArtifactMutationPaths(
+    toolResult,
+    state,
+    config
+  );
+  const activeExecutionContract = state.meta?.activeExecutionContract;
+  if (
+    ["write_file", "apply_patch"].includes(toolName) &&
+    scopedArtifactMutationPaths.length > 0 &&
+    Number(activeExecutionContract?.revision || 0) ===
+      Number(state.meta?.goalContract?.revision || 0)
+  ) {
+    activeExecutionContract.scopedArtifactMutationAt = now;
+    activeExecutionContract.scopedArtifactMutationPaths = [
+      ...new Set([
+        ...(Array.isArray(activeExecutionContract.scopedArtifactMutationPaths)
+          ? activeExecutionContract.scopedArtifactMutationPaths
+          : []),
+        ...scopedArtifactMutationPaths,
+      ]),
+    ].slice(0, 24);
+  }
   if (["write_file", "apply_patch"].includes(toolName) && privateMutationPaths.length) {
     delete state.meta.verifiedCompletionCandidate;
     verification.privateMutationRevision += 1;
@@ -6669,7 +6691,6 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
           }
         : {}),
     }, config);
-    const activeExecutionContract = state.meta?.activeExecutionContract;
     if (
       materialMutationPaths.length > 0 &&
       Number(activeExecutionContract?.revision || 0) ===
@@ -13820,6 +13841,33 @@ function successfulMutationPaths(toolResult = {}) {
   return [...new Set([toolResult.path, ...changes.map((change) => change.path)].filter(Boolean))];
 }
 
+function successfulScopedArtifactMutationPaths(
+  toolResult = {},
+  state = {},
+  config = {}
+) {
+  const artifactRoot = String(
+    config.scopedArtifactRoot ||
+      scopedArtifactRoot(completionContractGoal(config, state)) ||
+      ""
+  ).trim();
+  if (!artifactRoot) return [];
+  const commandCwd = path.resolve(
+    config.commandCwd || state.commandCwd || process.cwd()
+  );
+  const resolvedRoot = path.resolve(commandCwd, artifactRoot);
+  return successfulMutationPaths(toolResult)
+    .map((candidate) => path.resolve(commandCwd, String(candidate || "")))
+    .filter((candidate) => {
+      const relative = path.relative(resolvedRoot, candidate);
+      return (
+        relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative))
+      );
+    })
+    .map((candidate) => path.relative(commandCwd, candidate).replace(/\\/g, "/"));
+}
+
 function successfulWorkspaceMutationPaths(toolResult = {}) {
   if (!toolResult || toolResult.blocked || toolResult.skipped) return [];
   if (!["write_file", "apply_patch"].includes(String(toolResult.toolName || ""))) return [];
@@ -15321,6 +15369,20 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
     runtimeConfig.scopedArtifactRoot = scopedRootRelative.replace(/\\/g, "/");
     runtimeConfig.workspaceWritePathScopeRoots = [runtimeConfig.scopedArtifactRoot];
   }
+  const scopedArtifactMutationAt = Date.parse(
+    String(groundingExecutionContract.scopedArtifactMutationAt || "")
+  );
+  const executionContractRefreshedAt = Date.parse(
+    String(groundingExecutionContract.refreshedAt || "")
+  );
+  const groundingScopedArtifactMutationSatisfied = Boolean(
+    scopedArtifactTask &&
+      Number.isFinite(scopedArtifactMutationAt) &&
+      (
+        !Number.isFinite(executionContractRefreshedAt) ||
+        scopedArtifactMutationAt >= executionContractRefreshedAt
+      )
+  );
   if (
     (
       groundingTaskContract.requiresSourceGrounding === true ||
@@ -15435,7 +15497,8 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
   const currentTurnRequiresFreshMutation = Boolean(
     groundingExecutionContract.requiresFileMutation === true &&
       groundingExecutionContract.requiresSourceGrounding === true &&
-      !groundingFreshMutationSatisfied
+      !groundingFreshMutationSatisfied &&
+      !groundingScopedArtifactMutationSatisfied
   );
   const explicitHeadRestore = currentTurnRequiresFreshMutation
     ? explicitlyRequestedDirtyHeadRestore(state, config)

package/src/scs-evidence.js

@@ -583,6 +583,7 @@ const REQUESTED_ARTIFACT_FORMATS = [
   { extension: ".pptx", pattern: /\b(?:pptx|powerpoint)\b/i, description: "editable PowerPoint deck" },
   { extension: ".odp", pattern: /\b(?:odp|open(?:office|document) presentation)\b/i, description: "editable ODP deck" },
   { extension: ".pdf", pattern: /\bpdf\b/i, description: "PDF document" },
+  { extension: ".md", pattern: /(?:\bmarkdown\b|\.md\b)/i, description: "Markdown document" },
   {
     extension: ".tex",
     pattern: /(?:\b(?:editable\s+)?(?:latex|tex)\s+source\b|\.tex\b)/i,
@@ -594,6 +595,64 @@ const REQUESTED_ARTIFACT_FORMATS = [
   { extension: ".svg", pattern: /\bsvg\b/i, description: "editable SVG image" },
 ];
 
+function requestedArtifactFormatHasOutputIntent(source = "", format = {}) {
+  const extension = String(format.extension || "").toLocaleLowerCase("en-US");
+  if (!extension || !format.pattern) return false;
+  if (
+    inferExactOutputPaths(source).some(
+      (candidate) => path.extname(candidate).toLocaleLowerCase("en-US") === extension
+    )
+  ) {
+    return true;
+  }
+
+  const matcher = new RegExp(
+    format.pattern.source,
+    format.pattern.flags.includes("g") ? format.pattern.flags : `${format.pattern.flags}g`
+  );
+  const outputAction =
+    /\b(?:compile|convert|create|deliver|export|generate|keep|make|output|prepare|preserve|produce|provide|render|retain|return|reuse|save|send|write)\b/i;
+  const directRequest =
+    /\b(?:can|could|would|will)\s+you\b|\b(?:i|we)\s+(?:also\s+)?(?:need|want|would\s+like|request)\b|\b(?:please|kindly)\b/i;
+  for (const match of source.matchAll(matcher)) {
+    const index = Number(match.index || 0);
+    const clauseStart = Math.max(
+      source.lastIndexOf(".", index - 1),
+      source.lastIndexOf("!", index - 1),
+      source.lastIndexOf("?", index - 1),
+      source.lastIndexOf(";", index - 1),
+      source.lastIndexOf("。", index - 1),
+      source.lastIndexOf("！", index - 1),
+      source.lastIndexOf("？", index - 1),
+      source.lastIndexOf("；", index - 1),
+      source.lastIndexOf("\n", index - 1)
+    );
+    const nextBoundaries = [".", "!", "?", ";", "。", "！", "？", "；", "\n"]
+      .map((delimiter) => source.indexOf(delimiter, index + String(match[0] || "").length))
+      .filter((candidate) => candidate >= 0);
+    const clauseEnd = nextBoundaries.length ? Math.min(...nextBoundaries) : source.length;
+    const clause = source.slice(clauseStart + 1, clauseEnd);
+    const matchOffset = index - clauseStart - 1;
+    const before = clause.slice(Math.max(0, matchOffset - 180), matchOffset);
+    const after = clause.slice(matchOffset + String(match[0] || "").length, matchOffset + 120);
+    if (outputAction.test(before) || directRequest.test(before)) return true;
+    if (
+      /\b(?:as|into|to)\s+(?:an?\s+)?$/i.test(before) &&
+      /\b(?:compile|convert|export|render|save)\b/i.test(clause)
+    ) {
+      return true;
+    }
+    if (
+      /^\s*(?:output|deliverable|file|document|report|version|copy)\b/i.test(after) &&
+      outputAction.test(clause)
+    ) {
+      return true;
+    }
+    if (/^\s*(?:please|required|requested)\b/i.test(after)) return true;
+  }
+  return false;
+}
+
 function artifactRequestHasOutputIntent(goal = "", taskProfile = "") {
   const source = stripForbiddenLanguage(String(goal || ""));
   return Boolean(
@@ -622,7 +681,7 @@ export function inferRequestedArtifactRequirements(goal = "", taskProfile = "")
   };
 
   for (const format of REQUESTED_ARTIFACT_FORMATS) {
-    if (!format.pattern.test(source)) continue;
+    if (!requestedArtifactFormatHasOutputIntent(source, format)) continue;
     add({
       id: `format:${format.extension}`,
       kind: "format",
@@ -1456,6 +1515,41 @@ function requiresSourceGrounding(goal = "") {
   );
 }
 
+function goalRequestsPublishAction(goal = "") {
+  const text = normalizedText(stripCompletedWorkNarration(stripForbiddenLanguage(goal)));
+  const action =
+    "(?:publish|deploy|submit|upload\\s+to|generate\\s+(?:a\\s+)?video|npm\\s+publish)";
+  const release =
+    "(?:release|ship)(?:\\s+(?:(?:the|this|that|a|an)\\s+)?(?:package|version|build|app|application|software|library|plugin|extension|product)|\\s+(?:to|on|via|through))|cut\\s+(?:a\\s+)?release";
+  const clauses = text
+    .split(/[\n.!?;，；。！？]+/u)
+    .map((clause) => clause.trim())
+    .filter(Boolean);
+  for (const clause of clauses) {
+    if (
+      new RegExp(
+        `^(?:(?:and|also|then|next|finally|please|kindly)\\s+)*(?:${action}|${release})\\b`,
+        "i"
+      ).test(clause)
+    ) {
+      return true;
+    }
+    if (
+      new RegExp(
+        `\\b(?:(?:can|could|would|will)\\s+you|(?:i|we)\\s+(?:need|want|would\\s+like)\\s+(?:you\\s+)?to|you\\s+(?:must|should|need\\s+to|have\\s+to)|please|kindly|then|next|finally)\\b[^.\\n;]{0,140}\\b(?:${action}|${release})\\b`,
+        "i"
+      ).test(clause)
+    ) {
+      return true;
+    }
+  }
+  return (
+    /(?:请|請|需要|必须|必須|帮我|幫我|立即|现在|現在)[^。；\n]{0,100}(?:发布|發布|部署|提交|上传|上傳|生成视频|生成影片)/u.test(
+      text
+    ) || /^(?:发布|發布|部署|提交|上传|上傳|生成视频|生成影片)/u.test(text)
+  );
+}
+
 function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCriteria = []) {
   const positiveGoal = stripForbiddenLanguage(goal);
   const text = normalizedText(positiveGoal);
@@ -1531,16 +1625,7 @@ function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCrite
   ) {
     categories.add("visual");
   }
-  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);
+  const explicitPublishAction = goalRequestsPublishAction(positiveGoal);
   if (explicitPublishAction) {
     categories.add("publish");
   }