nexus-agents 6.3.15 → 7.0.0

package/dist/{consensus-vote-A65EDXPT.js → consensus-vote-ZMEESJFP.js}

@@ -11,11 +11,11 @@ import {
   resetCorrelationTracker,
   runConsensusForGoal,
   unwrapVoteOrThrow
-} from "./chunk-TAC3HDZP.js";
+} from "./chunk-K3ZTZSLW.js";
 import "./chunk-JC4WREXA.js";
 import "./chunk-OQB3XC5O.js";
-import "./chunk-5NEA63UC.js";
-import "./chunk-5QUPQZJ7.js";
+import "./chunk-XF6J4PCH.js";
+import "./chunk-OXJEIMLS.js";
 import "./chunk-DR7DYEFQ.js";
 import "./chunk-KXQNETUB.js";
 import "./chunk-DXIZQRP5.js";
@@ -50,4 +50,4 @@ export {
   runConsensusForGoal,
   unwrapVoteOrThrow
 };
-//# sourceMappingURL=consensus-vote-A65EDXPT.js.map
+//# sourceMappingURL=consensus-vote-ZMEESJFP.js.map

package/dist/{improvement-review-JZTEJOWQ.js → improvement-review-PUEF3WL4.js}

@@ -11,9 +11,9 @@ import {
   loadSelfEvalSignals,
   registerImprovementReviewTool,
   runImprovementReview
-} from "./chunk-LCPMVQTQ.js";
-import "./chunk-5NEA63UC.js";
-import "./chunk-5QUPQZJ7.js";
+} from "./chunk-6SA3FIBZ.js";
+import "./chunk-XF6J4PCH.js";
+import "./chunk-OXJEIMLS.js";
 import "./chunk-DR7DYEFQ.js";
 import "./chunk-UOHOHH72.js";
 import "./chunk-GBHJ37V3.js";
@@ -33,4 +33,4 @@ export {
   registerImprovementReviewTool,
   runImprovementReview
 };
-//# sourceMappingURL=improvement-review-JZTEJOWQ.js.map
+//# sourceMappingURL=improvement-review-PUEF3WL4.js.map

package/dist/index.d.ts

@@ -18495,6 +18495,21 @@ interface PolicyDecision$2 {
     readonly reason: string;
     readonly requiredArtifact?: string;
     readonly ruleName?: string;
+    /**
+     * A rule denied this call and warn mode overrode the denial, so `allowed` is
+     * `true` but the operation WOULD have been blocked in enforce mode (#4991).
+     *
+     * Set explicitly by the evaluator rather than inferred downstream. The first
+     * implementation deduced it from `allowed === true && ruleName !== undefined`
+     * — true of today's code, because `allowWithReason` never sets `ruleName` —
+     * and a consensus panel rejected that: naming which rule *permitted* an
+     * action (`admin-override` vs `default-allow`) is ordinary access-control
+     * practice, so the day an allow rule sets `ruleName`, every authorized call
+     * it covers would be silently recorded as a near-miss. Deriving a verdict
+     * from the absence of an unrelated field is not a signal, it is a
+     * coincidence.
+     */
+    readonly overriddenByWarnMode?: boolean;
 }
 /**
  * Context provided to policy rules for evaluation.
@@ -19068,6 +19083,7 @@ declare const AuditEventSchema: z.ZodObject<{
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     policyName: z.ZodOptional<z.ZodString>;
     policyDecision: z.ZodOptional<z.ZodString>;
+    policyOccurrence: z.ZodOptional<z.ZodNumber>;
     violationType: z.ZodOptional<z.ZodString>;
     previousHash: z.ZodOptional<z.ZodString>;
     hash: z.ZodOptional<z.ZodString>;
@@ -19125,6 +19141,7 @@ declare const AuditEventInputSchema: z.ZodObject<{
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     policyName: z.ZodOptional<z.ZodString>;
     policyDecision: z.ZodOptional<z.ZodString>;
+    policyOccurrence: z.ZodOptional<z.ZodNumber>;
     violationType: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type AuditEventInput = z.infer<typeof AuditEventInputSchema>;
@@ -19157,13 +19174,13 @@ declare const AuditLogConfigSchema: z.ZodObject<{
 type AuditLogConfig = z.infer<typeof AuditLogConfigSchema>;
 interface IAuditStorage {
     /** Write an audit event to storage */
-    write(event: AuditEvent$1): Promise<void>;
+    write: (event: AuditEvent$1) => Promise<void>;
     /** Flush pending writes */
-    flush(): Promise<void>;
+    flush: () => Promise<void>;
     /** Close the storage */
-    close(): Promise<void>;
+    close: () => Promise<void>;
     /** Query events by criteria */
