chainlesschain 0.166.64 → 0.166.68

package/src/lib/evolution/pm-exploration-transition-committer.js

@@ -7,6 +7,8 @@ export const PM_EXPLORATION_SUCCESS_TRANSITION_SCHEMA =
   "chainlesschain.desktop-pm-state-transition-success/v1";
 export const PM_EXPLORATION_FAILED_TRANSITION_SCHEMA =
   "chainlesschain.desktop-pm-failed-execution-evidence/v1";
+export const PM_EXPLORATION_CLONE_RECOVERY_EVENT_SCHEMA =
+  "chainlesschain.desktop-pm-clone-recovery-event/v1";
 export const PM_EXPLORATION_TRANSITION_DURABILITY_ACK_SCHEMA =
   "chainlesschain.pm-exploration-transition-durability-ack/v1";
 export const PM_EXPLORATION_SNAPSHOT_BOUND_TRANSITION_DURABILITY_ACK_SCHEMA =
@@ -15,6 +17,8 @@ export const PM_EXPLORATION_TRANSITION_RECOVERY_REQUEST_SCHEMA =
   "chainlesschain.pm-exploration-transition-recovery-request/v1";
 export const PM_EXPLORATION_TRANSITION_RECOVERY_SCHEMA =
   "chainlesschain.pm-exploration-transition-recovery/v1";
+export const PM_EXPLORATION_SNAPSHOT_BOUND_TRANSITION_RECOVERY_SCHEMA =
+  "chainlesschain.pm-exploration-transition-recovery/v2";
 
 const DATABASE_SEAL_SCHEMA =
   "chainlesschain.desktop-pm-database-pre-run-seal/v1";
@@ -285,6 +289,106 @@ function failedTransition(value, expectedManifestDigest) {
   return deepFreeze({ ...core, evidenceDigest });
 }
 
