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

package/src/config/bundled-skills/acp/SKILL.md

@@ -26,24 +26,11 @@ Users can refer to agents by natural names: "claude code", "codex cli", "openai
 
 ## First-time setup
 
-When the user first tries to use ACP and it's not enabled, set it up automatically:
+ACP is always available - default profiles for `claude`, `codex`, and `gemini` ship out-of-box, so no config edit is needed to start. First-time setup is just making the adapter binary available, then spawning:
 
-1. **Enable the `acp` feature flag** (the primary enablement path). Either PATCH it via the gateway feature-flags endpoint or direct the user to toggle "ACP Coding Agents" in the client's feature flags UI. Flag changes are hot-refreshed in the assistant - no restart needed.
+1. Install the adapter binary if it's missing. This happens automatically: when `acp_spawn` finds the agent's binary missing from PATH, the assistant installs it once via a sandboxed bun global install and proceeds in the same call (see "Automatic adapter availability" below).
 
-   As a supported alternative, edit the workspace config file to add the `acp` section. Default profiles for `claude`, `codex`, and `gemini` ship out-of-box, so the minimal config is just:
-   ```json
-   {
-     "acp": {
-       "enabled": true,
-       "maxConcurrentSessions": 4
-     }
-   }
-   ```
-   If you go the config route, **wait a few seconds** for the config watcher to pick up the change (it hot-reloads automatically - no restart needed).
-
-2. Then retry the `acp_spawn` call. Do NOT run `vellum sleep && vellum wake` - that kills the conversation.
-
-No manual binary installation is needed first: missing adapter binaries are installed automatically (see below).
+2. Call `acp_spawn`. Do NOT run `vellum sleep && vellum wake` - that kills the conversation.
 
 ## Automatic adapter availability
 
@@ -140,7 +127,7 @@ Then retry the `acp_spawn` call.
 
 ## Discoverability
 
-Use `acp_list_agents` to see what's set up and what's missing. It returns each available agent profile, whether ACP is enabled, whether the agent's binary is on PATH (missing binaries are installed automatically on first spawn), and an install hint if not. This is the right tool to call when deciding between `claude`, `codex`, and `gemini`, or when the user asks "what coding agents do I have?"
+Use `acp_list_agents` to see what's set up and what's missing. It returns each available agent profile, whether the agent's binary is on PATH (missing binaries are installed automatically on first spawn), and an install hint if not. This is the right tool to call when deciding between `claude`, `codex`, and `gemini`, or when the user asks "what coding agents do I have?"
 
 ## Working directory
 

