chainlesschain 0.166.103 → 0.166.105

package/src/repl/agent-repl.js

@@ -86,7 +86,9 @@ import {
 } from "../lib/session-host-snapshot.js";
 import { acquireSessionHostLease } from "../lib/session-host-lease.js";
 import {
+  normalizeSessionBudgetRootConfig,
   openProductionSessionBudgetRoot,
+  readProductionSessionBudget,
   sessionBudgetAdmissionError,
 } from "../lib/session-budget-production-root.js";
 import {
@@ -2265,9 +2267,25 @@ export function prepareReplJsonlResumeCandidate(sessionId, dependencies = {}) {
       error.code = "CC_REPL_SESSION_AUTHORITY_MISMATCH";
       throw error;
     }
+    const declaredBudget = dataDescriptorValue(
+      stateDescriptors,
+      "sessionBudgetRoot",
+      "REPL session host resume state",
+      { required: false },
+    );
+    const sessionBudgetRoot =
+      declaredBudget == null
+        ? null
+        : normalizeSessionBudgetRootConfig(
+            snapshotReplMessageValue(
+              declaredBudget,
+              "REPL session budget declaration",
+            ),
+          );
     return brandedFrozenCandidate(REPL_JSONL_RESUME_CANDIDATES, {
       ok: true,
       sessionId,
+      sessionBudgetRoot,
       rebuiltMessages,
       replayMessages: normalizedReplay.replayMessages,
       canonicalSystemMessages: normalizedReplay.canonicalSystemMessages,
@@ -2786,8 +2804,60 @@ export async function runReplStartupBoundary(options, startupDependencies) {
   ) {
     leaseScope.lease = acquireHostLease(leaseSessionId, { hostKind: "repl" });
   }
-  let workspaceOptions = options;
-  if (options.sessionBudgetRoot?.enabled === true) {
+  const injectedBudgetReader = dependencyDataFunction(
+    startupDependencies,
+    "readProductionSessionBudget",
+    null,
+  );
+  const sidecar =
+    leaseSessionId &&
+    (process.platform === "linux" || injectedBudgetReader !== null)
+      ? synchronousReplRecoveryValue(
+          (injectedBudgetReader || readProductionSessionBudget)(leaseSessionId),
+          "REPL budget sidecar",
+        )
+      : null;
+  let effectiveBudgetConfig = options.sessionBudgetRoot;
+  const declaredBudgetConfig = startupCandidate?.sessionBudgetRoot;
+  const requestedBudgetConfig = options.sessionBudgetRoot?.enabled
+    ? normalizeSessionBudgetRootConfig(options.sessionBudgetRoot)
+    : null;
+  if (startupCandidate?.ok === true) {
+    if (declaredBudgetConfig?.enabled) {
+      if (!sidecar) {
+        throw Object.assign(
+          new Error("budgeted REPL session is missing its budget sidecar"),
+          { code: "CC_SESSION_BUDGET_SIDECAR_REQUIRED" },
+        );
+      }
+      if (
+        requestedBudgetConfig &&
+        JSON.stringify(requestedBudgetConfig) !==
+          JSON.stringify(declaredBudgetConfig)
+      ) {
+        throw Object.assign(
+          new Error("REPL budget does not match its JSONL declaration"),
+          { code: "CC_SESSION_BUDGET_CONFIG_MISMATCH" },
+        );
+      }
+      effectiveBudgetConfig = declaredBudgetConfig;
+    } else if (requestedBudgetConfig || sidecar) {
+      throw Object.assign(
+        new Error("existing REPL session has no canonical budget declaration"),
+        { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+      );
+    }
+  } else if (sidecar) {
+    throw Object.assign(
+      new Error("budget sidecar has no canonical REPL session"),
+      { code: "CC_SESSION_BUDGET_JSONL_REQUIRED" },
+    );
+  }
+  let workspaceOptions = {
+    ...options,
+    sessionBudgetRoot: effectiveBudgetConfig,
+  };
+  if (effectiveBudgetConfig?.enabled === true) {
     if (!leaseSessionId || !leaseScope?.lease) {
       throw Object.assign(
         new Error(
@@ -2813,10 +2883,10 @@ export async function runReplStartupBoundary(options, startupDependencies) {
         "CC_REPL_STARTUP_DEPENDENCY_INVALID",
       );
     }
-    const root = openBudgetRoot(leaseSessionId, options.sessionBudgetRoot, {
+    const root = openBudgetRoot(leaseSessionId, effectiveBudgetConfig, {
       persist: true,
       signal: combineReplSignals(options.signal, leaseScope.lease.signal),
-      table: options.sessionBudgetRoot.table,
+      table: effectiveBudgetConfig.table,
     });
     if (
       root?.enabled !== true ||
@@ -2850,7 +2920,7 @@ export async function runReplStartupBoundary(options, startupDependencies) {
       throw admissionError;
     }
     budgetScope.root = root;
-    workspaceOptions = { ...options, ...root.options };
+    workspaceOptions = { ...workspaceOptions, ...root.options };
   }
   const trustedWorkspaceRoot = readCwd();
   return enterWorkspace(trustedWorkspaceRoot, () =>
@@ -2867,11 +2937,17 @@ export function startReplJsonlSession(
   options = {},
 ) {
   const requireDurable =
-    observabilityScope != null || options.requireDurable === true;
+    observabilityScope != null ||
+    options.requireDurable === true ||
+    options.sessionBudgetRoot?.enabled === true;
   try {
+    const budgetDeclaration = options.sessionBudgetRoot?.enabled
+      ? normalizeSessionBudgetRootConfig(options.sessionBudgetRoot)
+      : null;
     const sessionId = startSession(requestedId, {
       ...meta,
       ...(observabilityScope != null ? { observabilityScope } : {}),
+      ...(budgetDeclaration ? { sessionBudgetRoot: budgetDeclaration } : {}),
     });
     if (requireDurable && (typeof sessionId !== "string" || !sessionId)) {
       throw new Error("JSONL session creation returned no durable session id");
@@ -3966,7 +4042,10 @@ async function startAgentReplInWorkspaceOwned(
         options.sessionId || null,
         meta,
         options.observabilityScope,
-        { requireDurable: Boolean(_sessionBudget) },
+        {
+          requireDurable: Boolean(_sessionBudget),
+          sessionBudgetRoot: options.sessionBudgetRoot,
+        },
       );
       if (
         sessionId &&

package/src/runtime/agent-core.js

@@ -49,6 +49,7 @@ import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
 import { gitToolInputError } from "../lib/git-tool-input.js";
 import { shellOutputPage, shellOutputPreview } from "../lib/shell-output.js";
 import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "../lib/diagnostic-workflow.js";
+import { CODING_TASK_QUALITY_GUIDANCE } from "../lib/coding-task-guidance.js";
 import { RemoteReadLoopGuard } from "../lib/remote-read-loop-guard.js";
 import {
   isPrActionRequest,
@@ -1167,6 +1168,8 @@ export function getBaseSystemPrompt(cwd) {
 You have access to tools that let you read files, write files, edit files, run shell commands, and search the codebase. When the user asks you to do something, USE THE TOOLS to actually do it — don't just describe what should be done.
 
 Key behaviors:
+${CODING_TASK_QUALITY_GUIDANCE}
+
 - A new user message may arrive before the previous task finishes. Incorporate corrections and added requests while preserving unfinished authorized work, unless the user cancels or replaces it. Use the completed tool results already in history; do not restart the investigation.
 - When asked to modify code, read the file first, then edit it
 - When asked to create something, use write_file to create it
@@ -4927,19 +4930,63 @@ export async function _withPostEditDiagnostics(
   cwd,
   additionalDirectories,
   managedCheckpoint = false,
+  writtenContent = null,
 ) {
+  // Parsing the bytes we just wrote is safe even when starting a language
+  // server is forbidden. Feed definite local import mistakes back in the same
+  // tool result; a successful write still means persistence, not test success.
+  let enriched = result;
+  if (
+    result?.success === true &&
+    typeof writtenContent === "string" &&
+    /\.(?:js|mjs|cjs)$/i.test(filePath) &&
+    process.env.CC_EDIT_DIAGNOSTICS !== "0"
+  ) {
+    try {
+      const root = pickRootForFile(
+        path.resolve(cwd || process.cwd(), filePath),
+        workspaceRootsFor(cwd, additionalDirectories),
+      );
+      if (root) {
+        const { collectFileImportDiagnostics } = await import(
+          "../lib/file-import-diagnostics.js"
+        );
+        const checked = collectFileImportDiagnostics({
+          filePath,
+          content: writtenContent,
+          workspaceRoot: root,
+        });
+        if (checked.diagnostics.length) {
+          enriched = {
+            ...result,
+            newDiagnostics: [
+              ...(result.newDiagnostics || []),
+              ...checked.diagnostics.slice(0, 8),
+            ],
+          };
+        }
+      }
+    } catch {
+      // Optional diagnostics must not turn a persisted edit into a failed one.
+    }
+  }
   // A cold language server is a long-lived child process. Starting one inside
   // a managed workspace transaction would keep a writer bound past tool
   // settlement and make commit/rollback unverifiable. Managed edits therefore
   // skip this best-effort enrichment; callers can request diagnostics after the
   // checkpoint has sealed.
-  if (managedCheckpoint) return result;
+  if (managedCheckpoint) return enriched;
   const newDiagnostics = await _postEditDiagnostics(
     filePath,
     cwd,
     additionalDirectories,
   );
-  return newDiagnostics ? { ...result, newDiagnostics } : result;
+  return newDiagnostics
+    ? {
+        ...enriched,
+        newDiagnostics: [...(enriched.newDiagnostics || []), ...newDiagnostics],
+      }
+    : enriched;
 }
 
 // ─── Lazy subtree instruction injection (large-monorepo lever) ─────────────
@@ -5791,6 +5838,7 @@ async function executeToolInner(
             cwd,
             additionalDirectories,
             managedCheckpoint || hermeticExecution,
+            args.content,
           ),
           filePath,
           cwd,
@@ -5992,6 +6040,7 @@ async function executeToolInner(
             cwd,
             additionalDirectories,
             managedCheckpoint || hermeticExecution,
+            newContent,
           ),
           filePath,
           cwd,
@@ -6094,6 +6143,7 @@ async function executeToolInner(
             cwd,
             additionalDirectories,
             managedCheckpoint || hermeticExecution,
+            result.content,
           ),
           filePath,
           cwd,
@@ -9289,24 +9339,122 @@ async function executeToolInner(
             ? null
             : captureSkillDecisionRuntime(skillDecisionRuntime);
         if (decisionRuntime !== null && routing.candidates.length > 0) {
-          const decision = await decisionRuntime.suggest({
-            query: args.query,
-            candidates: routing.candidates.slice(0, 5).map((candidate) => {
-              const descriptor = byDigest.get(candidate.digest);
+          const decisionInputsFor = (result, descriptors) => {
+            const descriptorsByDigest = new Map(
+              descriptors.map((skill) => [
+                skill.executionIdentity?.contentDigest,
+                skill,
+              ]),
+            );
+            return result.candidates.slice(0, 5).map((candidate) => {
+              const descriptor = descriptorsByDigest.get(candidate.digest);
               return {
-                id: candidate.id,
-                displayName: candidate.displayName,
-                description: descriptor?.description || candidate.displayName,
-                category: candidate.category,
-                digest: candidate.digest,
-                tags: Array.isArray(descriptor?.tags) ? descriptor.tags : [],
+                candidate: {
+                  id: candidate.id,
+                  displayName: candidate.displayName,
+                  description: descriptor?.description || candidate.displayName,
+                  category: candidate.category,
+                  digest: candidate.digest,
+                  tags: Array.isArray(descriptor?.tags)
+                    ? [...descriptor.tags]
+                    : [],
+                },
+                // Scope and compatibility are local routing inputs. They never
+                // leave the process, but changes invalidate the old advice.
+                identity: {
+                  namespace: candidate.namespace,
+                  version: candidate.version,
+                  paths: descriptor?.paths ?? null,
+                  os: descriptor?.os ?? null,
+                  capabilities: descriptor?.capabilities ?? null,
+                },
               };
-            }),
+            });
+          };
+          const decisionInputs = decisionInputsFor(routing, skills);
+          const snapshotFor = (result, inputs) =>
+            JSON.stringify({
+              candidates: inputs,
+              selectedDigest: result.selected?.digest ?? null,
+              conflicts: result.conflicts,
+            });
+          const decisionSnapshot = snapshotFor(routing, decisionInputs);
+          const contextRevision = `routing-${createHash("sha256")
+            .update(
+              JSON.stringify({
+                query: args.query,
+                category: args.category ?? null,
+                cwd,
+                turnId: turnId || toolCallId || "list-skills",
+                toolCallId: toolCallId ?? null,
+                decisionSnapshot,
+              }),
+            )
+            .digest("hex")}`;
+          const decision = await decisionRuntime.suggest({
+            query: args.query,
+            candidates: decisionInputs.map(({ candidate }) => candidate),
             turnId: turnId || toolCallId || "list-skills",
-            contextRevision: "skill-routing-v1",
+            contextRevision,
             signal,
           });
-          if (decision.visible) {
+          signal?.throwIfAborted();
+          // The provider result belongs to the captured candidate set. Recheck
+          // the persisted revocations and live loader before exposing advice.
+          await skillRetrievalRevocationReader?.refresh();
+          signal?.throwIfAborted();
+          const refreshedSkills =
+            typeof skillLoader.refreshResolvedSkills === "function"
+              ? await skillLoader.refreshResolvedSkills()
+              : skillLoader.getResolvedSkills();
+          signal?.throwIfAborted();
+          let currentSkills = await filterSkillsByCwd(
+            refreshedSkills.filter(skillAllowed),
+            cwd,
+          );
+          if (args.category) {
+            currentSkills = currentSkills.filter(
+              (s) => s.category.toLowerCase() === args.category.toLowerCase(),
+            );
+          }
+          // The vector index can change while the decision provider is in
+          // flight. Score the refreshed corpus again before comparing routing.
+          vector =
+            vectorAuthority === null
+              ? null
+              : await vectorAuthority.score({
+                  query: args.query,
+                  skills: currentSkills,
+                });
+          signal?.throwIfAborted();
+          const currentRouting = routeSkillDescriptors({
+            skills: currentSkills,
+            query: args.query,
+            target: { os: process.platform },
+            vectorScores: vector?.scores ?? null,
+            outcomeMetrics: outcomeAuthority.metrics,
+            revocationReader: skillRetrievalRevocationReader ?? null,
+            topK: Math.min(64, Math.max(1, currentSkills.length)),
+          });
+          const currentByDigest = new Map(
+            currentSkills.map((skill) => [
+              skill.executionIdentity?.contentDigest,
+              skill,
+            ]),
+          );
+          const currentDecisionSnapshot = snapshotFor(
+            currentRouting,
+            decisionInputsFor(currentRouting, currentSkills),
+          );
+          routing = currentRouting;
+          skills = routing.candidates
+            .map(({ digest }) => currentByDigest.get(digest))
+            .filter(Boolean);
+          signal?.throwIfAborted();
+          if (
+            decision.visible &&
+            currentDecisionSnapshot === decisionSnapshot
+          ) {
             routing = Object.freeze({
               ...routing,
               decisionSuggestion: Object.freeze({
@@ -14524,6 +14672,53 @@ export async function* agentLoop(messages, options) {
     options.hostResourceBudget || new HostResourceBudget();
   const taskProgressTracker =
     options.taskProgressTracker || new TaskProgressTracker();
+  // A subtree preflight is deliberately not an executed mutation. Keep this
+  // obligation outside transcript compaction and never replay it automatically.
+  const pendingSubtreeMutations = new Map();
+  let subtreeMutationReprompted = false;
+  const recordSubtreeMutation = (tool, args, result) => {
+    if (!GUARDED_FILE_MUTATION_TOOLS.has(tool)) return;
+    if (!args || typeof args !== "object" || Array.isArray(args)) return;
+    // Invalid tool arguments/results must retain their existing error path;
+    // bookkeeping must not introduce a new exception or completion verdict.
+    const requestedPaths = fileMutationPaths(tool, args);
+    if (
+      !requestedPaths.length ||
+      requestedPaths.some((target) => typeof target !== "string")
+    )
+      return;
+    const targets = [
+      ...new Set(
+        requestedPaths.map((target) =>
+          path.resolve(options.cwd || process.cwd(), target),
+        ),
+      ),
+    ].sort();
+    // These tools are alternative ways to deliver content to the same target.
+    // A successful explicit replacement must settle a deferred edit (and vice
+    // versa); move/delete/notebook effects retain their distinct obligations.
+    const effect = ["write_file", "edit_file", "edit_file_hashed"].includes(tool)
+      ? "file-content"
+      : tool;
+    const key = JSON.stringify([effect, targets]);
+    if (
+      result?.policy?.via === "subtree-instructions" &&
+      result.policy.decision === "deferred" &&
+      result.mutationPerformed === false
+    ) {
+      pendingSubtreeMutations.set(key, { tool, targets });
+    } else if (
+      result &&
+      !result.error &&
+      result.success === true &&
+      result.isError !== true &&
+      result.policy?.decision !== "deny" &&
+      result.policy?.decision !== "deferred" &&
+      result.mutationPerformed !== false
+    ) {
+      pendingSubtreeMutations.delete(key);
+    }
+  };
   const signal = options.signal || null;
   const workflowEffectId = _normalizeWorkflowEffectId(options.workflowEffectId);
   // Optional OpenTelemetry recorder (TelemetryRecorder). When present, the loop
@@ -16299,6 +16494,42 @@ export async function* agentLoop(messages, options) {
         }
         continue;
       }
+      if (pendingSubtreeMutations.size) {
+        const pending = [...pendingSubtreeMutations.values()];
+        if (!subtreeMutationReprompted && budget.remaining() > 0) {
+          subtreeMutationReprompted = true;
+          messages.push({ role: "assistant", content: msg.content || "" });
+          messages.push({
+            role: "user",
+            content:
+              "Runtime status: these mutations were deferred before any effect: " +
+              JSON.stringify(pending) +
+              ". Review the authoritative subtree instructions already returned. " +
+              "If still authorized and appropriate, explicitly issue the required tool call. " +
+              "Do not bypass rules or perform a prohibited write. Otherwise report the unfinished work and its blocker. " +
+              "A promise to retry does not execute the mutation.",
+          });
+          yield {
+            type: "iteration-warning",
+            message:
+              "Subtree-deferred mutations remain unexecuted; one recovery turn requested.",
+          };
+          continue;
+        }
+        yield {
+          type: "response-complete",
+          content:
+            (msg.content ? msg.content + "\n\n" : "") +
+            "Incomplete: subtree-deferred mutations remain unexecuted.",
+        };
+        yield {
+          type: "run-ended",
+          runId,
+          reason: "deferred-mutation-unresolved",
+          pendingMutations: pending,
+        };
+        return;
+      }
       // Surface the final answer's extended-thinking reasoning (Anthropic, when
       // --think is on) so non-streaming consumers (the REPL) can show it. The
       // streaming path forwards reasoning live via onThinking instead.
@@ -16540,6 +16771,7 @@ export async function* agentLoop(messages, options) {
         } = await promise;
         if (fatalError) throw fatalError;
         throwIfAborted(signal);
+        recordSubtreeMutation(call.function.name, toolArgs, toolResult);
         const taskAdvanced = taskProgressTracker.record(
           call.function.name,
           toolResult,
@@ -17083,6 +17315,7 @@ export async function* agentLoop(messages, options) {
         // context — but tell the model when we cut it (no more silent
         // mid-content slice). See MAX_TOOL_RESULT_CHARS / capToolResultString.
         const resultStr = toolResultForModel(toolName, toolResult, messages);
+        recordSubtreeMutation(toolName, toolArgs, toolResult);
         const taskAdvanced = taskProgressTracker.record(
           toolName,
           toolResult,