nexus-agents 8.60.2 → 8.61.0

package/dist/{chunk-Q3LSWYM5.js → chunk-3IDUHDPD.js}

@@ -21,7 +21,7 @@ import {
 import {
   DEFAULT_TASK_TTL_MS,
   clampTaskTtl
-} from "./chunk-RTEZ6OJY.js";
+} from "./chunk-K576C3OX.js";
 import {
   executeExpert
 } from "./chunk-QBVYOOEI.js";
@@ -71,7 +71,7 @@ import {
   updateStage,
   withWarnings,
   writeJobCancelled
-} from "./chunk-TCEMOFIM.js";
+} from "./chunk-X3WILSBY.js";
 import {
   allOf,
   anyOf
@@ -87,14 +87,14 @@ import {
   createDurableAuditTrail,
   createGraphAuditBridge,
   emitPipelinePolicyEvent
-} from "./chunk-5ZVGPKNO.js";
+} from "./chunk-AZI3WR3N.js";
 import {
   resolveEnvMode,
   sanitizeInput
 } from "./chunk-DIV6TBCN.js";
 import {
   withPrerequisite
-} from "./chunk-426AIY5F.js";
+} from "./chunk-Z2WFGKLU.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -117,7 +117,7 @@ import {
   toolSuccessStructured,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-3UAEJN4N.js";
