pi-advisor-flow 0.7.0 → 0.8.1-dev.1

package/src/session-state.ts

@@ -1,11 +1,14 @@
-import { AdvisorJevLedgerState, type AdvisorJevUsage } from "./jev/ledger.ts";
+import { isRecordOf, isString } from "./content-utils.ts";
+import type { JsonValue } from "./content-utils.ts";
+import { AdvisorJevLedgerState } from "./jev/ledger.ts";
+import type { AdvisorJevUsage } from "./jev/ledger.ts";
 import {
-  type AdvisorUsageTotals,
   addAdvisorUsage,
   emptyAdvisorUsageTotals,
   formatAdvisorUsageStatus,
   formatAdvisorUsageTotals,
 } from "./usage.ts";
+import type { AdvisorUsageTotals } from "./usage.ts";
 
 export type GateDecision = "proceed" | "revise" | "blocked";
 export type ConsultationTrigger = "manual" | "executor-requested" | "turn-gate";
@@ -27,7 +30,7 @@ export interface AdvisorInvocationRecord {
   usage?: unknown;
 }
 
-const WHITESPACE = /\s/;
+const WHITESPACE = /\s/u;
 const TIMESTAMP_KEYS = new Set([
   "createdat",
   "date",
@@ -37,7 +40,8 @@ const TIMESTAMP_KEYS = new Set([
   "updatedat",
 ]);
 const REQUEST_ID_KEYS = new Set(["correlationid", "requestid", "traceid"]);
-const normalizedKey = (key: string) => key.replace(/[-_]/g, "").toLowerCase();
+const normalizedKey = (key: string) =>
+  key.replaceAll(/[-_]/gu, "").toLowerCase();
 const isVolatileKey = (key: string, keys: Set<string>) =>
   keys.has(normalizedKey(key));
 
@@ -75,15 +79,24 @@ const normalizeShellWhitespace = (command: string) => {
 
 const normalizeString = (value: string) =>
   value
-    .replace(/\/(?:private\/)?tmp\/[^\s/]+/g, "/tmp/<temporary>")
-    .replace(/\/var\/folders\/[^\s/]+/g, "/var/folders/<temporary>");
+    .replaceAll(/\/(?:private\/)?tmp\/[^\s/]+/gu, "/tmp/<temporary>")
+    .replaceAll(/\/var\/folders\/[^\s/]+/gu, "/var/folders/<temporary>");
 
-export const normalizeToolInput = (
+export type NormalizedToolInput =
+  | JsonValue
+  | undefined
+  | NormalizedToolInput[]
+  | { [key: string]: NormalizedToolInput };
+
+export const normalizeToolInput = <Input>(
   toolName: string,
-  input: unknown
-): unknown => {
-  const visit = (value: unknown, key?: string): unknown => {
-    if (typeof value === "string") {
+  input: Input
+): NormalizedToolInput => {
+  const visit = (
+    value: NormalizedToolInput,
+    key?: string
+  ): NormalizedToolInput => {
+    if (isString(value)) {
       if (key && isVolatileKey(key, TIMESTAMP_KEYS)) {
         return "<timestamp>";
       }
@@ -98,21 +111,23 @@ export const normalizeToolInput = (
     if (Array.isArray(value)) {
       return value.map((item) => visit(item));
     }
-    if (value && typeof value === "object") {
-      const record = value as Record<string, unknown>;
+    if (isRecordOf(value)) {
       return Object.fromEntries(
-        Object.keys(record)
-          .sort()
-          .map((childKey) => [childKey, visit(record[childKey], childKey)])
+        Object.keys(value)
+          .toSorted()
+          .map((childKey) => [childKey, visit(value[childKey], childKey)])
       );
     }
     return value;
   };
-  return visit(input);
+  // SAFETY: Pi tool inputs are JSON-decoded tool arguments, so the root value is already NormalizedToolInput-shaped.
+  return visit(input as Input & NormalizedToolInput);
 };
 
-export const normalizedToolSignature = (toolName: string, input: unknown) =>
-  `${toolName}:${JSON.stringify(normalizeToolInput(toolName, input))}`;
+export const normalizedToolSignature = <Input>(
+  toolName: string,
+  input: Input
+) => `${toolName}:${JSON.stringify(normalizeToolInput(toolName, input))}`;
 
 interface RepetitionState {
   count: number;
@@ -120,16 +135,15 @@ interface RepetitionState {
   previousSignature?: string;
 }
 
+interface IssuedAdvice {
+  advice: string;
+  normalizedQuestion?: string;
+  trigger: ConsultationTrigger;
+}
+
 interface AdviceLedger {
   draftConsultations: number;
-  issued: Map<
-    string,
-    {
-      advice: string;
-      normalizedQuestion?: string;
-      trigger: ConsultationTrigger;
-    }
-  >;
+  issued: Map<string, IssuedAdvice>;
   lastAdvice?: string;
   outcomes: number;
   pending: Set<string>;
@@ -196,7 +210,7 @@ export class AdvisorSessionState {
     this.#blockedReason ??= reason;
   }
 
-  recordToolCall(toolName: string, input: unknown, threshold: number) {
+  recordToolCall<Input>(toolName: string, input: Input, threshold: number) {
     if (toolName === "ask_advisor") {
       return false;
     }
@@ -269,11 +283,11 @@ export class AdvisorSessionState {
     draft = false,
     normalizedQuestion?: string
   ) {
-    this.#ledger.issued.set(id, {
-      advice,
-      ...(normalizedQuestion ? { normalizedQuestion } : {}),
-      trigger,
-    });
+    const issued: IssuedAdvice = { advice, trigger };
+    if (normalizedQuestion) {
+      issued.normalizedQuestion = normalizedQuestion;
+    }
+    this.#ledger.issued.set(id, issued);
     this.#ledger.lastAdvice = advice;
     if (draft) {
       this.#ledger.draftConsultations += 1;
@@ -300,12 +314,11 @@ export class AdvisorSessionState {
       return false;
     }
     const mentioned = paths.every((path) => {
-      const escaped = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const boundary =
-        "(^|[\\s\\\"'`()\\[])" +
-        escaped +
-        "(?=$|[\\s\\\"'`),;:!?\\]]|\\.(?=\\s|$))";
-      return new RegExp(boundary).test(advice);
+      const escaped = path.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+      const boundary = `(^|[\\s"'\`()\\[])${
+        escaped
+      }(?=$|[\\s"'\`),;:!?\\]]|\\.(?=\\s|$))`;
+      return new RegExp(boundary, "u").test(advice);
     });
     if (!mentioned) {
       return false;
@@ -354,7 +367,7 @@ export class AdvisorSessionState {
       (item) => item.kind === "gate"
     );
     return (
-      (["proceed", "revise", "blocked"] as GateDecision[])
+      (["proceed", "revise", "blocked"] as const)
         .map(
           (decision) =>
             [
@@ -375,15 +388,17 @@ export class AdvisorSessionState {
 
   #triggersLine() {
     return (
-      [
-        "manual",
-        "executor-requested",
-        "turn-gate",
-        "repeated-tool-call",
-        "completion-review",
-        "custom-rule",
-      ]
-        .filter((trigger) => this.#countTrigger(trigger as AdvisorTrigger) > 0)
+      (
+        [
+          "manual",
+          "executor-requested",
+          "turn-gate",
+          "repeated-tool-call",
+          "completion-review",
+          "custom-rule",
+        ] as const
+      )
+        .filter((trigger) => this.#countTrigger(trigger) > 0)
         .join(", ") || "none"
     );
   }

package/src/tool-result-cap.ts

@@ -14,6 +14,24 @@ export interface ToolResultTruncation {
 
 const OMITTED_MARKER = "[... omitted tool-result section ...]";
 
+const collect = (
+  candidates: string[],
+  maxEntries: number,
+  maxContentBytes: number
+) => {
+  const selected: string[] = [];
+  let used = 0;
+  for (const line of candidates.slice(0, maxEntries)) {
+    const next = used + byteLength(line) + (selected.length ? 1 : 0);
+    if (next > maxContentBytes) {
+      break;
+    }
+    selected.push(line);
+    used = next;
+  }
+  return selected;
+};
+
 export const capToolResult = (
   value: string,
   maxLines = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES,
@@ -53,23 +71,6 @@ export const capToolResult = (
   }
   const headCount = Math.floor((maxLines - 1) / 2);
   const tailCount = maxLines - 1 - headCount;
-  const collect = (
-    candidates: string[],
-    maxEntries: number,
-    maxContentBytes: number
-  ) => {
-    const selected: string[] = [];
-    let used = 0;
-    for (const line of candidates.slice(0, maxEntries)) {
-      const next = used + byteLength(line) + (selected.length ? 1 : 0);
-      if (next > maxContentBytes) {
-        break;
-      }
-      selected.push(line);
-      used = next;
-    }
-    return selected;
-  };
   const availableBytes = maxBytes - markerBytes - 2;
   const head = collect(lines, headCount, Math.floor(availableBytes / 2));
   const tail = collect(

package/src/tools/consult-context.ts

@@ -1,9 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  readTrackedFiles,
-  readUntrackedFiles,
-  type UntrackedAttachment,
-} from "../attachments.ts";
+
+import { readTrackedFiles, readUntrackedFiles } from "../attachments.ts";
+import type { UntrackedAttachment } from "../attachments.ts";
 import {
   advisorGitContextMaxCharsRef,
   advisorGitContextRef,
@@ -13,19 +11,13 @@ import {
   advisorUntrackedContentRef,
   contextMaxCharsRef,
 } from "../config/state.ts";
-import {
-  clampGitContextLevel,
-  collectGitContext,
-  type GitContextLevel,
-} from "../git.ts";
+import { clampGitContextLevel, collectGitContext } from "../git.ts";
+import type { GitContextLevel } from "../git.ts";
 import { readProjectPreferences } from "../preferences.ts";
 import { redactAndCapText, redactSecrets } from "../redaction.ts";
-import {
-  runAdvisorScout,
-  type ScoutLifecycleEvent,
-  type ScoutOutcome,
-} from "../scout.ts";
 import { curateAdvisorConversation } from "../scout-curation.ts";
+import { runAdvisorScout } from "../scout.ts";
+import type { ScoutLifecycleEvent, ScoutOutcome } from "../scout.ts";
 import {
   advisorGitContextBudget,
   advisorRepositoryContext,

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

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Fetch } from "@typesafe-ai/sdk";
+
 import {
   advisorJevFilterEnabledRef,
   advisorJevFilterNoulMarginRef,
@@ -14,7 +15,8 @@ import {
   screeningQuestions,
 } from "../jev/questions.ts";
 import { buildJevState } from "../jev/state.ts";
-import { type JevCredentials, resolveJevTransport } from "../jev/transport.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";
 
@@ -42,7 +44,7 @@ export interface ScreeningDeps {
 }
 
 export const normalizeScreeningQuestion = (question: string | undefined) =>
-  question?.trim().toLowerCase().replace(/\s+/g, " ") || undefined;
+  question?.trim().toLowerCase().replaceAll(/\s+/gu, " ") || undefined;
 
 const REATTACHED_ADVICE_CAP_BYTES = 4 * 1024;
 
@@ -64,45 +66,6 @@ export const resetJevOutageNotification = outageNotifier.reset;
 
 const allow = (): ScreeningOutcome => ({ decision: "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);
-};
-
 const bypassOutcome = (
   session: AdvisorSessionState,
   options: ScreenConsultationOptions,
@@ -193,6 +156,45 @@ const screenWithJev = async (
   }
 };
 
+/**
+ * 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;

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

@@ -1,5 +1,9 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionContext,
+  TurnEndEvent,
+} from "@earendil-works/pi-coding-agent";
 import type { Fetch } from "@typesafe-ai/sdk";
+
 import {
   advisorJevTurnGateEveryTurnsRef,
   advisorJevTurnGateNoulThresholdRef,
@@ -10,11 +14,13 @@ 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 { type JevCredentials, resolveJevTransport } from "../jev/transport.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 = {
@@ -34,6 +40,17 @@ export interface JevTurnGateDeps {
   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;
@@ -41,7 +58,7 @@ export interface JevTurnGateRegistration {
   send: (message: {
     content: string;
     customType: string;
-    details: Record<string, unknown>;
+    details: TurnGateCallDetails | TurnGateResultDetails;
     display: boolean;
   }) => void;
   session: AdvisorSessionState;
@@ -81,6 +98,7 @@ export const handleJevTurnEnd = async (
     isSimpleMode() ||
     session.blocked ||
     !registration.activeTools().includes("ask_advisor") ||
+    !advisorModelIsAllowed(ctx) ||
     !session.canConsult(getAdvisorMaxCallsPerSession())
   ) {
     return;
@@ -171,13 +189,15 @@ export const handleJevTurnEnd = async (
   }
 };
 
+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 = <T extends string>(
-  on: (
-    event: T,
-    handler: (event: unknown, ctx: ExtensionContext) => unknown
-  ) => void,
+export const registerJevTurnGate = (
+  on: TurnEndRegistrar,
   registration: JevTurnGateRegistration
 ): void => {
-  on("turn_end" as T, (_event, ctx) => handleJevTurnEnd(registration, ctx));
+  on("turn_end", (_event, ctx) => handleJevTurnEnd(registration, ctx));
 };