pi-advisor-flow 0.6.0 → 0.8.0

package/src/tools/consultation.ts

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
+
 import type { Message } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
 import {
   advisorEffortRef,
   advisorRedactSecretsRef,
@@ -14,6 +16,7 @@ import type { ScoutLifecycleEvent } from "../scout.ts";
 import type { ConsultationTrigger, GateTrigger } from "../session-state.ts";
 import { assembleConsultationContext } from "./consult-context.ts";
 import { parseAutomaticDecision } from "./gate-protocol.ts";
+import { advisorModelAccessReason } from "./model-access.ts";
 import {
   ADVISOR_DECISION_SYSTEM,
   ADVISOR_SYSTEM,
@@ -21,7 +24,7 @@ import {
 } from "./prompts.ts";
 import type { AdvisorConsultationResult, AdvisorGateOutcome } from "./types.ts";
 
-// biome-ignore lint/performance/noBarrelFile: preserves the tools facade's historical re-export of the moved curation entry point.
+// Re-export preserves the tools facade's historical curation entry point.
 export { curateAdvisorConversation } from "../scout-curation.ts";
 
 /** Thrown when the Advisor produced an empty response body. */
@@ -54,6 +57,10 @@ const collectAdvisorResponse = async (
 ) => {
   const { ctx, question, signal, systemPrompt } = options;
   loadConfig(ctx);
+  const accessReason = advisorModelAccessReason(ctx);
+  if (accessReason) {
+    throw new Error(accessReason);
+  }
   const resolved = await resolveConfiguredModel(ctx, advisorRef, "Advisor");
   const context = await assembleConsultationContext(options);
 
@@ -95,9 +102,9 @@ const collectAdvisorResponse = async (
   if (!markdown.trim()) {
     throw new AdvisorNoAdviceError();
   }
-  return {
+  const response: Omit<AdvisorConsultationResult, "adviceId" | "trigger"> = {
     draftBytes: context.draftText
-      ? Buffer.byteLength(context.draftText, "utf8")
+      ? Buffer.byteLength(context.draftText, "utf-8")
       : undefined,
     markdown,
     model: advisorRef,
@@ -108,8 +115,11 @@ const collectAdvisorResponse = async (
     untrackedBytes:
       context.untracked.reduce((sum, item) => sum + item.bytes, 0) || undefined,
     usage: streamed.usage,
-    ...(context.scout ? { scout: context.scout } : {}),
   };
+  if (context.scout) {
+    response.scout = context.scout;
+  }
+  return response;
 };
 
 export const consultAdvisor = async (

package/src/tools/gate-policy.ts

@@ -3,6 +3,7 @@ import type {
   ToolCallEvent,
   ToolCallEventResult,
 } from "@earendil-works/pi-coding-agent";
+
 import {
   advisorBlockOnBlockedRef,
   getAdvisorMaxCallsPerSession,

package/src/tools/gate-protocol.ts

@@ -1,20 +1,30 @@
 import type { GateDecision } from "../session-state.ts";
 import type { AdvisorGateFailure, AdvisorGateResult } from "./types.ts";
 
-const DECISION_LINE = /^Decision\s*:\s*(proceed|revise|blocked)\s*$/i;
-const CODE_FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-const LINE_BREAK = /\r?\n/;
+/** Named-group accessor; exec matches of these regexes always populate groups. */
+const namedGroups = (match: RegExpExecArray): Record<string, string> =>
+  match.groups ?? {};
+
+const DECISION_LINE =
+  /^Decision\s*:\s*(?<decision>proceed|revise|blocked)\s*$/iu;
+const CODE_FENCE = /^ {0,3}(?<marker>`{3,}|~{3,})(?<suffix>.*)$/u;
+const LINE_BREAK = /\r?\n/u;
 
 interface FenceState {
   character: string;
   length: number;
 }
 
+interface FenceAdvance {
+  closed: boolean;
+  openingFence: FenceState | undefined;
+}
+
 const advanceFence = (
   openingFence: FenceState | undefined,
   marker: string,
   suffix: string
-): { closed: boolean; openingFence: FenceState | undefined } => {
+): FenceAdvance => {
   if (!openingFence) {
     if (marker[0] === "`" && suffix.includes("`")) {
       return { closed: false, openingFence: undefined };
@@ -59,7 +69,8 @@ export const parseAutomaticDecision = (
       ok: false,
     };
   }
-  const decision = match[1].toLowerCase() as GateDecision;
+  // SAFETY: DECISION_LINE's decision group only matches proceed, revise, or blocked.
+  const decision = namedGroups(match).decision.toLowerCase() as GateDecision;
   let openingFence: FenceState | undefined;
   const decisions: string[] = [];
   let pendingFencedDecisions: string[] = [];
@@ -72,10 +83,11 @@ export const parseAutomaticDecision = (
     // open.
     const fence = CODE_FENCE.exec(line);
     if (fence) {
+      const groups = namedGroups(fence);
       const { closed, openingFence: nextOpeningFence } = advanceFence(
         openingFence,
-        fence[1],
-        fence[2]
+        groups.marker,
+        groups.suffix
       );
       openingFence = nextOpeningFence;
       if (closed) {
@@ -87,7 +99,7 @@ export const parseAutomaticDecision = (
     if (!subsequent) {
       continue;
     }
-    const repeated = subsequent[1].trim().toLowerCase();
+    const repeated = namedGroups(subsequent).decision.trim().toLowerCase();
     if (openingFence) {
       pendingFencedDecisions.push(repeated);
     } else {
@@ -97,21 +109,22 @@ export const parseAutomaticDecision = (
   if (openingFence) {
     decisions.push(...pendingFencedDecisions);
   }
-  for (const repeated of decisions) {
-    if (repeated === decision) {
-      return {
-        category: "duplicate-decision",
-        markdown: text,
-        message: "Advisor gate response contains duplicate decision lines.",
-        ok: false,
-      };
-    }
-    return {
-      category: "contradictory-decision",
-      markdown: text,
-      message: "Advisor gate response contains contradictory decision lines.",
-      ok: false,
-    };
+  const [repeated] = decisions;
+  if (repeated !== undefined) {
+    return repeated === decision
+      ? {
+          category: "duplicate-decision",
+          markdown: text,
+          message: "Advisor gate response contains duplicate decision lines.",
+          ok: false,
+        }
+      : {
+          category: "contradictory-decision",
+          markdown: text,
+          message:
+            "Advisor gate response contains contradictory decision lines.",
+          ok: false,
+        };
   }
   return {
     decision,

package/src/tools/jev-filter.ts

@@ -0,0 +1,204 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Fetch } from "@typesafe-ai/sdk";
+
+import {
+  advisorJevFilterEnabledRef,
+  advisorJevFilterNoulMarginRef,
+  advisorJevFilterOverrideWindowRef,
+  advisorJevFilterSkipConfidenceRef,
+  isSimpleMode,
+} from "../config/state.ts";
+import { JevFailure, jevClientFromCredentials } from "../jev/client.ts";
+import { consumePlaintextKeyWarning } from "../jev/key-store.ts";
+import {
+  composeScreeningVerdict,
+  screeningQuestions,
+} from "../jev/questions.ts";
+import { buildJevState } from "../jev/state.ts";
+import { resolveJevTransport } from "../jev/transport.ts";
+import type { JevCredentials } from "../jev/transport.ts";
+import type { AdvisorSessionState } from "../session-state.ts";
+import { createOutageNotifier } from "./outage-notifier.ts";
+
+export type JevSkipKind = "screened" | "repeat";
+
+export type ScreeningOutcome =
+  | { decision: "allow" }
+  | {
+      decision: "skip";
+      kind: JevSkipKind;
+      reason: string;
+      reattachedAdvice?: string;
+    };
+
+export interface ScreenConsultationOptions {
+  draft?: string;
+  force?: boolean;
+  question?: string;
+  signal?: AbortSignal;
+}
+
+export interface ScreeningDeps {
+  fetch?: Fetch;
+  resolveTransport?: () => Promise<JevCredentials | undefined>;
+}
+
+export const normalizeScreeningQuestion = (question: string | undefined) =>
+  question?.trim().toLowerCase().replaceAll(/\s+/gu, " ") || undefined;
+
+const REATTACHED_ADVICE_CAP_BYTES = 4 * 1024;
+
+const 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.";
+
+const repeatSkipText = (advice: string) =>
+  `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.\n\n${advice}`;
+
+const outageNotifier = createOutageNotifier(
+  (category, message) =>
+    `Advisor Jev filter failed (${category}); allowing consultations. ${message}`
+);
+
+const notifyOutageOnce = outageNotifier.notify;
+
+/** Test-only: re-arms the once-per-outage notification. */
+export const resetJevOutageNotification = outageNotifier.reset;
+
+const allow = (): ScreeningOutcome => ({ decision: "allow" });
+
+const bypassOutcome = (
+  session: AdvisorSessionState,
+  options: ScreenConsultationOptions,
+  normalizedQuestion: string | undefined
+): ScreeningOutcome | undefined => {
+  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 undefined;
+};
+
+const screenWithJev = async (
+  ctx: ExtensionContext,
+  session: AdvisorSessionState,
+  options: ScreenConsultationOptions,
+  deps: ScreeningDeps,
+  normalizedQuestion: string | undefined
+): Promise<ScreeningOutcome> => {
+  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();
+  }
+};
+
+/**
+ * Fail-open screening: decides run/skip for one ask_advisor call. Disabled or
+ * simple mode, missing credentials, and every Jev failure allow the
+ * consultation; only the hard conjunction (negligible-mass ≥ skip confidence
+ * AND confidently self-answerable) or an exact repeat skips.
+ */
+export const screenConsultation = (
+  ctx: ExtensionContext,
+  session: AdvisorSessionState,
+  options: ScreenConsultationOptions,
+  deps: ScreeningDeps = {}
+): Promise<ScreeningOutcome> => {
+  if (isSimpleMode()) {
+    return Promise.resolve(allow());
+  }
+  // Repeat reattachment and its force/passthrough escape hatch are code-side
+  // and free: they run regardless of the Jev enable flag, which only gates
+  // the (paid, network) Jev screening call.
+  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);
+};
+
+export const screeningSkipText = (outcome: {
+  kind: JevSkipKind;
+  reattachedAdvice?: string;
+}) =>
+  outcome.kind === "repeat" && outcome.reattachedAdvice
+    ? repeatSkipText(outcome.reattachedAdvice)
+    : SCREENED_SKIP_TEXT;

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

@@ -0,0 +1,203 @@
+import type {
+  ExtensionContext,
+  TurnEndEvent,
+} from "@earendil-works/pi-coding-agent";
+import type { Fetch } from "@typesafe-ai/sdk";
+
+import {
+  advisorJevTurnGateEveryTurnsRef,
+  advisorJevTurnGateNoulThresholdRef,
+  getAdvisorMaxCallsPerSession,
+  isSimpleMode,
+} from "../config/state.ts";
+import { herdrAdvisorActivity } from "../herdr.ts";
+import { JevFailure, jevClientFromCredentials } from "../jev/client.ts";
+import { composeTurnGateVerdict } from "../jev/questions.ts";
+import { buildJevState } from "../jev/state.ts";
+import { resolveJevTransport } from "../jev/transport.ts";
+import type { JevCredentials } from "../jev/transport.ts";
+import type { AdvisorSessionState } from "../session-state.ts";
+import { advisorUsageCost } from "../usage.ts";
+import type { consultAdvisor } from "./consultation.ts";
+import { updateAdvisorUsageStatus } from "./gate-policy.ts";
+import { advisorModelIsAllowed } from "./model-access.ts";
+import { createOutageNotifier } from "./outage-notifier.ts";
+
+export const 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",
+} as const;
+
+export interface JevTurnGateDeps {
+  consult?: typeof consultAdvisor;
+  fetch?: Fetch;
+  resolveTransport?: () => Promise<JevCredentials | undefined>;
+}
+
+export interface TurnGateCallDetails {
+  question: string;
+  turn: number;
+}
+
+export interface TurnGateResultDetails {
+  advisor: string;
+  text: string;
+  usage?: unknown;
+}
+
+export interface JevTurnGateRegistration {
+  activeTools: () => string[];
+  consult: typeof consultAdvisor;
+  deps?: JevTurnGateDeps;
+  send: (message: {
+    content: string;
+    customType: string;
+    details: TurnGateCallDetails | TurnGateResultDetails;
+    display: boolean;
+  }) => void;
+  session: AdvisorSessionState;
+}
+
+const outageNotifier = createOutageNotifier(
+  (category, message) =>
+    `Advisor Jev turn gate failed (${category}); continuing without a proactive consultation. ${message}`
+);
+
+const notifyFailureOnce = outageNotifier.notify;
+
+/** Test-only: re-arms the once-per-outage notification. */
+export const resetJevTurnGateNotification = outageNotifier.reset;
+
+/**
+ * turn_end handler: counts turns without a consultation and, every Nth such
+ * turn, asks Jev whether the Advisor should proactively weigh in. Confident
+ * true runs a real consultation delivered as a steer message; everything else
+ * keeps the status quo.
+ */
+export const handleJevTurnEnd = async (
+  registration: JevTurnGateRegistration,
+  ctx: ExtensionContext
+): 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())
+  ) {
+    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)
+      );
+    }
+  }
+};
+
+type TurnEndRegistrar = (
+  event: "turn_end",
+  handler: (event: TurnEndEvent, ctx: ExtensionContext) => void | Promise<void>
+) => void;
+
+/** Wires the turn_end handler on an ExtensionAPI-like surface. */
+export const registerJevTurnGate = (
+  on: TurnEndRegistrar,
+  registration: JevTurnGateRegistration
+): void => {
+  on("turn_end", (_event, ctx) => handleJevTurnEnd(registration, ctx));
+};

package/src/tools/loop-gate.ts

@@ -4,6 +4,7 @@ import type {
   ToolCallEvent,
   ToolCallEventResult,
 } from "@earendil-works/pi-coding-agent";
+
 import {
   advisorAutoLoopGateRef,
   advisorFailureModeRef,
@@ -15,8 +16,9 @@ import {
 } from "../config/state.ts";
 import type { GateFailureMode } from "../config/types.ts";
 import { herdrAdvisorActivity } from "../herdr.ts";
-import type { AdvisorSessionState } from "../session-state.ts";
+import type { AdvisorSessionState, GateDecision } from "../session-state.ts";
 import { advisorUsageCost, snapshotAdvisorUsage } from "../usage.ts";
+import type { AdvisorUsageSnapshot } from "../usage.ts";
 import type { runAdvisorGate } from "./consultation.ts";
 import {
   blockedDecisionEffect,
@@ -26,10 +28,9 @@ import {
   updateAdvisorUsageStatus,
 } from "./gate-policy.ts";
 import { adviceForGateText } from "./gate-protocol.ts";
-import {
-  appendScoutLifecycleEntry,
-  type ScoutStatusManager,
-} from "./scout-status.ts";
+import { advisorModelIsAllowed } from "./model-access.ts";
+import { appendScoutLifecycleEntry } from "./scout-status.ts";
+import type { ScoutStatusManager } from "./scout-status.ts";
 import type { AdvisorGateResult, ScoutToolDetails } from "./types.ts";
 
 const sendAutomaticGateCall = (pi: ExtensionAPI, event: ToolCallEvent) => {
@@ -46,20 +47,27 @@ const sendAutomaticGateCall = (pi: ExtensionAPI, event: ToolCallEvent) => {
   );
 };
 
+interface LoopResultDetails {
+  advisor?: string;
+  decision?: GateDecision;
+  text: string;
+  usage?: AdvisorUsageSnapshot;
+}
+
 const sendAutomaticGateFailure = (
   pi: ExtensionAPI,
   markdown: string,
-  usage?: unknown
+  usage?: AdvisorUsageSnapshot
 ) => {
-  const normalizedUsage = snapshotAdvisorUsage(usage);
+  const details: LoopResultDetails = { text: markdown };
+  if (usage) {
+    details.usage = usage;
+  }
   pi.sendMessage(
     {
       content: markdown,
       customType: "advisor-loop-result",
-      details: {
-        text: markdown,
-        ...(normalizedUsage ? { usage: normalizedUsage } : {}),
-      },
+      details,
       display: true,
     },
     { deliverAs: "steer" }
@@ -70,18 +78,20 @@ const sendAutomaticGateResult = (
   pi: ExtensionAPI,
   result: AdvisorGateResult
 ) => {
+  const details: LoopResultDetails = {
+    advisor: result.model,
+    decision: result.decision,
+    text: result.markdown,
+  };
+  const normalizedUsage = snapshotAdvisorUsage(result.usage);
+  if (normalizedUsage) {
+    details.usage = normalizedUsage;
+  }
   pi.sendMessage(
     {
       content: adviceForGateText(result),
       customType: "advisor-loop-result",
-      details: {
-        advisor: result.model,
-        decision: result.decision,
-        text: result.markdown,
-        ...(snapshotAdvisorUsage(result.usage)
-          ? { usage: snapshotAdvisorUsage(result.usage) }
-          : {}),
-      },
+      details,
       display: true,
     },
     { deliverAs: "steer" }
@@ -118,7 +128,7 @@ const applyGateDecision = (
     sendAutomaticGateFailure(
       pi,
       `**Advisor gate failure (${result.category}):** ${result.message}`,
-      result.usage
+      snapshotAdvisorUsage(result.usage)
     );
     return failure.block
       ? { block: true, reason: `${reason}\n${failure.reason}` }
@@ -158,6 +168,7 @@ export const handleAutomaticGate = async (
   if (
     isSimpleMode() ||
     event.toolName === "ask_advisor" ||
+    !advisorModelIsAllowed(ctx) ||
     !advisorAutoLoopGateRef ||
     !session.recordToolCall(
       event.toolName,
@@ -180,6 +191,7 @@ export const handleAutomaticGate = async (
     return failure.block ? { block: true, reason: failure.reason } : undefined;
   }
   session.consumeCall();
+  session.resetTurnsSinceConsultation();
   herdrAdvisorActivity.start();
   let scoutDetails: ScoutToolDetails | undefined;
   const scoutStatusToken = Symbol("automatic-gate-scout");