pi-advisor-flow 0.6.0 → 0.7.0

package/dist/index.js

@@ -8,6 +8,21 @@ var MAX_CONTEXT_MAX_CHARS = Number.MAX_SAFE_INTEGER;
 var DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES = DEFAULT_MAX_LINES;
 var DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES = DEFAULT_MAX_BYTES;
 var DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS = 20000;
+var DEFAULT_JEV_MODEL = "jev-latest";
+var DEFAULT_JEV_TIMEOUT_MS = 8000;
+var DEFAULT_JEV_DIGEST_MAX_CHARS = 4000;
+var DEFAULT_JEV_PRICE_PER_MTOK = 0.042;
+var DEFAULT_JEV_FILTER_SKIP_CONFIDENCE = 0.85;
+var DEFAULT_JEV_FILTER_NOUL_MARGIN = 0.35;
+var DEFAULT_JEV_FILTER_OVERRIDE_WINDOW = 10;
+var DEFAULT_JEV_TURN_GATE_EVERY_TURNS = 0;
+var DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD = 0.8;
+var DEFAULT_JEV_TRANSPORT = "auto";
+var JEV_TRANSPORTS = [
+  "auto",
+  "typesafe",
+  "openrouter"
+];
 var ADVISOR_TOOL_POLICIES = [
   "full",
   "summary",
@@ -41,6 +56,17 @@ var simpleModeRef = false;
 var alwaysOnRef = false;
 var advisorFailureModeRef = "block-session";
 var advisorHerdrIntegrationRef = true;
+var advisorJevFilterEnabledRef = false;
+var advisorJevFilterSkipConfidenceRef = DEFAULT_JEV_FILTER_SKIP_CONFIDENCE;
+var advisorJevFilterNoulMarginRef = DEFAULT_JEV_FILTER_NOUL_MARGIN;
+var advisorJevFilterOverrideWindowRef = DEFAULT_JEV_FILTER_OVERRIDE_WINDOW;
+var advisorJevModelRef = DEFAULT_JEV_MODEL;
+var advisorJevTimeoutMsRef = DEFAULT_JEV_TIMEOUT_MS;
+var advisorJevDigestMaxCharsRef = DEFAULT_JEV_DIGEST_MAX_CHARS;
+var advisorJevPricePerMtokRef = DEFAULT_JEV_PRICE_PER_MTOK;
+var advisorJevTransportRef = DEFAULT_JEV_TRANSPORT;
+var advisorJevTurnGateEveryTurnsRef = DEFAULT_JEV_TURN_GATE_EVERY_TURNS;
+var advisorJevTurnGateNoulThresholdRef = DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD;
 var advisorToolResultMaxLinesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES;
 var advisorToolResultMaxBytesRef = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES;
 var advisorRedactSecretsRef = false;
@@ -119,6 +145,39 @@ var setAdvisorFailureModeRef = (value) => {
 var setAdvisorHerdrIntegrationRef = (enabled) => {
   advisorHerdrIntegrationRef = enabled;
 };
+var setAdvisorJevFilterEnabledRef = (enabled) => {
+  advisorJevFilterEnabledRef = enabled;
+};
+var setAdvisorJevFilterSkipConfidenceRef = (value) => {
+  advisorJevFilterSkipConfidenceRef = value;
+};
+var setAdvisorJevFilterNoulMarginRef = (value) => {
+  advisorJevFilterNoulMarginRef = value;
+};
+var setAdvisorJevFilterOverrideWindowRef = (value) => {
+  advisorJevFilterOverrideWindowRef = value;
+};
+var setAdvisorJevModelRef = (model) => {
+  advisorJevModelRef = model?.trim() || DEFAULT_JEV_MODEL;
+};
+var setAdvisorJevTimeoutMsRef = (value) => {
+  advisorJevTimeoutMsRef = value;
+};
+var setAdvisorJevDigestMaxCharsRef = (value) => {
+  advisorJevDigestMaxCharsRef = value;
+};
+var setAdvisorJevPricePerMtokRef = (value) => {
+  advisorJevPricePerMtokRef = value;
+};
+var setAdvisorJevTransportRef = (value) => {
+  advisorJevTransportRef = value;
+};
+var setAdvisorJevTurnGateEveryTurnsRef = (value) => {
+  advisorJevTurnGateEveryTurnsRef = value;
+};
+var setAdvisorJevTurnGateNoulThresholdRef = (value) => {
+  advisorJevTurnGateNoulThresholdRef = value;
+};
 var setAdvisorToolResultMaxLinesRef = (value) => {
   advisorToolResultMaxLinesRef = value;
 };
@@ -169,6 +228,17 @@ var 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,
@@ -312,6 +382,12 @@ var isValidMaxCallsPerSession = (value) => nonNegativeSafeInteger(value);
 var isValidGateFailureMode = (value) => typeof value === "string" && GATE_FAILURE_MODES.includes(value);
 var isValidToolResultMaxLines = (value) => nonNegativeSafeInteger(value);
 var isValidToolResultMaxBytes = (value) => nonNegativeSafeInteger(value);
+var isValidJevTimeoutMs = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+var isValidJevDigestMaxChars = (value) => nonNegativeSafeInteger(value);
+var isValidJevPricePerMtok = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
+var isValidJevSkipConfidence = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0.5 && value <= 1;
+var isValidJevNoulMargin = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 0.5;
+var isValidJevTransport = (value) => typeof value === "string" && JEV_TRANSPORTS.includes(value);
 var CONFIG_SCHEMA = {
   advisor: {
     accepted: "a provider/model string",
@@ -381,6 +457,81 @@ var 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,
@@ -629,6 +780,17 @@ var 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);
@@ -676,6 +838,17 @@ var applyConfig = (config) => {
   applyOptionalConfig(config, "alwaysOn", setAlwaysOnRef);
   applyOptionalConfig(config, "gateFailureMode", setAdvisorFailureModeRef);
   applyOptionalConfig(config, "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", setAdvisorToolResultMaxLinesRef);
   applyOptionalConfig(config, "advisorToolResultMaxBytes", setAdvisorToolResultMaxBytesRef);
   applyOptionalConfig(config, "advisorRedactSecrets", setAdvisorRedactSecretsRef);
@@ -690,6 +863,7 @@ var applyConfig = (config) => {
 // src/config/storage.ts
 var currentConfigState = () => Object.fromEntries(SAVED_CONFIG_KEYS.map((key) => [key, CONFIG_SCHEMA[key].current()]));
 var sameConfigValue = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+var RESERVED_ADVISOR_JSON_KEYS = new Set(["typesafe_api_key"]);
 var readExistingConfig = (path) => {
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
@@ -751,7 +925,7 @@ var loadConfig = (_ctx) => {
   setPersistedModelRefs(configuredModelRef(globalConfig?.advisor), configuredModelRef(globalConfig?.executor));
   if (globalConfig) {
     applyConfig(globalConfig);
-    const unknownKeys = unknownConfigKeys(globalConfig);
+    const unknownKeys = unknownConfigKeys(globalConfig).filter((key) => !RESERVED_ADVISOR_JSON_KEYS.has(key));
     const warningIdentity = `${global}:${configIdentity(global)}`;
     if (unknownKeys.length > 0 && _ctx.hasUI && !warnedUnknownConfigIdentities.has(warningIdentity)) {
       _ctx.ui.notify(`Advisor configuration at ${global} contains unrecognized key(s) ${unknownKeys.map((key) => JSON.stringify(key)).join(", ")}. They were preserved but ignored; check for typos or upgrade pi-advisor.`, "warning");
@@ -2231,7 +2405,7 @@ var addAdvisorUsage = (totals, usage) => {
     totals.costCalls += 1;
   }
 };
-var formatTokens = (value) => {
+var formatTokenCount = (value) => {
   if (value < 1000) {
     return String(value);
   }
@@ -2246,6 +2420,7 @@ var formatTokens = (value) => {
   }
   return `${Math.round(value / 1e6)}M`;
 };
+var formatTokens = formatTokenCount;
 var formatCost = (value) => `$${value.toFixed(4)}`;
 var formatUsageFields = (usage) => {
   const tokens = [
@@ -3236,6 +3411,139 @@ var renderScoutDetails = (box, scout, expanded, theme) => {
   }
 };
 
+// src/jev/ledger.ts
+var freshJevUsage = () => ({
+  cost: 0,
+  inputTokens: 0,
+  outputTokens: 0
+});
+var freshJevLedger = () => ({
+  filter: {
+    allowed: 0,
+    failures: 0,
+    overrides: 0,
+    repeatSkipped: 0,
+    screened: 0,
+    skipped: 0
+  },
+  gate: { checks: 0, consultations: 0, failures: 0, usage: freshJevUsage() },
+  usage: freshJevUsage()
+});
+var addJevUsage = (totals, usage) => {
+  totals.cost += usage.cost;
+  totals.inputTokens += usage.inputTokens;
+  totals.outputTokens += usage.outputTokens;
+};
+
+class AdvisorJevLedgerState {
+  #ledger = freshJevLedger();
+  #lastSkip;
+  reset() {
+    this.#ledger = freshJevLedger();
+    this.#lastSkip = undefined;
+  }
+  get lastSkip() {
+    return this.#lastSkip;
+  }
+  recordFilterAllowed() {
+    this.#ledger.filter.allowed += 1;
+    this.#ledger.filter.screened += 1;
+  }
+  recordFilterSkipped(repeat, normalizedQuestion, turn) {
+    this.#ledger.filter.skipped += 1;
+    this.#ledger.filter.screened += 1;
+    if (repeat) {
+      this.#ledger.filter.repeatSkipped += 1;
+    }
+    this.#lastSkip = {
+      ...normalizedQuestion ? { normalizedQuestion } : {},
+      turn
+    };
+  }
+  recordFilterOverride() {
+    this.#ledger.filter.overrides += 1;
+  }
+  recordFilterFailure() {
+    this.#ledger.filter.failures += 1;
+  }
+  recordFilterUsage(usage) {
+    addJevUsage(this.#ledger.usage, usage);
+  }
+  recordGateCheck(usage) {
+    this.#ledger.gate.checks += 1;
+    if (usage) {
+      addJevUsage(this.#ledger.gate.usage, usage);
+    }
+  }
+  recordGateConsultation() {
+    this.#ledger.gate.consultations += 1;
+  }
+  recordGateFailure() {
+    this.#ledger.gate.failures += 1;
+  }
+  summaryLines(invocations) {
+    const lines = [];
+    const { filter, gate, usage } = this.#ledger;
+    const nonRepeatJevActivity = filter.allowed + (filter.skipped - filter.repeatSkipped) + filter.failures;
+    if (nonRepeatJevActivity === 0 && filter.repeatSkipped > 0) {
+      const parts = [
+        `${filter.repeatSkipped} repeat question${filter.repeatSkipped === 1 ? "" : "s"} skipped, earlier advice reattached`
+      ];
+      if (filter.overrides > 0) {
+        parts.push(`${filter.overrides} override${filter.overrides === 1 ? "" : "s"}`);
+      }
+      lines.push(`Consultation dedup: ${parts.join(", ")}`);
+      lines.push(this.#savingsLine(this.#markdownCosts(invocations), filter.skipped));
+    } else if (this.#filterActive()) {
+      lines.push(this.#filterLine(filter));
+      const jevTokens = usage.inputTokens + usage.outputTokens;
+      if (jevTokens > 0) {
+        lines.push(`Jev cost: ${this.#formatJevTokens(usage)} tokens · $${usage.cost.toFixed(4)} (input only; output free)`);
+      }
+      if (filter.skipped > 0) {
+        lines.push(this.#savingsLine(this.#markdownCosts(invocations), filter.skipped));
+      }
+    }
+    if (gate.checks > 0 || gate.consultations > 0) {
+      lines.push(this.#gateLine(gate, invocations));
+    }
+    return lines;
+  }
+  #filterActive() {
+    const { filter } = this.#ledger;
+    return filter.screened > 0 || filter.overrides > 0 || filter.failures > 0;
+  }
+  #savingsLine(markdownCosts, skipped) {
+    if (markdownCosts.length === 0) {
+      return "Estimated saving from skips: unavailable — no observed consultation cost this session";
+    }
+    const mean = markdownCosts.reduce((sum, cost) => sum + cost, 0) / markdownCosts.length;
+    return `Estimated saving from skips: ≤ $${(mean * skipped).toFixed(4)} — upper bound; assumes each skipped consultation would have cost this session's mean allowed-consultation cost ($${mean.toFixed(4)}), which the skipped calls would likely have undercut`;
+  }
+  #gateLine(gate, invocations) {
+    const consultationCosts = invocations.filter((item) => item.trigger === "turn-gate" && typeof item.cost === "number").map((item) => item.cost);
+    const gateSpend = consultationCosts.reduce((sum, cost) => sum + cost, 0);
+    return `Turn gate: ${gate.checks} check${gate.checks === 1 ? "" : "s"} (Jev ${this.#formatJevTokens(gate.usage)} · $${gate.usage.cost.toFixed(4)}), ${gate.consultations} consultation${gate.consultations === 1 ? "" : "s"} ($${gateSpend.toFixed(4)})`;
+  }
+  #formatJevTokens(usage) {
+    return `↑${formatTokenCount(usage.inputTokens + usage.outputTokens)}`;
+  }
+  #markdownCosts(invocations) {
+    return invocations.filter((item) => item.kind === "markdown" && typeof item.cost === "number").map((item) => item.cost);
+  }
+  #filterLine(filter) {
+    const head = `${filter.screened} screened (${filter.allowed} allowed, ${filter.skipped} skipped${filter.repeatSkipped > 0 ? ` [${filter.repeatSkipped} repeat]` : ""})`;
+    const parts = [head];
+    if (filter.overrides > 0) {
+      parts.push(`${filter.overrides} override${filter.overrides === 1 ? "" : "s"}`);
+    }
+    if (filter.failures > 0) {
+      parts.push(`${filter.failures} failure${filter.failures === 1 ? "" : "s"}`);
+    }
+    return `Jev filter: ${parts.join(", ")}`;
+  }
+}
+
 // src/session-state.ts
 var WHITESPACE = /\s/;
 var TIMESTAMP_KEYS = new Set([
@@ -3327,12 +3635,18 @@ class AdvisorSessionState {
   #ledger = freshAdviceLedger();
   #usage = freshUsage();
   #consumedCalls = 0;
+  #jev = new AdvisorJevLedgerState;
+  #sessionTurnOrdinal = 0;
+  #turnsSinceConsultation = 0;
   resetTask() {
     this.#repetition = freshRepetition();
     this.#blockedReason = undefined;
     this.#ledger = freshAdviceLedger();
     this.#usage = freshUsage();
     this.#consumedCalls = 0;
+    this.#jev.reset();
+    this.#sessionTurnOrdinal = 0;
+    this.#turnsSinceConsultation = 0;
   }
   clearBlocked() {
     this.#blockedReason = undefined;
@@ -3375,6 +3689,19 @@ class AdvisorSessionState {
   get consumedCalls() {
     return this.#consumedCalls;
   }
+  recordCompletedTurn() {
+    this.#sessionTurnOrdinal += 1;
+    this.#turnsSinceConsultation += 1;
+  }
+  resetTurnsSinceConsultation() {
+    this.#turnsSinceConsultation = 0;
+  }
+  get sessionTurnOrdinal() {
+    return this.#sessionTurnOrdinal;
+  }
+  get turnsSinceConsultation() {
+    return this.#turnsSinceConsultation;
+  }
   get usageTotals() {
     return { ...this.#usage.totals };
   }
@@ -3385,13 +3712,28 @@ class AdvisorSessionState {
     this.#usage.invocations.push(record);
     addAdvisorUsage(this.#usage.totals, record.usage);
   }
-  issueAdvice(id, advice, trigger, draft = false) {
-    this.#ledger.issued.set(id, { advice, trigger });
+  issueAdvice(id, advice, trigger, draft = false, normalizedQuestion) {
+    this.#ledger.issued.set(id, {
+      advice,
+      ...normalizedQuestion ? { normalizedQuestion } : {},
+      trigger
+    });
     this.#ledger.lastAdvice = advice;
     if (draft) {
       this.#ledger.draftConsultations += 1;
     }
   }
+  reattachedAdviceFor(normalizedQuestion) {
+    if (!normalizedQuestion) {
+      return;
+    }
+    for (const entry of this.#ledger.issued.values()) {
+      if (entry.normalizedQuestion === normalizedQuestion) {
+        return entry.advice;
+      }
+    }
+    return;
+  }
   claimTrackedFiles(paths) {
     const advice = this.#ledger.lastAdvice;
     if (!advice || paths.length === 0) {
@@ -3452,14 +3794,43 @@ class AdvisorSessionState {
     return [
       "manual",
       "executor-requested",
+      "turn-gate",
       "repeated-tool-call",
       "completion-review",
       "custom-rule"
     ].filter((trigger) => this.#countTrigger(trigger) > 0).join(", ") || "none";
   }
+  recordJevFilterAllowed() {
+    this.#jev.recordFilterAllowed();
+  }
+  recordJevFilterSkipped(repeat, normalizedQuestion) {
+    this.#jev.recordFilterSkipped(repeat, normalizedQuestion, this.#sessionTurnOrdinal);
+  }
+  get lastJevSkip() {
+    return this.#jev.lastSkip;
+  }
+  recordJevFilterOverride() {
+    this.#jev.recordFilterOverride();
+  }
+  recordJevFilterFailure() {
+    this.#jev.recordFilterFailure();
+  }
+  recordJevFilterUsage(usage) {
+    this.#jev.recordFilterUsage(usage);
+  }
+  recordJevGateCheck(usage) {
+    this.#jev.recordGateCheck(usage);
+  }
+  recordJevGateConsultation() {
+    this.#jev.recordGateConsultation();
+  }
+  recordJevGateFailure() {
+    this.#jev.recordGateFailure();
+  }
   summary(limit) {
     const { invocations, totals } = this.#usage;
-    if (invocations.length === 0 && this.#repetition.interventions === 0) {
+    const jevLines = this.#jev.summaryLines(invocations);
+    if (invocations.length === 0 && this.#repetition.interventions === 0 && jevLines.length === 0) {
       return;
     }
     const markdown = invocations.filter((item) => item.kind === "markdown");
@@ -3480,7 +3851,8 @@ class AdvisorSessionState {
       `Gate decisions: ${this.#decisionsLine()}`,
       `Loop matching: normalized tool signatures; ${this.#repetition.interventions} gate intervention${this.#repetition.interventions === 1 ? "" : "s"}`,
       `Execution effects: ${effects("tool-blocked")} tool blocked, ${effects("session-blocked")} sessions blocked, ${effects("continued")} continued`,
-      `Failures: ${failures.length ? failures.join(", ") : "none"}`
+      `Failures: ${failures.length ? failures.join(", ") : "none"}`,
+      ...jevLines
     ].join(`
 `);
   }
@@ -4040,138 +4412,770 @@ class ManualAdvisorDialog {
   }
 }
 
-// src/commands/manual-consultation.ts
-var startManualConsultation = (runtime, ctx, question, controller, scoutStatusToken, progress, gitContext) => {
-  herdrAdvisorActivity.start();
-  progress.phase = "preparing";
-  runtime.requestManualRender(ctx);
-  if (ctx.hasUI) {
-    const timer = setInterval(() => {
-      if (controller.signal.aborted || runtime.manualConsultations.get(controller) !== scoutStatusToken) {
-        clearInterval(timer);
-        return;
+// src/jev/client.ts
+class JevFailure extends Error {
+  category;
+  constructor(category, message) {
+    super(message);
+    this.name = "JevFailure";
+    this.category = category;
+  }
+}
+var ENDPOINTS = {
+  openrouter: "https://openrouter.ai/api/alpha/decisions",
+  typesafe: "https://api.typesafe.ai/v1/systemone"
+};
+var RETRYABLE_STATUSES = new Set([408, 429, ...range(500, 599)]);
+var RETRY_BACKOFF_MS = 250;
+var MAX_ATTEMPTS = 2;
+function range(from, to) {
+  return Array.from({ length: to - from + 1 }, (_, index) => from + index);
+}
+var finiteTokens = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+var errorDetail = (error) => {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return "";
+};
+var statusCategory = (status) => {
+  if (status === 401 || status === 403) {
+    return "auth";
+  }
+  if (status === 400 || status === 422) {
+    return "malformed";
+  }
+  return "error";
+};
+var openRouterModelId = (model) => model.includes("/") ? model : `~typesafe/${model}`;
+
+class JevClient {
+  #apiKey;
+  #endpoint;
+  #fetch;
+  #model;
+  #pricePerMtok;
+  #timeoutMs;
+  constructor({
+    apiKey,
+    fetch,
+    model,
+    pricePerMtok,
+    timeoutMs,
+    transport
+  }) {
+    this.#apiKey = apiKey;
+    this.#endpoint = ENDPOINTS[transport];
+    this.#fetch = fetch ?? globalThis.fetch.bind(globalThis);
+    this.#model = transport === "openrouter" ? openRouterModelId(model) : model;
+    this.#pricePerMtok = pricePerMtok;
+    this.#timeoutMs = timeoutMs;
+  }
+  async ask(state, questions, signal) {
+    const deadline = new AbortController;
+    const abortFromCaller = () => deadline.abort(signal?.reason);
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    if (signal?.aborted) {
+      abortFromCaller();
+    }
+    let deadlineHit = false;
+    const timer = setTimeout(() => {
+      deadlineHit = true;
+      deadline.abort(new Error("Jev wall-time budget elapsed"));
+    }, this.#timeoutMs);
+    timer.unref?.();
+    const body = JSON.stringify({
+      model: this.#model,
+      questions,
+      state
+    });
+    try {
+      let outcome = {};
+      for (let attempt = 1;; attempt += 1) {
+        outcome = await this.#attempt(body, deadline.signal);
+        if (!outcome.retryable || attempt >= MAX_ATTEMPTS) {
+          break;
+        }
+        await this.#backoff(deadline.signal);
+        if (deadline.signal.aborted) {
+          break;
+        }
       }
-      runtime.requestManualRender(ctx);
-    }, 80);
-    runtime.manualProgressTimers.set(controller, timer);
+      return this.#settle(outcome, deadlineHit, signal);
+    } catch (error) {
+      if (signal?.aborted && !deadlineHit) {
+        throw error;
+      }
+      if (error instanceof JevFailure) {
+        throw error;
+      }
+      const message = redactSecrets(error instanceof Error ? error.message : String(error));
+      throw deadlineHit ? new JevFailure("timeout", `Jev call exceeded its ${this.#timeoutMs} ms wall-time budget.`) : new JevFailure("error", message);
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abortFromCaller);
+    }
   }
-  let scoutDetails;
-  return runtime.requestAdvisor(ctx, question, controller.signal, (thinking, text) => {
-    if (controller.signal.aborted) {
-      return;
+  #settle(outcome, deadlineHit, signal) {
+    if (outcome.answers) {
+      return this.#result(outcome);
     }
-    progress.phase = "active";
-    progress.thinking = thinking;
-    progress.text = text;
-    runtime.requestManualRender(ctx);
-  }, (event) => {
-    if (!controller.signal.aborted) {
-      runtime.scoutStatus.update(ctx, scoutStatusToken, event);
-      scoutDetails = appendScoutLifecycleEntry(runtime.pi, event, scoutDetails);
-      progress.scout = scoutDetails;
-      progress.phase = "active";
-      runtime.requestManualRender(ctx);
+    if (deadlineHit && outcome.failure?.category !== "auth") {
+      throw new JevFailure("timeout", `Jev call exceeded its ${this.#timeoutMs} ms wall-time budget.`);
     }
-  }, gitContext).then(({ markdown, usage }) => {
-    if (controller.signal.aborted) {
-      return;
+    if (outcome.failure) {
+      throw outcome.failure;
     }
-    progress.phase = "complete";
-    runtime.advisorSessionState.recordInvocation({
-      cost: advisorUsageCost(usage),
-      executionEffect: "continued",
-      kind: "markdown",
-      model: advisorRef,
-      trigger: "manual",
-      usage
-    });
-    runtime.updateAdvisorUsageStatus(ctx);
-    const normalizedUsage = snapshotAdvisorUsage(usage);
-    runtime.pi.sendMessage({
-      content: `Manual Advisor consultation${question ? ` (${question})` : ""}:
-
-${markdown}`,
-      customType: "advisor-manual-result",
-      details: {
-        advisor: advisorRef,
-        question,
-        text: markdown,
-        ...normalizedUsage ? { usage: normalizedUsage } : {}
-      },
-      display: true
-    }, {
-      deliverAs: "steer",
-      triggerTurn: true
-    });
-  }).catch((error) => {
-    if (controller.signal.aborted) {
+    if (signal?.aborted) {
+      throw new Error("Jev call aborted by the caller.");
+    }
+    throw new JevFailure("error", "Jev call failed.");
+  }
+  async#backoff(signal) {
+    if (signal.aborted) {
       return;
     }
-    progress.phase = "error";
-    const message = error instanceof Error ? error.message : String(error);
-    runtime.advisorSessionState.recordInvocation({
-      executionEffect: "continued",
-      failure: "provider-error",
-      kind: "markdown",
-      model: advisorRef,
-      trigger: "manual"
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, RETRY_BACKOFF_MS);
+      timer.unref?.();
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
     });
-    runtime.updateAdvisorUsageStatus(ctx);
-    runtime.pi.sendMessage({
-      content: `Manual Advisor consultation failed: ${message}`,
-      customType: "advisor-manual-result",
-      details: {
-        advisor: advisorRef,
-        text: `**Advisor consultation failed:** ${message}`
-      },
-      display: true
-    }, { deliverAs: "steer", triggerTurn: true });
-    notify(ctx, `Advisor consultation failed: ${message}`, "error");
-    notifyHerdrAdvisorFailure("Advisor consultation failed", message);
-  }).finally(() => {
-    if (controller.signal.aborted) {
-      progress.phase = "cancelled";
-    }
-    const timer = runtime.manualProgressTimers.get(controller);
-    if (timer) {
-      clearInterval(timer);
-      runtime.manualProgressTimers.delete(controller);
+  }
+  async#attempt(body, signal) {
+    if (signal.aborted) {
+      return { retryable: false };
     }
-    runtime.requestManualRender(ctx);
-    runtime.scoutStatus.release(ctx, scoutStatusToken);
-    runtime.manualConsultations.delete(controller);
-    herdrAdvisorActivity.finish();
-  });
-};
-
-// src/commands/manual-command.ts
-var registerManualCommand = (runtime) => {
-  runtime.pi.registerCommand("advisor-manual", {
-    description: "Consult the Advisor in parallel; accepts an optional focused question and fans its response out to the Executor",
-    handler: async (args, ctx) => {
-      if (!loadCommandConfig(ctx)) {
-        return;
-      }
-      if (!(isSimpleMode() || runtime.advisorSessionState.canConsult(getAdvisorMaxCallsPerSession()))) {
-        runtime.reportManualBudgetExhausted(ctx);
-        return;
+    let response;
+    try {
+      response = await this.#fetch(this.#endpoint, {
+        body,
+        headers: {
+          authorization: `Bearer ${this.#apiKey}`,
+          "content-type": "application/json"
+        },
+        method: "POST",
+        signal
+      });
+    } catch (error) {
+      if (signal.aborted) {
+        return { retryable: false };
       }
-      let gitContext;
-      let question;
-      if (ctx.mode === "tui") {
-        const request = await ctx.ui.custom((tui, theme, keybindings, done) => new ManualAdvisorDialog({
-          gitContext: getAdvisorSettings().gitContext,
-          initialMessage: args,
-          keybindings,
-          onCancel: () => done(undefined),
-          onSubmit: done,
-          theme,
-          tui
-        }), {
-          overlay: true,
-          overlayOptions: {
-            anchor: "center",
-            margin: 2,
+      return {
+        retryable: true,
+        ...this.#connectionFailure(error)
+      };
+    }
+    if (response.ok) {
+      return this.#parseSuccess(response);
+    }
+    const failure = await this.#failureFromStatus(response);
+    return {
+      failure,
+      retryable: RETRYABLE_STATUSES.has(response.status)
+    };
+  }
+  #connectionFailure(error) {
+    const message = redactSecrets(error instanceof Error ? error.message : String(error));
+    return {
+      failure: new JevFailure("network", `Jev connection failed: ${message}`)
+    };
+  }
+  async#failureFromStatus(response) {
+    let detail = "";
+    try {
+      const parsed = await response.json();
+      const error = parsed?.error;
+      detail = errorDetail(error);
+    } catch {
+      detail = "";
+    }
+    const message = redactSecrets(`Jev ${this.#transportLabel()} request failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}.`);
+    return new JevFailure(statusCategory(response.status), message);
+  }
+  #transportLabel() {
+    return this.#endpoint === ENDPOINTS.openrouter ? "OpenRouter" : "TypeSafe";
+  }
+  async#parseSuccess(response) {
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch (error) {
+      return {
+        failure: new JevFailure("malformed", `Jev response was not JSON: ${redactSecrets(error instanceof Error ? error.message : String(error))}`)
+      };
+    }
+    const record = parsed;
+    if (!record || typeof record !== "object" || !record.answers || typeof record.answers !== "object") {
+      return {
+        failure: new JevFailure("malformed", "Jev response did not include an answers object.")
+      };
+    }
+    return {
+      answers: record.answers,
+      model: typeof record.model === "string" ? record.model : this.#model,
+      usage: record.usage
+    };
+  }
+  #result(outcome) {
+    const usage = outcome.usage;
+    const inputTokens = finiteTokens(usage?.input_tokens);
+    const outputTokens = finiteTokens(usage?.output_tokens);
+    const price = this.#pricePerMtok ?? advisorJevPricePerMtokRef;
+    return {
+      answers: outcome.answers ?? {},
+      model: outcome.model ?? this.#model,
+      usage: {
+        cost: inputTokens / 1e6 * price,
+        inputTokens,
+        outputTokens
+      }
+    };
+  }
+}
+var jevClientFromCredentials = (credentials, fetch) => new JevClient({
+  apiKey: credentials.apiKey,
+  fetch,
+  model: advisorJevModelRef,
+  timeoutMs: advisorJevTimeoutMsRef,
+  transport: credentials.transport
+});
+
+// src/jev/key-store.ts
+import {
+  chmodSync,
+  existsSync as existsSync3,
+  readFileSync as readFileSync3,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { join as join4 } from "node:path";
+import { getAgentDir as getAgentDir3 } from "@earendil-works/pi-coding-agent";
+var TYPESAFE_KEY_ENV_VAR = "TYPESAFE_API_KEY";
+var TYPESAFE_KEY_SERVICE = "pi-advisor";
+var TYPESAFE_KEY_NAME = "typesafe-api-key";
+var TYPESAFE_KEY_CONFIG_FIELD = "typesafe_api_key";
+var KEY_FILE_MODE = 384;
+var keyFilePath = () => join4(getAgentDir3(), "typesafe_api_key");
+var runtimeSecrets = () => globalThis.Bun?.secrets;
+var normalizeKey = (value) => value?.trim() || undefined;
+var readAdvisorJsonConfig = () => readExistingConfig(join4(getAgentDir3(), "advisor.json"));
+var defaultReadFileStore = () => {
+  try {
+    return normalizeKey(readFileSync3(keyFilePath(), "utf8"));
+  } catch {
+    return;
+  }
+};
+var defaultWriteFileStore = (key) => {
+  const path = keyFilePath();
+  writeFileSync2(path, `${key}
+`, { mode: KEY_FILE_MODE });
+  chmodSync(path, KEY_FILE_MODE);
+};
+var defaultDeleteFileStore = () => {
+  rmSync(keyFilePath(), { force: true });
+};
+var messageOf = (error) => redactSecrets(error instanceof Error ? error.message : String(error));
+var resolveTypeSafeKey = async (deps = {}) => {
+  const secrets = deps.secrets === undefined ? runtimeSecrets() : deps.secrets;
+  if (secrets) {
+    try {
+      const stored = normalizeKey(await secrets.get({
+        name: TYPESAFE_KEY_NAME,
+        service: TYPESAFE_KEY_SERVICE
+      }));
+      if (stored) {
+        return { key: stored, source: "bun-secrets" };
+      }
+    } catch {}
+  }
+  const env = deps.env ?? process.env;
+  const fromEnv = normalizeKey(env[TYPESAFE_KEY_ENV_VAR]);
+  if (fromEnv) {
+    return { key: fromEnv, source: "env" };
+  }
+  const readFileStore = deps.readFileStore ?? defaultReadFileStore;
+  const fromFile = normalizeKey(readFileStore());
+  if (fromFile) {
+    return { key: fromFile, source: "file" };
+  }
+  const config = (deps.readAdvisorJson ?? readAdvisorJsonConfig)();
+  const staged = config[TYPESAFE_KEY_CONFIG_FIELD];
+  if (typeof staged === "string") {
+    const fromConfig = normalizeKey(staged);
+    if (fromConfig) {
+      return { key: fromConfig, source: "advisor-json" };
+    }
+  }
+  return {};
+};
+var writeKeyTypeSafeKey = async (key, deps = {}) => {
+  const normalized = normalizeKey(key);
+  if (!normalized) {
+    return { message: "The key is empty.", ok: false };
+  }
+  const secrets = deps.secrets === undefined ? runtimeSecrets() : deps.secrets;
+  if (secrets) {
+    try {
+      await secrets.set({
+        name: TYPESAFE_KEY_NAME,
+        service: TYPESAFE_KEY_SERVICE,
+        value: normalized
+      });
+      return { message: "Key stored in Bun.secrets.", ok: true };
+    } catch (error) {
+      return {
+        message: `Storing the key in Bun.secrets failed: ${messageOf(error)}. Alternatively set the ${TYPESAFE_KEY_ENV_VAR} environment variable in your shell profile.`,
+        ok: false
+      };
+    }
+  }
+  try {
+    (deps.writeFileStore ?? defaultWriteFileStore)(normalized);
+    return {
+      message: "Key stored in ~/.pi/agent/typesafe_api_key (mode 0600).",
+      ok: true
+    };
+  } catch (error) {
+    return {
+      message: `Storing the key failed: ${messageOf(error)}. Alternatively set the ${TYPESAFE_KEY_ENV_VAR} environment variable in your shell profile.`,
+      ok: false
+    };
+  }
+};
+var clearKeyTypeSafeKey = async (deps = {}) => {
+  let clearedSomething = false;
+  let firstError;
+  const secrets = deps.secrets === undefined ? runtimeSecrets() : deps.secrets;
+  if (secrets) {
+    try {
+      await secrets.delete({
+        name: TYPESAFE_KEY_NAME,
+        service: TYPESAFE_KEY_SERVICE
+      });
+      clearedSomething = true;
+    } catch (error) {
+      firstError = messageOf(error);
+    }
+  }
+  try {
+    if (deps.deleteFileStore) {
+      deps.deleteFileStore();
+    } else if (existsSync3(keyFilePath())) {
+      defaultDeleteFileStore();
+    }
+    clearedSomething = true;
+  } catch (error) {
+    firstError ??= messageOf(error);
+  }
+  if (firstError) {
+    return {
+      message: `Clearing the stored key failed: ${firstError}.`,
+      ok: false
+    };
+  }
+  return {
+    message: `Stored key cleared.${clearedSomething ? "" : ` Nothing was stored; unset ${TYPESAFE_KEY_ENV_VAR} and remove ${TYPESAFE_KEY_CONFIG_FIELD} from advisor.json yourself if you use them.`}`,
+    ok: true
+  };
+};
+var removeTypeSafeKeyFromAdvisorJson = () => {
+  try {
+    const path = join4(getAgentDir3(), "advisor.json");
+    const existing = readExistingConfig(path);
+    if (!(TYPESAFE_KEY_CONFIG_FIELD in existing)) {
+      return { message: "No plaintext key in advisor.json.", ok: true };
+    }
+    delete existing[TYPESAFE_KEY_CONFIG_FIELD];
+    writeFileSync2(path, `${JSON.stringify(existing, null, 2)}
+`);
+    resetConfigCache();
+    return { message: "Plaintext key removed from advisor.json.", ok: true };
+  } catch (error) {
+    return {
+      message: `Removing the plaintext key failed: ${messageOf(error)}.`,
+      ok: false
+    };
+  }
+};
+var warnedPlaintextKey = false;
+var consumePlaintextKeyWarning = () => {
+  if (warnedPlaintextKey) {
+    return;
+  }
+  warnedPlaintextKey = true;
+  return `Advisor is using a plaintext ${TYPESAFE_KEY_CONFIG_FIELD} from advisor.json; this is not recommended. Open /advisor-settings → Jev consultation filter to migrate it into a secure store, or use the ${TYPESAFE_KEY_ENV_VAR} environment variable.`;
+};
+
+// src/jev/questions.ts
+var STAKES_RUBRIC = [
+  "Negligible: routine, low-risk, mechanical, or reversible; a wrong call costs little and is easy to undo.",
+  "Moderate: some risk or rework, but bounded and recoverable.",
+  "High: material consequences for correctness, security, cost, user trust, or irreversibility."
+];
+var EVIDENCE_RULE = "Judge from `executor_question` and `executor_draft` when present, otherwise from `recent_conversation`; when both are absent, `recent_conversation` is the evidence to judge from.";
+var screeningQuestions = {
+  self_answerable: {
+    criteria: {
+      false: "The executor needs the Advisor's second opinion.",
+      true: "The executor can resolve this alone with available tools and context."
+    },
+    instructions: `Can the executor confidently resolve this request alone, using available tools and context? ${EVIDENCE_RULE}`,
+    type: "noul"
+  },
+  stakes: {
+    criteria: [...STAKES_RUBRIC],
+    instructions: `How material are the stakes of the decision behind this consultation request? ${EVIDENCE_RULE}`,
+    type: "score"
+  }
+};
+var NUMERIC_KEY_PATTERN = /^\d+$/;
+var isRecord2 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var lowestStakesProbability = (answer) => {
+  if (!isRecord2(answer)) {
+    return;
+  }
+  const probabilities = isRecord2(answer.probabilities) ? answer.probabilities : {};
+  const legend = isRecord2(answer.legend) ? answer.legend : undefined;
+  if (legend) {
+    const exact = Object.keys(legend).find((key) => legend[key] === STAKES_RUBRIC[0]);
+    if (exact) {
+      return finiteNumber(probabilities[exact]);
+    }
+  }
+  const numericKeys = Object.keys(probabilities).filter((key) => NUMERIC_KEY_PATTERN.test(key));
+  if (numericKeys.length === 0) {
+    return;
+  }
+  const lowest = numericKeys.reduce((left, right) => Number(left) <= Number(right) ? left : right);
+  return finiteNumber(probabilities[lowest]);
+};
+var selfAnswerableNoul = (answer) => isRecord2(answer) ? finiteNumber(answer.noul) : undefined;
+var composeScreeningVerdict = (answers, { noulMargin, skipConfidence }) => {
+  if (!isRecord2(answers)) {
+    return { skip: false };
+  }
+  const negligibleMass = lowestStakesProbability(answers.stakes);
+  const noul = selfAnswerableNoul(answers.self_answerable);
+  if (negligibleMass === undefined || noul === undefined) {
+    return { skip: false };
+  }
+  const confidentlySelfAnswerable = noul >= 0.5 + noulMargin;
+  return {
+    skip: negligibleMass >= skipConfidence && confidentlySelfAnswerable
+  };
+};
+var composeTurnGateVerdict = (answers, threshold) => {
+  if (!isRecord2(answers)) {
+    return false;
+  }
+  const answer = answers.should_consult;
+  const noul = isRecord2(answer) ? finiteNumber(answer.noul) : undefined;
+  return noul !== undefined && noul >= threshold;
+};
+
+// src/jev/state.ts
+var JEV_TEXT_CAP_BYTES = 8 * 1024;
+var buildJevState = (ctx, input = {}) => {
+  const state = { role: "executor" };
+  if (input.question) {
+    state.executor_question = redactAndCapText(input.question, JEV_TEXT_CAP_BYTES, advisorRedactSecretsRef);
+  }
+  if (input.draft) {
+    state.executor_draft = redactAndCapText(input.draft, JEV_TEXT_CAP_BYTES, advisorRedactSecretsRef);
+  }
+  const digest = recentConversation(ctx, advisorJevDigestMaxCharsRef);
+  if (digest) {
+    state.recent_conversation = digest;
+  }
+  return state;
+};
+
+// src/jev/transport.ts
+var OPENROUTER_PROVIDER = "openrouter";
+var openRouterKey = async (ctx, deps) => {
+  const key = deps.getProviderKey ? await deps.getProviderKey(OPENROUTER_PROVIDER) : await ctx?.modelRegistry?.getApiKeyForProvider(OPENROUTER_PROVIDER);
+  return key?.trim() || undefined;
+};
+var resolveJevTransport = async (ctx, deps = {}) => {
+  const preference = advisorJevTransportRef;
+  if (preference !== "openrouter") {
+    const resolveTypesafe = deps.resolveTypesafe ?? resolveTypeSafeKey;
+    const resolution = await resolveTypesafe();
+    if (resolution.key) {
+      return {
+        apiKey: resolution.key,
+        ...resolution.source ? { source: resolution.source } : {},
+        transport: "typesafe"
+      };
+    }
+  }
+  if (preference === "typesafe") {
+    return;
+  }
+  const openrouter = await openRouterKey(ctx, deps);
+  return openrouter ? { apiKey: openrouter, transport: "openrouter" } : undefined;
+};
+
+// src/tools/outage-notifier.ts
+var createOutageNotifier = (format) => {
+  let lastKey;
+  return {
+    notify: (ctx, category, message) => {
+      const key = `${category}:${message}`;
+      if (key === lastKey) {
+        return;
+      }
+      lastKey = key;
+      if (ctx.hasUI) {
+        ctx.ui.notify(format(category, message), "warning");
+      }
+    },
+    reset: () => {
+      lastKey = undefined;
+    }
+  };
+};
+
+// src/tools/jev-filter.ts
+var normalizeScreeningQuestion = (question) => question?.trim().toLowerCase().replace(/\s+/g, " ") || undefined;
+var REATTACHED_ADVICE_CAP_BYTES = 4 * 1024;
+var SCREENED_SKIP_TEXT = "Advisor consultation skipped (screened out): the stakes are low and you can resolve this yourself with available tools and context. Proceed on your own judgment with what you already have.";
+var repeatSkipText = (advice) => `Advisor consultation skipped (already answered): this question was answered earlier in this session; the earlier advice is reattached below. Consult again only if the situation has materially changed.
+
+${advice}`;
+var outageNotifier = createOutageNotifier((category, message) => `Advisor Jev filter failed (${category}); allowing consultations. ${message}`);
+var notifyOutageOnce = outageNotifier.notify;
+var resetJevOutageNotification = outageNotifier.reset;
+var allow = () => ({ decision: "allow" });
+var screenConsultation = (ctx, session, options, deps = {}) => {
+  if (isSimpleMode()) {
+    return Promise.resolve(allow());
+  }
+  const normalizedQuestion = normalizeScreeningQuestion(options.question);
+  const bypass = bypassOutcome(session, options, normalizedQuestion);
+  if (bypass) {
+    return Promise.resolve(bypass);
+  }
+  const reattached = session.reattachedAdviceFor(normalizedQuestion);
+  if (reattached) {
+    session.recordJevFilterSkipped(true, normalizedQuestion);
+    return Promise.resolve({
+      decision: "skip",
+      kind: "repeat",
+      reason: "already answered earlier in this session",
+      reattachedAdvice: reattached.slice(0, REATTACHED_ADVICE_CAP_BYTES)
+    });
+  }
+  if (!advisorJevFilterEnabledRef) {
+    return Promise.resolve(allow());
+  }
+  return screenWithJev(ctx, session, options, deps, normalizedQuestion);
+};
+var bypassOutcome = (session, options, normalizedQuestion) => {
+  const lastSkip = session.lastJevSkip;
+  if (options.force) {
+    if (lastSkip?.normalizedQuestion !== undefined && lastSkip.normalizedQuestion === normalizedQuestion) {
+      session.recordJevFilterOverride();
+    }
+    return allow();
+  }
+  if (normalizedQuestion !== undefined && lastSkip?.normalizedQuestion === normalizedQuestion && session.sessionTurnOrdinal - lastSkip.turn <= advisorJevFilterOverrideWindowRef) {
+    session.recordJevFilterOverride();
+    return allow();
+  }
+  return;
+};
+var screenWithJev = async (ctx, session, options, deps, normalizedQuestion) => {
+  const credentials = await (deps.resolveTransport ?? resolveJevTransport)(ctx);
+  if (!credentials) {
+    session.recordJevFilterFailure();
+    notifyOutageOnce(ctx, "missing-key", "No Jev credentials resolved (no TypeSafe key and no OpenRouter login).");
+    return allow();
+  }
+  if (credentials.source === "advisor-json") {
+    const warning = consumePlaintextKeyWarning();
+    if (warning && ctx.hasUI) {
+      ctx.ui.notify(warning, "warning");
+    }
+  }
+  const client = jevClientFromCredentials(credentials, deps.fetch);
+  try {
+    const result = await client.ask(buildJevState(ctx, options), screeningQuestions, options.signal);
+    session.recordJevFilterUsage(result.usage);
+    const verdict = composeScreeningVerdict(result.answers, {
+      noulMargin: advisorJevFilterNoulMarginRef,
+      skipConfidence: advisorJevFilterSkipConfidenceRef
+    });
+    if (verdict.skip) {
+      session.recordJevFilterSkipped(false, normalizedQuestion);
+      return {
+        decision: "skip",
+        kind: "screened",
+        reason: "low stakes and resolvable without a consultation"
+      };
+    }
+    session.recordJevFilterAllowed();
+    return allow();
+  } catch (error) {
+    session.recordJevFilterFailure();
+    if (error instanceof JevFailure) {
+      notifyOutageOnce(ctx, error.category, error.message);
+    } else if (options.signal?.aborted) {
+      throw error;
+    } else {
+      notifyOutageOnce(ctx, "error", error instanceof Error ? error.message : String(error));
+    }
+    return allow();
+  }
+};
+var screeningSkipText = (outcome) => outcome.kind === "repeat" && outcome.reattachedAdvice ? repeatSkipText(outcome.reattachedAdvice) : SCREENED_SKIP_TEXT;
+
+// src/commands/manual-consultation.ts
+var startManualConsultation = (runtime, ctx, question, controller, scoutStatusToken, progress, gitContext) => {
+  herdrAdvisorActivity.start();
+  progress.phase = "preparing";
+  runtime.requestManualRender(ctx);
+  if (ctx.hasUI) {
+    const timer = setInterval(() => {
+      if (controller.signal.aborted || runtime.manualConsultations.get(controller) !== scoutStatusToken) {
+        clearInterval(timer);
+        return;
+      }
+      runtime.requestManualRender(ctx);
+    }, 80);
+    runtime.manualProgressTimers.set(controller, timer);
+  }
+  let scoutDetails;
+  return runtime.requestAdvisor(ctx, question, controller.signal, (thinking, text) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    progress.phase = "active";
+    progress.thinking = thinking;
+    progress.text = text;
+    runtime.requestManualRender(ctx);
+  }, (event) => {
+    if (!controller.signal.aborted) {
+      runtime.scoutStatus.update(ctx, scoutStatusToken, event);
+      scoutDetails = appendScoutLifecycleEntry(runtime.pi, event, scoutDetails);
+      progress.scout = scoutDetails;
+      progress.phase = "active";
+      runtime.requestManualRender(ctx);
+    }
+  }, gitContext).then(({ adviceId, markdown, usage }) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    progress.phase = "complete";
+    runtime.advisorSessionState.resetTurnsSinceConsultation();
+    runtime.advisorSessionState.recordInvocation({
+      cost: advisorUsageCost(usage),
+      executionEffect: "continued",
+      kind: "markdown",
+      model: advisorRef,
+      trigger: "manual",
+      usage
+    });
+    if (typeof adviceId === "string") {
+      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})` : ""} — for your awareness; no action or follow-up consultation is needed unless the user asks:
+
+${markdown}`,
+      customType: "advisor-manual-result",
+      details: {
+        advisor: advisorRef,
+        question,
+        text: markdown,
+        ...normalizedUsage ? { usage: normalizedUsage } : {}
+      },
+      display: true
+    }, {
+      deliverAs: "steer",
+      triggerTurn: true
+    });
+  }).catch((error) => {
+    if (controller.signal.aborted) {
+      return;
+    }
+    progress.phase = "error";
+    const message = error instanceof Error ? error.message : String(error);
+    runtime.advisorSessionState.resetTurnsSinceConsultation();
+    runtime.advisorSessionState.recordInvocation({
+      executionEffect: "continued",
+      failure: "provider-error",
+      kind: "markdown",
+      model: advisorRef,
+      trigger: "manual"
+    });
+    runtime.updateAdvisorUsageStatus(ctx);
+    runtime.pi.sendMessage({
+      content: `Manual Advisor consultation failed: ${message}`,
+      customType: "advisor-manual-result",
+      details: {
+        advisor: advisorRef,
+        text: `**Advisor consultation failed:** ${message}`
+      },
+      display: true
+    }, { deliverAs: "steer", triggerTurn: true });
+    notify(ctx, `Advisor consultation failed: ${message}`, "error");
+    notifyHerdrAdvisorFailure("Advisor consultation failed", message);
+  }).finally(() => {
+    if (controller.signal.aborted) {
+      progress.phase = "cancelled";
+    }
+    const timer = runtime.manualProgressTimers.get(controller);
+    if (timer) {
+      clearInterval(timer);
+      runtime.manualProgressTimers.delete(controller);
+    }
+    runtime.requestManualRender(ctx);
+    runtime.scoutStatus.release(ctx, scoutStatusToken);
+    runtime.manualConsultations.delete(controller);
+    herdrAdvisorActivity.finish();
+  });
+};
+
+// src/commands/manual-command.ts
+var registerManualCommand = (runtime) => {
+  runtime.pi.registerCommand("advisor-manual", {
+    description: "Consult the Advisor in parallel; accepts an optional focused question and fans its response out to the Executor",
+    handler: async (args, ctx) => {
+      if (!loadCommandConfig(ctx)) {
+        return;
+      }
+      if (!(isSimpleMode() || runtime.advisorSessionState.canConsult(getAdvisorMaxCallsPerSession()))) {
+        runtime.reportManualBudgetExhausted(ctx);
+        return;
+      }
+      let gitContext;
+      let question;
+      if (ctx.mode === "tui") {
+        const request = await ctx.ui.custom((tui, theme, keybindings, done) => new ManualAdvisorDialog({
+          gitContext: getAdvisorSettings().gitContext,
+          initialMessage: args,
+          keybindings,
+          onCancel: () => done(undefined),
+          onSubmit: done,
+          theme,
+          tui
+        }), {
+          overlay: true,
+          overlayOptions: {
+            anchor: "center",
+            margin: 2,
             maxHeight: "80%",
             minWidth: 56,
             width: 76
@@ -4334,7 +5338,7 @@ var registerCommandRenderers = (runtime) => {
 import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
 import {
   SettingsList,
-  truncateToWidth as truncateToWidth5
+  truncateToWidth as truncateToWidth7
 } from "@earendil-works/pi-tui";
 
 // src/ui/settings-formatting.ts
@@ -4415,14 +5419,367 @@ var rainbowGradient = (text, startedAt) => {
   }).join("").concat("\x1B[0m");
 };
 
-// src/ui/text-setting-submenu.ts
+// src/ui/jev-setup-submenu.ts
+import {
+  Key as Key2,
+  matchesKey as matchesKey2,
+  truncateToWidth as truncateToWidth5
+} from "@earendil-works/pi-tui";
+
+// node_modules/@typesafe-ai/sdk/dist/index.mjs
+var range2 = (from, to) => Array.from({ length: to - from }, (_, i) => from + i);
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  backoffInitialMs: 500,
+  backoffMaxMs: 5000,
+  backoffJitter: 0.25,
+  httpStatuses: /* @__PURE__ */ new Set([
+    408,
+    429,
+    ...range2(500, 600)
+  ]),
+  respectRetryAfter: true,
+  maxRetryAfterMs: 60000,
+  apiConnectionError: true,
+  apiTimeoutError: true
+};
+DEFAULT_RETRY_POLICY.maxRetries;
+var noul = (instructions = null, criteria) => ({
+  type: "noul",
+  instructions,
+  criteria
+});
+var g = globalThis;
+var isBrowser = () => typeof g.window !== "undefined" && typeof g.window.document !== "undefined" && typeof g.navigator !== "undefined";
+var describeRuntime = () => {
+  const platform = g.process?.platform && g.process?.arch ? ` (${g.process.platform}; ${g.process.arch})` : "";
+  if (g.Bun?.version)
+    return `bun/${g.Bun.version}${platform}`;
+  if (g.Deno?.version?.deno)
+    return `deno/${g.Deno.version.deno}${platform}`;
+  if (g.EdgeRuntime !== undefined)
+    return "vercel-edge";
+  if (g.navigator?.userAgent === "Cloudflare-Workers")
+    return "cloudflare-workers";
+  if (g.process?.versions?.node)
+    return `node/${g.process.versions.node}${platform}`;
+  if (isBrowser())
+    return "browser";
+  return "unknown";
+};
+var RUNTIME = describeRuntime();
+
+// src/ui/masked-input.ts
 import {
   Input as Input2,
   truncateToWidth as truncateToWidth4
 } from "@earendil-works/pi-tui";
 
+class MaskedInput {
+  input;
+  options;
+  _focused = true;
+  constructor(options = {}) {
+    this.options = options;
+    this.input = new Input2({ placeholder: options.placeholder });
+    this.input.focused = true;
+    this.input.onSubmit = (value) => options.onSubmit?.(value);
+    this.input.onEscape = () => options.onEscape?.();
+  }
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value;
+    this.input.focused = value;
+  }
+  getValue() {
+    return this.input.getValue();
+  }
+  setValue(value) {
+    this.input.setValue(value);
+  }
+  handleInput(keyData) {
+    this.input.handleInput(keyData);
+  }
+  invalidate() {
+    this.input.invalidate();
+  }
+  render(width) {
+    const value = this.input.getValue();
+    const { cursor } = this.input;
+    const masked = `${"•".repeat(Math.min(cursor, value.length))}█${"•".repeat(Math.max(0, value.length - cursor))}`;
+    const placeholder = value.length === 0 && this.options.placeholder ? this.options.placeholder : masked;
+    return [truncateToWidth4(placeholder, Math.max(1, width))];
+  }
+}
+
+// src/ui/jev-setup-submenu.ts
+var transportLabel = (credentials) => {
+  if (credentials.transport === "openrouter") {
+    return "OpenRouter (reusing pi login)";
+  }
+  switch (credentials.source) {
+    case "advisor-json":
+      return "TypeSafe (key: advisor.json — plaintext, not recommended)";
+    case "bun-secrets":
+      return "TypeSafe (key: Bun.secrets)";
+    case "file":
+      return "TypeSafe (key: stored file, mode 0600)";
+    default:
+      return "TypeSafe (key: TYPESAFE_API_KEY)";
+  }
+};
+var defaultVerify = async (credentials) => {
+  const client = jevClientFromCredentials(credentials);
+  try {
+    await client.ask({ purpose: "pi-advisor setup verification" }, { verified: noul("Answer yes.") });
+    return { ok: true };
+  } catch (error) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      ok: false
+    };
+  }
+};
+
+class JevSetupSubmenu {
+  options;
+  deps;
+  maskedInput;
+  credentials;
+  mode = "menu";
+  notice;
+  selectedIndex = 0;
+  _focused = true;
+  constructor(options, deps = {}) {
+    this.options = options;
+    this.deps = {
+      clearStoredKey: deps.clearStoredKey ?? clearKeyTypeSafeKey,
+      removePlaintextKey: deps.removePlaintextKey ?? removeTypeSafeKeyFromAdvisorJson,
+      resolveTransport: deps.resolveTransport ?? (() => resolveJevTransport()),
+      verify: deps.verify ?? defaultVerify,
+      writeKey: deps.writeKey ?? writeKeyTypeSafeKey
+    };
+    this.maskedInput = new MaskedInput({
+      onEscape: () => this.options.done(),
+      onSubmit: (value) => this.submitEnteredKey(value),
+      placeholder: "Paste a TypeSafe API key"
+    });
+    this.refresh().catch(() => {
+      return;
+    });
+  }
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value;
+    this.maskedInput.focused = value;
+  }
+  invalidate() {
+    this.maskedInput.invalidate();
+  }
+  handleInput(keyData) {
+    if (this.mode === "key-entry") {
+      this.maskedInput.handleInput(keyData);
+      this.options.tui.requestRender();
+      return;
+    }
+    if (this.mode !== "menu") {
+      return;
+    }
+    const actions = this.actions();
+    if (matchesKey2(keyData, Key2.down) || keyData === "\x1B[B" || keyData === "\x1BOB") {
+      this.selectedIndex = (this.selectedIndex + 1) % actions.length;
+    } else if (matchesKey2(keyData, Key2.up) || keyData === "\x1B[A" || keyData === "\x1BOA") {
+      this.selectedIndex = (this.selectedIndex - 1 + actions.length) % actions.length;
+    } else if (matchesKey2(keyData, Key2.enter) || keyData === "\r") {
+      this.activate(actions[this.selectedIndex]);
+    } else {
+      return;
+    }
+    this.options.tui.requestRender();
+  }
+  render(width) {
+    const { theme } = this.options;
+    const enabled = this.options.currentValue === "On";
+    const lines = [
+      theme.fg("accent", theme.bold("  Jev consultation filter")),
+      ""
+    ];
+    if (this.credentials) {
+      lines.push(`  Transport: ${transportLabel(this.credentials)}`);
+      lines.push(`  Filter: ${enabled ? "On" : "Off"}`);
+    } else if (this.mode === "verifying") {
+      lines.push("  Checking available Jev credentials…");
+    } else {
+      lines.push("  No Jev credentials found. Enter a TypeSafe API key below, or add");
+      lines.push("  an OpenRouter login in pi; it is reused automatically.");
+    }
+    if (this.notice) {
+      lines.push("");
+      lines.push(theme.fg("warning", `  ${this.notice}`));
+    }
+    lines.push("");
+    if (this.mode === "verifying") {
+      lines.push("  Verifying with a live Jev call…");
+    } else if (this.mode === "key-entry") {
+      lines.push(`  ${this.maskedInput.render(Math.max(10, width - 4))[0] ?? ""}`);
+      lines.push(theme.fg("dim", "  Enter: verify · Esc: cancel"));
+    } else {
+      for (const [index, label] of this.labels().entries()) {
+        const prefix = index === this.selectedIndex ? "→ " : "  ";
+        lines.push(`${prefix}${label}`);
+      }
+    }
+    return lines.map((line) => truncateToWidth5(line, width));
+  }
+  actions() {
+    if (!this.credentials) {
+      return ["enter-key", "done"];
+    }
+    const enabled = this.options.currentValue === "On";
+    const actions = [enabled ? "verify-again" : "verify-enable"];
+    actions.push("disable");
+    if (this.credentials.source === "bun-secrets" || this.credentials.source === "file") {
+      actions.push("disable-clear");
+    }
+    actions.push("done");
+    return actions;
+  }
+  actionLabels() {
+    return {
+      disable: "Disable",
+      "disable-clear": "Disable and clear stored key",
+      done: "Done",
+      "enter-key": "Enter a TypeSafe API key",
+      "verify-again": "Verify again",
+      "verify-enable": "Verify and enable"
+    };
+  }
+  labels() {
+    const labels = this.actionLabels();
+    return this.actions().map((action) => labels[action]);
+  }
+  async refresh() {
+    const wasVerifying = this.mode === "verifying";
+    this.mode = "verifying";
+    if (!wasVerifying) {
+      this.options.tui.requestRender();
+    }
+    this.credentials = await this.deps.resolveTransport?.();
+    this.mode = "menu";
+    this.selectedIndex = 0;
+    if (this.credentials?.source === "advisor-json") {
+      this.notice ??= consumePlaintextKeyWarning();
+    }
+    this.options.tui.requestRender();
+  }
+  activate(action) {
+    switch (action) {
+      case "done":
+        this.options.done();
+        return;
+      case "enter-key":
+        this.mode = "key-entry";
+        return;
+      case "disable":
+        this.notice = undefined;
+        this.options.done("Off");
+        return;
+      case "disable-clear":
+        this.disableAndClear().catch(() => {
+          return;
+        });
+        return;
+      case "verify-again":
+      case "verify-enable":
+        this.verifyAndEnable().catch(() => {
+          return;
+        });
+        return;
+      default:
+        return;
+    }
+  }
+  async disableAndClear() {
+    const clear = this.deps.clearStoredKey;
+    if (!clear) {
+      return;
+    }
+    const result = await clear();
+    this.credentials = undefined;
+    this.notice = result.message;
+    this.options.done("Off");
+  }
+  async verifyAndEnable() {
+    const { credentials } = this;
+    if (!(credentials && this.deps.verify)) {
+      return;
+    }
+    this.mode = "verifying";
+    this.notice = undefined;
+    this.options.tui.requestRender();
+    const outcome = await this.deps.verify(credentials);
+    this.mode = "menu";
+    if (!outcome.ok) {
+      this.notice = `Verification failed: ${outcome.message ?? "unknown error"}`;
+      this.options.tui.requestRender();
+      return;
+    }
+    if (credentials.transport === "typesafe" && credentials.source === "advisor-json") {
+      const stored = await this.deps.writeKey?.(credentials.apiKey);
+      if (!stored?.ok) {
+        this.notice = stored?.message ?? "Storing the key failed; the plaintext advisor.json key keeps working.";
+        this.options.tui.requestRender();
+        return;
+      }
+      const removed = this.deps.removePlaintextKey?.();
+      this.notice = removed?.ok ? "Key moved from advisor.json into the secure store." : `Stored securely, but ${removed?.message ?? "removing the plaintext copy failed; remove it yourself."}`;
+    }
+    this.options.done("On");
+  }
+  async submitEnteredKey(value) {
+    const key = value.trim();
+    if (!key) {
+      return;
+    }
+    if (!this.deps.verify) {
+      return;
+    }
+    this.mode = "verifying";
+    this.options.tui.requestRender();
+    const outcome = await this.deps.verify({
+      apiKey: key,
+      transport: "typesafe"
+    });
+    this.mode = "menu";
+    if (!outcome.ok) {
+      this.notice = `Verification failed: ${outcome.message ?? "unknown error"}`;
+      this.options.tui.requestRender();
+      return;
+    }
+    const stored = await this.deps.writeKey?.(key);
+    if (!stored?.ok) {
+      this.notice = stored?.message ?? "Storing the key failed.";
+      this.options.tui.requestRender();
+      return;
+    }
+    this.notice = `${stored.message} Verification succeeded.`;
+    await this.refresh();
+    this.options.done("On");
+  }
+}
+
+// src/ui/text-setting-submenu.ts
+import {
+  Input as Input3,
+  truncateToWidth as truncateToWidth6
+} from "@earendil-works/pi-tui";
+
 class TextSettingSubmenu {
-  input = new Input2;
+  input = new Input3;
   options;
   _focused = true;
   error;
@@ -4466,7 +5823,7 @@ class TextSettingSubmenu {
       lines.push(theme.fg("error", `  ${this.error}`));
     }
     lines.push("", theme.fg("dim", "  Enter: apply · Esc: cancel"));
-    return lines.map((line) => truncateToWidth4(line, width));
+    return lines.map((line) => truncateToWidth6(line, width));
   }
   handleInput(keyData) {
     const before = this.input.getValue();
@@ -4485,6 +5842,103 @@ var toggle = (id, label, description, value, defaultValue) => ({
   label,
   values: TOGGLE_VALUES
 });
+var jevItems = (settings, theme, tui) => [
+  {
+    currentValue: settingValue(settings.jevFilterEnabled, false),
+    description: "Screen low-stakes ask_advisor consultations with Jev; guided setup verifies credentials.",
+    id: "jevFilter",
+    label: "Jev consultation filter",
+    submenu: (currentValue, done) => new JevSetupSubmenu({ currentValue, done, theme, tui })
+  },
+  {
+    currentValue: String(settings.jevFilterSkipConfidence ?? DEFAULT_JEV_FILTER_SKIP_CONFIDENCE),
+    description: "Required probability on negligible stakes before a consultation is skipped.",
+    id: "jevFilterSkipConfidence",
+    label: "Jev skip confidence",
+    values: numericValues(settings.jevFilterSkipConfidence ?? DEFAULT_JEV_FILTER_SKIP_CONFIDENCE, [0.6, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95])
+  },
+  {
+    currentValue: String(settings.jevFilterNoulMargin ?? DEFAULT_JEV_FILTER_NOUL_MARGIN),
+    description: "Extra margin over a coin flip required on self-answerability before skipping.",
+    id: "jevFilterNoulMargin",
+    label: "Jev Noul margin",
+    values: numericValues(settings.jevFilterNoulMargin ?? DEFAULT_JEV_FILTER_NOUL_MARGIN, [0.1, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45])
+  },
+  {
+    currentValue: `${settings.jevFilterOverrideWindow ?? DEFAULT_JEV_FILTER_OVERRIDE_WINDOW} turns`,
+    description: "Turns after a skip during which the same question passes automatically.",
+    id: "jevFilterOverrideWindow",
+    label: "Jev override window",
+    values: numericValues(settings.jevFilterOverrideWindow ?? DEFAULT_JEV_FILTER_OVERRIDE_WINDOW, [0, 3, 5, 10, 20, 50]).map((value) => `${value} turns`)
+  },
+  {
+    currentValue: settings.jevModel ?? DEFAULT_JEV_MODEL,
+    description: "TypeSafe Jev model used for screening and turn-gate checks.",
+    id: "jevModel",
+    label: "Jev model",
+    submenu: (_currentValue, done) => new TextSettingSubmenu({
+      description: "Enter a TypeSafe model name (for example jev-latest or jev-1.13.0).",
+      initial: settings.jevModel ?? DEFAULT_JEV_MODEL,
+      onCancel: done,
+      onSubmit: (value) => ({ value: value.trim() || DEFAULT_JEV_MODEL }),
+      theme,
+      title: "Jev model",
+      tui
+    })
+  },
+  {
+    currentValue: String(settings.jevTimeoutMs ?? DEFAULT_JEV_TIMEOUT_MS),
+    description: "Total wall-time budget for one Jev call, including retries.",
+    id: "jevTimeoutMs",
+    label: "Jev timeout ms",
+    values: numericValues(settings.jevTimeoutMs ?? DEFAULT_JEV_TIMEOUT_MS, [1000, 2000, 5000, 8000, 15000, 30000])
+  },
+  {
+    currentValue: String(settings.jevDigestMaxChars ?? DEFAULT_JEV_DIGEST_MAX_CHARS),
+    description: "Conversation characters sent to Jev as screening evidence.",
+    id: "jevDigestMaxChars",
+    label: "Jev digest chars",
+    values: numericValues(settings.jevDigestMaxChars ?? DEFAULT_JEV_DIGEST_MAX_CHARS, [0, 1000, 2000, 4000, 8000, 15000])
+  },
+  {
+    currentValue: String(settings.jevPricePerMtok ?? DEFAULT_JEV_PRICE_PER_MTOK),
+    description: "Assumed TypeSafe price per million input tokens for cost lines.",
+    id: "jevPricePerMtok",
+    label: "Jev price/Mtok",
+    values: numericValues(settings.jevPricePerMtok ?? DEFAULT_JEV_PRICE_PER_MTOK, [0.01, 0.02, 0.042, 0.05, 0.1])
+  },
+  {
+    currentValue: settings.jevTurnGateEveryTurns === 0 || settings.jevTurnGateEveryTurns === undefined ? "Off" : `every ${settings.jevTurnGateEveryTurns} turns`,
+    description: "Proactively consult the Advisor every N turns without a consultation (0 = off).",
+    id: "jevTurnGateEveryTurns",
+    label: "Jev turn gate",
+    values: [
+      "Off",
+      "every 3 turns",
+      "every 5 turns",
+      "every 10 turns",
+      "every 20 turns"
+    ]
+  },
+  {
+    currentValue: String(settings.jevTurnGateNoulThreshold ?? DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD),
+    description: "Jev confidence required before the turn gate interrupts with advice.",
+    id: "jevTurnGateNoulThreshold",
+    label: "Jev turn-gate threshold",
+    values: numericValues(settings.jevTurnGateNoulThreshold ?? DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD, [0.6, 0.7, 0.8, 0.85, 0.9, 0.95])
+  },
+  {
+    currentValue: settings.jevTransport ?? DEFAULT_JEV_TRANSPORT,
+    description: "How Jev calls travel: auto reuses an OpenRouter login when no TypeSafe key is set.",
+    id: "jevTransport",
+    label: "Jev transport",
+    values: withCurrentValue(settings.jevTransport ?? DEFAULT_JEV_TRANSPORT, [
+      "auto",
+      "typesafe",
+      "openrouter"
+    ])
+  }
+];
 var createSettingsItems = ({
   effortLevels,
   presets,
@@ -4621,14 +6075,14 @@ var createSettingsItems = ({
       title: "Tool disclosure policies",
       tui
     })
-  }, toggle("trackedFileContent", "Tracked file content", "Allow tracked file contents to be sent with Advisor context.", settings.trackedFileContent, false), toggle("untrackedContent", "Untracked file content", "Allow untracked file contents to be sent with Advisor context.", settings.untrackedContent, false), toggle("outcomeLogging", "Outcome logging (global)", "Allow anonymized Advisor outcomes to be logged globally.", settings.outcomeLogging, false));
+  }, toggle("trackedFileContent", "Tracked file content", "Allow tracked file contents to be sent with Advisor context.", settings.trackedFileContent, false), toggle("untrackedContent", "Untracked file content", "Allow untracked file contents to be sent with Advisor context.", settings.untrackedContent, false), toggle("outcomeLogging", "Outcome logging (global)", "Allow anonymized Advisor outcomes to be logged globally.", settings.outcomeLogging, false), ...jevItems(settings, theme, tui));
   return items;
 };
 
 // src/ui/settings-list-adapter.ts
 import {
-  Key as Key2,
-  matchesKey as matchesKey2
+  Key as Key3,
+  matchesKey as matchesKey3
 } from "@earendil-works/pi-tui";
 
 class SettingsListAdapter {
@@ -4663,9 +6117,9 @@ class SettingsListAdapter {
   }
   changeWithArrow(keyData, onChange) {
     let direction = 0;
-    if (matchesKey2(keyData, Key2.left) || keyData === "\x1B[D") {
+    if (matchesKey3(keyData, Key3.left) || keyData === "\x1B[D") {
       direction = -1;
-    } else if (matchesKey2(keyData, Key2.right) || keyData === "\x1B[C") {
+    } else if (matchesKey3(keyData, Key3.right) || keyData === "\x1B[C") {
       direction = 1;
     }
     if (direction === 0) {
@@ -4758,6 +6212,39 @@ var mutateAdvisorSettings = (settings, id, value, presets) => {
     case "gitContextMaxChars":
       settings.gitContextMaxChars = Number(value);
       break;
+    case "jevFilter":
+      settings.jevFilterEnabled = value === "On";
+      break;
+    case "jevFilterSkipConfidence":
+      settings.jevFilterSkipConfidence = Number(value);
+      break;
+    case "jevFilterNoulMargin":
+      settings.jevFilterNoulMargin = Number(value);
+      break;
+    case "jevFilterOverrideWindow":
+      settings.jevFilterOverrideWindow = Number(value.replace(" turns", ""));
+      break;
+    case "jevTurnGateEveryTurns":
+      settings.jevTurnGateEveryTurns = value === "Off" ? 0 : Number(value.replace(/[^0-9]/g, ""));
+      break;
+    case "jevTurnGateNoulThreshold":
+      settings.jevTurnGateNoulThreshold = Number(value);
+      break;
+    case "jevModel":
+      settings.jevModel = value.trim() || DEFAULT_JEV_MODEL;
+      break;
+    case "jevTimeoutMs":
+      settings.jevTimeoutMs = Number(value);
+      break;
+    case "jevDigestMaxChars":
+      settings.jevDigestMaxChars = Number(value);
+      break;
+    case "jevPricePerMtok":
+      settings.jevPricePerMtok = Number(value);
+      break;
+    case "jevTransport":
+      settings.jevTransport = value;
+      break;
     default:
       if (BOOLEAN_SETTING_IDS.has(id)) {
         settings[id] = value === "On";
@@ -4807,7 +6294,7 @@ class AdvisorSettingsSelector {
   }
   render(width) {
     const border = this.options.theme.fg("border", "─".repeat(Math.max(1, width)));
-    return [border, ...this.settingsList.render(width), border].map((line) => truncateToWidth5(line, width));
+    return [border, ...this.settingsList.render(width), border].map((line) => truncateToWidth7(line, width));
   }
   handleInput(keyData) {
     if (!this.settingsList.changeWithArrow(keyData, (id, value) => this.change(id, value))) {
@@ -4894,6 +6381,17 @@ var applyAdvisorSettings = (settings) => {
   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);
@@ -4985,8 +6483,8 @@ import {
   unlink,
   writeFile
 } from "node:fs/promises";
-import { join as join4 } from "node:path";
-import { getAgentDir as getAgentDir3 } from "@earendil-works/pi-coding-agent";
+import { join as join5 } from "node:path";
+import { getAgentDir as getAgentDir4 } from "@earendil-works/pi-coding-agent";
 var ADOPTIONS = [
   "followed",
   "not-followed",
@@ -4999,11 +6497,11 @@ var VALIDATIONS = [
   "unknown"
 ];
 var MAX_LOG_BYTES = 1024 * 1024;
-var statePath = () => join4(getAgentDir3(), "advisor-outcomes-salt");
-var outcomeLogPath = () => join4(getAgentDir3(), "advisor-outcomes.jsonl");
+var statePath = () => join5(getAgentDir4(), "advisor-outcomes-salt");
+var outcomeLogPath = () => join5(getAgentDir4(), "advisor-outcomes.jsonl");
 var salt = async () => {
   const path = statePath();
-  await mkdir(getAgentDir3(), { mode: 448, recursive: true });
+  await mkdir(getAgentDir4(), { mode: 448, recursive: true });
   for (let attempt = 0;attempt < 20; attempt += 1) {
     try {
       const existing = await readFile(path);
@@ -5080,7 +6578,7 @@ var withOutcomeLock = async (run) => {
 var adviceDigest = (advice, key) => createHmac("sha256", key).update(advice).digest("hex").slice(0, 16);
 var appendOutcome = async (record) => {
   const path = outcomeLogPath();
-  await mkdir(getAgentDir3(), { mode: 448, recursive: true });
+  await mkdir(getAgentDir4(), { mode: 448, recursive: true });
   return withOutcomeLock(async () => {
     const next = {
       adoption: record.adoption,
@@ -5108,9 +6606,6 @@ var appendOutcome = async (record) => {
   });
 };
 
-// src/tools/register-ask-advisor.ts
-import { Type } from "typebox";
-
 // src/tools/gate-policy.ts
 var updateAdvisorUsageStatus = (ctx, session) => {
   if (ctx.hasUI) {
@@ -5184,6 +6679,99 @@ var reserveAdvisorCall = (event, ctx, session, reservedCalls) => {
   return {};
 };
 
+// src/tools/jev-turn-gate.ts
+var turnGateQuestion = {
+  criteria: {
+    false: "The executor is progressing soundly on work that matches the user's intent; interrupting would add nothing material.",
+    true: "The executor is approaching a material decision, repeating a failure, about to claim success without validation, or drifting from the user's intent; a second opinion now would change what happens next."
+  },
+  instructions: "Should a senior engineering advisor be consulted right now, before the executor continues? Judge from `recent_conversation`.",
+  type: "noul"
+};
+var outageNotifier2 = createOutageNotifier((category, message) => `Advisor Jev turn gate failed (${category}); continuing without a proactive consultation. ${message}`);
+var notifyFailureOnce = outageNotifier2.notify;
+var resetJevTurnGateNotification = outageNotifier2.reset;
+var handleJevTurnEnd = async (registration, ctx) => {
+  const { session } = registration;
+  session.recordCompletedTurn();
+  const interval = advisorJevTurnGateEveryTurnsRef;
+  if (interval <= 0 || session.turnsSinceConsultation <= 0 || session.turnsSinceConsultation % interval !== 0) {
+    return;
+  }
+  if (isSimpleMode() || session.blocked || !registration.activeTools().includes("ask_advisor") || !session.canConsult(getAdvisorMaxCallsPerSession())) {
+    return;
+  }
+  const consult = registration.deps?.consult ?? registration.consult;
+  const deps = registration.deps ?? {};
+  try {
+    const credentials = await (deps.resolveTransport ?? resolveJevTransport)(ctx);
+    if (!credentials) {
+      session.recordJevGateFailure();
+      notifyFailureOnce(ctx, "missing-key", "No Jev credentials resolved (no TypeSafe key and no OpenRouter login).");
+      return;
+    }
+    const client = jevClientFromCredentials(credentials, deps.fetch);
+    const result = await client.ask(buildJevState(ctx, {}), {
+      should_consult: turnGateQuestion
+    });
+    session.recordJevGateCheck(result.usage);
+    const shouldConsult = composeTurnGateVerdict(result.answers, advisorJevTurnGateNoulThresholdRef);
+    if (!shouldConsult) {
+      return;
+    }
+    session.consumeCall();
+    herdrAdvisorActivity.start();
+    registration.send({
+      content: "Proactive Advisor turn review",
+      customType: "advisor-turn-gate-call",
+      details: {
+        question: `Turn gate: ${session.turnsSinceConsultation} turns without a consultation`,
+        turn: session.sessionTurnOrdinal
+      },
+      display: true
+    });
+    try {
+      const consulted = await consult(ctx, undefined, ctx.signal, undefined, "turn-gate");
+      session.recordJevGateConsultation();
+      session.resetTurnsSinceConsultation();
+      session.recordInvocation({
+        cost: advisorUsageCost(consulted.usage),
+        executionEffect: "continued",
+        kind: "markdown",
+        model: consulted.model,
+        trigger: "turn-gate",
+        usage: consulted.usage
+      });
+      updateAdvisorUsageStatus(ctx, session);
+      registration.send({
+        content: consulted.markdown,
+        customType: "advisor-turn-gate-result",
+        details: {
+          advisor: consulted.model,
+          text: consulted.markdown,
+          usage: consulted.usage
+        },
+        display: true
+      });
+    } finally {
+      herdrAdvisorActivity.finish();
+    }
+  } catch (error) {
+    session.recordJevGateFailure();
+    if (error instanceof JevFailure) {
+      notifyFailureOnce(ctx, error.category, error.message);
+    } else if (!ctx.signal?.aborted) {
+      notifyFailureOnce(ctx, "error", error instanceof Error ? error.message : String(error));
+    }
+  }
+};
+var registerJevTurnGate = (on, registration) => {
+  on("turn_end", (_event, ctx) => handleJevTurnEnd(registration, ctx));
+};
+
+// src/tools/register-ask-advisor.ts
+import { Type } from "typebox";
+
 // src/tools/render-advisor-result.ts
 import {
   getMarkdownTheme as getMarkdownTheme4
@@ -5197,6 +6785,22 @@ var syncRenderPhase = (context, phase) => {
   }
   context.state.phase = phase;
 };
+var attachmentLabels = (details) => [
+  details?.draftBytes ? `Draft attached · ${details.draftBytes} B` : undefined,
+  details?.preferenceBytes ? `Project preferences attached · ${details.preferenceBytes} B` : undefined,
+  details?.trackedBytes ? `Tracked files attached · ${details.trackedBytes} B` : undefined,
+  details?.untrackedBytes ? `Untracked files attached · ${details.untrackedBytes} B` : undefined
+].filter((label) => label !== undefined);
+var renderJevSkipBox = (box, result, expanded, theme) => {
+  const details = advisorResultDetails(result);
+  const lines = [
+    theme.fg("dim", theme.bold("◆ ADVISOR · SKIPPED")),
+    theme.fg("dim", `  ${details?.jev?.reason ?? ""}`)
+  ];
+  box.addChild(new Text5(lines.join(`
+`), 0, 0));
+  box.addChild(new Markdown4(adviceForDisplay(textFrom(result.content), expanded), 0, 0, getMarkdownTheme4()));
+};
 var renderPartialAdvisorResult = (box, result, expanded, theme, context) => {
   const details = advisorResultDetails(result);
   if (details?.scout) {
@@ -5235,6 +6839,10 @@ var renderFinalAdvisorResult = (box, result, expanded, theme, context) => {
     context.state.timerId = undefined;
   }
   const details = advisorResultDetails(result);
+  if (details?.jev?.skipped) {
+    renderJevSkipBox(box, result, expanded, theme);
+    return;
+  }
   if (details?.scout) {
     context.state.scout = details.scout;
   }
@@ -5256,12 +6864,7 @@ var renderFinalAdvisorResult = (box, result, expanded, theme, context) => {
       lines.push(theme.fg("dim", `  Usage: ${usage}`));
     }
   }
-  const attachments = [
-    details?.draftBytes ? `Draft attached · ${details.draftBytes} B` : undefined,
-    details?.preferenceBytes ? `Project preferences attached · ${details.preferenceBytes} B` : undefined,
-    details?.trackedBytes ? `Tracked files attached · ${details.trackedBytes} B` : undefined,
-    details?.untrackedBytes ? `Untracked files attached · ${details.untrackedBytes} B` : undefined
-  ].filter(Boolean);
+  const attachments = attachmentLabels(details);
   if (attachments.length) {
     lines.push(theme.fg("dim", `  ${attachments.join(" · ")}`));
   }
@@ -5303,6 +6906,7 @@ var registerAskAdvisorTool = ({
   consult: requestAdvisor,
   pi,
   reservedCalls,
+  screen,
   session
 }) => {
   pi.registerTool({
@@ -5312,9 +6916,31 @@ var registerAskAdvisorTool = ({
       if (!(isSimpleMode() || session.canConsult(getAdvisorMaxCallsPerSession()))) {
         throw new Error("Advisor call budget exhausted for this session.");
       }
+      const normalizedQuestion = normalizeScreeningQuestion(resolveAdvisorRequest(params.question));
+      const screening = await screen(ctx, session, {
+        draft: params.draft,
+        force: params.force,
+        question: resolveAdvisorRequest(params.question),
+        signal
+      });
+      if (screening.decision === "skip") {
+        const skipText = screeningSkipText(screening);
+        return {
+          content: [{ text: skipText, type: "text" }],
+          details: {
+            jev: {
+              kind: screening.kind,
+              reason: screening.reason,
+              skipped: true
+            },
+            text: skipText
+          }
+        };
+      }
       claimTrackedHandoff(session, params.includeTrackedFiles);
       if (!isSimpleMode()) {
         session.consumeCall();
+        session.resetTurnsSinceConsultation();
       }
       herdrAdvisorActivity.start();
       let scoutDetails;
@@ -5347,7 +6973,7 @@ var registerAskAdvisorTool = ({
           });
         }, _id);
         flushUpdate();
-        session.issueAdvice(result.adviceId, result.markdown, result.trigger, Boolean(result.draftBytes));
+        session.issueAdvice(result.adviceId, result.markdown, result.trigger, Boolean(result.draftBytes), normalizedQuestion);
         session.recordInvocation({
           cost: advisorUsageCost(result.usage),
           executionEffect: "continued",
@@ -5408,6 +7034,9 @@ ${result.markdown}`,
       draft: Type.Optional(Type.String({
         description: "Concise untrusted draft for plan or completion review; claims are not verification evidence."
       })),
+      force: Type.Optional(Type.Boolean({
+        description: "Set true only when you judge a decision genuinely material after a consultation was screened out; bypasses screening."
+      })),
       gitContext: Type.Optional(Type.Union([Type.Literal("none"), Type.Literal("summary"), Type.Literal("full")], {
         description: "How much of the working tree to include. Use full when the review depends on the exact code changes, such as a completion review. Use summary for changed file names only, or none when the question is not about the current changes. The user's configured allowance is the ceiling and a larger request is narrowed to it."
       })),
@@ -5520,6 +7149,7 @@ var handleAutomaticGate = async (pi, event, ctx, session, runGate, scoutStatus)
     return failure.block ? { block: true, reason: failure.reason } : undefined;
   }
   session.consumeCall();
+  session.resetTurnsSinceConsultation();
   herdrAdvisorActivity.start();
   let scoutDetails;
   const scoutStatusToken = Symbol("automatic-gate-scout");
@@ -5719,6 +7349,30 @@ var registerToolRenderers = (pi) => {
     renderScoutDetails(box, scout, Boolean(expanded), theme);
     return box;
   });
+  pi.registerMessageRenderer?.("advisor-turn-gate-call", (message, _options, theme) => {
+    const details = message.details;
+    return renderAdvisorCallBox(details?.question, theme);
+  });
+  pi.registerMessageRenderer?.("advisor-turn-gate-result", (message, { expanded }, theme) => {
+    const details = message.details;
+    const box = new Box4(1, 1, (text) => theme.bg("customMessageBg", text));
+    box.addChild(new Text7(theme.fg("warning", theme.bold("◆ ADVISOR · TURN REVIEW")), 0, 0));
+    if (details?.advisor) {
+      box.addChild(new Text7(theme.fg("dim", `  ${details.advisor}`), 0, 0));
+    }
+    if (getAdvisorSettings().showUsageDetails) {
+      const usage = formatAdvisorUsage(details?.usage);
+      if (usage) {
+        box.addChild(new Text7(theme.fg("dim", `  Usage: ${usage}`), 0, 0));
+      }
+    }
+    if (details?.text) {
+      box.addChild(new Markdown5(adviceForDisplay(details.text, Boolean(expanded)), 0, 0, getMarkdownTheme5()));
+    } else {
+      box.addChild(new Text7(theme.fg("error", typeof message.content === "string" ? message.content : "Advisor turn review failed."), 0, 0));
+    }
+    return box;
+  });
   pi.registerMessageRenderer?.("advisor-loop-call", (message, _options, theme) => {
     const details = message.details;
     return renderAdvisorCallBox(details?.question, theme);
@@ -5754,12 +7408,20 @@ var registerAdvisorTool = (pi, session = advisorSessionState, dependencies = {})
     reservedCalls: new Set,
     runGate: dependencies.runGate ?? runAdvisorGate,
     scoutStatus: dependencies.statusManager ?? new ScoutStatusManager,
+    screen: dependencies.screen ?? screenConsultation,
     session
   };
   registerToolRenderers(pi);
   registerToolLifecycle(registration);
   registerAskAdvisorTool(registration);
   registerOutcomeTool(registration);
+  registerJevTurnGate((event, handler) => pi.on(event, handler), {
+    activeTools: () => pi.getActiveTools(),
+    consult: registration.consult,
+    ...dependencies.turnGateDeps ? { deps: dependencies.turnGateDeps } : {},
+    send: (message) => pi.sendMessage(message, { deliverAs: "steer" }),
+    session
+  });
 };
 
 // extensions/index.ts