chainlesschain 0.166.80 → 0.166.82

package/src/lib/diagnostic-excerpt.js

@@ -1,12 +1,41 @@
+// Prefer test-runner verdicts over arbitrary "Error:" lines printed by tests.
+// A verdict is evidence to retain, not a claim about which defect caused it.
+const TEST_FAILURE =
+  /\bFAIL(?:ED)?\s+[^\r\n]*\.(?:[cm]?[jt]sx?|py|go|rs|java)(?=[:\s]|$)|(?:^|\s)not ok \d+\s+-|\bTest Files\s+\d+ failed/;
+export function hasTestFailureVerdict(value) {
+  return (
+    typeof value === "string" &&
+    TEST_FAILURE.test(stripVTControlCharacters(value))
+  );
+}
+
 /** Retain source context for several errors; an error line is not a root cause. */
 export function diagnosticExcerpt(value, limit = 1600) {
-  const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
+  const text = stripVTControlCharacters(
+    typeof value === "string" ? value : JSON.stringify(value ?? ""),
+  );
   if (text.length <= limit) return text;
+  if (limit < 256) return text.slice(0, Math.max(0, limit));
   const marker = "\n[... omitted ...]\n";
-  const lines = text.split("\n");
+  // gh prefixes every log line with job/step/timestamp. Keep the original
+  // head/tail, but spend diagnostic windows on the actual failure and stack.
+  const lines = text
+    .split("\n")
+    .map((line) =>
+      line.replace(/^[^\t\r\n]+\t[^\t\r\n]+\t\d{4}-\d\d-\d\dT[\d:.]+Z\s?/, ""),
+    );
   const errors = [];
   const workers = [];
+  const failures = [];
+  const summaries = [];
   for (let i = 0; i < lines.length; i++) {
+    if (TEST_FAILURE.test(lines[i])) failures.push(i);
+    if (
+      /\b(?:Test Files|Tests)\s+\d+ (?:failed|passed)|\b[\w -]+ tests (?:PASSED|FAILED)\b|\b(?:PASS|ok \d+ -)\b.*(?:negative|spawn|gate)/i.test(
+        lines[i],
+      )
+    )
+      summaries.push(i);
     if (
       /\b\w*Error:|Exception in thread|Caused by:|\bpanic:|panicked at|\bFAIL\b|error TS\d+|##\[error\]/.test(
         lines[i],
@@ -20,11 +49,21 @@ export function diagnosticExcerpt(value, limit = 1600) {
     )
       workers.push(i);
   }
-  // Keep both an early diagnostic (possibly expected negative-test output)
-  // and later runner failures. Never infer causality from their ordering.
+  // A middle failed-test block used to disappear between an expected early
+  // error and the final gate error. Keep its location and adjacent assertion,
+  // alongside process summaries; never infer causality from their ordering.
+  const lastError = errors.at(-1);
+  const finalError =
+    lastError !== undefined &&
+    /Process completed with exit code/.test(lines[lastError]) &&
+    errors.at(-2) >= lastError - 2
+      ? errors.at(-2)
+      : lastError;
   const indices = [
     ...new Set(
-      [workers[0], errors[0], errors.at(-1)].filter((i) => i !== undefined),
+      [failures[0], workers[0], errors[0], finalError].filter(
+        (i) => i !== undefined,
+      ),
     ),
   ].sort((a, b) => a - b);
   if (!indices.length) {
@@ -33,19 +72,61 @@ export function diagnosticExcerpt(value, limit = 1600) {
       text.slice(0, head) + marker + text.slice(-(limit - marker.length - head))
     );
   }
-  const available = limit - marker.length * (indices.length + 1);
+  const failedSuites = summaries.filter((index) =>
+    /tests FAILED\b/.test(lines[index]),
+  );
+  const verdictIndices = failedSuites.length
+    ? [
+        ...new Set(
+          [
+            ...failedSuites,
+            summaries.find((index) => /tests PASSED\b/.test(lines[index])),
+            ...failedSuites.map((index) => {
+              const suite = /([\w-]+ tests) FAILED\b/.exec(lines[index])?.[1];
+              return suite
+                ? summaries.findLast((next) =>
+                    lines[next].includes(`${suite} PASSED`),
+                  )
+                : undefined;
+            }),
+          ].filter((index) => index !== undefined),
+        ),
+      ]
+    : summaries.slice(-5);
+  const verdicts = verdictIndices
+    .map((index) => lines[index])
+    .join("\n")
+    .slice(0, Math.floor(limit * 0.2));
+  const available =
+    limit -
+    marker.length * (indices.length + 1 + (verdicts ? 1 : 0)) -
+    verdicts.length;
   const head = Math.floor(available * 0.1);
   const tail = Math.floor(available * 0.15);
-  const perWindow = Math.floor((available - head - tail) / indices.length);
+  const windowBudget = available - head - tail;
+  const failureBudget = failures.length
+    ? Math.floor(windowBudget * (indices.length > 1 ? 0.55 : 1))
+    : 0;
+  const perWindow = Math.floor(
+    (windowBudget - failureBudget) /
+      Math.max(1, indices.length - (failures.length ? 1 : 0)),
+  );
   const windows = indices.map((index) => {
+    const size = index === failures[0] ? failureBudget : perWindow;
     const before = lines
       .slice(Math.max(0, index - 2), index)
       .join("\n")
-      .slice(-Math.floor(perWindow * 0.2));
+      .slice(-Math.floor(size * 0.1));
     return (before + "\n" + lines.slice(index, index + 10).join("\n")).slice(
       0,
-      perWindow,
+      size,
     );
   });
-  return [text.slice(0, head), ...windows, text.slice(-tail)].join(marker);
+  return [
+    text.slice(0, head),
+    ...windows,
+    ...(verdicts ? [verdicts] : []),
+    text.slice(-tail),
+  ].join(marker);
 }
+import { stripVTControlCharacters } from "node:util";

package/src/lib/diagnostic-workflow.js

@@ -4,6 +4,8 @@ export const DIAGNOSTIC_WORKFLOW_GUIDANCE =
   "For debugging, retain the original failure signature (error, source location, stack, command, environment and revision when verified). " +
   "Label each observation by its source and reproduction scope. A passing subset is not a successful full reproduction; a different error is a separate finding until evidence connects it to the original failure. " +
   "Expected negative-test output, dependency/setup failures, failed assertions and runner/infrastructure failures are different possibilities. Inspect surrounding output and process outcomes before selecting one. Timing alone does not identify the cause, and argument order is not execution order. " +
+  "Keep confirmed facts separate from hypotheses and ruled-out signals, with their source. Preserve an established failure and excluded negative-test errors across compaction; a later command syntax error does not invalidate an earlier successful observation. Reopen a ruled-out hypothesis only when new evidence contradicts it. " +
+  "An issue, its linked PR, the PR head, a synthetic merge ref, the merged commit, and each workflow run/attempt are separate identities. Keep their numbers and revisions distinct. A green diagnostic retry does not replace the primary failure or prove that a flaky test was fixed. A different release workflow failing on that commit is a separate finding until connected to this task. " +
   "State one hypothesis and the smallest check that can disprove it; after that check, update the hypothesis from the observed result instead of restarting discovery. " +
   "Do not change dependencies while a reproduction using them is running. Poll background tasks by task_id and drain has_more_output after exit. " +
   "Bind reports to verified paths, runs and attempts; do not substitute a local or stale report for the target run. A green report alone does not override a nonzero exit, unhandled errors or incomplete output. " +

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

@@ -1,6 +1,13 @@
 // 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) {
+  if (/^\s*(?:git\s+)?gh(?:\.exe)?(?:\s|$)/i.test(command))
+    return {
+      success: false,
+      code: "CC_GIT_WRONG_TOOL",
+      error: "gh is the GitHub CLI, not a Git subcommand.",
+      hint: "Use run_shell for the original gh command, subject to its normal permissions. Use the git tool only for Git arguments such as status or log. No command was executed.",
+    };
   let quote = null;
   for (let i = 0; i < command.length; i++) {
     const char = command[i];

package/src/lib/plan-mode.js

@@ -893,8 +893,8 @@ export class PlanModeManager extends EventEmitter {
   }
 
   _commitMutation(transaction, eventType) {
+    const previousRevision = this.revision;
     if (!this._persistence) {
-      const previousRevision = this.revision;
       this.revision += 1;
       this.updatedAt = Date.now();
       this.lastEvent = this.sessionId
@@ -906,6 +906,11 @@ export class PlanModeManager extends EventEmitter {
             timestamp: this.updatedAt,
           })
         : null;
+      this.emit("revision-changed", {
+        revision: this.revision,
+        previousRevision,
+        type: eventType,
+      });
       if (this.lastEvent) this.emit("session-event", { ...this.lastEvent });
       return null;
     }
@@ -920,6 +925,11 @@ export class PlanModeManager extends EventEmitter {
       this.revision = snapshot.revision;
       this.updatedAt = snapshot.updatedAt;
       this.lastEvent = snapshot.event;
+      this.emit("revision-changed", {
+        revision: this.revision,
+        previousRevision,
+        type: eventType,
+      });
       this.emit("session-event", { ...this.lastEvent });
       return null;
     } catch (error) {
@@ -1369,7 +1379,7 @@ export class PlanModeManager extends EventEmitter {
   /**
    * Check if a tool is allowed in current state
    */
-  isToolAllowed(toolName) {
+  isToolAllowed(toolName, { recordBlocked = true } = {}) {
     if (!this.isActive()) return true;
     if (
       this.state === PlanState.APPROVED ||
@@ -1377,7 +1387,8 @@ export class PlanModeManager extends EventEmitter {
     ) {
       const allowed =
         this.executionLock?.allowedTools.includes(toolName) === true;
-      if (!allowed) this._recordBlockedTool(toolName, "execution-lock");
+      if (!allowed && recordBlocked)
+        this._recordBlockedTool(toolName, "execution-lock");
       return allowed;
     }
 
@@ -1386,7 +1397,7 @@ export class PlanModeManager extends EventEmitter {
 
     // Block write tools and log
     if (WRITE_TOOLS.has(toolName)) {
-      this._recordBlockedTool(toolName, "planning");
+      if (recordBlocked) this._recordBlockedTool(toolName, "planning");
       return false;
     }
 

package/src/lib/process-execution-broker/linux-generic-bwrap-runtime.js

@@ -21,13 +21,13 @@ import {
   buildLinuxBwrapDescriptorScrubbedLaunch,
   LINUX_BWRAP_DESCRIPTOR_SCRUBBER_PATH,
 } from "./linux-bwrap-descriptor-launch.js";
+import { linuxTmpfileFlag } from "./linux-open-flags.js";
 
 const BWRAP_PATH = "/usr/bin/bwrap";
 const MAX_ATTESTED_FILE_BYTES = 256 * 1024 * 1024;
 const MAX_MOUNTINFO_BYTES = 4 * 1024 * 1024;
 const MOUNTINFO_PATH = "/proc/self/mountinfo";
 const MOUNT_TOPOLOGY_VERSION = 1;
-const O_TMPFILE = 0x410000;
 const SYSTEM_DESTINATIONS = [
   "/usr",
   "/bin",
@@ -1085,7 +1085,7 @@ function createTrustedResources(
       const flags =
         Number(constants.O_RDWR) |
         Number(constants.O_EXCL) |
-        Number(constants.O_TMPFILE ?? O_TMPFILE) |
+        linuxTmpfileFlag(constants) |
         Number(constants.O_NOFOLLOW || 0) |
         Number(constants.O_NONBLOCK || 0);
       const fd = track(runtime.fs.openSync("/tmp", flags, 0o400), phase);

package/src/lib/process-execution-broker/linux-open-flags.js

@@ -0,0 +1,26 @@
+// Linux defines O_TMPFILE as __O_TMPFILE | O_DIRECTORY. O_DIRECTORY is
+// architecture-specific (0x4000 on ARM64, 0x10000 on x64), while Node does
+// not expose O_TMPFILE on every supported build.
+const LINUX_ANONYMOUS_TMPFILE_BIT = 0x400000;
+
+export function linuxTmpfileFlag(constants) {
+  const directoryFlag = constants?.O_DIRECTORY;
+  if (
+    !Number.isSafeInteger(directoryFlag) ||
+    directoryFlag <= 0 ||
+    (directoryFlag & (directoryFlag - 1)) !== 0
+  ) {
+    throw new Error("linux_o_directory_unavailable");
+  }
+
+  const fallbackFlag = LINUX_ANONYMOUS_TMPFILE_BIT | directoryFlag;
+  const tmpfileFlag = constants.O_TMPFILE ?? fallbackFlag;
+  if (
+    !Number.isSafeInteger(tmpfileFlag) ||
+    (tmpfileFlag & LINUX_ANONYMOUS_TMPFILE_BIT) === 0 ||
+    (tmpfileFlag & directoryFlag) !== directoryFlag
+  ) {
+    throw new Error("linux_o_tmpfile_invalid");
+  }
+  return tmpfileFlag;
+}

package/src/lib/process-execution-broker/platform-sandbox.js

@@ -33,6 +33,7 @@ import {
   applyLinuxGenericWorkspaceSandbox,
   isLinuxGenericWorkspaceContract,
 } from "./linux-generic-bwrap-runtime.js";
+import { linuxTmpfileFlag } from "./linux-open-flags.js";
 import {
   buildLinuxBwrapDescriptorScrubbedLaunch,
   LINUX_BWRAP_DESCRIPTOR_SCRUBBER_PATH,
@@ -288,10 +289,7 @@ const LINUX_ELF_MACHINES = Object.freeze({
   arm64: 183,
   riscv64: 243,
 });
-// Linux asm-generic: __O_TMPFILE (0x400000) | O_DIRECTORY (0x010000).
-// x64, arm64, and riscv64 use this value; unsupported seccomp architectures
-// already fail closed before the anonymous filter is created.
-const LINUX_O_TMPFILE = 0x410000;
+// Anonymous snapshots and seccomp filters require the native O_TMPFILE flag.
 const LINUX_CLONE_NEWNS = 0x00020000;
 const LINUX_CLONE_NEWUSER = 0x10000000;
 const LINUX_NAMESPACE_CLONE_FLAGS = LINUX_CLONE_NEWNS | LINUX_CLONE_NEWUSER;
@@ -2728,9 +2726,7 @@ function sameWindowsFileIdentity(left, right) {
 // the deletion authority.
 function sameWindowsFileObjectIdentity(left, right) {
   return (
-    left.dev === right.dev &&
-    left.ino === right.ino &&
-    left.mode === right.mode
+    left.dev === right.dev && left.ino === right.ino && left.mode === right.mode
   );
 }
 
@@ -5853,7 +5849,7 @@ function createLinuxRegularFileSnapshot(
     const writerFlags =
       Number(constants.O_RDWR) |
       Number(constants.O_EXCL) |
-      Number(constants.O_TMPFILE ?? LINUX_O_TMPFILE) |
+      linuxTmpfileFlag(constants) |
       Number(constants.O_NOFOLLOW || 0) |
       Number(constants.O_NONBLOCK || 0);
     writerFd = runtime.fs.openSync("/tmp", writerFlags, snapshotSourceMode);
@@ -7442,7 +7438,7 @@ function pinLinuxNetworkSeccompFilter(runtime, options = {}) {
     const flags =
       Number(constants.O_RDWR) |
       Number(constants.O_EXCL) |
-      Number(constants.O_TMPFILE ?? LINUX_O_TMPFILE) |
+      linuxTmpfileFlag(constants) |
       Number(constants.O_NOFOLLOW || 0) |
       Number(constants.O_NONBLOCK || 0);
     // An anonymous inode avoids a same-UID process opening the filter by path.

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

@@ -18,6 +18,19 @@ function pullRequestTarget(repo, id = "list") {
   return { ...githubTarget(repo, "pulls", id), pullRequest: true };
 }
 
+function issueTarget(repo, id = "list") {
+  return { ...githubTarget(repo, "issues", id), issue: true };
+}
+
+const ISSUE_WORKFLOW_GUIDANCE =
+  "Issue investigation: retain the issue, linked PR and workflow run as separate targets, with verified revisions and observed test outcomes. " +
+  "Use gh issue view for an issue and gh pr view for its linked PR; their numbers need not match. " +
+  "Use gh run view <run-id> for one run; gh run list accepts filters, not a positional run ID. " +
+  "For unknown JSON fields, inspect stderr/help and request supported fields without jq or shell pipelines first. " +
+  "A completed metadata read remains evidence after an unrelated command fails; do not restart the same investigation. " +
+  "Once the failing test and source are known, state a falsifiable hypothesis, run the focused reproduction, then make and validate the authorized fix. " +
+  "A merged PR or a passing diagnostic retry alone does not resolve the reported failure. Perform issue closure only when authorized and supported by the requested resolution evidence. ";
+
 function commandFlag(command, names) {
   return new RegExp(
     `(?:^|\\s)(?:${names})(?:=|\\s+)(?:"([^"]*)"|'([^']*)'|([^\\s;&|]+))`,
@@ -27,13 +40,16 @@ function commandFlag(command, names) {
     .find((value) => value !== undefined);
 }
 
-function pullRequestCommandTarget(command) {
+function discussionCommandTarget(command) {
   const match =
-    /(?:^|[\s;&|])gh(?:\.exe)?\s+pr\s+(list|view|diff)\b([^;&|\r\n]*)/i.exec(
+    /(?:^|[\s;&|])gh(?:\.exe)?\s+(pr|issue)\s+(list|view|diff)\b([^;&|\r\n]*)/i.exec(
       command,
     );
   if (!match) return null;
-  const fields = commandFlag(match[2], "--json")?.split(",");
+  const target =
+    match[1].toLowerCase() === "issue" ? issueTarget : pullRequestTarget;
+  const tail = match[3];
+  const fields = commandFlag(tail, "--json")?.split(",");
   // Lightweight status polling is intentional waiting, not repeated review.
   if (
     fields?.length &&
@@ -44,18 +60,20 @@ function pullRequestCommandTarget(command) {
     )
   )
     return null;
-  const repo = commandFlag(match[2], "--repo|-R") || "current-repo";
-  if (match[1].toLowerCase() === "list") return pullRequestTarget(repo);
+  const repo = commandFlag(tail, "--repo|-R") || "current-repo";
+  if (match[2].toLowerCase() === "list") return target(repo);
   const prUrl =
-    /https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/pull\/(\d+)\b/i.exec(match[2]);
-  if (prUrl) return pullRequestTarget(prUrl[1], prUrl[2]);
+    /https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/(?:pull|issues)\/(\d+)\b/i.exec(
+      tail,
+    );
+  if (prUrl) return target(prUrl[1], prUrl[2]);
   // Remove flags that consume values before finding the positional PR number.
-  const positional = match[2].replace(
+  const positional = tail.replace(
     /(?:^|\s)(?:--repo|-R|--json|--jq|-q|--template|-t|--color)(?:=|\s+)(?:"[^"]*"|'[^']*'|[^\s]+)/g,
     " ",
   );
   const number = /(?:^|\s)["']?(\d+)["']?(?=\s|$)/.exec(positional)?.[1];
-  return number ? pullRequestTarget(repo, number) : null;
+  return number ? target(repo, number) : null;
 }
 
 function urlTarget(value) {
@@ -69,6 +87,10 @@ function urlTarget(value) {
     };
   }
   if (url.hostname === "github.com") {
+    const issue = /^\/([^/]+\/[^/]+)\/issues(?:\/(\d+))?\/?$/.exec(
+      url.pathname,
+    );
+    if (issue) return issueTarget(issue[1], issue[2]);
     const pr =
       /^\/([^/]+\/[^/]+)\/(?:pulls\/?|pull\/(\d+)(?:\/(?:files|commits|checks))?\/?|pull\/(\d+)\.(?:diff|patch))$/.exec(
         url.pathname,
@@ -87,6 +109,11 @@ function urlTarget(value) {
       );
   }
   if (url.hostname === "api.github.com") {
+    const issue =
+      /^\/repos\/([^/]+\/[^/]+)\/issues(?:\/(\d+)(?:\/(?:comments|events|timeline))?)?\/?$/.exec(
+        url.pathname,
+      );
+    if (issue) return issueTarget(issue[1], issue[2]);
     const pr =
       /^\/repos\/([^/]+\/[^/]+)\/pulls(?:\/(\d+)(?:\/(?:files|commits|reviews|comments))?)?\/?$/.exec(
         url.pathname,
@@ -144,8 +171,8 @@ export function remoteReadTarget(tool, args = {}) {
   }
   if (tool !== "run_shell") return null;
   const command = typeof args.command === "string" ? args.command : "";
-  const pr = pullRequestCommandTarget(command);
-  if (pr) return pr;
+  const discussion = discussionCommandTarget(command);
+  if (discussion) return discussion;
   const view = /(?:^|[\s;&|])gh(?:\.exe)?\s+run\s+view\s+([^;&|\r\n]+)/i.exec(
     command,
   );
@@ -172,6 +199,11 @@ export function remoteReadTarget(tool, args = {}) {
       /(?:^|\s)(?:(?:--field|--raw-field|--input)(?:=|\s)|-[fF])/.test(command)
     )
       return null;
+    const issueApi =
+      /(?:https:\/\/api\.github\.com\/)?\/?repos\/([\w.-]+\/[\w.-]+)\/issues(?:\/(\d+)(?:\/(?:comments|events|timeline))?)?(?=[?\s"']|$)/.exec(
+        command,
+      );
+    if (issueApi) return issueTarget(issueApi[1], issueApi[2]);
     const prApi =
       /(?:https:\/\/api\.github\.com\/)?\/?repos\/([\w.-]+\/[\w.-]+)\/pulls(?:\/(\d+)(?:\/(?:files|commits|reviews|comments))?)?(?=[?\s"']|$)/.exec(
         command,
@@ -369,6 +401,14 @@ export class RemoteReadLoopGuard {
   get recoveryHint() {
     if (!(this.targets.get(this.activeKey)?.repeats >= RECOVERY_AFTER))
       return null;
+    if (this.targets.get(this.activeKey)?.issue) {
+      return (
+        "Remote-read loop recovery: repeated issue reads returned failures or already-seen evidence. " +
+        "Use the retained observations; identify the exact missing fact before a new focused read. " +
+        ISSUE_WORKFLOW_GUIDANCE +
+        DIAGNOSTIC_WORKFLOW_GUIDANCE
+      );
+    }
     if (this.targets.get(this.activeKey)?.shellPolicy) {
       return (
         "Tool-policy loop recovery: the same execution policy keeps rejecting commands, even when their arguments change. " +
@@ -449,6 +489,8 @@ export class RemoteReadLoopGuard {
   }
 
   get workflowHint() {
+    if (this.targets.get(this.activeKey)?.issue)
+      return ISSUE_WORKFLOW_GUIDANCE + DIAGNOSTIC_WORKFLOW_GUIDANCE;
     const active = this.targets.get(this.activeKey);
     if (active?.github && !active.pullRequest) {
       return (
@@ -505,6 +547,7 @@ export class RemoteReadLoopGuard {
         page,
         localLog,
         pullRequest,
+        issue,
         shellPolicy,
         gitRepository,
       }) => ({
@@ -515,9 +558,11 @@ export class RemoteReadLoopGuard {
             : github
               ? pullRequest
                 ? "GitHub pull requests"
-                : localLog
-                  ? "saved GitHub Actions log"
-                  : "GitHub Actions logs"
+                : issue
+                  ? "GitHub issues"
+                  : localLog
+                    ? "saved GitHub Actions log"
+                    : "GitHub Actions logs"
               : tool === "web_search"
                 ? "web_search"
                 : "web_fetch",