package/src/config/bundled-skills/acp/TOOLS.json

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "acp_spawn",
-      "description": "Spawn an external coding agent (e.g. Claude Code, Codex, Gemini) via ACP to work on a task. Default profiles ship for `claude` (`claude-agent-acp`), `codex` (`codex-acp`), and `gemini` (`gemini --acp`); the assistant resolves the agent id to the right binary. The agent runs as a subprocess and streams results back. Use this when you want to delegate a coding task to an external agent that has its own tools, file editing, and terminal access. If a default agent's binary is missing, the assistant installs it once via a sandboxed bun global install and proceeds in the same call; if that fails (e.g. bun unavailable), an actionable install hint is returned - do NOT alter `agents.<id>.command` to swap binaries. If ACP is disabled, follow the setup instructions in SKILL.md.",
+      "description": "Spawn an external coding agent (e.g. Claude Code, Codex, Gemini) via ACP to work on a task. Default profiles ship for `claude` (`claude-agent-acp`), `codex` (`codex-acp`), and `gemini` (`gemini --acp`); the assistant resolves the agent id to the right binary. The agent runs as a subprocess and streams results back. Use this when you want to delegate a coding task to an external agent that has its own tools, file editing, and terminal access. If a default agent's binary is missing, the assistant installs it once via a sandboxed bun global install and proceeds in the same call; if that fails (e.g. bun unavailable), an actionable install hint is returned - do NOT alter `agents.<id>.command` to swap binaries.",
       "category": "orchestration",
       "risk": "high",
       "input_schema": {
@@ -87,7 +87,7 @@
     },
     {
       "name": "acp_list_agents",
-      "description": "Lists ACP coding agents available to spawn. Each entry includes whether ACP is enabled, whether the agent's binary is on PATH (missing binaries are installed automatically on first spawn), and an install command if not. Use this to decide between 'claude', 'codex', and 'gemini' or to surface setup steps to the user.",
+      "description": "Lists ACP coding agents available to spawn. Each entry includes whether the agent's binary is on PATH (missing binaries are installed automatically on first spawn), and an install command if not. Use this to decide between 'claude', 'codex', and 'gemini' or to surface setup steps to the user.",
       "category": "orchestration",
       "risk": "low",
       "input_schema": {

package/src/config/call-site-defaults.ts

@@ -25,7 +25,6 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     profile: "cost-optimized",
     contextWindow: { maxInputTokens: 1000000 },
   },
-  memoryV3RouteL1: { profile: "balanced", temperature: 0 },
   memoryV3SelectL2: { profile: "balanced", temperature: 0 },
   recall: {
     profile: "balanced",

package/src/config/feature-flag-registry.json

@@ -39,8 +39,9 @@
       "scope": "client",
       "key": "experiment-activation-flow-2026-06-03",
       "label": "Activation Flow Experiment 2026-06-03",
-      "description": "Route allowlisted users to the activation-rail bootstrap template after pre-chat. Off by default and targeted through LaunchDarkly.",
-      "defaultEnabled": false
+      "description": "Multivariate activation-flow experiment. control = standard flow; variant-a = activation rail. Targeted via LaunchDarkly.",
+      "defaultEnabled": "control",
+      "values": ["control", "variant-a"]
     },
     {
       "id": "local-docker-enabled",
@@ -481,22 +482,6 @@
       "label": "Self-intro first message",
       "description": "On the first conversation, send a natural self-introduction (e.g. \"Hi Vela, I'm alex. Nice to meet you.\") on the user's behalf and route it through real LLM inference, instead of serving the canned first greeting. Names come from the onboarding context; falls back to the canned greeting when no name is known. Exposed to clients so pre-hatch onboarding can compute the source-of-truth initial message, and to the assistant so older clients can still be gated server-side. See assistant/src/daemon/first-greeting.ts (buildSelfIntroMessage).",
       "defaultEnabled": false
-    },
-    {
-      "id": "provider-first-profile-creation",
-      "scope": "client",
-      "key": "provider-first-profile-creation",
-      "label": "Provider-First Profile Creation",
-      "description": "New profile creation flow: pick (or inline-create) a provider first, then a model, with pre-filled provider and profile name/key, plus a quick-add \"+\" in the chat composer's Model Profile menu. When off, profile creation uses the previous field order and there is no composer quick-add.",
-      "defaultEnabled": false
-    },
-    {
-      "id": "acp",
-      "scope": "assistant",
-      "key": "acp",
-      "label": "ACP Coding Agents",
-      "description": "Enable spawning and steering external coding agents (Claude Code, Codex, Gemini) via the Agent Client Protocol. Alternative gate to the acp.enabled workspace config field; either enables the subsystem.",
-      "defaultEnabled": false
     }
   ]
 }

package/src/config/llm-resolver.ts

