pi-advisor-flow 0.5.6 → 0.6.0

package/dist/index.js

@@ -297,66 +297,226 @@ ${patch}` : "Patch: (no tracked-file content changes)");
   }
 };
 
+// src/config/schema.ts
+var configuredModelRef = (value) => value?.trim() || undefined;
+var isValidAdvisorToolPolicies = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return Object.entries(value).every(([toolName, policy]) => toolName.trim().length > 0 && typeof policy === "string" && ADVISOR_TOOL_POLICIES.includes(policy));
+};
+var nonNegativeSafeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+var isValidContextMaxChars = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_CONTEXT_MAX_CHARS;
+var isValidLoopThreshold = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 2;
+var isValidMaxCallsPerSession = (value) => nonNegativeSafeInteger(value);
+var isValidGateFailureMode = (value) => typeof value === "string" && GATE_FAILURE_MODES.includes(value);
+var isValidToolResultMaxLines = (value) => nonNegativeSafeInteger(value);
+var isValidToolResultMaxBytes = (value) => nonNegativeSafeInteger(value);
+var CONFIG_SCHEMA = {
+  advisor: {
+    accepted: "a provider/model string",
+    current: () => configuredModelRef(advisorRef),
+    persisted: true,
+    type: "string"
+  },
+  advisorAutoLoopGate: {
+    accepted: "true or false",
+    current: () => advisorAutoLoopGateRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorBlockOnBlocked: {
+    accepted: "true or false",
+    current: () => advisorBlockOnBlockedRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorCollapseResponses: {
+    accepted: "true or false",
+    current: () => advisorCollapseResponsesRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorCompletionGate: {
+    accepted: "true or false",
+    current: () => advisorCompletionGateRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorCustomInvocation: {
+    accepted: "a string",
+    current: () => advisorCustomInvocationRef,
+    persisted: true,
+    type: "string"
+  },
+  advisorEffort: {
+    accepted: "a string",
+    current: () => advisorEffortRef,
+    persisted: true,
+    type: "string"
+  },
+  advisorFailureGate: {
+    accepted: "true or false",
+    current: () => advisorFailureGateRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorGitContext: {
+    accepted: GIT_CONTEXT_LEVELS.join(", "),
+    current: () => advisorGitContextRef,
+    persisted: true,
+    type: "enum",
+    validate: isValidGitContextLevel
+  },
+  advisorGitContextMaxChars: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorGitContextMaxCharsRef,
+    persisted: true,
+    type: "number",
+    validate: nonNegativeSafeInteger
+  },
+  advisorHerdrIntegration: {
+    accepted: "true or false",
+    current: () => advisorHerdrIntegrationRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorLoopThreshold: {
+    accepted: "a safe integer of at least 2",
+    current: () => advisorLoopThresholdRef,
+    persisted: true,
+    type: "number",
+    validate: isValidLoopThreshold
+  },
+  advisorMaxCallsPerSession: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorMaxCallsPerSessionRef,
+    persisted: true,
+    type: "number",
+    validate: isValidMaxCallsPerSession
+  },
+  advisorOutcomeLogging: {
+    accepted: "true or false",
+    current: () => advisorOutcomeLoggingRef,
+    persisted: false,
+    type: "boolean"
+  },
+  advisorPlanGate: {
+    accepted: "true or false",
+    current: () => advisorPlanGateRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorRedactSecrets: {
+    accepted: "true or false",
+    current: () => advisorRedactSecretsRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorScoutEnabled: {
+    accepted: "true or false",
+    current: () => advisorScoutEnabledRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorSessionSummary: {
+    accepted: "true or false",
+    current: () => advisorSessionSummaryRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorToolPolicies: {
+    accepted: "a JSON object with non-empty tool names and full, summary, or exclude values",
+    current: () => ({ ...advisorToolPoliciesRef }),
+    persisted: true,
+    type: "object",
+    validate: isValidAdvisorToolPolicies
+  },
+  advisorToolResultMaxBytes: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorToolResultMaxBytesRef,
+    persisted: true,
+    type: "number",
+    validate: isValidToolResultMaxBytes
+  },
+  advisorToolResultMaxLines: {
+    accepted: "a non-negative safe integer",
+    current: () => advisorToolResultMaxLinesRef,
+    persisted: true,
+    type: "number",
+    validate: isValidToolResultMaxLines
+  },
+  advisorTrackedFileContent: {
+    accepted: "true or false",
+    current: () => advisorTrackedFileContentRef,
+    persisted: true,
+    type: "boolean"
+  },
+  advisorUntrackedContent: {
+    accepted: "true or false",
+    current: () => advisorUntrackedContentRef,
+    persisted: true,
+    type: "boolean"
+  },
+  alwaysOn: {
+    accepted: "true or false",
+    current: () => alwaysOnRef,
+    persisted: true,
+    type: "boolean"
+  },
+  contextMaxChars: {
+    accepted: `a safe integer from 0 through ${MAX_CONTEXT_MAX_CHARS}`,
+    current: () => contextMaxCharsRef,
+    persisted: true,
+    type: "number",
+    validate: isValidContextMaxChars
+  },
+  executor: {
+    accepted: "a provider/model string",
+    current: () => configuredModelRef(executorRef),
+    persisted: true,
+    type: "string"
+  },
+  executorEffort: {
+    accepted: "a string",
+    current: () => executorEffortRef,
+    persisted: true,
+    type: "string"
+  },
+  gateFailureMode: {
+    accepted: GATE_FAILURE_MODES.join(", "),
+    current: () => advisorFailureModeRef,
+    persisted: true,
+    type: "enum",
+    validate: isValidGateFailureMode
+  },
+  showUsageDetails: {
+    accepted: "true or false",
+    current: () => showUsageDetailsRef,
+    persisted: true,
+    type: "boolean"
+  },
+  showUsageFooter: {
+    accepted: "true or false",
+    current: () => showUsageFooterRef,
+    persisted: true,
+    type: "boolean"
+  },
+  simpleMode: {
+    accepted: "true or false",
+    current: () => simpleModeRef,
+    persisted: true,
+    type: "boolean"
+  }
+};
+var SAVED_CONFIG_KEYS = Object.keys(CONFIG_SCHEMA).filter((key) => CONFIG_SCHEMA[key].persisted);
+var SCHEMA_BY_KEY = CONFIG_SCHEMA;
+
 // src/config/validation.ts
-var CONFIG_KEYS = new Set([
-  "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"
-]);
-var BOOLEAN_CONFIG_KEYS = [
-  "advisorPlanGate",
-  "advisorFailureGate",
-  "advisorCompletionGate",
-  "advisorCollapseResponses",
-  "advisorBlockOnBlocked",
-  "advisorAutoLoopGate",
-  "advisorSessionSummary",
-  "advisorScoutEnabled",
-  "showUsageDetails",
-  "showUsageFooter",
-  "simpleMode",
-  "alwaysOn",
-  "advisorHerdrIntegration",
-  "advisorTrackedFileContent",
-  "advisorRedactSecrets",
-  "advisorUntrackedContent",
-  "advisorOutcomeLogging"
-];
-var STRING_CONFIG_KEYS = [
-  "executor",
-  "advisor",
-  "executorEffort",
-  "advisorEffort",
-  "advisorCustomInvocation"
-];
+var CONFIG_KEYS = new Set(Object.keys(CONFIG_SCHEMA));
+var keysOfType = (type) => Object.keys(CONFIG_SCHEMA).filter((key) => SCHEMA_BY_KEY[key].type === type);
+var BOOLEAN_CONFIG_KEYS = keysOfType("boolean");
+var STRING_CONFIG_KEYS = keysOfType("string");
 var invalidConfigValue = (path, key, accepted) => {
   throw new TypeError(`Invalid advisor configuration at ${path}, key ${JSON.stringify(key)}: expected ${accepted}.`);
 };
@@ -364,65 +524,38 @@ var unknownConfigKeys = (config) => Object.keys(config).filter((key) => !CONFIG_
 var validateStringValues = (config, path) => {
   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);
     }
   }
 };
 var validateBooleanValues = (config, path) => {
   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);
     }
   }
 };
-var isValidAdvisorToolPolicies = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
+var validateNumericValues = (config, path) => {
+  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));
 };
-var isValidContextMaxChars = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= MAX_CONTEXT_MAX_CHARS;
-var isValidLoopThreshold = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 2;
-var isValidMaxCallsPerSession = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-var isValidGateFailureMode = (value) => typeof value === "string" && GATE_FAILURE_MODES.includes(value);
-var isValidToolResultMaxLines = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-var isValidToolResultMaxBytes = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-var validateNumericValues = (config, path) => {
-  const numericRules = [
-    [
-      "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);
+var validateEnumValues = (config, path) => {
+  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);
+    }
+  }
+};
+var validateObjectValues = (config, path) => {
+  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);
     }
   }
 };
@@ -434,15 +567,8 @@ var validateConfig = (value, path = "advisor.json") => {
   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;
 };
 
@@ -562,71 +688,7 @@ var applyConfig = (config) => {
 };
 
 // src/config/storage.ts
-var configuredModelRef = (value) => value?.trim() || undefined;
-var 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"
-];
-var currentConfigState = () => ({
-  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
-});
+var currentConfigState = () => Object.fromEntries(SAVED_CONFIG_KEYS.map((key) => [key, CONFIG_SCHEMA[key].current()]));
 var sameConfigValue = (left, right) => JSON.stringify(left) === JSON.stringify(right);
 var readExistingConfig = (path) => {
   try {
@@ -654,13 +716,9 @@ var applyChangedConfigValues = (data, current, changedKeys, persistAdvisor, pers
 var loadedConfigState;
 var loadedConfigPath;
 var readConfig = (path) => {
-  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;
 };
 var configCache = new Map;
 var warnedUnknownConfigIdentities = new Set;
@@ -1039,26 +1097,30 @@ var selectAdvisorModels = async (ctx, options) => {
 // src/herdr.ts
 import net from "node:net";
 
-// src/conversation.ts
-var isRecord = (value) => Boolean(value) && typeof value === "object";
+// src/content-utils.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var byteLength = (value) => Buffer.byteLength(value, "utf8");
 var contentParts = (content) => {
   if (typeof content === "string") {
     return [content];
   }
   return Array.isArray(content) ? content : [];
 };
-var textFromPart = (part) => {
-  if (typeof part === "string") {
-    return part;
-  }
-  if (!isRecord(part) || part.type !== "text") {
-    return "";
+var capUtf8Bytes = (value, maxBytes) => {
+  let result = "";
+  let used = 0;
+  for (const character of value) {
+    const characterBytes = byteLength(character);
+    if (used + characterBytes > maxBytes) {
+      break;
+    }
+    result += character;
+    used += characterBytes;
   }
-  return typeof part.text === "string" ? part.text : "";
+  return result;
 };
-var textFrom = (content) => contentParts(content).map(textFromPart).join(`
-`).trim();
-var byteLength = (value) => Buffer.byteLength(value, "utf8");
+
+// src/redaction.ts
 var REDACTION_MARKER = "[REDACTED SECRET]";
 var PEM_BEGIN_PATTERN = /-----BEGIN(?: [A-Z0-9]+)? PRIVATE KEY-----/gi;
 var PEM_END_PATTERN = /-----END(?: [A-Z0-9]+)? PRIVATE KEY-----/i;
@@ -1088,263 +1150,85 @@ var redactSecrets = (value) => {
 };
 var redactAndCapText = (value, maxBytes, redact = true) => {
   const source = redact ? redactSecrets(value) : value;
-  let result = "";
-  for (const character of source) {
-    if (byteLength(result + character) > maxBytes) {
-      break;
-    }
-    result += character;
-  }
-  return result;
+  return capUtf8Bytes(source, maxBytes);
 };
-var capToolResult = (value, maxLines = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES, maxBytes = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES) => {
-  const lines = value.split(`
-`);
-  const totalLines = lines.length;
-  const totalBytes = byteLength(value);
-  if ((maxLines === 0 || maxBytes === 0) && value.length > 0) {
-    return {
-      content: "[Tool result omitted: configured limit is zero]",
-      omittedLines: totalLines,
-      totalBytes,
-      totalLines,
-      truncated: true
-    };
+
+// src/herdr.ts
+var HERDR_NOTIFICATION_METHOD = "notification.show";
+var SOURCE = "pi-advisor:advisor-activity";
+var BLOCK_SOURCE = "pi-advisor:advisor-block";
+var NOTIFICATION_SOURCE = "pi-advisor:advisor-notification";
+var HERDR_PI_SOURCE = "herdr:pi";
+var sequence = Date.now() * 1000;
+var nextSequence = () => {
+  sequence += 1;
+  return sequence;
+};
+var emitBlocked;
+var setHerdrBlockedEmitter = (emitter) => {
+  emitBlocked = emitter;
+};
+var safeEmitBlocked = (active, label = "Advisor blocked") => {
+  try {
+    emitBlocked?.(active, label);
+  } catch {}
+};
+var isControlCharacter = (character) => character <= "\x1F" || character === "";
+var cleanNotification = (value, max) => [...redactSecrets(value)].map((character) => isControlCharacter(character) ? " " : character).join("").replace(/\s+/g, " ").trim().slice(0, max);
+var createHerdrNotificationRequest = (title, body) => ({
+  id: `${NOTIFICATION_SOURCE}:${nextSequence()}`,
+  method: HERDR_NOTIFICATION_METHOD,
+  params: {
+    body: cleanNotification(body, 240),
+    position: "top-left",
+    sound: "request",
+    title: cleanNotification(title, 80)
   }
-  if (totalLines <= maxLines && totalBytes <= maxBytes) {
-    return {
-      content: value,
-      omittedLines: 0,
-      totalBytes,
-      totalLines,
-      truncated: false
-    };
+});
+var sendToHerdr = (request) => {
+  if (process.env.HERDR_ENV !== "1") {
+    return;
   }
-  const marker = "[... omitted tool-result section ...]";
-  const markerBytes = byteLength(marker);
-  if (maxBytes < markerBytes || maxLines === 1) {
-    const content = [...marker].reduce((result, character) => byteLength(result + character) <= maxBytes ? result + character : result, "");
-    return {
-      content,
-      omittedLines: totalLines,
-      totalBytes,
-      totalLines,
-      truncated: true
-    };
+  const paneId = process.env.HERDR_PANE_ID;
+  const socketPath = process.env.HERDR_SOCKET_PATH;
+  if (!(paneId && socketPath)) {
+    return;
   }
-  const headCount = Math.floor((maxLines - 1) / 2);
-  const tailCount = maxLines - 1 - headCount;
-  const collect = (candidates, maxEntries, maxContentBytes) => {
-    const selected = [];
-    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(lines.slice(Math.max(head.length, lines.length - tailCount)), tailCount, availableBytes - byteLength(head.join(`
-`)));
-  const content = [...head, marker, ...tail].join(`
-`);
-  return {
-    content,
-    omittedLines: Math.max(0, totalLines - head.length - tail.length),
-    totalBytes,
-    totalLines,
-    truncated: true
-  };
+  const endpoint = process.platform === "win32" ? `\\\\.\\pipe\\${socketPath}` : socketPath;
+  const socket = net.createConnection(endpoint);
+  const timeout = setTimeout(() => socket.destroy(), 500);
+  timeout.unref?.();
+  socket.once("connect", () => socket.write(`${JSON.stringify(request)}
+`));
+  socket.once("data", () => socket.destroy());
+  socket.once("error", () => socket.destroy());
+  socket.once("close", () => clearTimeout(timeout));
 };
-var assistantEntry = (message, policies, redact) => {
-  const parts = [];
-  const text = textFrom(message.content);
-  if (text) {
-    parts.push(redact ? redactSecrets(text) : text);
+
+class HerdrAdvisorActivity {
+  #activeConsultations = 0;
+  report;
+  enabled;
+  constructor(report = sendToHerdr, enabled = () => true) {
+    this.report = report;
+    this.enabled = enabled;
   }
-  for (const part of contentParts(message.content)) {
-    if (!isRecord(part) || part.type !== "toolCall") {
-      continue;
+  start() {
+    if (!this.enabled()) {
+      return;
     }
-    const toolName = typeof part.name === "string" ? part.name : "unknown";
-    const policy = policies[toolName] ?? "full";
-    if (policy === "exclude") {
-      parts.push(`[Tool Call: ${toolName}] (excluded by Advisor tool policy)`);
-      continue;
+    this.#activeConsultations += 1;
+    if (this.#activeConsultations === 1) {
+      this.safeReport(false);
     }
-    if (policy === "summary") {
-      parts.push(`[Tool Call: ${toolName}] (arguments omitted by Advisor tool policy: summary)`);
-      continue;
-    }
-    const argumentsText = JSON.stringify(part.arguments) ?? "undefined";
-    parts.push(`[Tool Call: ${toolName}(${redact ? redactSecrets(argumentsText) : argumentsText})]`);
-  }
-  return parts.length > 0 ? `Executor: ${parts.join(`
-`)}` : undefined;
-};
-var toolResultEntry = (message, toolResultMaxLines, toolResultMaxBytes, policies, redact) => {
-  const status = message.isError ? "error" : "success";
-  const toolName = typeof message.toolName === "string" ? message.toolName : "unknown";
-  const policy = policies[toolName] ?? "full";
-  const source = textFrom(message.content);
-  if (policy === "exclude") {
-    return `[Tool Result for ${toolName}] (excluded by Advisor tool policy)`;
-  }
-  if (policy === "summary") {
-    const capped = capToolResult(source, toolResultMaxLines, toolResultMaxBytes);
-    return `[Tool Result for ${toolName}] (output omitted by Advisor tool policy: summary; status: ${status}; ${capped.totalLines} lines, ${capped.totalBytes} bytes; source output was${capped.truncated ? "" : " not"} truncated)`;
-  }
-  const disclosed = redact ? redactSecrets(source) : source;
-  const capped = capToolResult(disclosed, toolResultMaxLines, toolResultMaxBytes);
-  return `[Tool Result for ${toolName}] (${message.isError ? "Error " : ""}output):
-${capped.content}`;
-};
-var conversationEntry = (entry, toolResultMaxLines, toolResultMaxBytes, policies, redact) => {
-  if (!isRecord(entry)) {
-    return;
-  }
-  if (entry.type === "compaction" && typeof entry.summary === "string") {
-    return `[System Compaction Summary]: ${redact ? redactSecrets(entry.summary) : entry.summary}`;
-  }
-  if (entry.type !== "message" || !isRecord(entry.message)) {
-    return;
-  }
-  const { message } = entry;
-  if (message.role === "user") {
-    const text = textFrom(message.content);
-    return text ? `User: ${redact ? redactSecrets(text) : text}` : undefined;
-  }
-  if (message.role === "assistant") {
-    return assistantEntry(message, policies, redact);
-  }
-  if (message.role === "toolResult" || message.role === "tool") {
-    return toolResultEntry(message, toolResultMaxLines, toolResultMaxBytes, policies, redact);
-  }
-};
-var selectRecentEntries = (entries, maxChars) => {
-  const separator = `
-
-`;
-  const joined = entries.join(separator);
-  if (joined.length <= maxChars || maxChars === Number.MAX_SAFE_INTEGER) {
-    return joined;
-  }
-  const newestTruncated = "[Newest entry truncated]";
-  if (entries.length === 1) {
-    const prefix = `${newestTruncated}${separator}`;
-    return `${prefix}${entries[0].slice(0, Math.max(0, maxChars - prefix.length))}`.slice(0, maxChars);
-  }
-  const selected = [];
-  let selectedLength = 0;
-  for (let index = entries.length - 1;index >= 0; index -= 1) {
-    const entry = entries[index];
-    const candidateCount = selected.length + 1;
-    const omitted = entries.length - candidateCount;
-    const marker = `[Older context omitted: ${omitted} complete entr${omitted === 1 ? "y" : "ies"}]`;
-    const candidateLength = selectedLength + entry.length + (selected.length > 0 ? separator.length : 0);
-    if (marker.length + separator.length + candidateLength > maxChars) {
-      break;
-    }
-    selected.unshift(entry);
-    selectedLength = candidateLength;
-  }
-  const omitted = entries.length - Math.max(1, selected.length);
-  const marker = `[Older context omitted: ${omitted} complete entr${omitted === 1 ? "y" : "ies"}]`;
-  if (selected.length > 0) {
-    return `${marker}${separator}${selected.join(separator)}`;
-  }
-  const prefix = `${marker}${separator}${newestTruncated}${separator}`;
-  return `${prefix}${entries.at(-1)?.slice(0, Math.max(0, maxChars - prefix.length)) ?? ""}`.slice(0, maxChars);
-};
-var recentConversation = (ctx, maxChars = 15000, toolResultMaxLines = advisorToolResultMaxLinesRef, toolResultMaxBytes = advisorToolResultMaxBytesRef, policies = advisorToolPoliciesRef, redact = advisorRedactSecretsRef) => {
-  if (maxChars === 0) {
-    return "";
-  }
-  const entries = ctx.sessionManager.getBranch().map((entry) => conversationEntry(entry, toolResultMaxLines, toolResultMaxBytes, policies, redact)).filter((entry) => entry !== undefined);
-  return selectRecentEntries(entries, maxChars);
-};
-
-// src/herdr.ts
-var HERDR_NOTIFICATION_METHOD = `${"notification"}.${"show"}`;
-var SOURCE = "pi-advisor:advisor-activity";
-var BLOCK_SOURCE = "pi-advisor:advisor-block";
-var NOTIFICATION_SOURCE = "pi-advisor:advisor-notification";
-var HERDR_PI_SOURCE = "herdr:pi";
-var sequence = Date.now() * 1000;
-var nextSequence = () => {
-  sequence += 1;
-  return sequence;
-};
-var emitBlocked;
-var setHerdrBlockedEmitter = (emitter) => {
-  emitBlocked = emitter;
-};
-var safeEmitBlocked = (active, label = "Advisor blocked") => {
-  try {
-    emitBlocked?.(active, label);
-  } catch {}
-};
-var isControlCharacter = (character) => character <= "\x1F" || character === "";
-var cleanNotification = (value, max) => [...redactSecrets(value)].map((character) => isControlCharacter(character) ? " " : character).join("").replace(/\s+/g, " ").trim().slice(0, max);
-var createHerdrNotificationRequest = (title, body) => ({
-  id: `${NOTIFICATION_SOURCE}:${nextSequence()}`,
-  method: HERDR_NOTIFICATION_METHOD,
-  params: {
-    body: cleanNotification(body, 240),
-    position: "top-left",
-    sound: "request",
-    title: cleanNotification(title, 80)
-  }
-});
-var sendToHerdr = (request) => {
-  if (process.env.HERDR_ENV !== "1") {
-    return;
-  }
-  const paneId = process.env.HERDR_PANE_ID;
-  const socketPath = process.env.HERDR_SOCKET_PATH;
-  if (!(paneId && socketPath)) {
-    return;
-  }
-  const endpoint = process.platform === "win32" ? `\\\\.\\pipe\\${socketPath}` : socketPath;
-  const socket = net.createConnection(endpoint);
-  const timeout = setTimeout(() => socket.destroy(), 500);
-  timeout.unref?.();
-  socket.once("connect", () => socket.write(`${JSON.stringify(request)}
-`));
-  socket.once("data", () => socket.destroy());
-  socket.once("error", () => socket.destroy());
-  socket.once("close", () => clearTimeout(timeout));
-};
-
-class HerdrAdvisorActivity {
-  #activeConsultations = 0;
-  report;
-  enabled;
-  constructor(report = sendToHerdr, enabled = () => true) {
-    this.report = report;
-    this.enabled = enabled;
-  }
-  start() {
-    if (!this.enabled()) {
-      return;
-    }
-    this.#activeConsultations += 1;
-    if (this.#activeConsultations === 1) {
-      this.safeReport(false);
-    }
-  }
-  finish() {
-    if (this.#activeConsultations === 0) {
-      return;
-    }
-    this.#activeConsultations -= 1;
-    if (this.#activeConsultations === 0) {
-      this.safeReport(true);
+  }
+  finish() {
+    if (this.#activeConsultations === 0) {
+      return;
+    }
+    this.#activeConsultations -= 1;
+    if (this.#activeConsultations === 0) {
+      this.safeReport(true);
     }
   }
   clear() {
@@ -1596,57 +1480,444 @@ var collectTextStream = async (resolved, options, streamModel = stream) => {
   };
 };
 
-// src/preferences.ts
+// src/attachments.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { constants } from "node:fs";
 import { lstat, open, realpath } from "node:fs/promises";
-import { join as join2, relative } from "node:path";
-var PREFERENCES_MAX_BYTES = 8 * 1024;
-var PREFERENCES_FILENAME = ["advisor-preferences", "md"].join(".");
-var inside = (root, candidate) => {
+import { isAbsolute, relative, resolve } from "node:path";
+var ADVISOR_FILE_MAX_BYTES = 8 * 1024;
+var ADVISOR_FILES_TOTAL_MAX_BYTES = 24 * 1024;
+var PATH_SEGMENTS = /[\\/]/;
+var within = (root, candidate) => {
   const path = relative(root, candidate);
-  return path === "" || !(path.startsWith("..") || path.includes("../"));
+  return path !== "" && !path.startsWith("..") && !path.includes("../");
 };
-var readProjectPreferences = async (ctx, maxBytes = PREFERENCES_MAX_BYTES, redact = true) => {
-  if (!ctx.isProjectTrusted()) {
+var normalizeRelativePath = (root, path) => relative(root, resolve(root, path));
+var normalizeRequestedPath = (root, value) => {
+  if (typeof value !== "string" || !value || isAbsolute(value) || value.split(PATH_SEGMENTS).includes("..")) {
     return;
   }
+  return normalizeRelativePath(root, value);
+};
+var git = (cwd, args) => execFileSync2("git", args, {
+  cwd,
+  encoding: "utf8",
+  maxBuffer: 16 * 1024 * 1024,
+  shell: false,
+  stdio: ["ignore", "pipe", "pipe"],
+  timeout: 5000,
+  windowsHide: true
+});
+var repositoryRoot = (cwd) => {
   try {
-    const root = await realpath(ctx.cwd);
-    const candidate = join2(ctx.cwd, ".pi", PREFERENCES_FILENAME);
-    const stats = await lstat(candidate);
-    if (stats.isSymbolicLink() || !stats.isFile()) {
-      return;
+    return realpath(git(cwd, ["rev-parse", "--show-toplevel"]).trim());
+  } catch {
+    return Promise.resolve(undefined);
+  }
+};
+var untracked = (cwd, path) => {
+  const output = git(cwd, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--",
+    path
+  ]);
+  const expected = normalizeRelativePath(cwd, path);
+  return output.split("\x00").filter(Boolean).some((entry) => normalizeRelativePath(cwd, entry) === expected);
+};
+var tracked = (cwd, path) => {
+  const output = git(cwd, ["ls-files", "--stage", "-z", "--", path]);
+  const expected = normalizeRelativePath(cwd, path);
+  return output.split("\x00").some((entry) => {
+    if (!entry) {
+      return false;
     }
-    const resolved = await realpath(candidate);
-    if (!inside(root, resolved)) {
+    const [metadata, name] = entry.split("\t");
+    return name && normalizeRelativePath(cwd, name) === expected && !metadata.startsWith("160000 ");
+  });
+};
+var isPermitted = (root, path, kind) => kind === "tracked" ? tracked(root, path) : untracked(root, path);
+var readAttachment = async (root, normalizedName, redact, available) => {
+  const absolute = resolve(root, normalizedName);
+  if (!(within(root, absolute) && available > 0)) {
+    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 openedStats = await file.stat();
+    if (!openedStats.isFile()) {
       return;
     }
-    const file = await open(resolved, "r");
-    try {
-      const buffer = Buffer.alloc(maxBytes + 1);
-      const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
-      const source = buffer.subarray(0, bytesRead).toString("utf8");
-      const capped = redactAndCapText(source, maxBytes, redact);
-      return { bytes: Buffer.byteLength(capped, "utf8"), text: capped };
-    } finally {
-      await file.close();
+    const buffer = Buffer.alloc(available + 1);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    const raw = buffer.subarray(0, bytesRead).toString("utf8");
+    if (raw.includes("\x00")) {
+      return;
     }
-  } catch {}
+    const text = redactAndCapText(raw, available, redact);
+    return {
+      bytes: Buffer.byteLength(text, "utf8"),
+      path: normalizedName,
+      text
+    };
+  } finally {
+    await file.close();
+  }
 };
-
-// src/scout-context.ts
-import { createHash } from "node:crypto";
-var SCOUT_MANIFEST_MAX_BYTES = 64 * 1024;
+var readFiles = async (cwd, requested, enabled, redact, kind, totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES) => {
+  if (!(enabled && Array.isArray(requested))) {
+    return [];
+  }
+  const root = await repositoryRoot(cwd);
+  if (!root) {
+    return [];
+  }
+  const unique = new Set;
+  const attachments = [];
+  let total = 0;
+  for (const name of requested) {
+    const normalizedName = normalizeRequestedPath(root, name);
+    if (!normalizedName || unique.has(normalizedName)) {
+      continue;
+    }
+    unique.add(normalizedName);
+    try {
+      if (!isPermitted(root, normalizedName, kind)) {
+        continue;
+      }
+      const available = Math.min(ADVISOR_FILE_MAX_BYTES, totalLimit - total);
+      if (available <= 0) {
+        break;
+      }
+      const attachment = await readAttachment(root, normalizedName, redact, available);
+      if (attachment) {
+        attachments.push(attachment);
+        total += attachment.bytes;
+      }
+    } catch {}
+  }
+  return attachments;
+};
+var readTrackedFiles = (cwd, requested, enabled, redact, totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES) => readFiles(cwd, requested, enabled, redact, "tracked", totalLimit);
+var readUntrackedFiles = (cwd, requested, enabled, redact, totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES) => readFiles(cwd, requested, enabled, redact, "untracked", totalLimit);
+
+// src/preferences.ts
+import { lstat as lstat2, open as open2, realpath as realpath2 } from "node:fs/promises";
+import { join as join2, relative as relative2 } from "node:path";
+var PREFERENCES_MAX_BYTES = 8 * 1024;
+var PREFERENCES_FILENAME = ["advisor-preferences", "md"].join(".");
+var inside = (root, candidate) => {
+  const path = relative2(root, candidate);
+  return path === "" || !(path.startsWith("..") || path.includes("../"));
+};
+var readProjectPreferences = async (ctx, maxBytes = PREFERENCES_MAX_BYTES, redact = true) => {
+  if (!ctx.isProjectTrusted()) {
+    return;
+  }
+  try {
+    const root = await realpath2(ctx.cwd);
+    const candidate = join2(ctx.cwd, ".pi", PREFERENCES_FILENAME);
+    const stats = await lstat2(candidate);
+    if (stats.isSymbolicLink() || !stats.isFile()) {
+      return;
+    }
+    const resolved = await realpath2(candidate);
+    if (!inside(root, resolved)) {
+      return;
+    }
+    const file = await open2(resolved, "r");
+    try {
+      const buffer = Buffer.alloc(maxBytes + 1);
+      const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+      const source = buffer.subarray(0, bytesRead).toString("utf8");
+      const capped = redactAndCapText(source, maxBytes, redact);
+      return { bytes: Buffer.byteLength(capped, "utf8"), text: capped };
+    } finally {
+      await file.close();
+    }
+  } catch {}
+};
+
+// src/scout-groups.ts
+import { createHash } from "node:crypto";
+
+// src/tool-result-cap.ts
+var OMITTED_MARKER = "[... omitted tool-result section ...]";
+var capToolResult = (value, maxLines = DEFAULT_ADVISOR_TOOL_RESULT_MAX_LINES, maxBytes = DEFAULT_ADVISOR_TOOL_RESULT_MAX_BYTES) => {
+  const lines = value.split(`
+`);
+  const totalLines = lines.length;
+  const totalBytes = byteLength(value);
+  if ((maxLines === 0 || maxBytes === 0) && value.length > 0) {
+    return {
+      content: "[Tool result omitted: configured limit is zero]",
+      omittedLines: totalLines,
+      totalBytes,
+      totalLines,
+      truncated: true
+    };
+  }
+  if (totalLines <= maxLines && totalBytes <= maxBytes) {
+    return {
+      content: value,
+      omittedLines: 0,
+      totalBytes,
+      totalLines,
+      truncated: false
+    };
+  }
+  const markerBytes = byteLength(OMITTED_MARKER);
+  if (maxBytes < markerBytes || maxLines === 1) {
+    return {
+      content: capUtf8Bytes(OMITTED_MARKER, maxBytes),
+      omittedLines: totalLines,
+      totalBytes,
+      totalLines,
+      truncated: true
+    };
+  }
+  const headCount = Math.floor((maxLines - 1) / 2);
+  const tailCount = maxLines - 1 - headCount;
+  const collect = (candidates, maxEntries, maxContentBytes) => {
+    const selected = [];
+    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(lines.slice(Math.max(head.length, lines.length - tailCount)), tailCount, availableBytes - byteLength(head.join(`
+`)));
+  const content = [...head, OMITTED_MARKER, ...tail].join(`
+`);
+  return {
+    content,
+    omittedLines: Math.max(0, totalLines - head.length - tail.length),
+    totalBytes,
+    totalLines,
+    truncated: true
+  };
+};
+
+// src/conversation.ts
+var textFromPart = (part) => {
+  if (typeof part === "string") {
+    return part;
+  }
+  if (!isRecord(part) || part.type !== "text") {
+    return "";
+  }
+  return typeof part.text === "string" ? part.text : "";
+};
+var textFrom = (content) => contentParts(content).map(textFromPart).join(`
+`).trim();
+var assistantEntry = (message, policies, redact) => {
+  const parts = [];
+  const text = textFrom(message.content);
+  if (text) {
+    parts.push(redact ? redactSecrets(text) : text);
+  }
+  for (const part of contentParts(message.content)) {
+    if (!isRecord(part) || part.type !== "toolCall") {
+      continue;
+    }
+    const toolName = typeof part.name === "string" ? part.name : "unknown";
+    const policy = policies[toolName] ?? "full";
+    if (policy === "exclude") {
+      parts.push(`[Tool Call: ${toolName}] (excluded by Advisor tool policy)`);
+      continue;
+    }
+    if (policy === "summary") {
+      parts.push(`[Tool Call: ${toolName}] (arguments omitted by Advisor tool policy: summary)`);
+      continue;
+    }
+    const argumentsText = JSON.stringify(part.arguments) ?? "undefined";
+    parts.push(`[Tool Call: ${toolName}(${redact ? redactSecrets(argumentsText) : argumentsText})]`);
+  }
+  return parts.length > 0 ? `Executor: ${parts.join(`
+`)}` : undefined;
+};
+var toolResultEntry = (message, toolResultMaxLines, toolResultMaxBytes, policies, redact) => {
+  const status = message.isError ? "error" : "success";
+  const toolName = typeof message.toolName === "string" ? message.toolName : "unknown";
+  const policy = policies[toolName] ?? "full";
+  const source = textFrom(message.content);
+  if (policy === "exclude") {
+    return `[Tool Result for ${toolName}] (excluded by Advisor tool policy)`;
+  }
+  if (policy === "summary") {
+    const capped = capToolResult(source, toolResultMaxLines, toolResultMaxBytes);
+    return `[Tool Result for ${toolName}] (output omitted by Advisor tool policy: summary; status: ${status}; ${capped.totalLines} lines, ${capped.totalBytes} bytes; source output was${capped.truncated ? "" : " not"} truncated)`;
+  }
+  const disclosed = redact ? redactSecrets(source) : source;
+  const capped = capToolResult(disclosed, toolResultMaxLines, toolResultMaxBytes);
+  return `[Tool Result for ${toolName}] (${message.isError ? "Error " : ""}output):
+${capped.content}`;
+};
+var conversationEntry = (entry, toolResultMaxLines, toolResultMaxBytes, policies, redact) => {
+  if (!isRecord(entry)) {
+    return;
+  }
+  if (entry.type === "compaction" && typeof entry.summary === "string") {
+    return `[System Compaction Summary]: ${redact ? redactSecrets(entry.summary) : entry.summary}`;
+  }
+  if (entry.type !== "message" || !isRecord(entry.message)) {
+    return;
+  }
+  const { message } = entry;
+  if (message.role === "user") {
+    const text = textFrom(message.content);
+    return text ? `User: ${redact ? redactSecrets(text) : text}` : undefined;
+  }
+  if (message.role === "assistant") {
+    return assistantEntry(message, policies, redact);
+  }
+  if (message.role === "toolResult" || message.role === "tool") {
+    return toolResultEntry(message, toolResultMaxLines, toolResultMaxBytes, policies, redact);
+  }
+};
+var omissionMarker = (omitted) => `[Older context omitted: ${omitted} complete entr${omitted === 1 ? "y" : "ies"}]`;
+var selectRecentEntries = (entries, maxChars) => {
+  const separator = `
+
+`;
+  const joined = entries.join(separator);
+  if (joined.length <= maxChars || maxChars === Number.MAX_SAFE_INTEGER) {
+    return joined;
+  }
+  const newestTruncated = "[Newest entry truncated]";
+  if (entries.length === 1) {
+    const prefix = `${newestTruncated}${separator}`;
+    return `${prefix}${entries[0].slice(0, Math.max(0, maxChars - prefix.length))}`.slice(0, maxChars);
+  }
+  const selected = [];
+  let selectedLength = 0;
+  for (let index = entries.length - 1;index >= 0; index -= 1) {
+    const entry = entries[index];
+    const candidateCount = selected.length + 1;
+    const omitted = entries.length - candidateCount;
+    const candidateLength = selectedLength + entry.length + (selected.length > 0 ? separator.length : 0);
+    if (omissionMarker(omitted).length + separator.length + candidateLength > maxChars) {
+      break;
+    }
+    selected.unshift(entry);
+    selectedLength = candidateLength;
+  }
+  const omitted = entries.length - Math.max(1, selected.length);
+  const marker = omissionMarker(omitted);
+  if (selected.length > 0) {
+    return `${marker}${separator}${selected.join(separator)}`;
+  }
+  const prefix = `${marker}${separator}${newestTruncated}${separator}`;
+  return `${prefix}${entries.at(-1)?.slice(0, Math.max(0, maxChars - prefix.length)) ?? ""}`.slice(0, maxChars);
+};
+var recentConversation = (ctx, maxChars = 15000, toolResultMaxLines = advisorToolResultMaxLinesRef, toolResultMaxBytes = advisorToolResultMaxBytesRef, policies = advisorToolPoliciesRef, redact = advisorRedactSecretsRef) => {
+  if (maxChars === 0) {
+    return "";
+  }
+  const entries = ctx.sessionManager.getBranch().map((entry) => conversationEntry(entry, toolResultMaxLines, toolResultMaxBytes, policies, redact)).filter((entry) => entry !== undefined);
+  return selectRecentEntries(entries, maxChars);
+};
+
+// src/scout-protocol.ts
+var invalid = (message) => ({
+  message,
+  ok: false,
+  reason: "invalid-protocol"
+});
+var toolCalls = (message) => contentParts(message.content).filter((part) => isRecord(part) && part.type === "toolCall");
+var toolCallId = (part) => typeof part.id === "string" ? part.id : undefined;
+var indexToolCalls = (entries) => {
+  const callOwners = new Map;
+  const resultsByCall = new Map;
+  const state = { latestUserIndex: -1 };
+  for (let index = 0;index < entries.length; index += 1) {
+    const failure = indexEntry(entries[index], index, callOwners, resultsByCall, state);
+    if (failure) {
+      return failure;
+    }
+  }
+  for (const [id, results] of resultsByCall) {
+    if (results.length > 1) {
+      return invalid(`Tool call ${id} has duplicate result messages.`);
+    }
+  }
+  return {
+    index: {
+      callOwners,
+      latestUserIndex: state.latestUserIndex,
+      resultsByCall
+    },
+    ok: true
+  };
+};
+var indexEntry = (entry, index, callOwners, resultsByCall, state) => {
+  if (entry.type !== "message" || !isRecord(entry.message)) {
+    return;
+  }
+  if (entry.message.role === "user" && textFrom(entry.message.content)) {
+    state.latestUserIndex = index;
+  }
+  if (entry.message.role === "assistant") {
+    return indexAssistantCalls(entry.message, index, callOwners);
+  }
+  if (entry.message.role === "toolResult") {
+    return indexToolResult(entry, entry.message, index, resultsByCall);
+  }
+  return;
+};
+var indexToolResult = (entry, message, index, resultsByCall) => {
+  const id = message.toolCallId;
+  if (typeof id !== "string") {
+    return invalid(`Tool result at context entry ${index} has no tool-call ID.`);
+  }
+  const results = resultsByCall.get(id) ?? [];
+  results.push({ entry, index });
+  resultsByCall.set(id, results);
+  return;
+};
+var indexAssistantCalls = (message, index, callOwners) => {
+  for (const call of toolCalls(message)) {
+    const id = toolCallId(call);
+    if (!id || callOwners.has(id)) {
+      return invalid(`Assistant tool calls at context entry ${index} have missing or duplicate IDs.`);
+    }
+    callOwners.set(id, {
+      index,
+      name: typeof call.name === "string" ? call.name : "unknown"
+    });
+  }
+  return;
+};
+
+// src/scout-types.ts
+var SCOUT_MANIFEST_MAX_BYTES = 64 * 1024;
 var SCOUT_MANIFEST_MAX_GROUPS = 64;
 var SCOUT_GROUP_MAX_BYTES = 24 * 1024;
 var SCOUT_LABEL_MAX_CHARS = 160;
 var SCOUT_SELECTION_MAX_IDS = 32;
 var SCOUT_SYNTHESIS_MAX_BYTES = 4 * 1024;
-var isRecord2 = (value) => Boolean(value) && typeof value === "object";
-var byteLength2 = (value) => Buffer.byteLength(value, "utf8");
+
+// src/scout-groups.ts
 var SPEAKER_PREFIX = /^(User|Executor):\s*/;
-var contentParts2 = (content) => Array.isArray(content) ? content : [];
-var toolCalls = (message) => contentParts2(message.content).filter((part) => isRecord2(part) && part.type === "toolCall");
-var toolCallId = (part) => typeof part.id === "string" ? part.id : undefined;
 var boundedLabel = (value) => [...value.replace(/\s+/g, " ").trim()].slice(0, SCOUT_LABEL_MAX_CHARS).join("");
 var labelFor = (kind, content) => {
   const preview = boundedLabel(content.replace(SPEAKER_PREFIX, ""));
@@ -1660,16 +1931,17 @@ var labelFor = (kind, content) => {
   return boundedLabel(`${prefix[kind]}: ${preview || "(no text)"}`);
 };
 var stableId = (index, entryIds, kind, content) => `g_${createHash("sha256").update(JSON.stringify([index, entryIds, kind, content])).digest("hex").slice(0, 16)}`;
-var groupWireBytes = (group) => byteLength2(JSON.stringify({
+var groupWire = (group) => ({
   bytes: group.bytes,
   content: group.content,
   id: group.id,
   kind: group.kind,
   label: group.label,
   required: group.required
-}));
+});
+var groupWireBytes = (group) => byteLength(JSON.stringify(groupWire(group)));
 var createGroup = (originalIndex, entryIds, kind, content, required) => ({
-  bytes: byteLength2(content),
+  bytes: byteLength(content),
   content,
   id: stableId(originalIndex, entryIds, kind, content),
   kind,
@@ -1678,7 +1950,7 @@ var createGroup = (originalIndex, entryIds, kind, content, required) => ({
   required
 });
 var pendingAdvisorArguments = (value) => {
-  if (!isRecord2(value)) {
+  if (!isRecord(value)) {
     return {};
   }
   const allowed = {};
@@ -1690,241 +1962,166 @@ var pendingAdvisorArguments = (value) => {
   return allowed;
 };
 var pendingInvocationDisclosure = (entry, invocationId, toolResultMaxLines, toolResultMaxBytes, policies, redact, disclosed) => {
-  if (!isRecord2(entry.message)) {
+  if (!isRecord(entry.message)) {
     return disclosed;
   }
-  const content = contentParts2(entry.message.content).map((part) => {
-    if (!isRecord2(part) || part.type !== "toolCall" || toolCallId(part) !== invocationId || part.name !== "ask_advisor") {
+  const content = contentParts(entry.message.content).map((part) => {
+    if (!isRecord(part) || part.type !== "toolCall" || toolCallId(part) !== invocationId || part.name !== "ask_advisor") {
       return part;
     }
     return { ...part, arguments: pendingAdvisorArguments(part.arguments) };
   });
   return conversationEntry({ ...entry, message: { ...entry.message, content } }, toolResultMaxLines, toolResultMaxBytes, policies, redact);
 };
-var buildScoutManifest = (ctx, options = {}) => {
-  const entries = ctx.sessionManager.buildContextEntries();
-  const policies = options.policies ?? advisorToolPoliciesRef;
-  const redact = options.redact ?? advisorRedactSecretsRef;
-  const toolResultMaxLines = options.toolResultMaxLines ?? advisorToolResultMaxLinesRef;
-  const toolResultMaxBytes = options.toolResultMaxBytes ?? advisorToolResultMaxBytesRef;
-  const {
-    maxBytes,
-    maxConversationChars,
-    maxGroupBytes = SCOUT_GROUP_MAX_BYTES,
-    maxGroups = SCOUT_MANIFEST_MAX_GROUPS,
-    maxManifestBytes = maxBytes ?? SCOUT_MANIFEST_MAX_BYTES
-  } = options;
-  let latestUserIndex = -1;
-  const callOwners = new Map;
-  const resultsByCall = new Map;
-  for (let index = 0;index < entries.length; index += 1) {
-    const entry = entries[index];
-    if (entry.type !== "message" || !isRecord2(entry.message)) {
+var toolExchangeGroup = (entry, index, entryId, disclosed, immediate, indexed, consumedResultIndexes, caps) => {
+  const calls = toolCalls(entry.message);
+  const callIds = calls.map(toolCallId);
+  const adjacentFailure = adjacentResultMismatch(immediate, index, callIds, indexed.callOwners);
+  if (adjacentFailure) {
+    return { kind: "invalid", message: adjacentFailure };
+  }
+  const missing = new Set;
+  const resultParts = [];
+  const resultEntryIds = [];
+  const matchFailure = collectResults(calls, callIds, index, indexed.resultsByCall, consumedResultIndexes, caps, missing, resultParts, resultEntryIds);
+  if (matchFailure) {
+    return { kind: "invalid", message: matchFailure };
+  }
+  if (missing.size > 0) {
+    return missingOutcome(entry, index, entryId, disclosed, callIds, missing, resultParts, resultEntryIds, caps);
+  }
+  return {
+    group: createGroup(index, [entryId, ...resultEntryIds], "tool-exchange", [disclosed, ...resultParts].join(`
+
+`), false),
+    kind: "group"
+  };
+};
+var adjacentResultMismatch = (immediate, index, callIds, callOwners) => {
+  const next = immediate;
+  if (next?.type === "message" && isRecord(next.message) && next.message.role === "toolResult" && typeof next.message.toolCallId === "string" && !callIds.includes(next.message.toolCallId) && !callOwners.has(next.message.toolCallId)) {
+    return `Tool result at context entry ${index + 1} does not match its adjacent assistant group.`;
+  }
+  return;
+};
+var collectResults = (calls, callIds, index, resultsByCall, consumedResultIndexes, caps, missing, resultParts, resultEntryIds) => {
+  for (const [callIndex, callId] of callIds.entries()) {
+    const resultMatch = resultsByCall.get(callId)?.[0];
+    if (!resultMatch) {
+      missing.add(callId);
       continue;
     }
-    if (entry.message.role === "user" && textFrom(entry.message.content)) {
-      latestUserIndex = index;
+    if (resultMatch.index <= index) {
+      return `Tool result at context entry ${resultMatch.index} precedes its assistant call.`;
     }
-    if (entry.message.role === "assistant") {
-      for (const call of toolCalls(entry.message)) {
-        const id = toolCallId(call);
-        if (!id || callOwners.has(id)) {
-          return {
-            message: `Assistant tool calls at context entry ${index} have missing or duplicate IDs.`,
-            ok: false,
-            reason: "invalid-protocol"
-          };
-        }
-        callOwners.set(id, {
-          index,
-          name: typeof call.name === "string" ? call.name : "unknown"
-        });
-      }
-    } else if (entry.message.role === "toolResult") {
-      const id = entry.message.toolCallId;
-      if (typeof id !== "string") {
-        return {
-          message: `Tool result at context entry ${index} has no tool-call ID.`,
-          ok: false,
-          reason: "invalid-protocol"
-        };
-      }
-      const results = resultsByCall.get(id) ?? [];
-      results.push({ entry, index });
-      resultsByCall.set(id, results);
+    const resultMessage = resultMatch.entry.message;
+    const expectedName = typeof calls[callIndex].name === "string" ? calls[callIndex].name : "unknown";
+    if (!isRecord(resultMessage) || resultMessage.toolName !== expectedName) {
+      return `Tool result at context entry ${resultMatch.index} conflicts with call ${callId}.`;
     }
-  }
-  for (const [id, results] of resultsByCall) {
-    if (results.length > 1) {
-      return {
-        message: `Tool call ${id} has duplicate result messages.`,
-        ok: false,
-        reason: "invalid-protocol"
-      };
+    consumedResultIndexes.add(resultMatch.index);
+    const resultText = conversationEntry(resultMatch.entry, caps.toolResultMaxLines, caps.toolResultMaxBytes, caps.policies, caps.redact);
+    if (resultText) {
+      resultParts.push(resultText);
     }
+    resultEntryIds.push(typeof resultMatch.entry.id === "string" ? resultMatch.entry.id : String(resultMatch.index));
   }
+  return;
+};
+var missingOutcome = (entry, index, entryId, disclosed, callIds, missing, resultParts, resultEntryIds, caps) => {
+  const { currentInvocationId } = caps;
+  const pendingCurrentInvocation = currentInvocationId !== undefined && missing.size === 1 && missing.has(currentInvocationId) && callIds.includes(currentInvocationId);
+  if (!pendingCurrentInvocation) {
+    return {
+      bytes: byteLength([disclosed, ...resultParts].join(`
+
+`)),
+      kind: "omitted"
+    };
+  }
+  const pendingDisclosed = pendingInvocationDisclosure(entry, currentInvocationId, caps.toolResultMaxLines, caps.toolResultMaxBytes, caps.policies, caps.redact, disclosed);
+  return {
+    group: createGroup(index, [entryId, ...resultEntryIds], "pending-invocation", [pendingDisclosed ?? disclosed, ...resultParts].join(`
+
+`), true),
+    kind: "group"
+  };
+};
+var buildGroups = (entries, indexed, caps) => {
   const groups = [];
   const consumedResultIndexes = new Set;
   let protocolOmittedBytes = 0;
   let protocolOmittedCount = 0;
   for (let index = 0;index < entries.length; index += 1) {
     const entry = entries[index];
-    const disclosed = conversationEntry(entry, toolResultMaxLines, toolResultMaxBytes, policies, redact);
+    const disclosed = conversationEntry(entry, caps.toolResultMaxLines, caps.toolResultMaxBytes, caps.policies, caps.redact);
     if (!disclosed) {
       continue;
     }
-    const entryId = typeof entry.id === "string" ? entry.id : String(index);
-    if (entry.type !== "message" || !isRecord2(entry.message)) {
-      groups.push(createGroup(index, [entryId], "compaction", disclosed, false));
-      continue;
+    const outcome = groupForEntry(entry, index, disclosed, entries[index + 1], indexed, consumedResultIndexes, caps);
+    if (outcome.kind === "invalid") {
+      return invalid(outcome.message);
     }
-    const { message } = entry;
-    if (message.role === "user") {
-      groups.push(createGroup(index, [entryId], "user", disclosed, index === latestUserIndex));
-      continue;
-    }
-    if (message.role === "toolResult") {
-      if (consumedResultIndexes.has(index)) {
-        continue;
-      }
-      const resultId = message.toolCallId;
-      const owner = typeof resultId === "string" ? callOwners.get(resultId) : undefined;
-      if (owner) {
-        return {
-          message: `Tool result at context entry ${index} precedes or conflicts with its retained call.`,
-          ok: false,
-          reason: "invalid-protocol"
-        };
-      }
+    if (outcome.kind === "omitted") {
       protocolOmittedCount += 1;
-      protocolOmittedBytes += byteLength2(disclosed);
-      continue;
-    }
-    if (message.role !== "assistant") {
-      continue;
-    }
-    const calls = toolCalls(message);
-    if (calls.length === 0) {
-      groups.push(createGroup(index, [entryId], "assistant", disclosed, false));
-      continue;
-    }
-    const callIds = calls.map(toolCallId);
-    const immediate = entries[index + 1];
-    if (immediate?.type === "message" && isRecord2(immediate.message) && immediate.message.role === "toolResult" && typeof immediate.message.toolCallId === "string" && !callIds.includes(immediate.message.toolCallId) && !callOwners.has(immediate.message.toolCallId)) {
-      return {
-        message: `Tool result at context entry ${index + 1} does not match its adjacent assistant group.`,
-        ok: false,
-        reason: "invalid-protocol"
-      };
-    }
-    const missing = new Set;
-    const resultParts = [];
-    const resultEntryIds = [];
-    for (const [callIndex, callId] of callIds.entries()) {
-      const resultMatch = resultsByCall.get(callId)?.[0];
-      if (!resultMatch) {
-        missing.add(callId);
-        continue;
-      }
-      if (resultMatch.index <= index) {
-        return {
-          message: `Tool result at context entry ${resultMatch.index} precedes its assistant call.`,
-          ok: false,
-          reason: "invalid-protocol"
-        };
-      }
-      const resultMessage = resultMatch.entry.message;
-      const expectedName = typeof calls[callIndex].name === "string" ? calls[callIndex].name : "unknown";
-      if (!isRecord2(resultMessage) || resultMessage.toolName !== expectedName) {
-        return {
-          message: `Tool result at context entry ${resultMatch.index} conflicts with call ${callId}.`,
-          ok: false,
-          reason: "invalid-protocol"
-        };
-      }
-      consumedResultIndexes.add(resultMatch.index);
-      const resultText = conversationEntry(resultMatch.entry, toolResultMaxLines, toolResultMaxBytes, policies, redact);
-      if (resultText) {
-        resultParts.push(resultText);
-      }
-      resultEntryIds.push(typeof resultMatch.entry.id === "string" ? resultMatch.entry.id : String(resultMatch.index));
-    }
-    if (missing.size > 0) {
-      const { currentInvocationId } = options;
-      const pendingCurrentInvocation = currentInvocationId !== undefined && missing.size === 1 && missing.has(currentInvocationId) && callIds.includes(currentInvocationId);
-      if (!pendingCurrentInvocation) {
-        protocolOmittedCount += 1;
-        protocolOmittedBytes += byteLength2([disclosed, ...resultParts].join(`
-
-`));
-        continue;
-      }
-      const pendingDisclosed = pendingInvocationDisclosure(entry, currentInvocationId, toolResultMaxLines, toolResultMaxBytes, policies, redact, disclosed);
-      groups.push(createGroup(index, [entryId, ...resultEntryIds], "pending-invocation", [pendingDisclosed ?? disclosed, ...resultParts].join(`
-
-`), true));
-      continue;
+      protocolOmittedBytes += outcome.bytes;
+    } else if (outcome.kind === "group") {
+      groups.push(outcome.group);
     }
-    groups.push(createGroup(index, [entryId, ...resultEntryIds], "tool-exchange", [disclosed, ...resultParts].join(`
-
-`), false));
   }
-  const availableCount = groups.length + protocolOmittedCount;
-  const availableBytes = groups.reduce((sum, group) => sum + groupWireBytes(group), 0) + protocolOmittedBytes;
-  if (maxManifestBytes <= 0) {
+  return {
+    groups,
+    ok: true,
+    protocolOmittedBytes,
+    protocolOmittedCount
+  };
+};
+var groupForEntry = (entry, index, disclosed, immediate, indexed, consumedResultIndexes, caps) => {
+  const entryId = typeof entry.id === "string" ? entry.id : String(index);
+  if (entry.type !== "message" || !isRecord(entry.message)) {
     return {
-      manifest: {
-        availableBytes: 0,
-        availableCount: 0,
-        groups: [],
-        omittedBytes: 0,
-        omittedCount: 0
-      },
-      ok: true
+      group: createGroup(index, [entryId], "compaction", disclosed, false),
+      kind: "group"
     };
   }
-  const required = groups.filter((group) => group.required);
-  if (required.some((group) => group.bytes > maxGroupBytes) || required.length > maxGroups || required.reduce((sum, group) => sum + groupWireBytes(group), 0) > maxManifestBytes) {
+  const { message } = entry;
+  if (message.role === "user") {
     return {
-      message: "Required Scout context exceeds the Scout manifest transport limit.",
-      ok: false,
-      reason: "required-group-overflow"
+      group: createGroup(index, [entryId], "user", disclosed, index === indexed.latestUserIndex),
+      kind: "group"
     };
   }
-  const contentChars = (items) => items.reduce((sum, group) => sum + group.content.length, 0) + Math.max(0, items.length - 1) * 2;
-  if (maxConversationChars !== undefined && contentChars(required) > maxConversationChars) {
+  if (message.role === "toolResult") {
+    return toolResultOutcome(message, index, disclosed, indexed.callOwners, consumedResultIndexes);
+  }
+  if (message.role !== "assistant") {
+    return { kind: "skipped" };
+  }
+  if (!hasCalls(message)) {
     return {
-      message: "Required Scout context exceeds the Advisor conversation budget.",
-      ok: false,
-      reason: "required-group-overflow"
+      group: createGroup(index, [entryId], "assistant", disclosed, false),
+      kind: "group"
     };
   }
-  const selected = groups.filter((group) => group.required || group.bytes <= maxGroupBytes);
-  const fits = () => selected.length <= maxGroups && selected.reduce((sum, group) => sum + groupWireBytes(group), 0) <= maxManifestBytes && (maxConversationChars === undefined || contentChars(selected) <= maxConversationChars);
-  while (!fits()) {
-    const optionalIndex = selected.findIndex((group) => !group.required);
-    if (optionalIndex < 0) {
-      return {
-        message: "Required Scout context exceeds fixed manifest limits.",
-        ok: false,
-        reason: "required-group-overflow"
-      };
-    }
-    selected.splice(optionalIndex, 1);
+  return toolExchangeGroup(entry, index, entryId, disclosed, immediate, indexed, consumedResultIndexes, caps);
+};
+var toolResultOutcome = (message, index, disclosed, callOwners, consumedResultIndexes) => {
+  if (consumedResultIndexes.has(index)) {
+    return { kind: "skipped" };
   }
-  const selectedIds = new Set(selected.map((group) => group.id));
-  const omitted = groups.filter((group) => !selectedIds.has(group.id));
-  return {
-    manifest: {
-      availableBytes,
-      availableCount,
-      groups: selected,
-      omittedBytes: protocolOmittedBytes + omitted.reduce((sum, group) => sum + group.bytes, 0),
-      omittedCount: protocolOmittedCount + omitted.length
-    },
-    ok: true
-  };
+  if (ownerOf(message, callOwners)) {
+    return {
+      kind: "invalid",
+      message: `Tool result at context entry ${index} precedes or conflicts with its retained call.`
+    };
+  }
+  return { bytes: byteLength(disclosed), kind: "omitted" };
 };
+var ownerOf = (message, callOwners) => typeof message.toolCallId === "string" ? callOwners.get(message.toolCallId) : undefined;
+var hasCalls = (message) => contentPartsOf(message).some((part) => isRecord(part) && part.type === "toolCall");
+var contentPartsOf = (message) => Array.isArray(message.content) ? message.content : [];
+
+// src/scout-reconstruct.ts
 var prefixWithinCharBudget = (value, maxChars) => {
   let result = "";
   for (const character of value) {
@@ -1965,13 +2162,12 @@ ${synthesis.trim()}` : undefined;
 // src/usage.ts
 var finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 var add = (left, right) => left === undefined || right === undefined ? left ?? right : left + right;
