pi-advisor-flow 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "pi-package",
@@ -8,7 +8,8 @@
     "pi-coding-agent",
     "advisor",
     "pi-advisor",
-    "herdr"
+    "herdr",
+    "jev"
   ],
   "homepage": "https://github.com/philipbrembeck/pi-advisor",
   "repository": {
@@ -62,18 +63,19 @@
     "undici": "8.9.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.12",
+    "@biomejs/biome": "2.5.13",
     "@earendil-works/pi-ai": "^0.85.1",
     "@earendil-works/pi-coding-agent": "^0.85.1",
     "@earendil-works/pi-tui": "^0.85.1",
-    "@types/node": "^26.4.1",
-    "bun-types": "1.4.1",
+    "@types/node": "^26.6.2",
+    "@typesafe-ai/sdk": "^0.6.0",
+    "bun-types": "1.4.2",
     "husky": "^9.1.7",
-    "knip": "^6.35.1",
-    "lint-staged": "^17.4.1",
-    "typebox": "^1.3.25",
+    "knip": "^6.37.0",
+    "lint-staged": "^17.5.1",
+    "typebox": "^1.3.34",
     "typescript": "^7.0.2",
-    "ultracite": "7.10.8"
+    "ultracite": "7.12.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.1 || ^0.85.1",

package/src/commands/manual-consultation.ts

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { advisorRef } from "../config/state.ts";
 import type { GitContextLevel } from "../git.ts";
 import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "../herdr.ts";
+import { normalizeScreeningQuestion } from "../tools/jev-filter.ts";
 import { appendScoutLifecycleEntry } from "../tools/scout-status.ts";
 import type { ScoutToolDetails } from "../tools/types.ts";
 import { advisorUsageCost, snapshotAdvisorUsage } from "../usage.ts";
@@ -63,11 +64,12 @@ export const startManualConsultation = (
       },
       gitContext
     )