@@ -78,6 +78,15 @@ export function resolveCallSiteConfig(
 ): z.infer<typeof LLMConfigBase> {
   const layers: Mergeable[] = [llm.default as Mergeable];
 
+  // Effective logit-bias preset, tracked outside the deep-merge so it ties to
+  // the single highest-precedence *profile* that wins resolution rather than
+  // inheriting from a lower one. Profile layers are appended low→high, and each
+  // one fully determines the preset (a profile that omits `logitBias` clears
+  // any value a lower-precedence profile set), so the last profile appended
+  // wins — matching the merge's own precedence and including the implicit
+  // call-site default selected by `effectiveDefault`.
+  const biasRef: LogitBiasRef = { preset: undefined };
+
   const activeFragment = resolveProfileFragment(llm.activeProfile, llm, opts);
   const overrideFragment = resolveProfileFragment(
     opts.overrideProfile,
@@ -89,18 +98,32 @@ export function resolveCallSiteConfig(
     effectiveDefault(callSite, llm, opts.overrideProfile != null);
 
   if (callSite === "mainAgent") {
-    appendCallSiteLayers(layers, callSite, llm, site, opts);
-    appendProfileLayer(layers, activeFragment);
-    appendProfileLayer(layers, overrideFragment);
+    appendCallSiteLayers(layers, callSite, llm, site, opts, biasRef);
+    appendProfileLayer(layers, activeFragment, biasRef);
+    appendProfileLayer(layers, overrideFragment, biasRef);
   } else {
-    appendProfileLayer(layers, activeFragment);
-    appendProfileLayer(layers, overrideFragment);
-    appendCallSiteLayers(layers, callSite, llm, site, opts);
+    appendProfileLayer(layers, activeFragment, biasRef);
+    appendProfileLayer(layers, overrideFragment, biasRef);
+    appendCallSiteLayers(layers, callSite, llm, site, opts, biasRef);
   }
 
-  return finalize(deepMerge(...layers.map(withImpliedProviderForKnownModel)));
+  const resolved = finalize(
+    deepMerge(...layers.map(withImpliedProviderForKnownModel)),
+  );
+  // `logitBias` is profile-scoped: the winning profile is its only source.
+  // Overwrite — or clear — whatever the deep-merge may have copied from a
+  // non-profile layer (`llm.default` or a call-site fragment), so a preset set
+  // outside a profile can't apply to a profile that didn't opt in.
+  if (biasRef.preset !== undefined) {
+    resolved.logitBias = biasRef.preset;
+  } else {
+    delete (resolved as { logitBias?: unknown }).logitBias;
+  }
+  return resolved;
 }
 
+type LogitBiasRef = { preset: ProfileEntry["logitBias"] };
+
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -261,8 +284,10 @@ function withImpliedProviderForKnownModel(source: Mergeable): Mergeable {
 function appendProfileLayer(
   layers: Mergeable[],
   profile: ProfileEntry | undefined,
+  biasRef: LogitBiasRef,
 ): void {
   if (profile != null) {
+    biasRef.preset = profile.logitBias;
     layers.push(profileConfigFragment(profile));
   }
 }
@@ -273,6 +298,7 @@ function appendCallSiteLayers(
   llm: z.infer<typeof LLMSchema>,
   site: z.infer<typeof LLMSchema>["callSites"][LLMCallSite] | undefined,
   opts: ResolveCallSiteOpts,
+  biasRef: LogitBiasRef,
 ): void {
   if (site != null) {
     if (site.profile != null) {
@@ -286,6 +312,7 @@ function appendCallSiteLayers(
           `LLM call site "${callSite}" references undefined profile "${site.profile}"`,
         );
       }
+      biasRef.preset = profileFragment.logitBias;
       layers.push(profileConfigFragment(profileFragment));
     }
     // Strip the `profile` discriminator before merging — it isn't a
@@ -304,6 +331,11 @@ function profileConfigFragment(profile: ProfileEntry): Mergeable {
     // profile before this point), but strip it defensively so it can never
     // leak into the merged `LLMConfigBase`.
     mix: _mix,
+    // `logitBias` is profile-identity metadata, not inheritable config: a
+    // preset must apply only to the profile that opted in, never bleed from a
+    // lower-precedence (e.g. active) profile into one that merely inherited it.
+    // `RetryProvider` resolves it from the applied profile, not the merge.
+    logitBias: _logitBias,
     ...config
   } = profile;
   return config as Mergeable;

package/src/config/schemas/__tests__/memory-v3.test.ts

@@ -7,19 +7,35 @@ describe("MemoryV3ConfigSchema", () => {
     const parsed = MemoryV3ConfigSchema.parse({});
     expect(parsed).toEqual({
       workingSet: { maxPages: 150, evictWindow: 5 },
-      l2Concurrency: 16,
+      needleK: 100,
+      denseK: 100,
+      edge: { hubDegree: 30, seedCount: 18, perSeed: 6, cap: 45 },
     });
   });
 
-  test("accepts an explicit l2Concurrency override", () => {
-    expect(MemoryV3ConfigSchema.parse({ l2Concurrency: 8 }).l2Concurrency).toBe(
-      8,
-    );
+  test("accepts explicit lane-K overrides", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ needleK: 50, denseK: 75 });
+    expect(parsed.needleK).toBe(50);
+    expect(parsed.denseK).toBe(75);
   });
 
-  test("rejects a non-positive or non-integer l2Concurrency", () => {
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 0 })).toThrow();
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: -4 })).toThrow();
-    expect(() => MemoryV3ConfigSchema.parse({ l2Concurrency: 1.5 })).toThrow();
+  test("accepts a partial edge override, defaulting the rest", () => {
+    const parsed = MemoryV3ConfigSchema.parse({ edge: { hubDegree: 10 } });
+    expect(parsed.edge).toEqual({
+      hubDegree: 10,
+      seedCount: 18,
+      perSeed: 6,
+      cap: 45,
+    });
+  });
+
+  test("rejects non-positive or non-integer lane knobs", () => {
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: 0 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ denseK: -4 })).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ needleK: 1.5 })).toThrow();
+    expect(() =>
+      MemoryV3ConfigSchema.parse({ edge: { perSeed: 0 } }),
+    ).toThrow();
+    expect(() => MemoryV3ConfigSchema.parse({ edge: { cap: -1 } })).toThrow();
   });
 });

