chainlesschain 0.166.56 → 0.166.58

package/src/lib/eval/outcomes.js

@@ -0,0 +1,373 @@
+import {
+  evalDigest,
+  evalHistoryRecordIssues,
+  evalExecutionSucceeded,
+} from "./evidence.js";
+
+export const OUTCOME_PLAN_SCHEMA = "chainlesschain.outcome-plan/v1";
+export const OUTCOME_REPORT_SCHEMA = "chainlesschain.outcome-report/v1";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const CATEGORIES = new Set([
+  "repair",
+  "support",
+  "compatibility",
+  "release",
+  "test-infrastructure",
+  "construction",
+]);
+const STAGES = ["install", "configure", "authenticate", "tool", "artifact"];
+const FAILURE_CAUSES = new Set([
+  "install",
+  "configuration-identity",
+  "model-protocol",
+  "tools-permissions",
+  "retrieval-context",
+  "recovery",
+  "artifact",
+  "environment",
+  "budget",
+  "manual-repair",
+]);
+const nonempty = (value) =>
+  typeof value === "string" && value.trim().length > 0;
+const nonnegative = (value) => Number.isFinite(value) && value >= 0;
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+const rate = (numerator, denominator) =>
+  denominator ? numerator / denominator : null;
+function assert(value, message) {
+  if (!value) throw new Error(message);
+}
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.keys(value)
+      .sort()
+      .map((key) => [key, canonical(value[key])]),
+  );
+}
+export function outcomeDigest(value) {
+  return evalDigest(JSON.stringify(canonical(value)));
+}
+function epoch(value) {
+  const time = Date.parse(value);
+  return typeof value === "string" &&
+    Number.isFinite(time) &&
+    new Date(time).toISOString() === value
+    ? time
+    : NaN;
+}
+function uniqueIndex(rows, key, label) {
+  assert(Array.isArray(rows), `${label} must be an array`);
+  const index = new Map();
+  for (const row of rows) {
+    assert(
+      row && nonempty(row[key]) && !index.has(row[key]),
+      `${label} contains a missing or duplicate ${key}`,
+    );
+    index.set(row[key], row);
+  }
+  return index;
+}
+
+export function validateOutcomePlan(plan) {
+  assert(plan?.schema === OUTCOME_PLAN_SCHEMA, "invalid outcome plan schema");
+  assert(
+    /^[a-f0-9]{40}$/u.test(plan.commitSha || ""),
+    "plan requires an exact commit SHA",
+  );
+  assert(/^[A-Z]{3}$/u.test(plan.currency || ""), "plan requires one currency");
+  assert(
+    epoch(plan.window?.start) < epoch(plan.window?.end),
+    "invalid observation window",
+  );
+  const samples = uniqueIndex(plan.samples, "id", "plan samples");
+  assert(
+    samples.size > 0 && samples.size <= 10000,
+    "plan requires 1–10000 samples",
+  );
+  for (const sample of samples.values()) {
+    assert(["task", "first-run"].includes(sample.kind), "invalid sample kind");
+    assert(
+      nonempty(sample.taskId) && nonempty(sample.stratum),
+      "sample requires taskId and stratum",
+    );
+    assert(
+      DIGEST.test(sample.comparisonDigest || ""),
+      "sample requires an Eval comparison digest",
+    );
+    assert(
+      nonnegative(sample.costBudget) &&
+        Number.isFinite(sample.timeBudgetMs) &&
+        sample.timeBudgetMs > 0,
+      "sample requires finite cost and time budgets",
+    );
+  }
+  return samples;
+}
+
+function summarize(rows) {
+  const succeeded = rows.filter((row) => row.succeeded).length;
+  const observed = rows.filter((row) => row.observed).length;
+  const knownCost = rows.reduce((sum, row) => sum + (row.cost ?? 0), 0);
+  const costsComplete = rows.every((row) => row.observed && row.cost !== null);
+  return {
+    planned: rows.length,
+    observed,
+    missing: rows.length - observed,
+    succeeded,
+    successRate: rate(succeeded, rows.length),
+    knownCost,
+    totalCost: costsComplete ? knownCost : null,
+    costPerSuccess: costsComplete && succeeded ? knownCost / succeeded : null,
+    retries: rows.every((row) => row.retries !== null)
+      ? rows.reduce((sum, row) => sum + row.retries, 0)
+      : null,
+    manualRepairs: rows.every((row) => row.manualRepairs !== null)
+      ? rows.reduce((sum, row) => sum + row.manualRepairs, 0)
+      : null,
+  };
+}
+
+/** Read-only measurement. Declarations and local Eval files are not attestations. */
+export function buildOutcomeReport(
+  { plan, history, observations = [], maintenance = null },
+  { now = Date.now(), expectedPlanDigest } = {},
+) {
+  const samples = validateOutcomePlan(plan);
+  assert(Number.isFinite(now), "invalid report time");
+  const planDigest = outcomeDigest(plan);
+  assert(
+    !expectedPlanDigest || expectedPlanDigest === planDigest,
+    "frozen plan digest mismatch",
+  );
+  const observed = uniqueIndex(observations, "sampleId", "observations");
+  for (const id of observed.keys())
+    assert(samples.has(id), "observation is outside the frozen plan");
+  const runs = uniqueIndex(history?.runs ?? [], "runId", "Eval history");
+  const issues = (history?.issues ?? []).map((issue) => issue.code);
+  if (epoch(plan.window.end) > now)
+    issues.push("observation_window_not_closed");
+  const usedEvidence = new Set();
+  const rows = [];
+  for (const sample of samples.values()) {
+    const observation = observed.get(sample.id);
+    const reasons = [];
+    const row = {
+      sampleId: sample.id,
+      kind: sample.kind,
+      taskId: sample.taskId,
+      stratum: sample.stratum,
+      observed: Boolean(observation),
+      succeeded: false,
+      reasons,
+      cost: null,
+      elapsedMs: null,
+      retries: null,
+      manualRepairs: null,
+      failureCause: null,
+      firstRunCompletedStages: [],
+    };
+    rows.push(row);
+    if (!observation) {
+      reasons.push("missing_observation");
+      issues.push(`${sample.id}:missing_observation`);
+      continue;
+    }
+    for (const key of ["cost", "elapsedMs", "retries", "manualRepairs"]) {
+      const valid = ["retries", "manualRepairs"].includes(key)
+        ? count(observation[key])
+        : nonnegative(observation[key]);
+      if (valid) row[key] = observation[key];
+      else reasons.push(`missing_or_invalid_${key}`);
+    }
+    const observedAt = epoch(observation.observedAt);
+    if (!(
+      observedAt <= Math.min(now, epoch(plan.window.end)) &&
+      observedAt - (row.elapsedMs ?? 0) >= epoch(plan.window.start)
+    ))
+      reasons.push("observation_outside_window");
+    const run = runs.get(observation.runId);
+    const stoppedBeforeTask =
+      sample.kind === "first-run" &&
+      observation.runId === null &&
+      observation.firstRun?.stages?.tool?.passed === false;
+    const evidenceKey = JSON.stringify([observation.runId, sample.taskId]);
+    if (observation.runId !== null) {
+      assert(
+        !usedEvidence.has(evidenceKey),
+        "a task execution cannot count as multiple samples",
+      );
+      usedEvidence.add(evidenceKey);
+    }
+    if (!run && !stoppedBeforeTask) reasons.push("missing_eval_run");
+    if (run) {
+      // Failed executions are valid observations, not successful outcomes.
+      // All other existing Eval integrity rules remain authoritative.
+      const integrity = evalHistoryRecordIssues(
+        run,
+        now,
+        Math.max(1, now - epoch(plan.window.start)),
+      ).filter((reason) => reason !== "execution_not_successful");
+      reasons.push(...integrity);
+      if (run.label !== plan.commitSha) reasons.push("commit_mismatch");
+      if (outcomeDigest(run.comparison) !== sample.comparisonDigest)
+        reasons.push("comparison_mismatch");
+      if (!(
+        epoch(run.ranAt) >= epoch(plan.window.start) &&
+        epoch(run.ranAt) <= epoch(plan.window.end)
+      ))
+        reasons.push("run_outside_window");
+    }
+    const result = run?.results?.find((item) => item?.id === sample.taskId);
+    if (!result && !stoppedBeforeTask) reasons.push("missing_task_result");
+    if (result && (!nonnegative(result.ms) || row.elapsedMs < result.ms))
+      reasons.push("invalid_elapsed_time");
+    if (sample.kind === "first-run") {
+      if (typeof observation.firstRun?.cleanEnvironment !== "boolean")
+        reasons.push("missing_clean_environment_evidence");
+      for (const stage of STAGES) {
+        const evidence = observation.firstRun?.stages?.[stage];
+        if (
+          !evidence ||
+          typeof evidence.passed !== "boolean" ||
+          !nonempty(evidence.receipt)
+        )
+          reasons.push(`missing_stage_evidence:${stage}`);
+        else if (evidence.passed) row.firstRunCompletedStages.push(stage);
+      }
+      // A later completed stage without its prerequisites is not a valid funnel.
+      if (
+        row.firstRunCompletedStages.some(
+          (stage, index) => stage !== STAGES[index],
+        )
+      )
+        reasons.push("inconsistent_first_run_stages");
+    }
+    for (const reason of reasons) issues.push(`${sample.id}:${reason}`);
+    const successfulExecution =
+      result?.pass === true &&
+      result.artifactCheckPassed === true &&
+      evalExecutionSucceeded(result) &&
+      result.executionEvidence.observedFallback === false;
+    if (!successfulExecution) reasons.push("task_not_successful");
+    if (row.elapsedMs > sample.timeBudgetMs || row.cost > sample.costBudget)
+      reasons.push("budget_exceeded");
+    if (row.manualRepairs > 0) reasons.push("manual_repair");
+    if (
+      sample.kind === "first-run" &&
+      (observation.firstRun?.cleanEnvironment !== true ||
+        row.firstRunCompletedStages.length !== STAGES.length)
+    )
+      reasons.push("first_run_not_completed");
+    row.succeeded = reasons.length === 0;
+    if (!row.succeeded) {
+      if (FAILURE_CAUSES.has(observation.failureCause))
+        row.failureCause = observation.failureCause;
+      else issues.push(`${sample.id}:missing_failure_cause`);
+    }
+  }
+  const categories = Object.fromEntries(
+    [...CATEGORIES].map((category) => [category, 0]),
+  );
+  let maintenanceComplete = false;
+  if (maintenance) {
+    const entries = uniqueIndex(
+      maintenance.entries,
+      "id",
+      "maintenance entries",
+    );
+    maintenanceComplete =
+      maintenance.complete === true &&
+      outcomeDigest(maintenance.window) === outcomeDigest(plan.window);
+    for (const entry of entries.values()) {
+      assert(
+        CATEGORIES.has(entry.category) &&
+          nonnegative(entry.hours) &&
+          nonempty(entry.evidenceRef),
+        "invalid maintenance entry",
+      );
+      categories[entry.category] += entry.hours;
+    }
+  }
+  if (!maintenanceComplete) issues.push("incomplete_maintenance_records");
+  const maintenanceHours = [...CATEGORIES]
+    .filter((category) => category !== "construction")
+    .reduce((sum, category) => sum + categories[category], 0);
+  const attempts = rows.filter((row) => row.observed).length;
+  const allObserved = rows.every((row) => row.observed);
+  const firstRuns = rows.filter((row) => row.kind === "first-run");
+  const tasks = rows.filter((row) => row.kind === "task");
+  if (!firstRuns.length || !tasks.length)
+    issues.push("missing_metric_population");
+  return {
+    schema: OUTCOME_REPORT_SCHEMA,
+    generatedAt: new Date(now).toISOString(),
+    scope: "local-outcome-baseline",
+    productionAttested: false,
+    status: issues.length ? "INSUFFICIENT_EVIDENCE" : "BASELINE_RECORDED",
+    // Neither a baseline nor operator declarations constitute an improvement gate.
+    improvementVerdict: "NOT_EVALUATED",
+    planDigest,
+    commitSha: plan.commitSha,
+    currency: plan.currency,
+    window: plan.window,
+    task: summarize(tasks),
+    firstRun: summarize(firstRuns),
+    maintenance: {
+      complete: maintenanceComplete,
+      knownHours: maintenanceHours,
+      totalHours: maintenanceComplete ? maintenanceHours : null,
+      per100Attempts:
+        maintenanceComplete && allObserved && attempts
+          ? (maintenanceHours / attempts) * 100
+          : null,
+      observedAttempts: attempts,
+      constructionHours: maintenanceComplete ? categories.construction : null,
+      categories,
+    },
+    groups: [
+      ...new Set(
+        rows.map((row) => JSON.stringify([row.kind, row.stratum, row.taskId])),
+      ),
+    ].map((key) => {
+      const [kind, stratum, taskId] = JSON.parse(key);
+      return {
+        kind,
+        stratum,
+        taskId,
+        ...summarize(
+          rows.filter(
+            (row) =>
+              row.kind === kind &&
+              row.stratum === stratum &&
+              row.taskId === taskId,
+          ),
+        ),
+      };
+    }),
+    firstRunFunnel: STAGES.map((stage, index) => ({
+      stage,
+      planned: firstRuns.length,
+      passed: firstRuns.filter((row) =>
+        STAGES.slice(0, index + 1).every((required) =>
+          row.firstRunCompletedStages.includes(required),
+        ),
+      ).length,
+    })),
+    failureCauses: [
+      ...new Set(
+        rows
+          .filter((row) => !row.succeeded)
+          .map((row) => row.failureCause || "unknown"),
+      ),
+    ].map((cause) => ({
+      cause,
+      count: rows.filter(
+        (row) => !row.succeeded && (row.failureCause || "unknown") === cause,
+      ).length,
+    })),
+    issues: [...new Set(issues)],
+    rows,
+  };
+}

