@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/src/config/schema/magic-context.test.ts

@@ -38,11 +38,10 @@ describe("MagicContextConfigSchema", () => {
                 fail_closed_blocking: true,
                 transform_mode: "ts",
                 storage: { enforce_private_permissions: true },
-                smart_notes: { retina_handoff: false },
+                smart_notes: { enabled: true, retina_handoff: false },
                 cache_ttl: "5m",
                 prompt_surface: { default: "full" },
                 execute_threshold_percentage: 65,
-                clear_reasoning_age: 50,
                 history_budget_percentage: DEFAULT_HISTORY_BUDGET_PERCENTAGE,
                 historian_timeout_ms: DEFAULT_HISTORIAN_TIMEOUT_MS,
                 embedding: {
@@ -145,7 +144,7 @@ describe("MagicContextConfigSchema", () => {
                     overlay: false,
                 },
                 smart_drops: false,
-                smart_notes: { retina_handoff: false },
+                smart_notes: { enabled: true, retina_handoff: false },
                 shadow_embedding: {
                     enabled: false,
                 },
@@ -701,8 +700,10 @@ describe("MagicContextConfigSchema", () => {
             ).toBe(30000);
         });
 
-        it("rejects clear_reasoning_age below minimum", () => {
-            expect(() => MagicContextConfigSchema.parse({ clear_reasoning_age: 9 })).toThrow();
+        it("accepts deprecated clear_reasoning_age without applying its old validation", () => {
+            expect(
+                MagicContextConfigSchema.parse({ clear_reasoning_age: 9 }).keep_reasoning_tokens,
+            ).toBeUndefined();
         });
 
         it("rejects historian_timeout_ms below minimum", () => {

package/src/config/schema/magic-context.ts

@@ -682,7 +682,7 @@ export const HistorianConfigSchema = AgentMetadataSchema.extend({
         )
         .optional()
         .describe(
-            'Readable historian tool expansions, keyed by exact host tool name. Templates override built-in defaults; false disables an expansion. Supports ${input.path}, ${output.path}, bare ${output}, array [N], [*].field, .each("${field}"), .join("separator"), .count and final .truncate(N). Missing fields are empty; placeholders default to 300 characters, lists to 10 elements, expansions to 1000 characters. Valid in user and project config; affects historian/recomp and verbose ctx_expand only, never the wire or default ctx_expand transcript.',
+            'Readable historian tool expansions, keyed by exact host tool name. Templates override built-in defaults; false disables an expansion. Supports ${input.path}, ${output.path}, bare ${output}, array [N], [*].field, .each("${field}"), .join("separator"), .count and final .truncate(N). Missing fields are empty. Historian text and lists have no implicit caps; explicit .truncate(N) keeps complete sentences and marks omitted characters, or emits only the marker if no sentence fits. When the ctx_expand history-recovery tool is called in verbose mode, its tool-call previews retain their original built-in templates and limits (300 characters per placeholder, 10 list elements, 1000 characters per expansion). Valid in user and project config; never changes the wire or default ctx_expand transcript.',
         ),
     opencode: OpenCodeHarnessBlockSchema.optional(),
     pi: PiHarnessBlockSchema.optional(),
@@ -917,9 +917,9 @@ export interface ShadowEmbeddingConfig {
 
 export interface MuralConfig {
     enabled: boolean;
-    /** The CUE COMPRESSOR model for the compress-cues dreamer task (the mural is
-     *  now rendered deterministically, so this no longer names an author model). */
-    model?: string;
+    /** Deprecated and ignored: compress-cues takes its model from each
+     *  harness's dreamer settings, like every other dreamer task. */
+    model?: unknown;
 }
 
 export interface MagicContextConfig {
@@ -943,6 +943,8 @@ export interface MagicContextConfig {
     historian?: HistorianConfig;
     dreamer?: DreamerConfig;
     smart_notes: {
+        /** Enable smart-note authoring and checks for the user; read at process startup. */
+        enabled: boolean;
         /** Flip ownership of authoring-compiled conditions from dreamer to retina. */
         retina_handoff: boolean;
     };
@@ -963,7 +965,8 @@ export interface MagicContextConfig {
     protected_tokens?: number;
     protected_tags?: number;
     protected_tools: Record<string, number>;
-    clear_reasoning_age: number;
+    clear_reasoning_age?: unknown;
+    keep_reasoning_tokens?: number | Record<string, number>;
     history_budget_percentage: number;
     historian_timeout_ms: number;
     commit_cluster_trigger: {
@@ -1120,13 +1123,12 @@ export const MagicContextConfigSchema = z
             .object({
                 enabled: z.boolean().default(false),
                 model: z
-                    .string()
-                    .trim()
-                    .min(1)
+                    .unknown()
                     .optional()
                     .describe(
-                        "Model for the compress-cues task that compresses each memory into a mural cue. The mural image itself is rendered deterministically (no author model).",
-                    ),
+                        "Deprecated: ignored. compress-cues now uses the dreamer model for each harness, like every other dreamer task; override it with dreamer.opencode.tasks.compress-cues.model (or the pi/omp equivalent). Remove this key; it no longer does anything.",
+                    )
+                    .meta({ deprecated: true }),
             })
             .default({ enabled: false })
             .describe(
@@ -1183,6 +1185,12 @@ export const MagicContextConfigSchema = z
         ),
         smart_notes: z
             .object({
+                enabled: z
+                    .boolean()
+                    .default(true)
+                    .describe(
+                        "Enable smart-note authoring and condition evaluation. User-level only: tool definitions are process-wide. Changes require a host restart and rebuild each session's cached prompt once. Pending notes remain stored and unchecked; already-ready notes still surface.",
+                    ),
                 retina_handoff: z
                     .boolean()
                     .default(false)
@@ -1190,7 +1198,7 @@ export const MagicContextConfigSchema = z
                         "When true, dreamer skips smart notes whose surface conditions compiled to retina provider configs at authoring time. Default false keeps both paths active until the retina consumer is deployed.",
                     ),
             })
-            .default({ retina_handoff: false })
+            .default({ enabled: true, retina_handoff: false })
             .describe("Smart-note ownership transition controls."),
         cache_ttl: z
             .union([z.string(), z.object({ default: z.string() }).catchall(z.string())])
@@ -1263,10 +1271,21 @@ export const MagicContextConfigSchema = z
             )
             .meta({ deprecated: true }),
         clear_reasoning_age: z
-            .number()
-            .min(10)
-            .default(50)
-            .describe("Clear reasoning/thinking blocks older than N tags (default: 50)"),
+            .unknown()
+            .optional()
+            .describe("Deprecated and ignored. Use keep_reasoning_tokens instead.")
+            .meta({ deprecated: true }),
+        keep_reasoning_tokens: z
+            .union([
+                z.number().int().min(0).max(1_000_000),
+                z
+                    .object({ default: z.number().int().min(0).max(1_000_000).optional() })
+                    .catchall(z.number().int().min(0).max(1_000_000)),
+            ])
+            .optional()
+            .describe(
+                "Reasoning tokens to keep on rebuilding passes. Number or per-model object; exact, shorter model keys, provider/*, then default. Omitted: fixed 10,000. 0 removes all eligible historical reasoning; newest and exempt steps always stay.",
+            ),
         history_budget_percentage: z
             .number()
             .min(0.05)
@@ -1589,7 +1608,6 @@ export const MagicContextConfigSchema = z
 /** Settings whose fresh values can be used by later agent runs without changing rendered prompt bytes. */
 export const LIVE_RELOAD_CONFIG_PATHS = [
     "cache_ttl",
-    "mural.model",
     "toast_duration_ms",
     "historian.opencode.model",
     "historian.opencode.fallback_models",

package/src/features/magic-context/dreamer/task-registry.ts

@@ -29,6 +29,12 @@ export const CANONICAL_DREAM_TASKS = [
 
 export type DreamTaskName = (typeof CANONICAL_DREAM_TASKS)[number];
 
+export function availableDreamTasks(smartNotesEnabled = true): DreamTaskName[] {
+    return CANONICAL_DREAM_TASKS.filter(
+        (task) => smartNotesEnabled || task !== "evaluate-smart-notes",
+    );
+}
+
 /** Prompt-token ceilings informed by docs/reports/dreamer-token-usage.md.
  * Completed Gemini run usage predicts 20-memory mapping/verification batches
  * at about 70% of their allowance

package/src/shared/auto-search-lifecycle.ts

@@ -0,0 +1,27 @@
+const pending = new Map<string, Set<AbortController>>();
+
+/** Cleanup cancels optional searches and backfill, not durable served decisions. */
+export function registerAutoSearchWork(sessionId: string): {
+    signal: AbortSignal;
+    done: () => void;
+} {
+    const controller = new AbortController();
+    const work = pending.get(sessionId) ?? new Set<AbortController>();
+    pending.set(sessionId, work);
+    work.add(controller);
+    return {
+        signal: controller.signal,
+        done: () => {
+            work.delete(controller);
+            if (pending.get(sessionId) === work && work.size === 0) pending.delete(sessionId);
+        },
+    };
+}
+
+export function cancelAutoSearchWork(sessionId?: string): void {
+    for (const [id, work] of pending) {
+        if (sessionId !== undefined && id !== sessionId) continue;
+        pending.delete(id);
+        for (const controller of work) controller.abort();
+    }
+}

package/src/shared/conflict-detector.test.ts

@@ -37,11 +37,13 @@ describe("detectConflicts", () => {
             OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
             XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
             OPENCODE_DISABLE_AUTOCOMPACT: process.env.OPENCODE_DISABLE_AUTOCOMPACT,
+            OPENCODE_DISABLE_PROJECT_CONFIG: process.env.OPENCODE_DISABLE_PROJECT_CONFIG,
             HOME: process.env.HOME,
         };
         process.env.OPENCODE_CONFIG_DIR = userConfigDir;
         process.env.HOME = homeDir;
         delete process.env.XDG_CONFIG_HOME;
+        delete process.env.OPENCODE_DISABLE_PROJECT_CONFIG;
         // Disable auto-compaction default during tests so we isolate plugin
         // detection from compaction detection.
         process.env.OPENCODE_DISABLE_AUTOCOMPACT = "1";
@@ -734,6 +736,60 @@ describe("detectConflicts", () => {
             expect(result.conflicts.compactionAuto).toBe(false);
         });
 
+        it("v1 boot fallback ignores project compaction when project config is disabled", async () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false, prune: false });
+            writeCompaction(projectDir, "opencode.json", { auto: true, prune: true });
+            writeCompaction(join(projectDir, ".opencode"), "opencode.jsonc", {
+                auto: true,
+                prune: true,
+            });
+            const resolvedCompaction = await resolveCompactionForBoot(
+                {
+                    config: { get: () => new Promise<never>(() => {}) },
+                },
+                20,
+            );
+            expect(resolvedCompaction).toBeNull();
+
+            for (const value of ["true", "1", "TRUE"]) {
+                process.env.OPENCODE_DISABLE_PROJECT_CONFIG = value;
+                const result = detectConflicts(projectDir, {
+                    compactionEnabled: true,
+                    hostGeneration: "v1",
+                    resolvedCompaction,
+                });
+                expect(result.nativeCompaction).toEqual({ auto: false, prune: false });
+                expect(result.hasConflict).toBe(false);
+            }
+        });
+
+        it("v1 still reads project compaction when the project-disable flag is false", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(projectDir, "opencode.jsonc", { auto: true });
+            for (const value of ["false", "0", ""]) {
+                process.env.OPENCODE_DISABLE_PROJECT_CONFIG = value;
+                const result = detectConflicts(projectDir, { compactionEnabled: true });
+                expect(result.nativeCompaction.auto).toBe(true);
+                expect(result.conflicts.compactionAuto).toBe(true);
+            }
+        });
+
+        it("v1 project-disable flag preserves explicit and user compaction layers", () => {
+            process.env.OPENCODE_DISABLE_PROJECT_CONFIG = "true";
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            const explicit = join(root, "explicit-opencode.json");
+            writeFileSync(explicit, JSON.stringify({ compaction: { auto: true } }));
+            process.env.OPENCODE_CONFIG = explicit;
+            expect(detectConflicts(projectDir).conflicts.compactionAuto).toBe(true);
+
+            delete process.env.OPENCODE_CONFIG;
+            writeCompaction(join(homeDir, ".opencode"), "opencode.json", { auto: true });
+            expect(detectConflicts(projectDir).conflicts.compactionAuto).toBe(true);
+
+            writeCompaction(launcherDir, "opencode.json", { auto: false });
+            expect(detectConflicts(projectDir).conflicts.compactionAuto).toBe(false);
+        });
+
         it("v2 ranks the project .opencode overlay above global supplementary config", () => {
             writeCompaction(launcherDir, "opencode.json", { auto: false });
             writeCompaction(join(projectDir, ".opencode"), "opencode.json", { auto: true });

package/src/shared/conflict-detector.ts

@@ -414,11 +414,22 @@ function openCodeConfigFileChain(
         .flatMap((dir) => [join(dir, "opencode.json"), join(dir, "opencode.jsonc")]);
     const explicitConfig = process.env.OPENCODE_CONFIG?.trim();
     const explicit = explicitConfig ? [explicitConfig] : [];
-    const direct = [join(directory, "opencode.json"), join(directory, "opencode.jsonc")];
-    const projectSupplementary = [
-        join(directory, ".opencode", "opencode.json"),
-        join(directory, ".opencode", "opencode.jsonc"),
-    ];
+    // OpenCode 1 can ignore project opencode.json/jsonc and .opencode configs.
+    // If config.get() times out during bootstrap, compaction detection falls
+    // back here and must not read settings from those host-disabled files.
+    const disableProjectConfig = process.env.OPENCODE_DISABLE_PROJECT_CONFIG?.toLowerCase();
+    const skipProject =
+        hostGeneration === "v1" &&
+        (disableProjectConfig === "true" || disableProjectConfig === "1");
+    const direct = skipProject
+        ? []
+        : [join(directory, "opencode.json"), join(directory, "opencode.jsonc")];
+    const projectSupplementary = skipProject
+        ? []
+        : [
+              join(directory, ".opencode", "opencode.json"),
+              join(directory, ".opencode", "opencode.jsonc"),
+          ];
 
     const files =
         hostGeneration === "v2"

package/src/shared/historian-tool-defaults.json

@@ -3,11 +3,11 @@
   "ctx_memory": "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}",
   "todowrite": "Todos (${input.todos.count}): ${input.todos.each(\"${status}: ${content}\")}",
   "question": "Asked user: ${input.questions[*].question.join(\" / \")} → ${output}",
-  "task": "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
-  "ask": "Asked: ${input.question.truncate(250)} [options: ${input.options.join(\" / \")}] ${input.resolution} → ${output.truncate(300)}",
-  "peer_send": "PM to ${input.agent}${input.agent_id}: ${input.message.truncate(400)}",
-  "board": "Board ${input.verb}: ${input.ops.each(\"${op} ${item}${lane.title} ${state}${lane.status}${props.text} ${lane.items[*].text}\")}",
-  "room": "Room ${input.action} ${input.room_id}: ${input.text.truncate(400)}",
-  "work": "Work ${input.action} ${input.id}: ${input.prompt_file}${input.prompt.truncate(200)}${input.notes.truncate(200)} → ${output.truncate(160)}",
+  "task": "Task ${input.subagent_type}: ${input.prompt.truncate(600)} → ${output.truncate(200)}",
+  "ask": "Asked: ${input.question} [options: ${input.options.join(\" / \")}] ${input.text}${input.resolution} → ${output.truncate(300)}",
+  "peer_send": "PM ${input.recipient}: ${input.message}",
+  "board": "Board ${input.verb}${input.board_lane}: ${input.ops.each(\"${op} ${lane_label} ${item}${props.text}${lane.items} ${state}${props.state}${lane.status}${id}${title}\")}",
+  "room": "Room ${input.action} ${input.room_label}: ${input.room_detail}",
+  "work": "Work ${input.action} ${input.title}${input.id}: ${input.prompt.truncate(600)}${input.notes.truncate(600)} → ${output.truncate(160)}",
   "knowhow": "Looked up how-to: ${input.query}${input.id}"
 }

package/src/shared/historian-tool-expansions.ts

@@ -1,18 +1,75 @@
 import defaults from "./historian-tool-defaults.json";
+import previewDefaults from "./historian-tool-preview-defaults.json";
 import { renderToolTemplate, type ToolExpansionMap } from "./historian-tool-template";
 
 export { defaults as DEFAULT_TOOL_EXPANSIONS };
-export function expandToolPart(part: unknown, overrides?: ToolExpansionMap): string | null {
+
+// Room actions, private-message addresses and board lanes have multiple input
+// shapes. Derive readable labels only for built-ins; configured template overrides
+// keep the unmodified tool input.
+function builtinInput(tool: string, input: unknown): unknown {
+    if (!input || typeof input !== "object") return input;
+    const i = input as Record<string, unknown>;
+    if (tool === "peer_send") {
+        const external = i.external as Record<string, unknown> | undefined;
+        const recipient = i.reply_to_pmid
+            ? `reply to ${i.reply_to_pmid}`
+            : i.agent || i.agent_id
+              ? `to ${i.agent || i.agent_id}`
+              : external?.session_id || i.session_id
+                ? `to session ${external?.session_id || i.session_id}`
+                : "to unknown recipient";
+        return { ...i, recipient };
+    }
+    if (tool === "room") {
+        return {
+            ...i,
+            room_label: i.room_id || i.title,
+            room_detail:
+                i.action === "create" || i.action === "invite"
+                    ? `invitees: ${renderToolTemplate("${input.invitees}", i)}`
+                    : i.text,
+        };
+    }
+    if (tool === "board") {
+        return {
+            ...i,
+            board_lane: i.lane ? ` ${i.lane}` : "",
+            ops: Array.isArray(i.ops)
+                ? i.ops.map((op) =>
+                      op && typeof op === "object"
+                          ? {
+                                ...op,
+                                lane_label:
+                                    typeof op.lane === "string"
+                                        ? op.lane
+                                        : op.lane?.title || op.lane?.id,
+                            }
+                          : op,
+                  )
+                : i.ops,
+        };
+    }
+    return input;
+}
+
+export function expandToolPart(
+    part: unknown,
+    overrides?: ToolExpansionMap,
+    legacyPreview = false,
+): string | null {
     if (!part || typeof part !== "object") return null;
     const p = part as Record<string, unknown>;
     if (p.type !== "tool" || typeof p.tool !== "string") return null;
-    const template =
-        overrides && Object.hasOwn(overrides, p.tool)
-            ? overrides[p.tool]
-            : Object.hasOwn(defaults, p.tool)
-              ? defaults[p.tool as keyof typeof defaults]
-              : undefined;
+    const builtinDefaults = legacyPreview ? previewDefaults : defaults;
+    const overridden = overrides && Object.hasOwn(overrides, p.tool);
+    const template = overridden
+        ? overrides[p.tool]
+        : Object.hasOwn(builtinDefaults, p.tool)
+          ? builtinDefaults[p.tool as keyof typeof defaults]
+          : undefined;
     if (typeof template !== "string") return null;
     const state = p.state as Record<string, unknown> | undefined;
-    return renderToolTemplate(template, state?.input, state?.output ?? state?.error);
+    const input = overridden || legacyPreview ? state?.input : builtinInput(p.tool, state?.input);
+    return renderToolTemplate(template, input, state?.output ?? state?.error, legacyPreview);
 }

package/src/shared/historian-tool-preview-defaults.json

@@ -0,0 +1,13 @@
+{
+  "ctx_note": "Note ${input.action} ${input.note_ids}: ${input.content} → ${output.truncate(160)}",
+  "ctx_memory": "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}",
+  "todowrite": "Todos (${input.todos.count}): ${input.todos.each(\"${status}: ${content}\")}",
+  "question": "Asked user: ${input.questions[*].question.join(\" / \")} → ${output}",
+  "task": "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
+  "ask": "Asked: ${input.question.truncate(250)} [options: ${input.options.join(\" / \")}] ${input.resolution} → ${output.truncate(300)}",
+  "peer_send": "PM to ${input.agent}${input.agent_id}: ${input.message.truncate(400)}",
+  "board": "Board ${input.verb}: ${input.ops.each(\"${op} ${item}${lane.title} ${state}${lane.status}${props.text} ${lane.items[*].text}\")}",
+  "room": "Room ${input.action} ${input.room_id}: ${input.text.truncate(400)}",
+  "work": "Work ${input.action} ${input.id}: ${input.prompt_file}${input.prompt.truncate(200)}${input.notes.truncate(200)} → ${output.truncate(160)}",
+  "knowhow": "Looked up how-to: ${input.query}${input.id}"
+}

package/src/shared/historian-tool-template.ts

@@ -1,4 +1,4 @@
-/** A deliberately non-executable language for readable, bounded historian tool lines. */
+/** A deliberately non-executable language for readable historian tool lines. */
 export type ToolExpansionMap = Record<string, string | false>;
 type Step = { field: string } | { index: number } | { project: string };
 type Expression = {
@@ -6,7 +6,7 @@ type Expression = {
     each?: Template;
     join?: string;
     count?: boolean;
-    cap: number;
+    cap?: number;
 };
 type Template = Array<string | Expression>;
 
@@ -78,7 +78,7 @@ class Parser {
                 if (this.source[this.pos] === "(") return this.error();
             } else break;
         }
-        const expression: Expression = { steps, cap: 300 };
+        const expression: Expression = { steps };
         if (this.take(".each(")) {
             if (relative) return this.error();
             expression.each = parseTemplate(this.quoted(), true);
@@ -145,9 +145,24 @@ function compiled(source: string): Template | null {
 function oneLine(value: string): string {
     return value.replace(/[\r\n\u2028\u2029]+/g, " ");
 }
-function truncate(value: string, cap: number): string {
+function truncate(value: string, cap?: number, legacyPreview = false): string {
     const chars = Array.from(oneLine(value));
-    return chars.length > cap ? `${chars.slice(0, cap).join("")}…` : chars.join("");
+    if (cap === undefined || chars.length <= cap) return chars.join("");
+    if (legacyPreview) return `${chars.slice(0, cap).join("")}…`;
+    // Explicit caps stop after sentence-ending punctuation so a cut is not
+    // mistaken for an intact tool message. If no sentence fits, show only the marker.
+    let end = 0;
+    for (let i = 0; i < Math.min(cap, chars.length); i++) {
+        if (!".!?。！？".includes(chars[i])) continue;
+        let next = i + 1;
+        while (next < chars.length && "\"'”’)]".includes(chars[next])) next++;
+        if (
+            next <= cap &&
+            ("。！？".includes(chars[i]) || next === chars.length || /[ \t]/.test(chars[next]))
+        )
+            end = next;
+    }
+    return `${end ? `${chars.slice(0, end).join("")} ` : ""}[… ${chars.length - end} more characters]`;
 }
 function scalar(value: unknown): string {
     if (value === undefined) return "";
@@ -174,10 +189,11 @@ function field(value: unknown, key: string): unknown {
         ? (value as Record<string, unknown>)[key]
         : undefined;
 }
-function render(nodes: Template, root: unknown): string {
+function render(nodes: Template, root: unknown, legacyPreview: boolean): string {
     return nodes
         .map((node) => {
             if (typeof node === "string") return node;
+            const cap = node.cap ?? (legacyPreview ? 300 : undefined);
             let value = root;
             let list = false;
             for (const step of node.steps) {
@@ -196,18 +212,31 @@ function render(nodes: Template, root: unknown): string {
                 }
             }
             if (node.count)
-                return truncate(Array.isArray(value) ? String(value.length) : "", node.cap);
+                return truncate(
+                    Array.isArray(value) ? String(value.length) : "",
+                    cap,
+                    legacyPreview,
+                );
             if (node.each || list || node.join !== undefined) {
                 if (!Array.isArray(value)) return "";
                 const elements = value
-                    .slice(0, 10)
+                    .slice(0, legacyPreview ? 10 : undefined)
                     .map((item) =>
-                        truncate(node.each ? render(node.each, item) : scalar(item), 300),
+                        truncate(
+                            node.each ? render(node.each, item, legacyPreview) : scalar(item),
+                            legacyPreview ? 300 : undefined,
+                            legacyPreview,
+                        ),
                     );
-                if (value.length > 10) elements.push(`… +${value.length - 10} more`);
-                return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), node.cap);
+                if (legacyPreview && value.length > 10)
+                    elements.push(`… +${value.length - 10} more`);
+                return truncate(
+                    elements.join(node.join ?? (node.each ? "; " : ", ")),
+                    cap,
+                    legacyPreview,
+                );
             }
-            return truncate(scalar(value), node.cap);
+            return truncate(scalar(value), cap, legacyPreview);
         })
         .join("");
 }
@@ -216,6 +245,7 @@ export function renderToolTemplate(
     source: string,
     input: unknown,
     output?: unknown,
+    legacyPreview = false,
 ): string | null {
     const nodes = compiled(source);
     if (!nodes) return null;
@@ -241,8 +271,12 @@ export function renderToolTemplate(
         !node.each &&
         !node.count &&
         node.join === undefined
-            ? truncate(text ?? "", node.cap)
+            ? truncate(text ?? "", node.cap ?? (legacyPreview ? 300 : undefined), legacyPreview)
             : node,
     );
-    return truncate(render(bareOutputNodes, root), 1000);
+    return truncate(
+        render(bareOutputNodes, root, legacyPreview),
+        legacyPreview ? 1000 : undefined,
+        legacyPreview,
+    );
 }