-var isRecord3 = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 var costFields = ["input", "output", "cacheRead", "cacheWrite", "total"];
 var snapshotAdvisorUsage = (usage) => {
-  if (!isRecord3(usage)) {
+  if (!isRecord(usage)) {
     return;
   }
-  const cost = isRecord3(usage.cost) ? usage.cost : undefined;
+  const cost = isRecord(usage.cost) ? usage.cost : undefined;
   const snapshot = {
     cacheRead: finite(usage.cacheRead),
     cacheWrite: finite(usage.cacheWrite),
@@ -1986,10 +2182,10 @@ var snapshotAdvisorUsage = (usage) => {
 var advisorUsageCost = (usage) => snapshotAdvisorUsage(usage)?.cost;
 var advisorUsageForPi = (usage) => {
   const snapshot = snapshotAdvisorUsage(usage);
-  if (!(snapshot && isRecord3(usage))) {
+  if (!(snapshot && isRecord(usage))) {
     return;
   }
-  const cost = isRecord3(usage.cost) ? usage.cost : undefined;
+  const cost = isRecord(usage.cost) ? usage.cost : undefined;
   const input = snapshot.input ?? 0;
   const output = snapshot.output ?? 0;
   const cacheRead = snapshot.cacheRead ?? 0;
@@ -2105,20 +2301,13 @@ var defaultDependencies = {
   collect: collectTextStream,
   resolve: resolveConfiguredModel
 };
-var byteLength3 = (value) => Buffer.byteLength(value, "utf8");
+var byteLength2 = (value) => Buffer.byteLength(value, "utf8");
 var AUTH_ERROR_PATTERN = /api key|auth|login|credential/i;
 var manifestMessage = (manifest) => ({
   content: [
     {
       text: JSON.stringify({
-        groups: manifest.groups.map((group) => ({
-          bytes: group.bytes,
-          content: group.content,
-          id: group.id,
-          kind: group.kind,
-          label: group.label,
-          required: group.required
-        })),
+        groups: manifest.groups.map(groupWire),
         omittedBeforeScout: {
           bytes: manifest.omittedBytes,
           groups: manifest.omittedCount
@@ -2168,7 +2357,7 @@ var parseScoutSelection = (text, manifest) => {
   if (typeof record.synthesis !== "string") {
     throw new Error("Scout synthesis must be a string.");
   }
-  if (byteLength3(record.synthesis) > SCOUT_SYNTHESIS_MAX_BYTES) {
+  if (byteLength2(record.synthesis) > SCOUT_SYNTHESIS_MAX_BYTES) {
     throw new Error(`Scout synthesis exceeds ${SCOUT_SYNTHESIS_MAX_BYTES} UTF-8 bytes.`);
   }
   return {
@@ -2197,32 +2386,36 @@ var runAdvisorScout = async (ctx, manifest, parentSignal, onEvent, timeoutMs = S
   const publish = (event) => {
     onEvent?.(event);
   };
-  if (parentSignal?.aborted) {
+  const cancelled = () => {
     publish({ type: "cancelled" });
     return { cancelled: true, ok: false };
+  };
+  const fallback = (category, message, usage) => {
+    const outcome = {
+      category,
+      message,
+      metrics: usage === undefined ? baseMetrics(manifest, startedAt) : { ...baseMetrics(manifest, startedAt), usage },
+      model: executorRef,
+      ok: false
+    };
+    publish({ outcome, type: "fallback" });
+    return outcome;
+  };
+  if (parentSignal?.aborted) {
+    return cancelled();
   }
   let resolved;
   try {
     resolved = await dependencies.resolve(ctx, executorRef, "Scout");
   } catch (error) {
     if (parentSignal?.aborted) {
-      publish({ type: "cancelled" });
-      return { cancelled: true, ok: false };
+      return cancelled();
     }
     const message = error instanceof Error ? error.message : String(error);
-    const outcome = {
-      category: classifyResolutionError(message),
-      message,
-      metrics: baseMetrics(manifest, startedAt),
-      model: executorRef,
-      ok: false
-    };
-    publish({ outcome, type: "fallback" });
-    return outcome;
+    return fallback(classifyResolutionError(message), message);
   }
   if (parentSignal?.aborted) {
-    publish({ type: "cancelled" });
-    return { cancelled: true, ok: false };
+    return cancelled();
   }
   publish({ model: executorRef, type: "call" });
   const controller = new AbortController;
@@ -2242,6 +2435,11 @@ var runAdvisorScout = async (ctx, manifest, parentSignal, onEvent, timeoutMs = S
       once: true
     });
   });
+  const teardown = () => {
+    clearTimeout(timer);
+    parentSignal?.removeEventListener("abort", abortFromParent);
+    controller.signal.removeEventListener("abort", onControllerAbort);
+  };
   let streamed;
   try {
     const collection = dependencies.collect(resolved, {
@@ -2255,50 +2453,25 @@ var runAdvisorScout = async (ctx, manifest, parentSignal, onEvent, timeoutMs = S
       signal: controller.signal,
       systemPrompt: SCOUT_SYSTEM
     });
-    streamed = await Promise.race([collection, abortPromise]);
-  } catch (error) {
-    clearTimeout(timer);
-    parentSignal?.removeEventListener("abort", abortFromParent);
-    controller.signal.removeEventListener("abort", onControllerAbort);
+    streamed = await Promise.race([collection, abortPromise]);
+  } catch (error) {
+    teardown();
     if (parentSignal?.aborted) {
-      publish({ type: "cancelled" });
-      return { cancelled: true, ok: false };
+      return cancelled();
     }
     const message = error instanceof Error ? error.message : String(error);
-    const outcome = {
-      category: timedOut ? "timeout" : "provider-error",
-      message: timedOut ? `Scout timed out after ${timeoutMs} ms.` : message,
-      metrics: baseMetrics(manifest, startedAt),
-      model: executorRef,
-      ok: false
-    };
-    publish({ outcome, type: "fallback" });
-    return outcome;
+    return timedOut ? fallback("timeout", `Scout timed out after ${timeoutMs} ms.`) : fallback("provider-error", message);
   }
-  clearTimeout(timer);
-  parentSignal?.removeEventListener("abort", abortFromParent);
-  controller.signal.removeEventListener("abort", onControllerAbort);
+  teardown();
   if (parentSignal?.aborted) {
-    publish({ type: "cancelled" });
-    return { cancelled: true, ok: false };
+    return cancelled();
   }
   let selection;
   try {
     selection = parseScoutSelection(streamed.text, manifest);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    const outcome = {
-      category: streamed.text.trim() ? "invalid-selection" : "empty-response",
-      message,
-      metrics: {
-        ...baseMetrics(manifest, startedAt),
-        usage: snapshotAdvisorUsage(streamed.usage)
-      },
-      model: executorRef,
-      ok: false
-    };
-    publish({ outcome, type: "fallback" });
-    return outcome;
+    return fallback(streamed.text.trim() ? "invalid-selection" : "empty-response", message, snapshotAdvisorUsage(streamed.usage));
   }
   const outcome = {
     conversation: reconstructScoutConversation(manifest, selection.selectedIds, selection.synthesis),
@@ -2319,234 +2492,137 @@ var runAdvisorScout = async (ctx, manifest, parentSignal, onEvent, timeoutMs = S
   return outcome;
 };
 
-// src/untracked.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { constants } from "node:fs";
-import { lstat as lstat2, open as open2, realpath as realpath2 } from "node:fs/promises";
-import { isAbsolute, relative as relative2, resolve } from "node:path";
-var ADVISOR_FILE_MAX_BYTES = 8 * 1024;
-var ADVISOR_FILES_TOTAL_MAX_BYTES = 24 * 1024;
-var PATH_SEGMENTS = /[\\/]/;
-var within = (root, candidate) => {
-  const path = relative2(root, candidate);
-  return path !== "" && !path.startsWith("..") && !path.includes("../");
-};
-var normalizeRelativePath = (root, path) => relative2(root, resolve(root, path));
-var normalizeRequestedPath = (root, value) => {
-  if (typeof value !== "string" || !value || isAbsolute(value) || value.split(PATH_SEGMENTS).includes("..")) {
-    return;
-  }
-  return normalizeRelativePath(root, value);
-};
-var git = (cwd, args) => execFileSync2("git", args, {
-  cwd,
-  encoding: "utf8",
-  maxBuffer: 16 * 1024 * 1024,
-  shell: false,
-  stdio: ["ignore", "pipe", "pipe"],
-  timeout: 5000,
-  windowsHide: true
+// src/scout-context.ts
+var resolveCaps = (options) => ({
+  currentInvocationId: options.currentInvocationId,
+  maxConversationChars: options.maxConversationChars,
+  maxGroupBytes: options.maxGroupBytes ?? SCOUT_GROUP_MAX_BYTES,
+  maxGroups: options.maxGroups ?? SCOUT_MANIFEST_MAX_GROUPS,
+  maxManifestBytes: options.maxManifestBytes ?? options.maxBytes ?? SCOUT_MANIFEST_MAX_BYTES,
+  policies: options.policies ?? advisorToolPoliciesRef,
+  redact: options.redact ?? advisorRedactSecretsRef,
+  toolResultMaxBytes: options.toolResultMaxBytes ?? advisorToolResultMaxBytesRef,
+  toolResultMaxLines: options.toolResultMaxLines ?? advisorToolResultMaxLinesRef
 });
-var repositoryRoot = (cwd) => {
-  try {
-    return realpath2(git(cwd, ["rev-parse", "--show-toplevel"]).trim());
-  } catch {
-    return Promise.resolve(undefined);
-  }
-};
-var untracked = (cwd, path) => {
-  const output = git(cwd, [
-    "ls-files",
-    "--others",
-    "--exclude-standard",
-    "-z",
-    "--",
-    path
-  ]);
-  const expected = normalizeRelativePath(cwd, path);
-  return output.split("\x00").filter(Boolean).some((entry) => normalizeRelativePath(cwd, entry) === expected);
-};
-var tracked = (cwd, path) => {
-  const output = git(cwd, ["ls-files", "--stage", "-z", "--", path]);
-  const expected = normalizeRelativePath(cwd, path);
-  return output.split("\x00").some((entry) => {
-    if (!entry) {
-      return false;
-    }
-    const [metadata, name] = entry.split("\t");
-    return name && normalizeRelativePath(cwd, name) === expected && !metadata.startsWith("160000 ");
-  });
-};
-var isPermitted = (root, path, kind) => kind === "tracked" ? tracked(root, path) : untracked(root, path);
-var readAttachment = async (root, normalizedName, redact, available) => {
-  const absolute = resolve(root, normalizedName);
-  if (!(within(root, absolute) && available > 0)) {
-    return;
-  }
-  const stats = await lstat2(absolute);
-  if (stats.isSymbolicLink() || !stats.isFile()) {
-    return;
+var buildScoutManifest = (ctx, options = {}) => {
+  const entries = ctx.sessionManager.buildContextEntries();
+  const caps = resolveCaps(options);
+  const indexed = indexToolCalls(entries);
+  if (!indexed.ok) {
+    return indexed;
   }
-  const resolved = await realpath2(absolute);
-  if (!within(root, resolved)) {
-    return;
+  const built = buildGroups(entries, indexed.index, caps);
+  if (!built.ok) {
+    return built;
   }
-  const flags = constants.O_NOFOLLOW ? constants.O_RDONLY | constants.O_NOFOLLOW : constants.O_RDONLY;
-  const file = await open2(resolved, flags);
-  try {
-    const openedStats = await file.stat();
-    if (!openedStats.isFile()) {
-      return;
-    }
-    const buffer = Buffer.alloc(available + 1);
-    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
-    const raw = buffer.subarray(0, bytesRead).toString("utf8");
-    if (raw.includes("\x00")) {
-      return;
-    }
-    const text = redactAndCapText(raw, available, redact);
+  return fitToBudget(built, caps);
+};
+var fits = (selected, caps) => selected.length <= caps.maxGroups && selected.reduce((sum, group) => sum + groupWireBytes(group), 0) <= caps.maxManifestBytes && (caps.maxConversationChars === undefined || contentChars(selected) <= caps.maxConversationChars);
+var contentChars = (items) => items.reduce((sum, group) => sum + group.content.length, 0) + Math.max(0, items.length - 1) * 2;
+var fitToBudget = (built, caps) => {
+  const { groups, protocolOmittedBytes, protocolOmittedCount } = built;
+  const availableCount = groups.length + protocolOmittedCount;
+  const availableBytes = groups.reduce((sum, group) => sum + groupWireBytes(group), 0) + protocolOmittedBytes;
+  if (caps.maxManifestBytes <= 0) {
     return {
-      bytes: Buffer.byteLength(text, "utf8"),
-      path: normalizedName,
-      text
+      manifest: {
+        availableBytes: 0,
+        availableCount: 0,
+        groups: [],
+        omittedBytes: 0,
+        omittedCount: 0
+      },
+      ok: true
     };
-  } finally {
-    await file.close();
-  }
-};
-var readFiles = async (cwd, requested, enabled, redact, kind, totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES) => {
-  if (!(enabled && Array.isArray(requested))) {
-    return [];
   }
-  const root = await repositoryRoot(cwd);
-  if (!root) {
-    return [];
-  }
-  const unique = new Set;
-  const attachments = [];
-  let total = 0;
-  for (const name of requested) {
-    const normalizedName = normalizeRequestedPath(root, name);
-    if (!normalizedName || unique.has(normalizedName)) {
-      continue;
-    }
-    unique.add(normalizedName);
-    try {
-      if (!isPermitted(root, normalizedName, kind)) {
-        continue;
-      }
-      const available = Math.min(ADVISOR_FILE_MAX_BYTES, totalLimit - total);
-      if (available <= 0) {
-        break;
-      }
-      const attachment = await readAttachment(root, normalizedName, redact, available);
-      if (attachment) {
-        attachments.push(attachment);
-        total += attachment.bytes;
-      }
-    } catch {}
+  const required = groups.filter((group) => group.required);
+  const overflow = requiredOverflow(required, caps);
+  if (overflow) {
+    return overflow;
   }
-  return attachments;
-};
-var readTrackedFiles = (cwd, requested, enabled, redact, totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES) => readFiles(cwd, requested, enabled, redact, "tracked", totalLimit);
-var readUntrackedFiles = (cwd, requested, enabled, redact, totalLimit = ADVISOR_FILES_TOTAL_MAX_BYTES) => readFiles(cwd, requested, enabled, redact, "untracked", totalLimit);
-
-// src/tools/gate-protocol.ts
-var DECISION_LINE = /^Decision\s*:\s*(proceed|revise|blocked)\s*$/i;
-var CODE_FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-var LINE_BREAK = /\r?\n/;
-var advanceFence = (openingFence, marker, suffix) => {
-  if (!openingFence) {
-    if (marker[0] === "`" && suffix.includes("`")) {
-      return { closed: false, openingFence: undefined };
+  const selected = groups.filter((group) => group.required || group.bytes <= caps.maxGroupBytes);
+  while (!fits(selected, caps)) {
+    const optionalIndex = selected.findIndex((group) => !group.required);
+    if (optionalIndex < 0) {
+      return {
+        message: "Required Scout context exceeds fixed manifest limits.",
+        ok: false,
+        reason: "required-group-overflow"
+      };
     }
-    return {
-      closed: false,
-      openingFence: { character: marker[0], length: marker.length }
-    };
-  }
-  if (suffix.trim().length > 0 || marker[0] !== openingFence.character || marker.length < openingFence.length) {
-    return { closed: false, openingFence };
+    selected.splice(optionalIndex, 1);
   }
-  return { closed: true, openingFence: undefined };
+  const selectedIds = new Set(selected.map((group) => group.id));
+  const omitted = groups.filter((group) => !selectedIds.has(group.id));
+  return {
+    manifest: {
+      availableBytes,
+      availableCount,
+      groups: selected,
+      omittedBytes: protocolOmittedBytes + omitted.reduce((sum, group) => sum + group.bytes, 0),
+      omittedCount: protocolOmittedCount + omitted.length
+    },
+    ok: true
+  };
 };
-var parseAutomaticDecision = (text) => {
-  const lines = text.split(LINE_BREAK);
-  const nonEmpty = lines.findIndex((line) => line.trim().length > 0);
-  if (nonEmpty === -1) {
+var requiredOverflow = (required, caps) => {
+  if (required.some((group) => group.bytes > caps.maxGroupBytes) || required.length > caps.maxGroups || required.reduce((sum, group) => sum + groupWireBytes(group), 0) > caps.maxManifestBytes) {
     return {
-      category: "empty-response",
-      message: "Advisor returned an empty gate response.",
-      ok: false
+      message: "Required Scout context exceeds the Scout manifest transport limit.",
+      ok: false,
+      reason: "required-group-overflow"
     };
   }
-  const first = lines[nonEmpty].trim();
-  const match = DECISION_LINE.exec(first);
-  if (!match) {
+  if (caps.maxConversationChars !== undefined && contentChars(required) > caps.maxConversationChars) {
     return {
-      category: first.toLowerCase().startsWith("decision:") ? "malformed-decision" : "missing-decision",
-      markdown: text,
-      message: "Advisor gate response must begin with Decision: proceed, Decision: revise, or Decision: blocked.",
-      ok: false
+      message: "Required Scout context exceeds the Advisor conversation budget.",
+      ok: false,
+      reason: "required-group-overflow"
     };
   }
-  const decision = match[1].toLowerCase();
-  let openingFence;
-  const decisions = [];
-  let pendingFencedDecisions = [];
-  for (const line of lines.slice(nonEmpty + 1)) {
-    const trimmed = line.trim();
-    const fence = CODE_FENCE.exec(line);
-    if (fence) {
-      const { closed, openingFence: nextOpeningFence } = advanceFence(openingFence, fence[1], fence[2]);
-      openingFence = nextOpeningFence;
-      if (closed) {
-        pendingFencedDecisions = [];
-      }
-      continue;
-    }
-    const subsequent = DECISION_LINE.exec(trimmed);
-    if (!subsequent) {
-      continue;
-    }
-    const repeated = subsequent[1].trim().toLowerCase();
-    if (openingFence) {
-      pendingFencedDecisions.push(repeated);
-    } else {
-      decisions.push(repeated);
-    }
-  }
-  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.",
+  return;
+};
+
+// src/scout-curation.ts
+var curateAdvisorConversation = async (ctx, legacyConversation, signal, onScout, enabled = advisorScoutEnabledRef, runScout = runAdvisorScout, currentInvocationId, maxChars) => {
+  if (!enabled) {
+    return { conversation: legacyConversation };
+  }
+  if (maxChars !== undefined && maxChars <= 0) {
+    return { conversation: "" };
+  }
+  const built = buildScoutManifest(ctx, {
+    currentInvocationId,
+    maxConversationChars: maxChars,
+    maxManifestBytes: SCOUT_MANIFEST_MAX_BYTES
+  });
+  if (!built.ok) {
+    const scout = {
+      category: built.reason,
+      message: built.message,
+      metrics: {
+        availableCount: 0,
+        inputBytes: 0,
+        latencyMs: 0,
+        omittedBeforeScout: 0,
+        selectedCount: 0
+      },
+      model: executorRef,
       ok: false
     };
+    onScout?.({ outcome: scout, type: "fallback" });
+    return { conversation: legacyConversation, scout };
   }
-  return {
-    decision,
-    markdown: text,
-    model: "",
-    ok: true,
-    thinkingText: "",
-    trigger: "repeated-tool-call"
-  };
+  const outcome = await runScout(ctx, built.manifest, signal, onScout, undefined, undefined);
+  if (!outcome.ok && outcome.cancelled) {
+    throw signal?.reason instanceof Error ? signal.reason : new Error("Advisor operation cancelled during Scout.");
+  }
+  let conversation = legacyConversation;
+  if (outcome.ok) {
+    conversation = maxChars === undefined ? outcome.conversation : reconstructScoutConversation(built.manifest, outcome.selection.selectedIds, outcome.selection.synthesis, maxChars);
+  }
+  return { conversation, scout: outcome };
 };
-var adviceForGateText = (result) => `**Decision: ${result.decision}**
-
-${result.markdown}`;
 
 // src/tools/prompts.ts
 var advisorMessageText = (conversation, question, changes, draft, preferences, untracked, tracked) => {
@@ -2657,72 +2733,152 @@ var ADVISOR_DECISION_SYSTEM = [
   "Use blocked only for a critical issue requiring the user. Never claim verification that the supplied evidence does not show."
 ].join(" ");
 
-// src/tools/consultation.ts
-var curateAdvisorConversation = async (ctx, legacyConversation, signal, onScout, enabled = advisorScoutEnabledRef, runScout = runAdvisorScout, currentInvocationId, maxChars) => {
-  if (!enabled) {
-    return { conversation: legacyConversation };
+// src/tools/consult-context.ts
+var ATTACHMENT_TEXT_MAX_BYTES = 8 * 1024;
+var ATTACHMENTS_TOTAL_MAX_BYTES = 24 * 1024;
+var assembleConsultationContext = async (options) => {
+  const { ctx } = options;
+  const allowed = advisorGitContextRef;
+  const level = clampGitContextLevel(options.gitContext ?? allowed, allowed);
+  const gitBudget = advisorGitContextBudget(contextMaxCharsRef, advisorGitContextMaxCharsRef);
+  const changes = collectGitContext(ctx.cwd, level, gitBudget, advisorRedactSecretsRef ? redactSecrets : undefined);
+  const changeText = advisorRepositoryContext(changes, options.gitContext ?? allowed, level, gitBudget);
+  const conversationBudget = Math.max(0, contextMaxCharsRef - changeText.length);
+  const legacyConversation = advisorRequestConversation(ctx, conversationBudget);
+  const curated = await curateAdvisorConversation(ctx, legacyConversation, options.signal, options.onScout, advisorScoutEnabledRef, runAdvisorScout, options.currentInvocationId, conversationBudget);
+  const preferences = await readProjectPreferences(ctx, ATTACHMENT_TEXT_MAX_BYTES, advisorRedactSecretsRef);
+  const draftText = options.draft ? redactAndCapText(options.draft, ATTACHMENT_TEXT_MAX_BYTES, advisorRedactSecretsRef) : undefined;
+  const untracked = await readUntrackedFiles(ctx.cwd, options.includeUntracked ?? [], advisorUntrackedContentRef, advisorRedactSecretsRef);
+  const tracked = await readTrackedFiles(ctx.cwd, options.includeTracked ?? [], advisorTrackedFileContentRef, advisorRedactSecretsRef, Math.max(0, ATTACHMENTS_TOTAL_MAX_BYTES - untracked.reduce((sum, item) => sum + item.bytes, 0)));
+  return {
+    changeText,
+    conversation: curated.conversation,
+    draftText,
+    preferences,
+    scout: curated.scout,
+    tracked,
+    untracked
+  };
+};
+
+// src/tools/gate-protocol.ts
+var DECISION_LINE = /^Decision\s*:\s*(proceed|revise|blocked)\s*$/i;
+var CODE_FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+var LINE_BREAK = /\r?\n/;
+var advanceFence = (openingFence, marker, suffix) => {
+  if (!openingFence) {
+    if (marker[0] === "`" && suffix.includes("`")) {
+      return { closed: false, openingFence: undefined };
+    }
+    return {
+      closed: false,
+      openingFence: { character: marker[0], length: marker.length }
+    };
   }
-  if (maxChars !== undefined && maxChars <= 0) {
-    return { conversation: "" };
+  if (suffix.trim().length > 0 || marker[0] !== openingFence.character || marker.length < openingFence.length) {
+    return { closed: false, openingFence };
   }
-  const built = buildScoutManifest(ctx, {
-    currentInvocationId,
-    maxConversationChars: maxChars,
-    maxManifestBytes: SCOUT_MANIFEST_MAX_BYTES
-  });
-  if (!built.ok) {
-    const scout = {
-      category: built.reason,
-      message: built.message,
-      metrics: {
-        availableCount: 0,
-        inputBytes: 0,
-        latencyMs: 0,
-        omittedBeforeScout: 0,
-        selectedCount: 0
-      },
-      model: executorRef,
+  return { closed: true, openingFence: undefined };
+};
+var parseAutomaticDecision = (text) => {
+  const lines = text.split(LINE_BREAK);
+  const nonEmpty = lines.findIndex((line) => line.trim().length > 0);
+  if (nonEmpty === -1) {
+    return {
+      category: "empty-response",
+      message: "Advisor returned an empty gate response.",
       ok: false
     };
-    onScout?.({ outcome: scout, type: "fallback" });
-    return { conversation: legacyConversation, scout };
   }
-  const outcome = await runScout(ctx, built.manifest, signal, onScout, undefined, undefined);
-  if (!outcome.ok && outcome.cancelled) {
-    throw signal?.reason instanceof Error ? signal.reason : new Error("Advisor operation cancelled during Scout.");
+  const first = lines[nonEmpty].trim();
+  const match = DECISION_LINE.exec(first);
+  if (!match) {
+    return {
+      category: first.toLowerCase().startsWith("decision:") ? "malformed-decision" : "missing-decision",
+      markdown: text,
+      message: "Advisor gate response must begin with Decision: proceed, Decision: revise, or Decision: blocked.",
+      ok: false
+    };
   }
-  let conversation = legacyConversation;
-  if (outcome.ok) {
-    conversation = maxChars === undefined ? outcome.conversation : reconstructScoutConversation(built.manifest, outcome.selection.selectedIds, outcome.selection.synthesis, maxChars);
+  const decision = match[1].toLowerCase();
+  let openingFence;
+  const decisions = [];
+  let pendingFencedDecisions = [];
+  for (const line of lines.slice(nonEmpty + 1)) {
+    const trimmed = line.trim();
+    const fence = CODE_FENCE.exec(line);
+    if (fence) {
+      const { closed, openingFence: nextOpeningFence } = advanceFence(openingFence, fence[1], fence[2]);
+      openingFence = nextOpeningFence;
+      if (closed) {
+        pendingFencedDecisions = [];
+      }
+      continue;
+    }
+    const subsequent = DECISION_LINE.exec(trimmed);
+    if (!subsequent) {
+      continue;
+    }
+    const repeated = subsequent[1].trim().toLowerCase();
+    if (openingFence) {
+      pendingFencedDecisions.push(repeated);
+    } else {
+      decisions.push(repeated);
+    }
   }
-  return { conversation, scout: outcome };
+  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
+    };
+  }
+  return {
+    decision,
+    markdown: text,
+    model: "",
+    ok: true,
+    thinkingText: "",
+    trigger: "repeated-tool-call"
+  };
 };
-var collectAdvisorResponse = async (ctx, systemPrompt, question, signal, onChunk, gitContext, draft, includeUntracked, includeTracked, onScout, currentInvocationId) => {
+var adviceForGateText = (result) => `**Decision: ${result.decision}**
+
+${result.markdown}`;
+
+// src/tools/consultation.ts
+class AdvisorNoAdviceError extends Error {
+  constructor() {
+    super("Advisor returned no advice.");
+    this.name = "AdvisorNoAdviceError";
+  }
+}
+var fileTag = (item) => `<file path=${JSON.stringify(item.path)}>
+${item.text}
+</file>`;
+var collectAdvisorResponse = async (options) => {
+  const { ctx, question, signal, systemPrompt } = options;
   loadConfig(ctx);
   const resolved = await resolveConfiguredModel(ctx, advisorRef, "Advisor");
-  const allowed = advisorGitContextRef;
-  const level = clampGitContextLevel(gitContext ?? allowed, allowed);
-  const gitBudget = advisorGitContextBudget(contextMaxCharsRef, advisorGitContextMaxCharsRef);
-  const changes = collectGitContext(ctx.cwd, level, gitBudget, advisorRedactSecretsRef ? redactSecrets : undefined);
-  const changeText = advisorRepositoryContext(changes, gitContext ?? allowed, level, gitBudget);
-  const conversationBudget = Math.max(0, contextMaxCharsRef - changeText.length);
-  const legacyConversation = advisorRequestConversation(ctx, conversationBudget);
-  const curated = await curateAdvisorConversation(ctx, legacyConversation, signal, onScout, advisorScoutEnabledRef, runAdvisorScout, currentInvocationId, conversationBudget);
-  const { conversation, scout } = curated;
-  const preferences = await readProjectPreferences(ctx, 8 * 1024, advisorRedactSecretsRef);
-  const draftText = draft ? redactAndCapText(draft, 8 * 1024, advisorRedactSecretsRef) : undefined;
-  const untracked = await readUntrackedFiles(ctx.cwd, includeUntracked ?? [], advisorUntrackedContentRef, advisorRedactSecretsRef);
-  const tracked = await readTrackedFiles(ctx.cwd, includeTracked ?? [], advisorTrackedFileContentRef, advisorRedactSecretsRef, Math.max(0, 24 * 1024 - untracked.reduce((sum, item) => sum + item.bytes, 0)));
+  const context = await assembleConsultationContext(options);
   const outboundQuestion = advisorRedactSecretsRef && question !== undefined ? redactSecrets(question) : question;
   const messages = [
     {
       content: [
         {
-          text: advisorMessageText(conversation, outboundQuestion, changeText, draftText, preferences?.text, untracked.map((item) => `<file path=${JSON.stringify(item.path)}>
-${item.text}
-</file>`), tracked.map((item) => `<file path=${JSON.stringify(item.path)}>
-${item.text}
-</file>`)),
+          text: advisorMessageText(context.conversation, outboundQuestion, context.changeText, context.draftText, context.preferences?.text, context.untracked.map(fileTag), context.tracked.map(fileTag)),
           type: "text"
         }
       ],
@@ -2732,34 +2888,54 @@ ${item.text}
   ];
   const streamed = await collectTextStream(resolved, {
     messages,
-    onChunk,
+    onChunk: options.onChunk,
     reasoning: advisorEffortRef,
     signal,
     systemPrompt
   });
   const markdown = streamed.text;
   if (!markdown.trim()) {
-    throw new Error("Advisor returned no advice.");
+    throw new AdvisorNoAdviceError;
   }
   return {
-    draftBytes: draftText ? Buffer.byteLength(draftText, "utf8") : undefined,
+    draftBytes: context.draftText ? Buffer.byteLength(context.draftText, "utf8") : undefined,
     markdown,
     model: advisorRef,
-    preferenceBytes: preferences?.bytes,
+    preferenceBytes: context.preferences?.bytes,
     thinkingText: streamed.thinking,
-    trackedBytes: tracked.reduce((sum, item) => sum + item.bytes, 0) || undefined,
-    untrackedBytes: untracked.reduce((sum, item) => sum + item.bytes, 0) || undefined,
+    trackedBytes: context.tracked.reduce((sum, item) => sum + item.bytes, 0) || undefined,
+    untrackedBytes: context.untracked.reduce((sum, item) => sum + item.bytes, 0) || undefined,
     usage: streamed.usage,
-    ...scout ? { scout } : {}
+    ...context.scout ? { scout: context.scout } : {}
   };
 };
 var consultAdvisor = async (ctx, question, signal, onChunk, trigger = "executor-requested", gitContext, draft, includeUntracked, includeTracked, onScout, currentInvocationId) => {
-  const result = await collectAdvisorResponse(ctx, ADVISOR_SYSTEM, question, signal, onChunk, gitContext, draft, includeUntracked, includeTracked, onScout, currentInvocationId);
+  const result = await collectAdvisorResponse({
+    ctx,
+    currentInvocationId,
+    draft,
+    gitContext,
+    includeTracked,
+    includeUntracked,
+    onChunk,
+    onScout,
+    question,
+    signal,
+    systemPrompt: ADVISOR_SYSTEM
+  });
   return { ...result, adviceId: randomUUID(), trigger };
 };
 var runAdvisorGate = async (ctx, question, trigger = "repeated-tool-call", signal, onChunk, onScout, currentInvocationId) => {
   try {
-    const result = await collectAdvisorResponse(ctx, ADVISOR_DECISION_SYSTEM, question, signal, onChunk, undefined, undefined, undefined, undefined, onScout, currentInvocationId);
+    const result = await collectAdvisorResponse({
+      ctx,
+      currentInvocationId,
+      onChunk,
+      onScout,
+      question,
+      signal,
+      systemPrompt: ADVISOR_DECISION_SYSTEM
+    });
     const parsed = parseAutomaticDecision(result.markdown);
     if (!parsed.ok) {
       return { ...parsed, usage: result.usage };
@@ -2777,7 +2953,7 @@ var runAdvisorGate = async (ctx, question, trigger = "repeated-tool-call", signa
     }
     const message = error instanceof Error ? error.message : String(error);
     return {
-      category: message === "Advisor returned no advice." ? "empty-response" : "provider-error",
+      category: error instanceof AdvisorNoAdviceError ? "empty-response" : "provider-error",
       message,
       ok: false
     };
@@ -2796,6 +2972,46 @@ import {
   truncateToWidth as truncateToWidth2,
   visibleWidth
 } from "@earendil-works/pi-tui";
+
+// src/pi-settings.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
+var SETTING_RECHECK_INTERVAL_MS = 2000;
+var cache = new Map;
+var settingsIdentity = (path) => {
+  try {
+    const stats = statSync2(path, { bigint: true });
+    return `${stats.mtimeNs}:${stats.ctimeNs}:${stats.size}:${stats.ino}`;
+  } catch {
+    return `unstattable:${process.hrtime.bigint()}`;
+  }
+};
+var readHideThinking = (path) => {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null && parsed.hideThinkingBlock === true;
+  } catch {
+    return false;
+  }
+};
+var piHideThinkingEnabled = () => {
+  const path = join3(getAgentDir2(), "settings.json");
+  if (!existsSync2(path)) {
+    return false;
+  }
+  const now = Date.now();
+  const cached = cache.get(path);
+  if (cached && now - cached.readAt < SETTING_RECHECK_INTERVAL_MS) {
+    return cached.hidden;
+  }
+  const identity = settingsIdentity(path);
+  const hidden = cached && cached.identity === identity ? cached.hidden : readHideThinking(path);
+  cache.set(path, { hidden, identity, readAt: now });
+  return hidden;
+};
+
+// src/tools/render-common.ts
 var SPINNER_FRAMES = [
   "⠋",
   "⠙",
@@ -2808,7 +3024,7 @@ var SPINNER_FRAMES = [
   "⠇",
   "⠏"
 ];
-var THINKING_PREFIX = "  \uD83D\uDCAD ";
+var THINKING_PREFIX = "  ";
 var THINKING_PREFIX_WIDTH = visibleWidth(THINKING_PREFIX);
 
 class ThinkingMarkdown {
@@ -2831,7 +3047,18 @@ class ThinkingMarkdown {
     this.markdown.invalidate();
   }
 }
-var renderThinkingMarkdown = (thinking, theme) => new ThinkingMarkdown(thinking, theme);
+
+class HiddenThinkingLabel {
+  label;
+  constructor(theme) {
+    this.label = theme.fg("thinkingText", `${THINKING_PREFIX}Thinking…`);
+  }
+  render() {
+    return [this.label];
+  }
+  invalidate() {}
+}
+var renderThinkingMarkdown = (thinking, theme) => piHideThinkingEnabled() ? new HiddenThinkingLabel(theme) : new ThinkingMarkdown(thinking, theme);
 var resolveAdvisorRequest = (question) => question?.trim() || undefined;
 var renderAdvisorCallBox = (question, theme) => {
   const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
@@ -3078,42 +3305,41 @@ var normalizeToolInput = (toolName, input) => {
   return visit(input);
 };
 var normalizedToolSignature = (toolName, input) => `${toolName}:${JSON.stringify(normalizeToolInput(toolName, input))}`;
+var freshRepetition = () => ({
+  count: 0,
+  interventions: 0
+});
+var freshAdviceLedger = () => ({
+  draftConsultations: 0,
+  issued: new Map,
+  outcomes: 0,
+  pending: new Set,
+  reported: new Set
+});
+var freshUsage = () => ({
+  invocations: [],
+  totals: emptyAdvisorUsageTotals()
+});
 
 class AdvisorSessionState {
-  #previousSignature;
-  #repetitions = 0;
+  #repetition = freshRepetition();
   #blockedReason;
-  #invocations = [];
-  #loopInterventions = 0;
+  #ledger = freshAdviceLedger();
+  #usage = freshUsage();
   #consumedCalls = 0;
-  #issuedAdvice = new Map;
-  #pendingAdvice = new Set;
-  #reportedAdvice = new Set;
-  #draftConsultations = 0;
-  #outcomes = 0;
-  #lastAdvice;
-  #usage = emptyAdvisorUsageTotals();
   resetTask() {
-    this.#previousSignature = undefined;
-    this.#repetitions = 0;
+    this.#repetition = freshRepetition();
     this.#blockedReason = undefined;
-    this.#invocations = [];
-    this.#loopInterventions = 0;
+    this.#ledger = freshAdviceLedger();
+    this.#usage = freshUsage();
     this.#consumedCalls = 0;
-    this.#issuedAdvice.clear();
-    this.#pendingAdvice.clear();
-    this.#reportedAdvice.clear();
-    this.#draftConsultations = 0;
-    this.#outcomes = 0;
-    this.#lastAdvice = undefined;
-    this.#usage = emptyAdvisorUsageTotals();
   }
   clearBlocked() {
     this.#blockedReason = undefined;
   }
   resetRepetition() {
-    this.#previousSignature = undefined;
-    this.#repetitions = 0;
+    this.#repetition.count = 0;
+    this.#repetition.previousSignature = undefined;
   }
   get blocked() {
     return this.#blockedReason !== undefined;
@@ -3129,12 +3355,12 @@ class AdvisorSessionState {
       return false;
     }
     const signature = normalizedToolSignature(toolName, input);
-    this.#repetitions = signature === this.#previousSignature ? this.#repetitions + 1 : 1;
-    this.#previousSignature = signature;
-    if (this.#repetitions < threshold) {
+    this.#repetition.count = signature === this.#repetition.previousSignature ? this.#repetition.count + 1 : 1;
+    this.#repetition.previousSignature = signature;
+    if (this.#repetition.count < threshold) {
       return false;
     }
-    this.#loopInterventions += 1;
+    this.#repetition.interventions += 1;
     return true;
   }
   canConsult(limit) {
@@ -3150,58 +3376,59 @@ class AdvisorSessionState {
     return this.#consumedCalls;
   }
   get usageTotals() {
-    return { ...this.#usage };
+    return { ...this.#usage.totals };
   }
   usageStatus() {
-    return formatAdvisorUsageStatus(this.#usage);
+    return formatAdvisorUsageStatus(this.#usage.totals);
   }
   recordInvocation(record) {
-    this.#invocations.push(record);
-    addAdvisorUsage(this.#usage, record.usage);
+    this.#usage.invocations.push(record);
+    addAdvisorUsage(this.#usage.totals, record.usage);
   }
   issueAdvice(id, advice, trigger, draft = false) {
-    this.#issuedAdvice.set(id, { advice, trigger });
-    this.#lastAdvice = advice;
+    this.#ledger.issued.set(id, { advice, trigger });
+    this.#ledger.lastAdvice = advice;
     if (draft) {
-      this.#draftConsultations += 1;
+      this.#ledger.draftConsultations += 1;
     }
   }
   claimTrackedFiles(paths) {
-    if (!this.#lastAdvice || paths.length === 0) {
+    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(this.#lastAdvice);
+      return new RegExp(boundary).test(advice);
     });
     if (!mentioned) {
       return false;
     }
-    this.#lastAdvice = undefined;
+    this.#ledger.lastAdvice = undefined;
     return true;
   }
   reserveAdvice(id) {
-    if (this.#reportedAdvice.has(id) || this.#pendingAdvice.has(id)) {
+    if (this.#ledger.reported.has(id) || this.#ledger.pending.has(id)) {
       return;
     }
-    const advice = this.#issuedAdvice.get(id);
+    const advice = this.#ledger.issued.get(id);
     if (!advice) {
       return;
     }
-    this.#pendingAdvice.add(id);
+    this.#ledger.pending.add(id);
     return advice;
   }
   commitAdvice(id) {
-    if (!this.#pendingAdvice.delete(id)) {
+    if (!this.#ledger.pending.delete(id)) {
       return false;
     }
-    this.#reportedAdvice.add(id);
-    this.#outcomes += 1;
+    this.#ledger.reported.add(id);
+    this.#ledger.outcomes += 1;
     return true;
   }
   releaseAdvice(id) {
-    this.#pendingAdvice.delete(id);
+    this.#ledger.pending.delete(id);
   }
   claimAdvice(id) {
     const advice = this.reserveAdvice(id);
@@ -3211,34 +3438,47 @@ class AdvisorSessionState {
     this.commitAdvice(id);
     return advice;
   }
-  summary(limit) {
-    if (this.#invocations.length === 0 && this.#loopInterventions === 0) {
-      return;
-    }
-    const markdown = this.#invocations.filter((item) => item.kind === "markdown");
-    const gates = this.#invocations.filter((item) => item.kind === "gate");
-    const countTrigger = (trigger) => this.#invocations.filter((item) => item.trigger === trigger).length;
-    const decisions = ["proceed", "revise", "blocked"].map((decision) => [
+  #decisionsLine() {
+    const gates = this.#usage.invocations.filter((item) => item.kind === "gate");
+    return ["proceed", "revise", "blocked"].map((decision) => [
       decision,
       gates.filter((item) => item.decision === decision).length
     ]).filter(([, count]) => count > 0).map(([decision, count]) => `${count} ${decision}`).join(", ") || "none";
-    const effects = (effect) => this.#invocations.filter((item) => item.executionEffect === effect).length;
-    const failures = this.#invocations.filter((item) => item.failure).map((item) => item.failure);
-    const models = [
-      ...new Set(this.#invocations.map((item) => item.model).filter(Boolean))
-    ].join(", ") || "unknown";
+  }
+  #countTrigger(trigger) {
+    return this.#usage.invocations.filter((item) => item.trigger === trigger).length;
+  }
+  #triggersLine() {
+    return [
+      "manual",
+      "executor-requested",
+      "repeated-tool-call",
+      "completion-review",
+      "custom-rule"
+    ].filter((trigger) => this.#countTrigger(trigger) > 0).join(", ") || "none";
+  }
+  summary(limit) {
+    const { invocations, totals } = this.#usage;
+    if (invocations.length === 0 && this.#repetition.interventions === 0) {
+      return;
+    }
+    const markdown = invocations.filter((item) => item.kind === "markdown");
+    const gates = invocations.filter((item) => item.kind === "gate");
+    const effects = (effect) => invocations.filter((item) => item.executionEffect === effect).length;
+    const failures = invocations.filter((item) => item.failure).map((item) => item.failure);
+    const models = [...new Set(invocations.map((item) => item.model).filter(Boolean))].join(", ") || "unknown";
     const budget = limit === undefined ? `${this.#consumedCalls} used; unlimited remaining` : `${this.#consumedCalls} / ${limit} used; ${Math.max(0, limit - this.#consumedCalls)} remaining`;
     return [
       "[Session Advisor Summary]",
-      `Consultations: ${markdown.length} Markdown (${countTrigger("manual")} manual, ${countTrigger("executor-requested")} executor-requested), automatic gates: ${gates.length}`,
-      `Triggers: ${["manual", "executor-requested", "repeated-tool-call", "completion-review", "custom-rule"].filter((trigger) => countTrigger(trigger) > 0).join(", ") || "none"}`,
+      `Consultations: ${markdown.length} Markdown (${this.#countTrigger("manual")} manual, ${this.#countTrigger("executor-requested")} executor-requested), automatic gates: ${gates.length}`,
+      `Triggers: ${this.#triggersLine()}`,
       `Models: ${models}`,
       `Budget: ${budget}`,
-      `Usage: ${formatAdvisorUsageTotals(this.#usage)}`,
-      `Markdown advice: ${markdown.length} responses (${this.#draftConsultations} with drafts)`,
-      `Outcome reports: ${this.#outcomes}`,
-      `Gate decisions: ${decisions}`,
-      `Loop matching: normalized tool signatures; ${this.#loopInterventions} gate intervention${this.#loopInterventions === 1 ? "" : "s"}`,
+      `Usage: ${formatAdvisorUsageTotals(totals)}`,
+      `Markdown advice: ${markdown.length} responses (${this.#ledger.draftConsultations} with drafts)`,
+      `Outcome reports: ${this.#ledger.outcomes}`,
+      `Gate decisions: ${this.#decisionsLine()}`,
+      `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"}`
     ].join(`
@@ -4099,7 +4339,6 @@ import {
 
 // src/ui/settings-formatting.ts
 import { visibleWidth as visibleWidth3 } from "@earendil-works/pi-tui";
-var DEFAULT_EFFORT_LEVEL2 = "Default (Model Default)";
 var TOGGLE_VALUES = ["On", "Off"];
 var SIMPLE_MODE_GRADIENT_INTERVAL_MS = 100;
 var SIMPLE_MODE_GRADIENT_COLORS = [
@@ -4156,7 +4395,7 @@ var contextDescription = (presets, contextMaxChars) => {
 ${meterPrefix}${meter}  full
 ${markerLabel}`;
 };
-var currentEffort = (effort) => effort || DEFAULT_EFFORT_LEVEL2;
+var currentEffort = (effort) => effort || DEFAULT_EFFORT_LEVEL;
 var rainbowGradient = (text, startedAt) => {
   const frame = Math.floor((Date.now() - startedAt) / SIMPLE_MODE_GRADIENT_INTERVAL_MS);
   const shinePosition = frame % (text.length * 2);
@@ -4746,8 +4985,8 @@ import {
   unlink,
   writeFile
 } from "node:fs/promises";
-import { join as join3 } from "node:path";
-import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
+import { join as join4 } from "node:path";
+import { getAgentDir as getAgentDir3 } from "@earendil-works/pi-coding-agent";
 var ADOPTIONS = [
   "followed",
   "not-followed",
@@ -4760,11 +4999,11 @@ var VALIDATIONS = [
   "unknown"
 ];
 var MAX_LOG_BYTES = 1024 * 1024;
-var statePath = () => join3(getAgentDir2(), "advisor-outcomes-salt");
-var outcomeLogPath = () => join3(getAgentDir2(), "advisor-outcomes.jsonl");
+var statePath = () => join4(getAgentDir3(), "advisor-outcomes-salt");
+var outcomeLogPath = () => join4(getAgentDir3(), "advisor-outcomes.jsonl");
 var salt = async () => {
   const path = statePath();
-  await mkdir(getAgentDir2(), { mode: 448, recursive: true });
+  await mkdir(getAgentDir3(), { mode: 448, recursive: true });
   for (let attempt = 0;attempt < 20; attempt += 1) {
     try {
       const existing = await readFile(path);
@@ -4841,7 +5080,7 @@ var withOutcomeLock = async (run) => {
 var adviceDigest = (advice, key) => createHmac("sha256", key).update(advice).digest("hex").slice(0, 16);
 var appendOutcome = async (record) => {
   const path = outcomeLogPath();
-  await mkdir(getAgentDir2(), { mode: 448, recursive: true });
+  await mkdir(getAgentDir3(), { mode: 448, recursive: true });
   return withOutcomeLock(async () => {
     const next = {
       adoption: record.adoption,
@@ -4949,7 +5188,7 @@ var reserveAdvisorCall = (event, ctx, session, reservedCalls) => {
 import {
   getMarkdownTheme as getMarkdownTheme4
 } from "@earendil-works/pi-coding-agent";
-import { Box as Box3, Markdown as Markdown4, Text as Text5 } from "@earendil-works/pi-tui";
+import { Box as Box3, Markdown as Markdown4, Spacer, Text as Text5 } from "@earendil-works/pi-tui";
 var advisorResultDetails = (result) => result.details;
 var syncRenderPhase = (context, phase) => {
   if (context.state.phase !== phase && context.state.timerId) {
@@ -5036,7 +5275,7 @@ var renderFinalAdvisorResult = (box, result, expanded, theme, context) => {
   box.addChild(new Markdown4(adviceForDisplay(displayAdvice, expanded), 0, 0, getMarkdownTheme4()));
 };
 var renderAdvisorResult = (result, { isPartial, expanded }, theme, context) => {
-  const box = context.lastComponent instanceof Box3 ? context.lastComponent : new Box3(1, 1, (text) => theme.bg("customMessageBg", text));
+  const box = context.lastComponent instanceof Box3 ? context.lastComponent : new Box3(1, 0, (text) => theme.bg("customMessageBg", text));
   box.setBgFn((text) => theme.bg("customMessageBg", text));
   box.clear();
   if (isPartial) {
@@ -5044,6 +5283,7 @@ var renderAdvisorResult = (result, { isPartial, expanded }, theme, context) => {
   } else {
     renderFinalAdvisorResult(box, result, expanded, theme, context);
   }
+  box.addChild(new Spacer(1));
   return box;
 };
 
@@ -5231,6 +5471,44 @@ var sendAutomaticGateResult = (pi, result) => {
     display: true
   }, { deliverAs: "steer" });
 };
+var applyGateDecision = (pi, ctx, session, result, reason, failureMode) => {
+  if (!result.ok) {
+    session.recordInvocation({
+      executionEffect: gateFailureEffectForMode(failureMode),
+      failure: result.category,
+      kind: "gate",
+      model: advisorRef,
+      trigger: "repeated-tool-call",
+      usage: result.usage
+    });
+    updateAdvisorUsageStatus(ctx, session);
+    const failure = failureEffect(result.category, result.message, ctx, session, failureMode);
+    sendAutomaticGateFailure(pi, `**Advisor gate failure (${result.category}):** ${result.message}`, result.usage);
+    return failure.block ? { block: true, reason: `${reason}
+${failure.reason}` } : undefined;
+  }
+  session.recordInvocation({
+    cost: advisorUsageCost(result.usage),
+    decision: result.decision,
+    executionEffect: gateDecisionEffect(result.decision, failureMode),
+    kind: "gate",
+    model: result.model,
+    trigger: result.trigger,
+    usage: result.usage
+  });
+  updateAdvisorUsageStatus(ctx, session);
+  sendAutomaticGateResult(pi, result);
+  if (result.decision === "proceed") {
+    session.resetRepetition();
+    return;
+  }
+  const gateReason = `Advisor loop review: ${result.markdown}`;
+  if (result.decision === "blocked") {
+    const effect = blockedDecisionEffect(gateReason, ctx, session, failureMode);
+    return effect.block ? { block: true, reason: effect.reason } : undefined;
+  }
+  return { block: true, reason: gateReason };
+};
 var handleAutomaticGate = async (pi, event, ctx, session, runGate, scoutStatus) => {
   if (isSimpleMode() || event.toolName === "ask_advisor" || !advisorAutoLoopGateRef || !session.recordToolCall(event.toolName, event.input, advisorLoopThresholdRef)) {
     return;
@@ -5265,42 +5543,7 @@ var handleAutomaticGate = async (pi, event, ctx, session, runGate, scoutStatus)
       }
     }, event.toolCallId);
     ensureGateCall();
-    if (!result.ok) {
-      session.recordInvocation({
-        executionEffect: gateFailureEffectForMode(failureMode),
-        failure: result.category,
-        kind: "gate",
-        model: advisorRef,
-        trigger: "repeated-tool-call",
-        usage: result.usage
-      });
-      updateAdvisorUsageStatus(ctx, session);
-      const failure = failureEffect(result.category, result.message, ctx, session, failureMode);
-      sendAutomaticGateFailure(pi, `**Advisor gate failure (${result.category}):** ${result.message}`, result.usage);
-      return failure.block ? { block: true, reason: `${reason}
-${failure.reason}` } : undefined;
-    }
-    session.recordInvocation({
-      cost: advisorUsageCost(result.usage),
-      decision: result.decision,
-      executionEffect: gateDecisionEffect(result.decision, failureMode),
-      kind: "gate",
-      model: result.model,
-      trigger: result.trigger,
-      usage: result.usage
-    });
-    updateAdvisorUsageStatus(ctx, session);
-    sendAutomaticGateResult(pi, result);
-    if (result.decision === "proceed") {
-      session.resetRepetition();
-      return;
-    }
-    const gateReason = `Advisor loop review: ${result.markdown}`;
-    if (result.decision === "blocked") {
-      const effect = blockedDecisionEffect(gateReason, ctx, session, failureMode);
-      return effect.block ? { block: true, reason: effect.reason } : undefined;
-    }
-    return { block: true, reason: gateReason };
+    return applyGateDecision(pi, ctx, session, result, reason, failureMode);
   } finally {
     scoutStatus.release(ctx, scoutStatusToken);
     herdrAdvisorActivity.finish();