package/src/lib/eval/runner.js

@@ -109,6 +109,8 @@ export async function runEvalSuite(tasks, opts = {}) {
       executionSucceeded: false,
       agentOk: false,
       executionEvidence: null,
+      usage: null,
+      totalCostUsd: null,
       ms: 0,
       detail: "",
       error: null,
@@ -153,6 +155,10 @@ export async function runEvalSuite(tasks, opts = {}) {
         (agentResult.error == null || agentResult.error === "");
       rec.agentOk = rec.executionSucceeded;
       rec.executionEvidence = agentResult?.executionEvidence || null;
+      rec.usage = agentResult?.usage || null;
+      rec.totalCostUsd = Number.isFinite(agentResult?.totalCostUsd)
+        ? agentResult.totalCostUsd
+        : null;
       if (agentResult?.evaluationMetrics !== undefined) {
         rec.evaluationMetrics = agentResult.evaluationMetrics;
       }

package/src/lib/git-tool-input.js

@@ -0,0 +1,37 @@
+// The git tool accepts argv text, not a shell program. Diagnose shell syntax
+// before spawning git while preserving literal operators in quoted arguments.
+export function gitToolInputError(command) {
+  let quote = null;
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    if (char === "\\" && quote === '"') {
+      i++;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/[|&;<>\r\n`]/.test(char) || (char === "$" && command[i + 1] === "(")) {
+      return {
+        success: false,
+        code: "CC_GIT_SHELL_SYNTAX",
+        error:
+          "The git tool accepts Git arguments only; shell operators are not executed.",
+        hint: 'Submit one Git command without pipes, redirects or &&. For example: "merge-base --is-ancestor main HEAD" (inspect exitCode), "log -n 5 --oneline", or "tag --list v-npm-* --sort=-v:refname". Do not reroute to a shell or execute a partial command automatically.',
+      };
+    }
+  }
+  if (quote)
+    return {
+      success: false,
+      code: "CC_GIT_UNCLOSED_QUOTE",
+      error:
+        "Unclosed quote in Git arguments. Close the quoted argument and retry.",
+    };
+  return null;
+}

package/src/lib/llm-config-defaults.js

@@ -55,6 +55,7 @@ export async function reconcileConfigLlmProvider(cfgLlm = {}) {
 }
 
 import { resolveApiKeyFromHelper } from "./api-key-helper.js";
+import { modelForeignToProvider } from "./runnable-provider.js";
 
 /**
  * Key backfill order: config llm.apiKey (plaintext, legacy) first, then
@@ -111,12 +112,27 @@ function optionalModel(value) {
   return model || null;
 }
 
+/**
+ * Claude settings and ANTHROPIC_MODEL carry a model name but no provider.
+ * Do not pair an unmistakably provider-specific inherited model with another
+ * configured provider. Explicit CLI/--settings choices may opt out because
+ * they provide the user's intent for this invocation.
+ */
+export function inheritedModelCompatible(provider, model) {
+  const candidate = optionalModel(model);
+  return (
+    !candidate || !provider || !modelForeignToProvider(provider, candidate)
+  );
+}
+
 /**
  * Resolve the model precedence used by `cc agent` without allowing a default
  * from one source to silently outrank an explicit choice from another:
  *
- *   CLI --model > ANTHROPIC_MODEL > settings.model > config/organization model
- *   > ANTHROPIC_DEFAULT_MODEL (new sessions only) > runtime provider default.
+ *   CLI --model > provider-compatible ANTHROPIC_MODEL/settings.model >
+ *   config/organization model > ANTHROPIC_DEFAULT_MODEL (new sessions only)
+ *   > runtime provider default. An explicit --settings file or managed setting
+ *   may authorize a foreign-looking alias for a custom provider endpoint.
  *
  * Environment values are supplied by the caller from the process startup
  * environment, before settings-file `env` entries are merged. That prevents a
@@ -128,18 +144,25 @@ export function applyAgentModelDefaults(options = {}, cfgLlm = {}, opts = {}) {
   const settingsModel = optionalModel(opts.settingsModel);
   const defaultModel = optionalModel(opts.anthropicDefaultModel);
 
-  if (!explicitModel) {
-    if (environmentModel) {
-      options.model = environmentModel;
-    } else if (settingsModel) {
-      options.model = settingsModel;
-    }
+  let inheritedModel = environmentModel || settingsModel;
+  const targetProvider = options.provider || cfgLlm.provider;
+  if (
+    inheritedModel &&
+    opts.allowForeignInheritedModel !== true &&
+    !inheritedModelCompatible(targetProvider, inheritedModel)
+  ) {
+    if (options.model === inheritedModel) delete options.model;
+    inheritedModel = null;
+  }
+
+  if (!explicitModel && inheritedModel) {
+    options.model = inheritedModel;
   }
 
   applyConfigLlmDefaults(options, cfgLlm, {
     // Reuse the existing config/provider wiring, but do not let its configured
     // model overwrite one selected by a higher-priority source above.
-    explicitModel: explicitModel || environmentModel || settingsModel,
+    explicitModel: explicitModel || inheritedModel,
   });
 
   if (!options.model && opts.isNewSession !== false && defaultModel) {

package/src/lib/read-file-loop-guard.js

@@ -30,6 +30,46 @@ export class ReadFileLoopGuard {
     this.recoveryOfferedAt = 0;
     this.batch = null;
     this.largeOutputs = new Set();
+    this.editRecoveryReads = new Map();
+  }
+
+  recordEditRecovery(result) {
+    if (result?.success === true && result.path) {
+      this.editRecoveryReads.delete(keyFor(result.path, { hashed: true }));
+      return;
+    }
+    const request = result?.recoveryRead;
+    if (
+      !request ||
+      !["hash_mismatch", "content_mismatch"].includes(result.error)
+    )
+      return;
+    const key = keyFor(request.path, { hashed: true });
+    // One refresh per file until an edit succeeds. Repeating the failed edit
+    // must not mint an unlimited read allowance.
+    if (
+      !this.editRecoveryReads.has(key) &&
+      this.editRecoveryReads.size < MAX_FILES
+    ) {
+      this.editRecoveryReads.set(key, { ...request, used: false });
+    }
+  }
+
+  get hasEditRecoveryReads() {
+    return [...this.editRecoveryReads.values()].some((entry) => !entry.used);
+  }
+
+  canRecoverEdit(filePath, args = {}) {
+    const entry = this.editRecoveryReads.get(keyFor(filePath, args));
+    return !!(
+      entry &&
+      !entry.used &&
+      args.hashed === true &&
+      args.raw !== true &&
+      args.column == null &&
+      args.offset === entry.offset &&
+      args.limit === entry.limit
+    );
   }
 
   startBatch() {
@@ -51,6 +91,16 @@ export class ReadFileLoopGuard {
     }
     let page = readPage(args);
     if (page.error || !page.readSpan) return page;
+    if (this.canRecoverEdit(filePath, args)) {
+      this.editRecoveryReads.get(key).used = true;
+      // The authorized read implementation has already refreshed stat/content.
+      // Return the requested anchors even if ordinary coverage is exhausted.
+      return {
+        ...page,
+        readRecovery: { action: "edit-anchor-refresh" },
+        readProgress: { newContent: false },
+      };
+    }
     const span = page.readSpan;
     const covered = entry.spans.some(
       ([start, end]) => start <= span.start && end >= span.end,
@@ -160,6 +210,8 @@ export class ReadFileLoopGuard {
     )
       return;
     if (tool === "read_file") {
+      if (result?.readRecovery?.action === "edit-anchor-refresh")
+        this.batch.advanced = true;
       if (result?.readProgress?.newContent === true) this.batch.advanced = true;
       if (result?.readProgress?.newContent === false) this.batch.duplicates++;
     } else if (
@@ -207,12 +259,14 @@ export class ReadFileLoopGuard {
 
   get hasRecoveryReads() {
     return (
+      this.hasEditRecoveryReads ||
       this.hasUnreadPages ||
       [...this.progress.values()].some((entry) => entry.rereads.size < 3)
     );
   }
 
   canContinue(filePath, args = {}) {
+    if (this.canRecoverEdit(filePath, args)) return true;
     const entry = this.progress.get(keyFor(filePath, args));
     return (
       entry?.summary?.reachedEnd === false ||

package/src/lib/remote-read-loop-guard.js

@@ -1,4 +1,6 @@
 import { createHash } from "node:crypto";
+import { diagnosticExcerpt } from "./diagnostic-excerpt.js";
+import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "./diagnostic-workflow.js";
 
 const MAX_TARGETS = 32;
 const RECOVERY_AFTER = 3;
@@ -196,19 +198,7 @@ function failedResult(result) {
 }
 
 function excerpt(value) {
-  const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
-  if (text.length <= 1600) return text;
-  // Retain failure lines from full CI logs as well as the opening context.
-  const failures = text
-    .split("\n")
-    .filter((line) => /FAIL|Error:|AssertionError|error TS|×|✕/.test(line))
-    .slice(0, 12)
-    .join("\n");
-  return (
-    text.slice(0, 400) +
-    "\n[excerpt]\n" +
-    (failures || text.slice(-1100)).slice(0, 1100)
-  );
+  return diagnosticExcerpt(value);
 }
 
 /** Per agentLoop, independent of history compaction and other agents' evidence. */
@@ -290,13 +280,19 @@ export class RemoteReadLoopGuard {
     this.activeKey = target.key;
     const previous = this.targets.get(target.key);
     const digests = previous?.digests || new Set();
-    const content =
+    const primaryContent =
       result?.output ??
       result?.stdout ??
       result?.content ??
       result?.matches ??
       result?.body ??
       "";
+    const content =
+      result?.stdout_diagnostics || result?.stderr_diagnostics
+        ? [result.stdout_diagnostics, result.stderr_diagnostics, primaryContent]
+            .filter(Boolean)
+            .join("\n")
+        : primaryContent;
     const digest = createHash("sha256")
       .update(typeof content === "string" ? content : JSON.stringify(content))
       .digest("hex");
@@ -453,6 +449,8 @@ export class RemoteReadLoopGuard {
         "An aggregate or incomplete-matrix gate can be a downstream symptom; inspect the dependency jobs' conclusions before assuming that the gate itself is wrong. " +
         "When a job is cancelled or logs are unavailable, record that fact and the command error; do not cycle through the same web page and log downloads. " +
         "Use one focused run/job metadata query to resolve the missing status or cancellation reason, then inspect the relevant workflow and make the justified, authorized fix with validation. " +
+        DIAGNOSTIC_WORKFLOW_GUIDANCE +
+        " " +
         "If available evidence cannot establish a fix, report the specific missing evidence and what was verified. Do not disable a release or safety gate just to make CI pass. " +
         "For a research/review request, synthesize the findings without unsolicited edits; for monitoring, use status queries instead of repeated logs."
       );