@lazyingart/agintiflow 0.20.216 → 0.20.218

package/docs/supervision-campaign-ledger.md

@@ -235,3 +235,98 @@ provider balance. A separate read-only `localllm-deep` review completed with no
 actionable findings. The full `npm test` suite, focused dynamic-step-budget,
 coding-tools, SCS-evidence, and syntax checks all pass before packaging
 AgInTiFlow `0.20.216`.
+
+### Same-session interruption convergence and bounded completion
+
+The `context-interruption-016` campaign exercised a long retained DeepSeek
+session with multiple concrete interruptions, source corrections, an exact
+external acceptance command, and a final clean-repository requirement. The
+agent owned every target edit and commit. Early recovery turns repeatedly read
+the same already-correct diff, showing that token limits alone do not guarantee
+convergence while the available action surface remains open ended.
+
+The reusable repair is driven by runtime state and evidence rather than task
+literals. Mutations invalidate stale tests and prior completion evidence;
+same-task interruptions refresh per-turn acceptance while retaining durable
+evidence; repository-state recovery derives task-owned paths since the latest
+successful commit and offers a bounded `commit_project_changes` action; and
+the runtime constructs the path-scoped Git command. A current-revision exact
+validator creates a one-use completion candidate. The following turn compacts
+the evidence and exposes only `finish`; rejection or mutation invalidates the
+candidate.
+
+The final live continuation converged in three turns: bounded commit, exact
+validator, and truthful finish. The target ended clean at commit `bd74bbd`.
+Repository-repair context compacted from 156,716 to 5,788 characters, and the
+verified-completion context compacted from 23,658 to 5,157 characters.
+
+An independent read-only DeepSeek review then drove three general fixes: a
+dedicated task-owned commit-path validator that supports binary,
+extensionless, and instruction files while rejecting protected paths;
+platform-aware POSIX and Windows command quoting; and recognition of bounded
+stdin `sed -n` pipelines as read-only inspection. Production code contains no
+campaign scenario IDs, target paths, expected prose, commit IDs, or acceptance
+literals.
+
+### Live inbox requirement coalescing
+
+The next installed-release run tested actual mid-turn input rather than a
+sequence of explicit resume commands. A DeepSeek task started from a normal
+repository-writing request. While its first model call was active, two
+independent corrections were appended through `aginti queue`. Both received
+distinct durable inbox IDs and were applied exactly once at the first safe tool
+boundary, before the source note was read.
+
+AgInTiFlow `0.20.217` retained both corrections through later context
+compaction, produced one concise artifact, removed every superseded value,
+preserved the source note, added only narrowly scoped runtime ignore rules,
+committed the intentional files, and left the target repository clean. An
+external semantic and repository-state contract passed at target commit
+`f19ff4b`. No AgInTiFlow source change or task-specific prompt branch was
+needed; the run validates the generic inbox, context, evidence, and completion
+contracts in the published package.
+
+### LabCanvas least-privilege worker integration
+
+`labcanvas-worker-permission-018` validated the installed AgInTiFlow `0.20.217`
+through LabCanvas after a real WeCom research task paused at
+`permission_required`. The defect was in the integration boundary: LabCanvas
+unconditionally selected AgInTi's blocked package-install tier, which also
+blocked ordinary workspace shell execution. LabCanvas now keeps response-only
+roles blocked while granting genuine worker roles reversible package setup
+inside the Docker workspace. Host access, credentials, payment, publication,
+destructive operations, and other irreversible actions remain separately
+guarded.
+
+A direct DeepSeek-backed worker smoke created and validated a bounded workspace
+artifact without a permission prompt. Focused backend regressions, all WeChat
+self-checks, the complete 1,442-test LabCanvas suite, and GitHub Actions passed.
+The originally blocked exact-chat task was then resumed without duplicate model
+work, produced a visually inspected nine-page XeLaTeX research report, and
+delivered one concise message plus the PDF through the verified WeCom transport.
+The follow-up message was preserved in the same chat session. The reusable fix
+is AgenticApp commit `e705bb0`; no AgInTiFlow release change was required.
+
+### Durable background-job recovery after foreground interruption
+
+`long-job-recovery-019` exercised installed AgInTiFlow `0.20.217` with a normal
+laboratory-export request whose terminal could disconnect. The DeepSeek-backed
+agent inspected the checked-in resumable scripts, rejected duplicate execution,
+and selected the generic `start_long_job` routine. The campaign interrupted only
+the foreground AgInTi pane after durable admission; the independent job tmux
+continued, completed eight delayed batches, ran deferred verification, and
+cleaned up its own tmux session.
+
+The same AgInTi session then resumed from retained state. It recovered the exact
+job ID through `long_job_status`, independently reran the project verifier,
+confirmed the artifact and checksum, and finished without calling
+`start_long_job` again. Proactive context compaction reduced the resumed history
+from 190,805 to 30,680 characters while preserving the job identity and original
+task boundary.
+
+The independent acceptance contract verified one process invocation, one durable
+job directory, attempt `1`, command and verifier exit `0`, the required durable
+event sequence, a project handoff with exact status and verification commands,
+and no lingering job tmux session. No source patch or npm release was needed;
+this run validates the published package's general long-job, resume, context,
+deduplication, and cleanup contracts without task-specific routing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.216",
+  "version": "0.20.218",
   "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

