pi-advisor-flow 0.8.2 → 0.8.3-dev.2

package/extensions/index.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { registerCommands } from "../src/commands/registration.ts";
-import { setHerdrBlockedEmitter } from "../src/herdr.ts";
+import { getAdvisorSettings } from "../src/config/state.ts";
+import { HerdrAdvisorBlock, herdrAdvisorActivity } from "../src/herdr.ts";
 import { AdvisorSessionState } from "../src/session-state.ts";
 import {
   consultAdvisor as consultAdvisorImplementation,
@@ -34,13 +35,21 @@ export const runAdvisorGate = (
 export default function registerPiAdvisor(pi: ExtensionAPI) {
   const sessionState = new AdvisorSessionState();
   const scoutStatus = new ScoutStatusManager();
-  setHerdrBlockedEmitter((active, label) =>
-    pi.events.emit("herdr:blocked", { active, label })
+  const herdrActivity = herdrAdvisorActivity.createScope();
+  const herdrBlock = new HerdrAdvisorBlock(
+    undefined,
+    () => getAdvisorSettings().herdrIntegration,
+    (active, label) => {
+      pi.events.emit("herdr:blocked", { active, label });
+    }
   );
   registerAdvisorTool(pi, sessionState, {
+    herdrActivity,
+    herdrBlock,
     statusManager: scoutStatus,
   });
   registerCommands(pi, {
+    herdrActivity,
     sessionState,
     statusManager: scoutStatus,
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.8.2",
+  "version": "0.8.3-dev.2",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "advisor",
@@ -55,12 +55,12 @@
     "@earendil-works/pi-coding-agent": "0.87.1",
     "@earendil-works/pi-tui": "0.87.1",
     "@oxlint/plugins": "1.85.0",
-    "@types/node": "^26.6.2",
+    "@types/node": "^26.6.3",
     "@typesafe-ai/sdk": "^0.6.0",
     "bun-types": "1.4.2",
     "husky": "^9.1.7",
-    "knip": "^6.37.0",
-    "lint-staged": "^17.5.1",
+    "knip": "^6.38.0",
+    "lint-staged": "^17.6.0",
     "oxfmt": "0.70.0",
     "oxlint": "1.85.0",
     "typebox": "^1.3.34",

package/src/commands/lifecycle.ts

@@ -8,7 +8,6 @@ import {
   setExecutorRef,
 } from "../config/state.ts";
 import { loadConfig, saveConfig } from "../config/storage.ts";
-import { herdrAdvisorActivity } from "../herdr.ts";
 import { notify } from "./runtime.ts";
 import type { CommandRuntime } from "./types.ts";
 
@@ -84,6 +83,6 @@ export const registerCommandLifecycle = (
     runtime.manualConsultations.clear();
     runtime.manualProgressTimers.clear();
     runtime.manualProgress.clear();
-    herdrAdvisorActivity.clear();
+    runtime.herdrActivity.clear();
   });
 };

package/src/commands/manual-consultation.ts

@@ -3,7 +3,7 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { advisorRef } from "../config/state.ts";
 import { isString } from "../content-utils.ts";
 import type { GitContextLevel } from "../git.ts";
-import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "../herdr.ts";
+import { 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";
@@ -28,7 +28,6 @@ export const startManualConsultation = async (
   progress: ManualAdvisorProgressState,
   gitContext?: GitContextLevel
 ) => {
-  herdrAdvisorActivity.start();
   progress.phase = "preparing";
   runtime.requestManualRender(ctx);
   if (ctx.hasUI) {
@@ -44,6 +43,7 @@ export const startManualConsultation = async (
     }, 80);
     runtime.manualProgressTimers.set(controller, timer);
   }
+  const finishHerdrActivity = runtime.herdrActivity.start();
   let scoutDetails: ScoutToolDetails | undefined;
   try {
     const { adviceId, markdown, usage } = await runtime.requestAdvisor(
@@ -152,6 +152,7 @@ export const startManualConsultation = async (
     notify(ctx, `Advisor consultation failed: ${message}`, "error");
     notifyHerdrAdvisorFailure("Advisor consultation failed", message);
   } finally {
+    finishHerdrActivity();
     if (controller.signal.aborted) {
       progress.phase = "cancelled";
     }
@@ -163,6 +164,5 @@ export const startManualConsultation = async (
     runtime.requestManualRender(ctx);
     runtime.scoutStatus.release(ctx, scoutStatusToken);
     runtime.manualConsultations.delete(controller);
-    herdrAdvisorActivity.finish();
   }
 };

package/src/commands/runtime.ts

@@ -4,7 +4,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 
 import { getAdvisorSettings } from "../config/state.ts";
-import { notifyHerdrAdvisorFailure } from "../herdr.ts";
+import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "../herdr.ts";
 import type { AdvisorSessionState } from "../session-state.ts";
 import { consultAdvisor } from "../tools/consultation.ts";
 import { ScoutStatusManager } from "../tools/scout-status.ts";
@@ -40,6 +40,7 @@ const requestManualRender = (ctx: ExtensionContext) => {
 
 class CommandRuntime implements CommandRuntimeContract {
   readonly advisorSessionState: AdvisorSessionState;
+  readonly herdrActivity: NonNullable<CommandDependencies["herdrActivity"]>;
   readonly manualConsultations = new Map<AbortController, symbol>();
   readonly manualProgress = new Map<string, ManualAdvisorProgressState>();
   readonly manualProgressTimers = new Map<
@@ -59,6 +60,7 @@ class CommandRuntime implements CommandRuntimeContract {
     this.pi = pi;
     this.advisorSessionState =
       dependencies.sessionState ?? defaultAdvisorSessionState;
+    this.herdrActivity = dependencies.herdrActivity ?? herdrAdvisorActivity;
     this.scoutStatus =
       dependencies.statusManager ?? new ScoutStatusManager(false);
     this.requestAdvisor =

package/src/commands/types.ts

@@ -4,6 +4,7 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 
 import type { GitContextLevel } from "../git.ts";
+import type { HerdrAdvisorActivityScope } from "../herdr.ts";
 import type { ScoutLifecycleEvent } from "../scout.ts";
 import type { AdvisorSessionState } from "../session-state.ts";
 import type { ScoutStatusManager } from "../tools/scout-status.ts";
@@ -43,12 +44,14 @@ export interface ManualAdvisorProgressState {
 
 export interface CommandDependencies {
   consult?: ManualConsult;
+  herdrActivity?: HerdrAdvisorActivityScope;
   sessionState?: AdvisorSessionState;
   statusManager?: ScoutStatusManager;
 }
 
 export interface CommandRuntime {
   readonly advisorSessionState: AdvisorSessionState;
+  readonly herdrActivity: HerdrAdvisorActivityScope;
   flowEnabled: () => boolean;
   readonly manualConsultations: Map<AbortController, symbol>;
   readonly manualProgress: Map<string, ManualAdvisorProgressState>;

package/src/herdr-block.ts

@@ -10,13 +10,16 @@ import {
 
 export class HerdrAdvisorBlock {
   #blocked = false;
+  private readonly emitBlocked: (active: boolean, label: string) => void;
   private readonly report: Report;
   private readonly enabled: () => boolean;
 
   constructor(
     report: Report = sendToHerdr,
-    enabled: () => boolean = () => true
+    enabled: () => boolean = () => true,
+    emitBlocked: (active: boolean, label: string) => void = safeEmitBlocked
   ) {
+    this.emitBlocked = emitBlocked;
     this.report = report;
     this.enabled = enabled;
   }
@@ -29,7 +32,7 @@ export class HerdrAdvisorBlock {
     const wasBlocked: boolean = this.#blocked;
     if (!wasBlocked) {
       // The listener refcounts, so only the false → true edge may emit.
-      safeEmitBlocked(true, label);
+      this.safeEmitBlocked(true, label);
     }
     this.#blocked = true;
     this.safeReport({ blocked: label });
@@ -43,7 +46,7 @@ export class HerdrAdvisorBlock {
     }
     // Clearing previously reported state is a de-escalation and must still be
     // delivered if integration was disabled after the block was reported.
-    safeEmitBlocked(false);
+    this.safeEmitBlocked(false, "Advisor blocked");
     try {
       this.report({
         id: `${BLOCK_SOURCE}:${nextSequence()}`,
@@ -62,6 +65,15 @@ export class HerdrAdvisorBlock {
     }
   }
 
+  private safeEmitBlocked(active: boolean, label: string): boolean {
+    try {
+      this.emitBlocked(active, label);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   private safeReport(labels: { blocked: string }) {
     try {
       this.report({

package/src/herdr.ts

@@ -32,8 +32,15 @@ const metadataRequest = (clear: boolean): HerdrMetadataRequest => ({
   },
 });
 
-export class HerdrAdvisorActivity {
+export interface HerdrAdvisorActivityScope {
+  clear: () => void;
+  start: () => () => void;
+}
+
+export class HerdrAdvisorActivity implements HerdrAdvisorActivityScope {
   #activeConsultations = 0;
+  #activeByOwner = new Map<symbol, Set<symbol>>();
+  #defaultOwner = Symbol("default Herdr Advisor activity");
   private readonly report: Report;
   private readonly enabled: () => boolean;
 
@@ -46,31 +53,74 @@ export class HerdrAdvisorActivity {
   }
 
   start() {
+    return this.startFor(this.#defaultOwner);
+  }
+
+  finish() {
+    this.finishFor(this.#defaultOwner);
+  }
+
+  clear() {
+    this.clearFor(this.#defaultOwner);
+  }
+
+  createScope(): HerdrAdvisorActivityScope {
+    const owner = Symbol("Herdr Advisor runtime");
+    return {
+      clear: () => this.clearFor(owner),
+      start: () => this.startFor(owner),
+    };
+  }
+
+  private startFor(owner: symbol) {
+    const lease = Symbol("Herdr activity lease");
     if (!this.enabled()) {
-      return;
+      return () => this.finishLease(owner, lease);
     }
+    let leases = this.#activeByOwner.get(owner);
+    if (!leases) {
+      leases = new Set();
+      this.#activeByOwner.set(owner, leases);
+    }
+    leases.add(lease);
     this.#activeConsultations += 1;
     if (this.#activeConsultations === 1) {
       this.safeReport(false);
     }
+    return () => this.finishLease(owner, lease);
   }
 
-  finish() {
-    if (this.#activeConsultations === 0) {
+  private finishFor(owner: symbol) {
+    const lease = this.#activeByOwner.get(owner)?.values().next().value;
+    if (lease) {
+      this.finishLease(owner, lease);
+    }
+  }
+
+  private finishLease(owner: symbol, lease: symbol) {
+    const leases = this.#activeByOwner.get(owner);
+    if (!leases?.delete(lease)) {
       return;
     }
+    if (leases.size === 0) {
+      this.#activeByOwner.delete(owner);
+    }
     this.#activeConsultations -= 1;
     if (this.#activeConsultations === 0) {
       this.safeReport(true);
     }
   }
 
-  clear() {
-    if (this.#activeConsultations === 0) {
+  private clearFor(owner: symbol) {
+    const leases = this.#activeByOwner.get(owner);
+    if (!leases?.size) {
       return;
     }
-    this.#activeConsultations = 0;
-    this.safeReport(true);
+    this.#activeByOwner.delete(owner);
+    this.#activeConsultations -= leases.size;
+    if (this.#activeConsultations === 0) {
+      this.safeReport(true);
+    }
   }
 
   private safeReport(clear: boolean) {

package/src/jev/client.ts

@@ -97,9 +97,12 @@ const connectionFailure = <E>(error: E) => {
   };
 };
 
-const sleepWithAbort = (signal: AbortSignal, ms: number): Promise<void> =>
+const sleepWithAbort = (signal: AbortSignal, ms: number): Promise<void> => {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
   // oxlint-disable-next-line promise/avoid-new -- unref-ed abortable retry timer cannot be expressed with async/await.
-  new Promise((resolve) => {
+  return new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
     timer.unref?.();
     signal.addEventListener(
@@ -111,6 +114,7 @@ const sleepWithAbort = (signal: AbortSignal, ms: number): Promise<void> =>
       { once: true }
     );
   });
+};
 
 /** One systemone client for both transports with a total wall deadline so
  * retries can never stall a tool call; errors are classified and redacted on
@@ -167,7 +171,11 @@ export class JevClient {
       for (let attempt = 1; ; attempt += 1) {
         // The retry loop is bounded to one backoff by the deadline controller.
         outcome = await this.#attempt(body, deadline.signal);
-        if (!outcome.retryable || attempt >= MAX_ATTEMPTS) {
+        if (
+          !outcome.retryable ||
+          attempt >= MAX_ATTEMPTS ||
+          deadline.signal.aborted
+        ) {
           break;
         }
         await sleepWithAbort(deadline.signal, RETRY_BACKOFF_MS);
@@ -212,12 +220,12 @@ export class JevClient {
         `Jev call exceeded its ${this.#timeoutMs} ms wall-time budget.`
       );
     }
-    if (outcome.failure) {
-      throw outcome.failure;
-    }
     if (signal?.aborted) {
       throw new Error("Jev call aborted by the caller.");
     }
+    if (outcome.failure) {
+      throw outcome.failure;
+    }
     throw new JevFailureError("error", "Jev call failed.");
   }
 

package/src/redaction.ts

@@ -3,10 +3,15 @@ import { capUtf8Bytes, isString } from "./content-utils.ts";
 const REDACTION_MARKER = "[REDACTED SECRET]";
 const PEM_BEGIN_PATTERN = /-----BEGIN(?: [A-Z0-9]+)? PRIVATE KEY-----/giu;
 const PEM_END_PATTERN = /-----END(?: [A-Z0-9]+)? PRIVATE KEY-----/iu;
+const CREDENTIAL_NAME = String.raw`(?:api[_-]?key|token|secret|password|passwd)`;
+const SECRET_ASSIGNMENT_PATTERN = new RegExp(
+  String.raw`(?:(?:"(?:[a-z0-9]+[_-])*?${CREDENTIAL_NAME}"|'(?:[a-z0-9]+[_-])*?${CREDENTIAL_NAME}')|(?:\b|_)${CREDENTIAL_NAME})\s*[:=]\s*(?:"(?:\\.|[^"])*(?:"|$)|'(?:\\.|[^'])*(?:'|$)|[^\s"'&,;)}\]]+)`,
+  "giu"
+);
 const SECRET_PATTERNS = [
   /-----BEGIN(?: [A-Z0-9]+)? PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z0-9]+)? PRIVATE KEY-----/giu,
   /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/giu,
-  /\b(?:api[_-]?key|token|secret|password|passwd)\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s"'&,;)}\]]+)/giu,
+  SECRET_ASSIGNMENT_PATTERN,
   /(?<scheme>[a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/giu,
   /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/gu,
   /\b(?:aws_secret_access_key|aws_session_token)\s*[:=]\s*[^\s"'&,;)}\]]+/giu,

package/src/session-state.ts

@@ -177,6 +177,7 @@ export class AdvisorSessionState {
   #ledger = freshAdviceLedger();
   #usage = freshUsage();
   #consumedCalls = 0;
+  #callReservations = new Set<string>();
   readonly #jev = new AdvisorJevLedgerState();
   #sessionTurnOrdinal = 0;
   #turnsSinceConsultation = 0;
@@ -187,6 +188,7 @@ export class AdvisorSessionState {
     this.#ledger = freshAdviceLedger();
     this.#usage = freshUsage();
     this.#consumedCalls = 0;
+    this.#callReservations.clear();
     this.#jev.reset();
     this.#sessionTurnOrdinal = 0;
     this.#turnsSinceConsultation = 0;
@@ -227,16 +229,40 @@ export class AdvisorSessionState {
     return true;
   }
 
-  canConsult(limit: number | undefined) {
-    return limit === undefined || this.#consumedCalls < limit;
+  canConsult(limit: number | undefined, reservationId?: string) {
+    const reservations =
+      this.#callReservations.size -
+      Number(
+        reservationId !== undefined && this.#callReservations.has(reservationId)
+      );
+    return limit === undefined || this.#consumedCalls + reservations < limit;
   }
-  consumeCall() {
+  reserveCall(id: string, limit: number | undefined) {
+    if (this.#callReservations.has(id)) {
+      return true;
+    }
+    if (!this.canConsult(limit)) {
+      return false;
+    }
+    this.#callReservations.add(id);
+    return true;
+  }
+  releaseCall(id: string) {
+    this.#callReservations.delete(id);
+  }
+  clearCallReservations() {
+    this.#callReservations.clear();
+  }
+  consumeCall(reservationId?: string) {
+    if (reservationId !== undefined) {
+      this.#callReservations.delete(reservationId);
+    }
     this.#consumedCalls += 1;
   }
   remainingCalls(limit: number | undefined) {
     return limit === undefined
       ? undefined
-      : Math.max(0, limit - this.#consumedCalls);
+      : Math.max(0, limit - this.#consumedCalls - this.#callReservations.size);
   }
   get consumedCalls() {
     return this.#consumedCalls;

package/src/tools/gate-policy.ts

@@ -11,6 +11,7 @@ import {
   isSimpleMode,
 } from "../config/state.ts";
 import type { GateFailureMode } from "../config/types.ts";
+import type { HerdrAdvisorBlock } from "../herdr-block.ts";
 import { herdrAdvisorBlock, notifyHerdrAdvisorFailure } from "../herdr.ts";
 import type { AdvisorSessionState } from "../session-state.ts";
 import type { AdvisorGateResult, GateFailureCategory } from "./types.ts";
@@ -66,7 +67,8 @@ export const failureEffect = (
   message: string,
   ctx: ExtensionContext,
   session: AdvisorSessionState,
-  failureMode: GateFailureMode
+  failureMode: GateFailureMode,
+  herdrBlock: HerdrAdvisorBlock = herdrAdvisorBlock
 ) => {
   const reason = `Advisor gate ${category}: ${message}`;
   notifyLocalFailure(ctx, message, failureMode === "block-session");
@@ -78,7 +80,7 @@ export const failureEffect = (
     return { block: true, effect: "tool-blocked" as const, reason };
   }
   session.block(reason);
-  herdrAdvisorBlock.set(reason);
+  herdrBlock.set(reason);
   if (advisorBlockOnBlockedRef) {
     ctx.abort();
   }
@@ -89,7 +91,8 @@ export const blockedDecisionEffect = (
   reason: string,
   ctx: ExtensionContext,
   session: AdvisorSessionState,
-  failureMode: GateFailureMode
+  failureMode: GateFailureMode,
+  herdrBlock: HerdrAdvisorBlock = herdrAdvisorBlock
 ) => {
   if (failureMode === "warn-and-continue") {
     if (ctx.hasUI) {
@@ -104,7 +107,7 @@ export const blockedDecisionEffect = (
     return { block: true, effect: "tool-blocked" as const, reason };
   }
   session.block(reason);
-  herdrAdvisorBlock.set(reason);
+  herdrBlock.set(reason);
   if (advisorBlockOnBlockedRef) {
     ctx.abort();
   }
@@ -120,7 +123,7 @@ export const reserveAdvisorCall = (
   if (event.toolName !== "ask_advisor" || isSimpleMode()) {
     return;
   }
-  if (!session.canConsult(getAdvisorMaxCallsPerSession())) {
+  if (!session.reserveCall(event.toolCallId, getAdvisorMaxCallsPerSession())) {
     const message = "Advisor call budget exhausted for this session.";
     if (ctx.hasUI) {
       ctx.ui.notify(message, "warning");

package/src/tools/jev-filter.ts

@@ -140,11 +140,12 @@ const screenWithJev = async (
     session.recordJevFilterAllowed();
     return allow();
   } catch (error) {
+    if (options.signal?.aborted) {
+      throw error;
+    }
     session.recordJevFilterFailure();
     if (error instanceof JevFailure) {
       notifyOutageOnce(ctx, error.category, error.message);
-    } else if (options.signal?.aborted) {
-      throw error;
     } else {
       notifyOutageOnce(
         ctx,

package/src/tools/jev-turn-gate.ts

@@ -11,6 +11,7 @@ import {
   isSimpleMode,
 } from "../config/state.ts";
 import { herdrAdvisorActivity } from "../herdr.ts";
+import type { HerdrAdvisorActivityScope } from "../herdr.ts";
 import { JevFailure, jevClientFromCredentials } from "../jev/client.ts";
 import { composeTurnGateVerdict } from "../jev/questions.ts";
 import { buildJevState } from "../jev/state.ts";
@@ -55,6 +56,7 @@ export interface JevTurnGateRegistration {
   activeTools: () => string[];
   consult: typeof consultAdvisor;
   deps?: JevTurnGateDeps;
+  herdrActivity?: HerdrAdvisorActivityScope;
   send: (message: {
     content: string;
     customType: string;
@@ -71,6 +73,35 @@ const outageNotifier = createOutageNotifier(
 
 const notifyFailureOnce = outageNotifier.notify;
 
+const shouldRunTurnGate = (
+  registration: JevTurnGateRegistration,
+  ctx: ExtensionContext,
+  session: AdvisorSessionState
+) => {
+  const interval = advisorJevTurnGateEveryTurnsRef;
+  return (
+    interval > 0 &&
+    session.turnsSinceConsultation > 0 &&
+    session.turnsSinceConsultation % interval === 0 &&
+    !isSimpleMode() &&
+    !session.blocked &&
+    registration.activeTools().includes("ask_advisor") &&
+    advisorModelIsAllowed(ctx) &&
+    session.canConsult(getAdvisorMaxCallsPerSession())
+  );
+};
+
+const consumeTurnGateBudget = (
+  session: AdvisorSessionState,
+  shouldConsult: boolean
+) => {
+  if (!shouldConsult || !session.canConsult(getAdvisorMaxCallsPerSession())) {
+    return false;
+  }
+  session.consumeCall();
+  return true;
+};
+
 /** Test-only: re-arms the once-per-outage notification. */
 export const resetJevTurnGateNotification = outageNotifier.reset;
 
@@ -86,21 +117,7 @@ export const handleJevTurnEnd = async (
 ): Promise<void> => {
   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") ||
-    !advisorModelIsAllowed(ctx) ||
-    !session.canConsult(getAdvisorMaxCallsPerSession())
-  ) {
+  if (!shouldRunTurnGate(registration, ctx, session)) {
     return;
   }
 
@@ -128,22 +145,21 @@ export const handleJevTurnEnd = async (
       result.answers,
       advisorJevTurnGateNoulThresholdRef
     );
-    if (!shouldConsult) {
+    if (!consumeTurnGateBudget(session, 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,
-    });
+    const herdrActivity = registration.herdrActivity ?? herdrAdvisorActivity;
+    const finishHerdrActivity = herdrActivity.start();
     try {
+      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,
+      });
       const consulted = await consult(
         ctx,
         undefined,
@@ -173,7 +189,7 @@ export const handleJevTurnEnd = async (
         display: true,
       });
     } finally {
-      herdrAdvisorActivity.finish();
+      finishHerdrActivity();
     }
   } catch (error) {
     session.recordJevGateFailure();