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

package/src/tools/loop-gate.ts

@@ -15,7 +15,8 @@ import {
   isSimpleMode,
 } from "../config/state.ts";
 import type { GateFailureMode } from "../config/types.ts";
-import { herdrAdvisorActivity } from "../herdr.ts";
+import { herdrAdvisorActivity, herdrAdvisorBlock } from "../herdr.ts";
+import type { HerdrAdvisorActivityScope, HerdrAdvisorBlock } from "../herdr.ts";
 import type { AdvisorSessionState, GateDecision } from "../session-state.ts";
 import { advisorUsageCost, snapshotAdvisorUsage } from "../usage.ts";
 import type { AdvisorUsageSnapshot } from "../usage.ts";
@@ -106,7 +107,8 @@ const applyGateDecision = (
   session: AdvisorSessionState,
   result: Awaited<ReturnType<typeof runAdvisorGate>>,
   reason: string,
-  failureMode: GateFailureMode
+  failureMode: GateFailureMode,
+  herdrBlock: HerdrAdvisorBlock
 ): ToolCallEventResult | undefined => {
   if (!result.ok) {
     session.recordInvocation({
@@ -123,7 +125,8 @@ const applyGateDecision = (
       result.message,
       ctx,
       session,
-      failureMode
+      failureMode,
+      herdrBlock
     );
     sendAutomaticGateFailure(
       pi,
@@ -151,7 +154,13 @@ const applyGateDecision = (
   }
   const gateReason = `Advisor loop review: ${result.markdown}`;
   if (result.decision === "blocked") {
-    const effect = blockedDecisionEffect(gateReason, ctx, session, failureMode);
+    const effect = blockedDecisionEffect(
+      gateReason,
+      ctx,
+      session,
+      failureMode,
+      herdrBlock
+    );
     return effect.block ? { block: true, reason: effect.reason } : undefined;
   }
   return { block: true, reason: gateReason };
@@ -163,7 +172,9 @@ export const handleAutomaticGate = async (
   ctx: ExtensionContext,
   session: AdvisorSessionState,
   runGate: typeof runAdvisorGate,
-  scoutStatus: ScoutStatusManager
+  scoutStatus: ScoutStatusManager,
+  herdrActivity: HerdrAdvisorActivityScope = herdrAdvisorActivity,
+  herdrBlock: HerdrAdvisorBlock = herdrAdvisorBlock
 ): Promise<ToolCallEventResult | undefined> => {
   if (
     isSimpleMode() ||
@@ -186,13 +197,14 @@ export const handleAutomaticGate = async (
       "Advisor gate call budget is exhausted.",
       ctx,
       session,
-      failureMode
+      failureMode,
+      herdrBlock
     );
     return failure.block ? { block: true, reason: failure.reason } : undefined;
   }
   session.consumeCall();
   session.resetTurnsSinceConsultation();
-  herdrAdvisorActivity.start();
+  const finishHerdrActivity = herdrActivity.start();
   let scoutDetails: ScoutToolDetails | undefined;
   const scoutStatusToken = Symbol("automatic-gate-scout");
   scoutStatus.register(scoutStatusToken);
@@ -203,10 +215,10 @@ export const handleAutomaticGate = async (
       gateCallSent = true;
     }
   };
-  if (!advisorScoutEnabledRef) {
-    ensureGateCall();
-  }
   try {
+    if (!advisorScoutEnabledRef) {
+      ensureGateCall();
+    }
     const result = await runGate(
       ctx,
       `${reason} Review the repeated actions and recommend the smallest safe next step.`,
@@ -223,9 +235,17 @@ export const handleAutomaticGate = async (
       event.toolCallId
     );
     ensureGateCall();
-    return applyGateDecision(pi, ctx, session, result, reason, failureMode);
+    return applyGateDecision(
+      pi,
+      ctx,
+      session,
+      result,
+      reason,
+      failureMode,
+      herdrBlock
+    );
   } finally {
+    finishHerdrActivity();
     scoutStatus.release(ctx, scoutStatusToken);
-    herdrAdvisorActivity.finish();
   }
 };

package/src/tools/register-ask-advisor.ts

@@ -10,7 +10,7 @@ import {
   getAdvisorSettings,
   isSimpleMode,
 } from "../config/state.ts";
-import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "../herdr.ts";
+import { notifyHerdrAdvisorFailure } from "../herdr.ts";
 import {
   ADVISOR_STREAM_UPDATE_INTERVAL_MS,
   createCoalescedUpdate,
@@ -63,6 +63,7 @@ const claimTrackedHandoff = (
 
 export const registerAskAdvisorTool = ({
   consult: requestAdvisor,
+  herdrActivity,
   pi,
   reservedCalls,
   screen,
@@ -72,162 +73,198 @@ export const registerAskAdvisorTool = ({
     description:
       "Consult the on-demand Advisor model for strategic guidance. Call with an empty object for a contextual review; attach an optional draft for concrete plan or completion review. If the Advisor explicitly names a missing file, you may make a sequential follow-up call with includeTrackedFiles when enabled and relevant.",
     async execute(_id, params, signal, onUpdate, ctx) {
-      reservedCalls.delete(_id);
-      assertAdvisorModelAccess(ctx);
-      // The budget check precedes the handoff claim so a rejected call never
-      // consumes the one-shot tracked-file handoff.
+      try {
+        assertAdvisorModelAccess(ctx);
+      } catch (error) {
+        session.releaseCall(_id);
+        reservedCalls.delete(_id);
+        throw error;
+      }
+      const simpleMode = isSimpleMode();
       if (
-        !(isSimpleMode() || session.canConsult(getAdvisorMaxCallsPerSession()))
+        !simpleMode &&
+        !session.reserveCall(_id, getAdvisorMaxCallsPerSession())
       ) {
         throw new Error("Advisor call budget exhausted for this session.");
       }
-      // The Jev screening seam sits after the budget re-check and before the
-      // handoff claim: a skipped call consumes neither the one-shot handoff
-      // nor the budget.
-      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,
-          },
-        };
+      if (simpleMode) {
+        session.releaseCall(_id);
+        reservedCalls.delete(_id);
+      } else {
+        reservedCalls.add(_id);
       }
-      claimTrackedHandoff(session, params.includeTrackedFiles);
-      if (!isSimpleMode()) {
-        session.consumeCall();
-        session.resetTurnsSinceConsultation();
-      }
-      herdrAdvisorActivity.start();
-      let scoutDetails: AdvisorToolDetails["scout"];
-      const coalescedUpdate = createCoalescedUpdate(
-        (update: Parameters<NonNullable<typeof onUpdate>>[0]) =>
-          onUpdate?.(update),
-        ADVISOR_STREAM_UPDATE_INTERVAL_MS
-      );
-      const flushUpdate = () => {
-        const result = coalescedUpdate.flush();
-        if (result.failed) {
-          throw result.error;
-        }
-      };
+      let normalizedQuestion: string | undefined;
       try {
-        const result = await requestAdvisor(
-          ctx,
-          resolveAdvisorRequest(params.question),
-          signal,
-          (t, tx) =>
-            coalescedUpdate.update({
-              content: [{ text: tx, type: "text" }],
-              details: {
-                advisor: advisorRef,
-                question: resolveAdvisorRequest(params.question),
-                scout: scoutDetails,
-                text: tx,
-                thinking: t,
-              },
-            }),
-          "executor-requested",
-          // "none" is the model declining repository context for this call.
-          params.gitContext === "none" ? "off" : params.gitContext,
-          params.draft,
-          params.includeUntracked,
-          params.includeTrackedFiles,
-          (event) => {
-            scoutDetails = scoutDetailsFromEvent(event, scoutDetails);
-            coalescedUpdate.update({
-              content: [{ text: scoutDetails.text ?? "", type: "text" }],
-              details: {
-                advisor: advisorRef,
-                question: resolveAdvisorRequest(params.question),
-                scout: scoutDetails,
-              },
-            });
-          },
-          _id
-        );
-        flushUpdate();
-        session.issueAdvice(
-          result.adviceId,
-          result.markdown,
-          result.trigger,
-          Boolean(result.draftBytes),
-          normalizedQuestion
+        if (
+          !simpleMode &&
+          !session.canConsult(getAdvisorMaxCallsPerSession(), _id)
+        ) {
+          throw new Error("Advisor call budget exhausted for this session.");
+        }
+        // The Jev screening seam sits before the handoff claim: a skipped call
+        // consumes neither the one-shot handoff nor the budget.
+        normalizedQuestion = normalizeScreeningQuestion(
+          resolveAdvisorRequest(params.question)
         );
-        session.recordInvocation({
-          cost: advisorUsageCost(result.usage),
-          executionEffect: "continued",
-          kind: "markdown",
-          model: result.model,
-          trigger: "executor-requested",
-          usage: result.usage,
-        });
-        const usage = snapshotAdvisorUsage(result.usage);
-        const piUsage = advisorUsageForPi(result.usage);
-        updateAdvisorUsageStatus(ctx, session);
-        const details: AdvisorToolDetails = {
-          adviceId: result.adviceId,
-          advisor: result.model,
-          draftBytes: result.draftBytes,
-          preferenceBytes: result.preferenceBytes,
+        const screening = await screen(ctx, session, {
+          draft: params.draft,
+          force: params.force,
           question: resolveAdvisorRequest(params.question),
-          scout: scoutDetails,
-          text: result.markdown,
-          thinking: result.thinkingText,
-          trackedBytes: result.trackedBytes,
-          untrackedBytes: result.untrackedBytes,
-        };
-        if (usage) {
-          details.usage = usage;
-        }
-        const response: AgentToolResult<AdvisorToolDetails> = {
-          content: [
-            {
-              text: `Advisor (${result.model})\n\n${result.markdown}`,
-              type: "text",
+          signal,
+        });
+        if (screening.decision === "skip") {
+          const skipText = screeningSkipText(screening);
+          session.releaseCall(_id);
+          reservedCalls.delete(_id);
+          return {
+            content: [{ text: skipText, type: "text" }],
+            details: {
+              jev: {
+                kind: screening.kind,
+                reason: screening.reason,
+                skipped: true,
+              },
+              text: skipText,
             },
-          ],
-          details,
-        };
-        if (piUsage) {
-          response.usage = piUsage;
+          };
+        }
+        if (
+          !simpleMode &&
+          !session.canConsult(getAdvisorMaxCallsPerSession(), _id)
+        ) {
+          throw new Error("Advisor call budget exhausted for this session.");
+        }
+        claimTrackedHandoff(session, params.includeTrackedFiles);
+        if (!simpleMode) {
+          session.consumeCall(_id);
+          reservedCalls.delete(_id);
+          session.resetTurnsSinceConsultation();
         }
-        return response;
       } catch (error) {
-        // Publish the latest partial state before surfacing a provider or
-        // execution error. A failure from the UI sink must not replace the
-        // original error because this path is also used for provider failures.
-        coalescedUpdate.flush();
-        const message = error instanceof Error ? error.message : String(error);
-        session.recordInvocation({
-          executionEffect: "continued",
-          failure: "provider-error",
-          kind: "markdown",
-          model: advisorRef,
-          trigger: "executor-requested",
-        });
-        updateAdvisorUsageStatus(ctx, session);
-        notifyLocalFailure(ctx, message);
-        notifyHerdrAdvisorFailure("Advisor consultation failed", message);
+        session.releaseCall(_id);
+        reservedCalls.delete(_id);
         throw error;
-      } finally {
-        coalescedUpdate.cancel();
-        herdrAdvisorActivity.finish();
       }
+      const runConsultation = async () => {
+        let scoutDetails: AdvisorToolDetails["scout"];
+        const coalescedUpdate = createCoalescedUpdate(
+          (update: Parameters<NonNullable<typeof onUpdate>>[0]) =>
+            onUpdate?.(update),
+          ADVISOR_STREAM_UPDATE_INTERVAL_MS
+        );
+        const flushUpdate = () => {
+          const result = coalescedUpdate.flush();
+          if (result.failed) {
+            throw result.error;
+          }
+        };
+        const finishHerdrActivity = herdrActivity.start();
+        try {
+          const result = await requestAdvisor(
+            ctx,
+            resolveAdvisorRequest(params.question),
+            signal,
+            (t, tx) =>
+              coalescedUpdate.update({
+                content: [{ text: tx, type: "text" }],
+                details: {
+                  advisor: advisorRef,
+                  question: resolveAdvisorRequest(params.question),
+                  scout: scoutDetails,
+                  text: tx,
+                  thinking: t,
+                },
+              }),
+            "executor-requested",
+            // "none" is the model declining repository context for this call.
+            params.gitContext === "none" ? "off" : params.gitContext,
+            params.draft,
+            params.includeUntracked,
+            params.includeTrackedFiles,
+            (event) => {
+              scoutDetails = scoutDetailsFromEvent(event, scoutDetails);
+              coalescedUpdate.update({
+                content: [{ text: scoutDetails.text ?? "", type: "text" }],
+                details: {
+                  advisor: advisorRef,
+                  question: resolveAdvisorRequest(params.question),
+                  scout: scoutDetails,
+                },
+              });
+            },
+            _id
+          );
+          flushUpdate();
+          session.issueAdvice(
+            result.adviceId,
+            result.markdown,
+            result.trigger,
+            Boolean(result.draftBytes),
+            normalizedQuestion
+          );
+          session.recordInvocation({
+            cost: advisorUsageCost(result.usage),
+            executionEffect: "continued",
+            kind: "markdown",
+            model: result.model,
+            trigger: "executor-requested",
+            usage: result.usage,
+          });
+          const usage = snapshotAdvisorUsage(result.usage);
+          const piUsage = advisorUsageForPi(result.usage);
+          updateAdvisorUsageStatus(ctx, session);
+          const details: AdvisorToolDetails = {
+            adviceId: result.adviceId,
+            advisor: result.model,
+            draftBytes: result.draftBytes,
+            preferenceBytes: result.preferenceBytes,
+            question: resolveAdvisorRequest(params.question),
+            scout: scoutDetails,
+            text: result.markdown,
+            thinking: result.thinkingText,
+            trackedBytes: result.trackedBytes,
+            untrackedBytes: result.untrackedBytes,
+          };
+          if (usage) {
+            details.usage = usage;
+          }
+          const response: AgentToolResult<AdvisorToolDetails> = {
+            content: [
+              {
+                text: `Advisor (${result.model})\n\n${result.markdown}`,
+                type: "text",
+              },
+            ],
+            details,
+          };
+          if (piUsage) {
+            response.usage = piUsage;
+          }
+          return response;
+        } catch (error) {
+          // Publish the latest partial state before surfacing a provider or
+          // execution error. A failure from the UI sink must not replace the
+          // original error because this path is also used for provider failures.
+          coalescedUpdate.flush();
+          const message =
+            error instanceof Error ? error.message : String(error);
+          session.recordInvocation({
+            executionEffect: "continued",
+            failure: "provider-error",
+            kind: "markdown",
+            model: advisorRef,
+            trigger: "executor-requested",
+          });
+          updateAdvisorUsageStatus(ctx, session);
+          notifyLocalFailure(ctx, message);
+          notifyHerdrAdvisorFailure("Advisor consultation failed", message);
+          throw error;
+        } finally {
+          finishHerdrActivity();
+          coalescedUpdate.cancel();
+        }
+      };
+      return runConsultation();
     },
     label: "Ask Advisor",
     name: "ask_advisor",

package/src/tools/register-lifecycle.ts

@@ -4,7 +4,6 @@ import {
   isSimpleMode,
 } from "../config/state.ts";
 import { loadConfig } from "../config/storage.ts";
-import { herdrAdvisorBlock } from "../herdr.ts";
 import { reserveAdvisorCall } from "./gate-policy.ts";
 import { handleAutomaticGate } from "./loop-gate.ts";
 import { advisorModelAccess } from "./model-access.ts";
@@ -26,6 +25,8 @@ const modelAccessBlock = (
 };
 
 export const registerToolLifecycle = ({
+  herdrActivity,
+  herdrBlock,
   pi,
   reservedCalls,
   runGate,
@@ -61,7 +62,7 @@ export const registerToolLifecycle = ({
   pi.on("session_start", (_event, ctx) => {
     session.resetTask();
     reservedCalls.clear();
-    herdrAdvisorBlock.clear();
+    herdrBlock.clear();
     if (ctx?.hasUI) {
       ctx.ui.setStatus("advisor-usage", undefined);
     }
@@ -114,13 +115,23 @@ export const registerToolLifecycle = ({
     if (event.toolName === "ask_advisor") {
       return reservation;
     }
-    return handleAutomaticGate(pi, event, ctx, session, runGate, scoutStatus);
+    return handleAutomaticGate(
+      pi,
+      event,
+      ctx,
+      session,
+      runGate,
+      scoutStatus,
+      herdrActivity,
+      herdrBlock
+    );
   });
 
   pi.on("agent_settled", (_event, ctx) => {
     // Any reservation still present never reached execute (for example because
     // another handler blocked it or the turn was aborted).
     reservedCalls.clear();
+    session.clearCallReservations();
     if (isSimpleMode() || session.blocked || !advisorSessionSummaryRef) {
       return;
     }
@@ -132,8 +143,9 @@ export const registerToolLifecycle = ({
 
   pi.on("session_shutdown", (_event, ctx) => {
     reservedCalls.clear();
+    session.clearCallReservations();
     scoutStatus.clear(ctx);
-    herdrAdvisorBlock.clear();
+    herdrBlock.clear();
     if (ctx?.hasUI) {
       ctx.ui.setStatus("advisor-usage", undefined);
     }

package/src/tools/registration.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
+import { herdrAdvisorActivity, herdrAdvisorBlock } from "../herdr.ts";
 import { appendOutcome } from "../outcomes.ts";
 import type { AdvisorSessionState } from "../session-state.ts";
 import { consultAdvisor, runAdvisorGate } from "./consultation.ts";
@@ -25,6 +26,8 @@ export const registerAdvisorTool = (
   const registration: ToolRegistrationContext = {
     appendOutcome: dependencies.appendOutcome ?? appendOutcome,
     consult: dependencies.consult ?? consultAdvisor,
+    herdrActivity: dependencies.herdrActivity ?? herdrAdvisorActivity,
+    herdrBlock: dependencies.herdrBlock ?? herdrAdvisorBlock,
     pi,
     reservedCalls: new Set<string>(),
     runGate: dependencies.runGate ?? runAdvisorGate,
@@ -40,6 +43,7 @@ export const registerAdvisorTool = (
   const turnGate: JevTurnGateRegistration = {
     activeTools: () => pi.getActiveTools(),
     consult: registration.consult,
+    herdrActivity: registration.herdrActivity,
     send: (message) => pi.sendMessage(message, { deliverAs: "steer" }),
     session,
   };

package/src/tools/types.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
+import type { HerdrAdvisorActivityScope, HerdrAdvisorBlock } from "../herdr.ts";
 import type { appendOutcome } from "../outcomes.ts";
 import type { ScoutOutcome } from "../scout.ts";
 import type {
@@ -112,6 +113,8 @@ export interface AdvisorToolContext {
 export interface ToolRegistrationContext {
   appendOutcome: typeof appendOutcome;
   consult: typeof consultAdvisor;
+  herdrActivity: HerdrAdvisorActivityScope;
+  herdrBlock: HerdrAdvisorBlock;
   pi: ExtensionAPI;
   reservedCalls: Set<string>;
   runGate: typeof runAdvisorGate;
@@ -123,6 +126,8 @@ export interface ToolRegistrationContext {
 export interface ToolRegistrationDependencies {
   appendOutcome?: typeof appendOutcome;
   consult?: typeof consultAdvisor;
+  herdrActivity?: HerdrAdvisorActivityScope;
+  herdrBlock?: HerdrAdvisorBlock;
   runGate?: typeof runAdvisorGate;
   screen?: typeof screenConsultation;
   statusManager?: ScoutStatusManager;

package/src/ui/jev-setup-submenu.ts

@@ -214,7 +214,9 @@ export class JevSetupSubmenu implements Component, Focusable {
 
   private actions(): SetupAction[] {
     if (!this.credentials) {
-      return ["enter-key", "done"];
+      return this.options.currentValue === "On"
+        ? ["enter-key", "disable", "done"]
+        : ["enter-key", "done"];
     }
     const enabled = this.options.currentValue === "On";
     const actions: SetupAction[] = [enabled ? "verify-again" : "verify-enable"];
@@ -277,8 +279,12 @@ export class JevSetupSubmenu implements Component, Focusable {
       return;
     }
     const result = await clear();
-    this.credentials = undefined;
     this.notice = result.message;
+    if (!result.ok) {
+      this.options.tui.requestRender();
+      return;
+    }
+    this.credentials = undefined;
     this.options.done("Off");
   }