@lazyingart/agintiflow 0.20.328 → 0.20.330

package/docs/supervision-campaign-ledger.md

@@ -675,3 +675,49 @@ demonstrated evidence from inferred recommendations, and finished normally.
 The retained trace contains no completion-evidence rejection or forced
 source-mutation loop. Focused completion, evidence, progressive-tool, runtime,
 and dynamic-budget suites plus the full npm suite pass for `0.20.303`.
+
+### Response-only context compaction after provider handoff
+
+`response-only-context-handoff-092` exercises a high-risk continuation boundary
+for DeepSeek-first operation with LocalLLM fallback. Recent same-session
+response-only evidence showed DeepSeek quota failures followed by LocalLLM
+resume attempts that failed before inference because the retained transcript
+exceeded the LocalLLM context window. Normal agent-step requests already had a
+local context-budget compaction retry, but the explicit response-only branch
+called the direct-response client without that recovery path.
+
+AgInTiFlow now catches only `LOCALLLM_CONTEXT_BUDGET_EXCEEDED` in the
+response-only branch, compacts the authoritative retained goal/evidence once,
+persists `model.local_context_budget_exceeded` and
+`history.compacted_for_local_context_retry`, and retries the same response-only
+request with a bounded output reserve. The source-free evidence guard remains
+active after compaction, so unsupported publication, validation, forecast,
+benchmark, or metric claims still retry once and then fail closed.
+
+The focused regression seeds a DeepSeek-owned response-only session, inflates
+retained same-session context, resumes with a normal "answer from the saved
+status" prompt, triggers a DeepSeek quota handoff, and verifies that LocalLLM is
+called only after compaction. The run completes without `session.failed`, keeps
+the provider handoff active on the same session, and records the compaction
+events as durable evidence.
+
+### Harmless tool-call annotations during repository discovery
+
+`inspect-project-annotation-093` covers a DeepSeek-first tool-loop boundary
+that was still under-tested after the provider handoff work. Recent runtime
+evidence showed ordinary project-inspection tasks stopping with
+`tool_contract_violation` before dispatch because the model included a
+non-executable `reason` field in an otherwise valid `inspect_project` call.
+The strict per-turn schema correctly rejected unknown executable fields, but
+the existing benign-annotation normalizer only recognized `description`.
+
+AgInTiFlow now treats a bounded string `reason` exactly like `description`: it
+is removed before schema validation only when the offered tool schema forbids
+additional properties and the schema does not define that field. Structured,
+non-string, oversized, or executable unknown fields still fail closed.
+
+The regression uses a normal weak prompt asking the agent to look over a small
+repository and report whether a README exists. The scripted DeepSeek-shaped
+response calls `inspect_project` with `reason` plus a real `limit`; the persisted
+runtime dispatches the inspection, records zero tool-contract failures, and
+finishes with the verified README status without mutating the workspace.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.328",
+  "version": "0.20.330",
   "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-progressive-tool-selection.js

@@ -7238,6 +7238,54 @@ assert(
   ).ok,
   "valid offered tool call did not satisfy its exact schema"
 );
