@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.4

package/src/tools/filesystem/read.ts

@@ -12,6 +12,7 @@ import {
   IMAGE_EXTENSIONS,
   readImageFile,
 } from "../shared/filesystem/image-read.js";
+import { legacyReadArgsError } from "../shared/filesystem/legacy-read-args.js";
 import { sandboxReadPolicy } from "../shared/filesystem/path-policy.js";
 import {
   invalidToolInputResult,
@@ -25,8 +26,8 @@ import type {
 
 /**
  * Model-input schema, the single source for both runtime validation (via
- * `TOOL_INPUT_SCHEMAS`) and the advertised `input_schema` below. `offset` and
- * `limit` catch to `undefined` because the tool has always ignored non-numeric
+ * `TOOL_INPUT_SCHEMAS`) and the advertised `input_schema` below. `start_index`
+ * and `max_chars` catch to `undefined` because the tool ignores non-numeric
  * values rather than failing the read.
  */
 export const fileReadInputSchema = z.looseObject({
@@ -36,14 +37,16 @@ export const fileReadInputSchema = z.looseObject({
     .describe(
       "The path to the file to read (absolute or relative to working directory)",
     ),
-  offset: z
+  start_index: z
     .number()
-    .describe("Line number to start reading from (1-indexed)")
+    .describe("Character to start reading from (0-indexed). Text files only.")
     .optional()
     .catch(undefined),
-  limit: z
+  max_chars: z
     .number()
-    .describe("Maximum number of lines to read (defaults to 2000)")
+    .describe(
+      "Maximum number of characters to read. Defaults to 20000, which is also the ceiling. Text files only.",
+    )
     .optional()
     .catch(undefined),
   activity: z
@@ -58,7 +61,7 @@ export const fileReadInputSchema = z.looseObject({
 export const fileReadTool = {
   name: "file_read",
   description:
-    "Read the contents of a file on your own machine. Text reads return the first 2000 lines unless you pass `limit`; when a read stops short the result says so, and `offset` pages on from there. For image files (JPEG, PNG, GIF, WebP), returns the image for visual analysis. For audio files (MP3, WAV, OGG, FLAC, AAC, M4A), returns the audio for listening. Use host_file_read for files on your guardian's device instead.",
+    "Read the contents of a file on your own machine. Text reads return the first 20000 characters unless you pass `max_chars`; when a read stops short the result says so, and `start_index` pages on from there. To find where something is in a large file, code_search is cheaper than paging through it. For image files (JPEG, PNG, GIF, WebP), returns the image for visual analysis. For audio files (MP3, WAV, OGG, FLAC, AAC, M4A), returns the audio for listening. Use host_file_read for files on your guardian's device instead.",
   category: "filesystem",
   executionTarget: "sandbox",
   defaultRiskLevel: RiskLevel.Low,
@@ -75,9 +78,14 @@ export const fileReadTool = {
     if (!parsed.success) {
       return invalidToolInputResult("file_read", parsed.error);
     }
-    const { path: rawPath, offset, limit } = parsed.data;
+    const {
+      path: rawPath,
+      start_index: startIndex,
+      max_chars: maxChars,
+    } = parsed.data;
 
-    // For image files, delegate to the shared image reader.
+    // For image files, delegate to the shared image reader. Media reads carry
+    // no window, so the legacy-argument guard below does not apply to them.
     const ext = extname(rawPath).toLowerCase();
     if (IMAGE_EXTENSIONS.has(ext)) {
       const pathCheck = sandboxReadPolicy(rawPath, context.workingDir);
@@ -102,11 +110,20 @@ export const fileReadTool = {
       return readAudioFile(pathCheck.resolved);
     }
 
+    const legacyArgs = legacyReadArgsError("file_read", input);
+    if (legacyArgs !== undefined) {
+      return { content: legacyArgs, isError: true };
+    }
+
     const ops = new FileSystemOps((path, opts) =>
       sandboxReadPolicy(path, context.workingDir, opts),
     );
 
-    const result = await ops.readFileSafe({ path: rawPath, offset, limit });
+    const result = await ops.readFileSafe({
+      path: rawPath,
+      startIndex,
+      maxChars,
+    });
 
     if (!result.ok) {
       const { error } = result;

package/src/tools/host-filesystem/read.ts

@@ -11,13 +11,14 @@ import {
   readAudioFile,
 } from "../shared/filesystem/audio-read.js";
 import {
-  DEFAULT_READ_LINE_LIMIT,
   FileSystemOps,
+  READ_CHAR_BUDGET,
 } from "../shared/filesystem/file-ops-service.js";
 import {
   IMAGE_EXTENSIONS,
   readImageFile,
 } from "../shared/filesystem/image-read.js";
+import { legacyReadArgsError } from "../shared/filesystem/legacy-read-args.js";
 import { hostPolicy } from "../shared/filesystem/path-policy.js";
 import {
   invalidToolInputResult,
@@ -32,9 +33,9 @@ import type {
 /**
  * Model-input schema, the single source for both runtime validation (via
  * `TOOL_INPUT_SCHEMAS`) and the advertised `input_schema` below — mirrors
- * `filesystem/read.ts`. `offset`/`limit` catch to `undefined` so a
- * non-numeric value falls back to the default line window instead of failing
- * the call; `target_client_id` catches so a non-string (or empty) value means
+ * `filesystem/read.ts`. `start_index`/`max_chars` catch to `undefined` so a
+ * non-numeric value falls back to the default character window instead of
+ * failing the call; `target_client_id` catches so a non-string (or empty) value means
  * "untargeted".
  */
 export const hostFileReadInputSchema = z.looseObject({
@@ -44,14 +45,16 @@ export const hostFileReadInputSchema = z.looseObject({
     .describe(
       "Absolute path on the guardian's device, which is a separate filesystem from your workspace, to read.",
     ),
-  offset: z
+  start_index: z
     .number()
-    .describe("Line number to start reading from (1-indexed)")
+    .describe("Character to start reading from (0-indexed). Text files only.")
     .optional()
     .catch(undefined),
-  limit: z
+  max_chars: z
     .number()
-    .describe("Maximum number of lines to read (defaults to 2000)")
+    .describe(
+      "Maximum number of characters to read. Defaults to 20000, which is also the ceiling. Text files only.",
+    )
     .optional()
     .catch(undefined),
   target_client_id: z
@@ -66,7 +69,7 @@ export const hostFileReadInputSchema = z.looseObject({
 export const hostFileReadTool = {
   name: "host_file_read",
   description:
-    "Read the contents of a file on your guardian's device, including images (JPEG, PNG, GIF, WebP) and audio (MP3, WAV, OGG, FLAC, AAC, M4A). Text reads return the first 2000 lines unless you pass `limit`; when a read stops short the result says so, and `offset` pages on from there. For files on your own machine, use file_read instead.",
+    "Read the contents of a file on your guardian's device, including images (JPEG, PNG, GIF, WebP) and audio (MP3, WAV, OGG, FLAC, AAC, M4A). Text reads return the first 20000 characters unless you pass `max_chars`; when a read stops short the result says so, and `start_index` pages on from there. For files on your own machine, use file_read instead.",
   category: "host-filesystem",
   executionTarget: "host",
   defaultRiskLevel: RiskLevel.Medium,
@@ -81,12 +84,12 @@ export const hostFileReadTool = {
     if (!parsed.success) {
       return invalidToolInputResult("host_file_read", parsed.error);
     }
-    const { path: rawPath, offset } = parsed.data;
+    const { path: rawPath, start_index: startIndex } = parsed.data;
     // Resolve the default here rather than leaving it to the read, so the
     // proxied branch below is bounded by the same window as the local one. A
-    // proxied read that sent no limit would stream a whole host file across
+    // proxied read that sent no budget would stream a whole host file across
     // the bridge before anything could trim it.
-    const limit = parsed.data.limit ?? DEFAULT_READ_LINE_LIMIT;
+    const maxChars = parsed.data.max_chars ?? READ_CHAR_BUDGET;
 
     const targetClientId =
       parsed.data.target_client_id !== ""
@@ -153,8 +156,8 @@ export const hostFileReadTool = {
         {
           operation: "read",
           path: rawPath,
-          offset,
-          limit,
+          startIndex,
+          maxChars,
           targetClientId,
         },
         context.conversationId,
@@ -181,9 +184,18 @@ export const hostFileReadTool = {
       return readAudioFile(pathCheck.resolved);
     }
 
+    const legacyArgs = legacyReadArgsError("host_file_read", input);
+    if (legacyArgs !== undefined) {
+      return { content: legacyArgs, isError: true };
+    }
+
     const ops = new FileSystemOps(hostPolicy);
 
-    const result = await ops.readFileSafe({ path: rawPath, offset, limit });
+    const result = await ops.readFileSafe({
+      path: rawPath,
+      startIndex,
+      maxChars,
+    });
 
     if (!result.ok) {
       const { error } = result;

package/src/tools/shared/filesystem/file-ops-service.ts

@@ -78,26 +78,55 @@ function pathError(
 }
 
 /**
- * Lines returned by a read that names no `limit`. Without a default the read
- * returns the whole file, and a file-read result is honored in full for the
- * rest of the turn (see `isSpoolEligible` in `context/tool-result-spool.ts`),
- * so one unbounded read of a large file rides every subsequent LLM call in
- * that turn. The cap bounds that; `offset`/`limit` page past it, and
- * {@link truncationNotice} tells the model when it is looking at a window
- * rather than the whole file.
+ * Characters returned by a read that names no `max_chars`. Stays under
+ * `THRESHOLD_CHARS` in `context/post-turn-tool-result-truncation.ts`, which
+ * spools any larger tool result to disk and replaces it inline with a short
+ * stub, so a default read returns content rather than a stub.
  */
-export const DEFAULT_READ_LINE_LIMIT = 2000;
+export const READ_CHAR_BUDGET = 20_000;
 
 /**
- * Trailing marker appended when a read stops short of the last line. Silent
- * truncation is the failure mode worth avoiding: a model that cannot tell a
- * window from a whole file reasons about code it never saw.
+ * Trailing marker appended when a read stops short of the end of the file. A
+ * model that cannot tell a window from a whole file reasons about code it
+ * never saw.
  */
 function truncationNotice(
-  lastLineReturned: number,
-  totalLines: number,
+  start: number,
+  end: number,
+  totalChars: number,
 ): string {
-  return `\n\n[Truncated: showing through line ${lastLineReturned} of ${totalLines}. Read on with offset=${lastLineReturned + 1}, or pass an explicit limit.]`;
+  return `\n\n[Truncated: characters ${start}-${end} of ${totalChars}. Read on with start_index=${end}.]`;
+}
+
+const isHighSurrogate = (code: number): boolean =>
+  code >= 0xd800 && code <= 0xdbff;
+const isLowSurrogate = (code: number): boolean =>
+  code >= 0xdc00 && code <= 0xdfff;
+
+/**
+ * Character window that never splits a surrogate pair. A split leaves a lone
+ * half at each edge, and each encodes to U+FFFD, so the character is lost from
+ * both this window and the next one paged in after it.
+ */
+export function surrogateSafeWindow(
+  total: number,
+  charCodeAt: (index: number) => number,
+  requestedStart: number,
+  maxChars: number,
+): { start: number; end: number } {
+  let start = Math.max(0, Math.min(requestedStart, total));
+  if (start > 0 && start < total && isLowSurrogate(charCodeAt(start))) {
+    start -= 1;
+  }
+
+  let end = Math.min(total, start + maxChars);
+  if (end > start && end < total && isHighSurrogate(charCodeAt(end - 1))) {
+    // Backing off would empty a one-character window, which stalls paging on
+    // the same offset, so take the whole pair instead.
+    end = end - 1 > start ? end - 1 : Math.min(total, end + 1);
+  }
+
+  return { start, end };
 }
 
 export class FileSystemOps {
@@ -139,28 +168,27 @@ export class FileSystemOps {
 
     try {
       const raw = await readFile(filePath, "utf-8");
-      const lines = raw.split("\n");
-
-      const offset = (input.offset ?? 1) - 1;
-      const start = Math.max(0, offset);
-      const limit = input.limit ?? DEFAULT_READ_LINE_LIMIT;
-      const selected = lines.slice(start, offset + limit);
-
-      const numbered = selected
-        .map((line, i) => {
-          const lineNum = offset + i + 1;
-          return `${String(lineNum).padStart(6)}  ${line}`;
-        })
-        .join("\n");
-
-      // Only when the window stops before the last line. An empty window means
-      // the caller paged past the end or asked for nothing, which is not a
-      // truncated read.
-      const lastLineReturned = start + selected.length;
+
+      // A ceiling, not just a default: a larger window would be spooled to
+      // disk and replaced with a stub, returning less than this.
+      const maxChars = Math.min(
+        READ_CHAR_BUDGET,
+        Math.max(0, input.maxChars ?? READ_CHAR_BUDGET),
+      );
+      const { start, end } = surrogateSafeWindow(
+        raw.length,
+        (i) => raw.charCodeAt(i),
+        input.startIndex ?? 0,
+        maxChars,
+      );
+      const window = raw.slice(start, end);
+
+      // An empty window means the caller paged past the end or asked for
+      // nothing, which is not a truncated read.
       const content =
-        selected.length > 0 && lastLineReturned < lines.length
-          ? numbered + truncationNotice(lastLineReturned, lines.length)
-          : numbered;
+        window.length > 0 && end < raw.length
+          ? window + truncationNotice(start, end, raw.length)
+          : window;
 
       return { ok: true, value: { content } };
     } catch (err) {

package/src/tools/shared/filesystem/legacy-read-args.ts

@@ -0,0 +1,22 @@
+/**
+ * Guard for callers still passing the line-based `offset`/`limit` read
+ * arguments. The tool schemas are loose, so those keys parse and are then
+ * dropped, which would silently serve the start of the file to a caller that
+ * asked to page into the middle of it.
+ *
+ * There is no safe translation: `offset` counted lines and `start_index`
+ * counts characters, so mapping one onto the other would read the wrong
+ * region rather than fail. Naming the rename lets the caller correct itself.
+ */
+export function legacyReadArgsError(
+  toolName: string,
+  input: Record<string, unknown>,
+): string | undefined {
+  const usesLegacy = input.offset !== undefined || input.limit !== undefined;
+  const usesCurrent =
+    input.start_index !== undefined || input.max_chars !== undefined;
+  if (!usesLegacy || usesCurrent) {
+    return undefined;
+  }
+  return `Error: ${toolName} no longer takes \`offset\`/\`limit\` (lines). Use \`start_index\` (0-indexed characters) and \`max_chars\` instead.`;
+}

package/src/tools/shared/filesystem/types.ts

@@ -6,14 +6,14 @@ import type { FsError } from "./errors.js";
 
 export interface ReadInput {
   path: string;
-  /** 1-indexed line number to start reading from. */
-  offset?: number;
-  /** Maximum number of lines to read. */
-  limit?: number;
+  /** 0-indexed character to start reading from. */
+  startIndex?: number;
+  /** Maximum number of characters to read. */
+  maxChars?: number;
 }
 
 export interface ReadOutput {
-  /** The (possibly line-numbered) file content. */
+  /** The character window, with a truncation notice when it stops short. */
   content: string;
 }
 

package/src/tools/skills/scaffold-managed.ts

@@ -28,10 +28,20 @@ function sanitizeFrontmatterValue(value: string): string {
 }
 
 /**
- * Validate + normalize an optional string-array input (sanitize, drop blanks,
- * dedupe). Returns `{ error }` on the first invalid element, or `{ value }`
- * holding the normalized array (undefined when empty). Shared by the
- * includes / activation_hints / avoid_when inputs so they behave identically.
+ * Self-correcting error for a scaffold call with no activation hints. Matches
+ * the shape of the schema validator's required-field error, which is what a
+ * call through the registered tool hits first; this covers direct callers and
+ * an explicit empty list, which the schema's presence check accepts.
+ */
+const MISSING_ACTIVATION_HINTS =
+  'activation_hints is required: pass 1-4 short trigger phrases stating the intent this skill serves (for example "user asks to deploy staging") so it can be found later by intent, not just by name.';
+
+/**
+ * Validate + normalize a string-array input (sanitize, drop blanks, dedupe).
+ * Returns `{ error }` on the first invalid element, or `{ value }` holding
+ * the normalized array (undefined when absent or empty). Shared by the
+ * includes / activation_hints / avoid_when inputs so they behave identically;
+ * whether an absent value is acceptable is the caller's call.
  * Each element goes through sanitizeFrontmatterValue: activation_hints /
  * avoid_when are concatenated verbatim into capability memory text (see
  * buildSkillContent), so an embedded newline could otherwise smuggle an extra
@@ -184,9 +194,9 @@ export async function executeScaffoldManagedSkill(
     };
   }
 
-  // Validate and normalize the optional string-array inputs. `includes` lists
-  // child skill IDs; activation_hints / avoid_when become the skill's
-  // "Use when:" / "Avoid when:" retrieval signal in memory.
+  // Validate and normalize the string-array inputs. `includes` lists child
+  // skill IDs; activation_hints / avoid_when become the skill's "Use when:" /
+  // "Avoid when:" retrieval signal in memory.
   const includesResult = normalizeOptionalStringArray(
     input.includes,
     "includes",
@@ -204,6 +214,14 @@ export async function executeScaffoldManagedSkill(
     return { content: `Error: ${activationHintsResult.error}`, isError: true };
   }
   const activationHints = activationHintsResult.value;
+  // Hints are the skill's "Use when:" retrieval text, and scaffolding rewrites
+  // the whole SKILL.md, so a write without them leaves (or strips) none.
+  if (!activationHints) {
+    return {
+      content: `Error: ${MISSING_ACTIVATION_HINTS}`,
+      isError: true,
+    };
+  }
 
   const avoidWhenResult = normalizeOptionalStringArray(
     input.avoid_when,

package/src/tools/subagent/spawn.ts

@@ -5,20 +5,18 @@ import { validateInferenceProfileKey } from "../../config/inference-profile-vali
 import { getConfig } from "../../config/loader.js";
 import { profileSupportsTools } from "../../config/profile-tool-support.js";
 import { findConversation } from "../../daemon/conversation-registry.js";
-import { getMessages } from "../../persistence/conversation-crud.js";
 import {
   countRecentSimilarSpawns,
   normalizeSpawnObjective,
   type RecentSimilarSpawns,
   type SimilarSpawnTally,
 } from "../../persistence/subagent-store.js";
-import type { ContentBlock, Message } from "../../providers/types.js";
+import type { Message } from "../../providers/types.js";
 import { buildAdvisorContext } from "../../subagent/consult-context.js";
 import {
   advisorRequestText,
   buildAdvisorSystem,
 } from "../../subagent/consult-prompt.js";
-import { sanitizeConsultTranscript } from "../../subagent/consult-transcript.js";
 import {
   getSubagentManager,
   SubagentAbortedError,
@@ -49,7 +47,7 @@ const log = getLogger("subagent-spawn");
  * reasoning while it works, so a fixed wall-clock ceiling would kill it
  * mid-thought; an idle window instead fires only when the consult is genuinely
  * stalled (or never starts). Generous enough to also span time-to-first-token
- * over a large inherited transcript.
+ * on a slow reasoning profile.
  */
 const ADVISOR_IDLE_TIMEOUT_MS = 60_000;
 
@@ -540,13 +538,19 @@ function inFlightGuardResult(
 // ── Advisor consult ──────────────────────────────────────────────────
 
 /**
- * Run the `advisor` role as a synchronous, context-inheriting, stronger-model
- * consult and return its guidance as the tool result.
+ * Run the `advisor` role as a synchronous, stronger-model consult and return
+ * its guidance as the tool result.
  *
- * Inherits the parent transcript (sanitized), frames it as advice via
- * `buildAdvisorSystem`, and runs on `llm.advisorProfile` (unless the caller
- * passed an explicit `inference_profile`) under both the advisor role allowlist
- * and `denySideEffectTools`, so the only tools it can reach are the first-party
+ * The consult sees only what it is handed: the spawning agent's own `objective`
+ * as a written brief, plus the situational context pack from
+ * `buildAdvisorContext`. Nothing of the parent conversation's transcript or
+ * system prompt travels with it, so a consult costs the brief rather than a
+ * re-prefill of the whole chat at premium rates.
+ *
+ * It is framed as advice via `buildAdvisorSystem` and runs on
+ * `llm.advisorProfile` (unless the caller passed an explicit
+ * `inference_profile`) under both the advisor role allowlist and
+ * `denySideEffectTools`, so the only tools it can reach are the first-party
  * built-in readers. It is bounded on two axes, because the consult holds up the
  * user-facing turn while it runs: a progress-aware deadline (an idle window,
  * `ADVISOR_IDLE_TIMEOUT_MS`, reset on every streamed token and every tool event
@@ -562,7 +566,7 @@ function inFlightGuardResult(
 async function runAdvisorConsult(args: {
   context: ToolContext;
   label: string;
-  /** The agent's own `objective` — its framing of what it wants advised on. */
+  /** The agent's own `objective`: the brief the advisor advises off. */
   objective: string;
   sendToClient: (msg: AssistantEvent) => void;
   requestedOverrideProfile: string | undefined;
@@ -576,35 +580,16 @@ async function runAdvisorConsult(args: {
   let profileNote: string | undefined;
 
   try {
+    // The parent conversation is looked up only for its warm skill catalog, so
+    // an unresolvable one (e.g. evicted) costs the skills section of the pack
+    // and nothing else: the consult itself runs off the brief.
     const parentConversation = findConversation(context.conversationId);
-    if (!parentConversation) {
-      return {
-        content:
-          "(advisor unavailable: parent conversation could not be resolved)",
-        isError: false,
-      };
-    }
-
-    // Snapshot the parent's in-memory transcript and system prompt, then append
-    // the in-flight assistant turn (the plan/text the model wrote THIS turn,
-    // before calling the advisor). The in-memory array does not yet hold that
-    // turn — the agent loop only writes it back to `conversation.messages` after
-    // the turn settles — but it is already persisted to the DB (the assistant
-    // row is finalized at `message_complete`, which fires before tool execution).
-    // `sanitizeConsultTranscript` then strips the dangling advisor `tool_use`
-    // off that final assistant turn so the inherited transcript is provider-safe.
-    const parentSystemPrompt = parentConversation.getCurrentSystemPrompt();
-    const withInFlight = appendInFlightAssistantTurn(
-      [...parentConversation.messages],
-      context.conversationId,
-    );
-    const sanitizedMessages = sanitizeConsultTranscript(withInFlight);
 
     // Situational awareness for the advisor: the parent's live tool set, the
     // full skill catalog, and its workspace. Assembled off the per-turn
     // ToolContext snapshot (trust, channel) so the personal-memory sections
     // are gated exactly like the runtime injectors. Best-effort: a null pack
-    // just means the consult runs on transcript + system prompt alone.
+    // just means the consult runs on the brief alone.
     const situationalContext = await buildAdvisorContext({
       conversationId: context.conversationId,
       workingDir: context.workingDir,
@@ -614,7 +599,7 @@ async function runAdvisorConsult(args: {
       enabledPluginSet: context.enabledPluginSet,
       // The parent's warm per-turn catalog keeps the synchronous on-disk
       // catalog scan out of the consult path.
-      skillCatalog: parentConversation.skillProjectionCache?.catalog,
+      skillCatalog: parentConversation?.skillProjectionCache?.catalog,
     });
 
     // Default to the stronger advisor profile when the caller did not pin one;
@@ -623,7 +608,7 @@ async function runAdvisorConsult(args: {
     let overrideProfile = requestedOverrideProfile ?? config.llm.advisorProfile;
     // The advisor carries read tools, so a profile the catalog states cannot
     // call them is handed a surface it can never use and answers from the
-    // transcript alone. Fall back to the call site's own default and say so
+    // brief alone. Fall back to the call site's own default and say so
     // alongside the guidance, the way a regular spawn reports it. The check is
     // unconditional, matching the tools it protects, and only a catalog `false`
     // redirects, so a model the catalog has never heard of is left alone.
@@ -697,16 +682,15 @@ async function runAdvisorConsult(args: {
         {
           parentConversationId: context.conversationId,
           label,
-          // Carry the agent's own objective into the consult request — the
-          // agent states the task here, and the inherited transcript can be
-          // thin. The situational pack rides in the model request only
-          // (`requestText`), keeping the system prompt minimal and the
-          // display-facing `objective` free of bulky internal context.
+          // The agent's own objective IS the brief the consult runs on, so it
+          // carries into the request verbatim. The situational pack rides in
+          // the model request only (`requestText`), keeping the system prompt
+          // minimal and the display-facing `objective` free of bulky internal
+          // context.
           objective: advisorRequestText(objective),
           requestText: advisorRequestText(objective, situationalContext),
           sendResultToUser: false,
           role: "advisor",
-          fork: true,
           // The advisor's read-only guarantee cannot rest on tool NAMES. A
           // workspace tool may register under `file_read` (registerWorkspaceTools
           // stashes the built-in and installs its own implementation), and a
@@ -718,10 +702,9 @@ async function runAdvisorConsult(args: {
           //
           // The advisor is a ROLE, not an `LLMCallSiteEnum` value, so its usage
           // lands under `subagentSpawn` like any other subagent. This is what
-          // makes advisor consults separable from regular forks in telemetry.
+          // makes advisor consults separable from regular spawns in telemetry.
           spawnMode: "advisor_consult",
-          parentMessages: sanitizedMessages,
-          systemPromptOverride: buildAdvisorSystem(parentSystemPrompt),
+          systemPromptOverride: buildAdvisorSystem(),
           ...(overrideProfile ? { overrideProfile } : {}),
           ...(forceOverrideProfile ? { forceOverrideProfile: true } : {}),
           // A consult is delegated work of the invoking turn, so its spend
@@ -817,46 +800,3 @@ function withAdvisorNote(
   }
   return `${guidance}\n\n${present.map((note) => `_(${note})_`).join("\n")}`;
 }
-
-/**
- * Append the in-flight assistant turn (persisted this turn before the advisor
- * tool ran) to an in-memory message snapshot, unless the snapshot already ends
- * with it. The latest persisted assistant row carries the plan/text the model
- * wrote immediately before calling the advisor plus the dangling advisor
- * `tool_use`; `sanitizeConsultTranscript` strips the dangling call.
- *
- * Best-effort: a malformed or missing row leaves the snapshot unchanged so the
- * consult still runs over the in-memory history.
- */
-function appendInFlightAssistantTurn(
-  messages: Message[],
-  conversationId: string,
-): Message[] {
-  // When the snapshot already ends on an assistant turn, the in-flight turn is
-  // present (or there is none to add) — appending the latest row would duplicate it.
-  if (messages[messages.length - 1]?.role === "assistant") {
-    return messages;
-  }
-
-  let rows;
-  try {
-    rows = getMessages(conversationId);
-  } catch {
-    return messages;
-  }
-  if (!rows || rows.length === 0) {
-    return messages;
-  }
-
-  const lastRow = rows[rows.length - 1];
-  if (lastRow.role !== "assistant") {
-    return messages;
-  }
-
-  const blocks: ContentBlock[] = lastRow.content;
-
-  if (blocks.length === 0) {
-    return messages;
-  }
-  return [...messages, { role: "assistant", content: blocks }];
-}

package/src/tools/ui-surface/surface-shape-docs.ts

@@ -123,7 +123,7 @@ export const SURFACE_SHAPE_DOCS: Record<string, SurfaceShapeDoc> = {
   work_result: {
     purpose: "structured receipt after completed work",
     shape:
-      '{ eyebrow?, status?: "completed"|"partial"|"failed"|"in_progress", summary?, metrics?: [{ label, value, detail?, tone?: "neutral"|"positive"|"warning"|"negative" }], sections?: [{ id?, title, description?, type?: "items"|"timeline"|"diff"|"artifacts"|"warnings", items?: [{ id?, title, description?, status?, tone?, metadata?: [{ label, value }], href? }], diffs?: [{ label?, before?, after? }] }] } — structured receipt after real work; keep display-only unless follow-up buttons are needed',
+      '{ eyebrow?, status?: "completed"|"partial"|"failed"|"in_progress", summary?, metrics?: [{ label, value, detail?, tone?: "neutral"|"positive"|"warning"|"negative" }], sections?: [{ id?, title, description?, type?: "items"|"timeline"|"diff"|"artifacts"|"warnings", items?: [{ id?, title, description?, status?, tone?, metadata?: [{ label, value }], href? }], diffs?: [{ label?, before?, after? }] }] }: structured receipt after real work; keep display-only unless follow-up buttons are needed. An item `href` makes the row a link: an in-app path (e.g. "/assistant/skills/<skillId>?tab=history") opens in place, an https URL opens externally; other schemes are ignored',
     missingContent: (data) =>
       hasContent(data)
         ? null