package/src/config/schemas/call-site-catalog.ts

@@ -121,13 +121,6 @@ const CATALOG_RECORD: CatalogRecord = {
       "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
     domain: "memory",
   },
-  memoryV3RouteL1: {
-    id: "memoryV3RouteL1",
-    displayName: "Memory V3 L1 Router",
-    description:
-      "Picks which leaves of the topic tree to open for the next agent turn by routing over a cache-warm static leaf block.",
-    domain: "memory",
-  },
   memoryV3SelectL2: {
     id: "memoryV3SelectL2",
     displayName: "Memory V3 L2 Selector",

package/src/config/schemas/llm.ts

@@ -50,7 +50,6 @@ export const LLMCallSiteEnum = z.enum([
   "memoryV2Migration",
   "memoryV2Sweep",
   "memoryRouter",
-  "memoryV3RouteL1",
   "memoryV3SelectL2",
   "memoryV2Consolidation",
   "memoryRetrospective",
@@ -124,6 +123,17 @@ const VerbosityEnum = z.enum(["low", "medium", "high"]);
 const ModelSchema = z.string().min(1);
 const MaxTokensSchema = z.number().int().positive();
 const TemperatureSchema = z.number().min(0).max(2).nullable();
+// Named, code-resolved logit-bias preset a profile may opt into. The value is a
+// preset *name*, not an inline token→bias map, so the workspace config stays
+// small. This is profile-identity metadata, not inheritable config: the resolver
+// strips it from the deep-merge and re-attaches it from the winning profile (see
+// `profileConfigFragment` / `resolveCallSiteConfig`), and `RetryProvider`
+// resolves it to a `logit_bias` map at request time, forwarded only on the
+// Fireworks (OpenAI-compatible) path. Keep these literals in sync with the
+// presets handled by `resolveLogitBiasPreset` in
+// `providers/inference/logit-bias.ts` (kept separate to avoid a schema →
+// provider import cycle).
+const LogitBiasPresetSchema = z.enum(["suppress-cjk"]);
 
 // ---------------------------------------------------------------------------
 // Thinking & ContextWindow
@@ -316,6 +326,11 @@ export const LLMConfigBase = z.object({
   thinking: ThinkingSchema.default(ThinkingSchema.parse({})),
   contextWindow: ContextWindowSchema.default(ContextWindowSchema.parse({})),
   openrouter: OpenRouterSchema.default(OpenRouterSchema.parse({})),
+  // Not deep-merged like the other fields: `resolveCallSiteConfig` sets this
+  // from the single highest-precedence profile that won resolution (see
+  // `profileConfigFragment`, which strips it from the merge), so a preset
+  // can't bleed from a lower-precedence profile into one that didn't opt in.
+  logitBias: LogitBiasPresetSchema.optional(),
 });
 export type LLMConfigBase = z.infer<typeof LLMConfigBase>;
 
@@ -336,6 +351,7 @@ const LLMConfigFragment = z.object({
   thinking: ThinkingFragmentSchema.optional(),
   contextWindow: ContextWindowDeepPartialSchema.optional(),
   openrouter: OpenRouterDeepPartialSchema.optional(),
+  logitBias: LogitBiasPresetSchema.optional(),
 });
 type LLMConfigFragment = z.infer<typeof LLMConfigFragment>;
 

package/src/config/schemas/memory-v3.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 
 /**
- * Memory v3 (topic-tree routing) working-set configuration.
+ * Memory v3 (section-grain lane retrieval) working-set configuration.
  *
  * The working set is the per-conversation set of concept pages carried
  * forward across turns. Eviction keeps it bounded: pages unseen for longer
@@ -28,20 +28,70 @@ export const MemoryV3WorkingSetSchema = z
   })
   .describe("Memory v3 working-set retention/eviction tuning.");
 
+/**
+ * Edge-lane tuning for the link-graph expansion that folds a turn's lexical and
+ * dense seeds outward to their first-class neighbours.
+ */
+export const MemoryV3EdgeSchema = z
+  .object({
+    hubDegree: z
+      .number({ error: "memory.v3.edge.hubDegree must be a number" })
+      .int("memory.v3.edge.hubDegree must be an integer")
+      .positive("memory.v3.edge.hubDegree must be a positive integer")
+      .default(30)
+      .describe(
+        "In-degree above which an article is treated as a hub and excluded from edge expansion (too generic to be a useful surface).",
+      ),
+    seedCount: z
+      .number({ error: "memory.v3.edge.seedCount must be a number" })
+      .int("memory.v3.edge.seedCount must be an integer")
+      .positive("memory.v3.edge.seedCount must be a positive integer")
+      .default(18)
+      .describe(
+        "Number of top needle+dense seeds (in rank order) expanded by the edge lane.",
+      ),
+    perSeed: z
+      .number({ error: "memory.v3.edge.perSeed must be a number" })
+      .int("memory.v3.edge.perSeed must be an integer")
+      .positive("memory.v3.edge.perSeed must be a positive integer")
+      .default(6)
+      .describe("Maximum neighbours surfaced per expanded seed."),
+    cap: z
+      .number({ error: "memory.v3.edge.cap must be a number" })
+      .int("memory.v3.edge.cap must be an integer")
+      .positive("memory.v3.edge.cap must be a positive integer")
+      .default(45)
+      .describe(
+        "Hard cap on the total number of distinct articles surfaced by the edge lane.",
+      ),
+  })
+  .describe("Memory v3 edge-lane (link-graph expansion) tuning.");
+
 export const MemoryV3ConfigSchema = z
   .object({
     workingSet: MemoryV3WorkingSetSchema.default(
       MemoryV3WorkingSetSchema.parse({}),
     ),
-    l2Concurrency: z
-      .number({ error: "memory.v3.l2Concurrency must be a number" })
-      .int("memory.v3.l2Concurrency must be an integer")
-      .positive("memory.v3.l2Concurrency must be a positive integer")
-      .default(16)
+    needleK: z
+      .number({ error: "memory.v3.needleK must be a number" })
+      .int("memory.v3.needleK must be an integer")
+      .positive("memory.v3.needleK must be a positive integer")
+      .default(100)
+      .describe(
+        "Number of section-grain BM25 needle articles folded into the candidate pool each turn.",
+      ),
+    denseK: z
+      .number({ error: "memory.v3.denseK must be a number" })
+      .int("memory.v3.denseK must be an integer")
+      .positive("memory.v3.denseK must be a positive integer")
+      .default(100)
       .describe(
-        "Bounded fan-out for the per-leaf L2 selection (number of leaf selector calls in flight at once).",
+        "Number of dense-lane articles folded into the candidate pool each turn.",
       ),
+    edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
   })
-  .describe("Memory v3 — topic-tree routing with a carry-forward working set");
+  .describe(
+    "Memory v3 — section-grain lane retrieval with a carry-forward working set",
+  );
 
 export type MemoryV3Config = z.infer<typeof MemoryV3ConfigSchema>;

package/src/config/seed-inference-profiles.ts

@@ -74,6 +74,24 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     thinking: { enabled: false, streamThinking: false },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
   },
+  // Open-weight economy option: Kimi K2.6 served by Fireworks via managed
+  // platform inference. Carries the `suppress-cjk` logit-bias preset to
+  // discourage the model from spontaneously emitting Chinese in English
+  // output; the preset is profile-scoped and only forwarded on the Fireworks
+  // path (see `providers/inference/logit-bias.ts`).
+  "balanced-economy": {
+    intent: "balanced",
+    provider: "fireworks",
+    connectionName: "fireworks-managed",
+    source: "managed",
+    label: "Balanced Economy",
+    description: "Strong open model (Kimi K2.6) at a lower price point",
+    maxTokens: 16000,
+    effort: "high",
+    thinking: { enabled: true, streamThinking: true },
+    contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
+    logitBias: "suppress-cjk",
+  },
 };
 
 /**

package/src/context/post-turn-tool-result-truncation.ts

@@ -22,6 +22,34 @@ export const TOOL_RESULT_DIR = ".tool-results";
 /** Marker used to detect already-truncated results (idempotency guard). */
 export const TRUNCATION_MARKER = "\u2014 full result:";
 
+/**
+ * Tools whose results carry durable operating instructions the model relies on
+ * across later turns rather than one-off data it only needs in the moment.
+ * Their results must never be middle-truncated: paging out the middle silently
+ * strips the workflow (e.g. a `skill_load` body losing its "## Available Tools"
+ * section), leaving the model to fall back to generic priors. Skill bodies are
+ * bounded and authored to live in context, so exempting them is safe.
+ */
+export const TRUNCATION_EXEMPT_TOOLS = new Set<string>(["skill_load"]);
+
+/**
+ * Build a map of tool_use_id -> originating tool name by walking the tool_use
+ * blocks in assistant messages. A tool_result only carries `tool_use_id`, so
+ * this is the only way to recover which tool produced a given result.
+ */
+function buildToolNameById(messages: Message[]): Map<string, string> {
+  const byId = new Map<string, string>();
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue;
+    for (const block of msg.content) {
+      if (block.type !== "tool_use") continue;
+      const tu = block as ToolUseContent;
+      byId.set(tu.id, tu.name);
+    }
+  }
+  return byId;
+}
+
 /**
  * Deterministic file path for a tool result's full content on disk.
  * Uses the first 12 hex chars of the SHA-256 of the tool_use_id.
@@ -59,7 +87,8 @@ export function buildTruncatedContent(
  * - The in-context content is replaced with a prefix/suffix stub.
  *
  * Results are skipped if they are below threshold, are error results,
- * or have already been truncated (contain `TRUNCATION_MARKER`).
+ * have already been truncated (contain `TRUNCATION_MARKER`), or were produced
+ * by a tool in `TRUNCATION_EXEMPT_TOOLS` (durable instructions like skill bodies).
  *
  * Returns a shallow-copied messages array (only modified messages are cloned)
  * and the count of results that were truncated.
@@ -70,6 +99,8 @@ export function postTurnTruncateToolResults(
 ): { messages: Message[]; truncatedCount: number } {
   let truncatedCount = 0;
 
+  const toolNameById = buildToolNameById(messages);
+
   const mapped = messages.map((msg) => {
     let changed = false;
     const nextContent: ContentBlock[] = msg.content.map((block) => {
@@ -82,6 +113,13 @@ export function postTurnTruncateToolResults(
       // Skip error results.
       if (tr.is_error) return block;
 
+      // Skip results from tools whose output is durable operating instructions
+      // (e.g. skill_load); middle-truncating them strips the workflow.
+      const toolName = toolNameById.get(tr.tool_use_id);
+      if (toolName !== undefined && TRUNCATION_EXEMPT_TOOLS.has(toolName)) {
+        return block;
+      }
+
       // Skip already-truncated results (idempotency).
       if (tr.content.includes(TRUNCATION_MARKER)) return block;
 

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -17,7 +17,6 @@ import type {
 import { getConfig } from "../config/loader.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
 import { getCalibrationProviderKey } from "../context/token-estimator.js";
-import type { ContextWindowResult } from "../context/window-manager.js";
 import { projectAssistantMessage } from "../memory/conversation-attention-store.js";
 import {
   deleteMessageById,
@@ -46,6 +45,7 @@ import {
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../messaging/providers/slack/message-metadata.js";
+import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import type {
   ContentBlock,
   ImageContent,
@@ -1482,6 +1482,13 @@ function annotatePersistedAssistantMessage(
         display: surface.display,
         ...(surface.persistent ? { persistent: true } : {}),
         ...(surface.toolCallId ? { toolCallId: surface.toolCallId } : {}),
+        // Daemon-only commit-timing activation tag, persisted so
+        // restoreSurfaceStateFromHistory can rehydrate it after a reload. This
+        // block lives only in server-side conversation history, never in the
+        // client `ui_surface_show` message.
+        ...(surface.activationMoment
+          ? { activationMoment: surface.activationMoment }
+          : {}),
       } as unknown as ContentBlock);
     }
     modified = true;