@lazyingart/agintiflow 0.20.337-integration.0 → 0.20.339-integration.0

package/aginti-work-examples/deepseek-cli-fallback-20261001.md

@@ -66,6 +66,15 @@ wall time. No external Codex/Claude/Gemini agent wrapper was called. The existin
 Docker image was reused; no GPU model, GUI desktop, or dependency rebuild was
 needed. The test-created containers exited after each command.
 
+The packaged CLI was then installed globally and tested again in a separate fresh
+workspace, using the installed entry point rather than the source checkout. All
+three cases passed again: summary in 6.8 seconds / 4 turns, code repair in 37.1
+seconds / 5 turns, and Chinese follow-up in 16.7 seconds / 4 additional turns.
+The same independent checks passed, including all 22 oracle assertions and
+unchanged input/code/test bytes where required. The installed package also passed
+the 13 focused lifecycle and CLI-policy regressions. These timings describe that
+individual run and are not a throughput guarantee.
+
 ## Usage
 
 See [DeepSeek CLI fallback](../docs/deepseek-cli-fallback.md) for start/resume,

package/docs/DEEPSEEK_ARTIFACT_COMPLETION.md

@@ -0,0 +1,62 @@
+# DeepSeek Artifact Completion and Host Integration
+
+Machine hosts should invoke both new and resumed AgInTi turns with
+`--no-wrappers` when AgInTi is the fallback for an unavailable external agent.
+Keep the provider explicit; credentials do not authorize a provider switch.
+Use the host's existing routines rather than rewriting them in the agent loop.
+
+## Source Changes Are Not Artifact Changes
+
+A task that reads inputs and writes a separate summary must not be pushed into
+editing those inputs. A task that creates or updates artifacts inside an exact
+host-provided root must not be pushed into changing the generator's source.
+Private task files deliberately do not increment the project-source revision.
+
+Execution and completion now share bounded artifact-root resolution. A real
+current-turn scoped write can satisfy artifact freshness without an unrelated
+project edit. Its saved timestamp must follow the current execution contract;
+old mutations, no-op patches, and workspace-wide roots do not qualify for this
+exemption. Explicit input repairs still require their requested changes.
+After a verified scoped write satisfies a prior missing-file/freshness repair,
+the runtime also stops enforcing that retained repair's obsolete source-edit
+phase. Actual source or artifact quality defects remain blocking. Keeping the
+current contract correct without retiring the obsolete phase can still trap a
+valid routine in repeated no-op patches.
+File, command, requested-format, source-grounding, and quality evidence gates
+remain active. In particular, a pre-existing PDF cannot satisfy a request to
+materially revise and rebuild it.
+
+Postfix input declarations such as `requirements.txt is a read-only input`
+are recognized without accidentally excluding a neighboring output path.
+Coordinated preservation instructions such as `leave a.txt and b.txt untouched`
+exclude both inputs from deliverables, not just paths adjacent to the verb.
+An output requested after that preservation clause remains required.
+
+## Source-Free Answers
+
+Refusing to invent a forecast is not a forecast. Chinese and English negated
+forecast clauses are stripped before assessing whether an answer needs source
+evidence. A real prediction later in the same sentence remains evidence-gated.
+Likewise, saying an item is unverified, pending confirmation, or needs no repeat
+confirmation is not a claim that it has been independently validated. Only the
+negated phrase is removed; real validation claims in the remaining text still
+require evidence.
+
+## Validation
+
+Run the evidence-visibility, truthful-completion, and scoped-artifact-research
+smokes, then the full `npm test`. The LabCanvas host adds separate mocked
+timeout/session/concurrency tests and opt-in live DeepSeek acceptance:
+
+```bash
+python scripts/evaluate_aginti_fallback.py --live --command /path/to/bin/aginti-cli.js
+```
+
+The host test uses synthetic inputs, isolated session registries, actual routine
+commands, a compiled Chinese memo PDF, and resumed turns. It prohibits external
+chat sends, public publication, and external agent wrappers. Saved inputs and
+attempted tool writes are checked independently of the model's final answer.
+
+This is acceptance for simple host tasks, not a claim that DeepSeek matches
+Codex across all tasks. Keep model/provider limitations separate from agent-loop
+or host-integration failures.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.337-integration.0",
+  "version": "0.20.339-integration.0",
   "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-scs-evidence-visibility.js

