pi-advisor-flow 0.6.0 → 0.8.0

package/src/scout.ts

@@ -1,20 +1,22 @@
 import type { Message } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
 import { executorEffortRef, executorRef } from "./config/state.ts";
-import {
-  type CollectedTextStream,
-  collectTextStream,
-  type ResolvedConfiguredModel,
-  resolveConfiguredModel,
+import { isRecord, isString } from "./content-utils.ts";
+import { collectTextStream, resolveConfiguredModel } from "./model-stream.ts";
+import type {
+  CollectedTextStream,
+  ResolvedConfiguredModel,
 } from "./model-stream.ts";
 import { groupWire } from "./scout-groups.ts";
 import { reconstructScoutConversation } from "./scout-reconstruct.ts";
 import {
   SCOUT_SELECTION_MAX_IDS,
   SCOUT_SYNTHESIS_MAX_BYTES,
-  type ScoutManifest,
 } from "./scout-types.ts";
+import type { ScoutManifest } from "./scout-types.ts";
 import { snapshotAdvisorUsage } from "./usage.ts";
+import type { AdvisorUsageSnapshot } from "./usage.ts";
 
 const SCOUT_TIMEOUT_MS = 30_000;
 
@@ -48,7 +50,7 @@ interface ScoutMetrics {
   latencyMs: number;
   omittedBeforeScout: number;
   selectedCount: number;
-  usage?: unknown;
+  usage?: AdvisorUsageSnapshot;
 }
 
 export interface ScoutSelection {
@@ -100,8 +102,8 @@ const defaultDependencies: ScoutDependencies = {
   collect: collectTextStream,
   resolve: resolveConfiguredModel,
 };
-const byteLength = (value: string) => Buffer.byteLength(value, "utf8");
-const AUTH_ERROR_PATTERN = /api key|auth|login|credential/i;
+const byteLength = (value: string) => Buffer.byteLength(value, "utf-8");
+const AUTH_ERROR_PATTERN = /api key|auth|login|credential/iu;
 
 const manifestMessage = (manifest: ScoutManifest): Message => ({
   content: [
@@ -120,6 +122,9 @@ const manifestMessage = (manifest: ScoutManifest): Message => ({
   timestamp: Date.now(),
 });
 
+const isStringArray = (value: unknown): value is string[] =>
+  Array.isArray(value) && value.every(isString);
+
 export const parseScoutSelection = (
   text: string,
   manifest: ScoutManifest
@@ -133,11 +138,10 @@ export const parseScoutSelection = (
   } catch (error) {
     throw new Error("Scout response is not a JSON object.", { cause: error });
   }
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
+  if (!isRecord(value)) {
     throw new Error("Scout response must be a JSON object.");
   }
-  const record = value as Record<string, unknown>;
-  const keys = Object.keys(record).sort();
+  const keys = Object.keys(value).toSorted();
   if (
     keys.length !== 2 ||
     keys[0] !== "selectedIds" ||
@@ -147,15 +151,10 @@ export const parseScoutSelection = (
       "Scout response must contain only selectedIds and synthesis."
     );
   }
-  if (
-    !(
-      Array.isArray(record.selectedIds) &&
-      record.selectedIds.every((id) => typeof id === "string")
-    )
-  ) {
+  if (!isStringArray(value.selectedIds)) {
     throw new Error("Scout selectedIds must be an array of strings.");
   }
-  const selectedIds = record.selectedIds as string[];
+  const { selectedIds } = value;
   if (new Set(selectedIds).size !== selectedIds.length) {
     throw new Error("Scout selected duplicate group IDs.");
   }
@@ -177,17 +176,17 @@ export const parseScoutSelection = (
   const normalizedIds = manifest.groups
     .filter((group) => retained.has(group.id))
     .map((group) => group.id);
-  if (typeof record.synthesis !== "string") {
-    throw new Error("Scout synthesis must be a string.");
+  if (!isString(value.synthesis)) {
+    throw new TypeError("Scout synthesis must be a string.");
   }
-  if (byteLength(record.synthesis) > SCOUT_SYNTHESIS_MAX_BYTES) {
+  if (byteLength(value.synthesis) > SCOUT_SYNTHESIS_MAX_BYTES) {
     throw new Error(
       `Scout synthesis exceeds ${SCOUT_SYNTHESIS_MAX_BYTES} UTF-8 bytes.`
     );
   }
   return {
     selectedIds: normalizedIds,
-    synthesis: knownSelectedIds.length > 0 ? record.synthesis : "",
+    synthesis: knownSelectedIds.length > 0 ? value.synthesis : "",
   };
 };
 
@@ -212,6 +211,84 @@ const classifyResolutionError = (message: string): ScoutFallbackCategory => {
   return "provider-error";
 };
 
+const setupAbortWatch = (
+  parentSignal: AbortSignal | undefined,
+  timeoutMs: number
+) => {
+  const controller = new AbortController();
+  let timedOut = false;
+  const abortFromParent = () => controller.abort(parentSignal?.reason);
+  parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error("Scout timed out."));
+  }, timeoutMs);
+  timer.unref?.();
+  const { promise: abortPromise, reject: rejectOnAbort } =
+    Promise.withResolvers<never>();
+  const onControllerAbort = () =>
+    rejectOnAbort(controller.signal.reason ?? new Error("Scout aborted."));
+  controller.signal.addEventListener("abort", onControllerAbort, {
+    once: true,
+  });
+  return {
+    abortPromise,
+    controller,
+    teardown: () => {
+      clearTimeout(timer);
+      parentSignal?.removeEventListener("abort", abortFromParent);
+      controller.signal.removeEventListener("abort", onControllerAbort);
+    },
+    wasTimedOut: () => timedOut,
+  };
+};
+
+type ScoutStreamResult =
+  | { ok: true; streamed: CollectedTextStream }
+  | { ok: false; category: ScoutFallbackCategory; message: string };
+
+const streamScoutResponse = async (
+  dependencies: ScoutDependencies,
+  resolved: ResolvedConfiguredModel,
+  manifest: ScoutManifest,
+  parentSignal: AbortSignal | undefined,
+  timeoutMs: number,
+  publish: (event: ScoutLifecycleEvent) => void
+): Promise<ScoutStreamResult> => {
+  const { abortPromise, controller, teardown, wasTimedOut } = setupAbortWatch(
+    parentSignal,
+    timeoutMs
+  );
+  try {
+    const collection = dependencies.collect(resolved, {
+      messages: [manifestMessage(manifest)],
+      onChunk: (thinking, text) => {
+        if (!controller.signal.aborted) {
+          publish({ model: executorRef, text, thinking, type: "chunk" });
+        }
+      },
+      reasoning: executorEffortRef,
+      signal: controller.signal,
+      systemPrompt: SCOUT_SYSTEM,
+    });
+    return {
+      ok: true,
+      streamed: await Promise.race([collection, abortPromise]),
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return wasTimedOut()
+      ? {
+          category: "timeout",
+          message: `Scout timed out after ${timeoutMs} ms.`,
+          ok: false,
+        }
+      : { category: "provider-error", message, ok: false };
+  } finally {
+    teardown();
+  }
+};
+
 export const runAdvisorScout = async (
   ctx: ExtensionContext,
   manifest: ScoutManifest,
@@ -231,7 +308,7 @@ export const runAdvisorScout = async (
   const fallback = (
     category: ScoutFallbackCategory,
     message: string,
-    usage?: unknown
+    usage?: AdvisorUsageSnapshot
   ): ScoutOutcome => {
     const outcome = {
       category,
@@ -266,69 +343,34 @@ export const runAdvisorScout = async (
     return cancelled();
   }
   publish({ model: executorRef, type: "call" });
-  const controller = new AbortController();
-  let timedOut = false;
-  const abortFromParent = () => controller.abort(parentSignal?.reason);
-  parentSignal?.addEventListener("abort", abortFromParent, { once: true });
-  const timer = setTimeout(() => {
-    timedOut = true;
-    controller.abort(new Error("Scout timed out."));
-  }, timeoutMs);
-  timer.unref?.();
-
-  let rejectOnAbort: ((reason?: unknown) => void) | undefined;
-  const onControllerAbort = () =>
-    rejectOnAbort?.(controller.signal.reason ?? new Error("Scout aborted."));
-  const abortPromise = new Promise<never>((_resolve, reject) => {
-    rejectOnAbort = reject;
-    controller.signal.addEventListener("abort", onControllerAbort, {
-      once: true,
-    });
-  });
-  const teardown = () => {
-    clearTimeout(timer);
-    parentSignal?.removeEventListener("abort", abortFromParent);
-    controller.signal.removeEventListener("abort", onControllerAbort);
-  };
 
-  let streamed: CollectedTextStream;
-  try {
-    const collection = dependencies.collect(resolved, {
-      messages: [manifestMessage(manifest)],
-      onChunk: (thinking, text) => {
-        if (!controller.signal.aborted) {
-          publish({ model: executorRef, text, thinking, type: "chunk" });
-        }
-      },
-      reasoning: executorEffortRef,
-      signal: controller.signal,
-      systemPrompt: SCOUT_SYSTEM,
-    });
-    streamed = await Promise.race([collection, abortPromise]);
-  } catch (error) {
-    teardown();
+  const streamed = await streamScoutResponse(
+    dependencies,
+    resolved,
+    manifest,
+    parentSignal,
+    timeoutMs,
+    publish
+  );
+  if (!streamed.ok) {
     if (parentSignal?.aborted) {
       return cancelled();
     }
-    const message = error instanceof Error ? error.message : String(error);
-    return timedOut
-      ? fallback("timeout", `Scout timed out after ${timeoutMs} ms.`)
-      : fallback("provider-error", message);
+    return fallback(streamed.category, streamed.message);
   }
-  teardown();
   if (parentSignal?.aborted) {
     return cancelled();
   }
 
   let selection: ScoutSelection;
   try {
-    selection = parseScoutSelection(streamed.text, manifest);
+    selection = parseScoutSelection(streamed.streamed.text, manifest);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return fallback(
-      streamed.text.trim() ? "invalid-selection" : "empty-response",
+      streamed.streamed.text.trim() ? "invalid-selection" : "empty-response",
       message,
-      snapshotAdvisorUsage(streamed.usage)
+      snapshotAdvisorUsage(streamed.streamed.usage)
     );
   }
 
@@ -346,7 +388,7 @@ export const runAdvisorScout = async (
           .filter((group) => group.required)
           .map((group) => group.id),
       ]).size,
-      usage: snapshotAdvisorUsage(streamed.usage),
+      usage: snapshotAdvisorUsage(streamed.streamed.usage),
     },
     model: executorRef,
     ok: true as const,

package/src/session-state.ts

@@ -1,13 +1,17 @@
+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";
+export type ConsultationTrigger = "manual" | "executor-requested" | "turn-gate";
 export type GateTrigger =
   | "repeated-tool-call"
   | "completion-review"
@@ -26,7 +30,7 @@ export interface AdvisorInvocationRecord {
   usage?: unknown;
 }
 
-const WHITESPACE = /\s/;
+const WHITESPACE = /\s/u;
 const TIMESTAMP_KEYS = new Set([
   "createdat",
   "date",
@@ -36,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));
 
@@ -74,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>";
       }
@@ -97,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;
@@ -119,9 +135,15 @@ interface RepetitionState {
   previousSignature?: string;
 }
 
+interface IssuedAdvice {
+  advice: string;
+  normalizedQuestion?: string;
+  trigger: ConsultationTrigger;
+}
+
 interface AdviceLedger {
   draftConsultations: number;
-  issued: Map<string, { advice: string; trigger: ConsultationTrigger }>;
+  issued: Map<string, IssuedAdvice>;
   lastAdvice?: string;
   outcomes: number;
   pending: Set<string>;
@@ -155,6 +177,9 @@ export class AdvisorSessionState {
   #ledger = freshAdviceLedger();
   #usage = freshUsage();
   #consumedCalls = 0;
+  readonly #jev = new AdvisorJevLedgerState();
+  #sessionTurnOrdinal = 0;
+  #turnsSinceConsultation = 0;
 
   resetTask() {
     this.#repetition = freshRepetition();
@@ -162,6 +187,9 @@ export class AdvisorSessionState {
     this.#ledger = freshAdviceLedger();
     this.#usage = freshUsage();
     this.#consumedCalls = 0;
+    this.#jev.reset();
+    this.#sessionTurnOrdinal = 0;
+    this.#turnsSinceConsultation = 0;
   }
 
   clearBlocked() {
@@ -182,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;
     }
@@ -214,6 +242,26 @@ export class AdvisorSessionState {
     return this.#consumedCalls;
   }
 
+  /** Counts one completed executor turn on both turn counters. The ordinal
+   * feeds the filter override window and summary positions and is never reset
+   * by anything; turnsSinceConsultation resets on every consultation. */
+  recordCompletedTurn() {
+    this.#sessionTurnOrdinal += 1;
+    this.#turnsSinceConsultation += 1;
+  }
+
+  resetTurnsSinceConsultation() {
+    this.#turnsSinceConsultation = 0;
+  }
+
+  get sessionTurnOrdinal() {
+    return this.#sessionTurnOrdinal;
+  }
+
+  get turnsSinceConsultation() {
+    return this.#turnsSinceConsultation;
+  }
+
   /** Returns a copy of cumulative direct Advisor usage for this session. */
   get usageTotals(): AdvisorUsageTotals {
     return { ...this.#usage.totals };
@@ -232,26 +280,45 @@ export class AdvisorSessionState {
     id: string,
     advice: string,
     trigger: ConsultationTrigger,
-    draft = false
+    draft = false,
+    normalizedQuestion?: string
   ) {
-    this.#ledger.issued.set(id, { advice, 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;
     }
   }
+
+  /** Returns earlier advice for an exactly-matching normalized question. */
+  reattachedAdviceFor(
+    normalizedQuestion: string | undefined
+  ): string | undefined {
+    if (!normalizedQuestion) {
+      return undefined;
+    }
+    for (const entry of this.#ledger.issued.values()) {
+      if (entry.normalizedQuestion === normalizedQuestion) {
+        return entry.advice;
+      }
+    }
+    return undefined;
+  }
   claimTrackedFiles(paths: string[]) {
     const advice = this.#ledger.lastAdvice;
     if (!advice || paths.length === 0) {
       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;
@@ -300,7 +367,7 @@ export class AdvisorSessionState {
       (item) => item.kind === "gate"
     );
     return (
-      (["proceed", "revise", "blocked"] as GateDecision[])
+      (["proceed", "revise", "blocked"] as const)
         .map(
           (decision) =>
             [
@@ -321,21 +388,62 @@ export class AdvisorSessionState {
 
   #triggersLine() {
     return (
-      [
-        "manual",
-        "executor-requested",
-        "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"
     );
   }
 
+  recordJevFilterAllowed() {
+    this.#jev.recordFilterAllowed();
+  }
+  recordJevFilterSkipped(repeat: boolean, normalizedQuestion?: string) {
+    this.#jev.recordFilterSkipped(
+      repeat,
+      normalizedQuestion,
+      this.#sessionTurnOrdinal
+    );
+  }
+  get lastJevSkip() {
+    return this.#jev.lastSkip;
+  }
+  recordJevFilterOverride() {
+    this.#jev.recordFilterOverride();
+  }
+  recordJevFilterFailure() {
+    this.#jev.recordFilterFailure();
+  }
+  recordJevFilterUsage(usage: AdvisorJevUsage) {
+    this.#jev.recordFilterUsage(usage);
+  }
+
+  recordJevGateCheck(usage?: AdvisorJevUsage) {
+    this.#jev.recordGateCheck(usage);
+  }
+  recordJevGateConsultation() {
+    this.#jev.recordGateConsultation();
+  }
+  recordJevGateFailure() {
+    this.#jev.recordGateFailure();
+  }
+
   summary(limit: number | undefined) {
     const { invocations, totals } = this.#usage;
-    if (invocations.length === 0 && this.#repetition.interventions === 0) {
+    const jevLines = this.#jev.summaryLines(invocations);
+    if (
+      invocations.length === 0 &&
+      this.#repetition.interventions === 0 &&
+      jevLines.length === 0
+    ) {
       return;
     }
     const markdown = invocations.filter((item) => item.kind === "markdown");
@@ -366,6 +474,7 @@ export class AdvisorSessionState {
       `Loop matching: normalized tool signatures; ${this.#repetition.interventions} gate intervention${this.#repetition.interventions === 1 ? "" : "s"}`,
       `Execution effects: ${effects("tool-blocked")} tool blocked, ${effects("session-blocked")} sessions blocked, ${effects("continued")} continued`,
       `Failures: ${failures.length ? failures.join(", ") : "none"}`,
+      ...jevLines,
     ].join("\n");
   }
 }

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,