pi-advisor-flow 0.5.6 → 0.7.0

package/src/config/storage.ts

@@ -5,43 +5,16 @@ import {
   type ExtensionContext,
   getAgentDir,
 } from "@earendil-works/pi-coding-agent";
-import { applyConfig, resetDefaults } from "./defaults.js";
+import { applyConfig, resetDefaults } from "./defaults.ts";
 import {
-  advisorAutoLoopGateRef,
-  advisorBlockOnBlockedRef,
-  advisorCollapseResponsesRef,
-  advisorCompletionGateRef,
-  advisorCustomInvocationRef,
-  advisorEffortRef,
-  advisorFailureGateRef,
-  advisorFailureModeRef,
-  advisorGitContextMaxCharsRef,
-  advisorGitContextRef,
-  advisorHerdrIntegrationRef,
-  advisorLoopThresholdRef,
-  advisorMaxCallsPerSessionRef,
-  advisorPlanGateRef,
-  advisorRedactSecretsRef,
-  advisorRef,
-  advisorScoutEnabledRef,
-  advisorSessionSummaryRef,
-  advisorToolPoliciesRef,
-  advisorToolResultMaxBytesRef,
-  advisorToolResultMaxLinesRef,
-  advisorTrackedFileContentRef,
-  advisorUntrackedContentRef,
-  alwaysOnRef,
-  contextMaxCharsRef,
-  executorEffortRef,
-  executorRef,
-  setAdvisorOutcomeLoggingRef,
-  setPersistedModelRefs,
-  showUsageDetailsRef,
-  showUsageFooterRef,
-  simpleModeRef,
-} from "./state.js";
-import type { AdvisorConfig } from "./types.js";
-import { unknownConfigKeys, validateConfig } from "./validation.js";
+  CONFIG_SCHEMA,
+  configuredModelRef,
+  type PersistedConfigKey,
+  SAVED_CONFIG_KEYS,
+} from "./schema.ts";
+import { setAdvisorOutcomeLoggingRef, setPersistedModelRefs } from "./state.ts";
+import type { AdvisorConfig } from "./types.ts";
+import { unknownConfigKeys, validateConfig } from "./validation.ts";
 
 export const configPaths = (ctx: ExtensionContext) => [
   ctx.isProjectTrusted()
@@ -50,83 +23,25 @@ export const configPaths = (ctx: ExtensionContext) => [
   join(getAgentDir(), "advisor.json"),
 ];
 
-const configuredModelRef = (value: string | undefined): string | undefined =>
-  value?.trim() || undefined;
-
-const SAVED_CONFIG_KEYS = [
-  "advisor",
-  "advisorAutoLoopGate",
-  "advisorBlockOnBlocked",
-  "advisorCollapseResponses",
-  "advisorCompletionGate",
-  "advisorCustomInvocation",
-  "advisorEffort",
-  "advisorFailureGate",
-  "advisorGitContext",
-  "advisorGitContextMaxChars",
-  "advisorHerdrIntegration",
-  "advisorLoopThreshold",
-  "advisorMaxCallsPerSession",
-  "advisorPlanGate",
-  "advisorRedactSecrets",
-  "advisorScoutEnabled",
-  "advisorSessionSummary",
-  "advisorToolPolicies",
-  "advisorToolResultMaxBytes",
-  "advisorToolResultMaxLines",
-  "advisorTrackedFileContent",
-  "advisorUntrackedContent",
-  "alwaysOn",
-  "contextMaxChars",
-  "executor",
-  "executorEffort",
-  "gateFailureMode",
-  "showUsageDetails",
-  "showUsageFooter",
-  "simpleMode",
-] as const satisfies readonly (keyof AdvisorConfig)[];
-type SavedConfigKey = (typeof SAVED_CONFIG_KEYS)[number];
+type SavedConfigKey = PersistedConfigKey;
 type ConfigState = {
   [Key in SavedConfigKey]: AdvisorConfig[Key];
 };
 
-const currentConfigState = (): ConfigState => ({
-  advisor: configuredModelRef(advisorRef),
-  advisorAutoLoopGate: advisorAutoLoopGateRef,
-  advisorBlockOnBlocked: advisorBlockOnBlockedRef,
-  advisorCollapseResponses: advisorCollapseResponsesRef,
-  advisorCompletionGate: advisorCompletionGateRef,
-  advisorCustomInvocation: advisorCustomInvocationRef,
-  advisorEffort: advisorEffortRef,
-  advisorFailureGate: advisorFailureGateRef,
-  advisorGitContext: advisorGitContextRef,
-  advisorGitContextMaxChars: advisorGitContextMaxCharsRef,
-  advisorHerdrIntegration: advisorHerdrIntegrationRef,
-  advisorLoopThreshold: advisorLoopThresholdRef,
-  advisorMaxCallsPerSession: advisorMaxCallsPerSessionRef,
-  advisorPlanGate: advisorPlanGateRef,
-  advisorRedactSecrets: advisorRedactSecretsRef,
-  advisorScoutEnabled: advisorScoutEnabledRef,
-  advisorSessionSummary: advisorSessionSummaryRef,
-  advisorToolPolicies: { ...advisorToolPoliciesRef },
-  advisorToolResultMaxBytes: advisorToolResultMaxBytesRef,
-  advisorToolResultMaxLines: advisorToolResultMaxLinesRef,
-  advisorTrackedFileContent: advisorTrackedFileContentRef,
-  advisorUntrackedContent: advisorUntrackedContentRef,
-  alwaysOn: alwaysOnRef,
-  contextMaxChars: contextMaxCharsRef,
-  executor: configuredModelRef(executorRef),
-  executorEffort: executorEffortRef,
-  gateFailureMode: advisorFailureModeRef,
-  showUsageDetails: showUsageDetailsRef,
-  showUsageFooter: showUsageFooterRef,
-  simpleMode: simpleModeRef,
-});
+const currentConfigState = (): ConfigState =>
+  Object.fromEntries(
+    SAVED_CONFIG_KEYS.map((key) => [key, CONFIG_SCHEMA[key].current()])
+  ) as ConfigState;
 
 const sameConfigValue = <Value>(left: Value, right: Value) =>
   JSON.stringify(left) === JSON.stringify(right);
 
-const readExistingConfig = (path: string): Record<string, unknown> => {
+/** Keys advisor.json may hold that are not AdvisorConfig settings but are
+ * still legitimate (hand-placed secrets). They stay out of CONFIG_SCHEMA, are
+ * preserved like any unknown key, and never trigger the typo warning. */
+const RESERVED_ADVISOR_JSON_KEYS = new Set(["typesafe_api_key"]);
+
+export const readExistingConfig = (path: string): Record<string, unknown> => {
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed)
@@ -166,25 +81,18 @@ const applyChangedConfigValues = (
   }
 };
 
-// Tracks the runtime state represented by the last successful load/save. A
-// save can then merge fresh disk contents without treating untouched in-memory
-// values as an instruction to overwrite an external edit.
+// Tracks the last load/save state so a later save merges fresh disk contents instead of overwriting an external edit.
 let loadedConfigState: ConfigState | undefined;
 let loadedConfigPath: string | undefined;
 
 const readConfig = (path: string): AdvisorConfig => {
-  try {
-    const config = JSON.parse(readFileSync(path, "utf8"));
-    validateConfig(config, path);
-    return config;
-  } catch (error) {
-    throw error instanceof Error ? error : new Error(String(error));
-  }
+  const config = JSON.parse(readFileSync(path, "utf8"));
+  validateConfig(config, path);
+  return config;
 };
 
-// loadConfig runs on every tool call and every consultation. Caching the parsed
-// file by path and stat identity removes that read and parse from the hot path
-// while still applying the full reset-then-apply sequence on each call.
+// loadConfig runs per tool call and consultation; caching by path and stat
+// identity keeps the parse off the hot path while still reset-applying each call.
 const configCache = new Map<
   string,
   { config: AdvisorConfig; identity: string }
@@ -236,7 +144,7 @@ export const loadConfig = (_ctx: ExtensionContext) => {
     applyConfig(globalConfig);
     const unknownKeys = unknownConfigKeys(
       globalConfig as Record<string, unknown>
-    );
+    ).filter((key) => !RESERVED_ADVISOR_JSON_KEYS.has(key));
     const warningIdentity = `${global}:${configIdentity(global)}`;
     if (
       unknownKeys.length > 0 &&

package/src/config/types.ts

@@ -2,13 +2,31 @@ import {
   DEFAULT_MAX_BYTES,
   DEFAULT_MAX_LINES,
 } from "@earendil-works/pi-coding-agent";
-import type { GitContextLevel } from "../git.js";
+import type { GitContextLevel } from "../git.ts";
 
 export const DEFAULT_CONTEXT_MAX_CHARS = 15_000;
 export const MAX_CONTEXT_MAX_CHARS = Number.MAX_SAFE_INTEGER;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES = DEFAULT_MAX_LINES;
 export const DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES = DEFAULT_MAX_BYTES;
 export const DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS = 20_000;
+export const DEFAULT_JEV_MODEL = "jev-latest";
+// Provisional: the latency benchmark was dropped from scope; revisit if live
+// measurements suggest a different bound.
+export const DEFAULT_JEV_TIMEOUT_MS = 8000;
+export const DEFAULT_JEV_DIGEST_MAX_CHARS = 4000;
+export const DEFAULT_JEV_PRICE_PER_MTOK = 0.042;
+export const DEFAULT_JEV_FILTER_SKIP_CONFIDENCE = 0.85;
+export const DEFAULT_JEV_FILTER_NOUL_MARGIN = 0.35;
+export const DEFAULT_JEV_FILTER_OVERRIDE_WINDOW = 10;
+export const DEFAULT_JEV_TURN_GATE_EVERY_TURNS = 0;
+export const DEFAULT_JEV_TURN_GATE_NOUL_THRESHOLD = 0.8;
+export type JevTransport = "auto" | "typesafe" | "openrouter";
+export const DEFAULT_JEV_TRANSPORT: JevTransport = "auto";
+export const JEV_TRANSPORTS: JevTransport[] = [
+  "auto",
+  "typesafe",
+  "openrouter",
+];
 
 export type AdvisorToolPolicy = "full" | "summary" | "exclude";
 export type AdvisorToolPolicies = Record<string, AdvisorToolPolicy>;
@@ -40,6 +58,17 @@ export interface AdvisorConfig {
   advisorGitContext?: GitContextLevel;
   advisorGitContextMaxChars?: number;
   advisorHerdrIntegration?: boolean;
+  advisorJevDigestMaxChars?: number;
+  advisorJevFilterEnabled?: boolean;
+  advisorJevFilterNoulMargin?: number;
+  advisorJevFilterOverrideWindow?: number;
+  advisorJevFilterSkipConfidence?: number;
+  advisorJevModel?: string;
+  advisorJevPricePerMtok?: number;
+  advisorJevTimeoutMs?: number;
+  advisorJevTransport?: JevTransport;
+  advisorJevTurnGateEveryTurns?: number;
+  advisorJevTurnGateNoulThreshold?: number;
   advisorLoopThreshold?: number;
   advisorMaxCallsPerSession?: number;
   advisorOutcomeLogging?: boolean;

package/src/config/validation.ts

@@ -1,72 +1,29 @@
-import { GIT_CONTEXT_LEVELS, isValidGitContextLevel } from "../git.js";
-import {
-  ADVISOR_TOOL_POLICIES,
-  type AdvisorConfig,
-  GATE_FAILURE_MODES,
-  MAX_CONTEXT_MAX_CHARS,
-} from "./types.js";
-
-const CONFIG_KEYS = new Set<keyof AdvisorConfig>([
-  "advisor",
-  "advisorAutoLoopGate",
-  "advisorBlockOnBlocked",
-  "advisorCollapseResponses",
-  "advisorCompletionGate",
-  "advisorCustomInvocation",
-  "advisorEffort",
-  "advisorFailureGate",
-  "advisorGitContext",
-  "advisorGitContextMaxChars",
-  "advisorHerdrIntegration",
-  "advisorLoopThreshold",
-  "advisorMaxCallsPerSession",
-  "advisorPlanGate",
-  "advisorSessionSummary",
-  "advisorScoutEnabled",
-  "showUsageDetails",
-  "showUsageFooter",
-  "simpleMode",
-  "alwaysOn",
-  "advisorToolResultMaxBytes",
-  "advisorToolResultMaxLines",
-  "advisorTrackedFileContent",
-  "advisorRedactSecrets",
-  "advisorUntrackedContent",
-  "advisorOutcomeLogging",
-  "advisorToolPolicies",
-  "contextMaxChars",
-  "executor",
-  "executorEffort",
-  "gateFailureMode",
-]);
-
-const BOOLEAN_CONFIG_KEYS = [
-  "advisorPlanGate",
-  "advisorFailureGate",
-  "advisorCompletionGate",
-  "advisorCollapseResponses",
-  "advisorBlockOnBlocked",
-  "advisorAutoLoopGate",
-  "advisorSessionSummary",
-  "advisorScoutEnabled",
-  "showUsageDetails",
-  "showUsageFooter",
-  "simpleMode",
-  "alwaysOn",
-  "advisorHerdrIntegration",
-  "advisorTrackedFileContent",
-  "advisorRedactSecrets",
-  "advisorUntrackedContent",
-  "advisorOutcomeLogging",
-] as const;
+import type { ConfigKeySchema } from "./schema.ts";
+import { CONFIG_SCHEMA, type ConfigKey, SCHEMA_BY_KEY } from "./schema.ts";
+import type { AdvisorConfig } from "./types.ts";
+
+// biome-ignore lint/performance/noBarrelFile: re-exports keep the isValid* validators on their historical module for the config facade.
+export {
+  isValidAdvisorToolPolicies,
+  isValidContextMaxChars,
+  isValidGateFailureMode,
+  isValidLoopThreshold,
+  isValidMaxCallsPerSession,
+  isValidToolResultMaxBytes,
+  isValidToolResultMaxLines,
+} from "./schema.ts";
+
+const CONFIG_KEYS = new Set<ConfigKey>(
+  Object.keys(CONFIG_SCHEMA) as ConfigKey[]
+);
+
+const keysOfType = (type: ConfigKeySchema["type"]): readonly ConfigKey[] =>
+  (Object.keys(CONFIG_SCHEMA) as ConfigKey[]).filter(
+    (key) => SCHEMA_BY_KEY[key].type === type
+  );
 
-const STRING_CONFIG_KEYS = [
-  "executor",
-  "advisor",
-  "executorEffort",
-  "advisorEffort",
-  "advisorCustomInvocation",
-] as const;
+const BOOLEAN_CONFIG_KEYS = keysOfType("boolean");
+const STRING_CONFIG_KEYS = keysOfType("string");
 
 type ConfigRecord = Record<string, unknown>;
 
@@ -81,20 +38,12 @@ const invalidConfigValue = (
 };
 
 export const unknownConfigKeys = (config: ConfigRecord) =>
-  Object.keys(config).filter(
-    (key) => !CONFIG_KEYS.has(key as keyof AdvisorConfig)
-  );
+  Object.keys(config).filter((key) => !CONFIG_KEYS.has(key as ConfigKey));
 
 const validateStringValues = (config: ConfigRecord, path: string) => {
   for (const key of STRING_CONFIG_KEYS) {
     if (config[key] !== undefined && typeof config[key] !== "string") {
-      invalidConfigValue(
-        path,
-        key,
-        key === "executor" || key === "advisor"
-          ? "a provider/model string"
-          : "a string"
-      );
+      invalidConfigValue(path, key, SCHEMA_BY_KEY[key].accepted);
     }
   }
 };
@@ -102,91 +51,46 @@ const validateStringValues = (config: ConfigRecord, path: string) => {
 const validateBooleanValues = (config: ConfigRecord, path: string) => {
   for (const key of BOOLEAN_CONFIG_KEYS) {
     if (config[key] !== undefined && typeof config[key] !== "boolean") {
-      invalidConfigValue(path, key, "true or false");
+      invalidConfigValue(path, key, SCHEMA_BY_KEY[key].accepted);
     }
   }
 };
 
-export const isValidAdvisorToolPolicies = (
-  value: unknown
-): value is Record<string, (typeof ADVISOR_TOOL_POLICIES)[number]> => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
+const validateNumericValues = (config: ConfigRecord, path: string) => {
+  for (const key of keysOfType("number")) {
+    const isValid = SCHEMA_BY_KEY[key].validate;
+    if (
+      config[key] !== undefined &&
+      isValid !== undefined &&
+      !isValid(config[key])
+    ) {
+      invalidConfigValue(path, key, SCHEMA_BY_KEY[key].accepted);
+    }
   }
-  return Object.entries(value).every(
-    ([toolName, policy]) =>
-      toolName.trim().length > 0 &&
-      typeof policy === "string" &&
-      ADVISOR_TOOL_POLICIES.includes(
-        policy as (typeof ADVISOR_TOOL_POLICIES)[number]
-      )
-  );
 };
 
-export const isValidContextMaxChars = (value: unknown): value is number =>
-  typeof value === "number" &&
-  Number.isSafeInteger(value) &&
-  value >= 0 &&
-  value <= MAX_CONTEXT_MAX_CHARS;
-
-export const isValidLoopThreshold = (value: unknown): value is number =>
-  typeof value === "number" && Number.isSafeInteger(value) && value >= 2;
-
-export const isValidMaxCallsPerSession = (value: unknown): value is number =>
-  typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-
-export const isValidGateFailureMode = (
-  value: unknown
-): value is (typeof GATE_FAILURE_MODES)[number] =>
-  typeof value === "string" &&
-  GATE_FAILURE_MODES.includes(value as (typeof GATE_FAILURE_MODES)[number]);
-
-export const isValidToolResultMaxLines = (value: unknown): value is number =>
-  typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-
-export const isValidToolResultMaxBytes = (value: unknown): value is number =>
-  typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const validateEnumValues = (config: ConfigRecord, path: string) => {
+  for (const key of keysOfType("enum")) {
+    const isValid = SCHEMA_BY_KEY[key].validate;
+    if (
+      config[key] !== undefined &&
+      isValid !== undefined &&
+      !isValid(config[key])
+    ) {
+      invalidConfigValue(path, key, SCHEMA_BY_KEY[key].accepted);
+    }
+  }
+};
 
-const validateNumericValues = (config: ConfigRecord, path: string) => {
-  const numericRules: [
-    keyof AdvisorConfig,
-    (value: unknown) => boolean,
-    string,
-  ][] = [
-    [
-      "contextMaxChars",
-      isValidContextMaxChars,
-      `a safe integer from 0 through ${MAX_CONTEXT_MAX_CHARS}`,
-    ],
-    [
-      "advisorLoopThreshold",
-      isValidLoopThreshold,
-      "a safe integer of at least 2",
-    ],
-    [
-      "advisorMaxCallsPerSession",
-      isValidMaxCallsPerSession,
-      "a non-negative safe integer",
-    ],
-    [
-      "advisorToolResultMaxLines",
-      isValidToolResultMaxLines,
-      "a non-negative safe integer",
-    ],
-    [
-      "advisorToolResultMaxBytes",
-      isValidToolResultMaxBytes,
-      "a non-negative safe integer",
-    ],
-    [
-      "advisorGitContextMaxChars",
-      isValidToolResultMaxBytes,
-      "a non-negative safe integer",
-    ],
-  ];
-  for (const [key, isValid, description] of numericRules) {
-    if (config[key] !== undefined && !isValid(config[key])) {
-      invalidConfigValue(path, key, description);
+const validateObjectValues = (config: ConfigRecord, path: string) => {
+  for (const key of keysOfType("object")) {
+    const isValid = SCHEMA_BY_KEY[key].validate;
+    if (
+      config[key] !== undefined &&
+      isValid !== undefined &&
+      !isValid(config[key])
+    ) {
+      invalidConfigValue(path, key, SCHEMA_BY_KEY[key].accepted);
     }
   }
 };
@@ -204,31 +108,7 @@ export const validateConfig = (
   validateStringValues(config, path);
   validateBooleanValues(config, path);
   validateNumericValues(config, path);
-  if (
-    config.advisorToolPolicies !== undefined &&
-    !isValidAdvisorToolPolicies(config.advisorToolPolicies)
-  ) {
-    invalidConfigValue(
-      path,
-      "advisorToolPolicies",
-      "a JSON object with non-empty tool names and full, summary, or exclude values"
-    );
-  }
-  if (
-    config.gateFailureMode !== undefined &&
-    !isValidGateFailureMode(config.gateFailureMode)
-  ) {
-    invalidConfigValue(path, "gateFailureMode", GATE_FAILURE_MODES.join(", "));
-  }
-  if (
-    config.advisorGitContext !== undefined &&
-    !isValidGitContextLevel(config.advisorGitContext)
-  ) {
-    invalidConfigValue(
-      path,
-      "advisorGitContext",
-      GIT_CONTEXT_LEVELS.join(", ")
-    );
-  }
+  validateObjectValues(config, path);
+  validateEnumValues(config, path);
   return true;
 };

package/src/config.ts

@@ -1,5 +1,5 @@
 // biome-ignore lint/performance/noBarrelFile: this facade intentionally preserves the public config module contract.
-export { parseArgs } from "./config/args.js";
+export { parseArgs } from "./config/args.ts";
 export {
   advisorAutoLoopGateRef,
   advisorBlockOnBlockedRef,
@@ -68,21 +68,21 @@ export {
   showUsageFooterRef,
   simpleModeRef,
   splitRef,
-} from "./config/state.js";
-export type { SaveConfigOptions } from "./config/storage.js";
+} from "./config/state.ts";
+export type { SaveConfigOptions } from "./config/storage.ts";
 export {
   configPaths,
   loadConfig,
   resetConfigCache,
   saveConfig,
   saveGlobalOutcomeLogging,
-} from "./config/storage.js";
+} from "./config/storage.ts";
 export type {
   AdvisorConfig,
   AdvisorToolPolicies,
   AdvisorToolPolicy,
   GateFailureMode,
-} from "./config/types.js";
+} from "./config/types.ts";
 export {
   ADVISOR_TOOL_POLICIES,
   DEFAULT_ADVISOR_GIT_CONTEXT_MAX_CHARS,
@@ -91,7 +91,7 @@ export {
   DEFAULT_CONTEXT_MAX_CHARS,
   GATE_FAILURE_MODES,
   MAX_CONTEXT_MAX_CHARS,
-} from "./config/types.js";
+} from "./config/types.ts";
 export {
   isValidAdvisorToolPolicies,
   isValidContextMaxChars,
@@ -101,4 +101,4 @@ export {
   isValidToolResultMaxBytes,
   isValidToolResultMaxLines,
   validateConfig,
-} from "./config/validation.js";
+} from "./config/validation.ts";

package/src/content-utils.ts

@@ -0,0 +1,30 @@
+/** Shared untyped-content inspection helpers. */
+
+export type RecordValue = Record<string, unknown>;
+
+export const isRecord = (value: unknown): value is RecordValue =>
+  Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+export const byteLength = (value: string) => Buffer.byteLength(value, "utf8");
+
+export const contentParts = (content: unknown): unknown[] => {
+  if (typeof content === "string") {
+    return [content];
+  }
+  return Array.isArray(content) ? content : [];
+};
+
+/** Longest UTF-8 prefix of `value` within `maxBytes`, in linear time. */
+export const capUtf8Bytes = (value: string, maxBytes: number): string => {
+  let result = "";
+  let used = 0;
+  for (const character of value) {
+    const characterBytes = byteLength(character);
+    if (used + characterBytes > maxBytes) {
+      break;
+    }
+    result += character;
+    used += characterBytes;
+  }
+  return result;
+};