@@ -98,6 +98,21 @@ assert.deepEqual(immutableInputsContract.exactInputPaths, ["notes.txt", "risks.t
 assert.deepEqual(immutableInputsContract.exactOutputPaths, ["summary.md"]);
 assert.deepEqual(immutableInputsContract.excludedOutputPaths, ["notes.txt", "risks.txt"]);
 assert.equal(immutableInputsContract.requiresSourceGrounding, true);
+const coordinatedUntouchedInputsContract = deriveScsTaskContract({
+  goal: "Read notes.txt and risks.txt. Create artifacts/summary.md. Leave notes.txt and risks.txt untouched, then write artifacts/result.json.",
+});
+assert.deepEqual(coordinatedUntouchedInputsContract.excludedOutputPaths, ["notes.txt", "risks.txt"]);
+assert.deepEqual(coordinatedUntouchedInputsContract.exactOutputPaths, ["artifacts/summary.md", "artifacts/result.json"]);
+assert.deepEqual(coordinatedUntouchedInputsContract.exactInputPaths, ["notes.txt", "risks.txt"]);
+const postfixReadonlyInputContract = deriveScsTaskContract({
+  goal: "Create a scene in bench.scene.json. requirements.txt is a read-only input.",
+});
+assert.deepEqual(postfixReadonlyInputContract.exactOutputPaths, ["bench.scene.json"]);
+assert.deepEqual(postfixReadonlyInputContract.exactInputPaths, ["requirements.txt"]);
+assert.deepEqual(postfixReadonlyInputContract.excludedOutputPaths, ["requirements.txt"]);
+assert.deepEqual(deriveScsTaskContract({
+  goal: "Create summary.md. `source.json` must remain immutable. Then update output.json.",
+}).excludedOutputPaths, ["source.json"], "postfix write protection leaked onto a later output");
 assert.deepEqual(evaluateScsSemanticContract(immutableInputsContract, {
   commandCwd: scopedReadThenWriteRoot,
   events: [{ type: "tool.completed", data: { ok: true, toolName: "read_file", path: "notes.txt", content: "first input" } }],

package/scripts/smoke-truthful-completion.js

@@ -9,6 +9,7 @@ import {
   assessResponseOnlyEmptyEnvelope,
   assessResponseOnlyPerfectAudit,
   completionRequirementCoverageInstruction,
+  completionTaskContract,
   continuationExecutionContractDirective,
   evaluateAuthoritativeStructuredCompletionCoverage,
   nextStepRuntimeConfig,
@@ -1214,6 +1215,16 @@ for (const candidateResult of [
   "No forecast is requested; please clarify what this number means.",
   "这不是预测；这串数字缺少上下文，无法判断它的含义。",
   "これは予測ではありません。この数字だけでは文脈が不足しており、意味を判断できません。",
+  "对两类客户群做事实性对比，只呈现现有资料中的差异，不编造营收预测。",
+  "对两个客户群做事实对比，不编造收入预测。",
+  "任务是对两个客户群体做事实性对比，不做虚构营收预测。",
+  "只做两个客户群的事实对比，不做收入预测。",
+  "对两个客户细分做事实对比，不做臆测性营收预测。",
+  "对两类客户客群做事实性对比，不使用收入预测。",
+  "结论以现有可得资料为限，未证实部分明确标注为待确认。",
+  "已确定事项不再重复确认。",
+  "Compare the customer groups; do not invent revenue forecasts.",
+  "Never fabricate market predictions.",
 ]) {
   const negatedForecastClarification = evaluateSourceFreeResponseClaims({
     goal: sourceFreeResearchGoal,
@@ -1231,6 +1242,10 @@ for (const candidateResult of [
   "No forecast was requested, but demand will grow next year.",
   "这串数字缺少上下文，但报告预测市场需求明年会增长。",
   "予測ではありませんが、市場需要は来年増加する見込みです。",
+  "不编造营收预测，但报告预测市场需求明年会增长。",
+  "Do not invent revenue forecasts, but demand will grow next year.",
+  "不做臆测性营收预测，但报告预测市场需求明年会增长。",
+  "资料未证实部分待确认，但实验已经验证成功。",
 ]) {
   const disguisedForecast = evaluateSourceFreeResponseClaims({
     goal: sourceFreeResearchGoal,
@@ -2488,6 +2503,17 @@ try {
       assert.equal(editRuntime.completionFreshMutationRequired, true, `${verb}: actual input correction was exempted`);
       assert(editRuntime.completionFreshMutationPaths.includes("notes.txt"));
     }
+    const artifactRuntime = nextStepRuntimeConfig({ goal, commandCwd: summaryWorkspace }, {
+      goal,
+      commandCwd: summaryWorkspace,
+      meta: {
+        goalContract: { revision: 1, currentRequest: goal, activeGoal: goal },
+        activeExecutionContract: { revision: 1, requiresFileMutation: true, requiresSourceGrounding: true, startedMutationRevision: 0 },
+        projectVerification: { mutationRevision: 0, mutationHistory: [] },
+      },
+    });
+    assert.notEqual(artifactRuntime.completionFreshMutationRequired, true,
+      `${id}: separate deliverable forced a correction of its input or an unrelated source`);
   }
 
   const summaryFollowup = await runCase({
@@ -2511,6 +2537,51 @@ try {
   assert.equal(await fs.readFile(path.join(followupWorkspace, "checklist.md"), "utf8"), "- Assign an archive owner.\n- Test the backup.\n");
 
   const crossTaskIsolationId = "scoped-artifact-cross-task-completion";
+  for (const nestedRoot of [true, false]) {
+    const workspace = path.join(tempRoot, "workspaces", "scoped-json-freshness");
+    await fs.mkdir(path.join(workspace, "artifacts"), { recursive: true });
+    await fs.writeFile(path.join(workspace, "requirements.txt"), "Keep the tool source read-only.\n");
+    await fs.writeFile(path.join(workspace, "artifacts", "bench.scene.json"), "{}\n");
+    const artifactRoot = nestedRoot ? path.join(workspace, "artifacts") : workspace;
+    const goal = scopedTaskGoal(
+      "Use the existing routine to create artifacts/bench.scene.json and validate it. requirements.txt is a read-only input.",
+      artifactRoot
+    );
+    const state = {
+      goal, commandCwd: workspace,
+      meta: {
+        goalContract: { revision: 1, currentRequest: goal, activeGoal: goal },
+        activeExecutionContract: {
+          revision: 1, requiresFileMutation: true, requiresSourceGrounding: true, startedMutationRevision: 0,
+          refreshedAt: "2026-10-01T05:00:00Z",
+          scopedArtifactMutationAt: "2026-10-01T05:00:01Z",
+        },
+        projectVerification: { mutationRevision: 0, mutationHistory: [] },
+      },
+    };
+    const contract = completionTaskContract({ goal, commandCwd: workspace }, state);
+    assert.equal(contract.requiredFreshMutationRevision, nestedRoot ? 0 : 1,
+      "task artifact writes were confused with project source corrections, or a workspace-wide root bypassed freshness");
+    assert(contract.requiredEvidence.some((item) => item.category === "file"),
+      "artifact creation must still require real file evidence");
+    assert(contract.requiredEvidence.every((item) => !nestedRoot || !item.minimumMutationRevision));
+    state.meta.completionEvidenceRepair = {
+      key: "previous-file-evidence-rejection", at: "2026-10-01T05:00:00.500Z",
+      requiresFreshFileMutation: true, requiredFreshMutationRevision: 1,
+    };
+    const runtime = nextStepRuntimeConfig({ goal, commandCwd: workspace }, state);
+    assert.equal(runtime.completionFreshMutationRequired === true, !nestedRoot,
+      "a satisfied artifact mutation remained trapped in the retained fresh-source repair phase");
+    if (nestedRoot) {
+      state.meta.completionEvidenceRepair.artifactQualityRepairRequired = true;
+      assert.equal(nextStepRuntimeConfig({ goal, commandCwd: workspace }, state).completionFreshMutationRequired, true,
+        "a fresh artifact write cannot waive an outstanding quality defect");
+      state.meta.completionEvidenceRepair.artifactQualityRepairRequired = false;
+    }
+    state.meta.activeExecutionContract.scopedArtifactMutationAt = "2026-10-01T04:59:00Z";
+    assert.equal(completionTaskContract({ goal, commandCwd: workspace }, state).requiredFreshMutationRevision, 1,
+      "a prior artifact mutation cannot satisfy the current revision");
+  }
   const crossTaskWorkspace = path.join(tempRoot, "workspaces", crossTaskIsolationId);
   const currentTaskRoot = path.join(crossTaskWorkspace, "output", "tasks", "current-task");
   const siblingTaskRoot = path.join(crossTaskWorkspace, "output", "tasks", "sibling-task");

package/src/agent-runner.js

@@ -18940,6 +18940,23 @@ function groundedProjectTaskInstructionText(state = {}, config = {}, directContr
   }
 }
 
+function scopedArtifactTaskRoot(contract = {}, goal = "", commandCwd = process.cwd()) {
+  const root = scopedArtifactRoot(goal);
+  if (!root) return "";
+  const cwd = path.resolve(commandCwd);
+  const resolvedRoot = path.resolve(root);
+  const relativeRoot = path.relative(cwd, resolvedRoot);
+  if (!relativeRoot || relativeRoot.startsWith("..") || path.isAbsolute(relativeRoot)) return "";
+  const outputs = Array.isArray(contract.exactOutputPaths) ? contract.exactOutputPaths : [];
+  const scopedOutputs = outputs.length > 0 && outputs.every((item) => {
+    const relative = path.relative(resolvedRoot, path.resolve(cwd, item));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+  });
+  return contract.scopedArtifactDeliverable || contract.scopedArtifactOperation || scopedOutputs
+    ? relativeRoot.replace(/\\/g, "/")
+    : "";
+}
+
 export function completionTaskContract(config = {}, state = {}) {
   const taskProfile = config.taskProfile || state.meta?.taskProfile || "auto";
   const contractGoal = completionContractGoal(config, state);
@@ -19021,9 +19038,22 @@ export function completionTaskContract(config = {}, state = {}) {
     const scopedArtifactDeliverable = currentContract
       ? currentContract.scopedArtifactDeliverable === true
       : activeExecutionContract.scopedArtifactDeliverable === true;
+    const scopedMutationAt = Date.parse(String(activeExecutionContract.scopedArtifactMutationAt || ""));
+    const refreshedAt = Date.parse(String(activeExecutionContract.refreshedAt || ""));
+    const freshScopedMutation = Boolean(
+      scopedArtifactTaskRoot(
+        currentContract || contract, currentRequest || contractGoal,
+        config.commandCwd || state.commandCwd || process.cwd()
+      ) &&
+      Number.isFinite(scopedMutationAt) && Number.isFinite(refreshedAt) &&
+      scopedMutationAt >= refreshedAt &&
+      (currentContract?.exactInputPaths || []).every(
+        (input) => !documentSourceMutationExplicitlyRequested(state, config, input)
+      )
+    );
     const requiresFreshMutation = Boolean(
       (currentContract?.requiresFileMutation || activeExecutionContract.requiresFileMutation) &&
-        !scopedArtifactDeliverable
+        !scopedArtifactDeliverable && !freshScopedMutation
     );
     const minimumMutationRevision = requiresFreshMutation
       ? startedMutationRevision + 1
@@ -19386,42 +19416,13 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
   const currentGroundingGoal = String(
     state.meta?.goalContract?.currentRequest || config.goal || state.goal || ""
   );
-  const scopedRoot = scopedArtifactRoot(completionContractGoal(config, state));
   const commandCwd = path.resolve(
     config.commandCwd || state.commandCwd || process.cwd()
   );
-  const resolvedScopedRoot = scopedRoot ? path.resolve(scopedRoot) : "";
-  const scopedRootRelative = resolvedScopedRoot
-    ? path.relative(commandCwd, resolvedScopedRoot)
-    : "";
-  const exactScopedOutputs = Array.isArray(groundingTaskContract.exactOutputPaths)
-    ? groundingTaskContract.exactOutputPaths
-        .map((item) => String(item || "").trim())
-        .filter(Boolean)
-    : [];
-  const exactOutputsStayInsideScopedRoot = Boolean(
-    resolvedScopedRoot &&
-      exactScopedOutputs.length > 0 &&
-      exactScopedOutputs.every((item) => {
-        const absoluteOutput = path.resolve(commandCwd, item);
-        const relativeOutput = path.relative(resolvedScopedRoot, absoluteOutput);
-        return (
-          relativeOutput === "" ||
-          (!relativeOutput.startsWith("..") && !path.isAbsolute(relativeOutput))
-        );
-      })
-  );
-  const scopedArtifactTask = Boolean(
-    (
-      groundingTaskContract.scopedArtifactDeliverable === true ||
-      groundingTaskContract.scopedArtifactOperation === true ||
-      exactOutputsStayInsideScopedRoot
-    ) &&
-      resolvedScopedRoot &&
-      scopedRootRelative &&
-      !scopedRootRelative.startsWith("..") &&
-      !path.isAbsolute(scopedRootRelative)
+  const scopedRootRelative = scopedArtifactTaskRoot(
+    groundingTaskContract, completionContractGoal(config, state), commandCwd
   );
+  const scopedArtifactTask = Boolean(scopedRootRelative);
   if (scopedArtifactTask) {
     runtimeConfig.scopedArtifactTask = true;
     runtimeConfig.scopedArtifactRoot = scopedRootRelative.replace(/\\/g, "/");
@@ -19544,20 +19545,32 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
     ),
     retainedSourceQualityRepairRequired ? mutationRevision + 1 : 0
   );
+  const artifactRepairBoundaryAt = Date.parse(String(completionRepair.at || ""));
+  const scopedArtifactSatisfiedRepair = Boolean(
+    groundingScopedArtifactMutationSatisfied &&
+    Number.isFinite(artifactRepairBoundaryAt) && scopedArtifactMutationAt > artifactRepairBoundaryAt &&
+    Number(groundingTaskContract.requiredFreshMutationRevision || 0) === 0 &&
+    !retainedSourceQualityRepairRequired &&
+    completionRepair.sourceQualityRepairRequired !== true &&
+    completionRepair.artifactQualityRepairRequired !== true
+  );
   const completionRepairRequiresFreshMutation = Boolean(
-    retainedSourceQualityRepairRequired ||
-    completionRepair.requiresFreshFileMutation === true ||
+    !scopedArtifactSatisfiedRepair && (
+      retainedSourceQualityRepairRequired ||
+      completionRepair.requiresFreshFileMutation === true ||
       (
         completionRepair.key &&
         groundingTaskContract.requiresFileMutation === true &&
         completionFreshMutationRevision > mutationRevision
       )
+    )
   );
   const currentTurnRequiresFreshMutation = Boolean(
     groundingExecutionContract.requiresFileMutation === true &&
       groundingExecutionContract.requiresSourceGrounding === true &&
       !groundingFreshMutationSatisfied &&
-      !groundingScopedArtifactMutationSatisfied
+      !groundingScopedArtifactMutationSatisfied &&
+      !separateSourceDeliverable
   );
   const explicitHeadRestore = currentTurnRequiresFreshMutation
     ? explicitlyRequestedDirtyHeadRestore(state, config)

package/src/scs-evidence.js

@@ -891,8 +891,10 @@ export function inferExplicitlyExcludedOutputPaths(goal = "") {
   // later exclusion backwards across coordinated clauses.
   const negativeActionAfter =
     /^\s*(?:(?:does\s+not|doesn't|is\s+not|isn't)\s+exist\b\s*(?:and\s+)?)?(?:must\s+not|should\s+not|never)\s+(?:be\s+)?(?:run|rerun|re-run|execut(?:e|ed)|creat(?:e|ed)|recreat(?:e|ed)|writ(?:e|ten)|generat(?:e|ed)|sav(?:e|ed)|output|touch(?:ed)?|modif(?:y|ied)|edit(?:ed)?|stag(?:e|ed)|commit(?:ted)?)(?:\b|\s)/i;
+  const immutablePathAfter =
+    /^[`"'\s]*(?:is|remains?|must\s+remain|should\s+remain)\s+(?:(?:an?|the)\s+)?(?:read[ -]?only|immutable)\b/i;
   const keepAbsent =
-    /\b(?:keep|leave)\b[^.!?。！？;；\n]{0,80}\b(?:absent|missing|nonexistent|uncreated|untouched)\b/i;
+    /\b(?:keep|leave)\b[^!?。！？;；\n]{0,300}?\b(?:absent|missing|nonexistent|uncreated|untouched)\b/gi;
   const cjkNegativeActionBefore =
     /(?:不要|不得|禁止|无需|不需要)[^。！？；\n]{0,140}(?:运行|执行|重跑|创建|建立|写入|生成|保存|输出|修改|编辑|提交|暂存)/u;
   const cjkNegativeActionAfter =
@@ -905,6 +907,7 @@ export function inferExplicitlyExcludedOutputPaths(goal = "") {
   for (const clause of source.split(/[;；\n]|(?<=[.!?。！？])\s+/u)) {
     pathPattern.lastIndex = 0;
     const matches = [...clause.matchAll(pathPattern)];
+    const preservedPathSpans = [...clause.matchAll(keepAbsent)];
     const immutablePathClause = Boolean(
       /\b(?:treat|consider|regard)\b[^!?。！？;；\n]{0,260}\b(?:as\s+)?(?:immutable|read[ -]?only)\b/i.test(
         clause
@@ -935,7 +938,10 @@ export function inferExplicitlyExcludedOutputPaths(goal = "") {
         immutablePathClause ||
         negativeActionBefore.test(before) ||
         negativeActionAfter.test(after) ||
-        keepAbsent.test(`${before}${after}`) ||
+        immutablePathAfter.test(after) ||
+        preservedPathSpans.some((span) =>
+          index >= span.index && index + rawPath.length <= span.index + span[0].length
+        ) ||
         cjkNegativeActionBefore.test(before) ||
         cjkNegativeActionAfter.test(after) ||
         directRemovalBefore.test(before) ||
@@ -2203,7 +2209,15 @@ function sourceFreeClaimSegmentOnlyNegatesForecast(text = "") {
       " "
     )
     .replace(
-      /(?:不是|並非|并非|没有|沒有|无|無|不作|不做|无需|無需|不需要)(?:任何)?(?:预测|預測|预计|預計|推测|推測|预言|預言)/gu,
+      /(?:不是|並非|并非|没有|沒有|无|無|不作|不做|不使用|无需|無需|不需要)[^\s，,。！？；;但而]{0,12}?(?:预测|預測|预计|預計|推测|推測|预言|預言)/gu,
+      " "
+    )
+    .replace(
+      /\b(?:do\s+not|don't|must\s+not|never)\s+(?:invent|fabricate|make\s+up)\s+(?:any\s+)?(?:(?:revenue|income|market|demand)\s+)?(?:forecasts?|predictions?|projections?)\b/giu,
+      " "
+    )
+    .replace(
+      /(?:不|不要|不得|禁止)(?:编造|編造|虚构|虛構|捏造|杜撰)(?:任何)?(?:营收|營收|收入|市场|市場|需求)?(?:预测|預測|预计|預計|推测|推測)/gu,
       " "
     )
     .replace(
@@ -2237,7 +2251,11 @@ function sourceFreeExternalClaimCategoriesForSegment(
   text = "",
   { requireNamedEvidenceGrounding = false } = {}
 ) {
-  const value = String(text || "");
+  // Remove only negated verification phrases; reassess the remaining clause
+  // so a real evidence claim beside a disclaimer still requires a source.
+  const value = String(text || "")
+    .replace(/(?:尚未|未经|未經|未|待)(?:被|得到|经过|經過)?(?:验证|驗證|核实|核實|证实|證實|确认|確認|证明|證明)/gu, " ")
+    .replace(/(?:不再|不必|无需|無需|无须|無須)[^\s，,。！？；;但而]{0,12}?(?:验证|驗證|核实|核實|证实|證實|确认|確認|证明|證明)/gu, " ");
   if (!value.trim()) return [];
   const categories = [];
   const add = (category, pattern) => {