+const strictInspectDescriptor = {
+  type: "function",
+  function: {
+    name: "inspect_project",
+    description: "Inspect the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        maxDepth: { type: "integer" },
+        limit: { type: "integer" },
+        includeFiles: { type: "boolean" },
+      },
+      additionalProperties: false,
+    },
+  },
+};
+const recoveredInspectReason = resolveDispatchableToolCallBatch(
+  [
+    contractCall("inspect-with-reason", "inspect_project", {
+      reason: "Orient before answering the user's project question.",
+      limit: 120,
+    }),
+  ],
+  createToolContract([strictInspectDescriptor])
+);
+assert(
+  recoveredInspectReason.ok && recoveredInspectReason.recoveredToolCallAnnotations,
+  "a harmless inspect_project reason annotation was not stripped before schema validation"
+);
+assertStrict.deepEqual(
+  JSON.parse(recoveredInspectReason.acceptedToolCalls[0].function.arguments),
+  { limit: 120 },
+  "inspect_project reason annotation recovery changed executable arguments"
+);
+const rejectedStructuredInspectReason = resolveDispatchableToolCallBatch(
+  [
+    contractCall("inspect-structured-reason", "inspect_project", {
+      reason: { intent: "orient" },
+      limit: 120,
+    }),
+  ],
+  createToolContract([strictInspectDescriptor])
+);
+assert(
+  !rejectedStructuredInspectReason.ok,
+  "a structured inspect_project reason annotation was stripped even though it is not a bounded text note"
+);
 
 const safeReadDescriptors = [
   {
@@ -7877,6 +7925,73 @@ assert(
   "authoritative routine flow still dispatched private/raw exploratory commands"
 );
 
+let annotatedInspectStep = 0;
+const annotatedInspectRun = await runToolContractCase({
+  id: "inspect-project-reason-annotation",
+  provider: "deepseek",
+  profile: "code",
+  goal: "Please look over this little repo and tell me whether it has a README. Keep it short.",
+  toolCalls: [
+    contractCall("unused-annotated-inspect", "finish", { result: "unused" }),
+  ],
+  expectSuccess: true,
+  expectedContractFailures: 0,
+  setupWorkspace: async (workspace) => {
+    await fs.writeFile(
+      path.join(workspace, "README.md"),
+      "# Demo\nThis workspace has a README.\n",
+      "utf8"
+    );
+  },
+  responseFactory: ({ payload }) => {
+    annotatedInspectStep += 1;
+    const offered = Array.isArray(payload.tools) ? names(payload.tools) : [];
+    if (annotatedInspectStep === 1) {
+      assert(
+        offered.includes("inspect_project"),
+        "normal repository orientation did not offer inspect_project"
+      );
+      return assistantWithToolCalls([
+        contractCall("inspect-with-natural-reason", "inspect_project", {
+          reason: "Orient before answering the user's project question.",
+          limit: 120,
+        }),
+      ]);
+    }
+    return assistantWithToolCalls([
+      contractCall("finish-after-annotated-inspect", "finish", {
+        result: "README.md is present.",
+      }),
+    ]);
+  },
+});
+assertStrict.equal(
+  annotatedInspectRun.requests.length,
+  2,
+  "annotated inspect_project recovery used extra model turns"
+);
+assert(
+  annotatedInspectRun.events.some(
+    (event) =>
+      event.type === "tool.completed" &&
+      event.data?.toolName === "inspect_project" &&
+      event.data?.ok === true
+  ),
+  "annotated inspect_project call was not dispatched through the real runtime"
+);
+assert(
+  !annotatedInspectRun.events.some(
+    (event) =>
+      event.type === "tool.failed" &&
+      event.data?.category === "tool-contract-violation"
+  ),
+  "annotated inspect_project still produced a tool-contract violation"
+);
+assert(
+  /README\.md is present/.test(String(annotatedInspectRun.result?.result || "")),
+  "annotated inspect_project run did not finish with the promised repository status"
+);
+
 const hiddenDryRun = await runToolContractCase({
   id: "native-hidden-dry-run",
   goal: "Create hidden-dry-run.txt containing unsafe if this tool dispatches.",

package/src/agent-runner.js

@@ -4155,6 +4155,72 @@ function responseOnlySourceFreeStopResult(assessment = {}) {
 }
 
 async function finishWithResponseOnlyModelTurn({ client, config, state, store, observers, sessionId }) {
+  async function requestWithResponseOnlyLocalContextRecovery({ step, mode }) {
+    try {
+      return await requestDirectResponse(client, config, state.messages);
+    } catch (error) {
+      if (!isLocalContextBudgetError(error)) throw error;
+      state.meta = state.meta || {};
+      const retried = state.meta.localContextBudgetRetries || {};
+      const retryKey = `response-only:${mode}`;
+      if (retried[retryKey]) throw error;
+
+      const requestMessages = Array.isArray(state.messages) ? state.messages : [];
+      const currentOutputTokens = Math.max(0, Number(config.maxOutputTokens || 0));
+      const retryOutputTokens = currentOutputTokens
+        ? Math.min(currentOutputTokens, 4096)
+        : 4096;
+      const retryRuntimeConfig = {
+        ...config,
+        maxOutputTokens: retryOutputTokens,
+      };
+      const compactMessages = buildContextBudgetCompactionMessages(
+        state,
+        retryRuntimeConfig,
+        null,
+        step,
+        {
+          heading: "A response-only LocalLLM request exceeded the local context window.",
+          detail: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+          recoveryInstruction:
+            "Answer the current response-only request directly from the compacted authoritative context above. Do not claim fresh external evidence unless the compacted context contains a current evidence manifest or scoped tool evidence.",
+        }
+      );
+      const detail = {
+        step,
+        mode,
+        provider: config.provider,
+        model: config.model,
+        messageCharsBefore: countMessageChars(requestMessages),
+        messageCharsAfter: countMessageChars(compactMessages),
+        messageTokensBefore: estimateMessageTokens(requestMessages),
+        messageTokensAfter: estimateMessageTokens(compactMessages),
+        maxOutputTokens: retryOutputTokens,
+        error: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+      };
+      state.messages = compactMessages;
+      resetStaticDiscoveryAfterContextLoss(state, "response-only-local-context-budget-retry", {
+        preserveStaticEvidence: true,
+      });
+      state.meta.localContextBudgetRetries = {
+        ...retried,
+        [retryKey]: true,
+      };
+      state.meta.lastResponseOnlyContextBudgetRecovery = detail;
+      await store.appendEvent("model.local_context_budget_exceeded", detail);
+      await store.appendEvent("history.compacted_for_local_context_retry", detail);
+      observers.event("model.local_context_budget_exceeded", detail);
+      observers.event("history.compacted_for_local_context_retry", detail);
+      emitConsole(
+        config,
+        "Local provider context exceeded its configured window for a response-only turn; compacted authoritative context and retrying once.",
+        { kind: "meta" }
+      );
+      await store.saveState(state);
+      return await requestDirectResponse(client, retryRuntimeConfig, state.messages);
+    }
+  }
+
   await store.appendEvent("model.requested", {
     step: 1,
     provider: config.provider,
@@ -4168,7 +4234,10 @@ async function finishWithResponseOnlyModelTurn({ client, config, state, store, o
     mode: "response-only",
   });
 
-  const response = await requestDirectResponse(client, config, state.messages);
+  const response = await requestWithResponseOnlyLocalContextRecovery({
+    step: 1,
+    mode: "response-only",
+  });
   const rawAssistantMessage = response.choices[0]?.message;
   let result = responseOnlyResultFromMessage(rawAssistantMessage);
   let finalAssistantMessage = rawAssistantMessage;
@@ -4208,7 +4277,10 @@ async function finishWithResponseOnlyModelTurn({ client, config, state, store, o
       model: config.model,
       mode: "response-only-repair",
     });
-    const repairResponse = await requestDirectResponse(client, config, state.messages);
+    const repairResponse = await requestWithResponseOnlyLocalContextRecovery({
+      step: 2,
+      mode: "response-only-repair",
+    });
     finalAssistantMessage = repairResponse.choices[0]?.message;
     result = responseOnlyResultFromMessage(finalAssistantMessage);
     sourceFreeAssessment = await assessResponseOnlySourceFreeClaims({

package/src/tool-contract.js

@@ -30,7 +30,7 @@ const MAX_VALIDATION_ERRORS = 8;
 const MAX_VALIDATION_NODES = 50_000;
 const MAX_SAFE_SEQUENTIAL_READ_CALLS = 4;
 const MAX_REPORTED_SEQUENTIAL_CALLS = 12;
-const BENIGN_TOOL_CALL_ANNOTATION_KEYS = new Set(["description"]);
+const BENIGN_TOOL_CALL_ANNOTATION_KEYS = new Set(["description", "reason"]);
 
 function cloneValue(value) {
   return structuredClone(value);