@cortexkit/opencode-magic-context 0.21.8 → 0.22.1

package/src/shared/tag-transcript.test.ts

@@ -0,0 +1,280 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import type { ContextDatabase } from "../features/magic-context/storage";
+import type { Tagger } from "../features/magic-context/tagger";
+import { tagTranscript } from "./tag-transcript";
+import type { Transcript, TranscriptPart, TranscriptPartKind } from "./transcript";
+
+class FakeTagger implements Tagger {
+    private nextTag = 1;
+    private toolTags = new Map<string, number>();
+    readonly owners: string[] = [];
+    readonly byteSizes = new Map<number, number>();
+
+    assignTag(): number {
+        return this.nextTag++;
+    }
+
+    getTag(): number | undefined {
+        return undefined;
+    }
+
+    assignToolTag(
+        _sessionId: string,
+        callId: string,
+        ownerMsgId: string,
+        byteSize: number,
+    ): number {
+        const key = `${ownerMsgId}\0${callId}`;
+        const existing = this.toolTags.get(key);
+        if (existing !== undefined) return existing;
+        const tag = this.nextTag++;
+        this.toolTags.set(key, tag);
+        this.byteSizes.set(tag, byteSize);
+        this.owners.push(ownerMsgId);
+        return tag;
+    }
+
+    getToolTag(_sessionId: string, callId: string, ownerMsgId: string): number | undefined {
+        return this.toolTags.get(`${ownerMsgId}\0${callId}`);
+    }
+
+    bindTag(): void {}
+
+    bindToolTag(_sessionId: string, callId: string, ownerMsgId: string, tagNumber: number): void {
+        this.toolTags.set(`${ownerMsgId}\0${callId}`, tagNumber);
+    }
+
+    getAssignments(): ReadonlyMap<string, number> {
+        return this.toolTags;
+    }
+
+    resetCounter(): void {
+        this.nextTag = 1;
+    }
+
+    getCounter(): number {
+        return this.nextTag - 1;
+    }
+
+    initFromDb(): void {}
+
+    cleanup(): void {}
+}
+
+class TestPart implements TranscriptPart {
+    constructor(
+        readonly kind: TranscriptPartKind,
+        readonly id: string | undefined,
+        private text: string,
+        private readonly toolName = "read",
+    ) {}
+
+    getText(): string | undefined {
+        return this.text;
+    }
+
+    setText(newText: string): boolean {
+        if (this.text === newText) return false;
+        this.text = newText;
+        return true;
+    }
+
+    setToolOutput(newText: string): boolean {
+        return this.setText(newText);
+    }
+
+    getToolMetadata(): { toolName: string | undefined; inputByteSize: number } {
+        return {
+            toolName: this.toolName,
+            inputByteSize: this.kind === "tool_use" ? this.text.length : 0,
+        };
+    }
+
+    replaceWithSentinel(sentinelText: string): boolean {
+        return this.setText(sentinelText);
+    }
+}
+
+class ThrowingToolOutputPart extends TestPart {
+    setToolOutput(): boolean {
+        throw new Error("setToolOutput on assistant part");
+    }
+}
+
+class NonTextToolResultPart extends TestPart {
+    constructor(
+        id: string,
+        readonly content: unknown,
+    ) {
+        super("tool_result", id, "");
+    }
+
+    getText(): string | undefined {
+        return undefined;
+    }
+
+    setText(): boolean {
+        return false;
+    }
+}
+
+class FakeDb {
+    readonly byteSizeUpdates: Array<{ byteSize: number; sessionId: string; tagNumber: number }> =
+        [];
+
+    prepare(sql: string): { run: (...args: unknown[]) => void } {
+        return {
+            run: (...args: unknown[]) => {
+                if (!sql.startsWith("UPDATE tags SET byte_size =")) return;
+                const [byteSize, sessionId, tagNumber] = args;
+                if (
+                    typeof byteSize === "number" &&
+                    typeof sessionId === "string" &&
+                    typeof tagNumber === "number"
+                ) {
+                    this.byteSizeUpdates.push({ byteSize, sessionId, tagNumber });
+                }
+            },
+        };
+    }
+}
+
+describe("tagTranscript tool aggregation", () => {
+    it("keeps repeated callIds in separate owner-scoped aggregate targets", () => {
+        const tagger = new FakeTagger();
+        const firstUse = new TestPart("tool_use", "read:32", '{"file":"long-a"}');
+        const firstResult = new TestPart("tool_result", "read:32", "r1");
+        const secondUse = new TestPart("tool_use", "read:32", '{"file":"long-b"}');
+        const secondResult = new TestPart("tool_result", "read:32", "r2");
+        const transcript: Transcript = {
+            harness: "pi",
+            messages: [
+                { info: { id: "assistant-1", role: "assistant" }, parts: [firstUse] },
+                { info: { id: "user-1", role: "user" }, parts: [firstResult] },
+                { info: { id: "assistant-2", role: "assistant" }, parts: [secondUse] },
+                { info: { id: "user-2", role: "user" }, parts: [secondResult] },
+            ],
+            commit() {},
+        };
+
+        const { targets } = tagTranscript("session-1", transcript, tagger, {} as ContextDatabase);
+
+        const firstTag = tagger.getToolTag("session-1", "read:32", "assistant-1");
+        const secondTag = tagger.getToolTag("session-1", "read:32", "assistant-2");
+        expect(firstTag).toBeDefined();
+        expect(secondTag).toBeDefined();
+        expect(firstTag).not.toBe(secondTag);
+        expect(tagger.owners).toEqual(["assistant-1", "assistant-2"]);
+        expect(targets.size).toBe(2);
+
+        expect(targets.get(firstTag ?? -1)?.drop()).toBe("removed");
+        expect(firstUse.getText()).toBe(`[dropped §${firstTag}§]`);
+        expect(firstResult.getText()).toBe(`[dropped §${firstTag}§]`);
+        expect(secondUse.getText()).toBe('{"file":"long-b"}');
+        expect(secondResult.getText()).toContain("r2");
+    });
+
+    it("truncates assistant tool_use parts via text fallback when setToolOutput asserts", () => {
+        const tagger = new FakeTagger();
+        const toolUse = new ThrowingToolOutputPart("tool_use", "read:99", '{"file":"long-a"}');
+        const transcript: Transcript = {
+            harness: "pi",
+            messages: [{ info: { id: "assistant-1", role: "assistant" }, parts: [toolUse] }],
+            commit() {},
+        };
+
+        const { targets } = tagTranscript("session-1", transcript, tagger, {} as ContextDatabase);
+        const tag = tagger.getToolTag("session-1", "read:99", "assistant-1");
+
+        let result: "truncated" | "absent" | undefined;
+        expect(() => {
+            result = targets.get(tag ?? -1)?.truncate?.();
+        }).not.toThrow();
+        expect(result).toBe("truncated");
+        expect(toolUse.getText()).toBe("[truncated]");
+    });
+
+    it("drops every contiguous folded tool_result block for the paired callId", () => {
+        const tagger = new FakeTagger();
+        const toolUse = new TestPart("tool_use", "read:multi", '{"file":"long-a"}');
+        const firstResult = new TestPart("tool_result", "read:multi", "r1");
+        const secondResult = new TestPart("tool_result", "read:multi", "r2");
+        const transcript: Transcript = {
+            harness: "pi",
+            messages: [
+                { info: { id: "assistant-1", role: "assistant" }, parts: [toolUse] },
+                { info: { id: "user-1", role: "user" }, parts: [firstResult, secondResult] },
+            ],
+            commit() {},
+        };
+
+        const { targets } = tagTranscript("session-1", transcript, tagger, {} as ContextDatabase);
+        const tag = tagger.getToolTag("session-1", "read:multi", "assistant-1");
+
+        expect(targets.size).toBe(1);
+        expect(targets.get(tag ?? -1)?.drop()).toBe("removed");
+        expect(toolUse.getText()).toBe(`[dropped §${tag}§]`);
+        expect(firstResult.getText()).toBe(`[dropped §${tag}§]`);
+        expect(secondResult.getText()).toBe(`[dropped §${tag}§]`);
+    });
+
+    it("pairs a reused callId result with the nearest previous unresolved owner", () => {
+        const tagger = new FakeTagger();
+        const olderUse = new TestPart("tool_use", "read:reused", '{"file":"older"}');
+        const nearestUse = new TestPart("tool_use", "read:reused", '{"file":"nearest"}');
+        const result = new TestPart("tool_result", "read:reused", "nearest result");
+        const transcript: Transcript = {
+            harness: "pi",
+            messages: [
+                { info: { id: "assistant-old", role: "assistant" }, parts: [olderUse] },
+                { info: { id: "assistant-near", role: "assistant" }, parts: [nearestUse] },
+                { info: { id: "user-result", role: "user" }, parts: [result] },
+            ],
+            commit() {},
+        };
+
+        const { targets } = tagTranscript("session-1", transcript, tagger, {} as ContextDatabase);
+
+        const olderTag = tagger.getToolTag("session-1", "read:reused", "assistant-old");
+        const nearestTag = tagger.getToolTag("session-1", "read:reused", "assistant-near");
+        expect(olderTag).toBeDefined();
+        expect(nearestTag).toBeDefined();
+        expect(olderTag).not.toBe(nearestTag);
+
+        expect(targets.get(nearestTag ?? -1)?.drop()).toBe("removed");
+        expect(olderUse.getText()).toBe('{"file":"older"}');
+        expect(nearestUse.getText()).toBe(`[dropped §${nearestTag}§]`);
+        expect(result.getText()).toBe(`[dropped §${nearestTag}§]`);
+    });
+
+    it("accounts non-text tool_result content when ranking tool output byte size", () => {
+        const tagger = new FakeTagger();
+        const db = new FakeDb();
+        const toolUse = new TestPart("tool_use", "read:image", "{}");
+        const caption = new TestPart("tool_result", "read:image", "c");
+        const image = new NonTextToolResultPart("read:image", {
+            type: "image",
+            data: "x".repeat(512),
+            mediaType: "image/png",
+        });
+        const transcript: Transcript = {
+            harness: "pi",
+            messages: [
+                { info: { id: "assistant-1", role: "assistant" }, parts: [toolUse] },
+                { info: { id: "user-1", role: "user" }, parts: [caption, image] },
+            ],
+            commit() {},
+        };
+
+        tagTranscript("session-1", transcript, tagger, db as unknown as ContextDatabase);
+
+        const tag = tagger.getToolTag("session-1", "read:image", "assistant-1");
+        expect(tag).toBeDefined();
+        expect(tagger.byteSizes.get(tag ?? -1)).toBe(2);
+        expect(db.byteSizeUpdates).toHaveLength(1);
+        expect(db.byteSizeUpdates[0]?.tagNumber).toBe(tag);
+        expect(db.byteSizeUpdates[0]?.byteSize).toBeGreaterThan(512);
+    });
+});