@@ -7,6 +7,8 @@ import {
   buildModelTimeoutRetryMessages,
   genericArtifactFilenameBlock,
   modelTimeoutRetryRoute,
+  applyModelTimeoutRetryRoute,
+  recoverFocusedTextRewriteWithWritingSpecialist,
   repairModelMessageHistory,
   shouldResetStaticDiscoveryPhase,
   runAgent,
@@ -16,6 +18,7 @@ import {
   shellDiagnosticHint,
   skippedAfterBlockedToolResult,
 } from "../src/agent-runner.js";
+import { createToolContract, resolveDispatchableToolCallBatch } from "../src/tool-contract.js";
 import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { readCodebaseMap } from "../src/codebase-map.js";
@@ -580,6 +583,58 @@ try {
     ...hostWorkspacePolicy,
     readOnlyRoots: [externalReadRoot],
   };
+  const exactReadOnlySkillLoop = [
+    "for f in",
+    "/home/lachlan/.agintiflow/skillmesh/skills/lazyedit-publish-workflow/SKILL.md",
+    "/home/lachlan/.codex/skills/musia-music-production/SKILL.md",
+    "/home/lachlan/.codex/skills/musia-lalachan-mv-workflow/SKILL.md",
+    "/home/lachlan/.codex/skills/lalachan-xyq-browser-video/SKILL.md",
+    "/home/lachlan/.nvm/versions/node/v22.21.0/lib/node_modules/@lazyingart/agintiflow/skills/browser-automation/SKILL.md",
+    "/home/lachlan/.codex/skills/musia-song-localization/SKILL.md;",
+    'do echo "===== $f ====="; wc -l "$f"; done',
+  ].join(" ");
+  const exactReadOnlySkillLoopPolicy = evaluateCommandPolicy(exactReadOnlySkillLoop, hostWorkspacePolicy);
+  assert(
+    exactReadOnlySkillLoopPolicy.allowed &&
+      exactReadOnlySkillLoopPolicy.category === "read-only" &&
+      exactReadOnlySkillLoopPolicy.boundedForLoop === true &&
+      exactReadOnlySkillLoopPolicy.needsNetwork === false &&
+      exactReadOnlySkillLoopPolicy.writesWorkspace === false,
+    "a finite echo/wc skill audit loop incorrectly required destructive host permission"
+  );
+  const multilineReadOnlyLoopPolicy = evaluateCommandPolicy(
+    [
+      "for target in README.md package.json",
+      "do",
+      '  echo "== ${target} =="',
+      '  wc -l "$target"',
+      "done",
+    ].join("\n"),
+    hostWorkspacePolicy
+  );
+  assert(
+    multilineReadOnlyLoopPolicy.allowed && multilineReadOnlyLoopPolicy.category === "read-only",
+    "a multiline finite read-only loop was not recognized"
+  );
+  for (const unsafeLoop of [
+    'for f in README.md; do rm -rf "$f"; done',
+    'for f in README.md; do curl "https://example.com/$f"; done',
+    'for f in README.md; do cp "$f" copied.md; done',
+    'for f in README.md; do echo "$f" > report.md; done',
+    'for f in $(find . -type f); do wc -l "$f"; done',
+    'for f in *.md; do wc -l "$f"; done',
+    'for f in --pre=unsafe-helper; do rg pattern "$f"; done',
+    'for f in $FILES; do wc -l "$f"; done',
+    'for f in README.md; do wc -l "${f:-package.json}"; done',
+    'for f in README.md; do for g in package.json; do wc -l "$g"; done; done',
+    'for f in README.md; do wc -l "$f" & done',
+  ]) {
+    const unsafeLoopPolicy = evaluateCommandPolicy(unsafeLoop, hostWorkspacePolicy);
+    assert(
+      !unsafeLoopPolicy.allowed && unsafeLoopPolicy.category !== "read-only",
+      `unsafe or dynamic shell loop bypassed the bounded read-only policy: ${unsafeLoop}`
+    );
+  }
   const readRootDoctorPolicy = evaluateCommandPolicy(
     `cd ${externalReadRoot} && node bin/musia.js doctor --json 2>&1 | head -80`,
     hostReadRootPolicy
@@ -648,6 +703,14 @@ try {
   );
   assert(readonlyVersionPipelinePolicy.allowed, "read-only version probe pipelines should not require package-install-policy=allow");
   assert(readonlyVersionPipelinePolicy.category === "read-only", "read-only version probe pipelines should be classified as read-only");
+  const readonlyDiffSlicePolicy = evaluateCommandPolicy(
+    "git diff -- src/agent-runner.js | sed -n '1,240p'",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(
+    readonlyDiffSlicePolicy.allowed && readonlyDiffSlicePolicy.category === "read-only",
+    "a bounded sed print filter made a read-only Git diff pipeline require broad shell access"
+  );
   const nodeNpmTestPolicy = evaluateCommandPolicy(
     'cd /workspace && node --version && npm test 2>&1; echo "EXIT:$?"',
     dockerWorkspaceNoInstallsPolicy
@@ -1308,6 +1371,128 @@ try {
     localTimeoutRoute.model === "localllm-fast" && localTimeoutRoute.retryTimeoutMs === 90000,
     "LocalLLM timeout retry did not switch to its same-boundary fast route"
   );
+  const adoptedLocalTimeoutRoute = applyModelTimeoutRetryRoute(
+    { provider: "localllm", model: "localllm-deep", routingMode: "manual" },
+    localTimeoutRoute
+  );
+  assert(
+    adoptedLocalTimeoutRoute.model === "localllm-fast" &&
+      adoptedLocalTimeoutRoute.modelTimeoutRecoveryActive === true &&
+      /continuing this run/.test(adoptedLocalTimeoutRoute.routeReason),
+    "a successful in-provider timeout retry was not retained for later steps in the same run"
+  );
+  const focusedRewriteDescriptor = {
+    type: "function",
+    function: {
+      name: "rewrite_text_excerpt",
+      description: "Rewrite one evidence-selected excerpt.",
+      parameters: {
+        type: "object",
+        properties: {
+          revisedText: {
+            type: "string",
+            minLength: 1,
+            maxLength: 4000,
+            pattern: "^(?:(?!load)[\\s\\S])+$",
+            description:
+              "Return only the complete revised excerpt. Remove the premature first-match operand while preserving the technical meaning.",
+          },
+        },
+        required: ["revisedText"],
+        additionalProperties: false,
+      },
+    },
+  };
+  const focusedRewriteContract = createToolContract([focusedRewriteDescriptor]);
+  const invalidFocusedRewriteCall = {
+    id: "focused-rewrite-smoke",
+    type: "function",
+    function: {
+      name: "rewrite_text_excerpt",
+      arguments: JSON.stringify({ revisedText: "A carefully preloaded technical summary." }),
+    },
+  };
+  const invalidFocusedRewrite = resolveDispatchableToolCallBatch(
+    [invalidFocusedRewriteCall],
+    focusedRewriteContract
+  );
+  assert(
+    !invalidFocusedRewrite.ok &&
+      invalidFocusedRewrite.errors.some((error) => error.code === "ARGUMENT_PATTERN_MISMATCH"),
+    "focused rewrite smoke input did not exercise the semantic pattern failure"
+  );
+  const focusedWriterCalls = [];
+  const focusedRewriteState = {
+    meta: {
+      failedTestDiagnostic: {
+        mutationRevision: 7,
+        failureSignature: "generic-first-occurrence-relation",
+      },
+    },
+  };
+  const focusedRewriteConfig = {
+    provider: "localllm",
+    model: "localllm-fast",
+    baseURL: "http://127.0.0.1:8008/v1",
+    testFailureSignature: "generic-first-occurrence-relation",
+    testFailureRepairPatchTargets: [{
+      path: "notes/handoff.md",
+      search: "A carefully preloaded technical summary.",
+    }],
+    writingClientFactory: (writingConfig) => {
+      focusedWriterCalls.push(writingConfig);
+      return {
+        chat: {
+          completions: {
+            create: async () => ({
+              choices: [{
+                message: {
+                  content: JSON.stringify({
+                    draft: "A carefully prepared technical summary.",
+                    revision_notes: [],
+                    continuity_notes: [],
+                    format_handoff: {},
+                    quality_checks: ["constraint satisfied"],
+                    questions: [],
+                  }),
+                },
+              }],
+            }),
+          },
+        },
+      };
+    },
+  };
+  const recoveredFocusedRewrite = await recoverFocusedTextRewriteWithWritingSpecialist(
+    focusedRewriteConfig,
+    focusedRewriteState,
+    [invalidFocusedRewriteCall],
+    focusedRewriteContract,
+    invalidFocusedRewrite
+  );
+  assert(recoveredFocusedRewrite?.ok, "writing specialist did not recover the bounded semantic rewrite");
+  assert(
+    recoveredFocusedRewrite.recoveredFocusedTextRewrite === true &&
+      JSON.parse(recoveredFocusedRewrite.acceptedToolCalls[0].function.arguments).revisedText ===
+        "A carefully prepared technical summary.",
+    "writing specialist recovery did not return a schema-valid focused rewrite call"
+  );
+  assert(
+    focusedWriterCalls.length === 1 &&
+      focusedWriterCalls[0].provider === "localllm" &&
+      focusedWriterCalls[0].model === "localllm-fast",
+    "focused rewrite recovery crossed the active provider/model boundary"
+  );
+  assert(
+    (await recoverFocusedTextRewriteWithWritingSpecialist(
+      focusedRewriteConfig,
+      focusedRewriteState,
+      [invalidFocusedRewriteCall],
+      focusedRewriteContract,
+      invalidFocusedRewrite
+    )) === null && focusedWriterCalls.length === 1,
+    "focused rewrite recovery repeated for the same retained failure state"
+  );
   const defaultLocalTimeoutRoute = modelTimeoutRetryRoute({
     provider: "localllm",
     model: "localllm-fast",
@@ -1512,6 +1697,25 @@ try {
   const unifiedText = await fs.readFile(path.join(workspace, "unified-target.txt"), "utf8");
   assert(unified.ok && unifiedText === "alpha\nnew\nomega\n", "unified apply_patch did not update expected file");
 
+  await fs.writeFile(path.join(workspace, "no-op-patch-target.txt"), "already correct\n", "utf8");
+  const noOpPatchError = await executeWorkspaceTool(
+    "apply_patch",
+    {
+      path: "no-op-patch-target.txt",
+      search: "already correct",
+      replace: "already correct",
+      expectedReplacements: 1,
+    },
+    { commandCwd: workspace, allowFileTools: true }
+  )
+    .then(() => "")
+    .catch((error) => String(error?.message || error));
+  assert(
+    /patch made no changes/i.test(noOpPatchError) &&
+      (await fs.readFile(path.join(workspace, "no-op-patch-target.txt"), "utf8")) === "already correct\n",
+    "an exact byte-identical replacement was reported as a successful mutation"
+  );
+
   await fs.writeFile(path.join(workspace, "hybrid-patch-target.txt"), "alpha\nold\nomega\n", "utf8");
   const hybridPatch = await executeWorkspaceTool(
     "apply_patch",
@@ -1858,6 +2062,7 @@ try {
           "node_profile_cli_package_manifest",
           "python_profile_helper_test_report",
           "model_timeout_compact_retry_messages",
+          "focused_text_rewrite_specialist_recovery",
         ],
       },
       null,