@lazyingart/agintiflow 0.20.327 → 0.20.329

package/docs/supervision-campaign-ledger.md

@@ -675,3 +675,28 @@ 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.327",
+  "version": "0.20.329",
   "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-truthful-completion.js

@@ -14,7 +14,11 @@ import {
 } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { SessionStore } from "../src/session-store.js";
-import { deriveScsTaskContract, finishResultClaimsIncompleteWork } from "../src/scs-evidence.js";
+import {
+  deriveScsTaskContract,
+  evaluateSourceFreeResponseClaims,
+  finishResultClaimsIncompleteWork,
+} 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-truthful-completion-"));
@@ -180,6 +184,114 @@ assert.equal(
   "agent-owned pending validation was accepted as a completed result"
 );
 
+const sourceFreeResearchGoal = [
+  "Correct the research status from the host-managed response context.",
+  `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+    mode: "host-managed-response",
+    request: "Correct the research status from the host-managed response context.",
+  })}`,
+].join("\n");
+const unsafeSourceFreeClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "The publication appeared in 2025 and was validated on a 12,000-case benchmark with 94.2% accuracy.",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  unsafeSourceFreeClaim.ok,
+  false,
+  "source-free response-only output accepted unsupported external factual claims"
+);
+assert(unsafeSourceFreeClaim.categories.includes("publication"));
+assert(unsafeSourceFreeClaim.categories.includes("benchmark_or_metric"));
+const unsafeChineseSourceFreeClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "这是未验证的背景说明。2025年Nature子刊预印本未公开，已有初步验证，响应延迟低于100ms，并预测2026年底前上线。",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  unsafeChineseSourceFreeClaim.ok,
+  false,
+  "Chinese source-free response-only output accepted publication, validation, metric, or forecast claims"
+);
+assert(unsafeChineseSourceFreeClaim.categories.includes("publication"));
+assert(unsafeChineseSourceFreeClaim.categories.includes("validation"));
+assert(unsafeChineseSourceFreeClaim.categories.includes("benchmark_or_metric"));
+assert(unsafeChineseSourceFreeClaim.categories.includes("forecast"));
+const unsafeJapaneseSourceFreeClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "2026年末までに公開される見込みで、査読済み研究によりレイテンシ80ms未満が検証済みです。",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  unsafeJapaneseSourceFreeClaim.ok,
+  false,
+  "Japanese source-free response-only output accepted publication, validation, metric, or forecast claims"
+);
+assert(unsafeJapaneseSourceFreeClaim.categories.includes("forecast"));
+assert(unsafeJapaneseSourceFreeClaim.categories.includes("validation"));
+assert(unsafeJapaneseSourceFreeClaim.categories.includes("benchmark_or_metric"));
+const framedHypothesisClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "Without fresh evidence, this is an unverified hypothesis only: the result may need a new literature check before any publication or benchmark claim is trusted.",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  framedHypothesisClaim.ok,
+  true,
+  "explicit unverified hypothesis framing was rejected for source-free response-only output"
+);
+const locallyDeniedChineseClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "没有本次新证据，这只是未验证假设：无法验证Nature子刊、2025年发表、已有验证或100ms延迟等说法。",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  locallyDeniedChineseClaim.ok,
+  true,
+  "local Chinese unverifiable/hypothesis framing was rejected"
+);
+const separatedUnverifiedClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "This paragraph is unverified. The Nature publication appeared in 2025 and validation reached 94.2% accuracy.",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  separatedUnverifiedClaim.ok,
+  false,
+  "a generic unverified phrase in one sentence governed a separate unsupported factual claim"
+);
+const ordinaryPureChat = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult: "A recursive function needs a base case so it can stop.",
+  evidenceLedger: { itemCount: 0, categories: [], items: [] },
+});
+assert.equal(
+  ordinaryPureChat.ok,
+  true,
+  "ordinary source-free pure chat was incorrectly rejected"
+);
+const sourcedResponseOnlyClaim = evaluateSourceFreeResponseClaims({
+  goal: sourceFreeResearchGoal,
+  candidateResult:
+    "The retained manifest says the benchmark accuracy is 94.2%.",
+  evidenceLedger: {
+    itemCount: 1,
+    categories: ["command"],
+    items: [{ category: "command", verified: true }],
+  },
+});
+assert.equal(
+  sourcedResponseOnlyClaim.ok,
+  true,
+  "response-only output with current scoped evidence was rejected"
+);
+
 const staleCompletionRepair =
   "The proposed completion was rejected because the requested action is not supported by concrete runtime evidence. Reason: Missing required git action(s): commit.";
 const repairCleanup = removeSupersededCompletionRepairInstructions([

package/src/agent-runner.js

@@ -140,6 +140,7 @@ import {
   evaluateScsSemanticContract,
   evaluateRequestedArtifactRequirements,
   augmentScsTaskContractWithProjectVerification,
+  evaluateSourceFreeResponseClaims,
   agintiEvidenceScopeLine,
   filterExplicitlyExcludedOutputPaths,
   extractMarkdownCommandEvidence,
@@ -4099,7 +4100,127 @@ async function finishWithDirectAnswer({ config, state, store, observers, session
   };
 }
 
+function responseOnlyResultFromMessage(message = {}) {
+  if (!message) {
+    throw new Error("Response-only model request returned no assistant message.");
+  }
+  if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
+    throw new Error("Response-only model request returned an unexpected tool call.");
+  }
+  const result = redactSensitiveText(message.content || "").trim();
+  if (!result) {
+    throw new Error("Response-only model request returned empty content.");
+  }
+  return result;
+}
+
+async function assessResponseOnlySourceFreeClaims({ config, state, store, result }) {
+  const scoped = currentContinuationEvidence(state, await store.loadEvents());
+  const ledger = buildScsEvidenceLedger({
+    state: scoped.state,
+    context: {
+      events: scoped.events,
+      taskProfile: config.taskProfile,
+      goal: config.goal,
+    },
+  });
+  return evaluateSourceFreeResponseClaims({
+    goal: completionContractGoal(config, state),
+    candidateResult: result,
+    evidenceLedger: ledger,
+  });
+}
+
+function responseOnlySourceFreeRepairInstruction(assessment = {}) {
+  const categories = Array.isArray(assessment.categories) && assessment.categories.length
+    ? assessment.categories.join(", ")
+    : "external factual claims";
+  return [
+    "No fresh AgInTi evidence manifest or scoped tool evidence is available for this response-only turn.",
+    `Your previous answer asserted unsupported external facts (${categories}).`,
+    "Do not claim publications, years, validation, forecasts, benchmarks, quantitative metrics, citations, or source-backed conclusions.",
+    "This includes multilingual claim wording such as 已有验证, 预测, 検証済み, or 予測.",
+    "Return a concise answer that is explicitly framed as an unverified hypothesis, or state that the requested external claim cannot be verified from this run.",
+  ].join(" ");
+}
+
+function responseOnlySourceFreeStopResult(assessment = {}) {
+  const categories = Array.isArray(assessment.categories) && assessment.categories.length
+    ? assessment.categories.join(", ")
+    : "external factual claims";
+  return [
+    "No result: this response-only turn has no fresh AgInTi evidence manifest or scoped tool evidence.",
+    `I cannot verify the requested ${categories} from this run. Resume with an evidence-producing research/tool scope or provide a fresh evidence manifest.`,
+  ].join(" ");
+}
+
 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,
@@ -4113,17 +4234,116 @@ 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;
-  if (!rawAssistantMessage) {
-    throw new Error("Response-only model request returned no assistant message.");
-  }
-  if (Array.isArray(rawAssistantMessage.tool_calls) && rawAssistantMessage.tool_calls.length) {
-    throw new Error("Response-only model request returned an unexpected tool call.");
-  }
-  const result = redactSensitiveText(rawAssistantMessage.content || "").trim();
-  if (!result) {
-    throw new Error("Response-only model request returned empty content.");
+  let result = responseOnlyResultFromMessage(rawAssistantMessage);
+  let finalAssistantMessage = rawAssistantMessage;
+  let sourceFreeAssessment = await assessResponseOnlySourceFreeClaims({
+    config,
+    state,
+    store,
+    result,
+  });
+  if (!sourceFreeAssessment.ok) {
+    const detail = {
+      step: 1,
+      mode: "response-only",
+      reason: sourceFreeAssessment.reason,
+      categories: sourceFreeAssessment.categories,
+      hasEvidence: sourceFreeAssessment.hasEvidence,
+      explicitlyUnverified: sourceFreeAssessment.explicitlyUnverified,
+      preview: publicCompletionText(result, 300),
+      unsupportedClaims: sourceFreeAssessment.unsupportedClaims || [],
+    };
+    await store.appendEvent("response_only.source_free_claim_rejected", detail);
+    observers.event("response_only.source_free_claim_rejected", detail);
+    state.messages.push({
+      role: "user",
+      content: responseOnlySourceFreeRepairInstruction(sourceFreeAssessment),
+    });
+    await store.saveState(state);
+    await store.appendEvent("model.requested", {
+      step: 2,
+      provider: config.provider,
+      model: config.model,
+      mode: "response-only-repair",
+    });
+    observers.event("model.requested", {
+      step: 2,
+      provider: config.provider,
+      model: config.model,
+      mode: "response-only-repair",
+    });
+    const repairResponse = await requestWithResponseOnlyLocalContextRecovery({
+      step: 2,
+      mode: "response-only-repair",
+    });
+    finalAssistantMessage = repairResponse.choices[0]?.message;
+    result = responseOnlyResultFromMessage(finalAssistantMessage);
+    sourceFreeAssessment = await assessResponseOnlySourceFreeClaims({
+      config,
+      state,
+      store,
+      result,
+    });
+    if (sourceFreeAssessment.ok) {
+      const repaired = {
+        step: 2,
+        mode: "response-only-repair",
+        reason: sourceFreeAssessment.reason,
+        categories: sourceFreeAssessment.categories,
+        explicitlyUnverified: sourceFreeAssessment.explicitlyUnverified,
+        unsupportedClaims: sourceFreeAssessment.unsupportedClaims || [],
+      };
+      await store.appendEvent("response_only.source_free_claim_repaired", repaired);
+      observers.event("response_only.source_free_claim_repaired", repaired);
+    } else {
+      result = responseOnlySourceFreeStopResult(sourceFreeAssessment);
+      const fallback = {
+        step: 2,
+        mode: "response-only-fail-closed",
+        reason: sourceFreeAssessment.reason,
+        categories: sourceFreeAssessment.categories,
+        unsupportedClaims: sourceFreeAssessment.unsupportedClaims || [],
+        result: publicCompletionText(result, 500),
+      };
+      state.meta = state.meta || {};
+      state.meta.responseOnly = {
+        stoppedAt: new Date().toISOString(),
+        provider: config.provider,
+        model: config.model,
+        sourceFreeClaimBlocked: true,
+      };
+      state.updatedAt = state.meta.responseOnly.stoppedAt;
+      state.messages.push({ role: "assistant", content: result });
+      appendChatEntry(state, "assistant", result);
+      updateGoalStatus(state, "paused", "source_free_evidence_required", state.updatedAt);
+      await store.saveState(state);
+      await store.appendEvent("response_only.source_free_claim_failed_closed", fallback);
+      await store.appendEvent("session.stopped", {
+        reason: "source_free_evidence_required",
+        result,
+        mode: "response-only",
+      });
+      observers.event("response_only.source_free_claim_failed_closed", fallback);
+      observers.event("session.stopped", {
+        reason: "source_free_evidence_required",
+        result,
+        sessionId,
+        mode: "response-only",
+      });
+      emitConsole(config, result, { kind: "assistant", markdown: true });
+      return {
+        sessionId,
+        stopped: true,
+        reason: "source_free_evidence_required",
+        result,
+        ...goalRunMetadata(state),
+      };
+    }
   }
 
   state.meta = state.meta || {};
@@ -4135,7 +4355,7 @@ async function finishWithResponseOnlyModelTurn({ client, config, state, store, o
   state.stepsCompleted = 1;
   state.updatedAt = state.meta.responseOnly.completedAt;
   state.messages.push(preserveAssistantMessage({
-    ...rawAssistantMessage,
+    ...finalAssistantMessage,
     role: "assistant",
     content: result,
     tool_calls: undefined,

package/src/model-client.js

@@ -300,6 +300,7 @@ export async function requestDirectResponse(client, config, messages = []) {
         "Response-only scope: return the requested final content directly as the assistant response.",
         "Do not produce an execution plan, call tools, mention internal runtime details, or stop at a placeholder.",
         "Preserve every material requirement and all source-grounded details supplied in the current request.",
+        "If no fresh evidence manifest or source text is present, do not claim publications, years, validation, forecasts, benchmarks, quantitative metrics, citations, or source-backed conclusions; in English, Chinese, Japanese, or any other response language, frame such material locally as an unverified hypothesis or say it cannot be verified from this run.",
       ].join(" "),
     },
   ];

package/src/scs-evidence.js

@@ -1825,6 +1825,191 @@ export function isResponseOnlyEvidenceScope(goal = "") {
   return ["chat-response", "host-managed-response", "plan-response", "read-only-answer"].includes(mode);
 }
 
+function responseOnlyScopeHasFreshEvidenceManifest(goal = "") {
+  const payload = parseAgintiEvidenceScope(goal);
+  if (!payload || typeof payload !== "object") return false;
+  const manifestCandidates = [
+    payload.evidenceManifest,
+    payload.evidence_manifest,
+    payload.freshEvidenceManifest,
+    payload.fresh_evidence_manifest,
+    payload.sourceManifest,
+    payload.source_manifest,
+    payload.manifestDigest,
+    payload.manifest_digest,
+    payload.evidenceDigest,
+    payload.evidence_digest,
+    payload.sourceDigest,
+    payload.source_digest,
+  ];
+  return manifestCandidates.some((item) => {
+    if (typeof item === "string") return item.trim().length >= 12;
+    if (item && typeof item === "object") return Object.keys(item).length > 0;
+    return Array.isArray(item) && item.length > 0;
+  });
+}
+
+function sourceFreeResponseHasEvidence(ledger = {}) {
+  if (!ledger || typeof ledger !== "object") return false;
+  if (Number(ledger.itemCount || 0) > 0) return true;
+  if (Array.isArray(ledger.items) && ledger.items.some((item) => item?.verified !== false)) return true;
+  if (Array.isArray(ledger.categories) && ledger.categories.length > 0) return true;
+  return false;
+}
+
+function sourceFreeClaimSegments(text = "") {
+  return String(text || "")
+    .split(/(?:[\n\r]+|(?<=[.!?。！？;；]))/u)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function sourceFreeClaimSegmentHasExplicitUnverifiedFraming(text = "") {
+  const value = String(text || "");
+  const admitsNoEvidence =
+    /\b(?:unverified|not\s+verified|cannot\s+verify|can't\s+verify|could\s+not\s+verify|no\s+(?:fresh\s+)?(?:evidence|sources?|manifest)|without\s+(?:fresh\s+)?(?:evidence|sources?|manifest))\b/iu.test(
+      value
+    ) ||
+    /(?:没有|沒有|无|無|缺少|未获得|未取得|未取得到)(?:新鲜|新鮮|当前|當前|本次|新的)?(?:证据|證據|来源|來源|资料|資料|文献|文獻|检索|檢索|材料)/u.test(
+      value
+    ) ||
+    /(?:无法|無法|不能|未能|没法|沒法)(?:在本次|从本次|從本次)?(?:验证|驗證|核实|核實|证实|證實|确认|確認|证明|證明|支持)/u.test(
+      value
+    ) ||
+    /(?:証拠|出典|根拠|資料|ソース)(?:が)?(?:ない|ありません|不足)|(?:検証|確認|裏付け)(?:できない|されていない|できません)|未検証/u.test(
+      value
+    );
+  const framesAsHypothesis =
+    /\b(?:hypothesis|hypotheses|speculative|speculation|not\s+(?:a\s+)?(?:verified|evidence-backed|source-backed)\s+claim)\b/iu.test(
+      value
+    ) ||
+    /(?:假设|假說|推测|推測|猜测|猜測|臆测|臆測|未验证|未經驗證|未经验证|未核实|未核實)/u.test(
+      value
+    ) ||
+    /(?:仮説|推測|憶測|未検証|未確認)/u.test(value);
+  return admitsNoEvidence && framesAsHypothesis;
+}
+
+function sourceFreeClaimSegmentDeniesVerification(text = "") {
+  const value = String(text || "");
+  return (
+    /\b(?:cannot|can't|could\s+not|do\s+not|don't|unable\s+to|not\s+able\s+to|no\s+(?:fresh\s+)?(?:evidence|source|manifest)\s+to|without\s+(?:fresh\s+)?(?:evidence|sources?|manifest),?\s+(?:i\s+)?(?:cannot|can't|could\s+not)?)\b[^.!?;。！？；\n]{0,140}\b(?:verify|confirm|substantiate|support|validate|prove|claim)\b/iu.test(
+      value
+    ) ||
+    /(?:无法|無法|不能|未能|没法|沒法|不应|不應|不能够|不能夠|没有证据|沒有證據|无证据|無證據)[^。！？；\n]{0,80}(?:验证|驗證|核实|核實|证实|證實|确认|確認|证明|證明|支持|声称|聲稱|断言|斷言)/u.test(
+      value
+    ) ||
+    /(?:検証|確認|裏付け|断言|主張)(?:できない|できません|されていない)|(?:証拠|出典|根拠)(?:が)?(?:ない|ありません)[^。！？；\n]{0,60}(?:検証|確認|主張|断言)/u.test(
+      value
+    )
+  );
+}
+
+function sourceFreeExternalClaimCategoriesForSegment(text = "") {
+  const value = String(text || "");
+  if (!value.trim()) return [];
+  const categories = [];
+  const add = (category, pattern) => {
+    pattern.lastIndex = 0;
+    if (pattern.test(value)) categories.push(category);
+  };
+  add(
+    "publication",
+    /\b(?:paper|study|article|preprint|publication|manuscript|dataset|trial|journal|conference|arxiv|doi|nature|science|cell)\b[^.!?;。！？；\n]{0,140}\b(?:published|appeared|released|accepted|reported|found|showed|demonstrated|validated)\b|\b(?:published|accepted|released)\b[^.!?;。！？；\n]{0,80}\b(?:paper|study|article|preprint|publication|manuscript|dataset|trial|journal|conference|arxiv|doi|nature|science|cell)\b|(?:Nature|Science|Cell|子刊|期刊|论文|論文|预印本|預印本|文章|研究|数据集|資料集|データセット|論文|研究|プレプリント|ジャーナル)[^.!?;。！？；\n]{0,80}(?:发表|發表|刊登|出版|公开|公開|收录|收録|发布|發布|掲載|発表|公開|出版)|(?:发表|發表|刊登|出版|公开|公開|收录|收録|发布|發布|掲載|発表|公開|出版)[^.!?;。！？；\n]{0,80}(?:Nature|Science|Cell|子刊|期刊|论文|論文|预印本|預印本|文章|研究|数据集|資料集|データセット|論文|研究|プレプリント|ジャーナル)/iu
+  );
+  add(
+    "year",
+    /\b(?:published|released|announced|accepted|reported|validated|verified|evaluated|benchmarked|forecast(?:ed)?|projected|predicted)\b[^.!?;。！？；\n]{0,100}\b(?:19|20)\d{2}\b|\b(?:19|20)\d{2}\b[^.!?;。！？；\n]{0,100}\b(?:publication|paper|study|article|benchmark|forecast|projection|dataset|trial|validation|release)\b|(?:19|20)\d{2}\s*年?[^.!?;。！？；\n]{0,80}(?:Nature|Science|Cell|子刊|期刊|论文|論文|预印本|預印本|文章|研究|发表|發表|发布|發布|预测|預測|预计|預計|验证|驗證|基准|基準|指标|指標|論文|研究|発表|公開|掲載|予測|検証|ベンチマーク)|(?:Nature|Science|Cell|子刊|期刊|论文|論文|预印本|預印本|文章|研究|发表|發表|发布|發布|预测|預測|预计|預計|验证|驗證|基准|基準|指标|指標|論文|研究|発表|公開|掲載|予測|検証|ベンチマーク)[^.!?;。！？；\n]{0,80}(?:19|20)\d{2}\s*年?/iu
+  );
+  add(
+    "validation",
+    /\b(?:validated|verified|proven|confirmed|replicated|peer-reviewed|source-backed|evidence-backed|grounded\s+in\s+(?:sources?|evidence)|the\s+evidence\s+(?:shows|confirms|validates|proves))\b|(?:已有|已经|已經|已经有|已經有|已|初步|经过|經過|得到|获得|獲得)[^。！？；\n]{0,20}(?:验证|驗證|核实|核實|证实|證實|确认|確認|证明|證明)|(?:验证|驗證|核实|核實|证实|證實|确认|確認|证明|證明)(?:通过|通過|完成|成功|结果|結果)|(?:検証済み|確認済み|実証済み|裏付けられた|査読済み)/iu
+  );
+  add(
+    "forecast",
+    /\b(?:forecast|forecasted|predict(?:s|ed|ion)?|project(?:s|ed|ion)?|expected\s+to|will\s+(?:reach|increase|decrease|grow|decline|outperform|underperform)|cagr)\b|(?:预测|預測|预计|預計|估计|估計|推算|推測|到\s*(?:19|20)\d{2}\s*年?(?:底|末)?(?:前|之前)?|(?:19|20)\d{2}\s*年?(?:底|末)?(?:前|之前)?[^。！？；\n]{0,40}(?:将|將|会|會|预计|預計|预测|預測))|(?:予測|予想|見込み|推定|年末まで|までに)/iu
+  );
+  add(
+    "benchmark_or_metric",
+    /\b(?:benchmark(?:ed|s)?|metric|score|accuracy|precision|recall|f1|auc|bleu|rouge|latency|throughput|validated\s+on|evaluated\s+on)\b[^.!?;。！？；\n]{0,100}\b\d[\d,.]*(?:\s*(?:%|percent|cases?|subjects?|participants?|patients?|samples?|records?|tokens?\/s|requests?\/s|ms|seconds?|x))?\b|\b\d[\d,.]*(?:\.\d+)?\s*(?:%|percent|cases?|subjects?|participants?|patients?|samples?|records?|benchmarks?|tokens?\/s|requests?\/s|ms|seconds?)\b[^.!?;。！？；\n]{0,100}\b(?:accuracy|validated|verified|benchmark|forecast|prediction|projection|reliable|better|improved|increase|decrease)\b|(?:响应延迟|響應延遲|响应时间|響應時間|延迟|延遲|准确率|準確率|精度|召回|吞吐|基准|基準|指标|指標|分数|分數|反応遅延|レイテンシ|精度|ベンチマーク|指標|スコア)[^。！？；\n]{0,60}\d[\d,.]*(?:\s*(?:%|％|ms|毫秒|秒|例|个|個|件|倍|x))?|\d[\d,.]*(?:\.\d+)?\s*(?:%|％|ms|毫秒|秒|例|个|個|件|倍|x)[^。！？；\n]{0,60}(?:响应延迟|響應延遲|响应时间|響應時間|延迟|延遲|准确率|準確率|精度|召回|吞吐|基准|基準|指标|指標|分数|分數|反応遅延|レイテンシ|精度|ベンチマーク|指標|スコア)/iu
+  );
+  add(
+    "external_evidence",
+    /\b(?:according\s+to|as\s+reported\s+by|sources?\s+(?:show|say|indicate|confirm|report)|cit(?:e|ation|ed)|doi\s*[:/]|arxiv\s*[:/]|the\s+(?:paper|study|source|evidence)\s+(?:shows|states|reports|confirms|validates))\b|(?:根据|根據|据|據|来源|來源|资料|資料|证据|證據|文献|文獻|论文|論文|引用)[^。！？；\n]{0,50}(?:显示|顯示|表明|指出|报道|報道|证明|證明|验证|驗證|确认|確認)|(?:によると|出典|証拠|根拠|引用|論文|研究)[^。！？；\n]{0,50}(?:示す|示した|報告|確認|検証)/iu
+  );
+  return unique(categories);
+}
+
+function sourceFreeExternalClaimAssessment(text = "") {
+  const segments = sourceFreeClaimSegments(text);
+  const categories = [];
+  const unsupported = [];
+  for (const segment of segments) {
+    const segmentCategories = sourceFreeExternalClaimCategoriesForSegment(segment);
+    if (!segmentCategories.length) continue;
+    categories.push(...segmentCategories);
+    const deniesVerification = sourceFreeClaimSegmentDeniesVerification(segment);
+    const explicitlyUnverified = sourceFreeClaimSegmentHasExplicitUnverifiedFraming(segment);
+    const assertsEvidence = segmentCategories.some((category) =>
+      ["validation", "external_evidence"].includes(category)
+    );
+    if (!deniesVerification && (assertsEvidence || !explicitlyUnverified)) {
+      unsupported.push({
+        categories: segmentCategories,
+        preview: compact(segment, 240),
+      });
+    }
+  }
+  return {
+    categories: unique(categories),
+    unsupported,
+    explicitlyUnverified:
+      categories.length > 0 &&
+      unsupported.length === 0 &&
+      segments.some((segment) => sourceFreeClaimSegmentHasExplicitUnverifiedFraming(segment)),
+  };
+}
+
+export function evaluateSourceFreeResponseClaims({
+  goal = "",
+  candidateResult = "",
+  evidenceLedger = {},
+} = {}) {
+  if (!isResponseOnlyEvidenceScope(goal)) {
+    return {
+      checked: false,
+      ok: true,
+      reason: "Not a response-only evidence scope.",
+      categories: [],
+      hasEvidence: false,
+      explicitlyUnverified: false,
+    };
+  }
+  const hasEvidence =
+    responseOnlyScopeHasFreshEvidenceManifest(goal) ||
+    sourceFreeResponseHasEvidence(evidenceLedger);
+  const claimAssessment = sourceFreeExternalClaimAssessment(candidateResult);
+  const categories = claimAssessment.categories;
+  const unsupportedClaims = claimAssessment.unsupported;
+  const explicitlyUnverified = claimAssessment.explicitlyUnverified;
+  const ok = hasEvidence || categories.length === 0 || unsupportedClaims.length === 0;
+  return {
+    checked: true,
+    ok,
+    reason: ok
+      ? hasEvidence
+        ? "Current scoped evidence is available for response-only factual claims."
+        : explicitlyUnverified
+          ? "Every source-free external claim is locally framed as unverified hypothesis or unverifiable."
+          : "No source-grounded external claim was detected."
+      : `Source-free response-only output claimed external facts without current evidence: ${categories.join(", ")}.`,
+    categories,
+    unsupportedClaims,
+    hasEvidence,
+    explicitlyUnverified,
+  };
+}
+
 export function scopedChatopsEvidenceGoal(goal = "", taskProfile = "") {
   const payload = parseAgintiEvidenceScope(goal);
   if (!payload) {