package/src/shared/tag-transcript.ts

@@ -48,7 +48,7 @@
 import type { ContextDatabase } from "../features/magic-context/storage";
 import { saveSourceContent } from "../features/magic-context/storage-source";
 import { updateTagByteSize, updateTagInputByteSize } from "../features/magic-context/storage-tags";
-import type { Tagger } from "../features/magic-context/tagger";
+import { makeToolCompositeKey, type Tagger } from "../features/magic-context/tagger";
 import {
     byteSize,
     prependTag,
@@ -67,6 +67,15 @@ export interface TagTranscriptOptions {
      * consistent across passes.
      */
     skipPrefixInjection?: boolean;
+    /**
+     * Pi-only: map of messageId → raw-message fingerprint. When a NEW message
+     * text tag is created, its fingerprint is persisted on the tag row so a
+     * later pass can adopt the fallback-id tag onto the real SessionEntry id
+     * (keeping tag_number/§N§ stable). OpenCode omits this → tags store NULL
+     * → adoption never fires. Keyed by the bare messageId (not the `:pN`
+     * contentId) since all parts of a message share one fingerprint.
+     */
+    entryFingerprintByMessageId?: ReadonlyMap<string, string>;
 }
 
 export interface TagTranscriptResult {
@@ -138,13 +147,13 @@ export function tagTranscript(
     const skipPrefixInjection = options.skipPrefixInjection === true;
     const targets = new Map<number, TagTarget>();
 
-    // Per-callId tool aggregation tracked across the single walk. Tags
-    // get allocated in transcript order (first occurrence reserves the
-    // tag number); subsequent occurrences reuse the same tag and merge
-    // their occurrence into the aggregate's TagTarget. This preserves
-    // chronological tag numbering while still aggregating drop behavior
-    // across both invocation and result.
+    // Tool aggregation is keyed by the same owner+callId identity used by
+    // assignToolTag. OpenCode/Pi callId counters can repeat across turns, so
+    // a bare callId key can merge distinct invocations and replay drops/status
+    // changes against the wrong tool pair.
     const toolAggregates = new Map<string, ToolAggregate & { tagId: number }>();
+    const openToolAggregateKeysByCallId = new Map<string, string[]>();
+    let activeToolResultRun: { callId: string; aggregateKey: string } | undefined;
 
     // v3.3.1 Layer C (plan v3.3.1 Finding #16): the previous outer
     // db.transaction() wrapper rolled back EVERY tag insert + savedSource
@@ -156,6 +165,7 @@ export function tagTranscript(
     for (let msgIndex = 0; msgIndex < transcript.messages.length; msgIndex += 1) {
         const message = transcript.messages[msgIndex];
         if (message === undefined) continue;
+        activeToolResultRun = undefined;
         const messageId = message.info.id;
 
         let textOrdinal = 0;
@@ -165,6 +175,10 @@ export function tagTranscript(
             const part = parts[partIndex];
             if (part === undefined) continue;
 
+            if (part.kind !== "tool_result") {
+                activeToolResultRun = undefined;
+            }
+
             if (part.kind === "text") {
                 // Synthetic message ids (Pi tail synthetic user with
                 // no id) cannot be tagged — there's no stable handle
@@ -186,19 +200,25 @@ export function tagTranscript(
                     db,
                     targets,
                     skipPrefixInjection,
+                    entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null,
                 });
                 textOrdinal += 1;
                 continue;
             }
 
             if (part.kind === "tool_use" || part.kind === "tool_result") {
-                if (messageId === undefined) continue;
+                if (messageId === undefined) {
+                    activeToolResultRun = undefined;
+                    continue;
+                }
 
                 const callId = part.id;
                 const text = part.getText() ?? "";
+                const toolByteSize = getToolPartByteSize(part, text);
                 const meta = part.getToolMetadata();
 
                 if (typeof callId !== "string" || callId.length === 0) {
+                    activeToolResultRun = undefined;
                     // No stable callId to aggregate on. Tag independently.
                     tagToolPart({
                         sessionId,
@@ -215,21 +235,35 @@ export function tagTranscript(
                     continue;
                 }
 
-                const existing = toolAggregates.get(callId);
+                const pendingKeys = openToolAggregateKeysByCallId.get(callId) ?? [];
+                let existingKey: string | undefined;
+                if (part.kind === "tool_result") {
+                    if (
+                        activeToolResultRun !== undefined &&
+                        activeToolResultRun.callId === callId
+                    ) {
+                        existingKey = activeToolResultRun.aggregateKey;
+                    } else {
+                        existingKey = findLastUnresolvedToolAggregateKey(
+                            pendingKeys,
+                            toolAggregates,
+                        );
+                    }
+                }
+                const aggregateKey: string = existingKey ?? makeToolCompositeKey(messageId, callId);
+                const existing = toolAggregates.get(aggregateKey);
                 if (existing) {
-                    // Second (or later) occurrence for this call_id.
-                    // Merge into the existing aggregate, update byte_size
-                    // in DB if larger, and rebuild the TagTarget so the
-                    // closures over `occurrences` see all parts.
+                    // Later occurrence for this owner+callId pair. Merge into the
+                    // aggregate, update byte accounting if larger, and rebuild the
+                    // TagTarget so drops mutate both invocation and result.
                     existing.occurrences.push({
                         message,
                         part,
                         kind: part.kind,
                     });
-                    const newByteSize = byteSize(text);
-                    if (newByteSize > existing.maxByteSize) {
-                        existing.maxByteSize = newByteSize;
-                        updateTagByteSize(db, sessionId, existing.tagId, newByteSize);
+                    if (toolByteSize > existing.maxByteSize) {
+                        existing.maxByteSize = toolByteSize;
+                        updateTagByteSize(db, sessionId, existing.tagId, toolByteSize);
                     }
                     if (existing.toolName === null && meta.toolName) {
                         existing.toolName = meta.toolName;
@@ -253,18 +287,23 @@ export function tagTranscript(
                         existing.tagId,
                         buildAggregateTarget(existing.tagId, existing.occurrences),
                     );
+                    if (part.kind === "tool_result") {
+                        markToolAggregateResolved(
+                            callId,
+                            aggregateKey,
+                            openToolAggregateKeysByCallId,
+                        );
+                        activeToolResultRun = { callId, aggregateKey };
+                    }
                 } else {
-                    // First occurrence — reserve the tag number.
-                    // v3.3.1 Layer C: Pi main aggregation path. Owner
-                    // is the Pi message hosting the tool aggregate.
-                    // Owner stays stable across passes because Pi
-                    // re-emits the full transcript each time and
-                    // message ids are durable.
+                    // First occurrence for this owner+callId identity — reserve
+                    // the tag number. Owner stays stable across passes because
+                    // transcript message ids are durable.
                     const tagId = tagger.assignToolTag(
                         sessionId,
                         callId,
                         messageId,
-                        byteSize(text),
+                        toolByteSize,
                         db,
                         0,
                         meta.toolName ?? null,
@@ -280,11 +319,14 @@ export function tagTranscript(
                                 kind: part.kind,
                             },
                         ],
-                        maxByteSize: byteSize(text),
+                        maxByteSize: toolByteSize,
                         toolName: meta.toolName ?? null,
                         inputByteSize: part.kind === "tool_use" ? meta.inputByteSize : 0,
                     };
-                    toolAggregates.set(callId, aggregate);
+                    toolAggregates.set(aggregateKey, aggregate);
+                    if (part.kind === "tool_use") {
+                        openToolAggregateKeysByCallId.set(callId, [...pendingKeys, aggregateKey]);
+                    }
                     // Inject §N§ prefix into this occurrence's visible text
                     // when it's a tool_result. (OpenCode parity: prefix
                     // only goes on the result, not the invocation.)
@@ -292,6 +334,14 @@ export function tagTranscript(
                         part.setText(prependTag(tagId, text));
                     }
                     targets.set(tagId, buildAggregateTarget(tagId, aggregate.occurrences));
+                    if (part.kind === "tool_result") {
+                        markToolAggregateResolved(
+                            callId,
+                            aggregateKey,
+                            openToolAggregateKeysByCallId,
+                        );
+                        activeToolResultRun = { callId, aggregateKey };
+                    }
                 }
             }
             // thinking, image, file, structural, unknown → skip.
@@ -301,6 +351,69 @@ export function tagTranscript(
     return { targets };
 }
 
+function findLastUnresolvedToolAggregateKey(
+    pendingKeys: string[],
+    toolAggregates: Map<string, ToolAggregate & { tagId: number }>,
+): string | undefined {
+    for (let i = pendingKeys.length - 1; i >= 0; i -= 1) {
+        const key = pendingKeys[i];
+        if (key === undefined) continue;
+        const aggregate = toolAggregates.get(key);
+        if (aggregate === undefined) continue;
+        if (!aggregate.occurrences.some((occ) => occ.kind === "tool_result")) {
+            return key;
+        }
+    }
+    return undefined;
+}
+
+function markToolAggregateResolved(
+    callId: string,
+    aggregateKey: string,
+    openToolAggregateKeysByCallId: Map<string, string[]>,
+): void {
+    const pendingKeys = openToolAggregateKeysByCallId.get(callId);
+    if (pendingKeys === undefined) return;
+    const nextPendingKeys = pendingKeys.filter((key) => key !== aggregateKey);
+    if (nextPendingKeys.length === 0) {
+        openToolAggregateKeysByCallId.delete(callId);
+        return;
+    }
+    openToolAggregateKeysByCallId.set(callId, nextPendingKeys);
+}
+
+function getToolPartByteSize(part: TranscriptPart, text: string): number {
+    const textByteSize = byteSize(text);
+    if (textByteSize > 0 || part.kind !== "tool_result") return textByteSize;
+    return getNonTextToolResultByteSize(part);
+}
+
+function getNonTextToolResultByteSize(part: TranscriptPart): number {
+    const record = isRecord(part) ? part : undefined;
+    const content =
+        record?.content ??
+        record?.rawContent ??
+        record?.rawPart ??
+        record?.part ??
+        record?.data ??
+        record?.image ??
+        record?.source;
+    const serialized = safeJsonStringify(content ?? part);
+    return serialized === undefined ? 0 : byteSize(serialized);
+}
+
+function safeJsonStringify(value: unknown): string | undefined {
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return undefined;
+    }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null;
+}
+
 interface TagTextPartArgs {
     sessionId: string;
     message: { info: { id?: string; role: string } };
@@ -312,6 +425,7 @@ interface TagTextPartArgs {
     db: ContextDatabase;
     targets: Map<number, TagTarget>;
     skipPrefixInjection: boolean;
+    entryFingerprint: string | null;
 }
 
 function tagTextPart(args: TagTextPartArgs): void {
@@ -323,6 +437,10 @@ function tagTextPart(args: TagTextPartArgs): void {
         "message",
         byteSize(text),
         args.db,
+        0,
+        null,
+        0,
+        args.entryFingerprint,
     );
 
     // Persist the original (pre-tagged) source content so caveman
@@ -371,6 +489,7 @@ function tagToolPart(args: TagToolPartArgs): void {
     const stableId = args.part.id;
     const contentId = stableId ?? `${args.messageId}:t${args.partIndex}`;
     const text = args.part.getText() ?? "";
+    const toolByteSize = getToolPartByteSize(args.part, text);
     const meta = args.part.getToolMetadata();
     // v3.3.1 Layer C: synthetic ownership for the no-callId Pi
     // fallback. Owner == callId == contentId. The composite key
@@ -382,7 +501,7 @@ function tagToolPart(args: TagToolPartArgs): void {
         args.sessionId,
         contentId,
         contentId,
-        byteSize(text),
+        toolByteSize,
         args.db,
         0,
         meta.toolName ?? null,
@@ -400,6 +519,18 @@ function tagToolPart(args: TagToolPartArgs): void {
     args.targets.set(tagId, buildToolTarget(args.part, args.message));
 }
 
+function setToolContentOrText(part: TranscriptPart, content: string): boolean {
+    try {
+        if (part.setToolOutput(content)) return true;
+    } catch {
+        // Pi assistant tool_use parts deliberately assert if callers try
+        // to write a nonexistent output slot. Truncated-mode drops still
+        // need to shrink the invocation, so fall back to visible text/args
+        // replacement while preserving the adapter-level invariant.
+    }
+    return part.setText(content);
+}
+
 /**
  * Build a TagTarget that walks ALL occurrences of a tool call (invocation
  * + result) when mutating. This is the per-callId aggregate target used
@@ -428,9 +559,7 @@ function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): Tag
             for (const occ of occurrences) {
                 // Try setToolOutput first (works on tool_result-shaped parts);
                 // fall back to setText so tool_use parts also get sentinelized.
-                if (occ.part.setToolOutput(content)) {
-                    changed = true;
-                } else if (occ.part.setText(content)) {
+                if (setToolContentOrText(occ.part, content)) {
                     changed = true;
                 }
             }
@@ -461,7 +590,7 @@ function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): Tag
             const sentinel = "[truncated]";
             let any = false;
             for (const occ of occurrences) {
-                if (occ.part.setToolOutput(sentinel) || occ.part.setText(sentinel)) {
+                if (setToolContentOrText(occ.part, sentinel)) {
                     any = true;
                 }
             }
@@ -521,7 +650,7 @@ function buildToolTarget(
 ): TagTarget {
     return {
         setContent(content: string): boolean {
-            return part.setToolOutput(content) || part.setText(content);
+            return setToolContentOrText(part, content);
         },
         getContent(): string | null {
             return part.getText() ?? null;
@@ -542,7 +671,7 @@ function buildToolTarget(
             // via setToolOutput so the underlying tool_result content
             // gets the truncation; falls back to setText for cases
             // where the part type doesn't support setToolOutput.
-            const ok = part.setToolOutput("[truncated]") || part.setText("[truncated]");
+            const ok = setToolContentOrText(part, "[truncated]");
             return ok ? "truncated" : "absent";
         },
         message: {