+} from "./chunk-FV7WJ4ES.js";
 import {
   EventTopics,
   UNRESOLVED_MODEL_ID,
@@ -45864,7 +45864,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-CGMODLMK.js");
+    const { createIssueTriage } = await import("./issue-triage-OMJMXLCX.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num2 = issueMatch[2] ?? "";
@@ -46266,7 +46266,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-QMDRIAM7.js");
+    const { executeVoting } = await import("./consensus-vote-YKKVQIE7.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);
@@ -48064,7 +48064,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-QMDRIAM7.js");
+        const { executeVoting } = await import("./consensus-vote-YKKVQIE7.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -57277,4 +57277,4 @@ export {
   startPipelineEventBridge,
   shutdownPipelineEventBridge
 };
-//# sourceMappingURL=chunk-Q3LSWYM5.js.map
+//# sourceMappingURL=chunk-3IDUHDPD.js.map

package/dist/{chunk-5ZVGPKNO.js → chunk-AZI3WR3N.js}

@@ -1008,7 +1008,8 @@ function policyRefusal(policy, policyMode, user, effectiveTrustTier) {
   return {
     code: "POLICY_REFUSED",
     message: `Refused by firewall policy: ` + blocking.map((v) => `${v.rule} \u2014 ${v.message}`).join("; "),
-    stage: "policy"
+    stage: "policy",
+    violations: blocking
   };
 }
 
@@ -1569,29 +1570,82 @@ function getUntrustedInputFirewall() {
   return singleton;
 }
 function runUntrustedInputFirewall(input, options) {
+  const result = processAndLog(input, options);
+  if (!result.ok) return err(asError(result.error));
+  return ok(result.value);
+}
+function evaluateActionThroughFirewall(input, options) {
+  const { enforcedTier, ...processOptions } = options;
+  const result = processAndLog(input, processOptions);
+  if (!result.ok) {
+    const { code, stage, violations } = result.error;
+    if (code !== "POLICY_REFUSED" || stage !== "policy") return err(asError(result.error));
+    if (violations === void 0 || violations.length === 0) return err(asError(result.error));
+    return ok({ refused: true, allowed: false, violations, policyMode: "enforce" });
+  }
+  const { policy, policyMode, wouldRefuse, effectiveTrustTier } = result.value;
+  if (policy?.scope !== "action") {
+    const why = policy === void 0 ? "the policy stage is disabled" : `scope was ${policy.scope}`;
+    return err(
+      new Error(
+        `Untrusted-input firewall did not evaluate policy for action ${options.action.type} (${why})`
+      )
+    );
+  }
+  if (effectiveTrustTier !== enforcedTier) {
+    return err(
+      new Error(
+        `Untrusted-input firewall enforced tier ${effectiveTrustTier} for action ${options.action.type} but tier ${enforcedTier} for the classification`
+      )
+    );
+  }
+  return ok({
+    refused: false,
+    allowed: policy.allowed,
+    requiresApproval: policy.requiresApproval,
+    violations: policy.violations,
+    effectiveTrustTier,
+    policyMode,
+    wouldRefuse
+  });
+}
+function processAndLog(input, options) {
   const result = getUntrustedInputFirewall().process(input, options);
   if (!result.ok) {
-    const { code, stage, message } = result.error;
     logger4.warn("Untrusted-input firewall rejected the input", {
       user: input.username,
       sourceType: input.type,
-      code,
-      stage
+      ...options.action !== void 0 ? { actionType: options.action.type } : {},
+      code: result.error.code,
+      stage: result.error.stage
     });
-    return err(new Error(`Untrusted-input firewall ${code} at stage ${stage}: ${message}`));
+    return result;
   }
   if (result.value.wouldRefuse) {
     const policy = result.value.policy;
     logger4.warn("Untrusted-input firewall would refuse under enforce (audit mode)", {
       user: input.username,
       sourceType: input.type,
+      ...options.action !== void 0 ? { actionType: options.action.type } : {},
       trustTier: result.value.effectiveTrustTier,
       scope: policy?.scope,
       rules: policy?.violations.filter((v) => v.severity === "block").map((v) => v.rule),
       unmeasured: policy?.unmeasured
     });
   }
-  return ok(result.value);
+  return result;
+}
+function asError({ code, stage, message }) {
+  return new Error(`Untrusted-input firewall ${code} at stage ${stage}: ${message}`);
+}
+function firewallInputFor(type, source) {
+  return {
+    type,
+    username: source.author,
+    authorAssociation: source.authorAssociation,
+    title: source.title,
+    body: source.body
+  };
 }
 
 // src/scm/url-parsers.ts
@@ -1991,6 +2045,23 @@ function buildActionDetails(action, policy, corrob) {
     ...action.type === "ProposeLabels" && { labels: action.labels }
   };
 }
+function validateActionsThroughFirewall(input, gate, actions, existingLabels) {
+  const labels = existingLabels !== void 0 ? { existingLabels } : {};
+  const proposed = [];
+  for (const action of actions) {
+    const decision = evaluateActionThroughFirewall(input, { ...gate, ...labels, action });
+    if (!decision.ok) return decision;
+    const corrobResult = validateCorroboration(action);
+    proposed.push({
+      type: action.type,
+      description: describeAction(action),
+      policyApproved: decision.value.allowed,
+      corroborated: corrobResult.satisfied,
+      details: buildActionDetails(action, decision.value, corrobResult)
+    });
+  }
+  return ok(proposed);
+}
 
 // src/dogfooding/issue-triage.ts
 var logger6 = createLogger({ component: "IssueTriage" });
@@ -2070,10 +2141,16 @@ var IssueTriage = class {
     const enforced = { ...trustResult, trustTier: gateDecision.enforcedTier };
     const actions = this.generateActions(safeTitle, safeBody, issueResult, enforced);
     const withEscalation = applySafetyActions(actions, gateDecision, reputation, issueResult);
-    const validatedActions = this.validateActions(withEscalation, gateDecision, existingLabels);
+    const validatedActions = validateActionsThroughFirewall(
+      firewallInputFor("issue", issueResult),
+      { ...this.firewallOptions(reputation), enforcedTier: gateDecision.enforcedTier },
+      withEscalation,
+      existingLabels
+    );
+    if (!validatedActions.ok) return validatedActions;
     const result = this.buildResult({
       issue: issueResult,
-      actions: validatedActions,
+      actions: validatedActions.value,
       trustResult,
       isAllowlisted: firewall.value.isAllowlisted,
       auditSink: firewall.value.auditSink,
@@ -2111,27 +2188,26 @@ var IssueTriage = class {
    * (#4992; originally Issue #828 — trust-classifier wiring).
    *
    * The access posture is passed per call so the firewall's Rule-of-Two check
-   * sees the same facts `validateActions` enforces on. No maintainer allowlist
-   * is passed: there is no source for one today (no config field, no env var),
-   * so none is consulted and `isAllowlisted` stays absent on the result rather
-   * than being recorded as `false`.
+   * sees the same facts the per-action runs enforce on. No maintainer
+   * allowlist is passed: there is no source for one today (no config field, no
+   * env var), so none is consulted and `isAllowlisted` stays absent on the
+   * result rather than being recorded as `false`.
    */
   classifyAuthor(issue, reputation) {
     return runUntrustedInputFirewall(
-      {
-        type: "issue",
-        username: issue.author,
-        authorAssociation: issue.authorAssociation,
-        title: issue.title,
-        body: issue.body
-      },
-      { context: this.accessContext(), reputation: { assessment: reputation } }
+      firewallInputFor("issue", issue),
+      this.firewallOptions(reputation)
     );
   }
+  /** The per-call facts every firewall run of this triage shares (#4992, #5383). */
+  firewallOptions(reputation) {
+    return { context: this.accessContext(), reputation: { assessment: reputation } };
+  }
   /**
    * The access posture this triage runs under — the two Rule-of-Two conjuncts
-   * that are about the agent rather than the input. Shared by the firewall
-   * (#4992) and `validateActions` so the two cannot disagree.
+   * that are about the agent rather than the input. Passed to every firewall
+   * run (#4992, #5383) so the classification and the per-action policy checks
+   * cannot disagree on it.
    */
   accessContext() {
     return {
@@ -2202,29 +2278,6 @@ var IssueTriage = class {
     }
     return actions;
   }
-  /**
-   * Validates all actions through policy gate and corroboration validator.
-   * This completes the #828 wiring by integrating corroboration-validator.
-   * (Source: Issue #828 — policy-gate + corroboration-validator wiring)
-   */
-  validateActions(actions, gateDecision, existingLabels) {
-    const context = {
-      inputTrustTier: gateDecision.enforcedTier,
-      ...this.accessContext(),
-      ...existingLabels !== void 0 ? { existingLabels } : {}
-    };
-    return actions.map((action) => {
-      const policyDecision = evaluatePolicy(action, context);
-      const corrobResult = validateCorroboration(action);
-      return {
-        type: action.type,
-        description: describeAction(action),
-        policyApproved: policyDecision.allowed,
-        corroborated: corrobResult.satisfied,
-        details: buildActionDetails(action, policyDecision, corrobResult)
-      };
-    });
-  }
   /**
    * Builds the final triage result.
    */
@@ -2386,6 +2439,8 @@ export {
   createGitHubAdapter,
   configureUntrustedInputFirewall,
   runUntrustedInputFirewall,
+  evaluateActionThroughFirewall,
+  firewallInputFor,
   parsePRUrl,
   GitHubReviewer,
   GitHubUserInfo,
@@ -2393,4 +2448,4 @@ export {
   IssueTriage,
   createIssueTriage
 };
-//# sourceMappingURL=chunk-5ZVGPKNO.js.map
+//# sourceMappingURL=chunk-AZI3WR3N.js.map