pi-advisor-flow 0.7.0 → 0.8.0

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));
 };

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,

package/src/tools/model-access.ts

@@ -0,0 +1,46 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { advisorModelWhitelistRef } from "../config/state.ts";
+
+type AdvisorModelAccess =
+  | { allowed: true; modelRef?: string }
+  | { allowed: false; modelRef?: string; reason: string };
+
+const currentModelRef = (
+  ctx: Pick<ExtensionContext, "model">
+): string | undefined => {
+  const { model } = ctx;
+  return model ? `${model.provider}/${model.id}` : undefined;
+};
+
+export const advisorModelAccess = (
+  ctx: Pick<ExtensionContext, "model">
+): AdvisorModelAccess => {
+  const modelRef = currentModelRef(ctx);
+  if (advisorModelWhitelistRef.length === 0) {
+    return modelRef ? { allowed: true, modelRef } : { allowed: true };
+  }
+  if (modelRef && advisorModelWhitelistRef.includes(modelRef)) {
+    return { allowed: true, modelRef };
+  }
+  const current = modelRef ?? "no current model";
+  const denial: AdvisorModelAccess = {
+    allowed: false,
+    reason: `Advisor calls are restricted to the configured model whitelist (${advisorModelWhitelistRef.join(", ")}). Current model: ${current}.`,
+  };
+  if (modelRef) {
+    denial.modelRef = modelRef;
+  }
+  return denial;
+};
+
+export const advisorModelIsAllowed = (
+  ctx: Pick<ExtensionContext, "model">
+): boolean => advisorModelAccess(ctx).allowed;
+
+export const advisorModelAccessReason = (
+  ctx: Pick<ExtensionContext, "model">
+): string | undefined => {
+  const access = advisorModelAccess(ctx);
+  return access.allowed ? undefined : access.reason;
+};