pi-advisor-flow 0.8.3-dev.3 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.8.3-dev.3",
+  "version": "0.9.0",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "advisor",

package/src/attachments.ts

@@ -14,16 +14,28 @@ export interface UntrackedAttachment {
   text: string;
 }
 
+const imageExtensions = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+]);
+export const imageMime = (path: string) =>
+  imageExtensions.get(path.slice(path.lastIndexOf(".")).toLowerCase());
+export const imageFileCandidate = (path: string) =>
+  Boolean(imageMime(path)) || /\.(?:avif|bmp|heic|svg|tiff?)$/iu.test(path);
+
 const PATH_SEGMENTS = /[\\/]/u;
 
-const within = (root: string, candidate: string) => {
+export const within = (root: string, candidate: string) => {
   const path = relative(root, candidate);
   return path !== "" && !path.startsWith("..") && !path.includes("../");
 };
 const normalizeRelativePath = (root: string, path: string) =>
   relative(root, resolve(root, path));
 
-const normalizeRequestedPath = (root: string, value: string) => {
+export const normalizeRequestedPath = (root: string, value: string) => {
   if (
     !isString(value) ||
     !value ||
@@ -46,7 +58,7 @@ const git = (cwd: string, args: string[]) =>
     windowsHide: true,
   });
 
-const repositoryRoot = (cwd: string) => {
+export const repositoryRoot = (cwd: string) => {
   try {
     return realpath(git(cwd, ["rev-parse", "--show-toplevel"]).trim());
   } catch {
@@ -86,7 +98,7 @@ const tracked = (cwd: string, path: string) => {
   });
 };
 
-const isPermitted = (
+export const isPermitted = (
   root: string,
   path: string,
   kind: "tracked" | "untracked"
@@ -158,7 +170,11 @@ const readFiles = async (
   let total = 0;
   for (const name of requested) {
     const normalizedName = normalizeRequestedPath(root, name);
-    if (!normalizedName || unique.has(normalizedName)) {
+    if (
+      !normalizedName ||
+      unique.has(normalizedName) ||
+      imageFileCandidate(normalizedName)
+    ) {
       continue;
     }
     unique.add(normalizedName);

package/src/commands/activation.ts

@@ -19,6 +19,7 @@ import {
   setExecutorRef,
 } from "../config/state.ts";
 import { saveConfig } from "../config/storage.ts";
+import { sameModelAdvisorDisabled } from "../tools/model-access.ts";
 import {
   loadCommandConfig,
   prepareActivationModels,
@@ -132,12 +133,16 @@ export const activateAdvisor = async (
       "record_advisor_outcome",
     ]);
   }
+  const activeModel = isMarkedSubagent()
+    ? ctx.model
+    : findConfiguredModel(ctx, executorRef);
+  runtime.updateSameModelNotice(ctx, activeModel);
   if (announce) {
     const activeExecutorRef = effectiveExecutorRef(ctx);
     const activeExecutorEffort = effectiveExecutorEffort(ctx);
     notify(
       ctx,
-      `${ADVISOR_ACTIVATION_EXPLANATION}\n\nAdvisor flow ready — Executor: ${activeExecutorRef} (thinking: ${activeExecutorEffort || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
+      `${ADVISOR_ACTIVATION_EXPLANATION}\n\nAdvisor flow ${sameModelAdvisorDisabled(ctx, activeModel) ? "configured" : "ready"} — Executor: ${activeExecutorRef} (thinking: ${activeExecutorEffort || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
       "info"
     );
   }

package/src/commands/lifecycle.ts

@@ -23,12 +23,15 @@ export const registerCommandLifecycle = (
 ) => {
   runtime.pi.on("session_start", async (_event, ctx) => {
     runtime.pendingExecutorModelRef = undefined;
+    runtime.resetSameModelNotice();
     // A malformed advisor.json or a provider auth failure must not reject a
     // lifecycle handler and break session startup.
     try {
       loadConfig(ctx);
       if (alwaysOnRef) {
         await activateAdvisor("", ctx, false);
+      } else {
+        runtime.updateSameModelNotice(ctx);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -37,6 +40,9 @@ export const registerCommandLifecycle = (
   });
 
   runtime.pi.on("model_select", (event, ctx) => {
+    if (!runtime.suppressModelSelectionSync) {
+      runtime.updateSameModelNotice(ctx, event.model);
+    }
     // "restore" replays a stored session model and "cycle" changes the active
     // model without an explicit `/model` choice. Neither should redefine the
     // configured Executor.

package/src/commands/manual-command.ts

@@ -4,7 +4,11 @@ import {
   isSimpleMode,
 } from "../config/state.ts";
 import type { GitContextLevel } from "../git.ts";
-import { advisorModelAccessReason } from "../tools/model-access.ts";
+import {
+  advisorModelAccessReason,
+  sameModelAdvisorDisabled,
+  sameModelAdvisorNotice,
+} from "../tools/model-access.ts";
 import { resolveAdvisorRequest } from "../tools/render-common.ts";
 import { ManualAdvisorDialog } from "../ui/manual-dialog.ts";
 import type { ManualAdvisorRequest } from "../ui/types.ts";
@@ -21,6 +25,10 @@ export const registerManualCommand = (runtime: CommandRuntime) => {
       if (!loadCommandConfig(ctx)) {
         return;
       }
+      if (sameModelAdvisorDisabled(ctx)) {
+        notify(ctx, sameModelAdvisorNotice, "info");
+        return;
+      }
       const accessReason = advisorModelAccessReason(ctx);
       if (accessReason) {
         notify(ctx, accessReason, "warning");
@@ -82,6 +90,10 @@ export const registerManualCommand = (runtime: CommandRuntime) => {
         question = resolveAdvisorRequest(args);
       }
 
+      if (sameModelAdvisorDisabled(ctx)) {
+        notify(ctx, sameModelAdvisorNotice, "info");
+        return;
+      }
       if (!isSimpleMode()) {
         runtime.advisorSessionState.consumeCall();
       }

package/src/commands/model-commands.ts

@@ -57,6 +57,7 @@ export const registerModelCommands = (runtime: CommandRuntime) => {
         persistExecutor: true,
       });
       runtime.pendingExecutorModelRef = undefined;
+      runtime.updateSameModelNotice(ctx);
       ctx.ui.notify(
         `Saved Executor + Advisor configurations to ${path}`,
         "info"

package/src/commands/runtime.ts

@@ -7,6 +7,10 @@ import { getAdvisorSettings } from "../config/state.ts";
 import { herdrAdvisorActivity, notifyHerdrAdvisorFailure } from "../herdr.ts";
 import type { AdvisorSessionState } from "../session-state.ts";
 import { consultAdvisor } from "../tools/consultation.ts";
+import {
+  sameModelAdvisorDisabled,
+  sameModelAdvisorNotice,
+} from "../tools/model-access.ts";
 import { ScoutStatusManager } from "../tools/scout-status.ts";
 import { advisorSessionState as defaultAdvisorSessionState } from "../tools/session.ts";
 import type {
@@ -55,6 +59,7 @@ class CommandRuntime implements CommandRuntimeContract {
   manualProgressSequence = 0;
   pendingExecutorModelRef: string | undefined;
   suppressModelSelectionSync = false;
+  private lastSameModelDisabled: boolean | undefined;
 
   constructor(pi: ExtensionAPI, dependencies: CommandDependencies = {}) {
     this.pi = pi;
@@ -84,6 +89,30 @@ class CommandRuntime implements CommandRuntimeContract {
     return this.pi.getActiveTools().includes("ask_advisor");
   }
 
+  resetSameModelNotice() {
+    this.lastSameModelDisabled = undefined;
+  }
+
+  updateSameModelNotice(
+    ctx: ExtensionContext,
+    model: { id: string; provider: string } | undefined = ctx.model
+  ) {
+    if (!this.flowEnabled()) {
+      return;
+    }
+    const disabled = sameModelAdvisorDisabled(ctx, model);
+    if (disabled && this.lastSameModelDisabled !== true) {
+      notify(ctx, sameModelAdvisorNotice, "info");
+    } else if (!disabled && this.lastSameModelDisabled === true) {
+      notify(
+        ctx,
+        "Advisor re-enabled: executor and advisor models differ.",
+        "info"
+      );
+    }
+    this.lastSameModelDisabled = disabled;
+  }
+
   nextManualProgressId() {
     this.manualProgressSequence += 1;
     return `manual-${this.manualProgressSequence}`;

package/src/commands/settings-commands.ts

@@ -36,6 +36,7 @@ export const registerSettingsCommands = (runtime: CommandRuntime) => {
             onChange: (settings) => {
               try {
                 saveAdvisorSettings(ctx, settings);
+                runtime.updateSameModelNotice(ctx);
                 runtime.updateAdvisorUsageStatus(ctx);
               } catch (error) {
                 const message =
@@ -65,6 +66,7 @@ export const registerSettingsCommands = (runtime: CommandRuntime) => {
               name !== "ask_advisor" && name !== "record_advisor_outcome"
           )
       );
+      runtime.resetSameModelNotice();
       // Leaving alwaysOn set would silently reactivate the flow next session.
       const wasAlwaysOn = alwaysOnRef;
       if (wasAlwaysOn) {

package/src/commands/settings-persistence.ts

@@ -7,6 +7,7 @@ import {
   setAdvisorCollapseResponsesRef,
   setAdvisorCompletionGateRef,
   setAdvisorCustomInvocationRef,
+  setAdvisorDisableSameModelRef,
   setAdvisorEffortRef,
   setAdvisorFailureGateRef,
   setAdvisorFailureModeRef,
@@ -68,6 +69,7 @@ const applySessionSettings = (settings: AdvisorSettings) => {
   setAdvisorPlanGateRef(settings.planGate);
   setAdvisorFailureGateRef(settings.failureGate);
   setAdvisorCompletionGateRef(settings.completionGate);
+  setAdvisorDisableSameModelRef(settings.disableSameModel ?? true);
   setAdvisorCollapseResponsesRef(settings.collapseResponses);
   setAdvisorCustomInvocationRef(settings.customRule);
   setAdvisorBlockOnBlockedRef(settings.blockOnBlocked ?? true);

package/src/commands/types.ts

@@ -71,5 +71,10 @@ export interface CommandRuntime {
     model: Parameters<ExtensionAPI["setModel"]>[0]
   ) => ReturnType<ExtensionAPI["setModel"]>;
   suppressModelSelectionSync: boolean;
+  resetSameModelNotice: () => void;
+  updateSameModelNotice: (
+    ctx: ExtensionContext,
+    model?: { id: string; provider: string }
+  ) => void;
   updateAdvisorUsageStatus: (ctx: ExtensionContext) => void;
 }

package/src/config/defaults.ts

@@ -4,6 +4,7 @@ import {
   setAdvisorCollapseResponsesRef,
   setAdvisorCompletionGateRef,
   setAdvisorCustomInvocationRef,
+  setAdvisorDisableSameModelRef,
   setAdvisorEffortRef,
   setAdvisorFailureGateRef,
   setAdvisorFailureModeRef,
@@ -75,6 +76,7 @@ export const resetDefaults = () => {
   setAdvisorFailureGateRef(true);
   setAdvisorCompletionGateRef(true);
   setAdvisorCustomInvocationRef(undefined);
+  setAdvisorDisableSameModelRef(true);
   setAdvisorCollapseResponsesRef(false);
   setAdvisorBlockOnBlockedRef(true);
   setAdvisorAutoLoopGateRef(true);
@@ -150,6 +152,11 @@ export const applyConfig = (config: AdvisorConfig) => {
     "advisorCustomInvocation",
     setAdvisorCustomInvocationRef
   );
+  applyOptionalConfig(
+    config,
+    "advisorDisableSameModel",
+    setAdvisorDisableSameModelRef
+  );
   applyOptionalConfig(
     config,
     "advisorCollapseResponses",

package/src/config/schema.ts

@@ -7,6 +7,7 @@ import {
   advisorCollapseResponsesRef,
   advisorCompletionGateRef,
   advisorCustomInvocationRef,
+  advisorDisableSameModelRef,
   advisorEffortRef,
   advisorFailureGateRef,
   advisorFailureModeRef,
@@ -200,6 +201,12 @@ export const CONFIG_SCHEMA = {
     persisted: true,
     type: "string",
   },
+  advisorDisableSameModel: {
+    accepted: "true or false",
+    current: () => advisorDisableSameModelRef,
+    persisted: true,
+    type: "boolean",
+  },
   advisorEffort: {
     accepted: "a string",
     current: () => advisorEffortRef,

package/src/config/state.ts

@@ -34,6 +34,7 @@ export let advisorPlanGateRef = true;
 export let advisorFailureGateRef = true;
 export let advisorCompletionGateRef = true;
 export let advisorCustomInvocationRef: string | undefined;
+export let advisorDisableSameModelRef = true;
 export let advisorCollapseResponsesRef = false;
 export let advisorBlockOnBlockedRef = true;
 export let advisorAutoLoopGateRef = true;
@@ -115,6 +116,9 @@ export const setAdvisorCompletionGateRef = (enabled: boolean) => {
 export const setAdvisorCustomInvocationRef = (rule: string | undefined) => {
   advisorCustomInvocationRef = rule?.trim() || undefined;
 };
+export const setAdvisorDisableSameModelRef = (enabled: boolean) => {
+  advisorDisableSameModelRef = enabled;
+};
 export const setAdvisorCollapseResponsesRef = (enabled: boolean) => {
   advisorCollapseResponsesRef = enabled;
 };
@@ -237,6 +241,7 @@ export const getAdvisorSettings = () => ({
   completionGate: advisorCompletionGateRef,
   contextMaxChars: contextMaxCharsRef,
   customRule: advisorCustomInvocationRef,
+  disableSameModel: advisorDisableSameModelRef,
   effort: advisorEffortRef,
   failureGate: advisorFailureGateRef,
   failureMode: advisorFailureModeRef,

package/src/config/types.ts

@@ -65,6 +65,7 @@ export interface AdvisorConfig {
   advisorCollapseResponses?: boolean;
   advisorCompletionGate?: boolean;
   advisorCustomInvocation?: string;
+  advisorDisableSameModel?: boolean;
   advisorEffort?: string;
   advisorFailureGate?: boolean;
   advisorGitContext?: GitContextLevel;

package/src/conversation.ts

@@ -9,6 +9,7 @@ import {
 import type { AdvisorToolPolicies } from "./config/types.ts";
 import { contentParts, isRecordOf, isString } from "./content-utils.ts";
 import type { RecordValue } from "./content-utils.ts";
+import { imageMarker } from "./images.ts";
 import { redactSecrets } from "./redaction.ts";
 import { capToolResult } from "./tool-result-cap.ts";
 
@@ -25,6 +26,11 @@ const textFromPart = <Part>(part: Part): string => {
 export const textFrom = <Content>(content: Content): string =>
   contentParts(content).map(textFromPart).join("\n").trim();
 
+const imageNotes = (content: RecordValue["content"], nonce: string) =>
+  contentParts(content)
+    .map((part) => (isRecordOf(part) ? imageMarker(part, nonce) : undefined))
+    .filter(isString);
+
 const assistantEntry = (
   message: RecordValue,
   policies: AdvisorToolPolicies,
@@ -64,12 +70,17 @@ const toolResultEntry = (
   toolResultMaxLines: number,
   toolResultMaxBytes: number,
   policies: AdvisorToolPolicies,
-  redact: boolean
+  redact: boolean,
+  describeImages: boolean,
+  imageNonce: string
 ): string => {
   const status = message.isError ? "error" : "success";
   const toolName = isString(message.toolName) ? message.toolName : "unknown";
   const policy = policies[toolName] ?? "full";
-  const source = textFrom(message.content);
+  const notes = describeImages ? imageNotes(message.content, imageNonce) : [];
+  const source = [textFrom(message.content), ...notes]
+    .filter(Boolean)
+    .join("\n");
   if (policy === "exclude") {
     return `[Tool Result for ${toolName}] (excluded by Advisor tool policy)`;
   }
@@ -95,7 +106,9 @@ export const conversationEntry = <Entry>(
   toolResultMaxLines: number,
   toolResultMaxBytes: number,
   policies: AdvisorToolPolicies,
-  redact: boolean
+  redact: boolean,
+  describeImages = false,
+  imageNonce = ""
 ): string | undefined => {
   if (!isRecordOf(entry)) {
     return;
@@ -108,7 +121,10 @@ export const conversationEntry = <Entry>(
   }
   const { message } = entry;
   if (message.role === "user") {
-    const text = textFrom(message.content);
+    const notes = describeImages ? imageNotes(message.content, imageNonce) : [];
+    const text = [textFrom(message.content), ...notes]
+      .filter(Boolean)
+      .join("\n");
     return text ? `User: ${redact ? redactSecrets(text) : text}` : undefined;
   }
   if (message.role === "assistant") {
@@ -120,7 +136,9 @@ export const conversationEntry = <Entry>(
       toolResultMaxLines,
       toolResultMaxBytes,
       policies,
-      redact
+      redact,
+      describeImages,
+      imageNonce
     );
   }
 };
@@ -179,7 +197,9 @@ export const recentConversation = (
   toolResultMaxLines = advisorToolResultMaxLinesRef,
   toolResultMaxBytes = advisorToolResultMaxBytesRef,
   policies = advisorToolPoliciesRef,
-  redact = advisorRedactSecretsRef
+  redact = advisorRedactSecretsRef,
+  describeImages = false,
+  imageNonce = ""
 ): string => {
   if (maxChars === 0) {
     return "";
@@ -192,7 +212,9 @@ export const recentConversation = (
         toolResultMaxLines,
         toolResultMaxBytes,
         policies,
-        redact
+        redact,
+        describeImages,
+        imageNonce
       )
     )
     .filter((entry): entry is string => entry !== undefined);

package/src/image-attachments.ts

@@ -0,0 +1,118 @@
+import { constants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+
+import type { ImageContent } from "@earendil-works/pi-ai/compat";
+
+import {
+  imageFileCandidate,
+  imageMime,
+  isPermitted,
+  normalizeRequestedPath,
+  repositoryRoot,
+  within,
+} from "./attachments.ts";
+import { isString } from "./content-utils.ts";
+import { ADVISOR_IMAGE_MAX_BYTES, imageFromBytes } from "./images.ts";
+
+export interface ImageAttachment {
+  bytes: number;
+  image: ImageContent;
+  path: string;
+}
+
+const readImageAttachment = async (
+  root: string,
+  name: string,
+  mimeType: string,
+  remaining: number
+): Promise<ImageAttachment | undefined> => {
+  const absolute = resolve(root, name);
+  if (!within(root, absolute)) {
+    return;
+  }
+  const stats = await lstat(absolute);
+  if (stats.isSymbolicLink() || !stats.isFile()) {
+    return;
+  }
+  const resolved = await realpath(absolute);
+  if (!within(root, resolved)) {
+    return;
+  }
+  const flags = constants.O_NOFOLLOW
+    ? constants.O_RDONLY + constants.O_NOFOLLOW
+    : constants.O_RDONLY;
+  const file = await open(resolved, flags);
+  try {
+    const opened = await file.stat();
+    if (
+      !opened.isFile() ||
+      opened.size > ADVISOR_IMAGE_MAX_BYTES ||
+      opened.size > remaining
+    ) {
+      return;
+    }
+    const buffer = Buffer.alloc(opened.size + 1);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    if (bytesRead !== opened.size) {
+      return;
+    }
+    const image = imageFromBytes(buffer.subarray(0, bytesRead), mimeType);
+    return image ? { bytes: bytesRead, image, path: name } : undefined;
+  } finally {
+    await file.close();
+  }
+};
+
+export const readImageFiles = async (
+  cwd: string,
+  requested: string[],
+  enabled: boolean,
+  kind: "tracked" | "untracked",
+  remainingBytes: number,
+  remainingCount: number
+): Promise<{ images: ImageAttachment[]; omitted: number }> => {
+  const names = Array.isArray(requested)
+    ? requested.filter((path) => isString(path) && imageFileCandidate(path))
+    : [];
+  if (!enabled || !names.length) {
+    return { images: [], omitted: names.length };
+  }
+  const root = await repositoryRoot(cwd);
+  if (!root) {
+    return { images: [], omitted: names.length };
+  }
+  const seen = new Set<string>();
+  const images: ImageAttachment[] = [];
+  let omitted = 0;
+  let bytes = 0;
+  for (const path of names) {
+    const name = normalizeRequestedPath(root, path);
+    if (name && seen.has(name)) {
+      continue;
+    }
+    if (name) {
+      seen.add(name);
+    }
+    try {
+      const mime = name && imageMime(name);
+      const image =
+        name &&
+        mime &&
+        images.length < remainingCount &&
+        remainingBytes - bytes > 0 &&
+        isPermitted(root, name, kind)
+          ? await readImageAttachment(root, name, mime, remainingBytes - bytes)
+          : undefined;
+      if (image) {
+        images.push(image);
+        bytes += image.bytes;
+      } else {
+        omitted += 1;
+      }
+    } catch {
+      omitted += 1;
+    }
+  }
+  return { images, omitted };
+};