chainlesschain 0.162.162 → 0.162.164

package/src/lib/review-pipeline.js

@@ -12,8 +12,16 @@
  * verifier verdicts, confidence-filter, rank, and render the structured report.
  * The fan-out of finder/verifier AGENTS is orchestration the command layer adds;
  * everything here is deterministic and testable without an LLM.
+ *
+ * P1-1 wiring (行评论锚定): when the caller supplies the reviewed file contents,
+ * each finding's output carries a re-anchorable comment ANCHOR (file + base hash
+ * + line + anchored line text + context) via [[review-comment-anchor.js]] instead
+ * of only a bare `line` coordinate — so a downstream IDE Diff Review can relocate
+ * or stale the comment after the agent edits the file, never reusing a dead line.
  */
 
+import { makeCommentAnchor } from "./review-comment-anchor.js";
+
 /** The finder dimensions a full review fans out across. */
 export const REVIEW_DIMENSIONS = Object.freeze([
   "correctness",
@@ -184,16 +192,44 @@ export function rankFindings(findings) {
   );
 }
 
-function toOutputFinding(f) {
-  return {
+/** Look a path's content up from a Map or plain object, or return undefined. */
+function lookupContent(fileContents, filePath) {
+  if (!fileContents) return undefined;
+  if (typeof fileContents.get === "function") return fileContents.get(filePath);
+  return fileContents[filePath];
+}
+
+function toOutputFinding(f, fileContents) {
+  const line = Number.isFinite(Number(f.line))
+    ? Math.floor(Number(f.line))
+    : null;
+  const failureScenario = String(f.failureScenario || f.failure_scenario || "");
+  const out = {
     path: String(f.path || ""),
-    line: Number.isFinite(Number(f.line)) ? Math.floor(Number(f.line)) : null,
+    line,
     category: f.category || (f.categories && f.categories[0]) || "correctness",
     severity: normalizeSeverity(f.severity),
-    failure_scenario: String(f.failureScenario || f.failure_scenario || ""),
+    failure_scenario: failureScenario,
     evidence: String(f.evidence || ""),
     confidence: clampConfidence(f.confidence),
   };
+  // P1-1: anchor the comment to the CODE it addresses, not to a coordinate, so
+  // an IDE diff review can relocate/stale it after edits (never reuse a dead
+  // line). Only when the caller supplied this file's content AND we have a
+  // valid 1-based line to anchor.
+  if (line != null && line >= 1) {
+    const content = lookupContent(fileContents, out.path);
+    if (typeof content === "string") {
+      out.anchor = makeCommentAnchor({
+        file: out.path,
+        content,
+        line,
+        comment: failureScenario || out.evidence,
+        id: `${out.path}:${line}:${out.category}`,
+      });
+    }
+  }
+  return out;
 }
 
 /**
@@ -202,17 +238,20 @@ function toOutputFinding(f) {
  * evidence output) plus severity/category rollups.
  *
  * @param {Array} rawFindings   findings from all finders
- * @param {object} [opts]       { verdicts, minConfidence }
+ * @param {object} [opts]       { verdicts, minConfidence, fileContents }
+ *   fileContents — optional Map/object of `path → current file content`. When a
+ *   finding's file is present, its output gains a re-anchorable `anchor` (P1-1);
+ *   omit it and the output is byte-identical to before.
  */
 export function buildReviewReport(
   rawFindings,
-  { verdicts = {}, minConfidence = 0 } = {},
+  { verdicts = {}, minConfidence = 0, fileContents = null } = {},
 ) {
   const deduped = dedupeFindings(rawFindings);
   const verified = applyVerdicts(deduped, verdicts);
   const filtered = filterByConfidence(verified, { minConfidence });
   const ranked = rankFindings(filtered);
-  const findings = ranked.map(toOutputFinding);
+  const findings = ranked.map((f) => toOutputFinding(f, fileContents));
 
   const bySeverity = { Critical: 0, High: 0, Medium: 0, Low: 0, Note: 0 };
   const byCategory = {};

package/src/lib/runtime-checkup.js

@@ -216,6 +216,227 @@ export function checkHooks(hooks = [], t) {
   return out;
 }
 
+/**
+ * STATICALLY validate a settings.json `hooks` block for reliably-detectable
+ * breakage — a hook that will silently NEVER fire (unknown event name, an
+ * uncompilable `/…/` regex matcher, a missing command) or is misconfigured (a
+ * non-positive / over-cap timeout). This is the config subset a doctor can
+ * catch without running anything; RUNTIME health (slow / circuit-broken hooks)
+ * needs live per-process stats and is handled by `checkHooks`, not here.
+ *
+ * @param {object} hooksBlock raw `.hooks` object from settings.json
+ * @param {object} [opts] { validEvents: Set<string>|string[], maxTimeoutSec }
+ */
+export function checkHookConfig(
+  hooksBlock,
+  { validEvents, maxTimeoutSec = 600 } = {},
+) {
+  const out = [];
+  if (!hooksBlock || typeof hooksBlock !== "object") return out;
+  const known =
+    validEvents instanceof Set ? validEvents : new Set(validEvents || []);
+
+  for (const [event, groups] of Object.entries(hooksBlock)) {
+    // An event key the loader doesn't understand → every hook under it is dead
+    // (silently never fires). This is the highest-value static catch.
+    if (known.size && !known.has(event)) {
+      out.push(
+        finding(
+          "hook-unknown-event",
+          "hooks",
+          "warn",
+          `Hook event "${event}" is not recognized — its hooks never fire`,
+          "fix the event name in settings.json hooks",
+          { ref: event },
+        ),
+      );
+      continue;
+    }
+    if (!Array.isArray(groups)) {
+      out.push(
+        finding(
+          "hook-malformed",
+          "hooks",
+          "warn",
+          `Hook event "${event}" is not an array`,
+          "settings.json hooks[<event>] must be an array",
+          { ref: event },
+        ),
+      );
+      continue;
+    }
+    groups.forEach((g, gi) => {
+      const at = `${event}[${gi}]`;
+      // A `/body/flags` regex matcher that won't compile silently never matches.
+      if (g && typeof g.matcher === "string" && g.matcher.startsWith("/")) {
+        const m = g.matcher.match(/^\/(.*)\/([a-z]*)$/);
+        try {
+          new RegExp(m ? m[1] : g.matcher.slice(1), m ? m[2] : "");
+        } catch {
+          out.push(
+            finding(
+              "hook-bad-matcher",
+              "hooks",
+              "warn",
+              `Hook ${at} matcher ${g.matcher} is not a valid regex — it never matches`,
+              "fix the regex matcher",
+              { ref: at },
+            ),
+          );
+        }
+      }
+      const cmds = g && Array.isArray(g.hooks) ? g.hooks : null;
+      if (!cmds) {
+        out.push(
+          finding(
+            "hook-malformed",
+            "hooks",
+            "warn",
+            `Hook ${at} has no hooks array`,
+            "each hook group needs a hooks:[] array",
+            { ref: at },
+          ),
+        );
+        return;
+      }
+      cmds.forEach((h, hi) => {
+        const hAt = `${at}.hooks[${hi}]`;
+        if (!h || typeof h.command !== "string" || !h.command.trim()) {
+          out.push(
+            finding(
+              "hook-no-command",
+              "hooks",
+              "warn",
+              `Hook ${hAt} has no command — it does nothing`,
+              "add a command string or remove the entry",
+              { ref: hAt },
+            ),
+          );
+        }
+        if (h && h.timeout != null) {
+          const t = Number(h.timeout);
+          if (!Number.isFinite(t) || t <= 0) {
+            out.push(
+              finding(
+                "hook-bad-timeout",
+                "hooks",
+                "info",
+                `Hook ${hAt} timeout ${h.timeout} is not a positive number`,
+                "timeout is in seconds; use a positive value",
+                { ref: hAt },
+              ),
+            );
+          } else if (t > maxTimeoutSec) {
+            out.push(
+              finding(
+                "hook-bad-timeout",
+                "hooks",
+                "info",
+                `Hook ${hAt} timeout ${t}s exceeds the ${maxTimeoutSec}s cap (clamped)`,
+                "lower the timeout",
+                { ref: hAt },
+              ),
+            );
+          }
+        }
+      });
+    });
+  }
+  return out;
+}
+
+/**
+ * Sandbox real-capability / silent-degradation (P2 doctor "沙箱真实能力和静默
+ * 降级"). Given a probed snapshot, flag the dangerous case: a sandbox is
+ * CONFIGURED but its engine is unavailable AND `failIfUnavailable` is off — so
+ * tool subprocesses run with NO isolation and nothing warns (you think you're
+ * sandboxed but you're not). Strict-but-unavailable is a warn (fail-closed: the
+ * agent refuses to start, so it's not silent). Available → an info confirming
+ * the true isolation level.
+ *
+ * @param {object} snapshot { configured, engine, available, reason,
+ *   failIfUnavailable, isolationLevel }
+ */
+export function checkSandbox(snapshot = {}) {
+  const out = [];
+  if (!snapshot || !snapshot.configured) return out;
+  const engine = snapshot.engine || "sandbox";
+  const why = snapshot.reason ? `: ${snapshot.reason}` : "";
+  if (snapshot.available) {
+    out.push(
+      finding(
+        "sandbox-active",
+        "sandbox",
+        "info",
+        `Sandbox ${engine} available (isolation: ${snapshot.isolationLevel || "unknown"})`,
+        "",
+        { ref: engine },
+      ),
+    );
+    return out;
+  }
+  if (snapshot.failIfUnavailable) {
+    out.push(
+      finding(
+        "sandbox-strict-unavailable",
+        "sandbox",
+        "warn",
+        `Sandbox ${engine} is configured (strict) but unavailable${why} — the agent refuses to start until it's installed`,
+        `install ${engine} or unset sandbox.failIfUnavailable`,
+        { ref: engine },
+      ),
+    );
+  } else {
+    out.push(
+      finding(
+        "sandbox-silent-degrade",
+        "sandbox",
+        "error",
+        `Sandbox ${engine} is configured but unavailable${why} — commands run WITHOUT isolation and won't warn`,
+        `install ${engine}, or set sandbox.failIfUnavailable:true to fail closed`,
+        { ref: engine },
+      ),
+    );
+  }
+  return out;
+}
+
+/**
+ * Skill ids defined MORE THAN ONCE across (or within) layers (P2 doctor "重复
+ * Skill"). The loader's loadAll() silently keeps only the highest-priority copy
+ * per id (Map.set overwrite), so a user never learns their custom skill shadowed
+ * — or was shadowed by — another. Given the full, un-deduped per-layer entry
+ * list, flag every id with more than one definition.
+ *
+ * @param {Array<{id:string, layer:string}>} entries
+ */
+export function checkDuplicateSkills(entries = []) {
+  const byId = new Map(); // id → layer[]
+  for (const e of entries) {
+    if (!e || !e.id) continue;
+    const arr = byId.get(e.id) || [];
+    arr.push(e.layer || "?");
+    byId.set(e.id, arr);
+  }
+  const out = [];
+  for (const [id, layers] of byId) {
+    if (layers.length > 1) {
+      const uniq = [...new Set(layers)];
+      out.push(
+        finding(
+          "skill-duplicate",
+          "skills",
+          "warn",
+          `Skill "${id}" has ${layers.length} definitions (${uniq.join(", ")}) — only the highest-priority copy loads`,
+          "rename or remove the redundant skill copy",
+          { ref: id, layers: uniq },
+        ),
+      );
+    }
+  }
+  return out;
+}
+
 /** Plugins / LSP servers reported unhealthy or dead. */
 export function checkPluginsAndLsp(plugins = []) {
   const out = [];

package/src/lib/schedule-planner.js

@@ -52,11 +52,27 @@ export function baseFireAt(entry) {
   return Number.isFinite(n) ? n : null;
 }
 
+/**
+ * The jitter window that governs an entry: a PER-ENTRY `entry.jitterMs` (a
+ * finite, non-negative number stored at create time) is authoritative and wins
+ * over the caller's `jitterMs` fallback; an entry without its own field falls
+ * back to the passed global. This lets each scheduled task carry its own spread
+ * — one noisy cron can jitter without perturbing the rest — while still honoring
+ * a daemon-wide default for entries that predate per-entry jitter.
+ */
+export function resolveEntryJitterMs(entry, jitterMs = 0) {
+  const per = Number(entry?.jitterMs);
+  if (Number.isFinite(per) && per >= 0) return per;
+  return Number(jitterMs) || 0;
+}
+
 /** Base fire time with the entry's deterministic jitter applied. */
 export function effectiveFireAt(entry, jitterMs = 0) {
   const base = baseFireAt(entry);
   if (base == null) return null;
-  return base + jitterOffsetMs(entry?.id, jitterMs);
+  return (
+    base + jitterOffsetMs(entry?.id, resolveEntryJitterMs(entry, jitterMs))
+  );
 }
 
 /** Is an entry still pending/active (not in a terminal state)? */