-    .then(({ markdown, usage }) => {
+    .then(({ adviceId, markdown, usage }) => {
       if (controller.signal.aborted) {
         return;
       }
       progress.phase = "complete";
+      runtime.advisorSessionState.resetTurnsSinceConsultation();
       runtime.advisorSessionState.recordInvocation({
         cost: advisorUsageCost(usage),
         executionEffect: "continued",
@@ -76,11 +78,22 @@ export const startManualConsultation = (
         trigger: "manual",
         usage,
       });
+      if (typeof adviceId === "string") {
+        // Registering the manual question lets an identical later ask_advisor
+        // hit repeat detection instead of re-consulting.
+        runtime.advisorSessionState.issueAdvice(
+          adviceId,
+          markdown,
+          "manual",
+          false,
+          normalizeScreeningQuestion(question)
+        );
+      }
       runtime.updateAdvisorUsageStatus(ctx);
       const normalizedUsage = snapshotAdvisorUsage(usage);
       runtime.pi.sendMessage(
         {
-          content: `Manual Advisor consultation${question ? ` (${question})` : ""}:\n\n${markdown}`,
+          content: `Manual Advisor consultation${question ? ` (${question})` : ""} — for your awareness; no action or follow-up consultation is needed unless the user asks:\n\n${markdown}`,
           customType: "advisor-manual-result",
           details: {
             advisor: advisorRef,
@@ -104,6 +117,7 @@ export const startManualConsultation = (
       }
       progress.phase = "error";
       const message = error instanceof Error ? error.message : String(error);
+      runtime.advisorSessionState.resetTurnsSinceConsultation();
       runtime.advisorSessionState.recordInvocation({
         executionEffect: "continued",
         failure: "provider-error",

package/src/commands/settings-persistence.ts

@@ -12,6 +12,17 @@ import {
   setAdvisorGitContextMaxCharsRef,
   setAdvisorGitContextRef,
   setAdvisorHerdrIntegrationRef,
+  setAdvisorJevDigestMaxCharsRef,
+  setAdvisorJevFilterEnabledRef,
+  setAdvisorJevFilterNoulMarginRef,
+  setAdvisorJevFilterOverrideWindowRef,
+  setAdvisorJevFilterSkipConfidenceRef,
+  setAdvisorJevModelRef,
+  setAdvisorJevPricePerMtokRef,
+  setAdvisorJevTimeoutMsRef,
+  setAdvisorJevTransportRef,
+  setAdvisorJevTurnGateEveryTurnsRef,
+  setAdvisorJevTurnGateNoulThresholdRef,
   setAdvisorLoopThresholdRef,
   setAdvisorMaxCallsPerSessionRef,
   setAdvisorOutcomeLoggingRef,
@@ -31,6 +42,18 @@ import {
   setSimpleModeRef,
 } from "../config/state.ts";
 import { saveConfig, saveGlobalOutcomeLogging } from "../config/storage.ts";
+import {
+  DEFAULT_JEV_DIGEST_MAX_CHARS,
+  DEFAULT_JEV_FILTER_NOUL_MARGIN,
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW,
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE,
+  DEFAULT_JEV_MODEL,
+  DEFAULT_JEV_PRICE_PER_MTOK,
+  DEFAULT_JEV_TIMEOUT_MS,
+  DEFAULT_JEV_TRANSPORT,
+  DEFAULT_JEV_TURN_GATE_EVERY_TURNS,
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
+} from "../config/types.ts";
 import type { AdvisorSettings } from "../ui/types.ts";
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: one settings form maps every persisted control.
@@ -56,6 +79,31 @@ const applyAdvisorSettings = (settings: AdvisorSettings) => {
   setAlwaysOnRef(settings.alwaysOn ?? false);
   setAdvisorFailureModeRef(settings.failureMode ?? "block-session");
   setAdvisorHerdrIntegrationRef(settings.herdrIntegration ?? true);
+  setAdvisorJevFilterEnabledRef(settings.jevFilterEnabled ?? false);
+  setAdvisorJevFilterSkipConfidenceRef(
+    settings.jevFilterSkipConfidence ?? DEFAULT_JEV_FILTER_SKIP_CONFIDENCE
+  );
+  setAdvisorJevFilterNoulMarginRef(
+    settings.jevFilterNoulMargin ?? DEFAULT_JEV_FILTER_NOUL_MARGIN
+  );
+  setAdvisorJevFilterOverrideWindowRef(
+    settings.jevFilterOverrideWindow ?? DEFAULT_JEV_FILTER_OVERRIDE_WINDOW
+  );
+  setAdvisorJevModelRef(settings.jevModel ?? DEFAULT_JEV_MODEL);
+  setAdvisorJevTimeoutMsRef(settings.jevTimeoutMs ?? DEFAULT_JEV_TIMEOUT_MS);
+  setAdvisorJevDigestMaxCharsRef(
+    settings.jevDigestMaxChars ?? DEFAULT_JEV_DIGEST_MAX_CHARS
+  );
+  setAdvisorJevPricePerMtokRef(
+    settings.jevPricePerMtok ?? DEFAULT_JEV_PRICE_PER_MTOK
+  );
+  setAdvisorJevTransportRef(settings.jevTransport ?? DEFAULT_JEV_TRANSPORT);
+  setAdvisorJevTurnGateEveryTurnsRef(
+    settings.jevTurnGateEveryTurns ?? DEFAULT_JEV_TURN_GATE_EVERY_TURNS
+  );
+  setAdvisorJevTurnGateNoulThresholdRef(
+    settings.jevTurnGateNoulThreshold ?? DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD
+  );
   setAdvisorToolResultMaxLinesRef(settings.toolResultMaxLines ?? 2000);
   setAdvisorToolResultMaxBytesRef(settings.toolResultMaxBytes ?? 50 * 1024);
   setAdvisorRedactSecretsRef(settings.redactSecrets ?? false);

package/src/commands/types.ts

@@ -16,6 +16,7 @@ export type ManualConsult = (
   onScout?: (event: ScoutLifecycleEvent) => void,
   gitContext?: GitContextLevel
 ) => Promise<{
+  adviceId?: string;
   markdown: string;
   thinkingText: string;
   draftBytes?: number;

package/src/config/defaults.ts

@@ -10,6 +10,17 @@ import {
   setAdvisorGitContextMaxCharsRef,
   setAdvisorGitContextRef,
   setAdvisorHerdrIntegrationRef,
+  setAdvisorJevDigestMaxCharsRef,
+  setAdvisorJevFilterEnabledRef,
+  setAdvisorJevFilterNoulMarginRef,
+  setAdvisorJevFilterOverrideWindowRef,
+  setAdvisorJevFilterSkipConfidenceRef,
+  setAdvisorJevModelRef,
+  setAdvisorJevPricePerMtokRef,
+  setAdvisorJevTimeoutMsRef,
+  setAdvisorJevTransportRef,
+  setAdvisorJevTurnGateEveryTurnsRef,
+  setAdvisorJevTurnGateNoulThresholdRef,
   setAdvisorLoopThresholdRef,
   setAdvisorMaxCallsPerSessionRef,
   setAdvisorOutcomeLoggingRef,
@@ -38,6 +49,16 @@ import {
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES,
   DEFAULT_CONTEXT_MAX_CHARS,
+  DEFAULT_JEV_DIGEST_MAX_CHARS,
+  DEFAULT_JEV_FILTER_NOUL_MARGIN,
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW,
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE,
+  DEFAULT_JEV_MODEL,
+  DEFAULT_JEV_PRICE_PER_MTOK,
+  DEFAULT_JEV_TIMEOUT_MS,
+  DEFAULT_JEV_TRANSPORT,
+  DEFAULT_JEV_TURN_GATE_EVERY_TURNS,
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
 } from "./types.ts";
 
 export const resetDefaults = () => {
@@ -61,6 +82,17 @@ export const resetDefaults = () => {
   setAlwaysOnRef(false);
   setAdvisorFailureModeRef("block-session");
   setAdvisorHerdrIntegrationRef(true);
+  setAdvisorJevModelRef(DEFAULT_JEV_MODEL);
+  setAdvisorJevFilterEnabledRef(false);
+  setAdvisorJevFilterSkipConfidenceRef(DEFAULT_JEV_FILTER_SKIP_CONFIDENCE);
+  setAdvisorJevFilterNoulMarginRef(DEFAULT_JEV_FILTER_NOUL_MARGIN);
+  setAdvisorJevFilterOverrideWindowRef(DEFAULT_JEV_FILTER_OVERRIDE_WINDOW);
+  setAdvisorJevTimeoutMsRef(DEFAULT_JEV_TIMEOUT_MS);
+  setAdvisorJevDigestMaxCharsRef(DEFAULT_JEV_DIGEST_MAX_CHARS);
+  setAdvisorJevPricePerMtokRef(DEFAULT_JEV_PRICE_PER_MTOK);
+  setAdvisorJevTransportRef(DEFAULT_JEV_TRANSPORT);
+  setAdvisorJevTurnGateEveryTurnsRef(DEFAULT_JEV_TURN_GATE_EVERY_TURNS);
+  setAdvisorJevTurnGateNoulThresholdRef(DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD);
   setAdvisorToolResultMaxLinesRef(DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES);
   setAdvisorToolResultMaxBytesRef(DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES);
   setAdvisorRedactSecretsRef(false);
@@ -150,6 +182,49 @@ export const applyConfig = (config: AdvisorConfig) => {
     "advisorHerdrIntegration",
     setAdvisorHerdrIntegrationRef
   );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterEnabled",
+    setAdvisorJevFilterEnabledRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterSkipConfidence",
+    setAdvisorJevFilterSkipConfidenceRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterNoulMargin",
+    setAdvisorJevFilterNoulMarginRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevFilterOverrideWindow",
+    setAdvisorJevFilterOverrideWindowRef
+  );
+  applyNonEmptyStringConfig(config.advisorJevModel, setAdvisorJevModelRef);
+  applyOptionalConfig(config, "advisorJevTimeoutMs", setAdvisorJevTimeoutMsRef);
+  applyOptionalConfig(
+    config,
+    "advisorJevDigestMaxChars",
+    setAdvisorJevDigestMaxCharsRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevPricePerMtok",
+    setAdvisorJevPricePerMtokRef
+  );
+  applyOptionalConfig(config, "advisorJevTransport", setAdvisorJevTransportRef);
+  applyOptionalConfig(
+    config,
+    "advisorJevTurnGateEveryTurns",
+    setAdvisorJevTurnGateEveryTurnsRef
+  );
+  applyOptionalConfig(
+    config,
+    "advisorJevTurnGateNoulThreshold",
+    setAdvisorJevTurnGateNoulThresholdRef
+  );
   applyOptionalConfig(
     config,
     "advisorToolResultMaxLines",

package/src/config/schema.ts

@@ -11,6 +11,17 @@ import {
   advisorGitContextMaxCharsRef,
   advisorGitContextRef,
   advisorHerdrIntegrationRef,
+  advisorJevDigestMaxCharsRef,
+  advisorJevFilterEnabledRef,
+  advisorJevFilterNoulMarginRef,
+  advisorJevFilterOverrideWindowRef,
+  advisorJevFilterSkipConfidenceRef,
+  advisorJevModelRef,
+  advisorJevPricePerMtokRef,
+  advisorJevTimeoutMsRef,
+  advisorJevTransportRef,
+  advisorJevTurnGateEveryTurnsRef,
+  advisorJevTurnGateNoulThresholdRef,
   advisorLoopThresholdRef,
   advisorMaxCallsPerSessionRef,
   advisorOutcomeLoggingRef,
@@ -36,6 +47,8 @@ import {
   ADVISOR_TOOL_POLICIES,
   type AdvisorConfig,
   GATE_FAILURE_MODES,
+  JEV_TRANSPORTS,
+  type JevTransport,
   MAX_CONTEXT_MAX_CHARS,
 } from "./types.ts";
 
@@ -86,6 +99,30 @@ export const isValidToolResultMaxLines = (value: unknown): value is number =>
 export const isValidToolResultMaxBytes = (value: unknown): value is number =>
   nonNegativeSafeInteger(value);
 
+export const isValidJevTimeoutMs = (value: unknown): value is number =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+
+export const isValidJevDigestMaxChars = (value: unknown): value is number =>
+  nonNegativeSafeInteger(value);
+
+export const isValidJevPricePerMtok = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value) && value > 0;
+
+export const isValidJevSkipConfidence = (value: unknown): value is number =>
+  typeof value === "number" &&
+  Number.isFinite(value) &&
+  value >= 0.5 &&
+  value <= 1;
+
+export const isValidJevNoulMargin = (value: unknown): value is number =>
+  typeof value === "number" &&
+  Number.isFinite(value) &&
+  value >= 0 &&
+  value <= 0.5;
+
+export const isValidJevTransport = (value: unknown): value is JevTransport =>
+  typeof value === "string" && JEV_TRANSPORTS.includes(value as JevTransport);
+
 /** One declarative entry per AdvisorConfig key: JSON type, persistence, and
  * the live runtime value behind it. Validation and storage derive from this
  * table; adding a setting means adding exactly one entry here. */
@@ -171,6 +208,81 @@ export const CONFIG_SCHEMA = {
     persisted: true,
     type: "boolean",
   },
+  advisorJevDigestMaxChars: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorJevDigestMaxCharsRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevDigestMaxChars,
+  },
+  advisorJevFilterEnabled: {
+    accepted: "true or false",
+    current: () => advisorJevFilterEnabledRef,
+    persisted: true,
+    type: "boolean",
+  },
+  advisorJevFilterNoulMargin: {
+    accepted: "a number from 0 through 0.5",
+    current: () => advisorJevFilterNoulMarginRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevNoulMargin,
+  },
+  advisorJevFilterOverrideWindow: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorJevFilterOverrideWindowRef,
+    persisted: true,
+    type: "number",
+    validate: nonNegativeSafeInteger,
+  },
+  advisorJevFilterSkipConfidence: {
+    accepted: "a number between 0.5 and 1 inclusive",
+    current: () => advisorJevFilterSkipConfidenceRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevSkipConfidence,
+  },
+  advisorJevModel: {
+    accepted: "a non-empty string",
+    current: () => advisorJevModelRef,
+    persisted: true,
+    type: "string",
+  },
+  advisorJevPricePerMtok: {
+    accepted: "a positive number",
+    current: () => advisorJevPricePerMtokRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevPricePerMtok,
+  },
+  advisorJevTimeoutMs: {
+    accepted: "a positive safe integer",
+    current: () => advisorJevTimeoutMsRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevTimeoutMs,
+  },
+  advisorJevTransport: {
+    accepted: JEV_TRANSPORTS.join(", "),
+    current: () => advisorJevTransportRef,
+    persisted: true,
+    type: "enum",
+    validate: isValidJevTransport,
+  },
+  advisorJevTurnGateEveryTurns: {
+    accepted: "a non-negative safe integer (0 disables the turn gate)",
+    current: () => advisorJevTurnGateEveryTurnsRef,
+    persisted: true,
+    type: "number",
+    validate: nonNegativeSafeInteger,
+  },
+  advisorJevTurnGateNoulThreshold: {
+    accepted: "a number between 0.5 and 1 inclusive",
+    current: () => advisorJevTurnGateNoulThresholdRef,
+    persisted: true,
+    type: "number",
+    validate: isValidJevSkipConfidence,
+  },
   advisorLoopThreshold: {
     accepted: "a safe integer of at least 2",
     current: () => advisorLoopThresholdRef,

package/src/config/state.ts

@@ -5,7 +5,18 @@ import {
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES,
   DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES,
   DEFAULT_CONTEXT_MAX_CHARS,
+  DEFAULT_JEV_DIGEST_MAX_CHARS,
+  DEFAULT_JEV_FILTER_NOUL_MARGIN,
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW,
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE,
+  DEFAULT_JEV_MODEL,
+  DEFAULT_JEV_PRICE_PER_MTOK,
+  DEFAULT_JEV_TIMEOUT_MS,
+  DEFAULT_JEV_TRANSPORT,
+  DEFAULT_JEV_TURN_GATE_EVERY_TURNS,
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD,
   type GateFailureMode,
+  type JevTransport,
 } from "./types.ts";
 
 // An empty ref means no model has been selected yet.
@@ -30,6 +41,20 @@ export let simpleModeRef = false;
 export let alwaysOnRef = false;
 export let advisorFailureModeRef: GateFailureMode = "block-session";
 export let advisorHerdrIntegrationRef = true;
+export let advisorJevFilterEnabledRef = false;
+export let advisorJevFilterSkipConfidenceRef =
+  DEFAULT_JEV_FILTER_SKIP_CONFIDENCE;
+export let advisorJevFilterNoulMarginRef = DEFAULT_JEV_FILTER_NOUL_MARGIN;
+export let advisorJevFilterOverrideWindowRef =
+  DEFAULT_JEV_FILTER_OVERRIDE_WINDOW;
+export let advisorJevModelRef = DEFAULT_JEV_MODEL;
+export let advisorJevTimeoutMsRef = DEFAULT_JEV_TIMEOUT_MS;
+export let advisorJevDigestMaxCharsRef = DEFAULT_JEV_DIGEST_MAX_CHARS;
+export let advisorJevPricePerMtokRef = DEFAULT_JEV_PRICE_PER_MTOK;
+export let advisorJevTransportRef: JevTransport = DEFAULT_JEV_TRANSPORT;
+export let advisorJevTurnGateEveryTurnsRef = DEFAULT_JEV_TURN_GATE_EVERY_TURNS;
+export let advisorJevTurnGateNoulThresholdRef =
+  DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD;
 export let advisorToolResultMaxLinesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES;
 export let advisorToolResultMaxBytesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES;
 export let advisorRedactSecretsRef = false;
@@ -117,6 +142,39 @@ export const setAdvisorFailureModeRef = (value: GateFailureMode) => {
 export const setAdvisorHerdrIntegrationRef = (enabled: boolean) => {
   advisorHerdrIntegrationRef = enabled;
 };
+export const setAdvisorJevFilterEnabledRef = (enabled: boolean) => {
+  advisorJevFilterEnabledRef = enabled;
+};
+export const setAdvisorJevFilterSkipConfidenceRef = (value: number) => {
+  advisorJevFilterSkipConfidenceRef = value;
+};
+export const setAdvisorJevFilterNoulMarginRef = (value: number) => {
+  advisorJevFilterNoulMarginRef = value;
+};
+export const setAdvisorJevFilterOverrideWindowRef = (value: number) => {
+  advisorJevFilterOverrideWindowRef = value;
+};
+export const setAdvisorJevModelRef = (model: string | undefined) => {
+  advisorJevModelRef = model?.trim() || DEFAULT_JEV_MODEL;
+};
+export const setAdvisorJevTimeoutMsRef = (value: number) => {
+  advisorJevTimeoutMsRef = value;
+};
+export const setAdvisorJevDigestMaxCharsRef = (value: number) => {
+  advisorJevDigestMaxCharsRef = value;
+};
+export const setAdvisorJevPricePerMtokRef = (value: number) => {
+  advisorJevPricePerMtokRef = value;
+};
+export const setAdvisorJevTransportRef = (value: JevTransport) => {
+  advisorJevTransportRef = value;
+};
+export const setAdvisorJevTurnGateEveryTurnsRef = (value: number) => {
+  advisorJevTurnGateEveryTurnsRef = value;
+};
+export const setAdvisorJevTurnGateNoulThresholdRef = (value: number) => {
+  advisorJevTurnGateNoulThresholdRef = value;
+};
 export const setAdvisorToolResultMaxLinesRef = (value: number) => {
   advisorToolResultMaxLinesRef = value;
 };
@@ -172,6 +230,17 @@ export const getAdvisorSettings = () => ({
   gitContext: advisorGitContextRef,
   gitContextMaxChars: advisorGitContextMaxCharsRef,
   herdrIntegration: advisorHerdrIntegrationRef,
+  jevDigestMaxChars: advisorJevDigestMaxCharsRef,
+  jevFilterEnabled: advisorJevFilterEnabledRef,
+  jevFilterNoulMargin: advisorJevFilterNoulMarginRef,
+  jevFilterOverrideWindow: advisorJevFilterOverrideWindowRef,
+  jevFilterSkipConfidence: advisorJevFilterSkipConfidenceRef,
+  jevModel: advisorJevModelRef,
+  jevPricePerMtok: advisorJevPricePerMtokRef,
+  jevTimeoutMs: advisorJevTimeoutMsRef,
+  jevTransport: advisorJevTransportRef,
+  jevTurnGateEveryTurns: advisorJevTurnGateEveryTurnsRef,
+  jevTurnGateNoulThreshold: advisorJevTurnGateNoulThresholdRef,
   loopThreshold: advisorLoopThresholdRef,
   maxCallsPerSession: advisorMaxCallsPerSessionRef,
   outcomeLogging: advisorOutcomeLoggingRef,

package/src/config/storage.ts

@@ -36,7 +36,12 @@ const currentConfigState = (): ConfigState =>
 const sameConfigValue = <Value>(left: Value, right: Value) =>
   JSON.stringify(left) === JSON.stringify(right);
 
-const readExistingConfig = (path: string): Record<string, unknown> => {
+/** Keys advisor.json may hold that are not AdvisorConfig settings but are
+ * still legitimate (hand-placed secrets). They stay out of CONFIG_SCHEMA, are
+ * preserved like any unknown key, and never trigger the typo warning. */
+const RESERVED_ADVISOR_JSON_KEYS = new Set(["typesafe_api_key"]);
+
+export const readExistingConfig = (path: string): Record<string, unknown> => {
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed)
@@ -139,7 +144,7 @@ export const loadConfig = (_ctx: ExtensionContext) => {
     applyConfig(globalConfig);
     const unknownKeys = unknownConfigKeys(
       globalConfig as Record<string, unknown>
-    );
+    ).filter((key) => !RESERVED_ADVISOR_JSON_KEYS.has(key));
     const warningIdentity = `${global}:${configIdentity(global)}`;
     if (
       unknownKeys.length > 0 &&

package/src/config/types.ts

@@ -9,6 +9,24 @@ export const MAX_CONTEXT_MAX_CHARS = Number.MAX_SAFE_INTEGER;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES = DEFAULT_MAX_LINES;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES = DEFAULT_MAX_BYTES;
 export const DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS = 20_000;
+export const DEFAULT_JEV_MODEL = "jev-latest";
+// Provisional: the latency benchmark was dropped from scope; revisit if live
+// measurements suggest a different bound.
+export const DEFAULT_JEV_TIMEOUT_MS = 8000;
+export const DEFAULT_JEV_DIGEST_MAX_CHARS = 4000;
+export const DEFAULT_JEV_PRICE_PER_MTOK = 0.042;
+export const DEFAULT_JEV_FILTER_SKIP_CONFIDENCE = 0.85;
+export const DEFAULT_JEV_FILTER_NOUL_MARGIN = 0.35;
+export const DEFAULT_JEV_FILTER_OVERRIDE_WINDOW = 10;
+export const DEFAULT_JEV_TURN_GATE_EVERY_TURNS = 0;
+export const DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD = 0.8;
+export type JevTransport = "auto" | "typesafe" | "openrouter";
+export const DEFAULT_JEV_TRANSPORT: JevTransport = "auto";
+export const JEV_TRANSPORTS: JevTransport[] = [
+  "auto",
+  "typesafe",
+  "openrouter",
+];
 
 export type AdvisorToolPolicy = "full" | "summary" | "exclude";
 export type AdvisorToolPolicies = Record<string, AdvisorToolPolicy>;
@@ -40,6 +58,17 @@ export interface AdvisorConfig {
   advisorGitContext?: GitContextLevel;
   advisorGitContextMaxChars?: number;
   advisorHerdrIntegration?: boolean;
+  advisorJevDigestMaxChars?: number;
+  advisorJevFilterEnabled?: boolean;
+  advisorJevFilterNoulMargin?: number;
+  advisorJevFilterOverrideWindow?: number;
+  advisorJevFilterSkipConfidence?: number;
+  advisorJevModel?: string;
+  advisorJevPricePerMtok?: number;
+  advisorJevTimeoutMs?: number;
+  advisorJevTransport?: JevTransport;
+  advisorJevTurnGateEveryTurns?: number;
+  advisorJevTurnGateNoulThreshold?: number;
   advisorLoopThreshold?: number;
   advisorMaxCallsPerSession?: number;
   advisorOutcomeLogging?: boolean;