-    query(criteria: AuditQueryCriteria): Promise<AuditEvent$1[]>;
+    query: (criteria: AuditQueryCriteria) => Promise<AuditEvent$1[]>;
 }
 declare const AuditQueryCriteriaSchema: z.ZodObject<{
     startTime: z.ZodOptional<z.ZodDate>;
@@ -19198,23 +19215,59 @@ declare const AuditQueryCriteriaSchema: z.ZodObject<{
     offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, z.core.$strip>;
 type AuditQueryCriteria = z.infer<typeof AuditQueryCriteriaSchema>;
+/**
+ * Sink for audit records.
+ *
+ * **Every member is declared as a function PROPERTY, not a method, and that is
+ * load-bearing (#4991.)** TypeScript exempts method-shorthand parameters from
+ * `strictFunctionTypes` and checks them bivariantly. When
+ * {@link PolicyAuditDecision} gained `would_deny`, an out-of-tree implementor
+ * still typed against the old two-value union would have kept COMPILING and
+ * then received a value it cannot handle at runtime — silently dropping the
+ * audit record, or throwing inside the authorization path. A major version bump
+ * is a note in a changelog; a property signature is a compile error.
+ *
+ * EVERY member is converted, not just the one whose union widened. (Stated
+ * without a count on purpose: a literal here drifts the moment a member is
+ * added, which is the same doc-accuracy defect this file is fixing elsewhere.
+ * `audit-types-variance.test.ts` asserts the property, whatever the count.) An
+ * earlier revision converted only `logPolicyDecision`, on the reasoning that
+ * touching the others "would break implementors for no reason". That reasoning
+ * was wrong, and a panel caught it: an ES6 class using ordinary method syntax
+ * satisfies a property signature perfectly well, as does an object literal with
+ * method shorthand — the ONLY implementor a property signature rejects is one
+ * whose parameter is *narrower* than declared, which is exactly the unsound
+ * case. Converting one member and leaving six is the dangerous state: it looks
+ * consistent enough to imitate, and the next person to widen a parameter on any
+ * of the other six silently reopens the same hole.
+ *
+ * **Limit, stated because it is real:** contravariant checking requires
+ * `strictFunctionTypes` (implied by `strict`) in the CONSUMER's tsconfig. A
+ * downstream project compiling without it falls back to bivariance, compiles a
+ * stale implementor, and drops `would_deny` records at runtime. That flag is
+ * outside this package's control, so the guarantee here is "strict consumers
+ * get a compile error", not "no consumer can get this wrong".
+ *
+ * Pinned by `audit-types-variance.test.ts`, whose `@ts-expect-error` probe
+ * fails with TS2578 if any of these reverts to method shorthand.
+ */
 interface IAuditLogger {
     /** Log an audit event */
-    log(input: AuditEventInput): void;
+    log: (input: AuditEventInput) => void;
     /** Log a tool invocation */
-    logToolInvocation(opts: ToolInvocationAuditOpts): void;
-    /** Log a policy decision */
-    logPolicyDecision(opts: PolicyDecisionAuditOpts): void;
+    logToolInvocation: (opts: ToolInvocationAuditOpts) => void;
+    /** Log a policy decision. See the interface note on parameter variance. */
+    logPolicyDecision: (opts: PolicyDecisionAuditOpts) => void;
     /** Log a security event */
-    logSecurityEvent(opts: SecurityEventAuditOpts): void;
+    logSecurityEvent: (opts: SecurityEventAuditOpts) => void;
     /** Log a rate limit violation */
-    logRateLimitViolation(opts: RateLimitAuditOpts): void;
+    logRateLimitViolation: (opts: RateLimitAuditOpts) => void;
     /** Log an authority-tier transition (promotion/demotion) — Epic D, #3842. */
-    logTierTransition(opts: TierTransitionAuditOpts): void;
+    logTierTransition: (opts: TierTransitionAuditOpts) => void;
     /** Flush pending events */
-    flush(): Promise<void>;
+    flush: () => Promise<void>;
     /** Close the logger */
-    close(): Promise<void>;
+    close: () => Promise<void>;
 }
 interface ToolInvocationAuditOpts {
     toolName: string;
@@ -19224,15 +19277,49 @@ interface ToolInvocationAuditOpts {
     durationMs?: number | undefined;
     errorMessage?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
+    /**
+     * The policy verdict for this invocation, when a rule fired (#5228 review).
+     *
+     * Only `would_deny` reaches here: a real `deny` returns before the handler
+     * runs, so it produces no invocation record at all. Set on EVERY near-miss
+     * invocation, including those whose separate policy record was sampled out —
+     * otherwise an executed near-miss would be indistinguishable from a call no
+     * rule touched, which is the inference this change exists to break.
+     */
+    policyDecision?: PolicyAuditDecision | undefined;
 }
+/**
+ * The verdict a policy evaluation reached.
+ *
+ * `would_deny` (#4991) is warn mode: a rule fired, but the firewall allowed the
+ * call anyway. It is deliberately NOT `deny` — recording it as a denial would
+ * assert an enforcement that never happened — and NOT `allow`, which would
+ * erase the only signal the warn-mode soak produces. `#4988`'s enforce decision
+ * is read from these records, so the instrument has to be able to say
+ * "a rule would have stopped this" without lying in either direction.
+ *
+ * BREAKING for implementors of {@link IAuditLogger} (ratified 5/6, #4991):
+ * TypeScript's method-parameter bivariance means an out-of-tree implementor
+ * typed against the old two-value union still COMPILES and then receives
+ * `would_deny` at runtime, falling through whatever its `=== 'deny'` branch
+ * does. The major version bump is the only thing that makes those implementors
+ * look.
+ */
+type PolicyAuditDecision = 'allow' | 'deny' | 'would_deny';
 interface PolicyDecisionAuditOpts {
     policyName: string;
-    decision: 'allow' | 'deny';
+    decision: PolicyAuditDecision;
     reason: string;
     toolName: string;
     actor: AuditActor;
     requestId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
+    /**
+     * Which occurrence of this `{tool, rule}` near-miss this record represents
+     * (#5228 review). Set only for a sampled `would_deny`; absent means every
+     * occurrence was recorded.
+     */
+    occurrence?: number | undefined;
 }
 interface SecurityEventAuditOpts {
     eventType: string;

package/dist/index.js

@@ -553,7 +553,7 @@ import {
   withLogging,
   withRetry,
   withRetryWrapper
-} from "./chunk-BQNXEFYU.js";
+} from "./chunk-WMXHD6UA.js";
 import {
   FALLBACK_SCANNER_DATA,
   buildPlanFromAnalysis,
@@ -574,7 +574,7 @@ import {
   connectTransport,
   createServer,
   startStdioServer
-} from "./chunk-U4YGR5BI.js";
+} from "./chunk-46XUGUB4.js";
 import {
   OPENAI_MODELS,
   OPENAI_MODEL_ALIASES,
@@ -632,7 +632,7 @@ import {
   generateProposalId,
   parseAgentPairKey,
   registerConsensusVoteTool
-} from "./chunk-TAC3HDZP.js";
+} from "./chunk-K3ZTZSLW.js";
 import "./chunk-JC4WREXA.js";
 import {
   allOf
@@ -683,7 +683,7 @@ import {
 import {
   ImprovementReviewInputSchema,
   registerImprovementReviewTool
-} from "./chunk-LCPMVQTQ.js";
+} from "./chunk-6SA3FIBZ.js";
 import {
   AgentPerformanceSchema,
   ConsensusAlgorithmSchema,
@@ -719,10 +719,10 @@ import {
   toolSuccess,
   toolSuccessStructured,
   validateToolInput
-} from "./chunk-5NEA63UC.js";
+} from "./chunk-XF6J4PCH.js";
 import {
   VERSION
-} from "./chunk-5QUPQZJ7.js";
+} from "./chunk-OXJEIMLS.js";
 import {
   AuditTrail,
   MAX_STRIPPED_ELEMENTS_PER_EVENT,
@@ -4755,7 +4755,7 @@ function buildVotingInput(plan, config) {
 }
 async function executeSingleVote(plan, config, log) {
   try {
-    const { executeVoting } = await import("./consensus-vote-A65EDXPT.js");
+    const { executeVoting } = await import("./consensus-vote-ZMEESJFP.js");
     const input = buildVotingInput(plan, config);
     const result = await executeVoting(input, log);
     return parseVotingResult(result);

package/dist/{setup-data-dir-XRJNMTQV.js → setup-data-dir-3MPQZUHC.js}

@@ -2,11 +2,11 @@ import {
   NEXUS_DATA_DIR,
   describeDataDirFix,
   initDataDirectories
-} from "./chunk-U4YGR5BI.js";
+} from "./chunk-46XUGUB4.js";
 import "./chunk-CF5CXFYJ.js";
 import "./chunk-JC4WREXA.js";
 import "./chunk-OQB3XC5O.js";
-import "./chunk-5QUPQZJ7.js";
+import "./chunk-OXJEIMLS.js";
 import "./chunk-6T3EPABN.js";
 import "./chunk-KYCJ47JZ.js";
 import "./chunk-UAKFLKW3.js";
@@ -26,4 +26,4 @@ export {
   describeDataDirFix,
   initDataDirectories
 };
-//# sourceMappingURL=setup-data-dir-XRJNMTQV.js.map
+//# sourceMappingURL=setup-data-dir-3MPQZUHC.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-agents",
-  "version": "6.3.15",
+  "version": "7.0.0",
   "description": "Governance substrate for AI coding agents — adversarial PR review, drift-detected rules, tamper-evident audit, and closed-loop outcome routing for Claude, Codex, Gemini, and OpenCode",
   "mcpName": "io.github.nexus-substrate/nexus-agents",
   "license": "MIT",