+function cloneRecoveryEvent(value, expectedManifestDigest) {
+  exact(
+    value,
+    [
+      "schema",
+      "manifestDigest",
+      "cloneIdentityDigest",
+      "sourceTransitionRevision",
+      "sourceFailureEvidenceDigest",
+      "previousStateTransitionDigest",
+      "recoverySnapshotAckDigest",
+      "restoredDatabaseSealDigest",
+      "restoredWorkspaceSealDigest",
+      "switchReceiptDigest",
+      "authenticated",
+      "durable",
+      "qualifiesForPromotion",
+      "recoveryEventDigest",
+    ],
+    "PM clone recovery event",
+  );
+  if (
+    value.schema !== PM_EXPLORATION_CLONE_RECOVERY_EVENT_SCHEMA ||
+    value.manifestDigest !== expectedManifestDigest ||
+    !Number.isSafeInteger(value.sourceTransitionRevision) ||
+    value.sourceTransitionRevision < 1 ||
+    value.authenticated !== false ||
+    value.durable !== false ||
+    value.qualifiesForPromotion !== false
+  ) {
+    throw new Error("PM clone recovery event fields are invalid");
+  }
+  const core = {
+    schema: value.schema,
+    manifestDigest: digest(value.manifestDigest, "manifestDigest"),
+    cloneIdentityDigest: digest(
+      value.cloneIdentityDigest,
+      "cloneIdentityDigest",
+    ),
+    sourceTransitionRevision: value.sourceTransitionRevision,
+    sourceFailureEvidenceDigest: digest(
+      value.sourceFailureEvidenceDigest,
+      "sourceFailureEvidenceDigest",
+    ),
+    previousStateTransitionDigest: optionalDigest(
+      value.previousStateTransitionDigest,
+      "previousStateTransitionDigest",
+    ),
+    recoverySnapshotAckDigest: digest(
+      value.recoverySnapshotAckDigest,
+      "recoverySnapshotAckDigest",
+    ),
+    restoredDatabaseSealDigest: digest(
+      value.restoredDatabaseSealDigest,
+      "restoredDatabaseSealDigest",
+    ),
+    restoredWorkspaceSealDigest: digest(
+      value.restoredWorkspaceSealDigest,
+      "restoredWorkspaceSealDigest",
+    ),
+    switchReceiptDigest: digest(
+      value.switchReceiptDigest,
+      "switchReceiptDigest",
+    ),
+    authenticated: false,
+    durable: false,
+    qualifiesForPromotion: false,
+  };
+  const recoveryEventDigest = digest(
+    value.recoveryEventDigest,
+    "recoveryEventDigest",
+  );
+  if (
+    recoveryEventDigest !==
+    hash(PM_EXPLORATION_CLONE_RECOVERY_EVENT_SCHEMA, core)
+  ) {
+    throw new Error("PM clone recovery event digest mismatch");
+  }
+  return deepFreeze({ ...core, recoveryEventDigest });
+}
+
+function transitionBinding(evidence) {
+  if (evidence.schema === PM_EXPLORATION_SUCCESS_TRANSITION_SCHEMA) {
+    return Object.freeze({
+      transitionKind: "success",
+      evidenceDigest: evidence.stateTransitionDigest,
+    });
+  }
+  if (evidence.schema === PM_EXPLORATION_FAILED_TRANSITION_SCHEMA) {
+    return Object.freeze({
+      transitionKind: "failure",
+      evidenceDigest: evidence.evidenceDigest,
+    });
+  }
+  return Object.freeze({
+    transitionKind: "recovery",
+    evidenceDigest: evidence.recoveryEventDigest,
+  });
+}
+
 export function verifyPmExplorationTransitionEvidence(
   value,
   expectedManifestDigest,
@@ -305,6 +409,8 @@ export function verifyPmExplorationTransitionEvidence(
     return successTransition(value, manifestDigest);
   if (schema.value === PM_EXPLORATION_FAILED_TRANSITION_SCHEMA)
     return failedTransition(value, manifestDigest);
+  if (schema.value === PM_EXPLORATION_CLONE_RECOVERY_EVENT_SCHEMA)
+    return cloneRecoveryEvent(value, manifestDigest);
   throw new TypeError("PM transition evidence schema is invalid");
 }
 
@@ -370,34 +476,67 @@ function durabilityAck(value, binding) {
 }
 
 function transitionRecovery(value, expectedManifestDigest) {
+  const schemaDescriptor =
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    !isProxy(value) &&
+    Object.getPrototypeOf(value) === Object.prototype
+      ? Object.getOwnPropertyDescriptor(value, "schema")
+      : null;
+  const snapshotBound =
+    schemaDescriptor &&
+    "value" in schemaDescriptor &&
+    schemaDescriptor.value ===
+      PM_EXPLORATION_SNAPSHOT_BOUND_TRANSITION_RECOVERY_SCHEMA;
   exact(
     value,
-    [
-      "schema",
-      "authenticated",
-      "durable",
-      "readbackVerified",
-      "manifestDigest",
-      "revision",
-      "transitionKind",
-      "evidenceDigest",
-      "evidence",
-      "ledgerHeadDigest",
-      "ledgerEventDigest",
-      "durabilityReceiptDigest",
-      "qualifiesForPromotion",
-    ],
+    snapshotBound
+      ? [
+          "schema",
+          "authenticated",
+          "durable",
+          "readbackVerified",
+          "manifestDigest",
+          "revision",
+          "transitionKind",
+          "evidenceDigest",
+          "evidence",
+          "recoverySnapshot",
+          "ledgerHeadDigest",
+          "ledgerEventDigest",
+          "durabilityReceiptDigest",
+          "qualifiesForPromotion",
+        ]
+      : [
+          "schema",
+          "authenticated",
+          "durable",
+          "readbackVerified",
+          "manifestDigest",
+          "revision",
+          "transitionKind",
+          "evidenceDigest",
+          "evidence",
+          "ledgerHeadDigest",
+          "ledgerEventDigest",
+          "durabilityReceiptDigest",
+          "qualifiesForPromotion",
+        ],
     "PM transition recovery",
   );
   if (
-    value.schema !== PM_EXPLORATION_TRANSITION_RECOVERY_SCHEMA ||
+    ![
+      PM_EXPLORATION_TRANSITION_RECOVERY_SCHEMA,
+      PM_EXPLORATION_SNAPSHOT_BOUND_TRANSITION_RECOVERY_SCHEMA,
+    ].includes(value.schema) ||
     value.authenticated !== true ||
     value.durable !== true ||
     value.readbackVerified !== true ||
     value.manifestDigest !== expectedManifestDigest ||
     !Number.isSafeInteger(value.revision) ||
     value.revision < 0 ||
-    ![null, "success", "failure"].includes(value.transitionKind) ||
+    ![null, "success", "failure", "recovery"].includes(value.transitionKind) ||
     !DIGEST.test(value.ledgerHeadDigest ?? "") ||
     value.qualifiesForPromotion !== false
   ) {
@@ -405,6 +544,7 @@ function transitionRecovery(value, expectedManifestDigest) {
   }
   if (value.transitionKind === null) {
     if (
+      snapshotBound ||
       value.revision !== 0 ||
       value.evidenceDigest !== null ||
       value.evidence !== null ||
@@ -427,21 +567,34 @@ function transitionRecovery(value, expectedManifestDigest) {
     value.evidence,
     expectedManifestDigest,
   );
-  const transitionKind =
-    evidence.schema === PM_EXPLORATION_SUCCESS_TRANSITION_SCHEMA
-      ? "success"
-      : "failure";
-  const evidenceDigest =
-    transitionKind === "success"
-      ? evidence.stateTransitionDigest
-      : evidence.evidenceDigest;
+  const { transitionKind, evidenceDigest } = transitionBinding(evidence);
   if (
     value.transitionKind !== transitionKind ||
     value.evidenceDigest !== evidenceDigest
   ) {
     throw new Error("PM transition recovery evidence binding is invalid");
   }
-  return deepFreeze({ ...value, evidence });
+  if (snapshotBound && transitionKind === "recovery") {
+    throw new Error(
+      "PM clone recovery event cannot carry a transition recovery snapshot",
+    );
+  }
+  const recoverySnapshot = snapshotBound
+    ? verifyPmExplorationRecoverySnapshotAck(value.recoverySnapshot, {
+        manifestDigest: expectedManifestDigest,
+        transitionKind,
+        evidenceDigest,
+        sealDigest:
+          transitionKind === "success"
+            ? evidence.postRunSeal.sealDigest
+            : evidence.preRunSeal.sealDigest,
+      })
+    : null;
+  return deepFreeze({
+    ...value,
+    evidence,
+    ...(snapshotBound ? { recoverySnapshot } : {}),
+  });
 }
 
 export function createPmExplorationTransitionCommitter(input = {}) {
@@ -493,14 +646,12 @@ export function capturePmExplorationTransitionCommitter(value) {
         input,
         captured.manifestDigest,
       );
-      const transitionKind =
-        evidence.schema === PM_EXPLORATION_SUCCESS_TRANSITION_SCHEMA
-          ? "success"
-          : "failure";
-      const evidenceDigest =
-        transitionKind === "success"
-          ? evidence.stateTransitionDigest
-          : evidence.evidenceDigest;
+      const { transitionKind, evidenceDigest } = transitionBinding(evidence);
+      if (transitionKind === "recovery" && recoverySnapshotInput !== null) {
+        throw new Error(
+          "PM clone recovery event cannot retain another recovery snapshot",
+        );
+      }
       const recoverySnapshot =
         recoverySnapshotInput === null
           ? null

package/src/lib/evolution/skill-outcome-index-authority.js

@@ -1,6 +1,9 @@
 import { createHash } from "node:crypto";
 
-import { verifyEvolutionWorkbenchMetricsSnapshot } from "./evolution-workbench-metrics.js";
+import {
+  EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA,
+  verifyEvolutionWorkbenchMetricsSnapshot,
+} from "./evolution-workbench-metrics.js";
 import { isEvolutionWorkbenchMetricsOutcomeReader } from "./evolution-workbench-metrics-ledger-adapter.js";
 
 export const SKILL_OUTCOME_INDEX_AUTHORITY_SCHEMA =
@@ -96,8 +99,9 @@ function inspectSource(adapter) {
     descriptor,
   );
   if (
-    snapshot.outcomeHistoryComplete !== true &&
-    snapshot.versions.length !== 0
+    snapshot.versions.length !== 0 &&
+    (snapshot.schema !== EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA ||
+      snapshot.outcomeHistoryComplete !== true)
   ) {
     throw unavailable(
       "Skill outcome index requires a complete outcome backfill",

package/src/lib/governance-coverage.js

@@ -1,6 +1,6 @@
 /**
  * Governance coverage metrics — the last open item of P1-9 ("覆盖率指标") in
- * docs/CLAUDE_CODE_IDE_INCREMENTAL_GAP_ANALYSIS_2026-07-13.md, and the
+ * docs/research/ide/CLAUDE_CODE_IDE_INCREMENTAL_GAP_ANALYSIS_2026-07-13.md, and the
  * computation behind two §11.3 acceptance targets:
  *
  *   - "高风险 Tool Call Ledger/Trace 覆盖率：100%"

package/src/lib/headless-manifest.js

@@ -1,6 +1,6 @@
 /**
  * Deterministic-headless manifest helpers (gap-analysis 2026-07-11,
- * docs/CLAUDE_CODE_CLI_GAP_ANALYSIS.md P0 "确定性 Headless").
+ * docs/research/cli/CLAUDE_CODE_CLI_GAP_ANALYSIS.md P0 "确定性 Headless").
  *
  * The stream-json init event carries a protocol version, whether this run
  * persists its session, which ambient customization sources are live, and

package/src/lib/protocol-replay.js

@@ -1,6 +1,6 @@
 /**
  * Offline protocol replay — the last open pure item of P1-9 ("离线协议回放") in
- * docs/CLAUDE_CODE_IDE_INCREMENTAL_GAP_ANALYSIS_2026-07-13.md.
+ * docs/research/ide/CLAUDE_CODE_IDE_INCREMENTAL_GAP_ANALYSIS_2026-07-13.md.
  *
  * [[event-seq-replay.js]] replays for TRANSPORT reliability (re-send a gap over a
  * lossy socket). This module replays for PROTOCOL COMPAT: take a recorded

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

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { EXPLORATION_TOOLS } from "./task-progress-tracker.js";
+import { isToolRecoveryPaused } from "./tool-recovery-result.js";
 const MAX_FILES = 12;
 
 function keyFor(filePath, args) {
@@ -215,14 +216,10 @@ export class ReadFileLoopGuard {
   }
 
   record(tool, result, actionable = true) {
-    if (
-      this.batch &&
-      tool === "read_file" &&
-      result?.code === "CC_TOOL_RECOVERY_PAUSED"
-    ) {
-      this.batch.duplicates++;
-      return;
-    }
+    // The runtime denied this call before execution. Counting its own denial
+    // as another duplicate would immediately schedule another "one-turn"
+    // pause and prevent read_file from ever becoming available again.
+    if (isToolRecoveryPaused(result)) return;
     if (
       !this.batch ||
       result?.error ||

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

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { diagnosticExcerpt } from "./diagnostic-excerpt.js";
 import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "./diagnostic-workflow.js";
+import { isToolRecoveryPaused } from "./tool-recovery-result.js";
 
 const MAX_TARGETS = 32;
 const RECOVERY_AFTER = 3;
@@ -208,22 +209,14 @@ export class RemoteReadLoopGuard {
     this.activeKey = null;
     this.revision = 0;
     this.offeredRevision = 0;
+    this.pausedKey = null;
   }
 
   record(tool, result, args = {}) {
-    if (result?.code === "CC_TOOL_RECOVERY_PAUSED") {
-      // A provider can ignore omitted tool definitions. Count that attempt
-      // without replacing the actual failure/evidence with our own denial.
-      const key = remoteReadTarget(tool, args)?.key || this.activeKey;
-      const entry = this.targets.get(key);
-      if (entry?.tool === tool && entry.repeats >= RECOVERY_AFTER) {
-        entry.repeats++;
-        entry.recoveryOffered = true;
-        this.activeKey = key;
-        this.revision++;
-      }
-      return;
-    }
+    // Preserve the last real error/evidence, but do not count a call that the
+    // runtime itself refused to execute. Otherwise a one-turn pause advances
+    // the retry counter and remains active forever.
+    if (isToolRecoveryPaused(result)) return;
     const failed = failedResult(result);
     const policy = result?.shellCommandPolicy;
     const gitRepositoryKey = `git-repository:${createHash("sha256")
@@ -421,10 +414,15 @@ export class RemoteReadLoopGuard {
   }
 
   takeRecoveryTurn() {
+    // Recovery narrowing lasts for exactly the model request for which it was
+    // offered. Calling this method at the next request clears the old target
+    // before deciding whether fresh real evidence warrants another pause.
+    this.pausedKey = null;
     if (!this.recoveryHint || this.offeredRevision === this.revision) return [];
     this.offeredRevision = this.revision;
     const entry = this.targets.get(this.activeKey);
     entry.recoveryOffered = true;
+    this.pausedKey = this.activeKey;
     // Keep the shell available for local reproduction and validation. Only
     // repeated reads of the stalled remote target are narrowed below.
     if (entry.tool === "run_shell" && entry.github) return [];
@@ -433,14 +431,23 @@ export class RemoteReadLoopGuard {
 
   shouldPause(tool, args = {}) {
     const target = remoteReadTarget(tool, args);
-    const entry = target && this.targets.get(target.key);
-    return !!(
-      entry?.github &&
-      entry.recoveryOffered &&
-      entry.repeats >= RECOVERY_AFTER
+    return !!(target && target.key === this.pausedKey);
+  }
+
+  hasScopedContinuation(tool) {
+    return [...this.targets.values()].some(
+      (entry) =>
+        entry.tool === tool &&
+        (entry.repeats > 0 || entry.page?.hasMore === true),
     );
   }
 
+  canContinue(tool, args = {}) {
+    const target = remoteReadTarget(tool, args);
+    const entry = target && this.targets.get(target.key);
+    return !!(entry && (entry.repeats > 0 || entry.page?.hasMore === true));
+  }
+
   get workflowHint() {
     const active = this.targets.get(this.activeKey);
     if (active?.github && !active.pullRequest) {

package/src/lib/skill-outcome-transcript-authority.js

@@ -7,10 +7,15 @@ import {
 } from "../harness/jsonl-session-store.js";
 import { canonicalJson } from "./scheduler-kernel/contract.js";
 
-const { verifySkillInvocationReceipt } = skillInvocationReceipt;
+const {
+  inspectSkillInvocationReceiptCompatibility,
+  verifySkillInvocationReceipt,
+} = skillInvocationReceipt;
 
-export const SKILL_OUTCOME_AUTHORITY_SCHEMA =
+export const LEGACY_SKILL_OUTCOME_AUTHORITY_SCHEMA =
   "chainlesschain.skill-outcome-transcript-authority/v1";
+export const SKILL_OUTCOME_AUTHORITY_SCHEMA =
+  "chainlesschain.skill-outcome-transcript-authority/v2";
 export const MAX_OUTCOME_AUTHORITY_SESSIONS = 128;
 export const MAX_OUTCOME_AUTHORITY_RECEIPTS = 10_000;
 
@@ -103,13 +108,16 @@ export function buildSkillOutcomeTranscriptAuthority(
     options.maxReceipts === undefined
       ? MAX_OUTCOME_AUTHORITY_RECEIPTS
       : Number(options.maxReceipts);
+  const expectedEnvironmentDigest = options.expectedEnvironmentDigest ?? null;
   if (
     !Number.isSafeInteger(maxSessions) ||
     maxSessions < 1 ||
     maxSessions > MAX_OUTCOME_AUTHORITY_SESSIONS ||
     !Number.isSafeInteger(maxReceipts) ||
     maxReceipts < 1 ||
-    maxReceipts > MAX_OUTCOME_AUTHORITY_RECEIPTS
+    maxReceipts > MAX_OUTCOME_AUTHORITY_RECEIPTS ||
+    (expectedEnvironmentDigest !== null &&
+      !DIGEST.test(expectedEnvironmentDigest))
   ) {
     throw new TypeError("Skill outcome authority bounds are invalid");
   }
@@ -170,8 +178,30 @@ export function buildSkillOutcomeTranscriptAuthority(
   const totals = new Map();
   let attributionEligibleReceiptCount = 0;
   let outcomeEligibleReceiptCount = 0;
+  let legacyEnvironmentUnboundReceiptCount = 0;
+  let staleEnvironmentReceiptCount = 0;
+  let incompleteAttributionReceiptCount = 0;
   for (const receipt of uniqueReceipts.values()) {
-    if (receipt.attributionEligible !== true) continue;
+    const compatibility = inspectSkillInvocationReceiptCompatibility(receipt, {
+      expectedEnvironmentDigest,
+    });
+    if (compatibility.legacyEnvironmentUnbound) {
+      legacyEnvironmentUnboundReceiptCount += 1;
+    } else if (!compatibility.environmentBoundAttributionEligible) {
+      incompleteAttributionReceiptCount += 1;
+    } else if (
+      expectedEnvironmentDigest !== null &&
+      !compatibility.currentEnvironmentEligible
+    ) {
+      staleEnvironmentReceiptCount += 1;
+    }
+    if (
+      !compatibility.environmentBoundAttributionEligible ||
+      (expectedEnvironmentDigest !== null &&
+        !compatibility.currentEnvironmentEligible)
+    ) {
+      continue;
+    }
     attributionEligibleReceiptCount += 1;
     const hasOutcomeEvidence =
       receipt.graderReceipts.length > 0 || receipt.userCorrectionRef !== null;
@@ -213,7 +243,12 @@ export function buildSkillOutcomeTranscriptAuthority(
     }))
     .sort((left, right) => left.sessionId.localeCompare(right.sessionId));
   const sourceDigest = `sha256:${createHash("sha256")
-    .update(`${SKILL_OUTCOME_AUTHORITY_SCHEMA}\0${canonicalJson(source)}`)
+    .update(
+      `${SKILL_OUTCOME_AUTHORITY_SCHEMA}\0${canonicalJson({
+        source,
+        expectedEnvironmentDigest,
+      })}`,
+    )
     .digest("hex")}`;
   return Object.freeze({
     schema: SKILL_OUTCOME_AUTHORITY_SCHEMA,
@@ -228,6 +263,11 @@ export function buildSkillOutcomeTranscriptAuthority(
       uniqueReceiptCount: uniqueReceipts.size,
       attributionEligibleReceiptCount,
       outcomeEligibleReceiptCount,
+      legacyEnvironmentUnboundReceiptCount,
+      staleEnvironmentReceiptCount,
+      incompleteAttributionReceiptCount,
+      environmentPolicy:
+        expectedEnvironmentDigest === null ? "bound" : "current",
       duplicateReceiptCount,
       maxSessions,
       maxReceipts,

package/src/lib/tool-recovery-result.js

@@ -0,0 +1,11 @@
+export const TOOL_RECOVERY_PAUSED_CODE = "CC_TOOL_RECOVERY_PAUSED";
+
+/**
+ * A recovery pause is a synthetic runtime result: the requested tool never
+ * executed and therefore produced no new evidence about the underlying task.
+ * Loop guards must not feed that result back into their retry counters, or a
+ * one-turn pause becomes a self-sustaining recovery loop.
+ */
+export function isToolRecoveryPaused(result) {
+  return result?.code === TOOL_RECOVERY_PAUSED_CODE;
+}

package/src/runtime/agent-core.js

@@ -39,6 +39,7 @@ import {
   TaskProgressTracker,
   TASK_RECOVERY_TOOLS,
 } from "../lib/task-progress-tracker.js";
+import { TOOL_RECOVERY_PAUSED_CODE } from "../lib/tool-recovery-result.js";
 import broker from "../lib/process-execution-broker/index.js";
 import os from "os";
 import { createHash, randomUUID } from "node:crypto";
@@ -8258,6 +8259,22 @@ async function executeToolInner(
           }),
         )
         .digest("hex")}`;
+      const invocationEnvironmentDigest =
+        runtimeEligibility?.binding?.environmentDigest ||
+        `sha256:${createHash("sha256")
+          .update("chainlesschain.cli-skill-invocation-environment/v1\0")
+          .update(
+            JSON.stringify({
+              node: process.versions.node,
+              platform: process.platform,
+              arch: process.arch,
+              provider: llmOptions?.provider ?? null,
+              model: llmOptions?.model ?? null,
+              toolSetDigest,
+              policyDigest,
+            }),
+          )
+          .digest("hex")}`;
       const invocationStartedAt = Date.now();
       const invocationStart = startSkillInvocation({
         attributionRequired: ["automatic-candidate", "canary"].includes(
@@ -8281,6 +8298,7 @@ async function executeToolInner(
         toolSetDigest,
         osSandboxPermissionPolicyDigest: policyDigest,
         taskCohort: "cli:run_skill",
+        environmentDigest: invocationEnvironmentDigest,
       });
       const settleInvocation = (executionStatus, result = {}) =>
         settleSkillInvocation(invocationStart, {
@@ -14997,7 +15015,9 @@ export async function* agentLoop(messages, options) {
     // known, explicitly bounded section. Admission below still rejects broad
     // new-file reads and repeated covered ranges.
     const taskRecoveryTools = TASK_RECOVERY_TOOLS.filter(
-      (tool) => tool !== "read_file",
+      (tool) =>
+        tool !== "read_file" &&
+        !remoteReadLoopGuard.hasScopedContinuation(tool),
     );
     const readToolRecoveryPaused =
       readRecoveryTurn &&
@@ -15926,10 +15946,13 @@ export async function* agentLoop(messages, options) {
               path.resolve(toolContext.cwd || process.cwd(), toolArgs.path),
               toolArgs,
             )
-          ))
+          )) ||
+        (taskRecoveryTurn &&
+          (toolName === "web_fetch" || toolName === "web_search") &&
+          !remoteReadLoopGuard.canContinue(toolName, toolArgs))
           ? {
               success: false,
-              code: "CC_TOOL_RECOVERY_PAUSED",
+              code: TOOL_RECOVERY_PAUSED_CODE,
               error: `${toolName} is paused for loop recovery and was not executed. Use retained findings for an authorized action or report the specific blocker; do not repeat or disguise this call.`,
             }
           : null) ||

package/src/assets/web-panel/assets/ChatBubbleRenderer-6T0uoJuS.js

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as n,R as a,S as y,K as C,Q as x,V as w,_ as B,b as s}from"./vendor-Bn1JzzAn.js";import{_ as k}from"./index-D5Rvq67L.js";import"./icons-DG5UD-6K.js";const N={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=s(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=s(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=s(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=s(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=s(()=>{if(!t.event.occurredAt)return"";try{const e=new Date(t.event.occurredAt),p=e.getFullYear(),b=String(e.getMonth()+1).padStart(2,"0"),f=String(e.getDate()).padStart(2,"0"),g=String(e.getHours()).padStart(2,"0"),h=String(e.getMinutes()).padStart(2,"0");return`${p}-${b}-${f} ${g}:${h}`}catch{return""}}),_={props:t,messageText:r,actorLabel:i,isMine:l,adapterColor:o,formattedTime:m,computed:s};return Object.defineProperty(_,"__isScriptSetup",{enumerable:!1,value:!0}),_}},T={class:"bubble"},M={class:"meta"},R={class:"actor"},V={class:"time"},q={class:"body"};function D(c,d,t,r,i,l){const o=v("a-tag");return u(),S("div",{class:B(["chat-row",{mine:r.isMine}])},[n("div",T,[n("div",M,[n("span",R,a(r.actorLabel),1),n("span",V,a(r.formattedTime),1)]),n("div",q,a(r.messageText),1),t.event.source.adapter?(u(),y(o,{key:0,class:"src",color:r.adapterColor},{default:C(()=>[x(a(t.event.source.adapter),1)]),_:1},8,["color"])):w("v-if",!0)])],2)}const A=k(N,[["render",D],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-210eXb/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{A as default};