@cortexkit/opencode-magic-context 0.49.20 → 0.49.21

package/src/shared/sqlite-turn-deadline.test.ts

@@ -0,0 +1,270 @@
+import { Database as NativeDatabase } from "bun:sqlite";
+import { expect, spyOn, test } from "bun:test";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    createSqliteTurnDatabase,
+    Database,
+    withoutSqliteTransformPass,
+    withSqliteTurnDeadline,
+} from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+async function fixture(run: (db: Database, path: string) => Promise<void>) {
+    const root = createTestTempDirFromPath(join(tmpdir(), "sqlite-turn-deadline-"));
+    const path = join(root, "context.db");
+    const db = createSqliteTurnDatabase(path);
+    db.exec(
+        "PRAGMA journal_mode=DELETE; PRAGMA busy_timeout=900; CREATE TABLE t(value); INSERT INTO t VALUES(1)",
+    );
+    try {
+        await run(db, path);
+    } finally {
+        db.close();
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+
+async function hold(path: string, reader = false) {
+    const child = Bun.spawn(
+        [
+            process.execPath,
+            "-e",
+            `
+        const { Database } = require('bun:sqlite');
+        const db = new Database(process.argv[1]);
+        db.exec(${JSON.stringify(reader ? "BEGIN; SELECT * FROM t" : "BEGIN EXCLUSIVE")});
+        console.log('HELD');
+        setInterval(() => {}, 1000);
+    `,
+            path,
+        ],
+        { stdout: "pipe", stderr: "pipe", windowsHide: true },
+    );
+    const output = child.stdout.getReader();
+    const first = await output.read();
+    output.releaseLock();
+    if (!new TextDecoder().decode(first.value).includes("HELD")) {
+        child.kill();
+        throw new Error(`holder failed: ${await new Response(child.stderr).text()}`);
+    }
+    return async () => {
+        child.kill();
+        await child.exited;
+    };
+}
+
+function bounded(operation: () => unknown) {
+    const start = performance.now();
+    expect(() =>
+        withSqliteTurnDeadline(() => Math.max(0, 80 - (performance.now() - start)), operation),
+    ).toThrow(/locked|busy/i);
+    // The connection allows 900 ms; a late turn has only 80 ms left for this wait.
+    expect(performance.now() - start).toBeLessThan(400);
+    expect(performance.now() - start).toBeGreaterThan(40);
+}
+
+test("ordinary connections keep native cached SELECT methods", () => {
+    const db = new Database(":memory:");
+    const native = new NativeDatabase(":memory:");
+    try {
+        expect(db.prepare("SELECT 1").get).toBe(native.prepare("SELECT 1").get);
+    } finally {
+        db.close();
+        native.close();
+    }
+});
+
+test("native deadlines read the connection timeout once, not per cached execution", () => {
+    let reads = 0;
+    const prepare = Database.prototype.prepare;
+    const spy = spyOn(Database.prototype, "prepare").mockImplementation(function (
+        this: Database,
+        sql: string,
+    ) {
+        const statement = prepare.call(this, sql);
+        if (sql === "PRAGMA busy_timeout") {
+            const get = statement.get.bind(statement);
+            statement.get = (...args: unknown[]) => {
+                reads++;
+                return get(...args);
+            };
+        }
+        return statement;
+    });
+    let db: Database | undefined;
+    try {
+        db = createSqliteTurnDatabase(":memory:");
+        db.exec("PRAGMA busy_timeout=900");
+        const query = db.prepare("SELECT 1 AS value");
+        withSqliteTurnDeadline(
+            () => 80,
+            () => {
+                for (let i = 0; i < 100; i++) expect(query.get()).toEqual({ value: 1 });
+            },
+        );
+        expect(reads).toBe(1);
+        withSqliteTurnDeadline(
+            () => 80,
+            () => {
+                expect(db!.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 900 });
+            },
+        );
+    } finally {
+        db?.close();
+        spy.mockRestore();
+    }
+});
+
+test("timeout cache follows scripts, prepared setters, comments and failed prefixes", async () => {
+    await fixture(async (db, path) => {
+        db.exec(
+            "PRAGMA main.busy_timeout(900); SELECT '; PRAGMA busy_timeout=0;'; -- PRAGMA busy_timeout=1",
+        );
+        db.prepare("PRAGMA busy_timeout=800").get();
+        expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 800 });
+        expect(() => db.exec("PRAGMA busy_timeout=700; SELECT * FROM missing_table")).toThrow();
+        const read = db.prepare("SELECT * FROM t");
+        const release = await hold(path);
+        try {
+            bounded(() => read.get());
+            expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 700 });
+        } finally {
+            await release();
+        }
+    });
+});
+
+test("timeout cache follows prepare-time PRAGMA effects", () => {
+    const db = createSqliteTurnDatabase(":memory:");
+    const physicalTimeout = () =>
+        (db.prepare("PRAGMA busy_timeout").get() as { timeout: number }).timeout;
+    const harmlessRead = () =>
+        withSqliteTurnDeadline(
+            () => 80,
+            () => db.prepare("SELECT 1").get(),
+        );
+    try {
+        db.exec("PRAGMA busy_timeout=900");
+        const setter = db.prepare("PRAGMA busy_timeout=800");
+        expect(physicalTimeout()).toBe(800);
+        harmlessRead();
+        expect(physicalTimeout()).toBe(800);
+        db.exec("PRAGMA busy_timeout=700");
+        setter.get();
+        const before = physicalTimeout();
+        harmlessRead();
+        expect(physicalTimeout()).toBe(before);
+        const iterator = db.prepare("PRAGMA busy_timeout=600").iterate();
+        const beforeIteration = physicalTimeout();
+        harmlessRead();
+        expect(physicalTimeout()).toBe(beforeIteration);
+        db.exec("PRAGMA busy_timeout=500");
+        iterator.next();
+        const afterIteration = physicalTimeout();
+        harmlessRead();
+        expect(physicalTimeout()).toBe(afterIteration);
+        iterator.return?.();
+    } finally {
+        db.close();
+    }
+});
+
+for (const method of ["get", "all", "run", "values", "iterate"] as const) {
+    test(`turn deadline bounds cached SELECT ${method}`, async () => {
+        await fixture(async (db, path) => {
+            const statement = db.prepare("SELECT * FROM t") as any;
+            const release = await hold(path);
+            try {
+                bounded(() =>
+                    method === "iterate" ? statement.iterate().next() : statement[method](),
+                );
+                expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 900 });
+            } finally {
+                await release();
+            }
+        });
+    });
+}
+
+test("turn deadline bounds native exec reads", async () => {
+    await fixture(async (db, path) => {
+        const release = await hold(path);
+        try {
+            bounded(() => db.exec("SELECT * FROM t"));
+        } finally {
+            await release();
+        }
+    });
+});
+
+test("turn deadline bounds native schema preparation", async () => {
+    await fixture(async (_db, path) => {
+        const release = await hold(path);
+        const fresh = createSqliteTurnDatabase(path);
+        fresh.exec("PRAGMA busy_timeout=900");
+        try {
+            bounded(() => fresh.prepare("SELECT * FROM t"));
+        } finally {
+            fresh.close();
+            await release();
+        }
+    });
+});
+
+test("turn deadline bounds COMMIT waiting for a reader", async () => {
+    await fixture(async (db, path) => {
+        db.exec("BEGIN IMMEDIATE; UPDATE t SET value=2");
+        const release = await hold(path, true);
+        try {
+            bounded(() => db.exec("COMMIT"));
+            expect(db.inTransaction).toBe(true);
+            db.exec("ROLLBACK");
+        } finally {
+            await release();
+        }
+    });
+});
+
+test("turn deadline bounds execution inside a deferred transaction", async () => {
+    await fixture(async (db, path) => {
+        const read = db.prepare("SELECT * FROM t");
+        db.exec("BEGIN DEFERRED");
+        const release = await hold(path);
+        try {
+            bounded(() => read.get());
+        } finally {
+            db.exec("ROLLBACK");
+            await release();
+        }
+    });
+});
+
+test("turn deadline preserves zero-timeout probes and detached work", async () => {
+    await fixture(async (db, path) => {
+        const read = db.prepare("SELECT * FROM t");
+        const release = await hold(path);
+        try {
+            withSqliteTurnDeadline(
+                () => 80,
+                () => {
+                    db.exec("PRAGMA busy_timeout=0");
+                    expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 0 });
+                    expect(() => read.get()).toThrow(/locked|busy/i);
+                    db.exec("PRAGMA busy_timeout=900");
+                },
+            );
+            const start = performance.now();
+            expect(() =>
+                withSqliteTurnDeadline(
+                    () => 0,
+                    () => withoutSqliteTransformPass(() => read.get()),
+                ),
+            ).toThrow(/locked|busy/i);
+            expect(performance.now() - start).toBeGreaterThan(700);
+        } finally {
+            await release();
+        }
+    });
+});

package/src/shared/sqlite.ts

@@ -403,11 +403,187 @@ export function getTagIdentityWriteGeneration(): number {
     return tagIdentityWriteGeneration;
 }
 
-/** Route native Bun and Node transaction entry through the same acquisition retry.
- * Native Bun transaction wrappers execute BEGIN internally, bypassing an exec override,
- * so both runtimes use this small synchronous wrapper instead. Writable handles
- * default to IMMEDIATE; explicit deferred calls and readonly handles keep read
- * snapshots without acquiring the writer lock. */
+/** Only Pi serving connections need a mirror of their native busy handler. */
+const busyTimeoutStates = new WeakMap<Database, { current: number }>();
+const BUSY_TIMEOUT_QUERY =
+    /^\s*PRAGMA\s+(?:(?:\w+|"[^"]+"|`[^`]+`|\[[^\]]+\])\s*\.\s*)?(?:busy_timeout|"busy_timeout"|`busy_timeout`|\[busy_timeout\])\s*;?\s*$/i;
+const BUSY_TIMEOUT_SETTER =
+    /^\s*PRAGMA\s+(?:(?:\w+|"[^"]+"|`[^`]+`|\[[^\]]+\])\s*\.\s*)?(?:busy_timeout|"busy_timeout"|`busy_timeout`|\[busy_timeout\])\s*(?==|\()/i;
+
+function literalBusyTimeout(sql: string): number | undefined {
+    const head = BUSY_TIMEOUT_SETTER.exec(sql);
+    if (!head) return undefined;
+    const match = /^(?:=\s*|\(\s*)(?:'(-?\d+)'|"(-?\d+)"|(-?\d+))\s*\)?\s*;?\s*$/.exec(
+        sql.slice(head[0].length),
+    );
+    if (!match) return undefined;
+    const value = Number(match[1] ?? match[2] ?? match[3]);
+    return value < 0 ? 0 : value <= 0x7fffffff ? value : undefined;
+}
+
+/** Split timeout-setting scripts without mistaking quoted text or comments for pragmas. */
+function busyTimeoutStatements(sql: string): string[] {
+    const statements: string[] = [];
+    let statement = "";
+    let quote = "";
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql[i];
+        if (quote) {
+            statement += char;
+            if (char === quote) {
+                if (sql[i + 1] === quote) statement += sql[++i];
+                else quote = "";
+            }
+        } else if (char === "'" || char === '"' || char === "`" || char === "[") {
+            quote = char === "[" ? "]" : char;
+            statement += char;
+        } else if (char === "-" && sql[i + 1] === "-") {
+            while (i + 1 < sql.length && sql[i + 1] !== "\n") i++;
+            statement += " ";
+        } else if (char === "/" && sql[i + 1] === "*") {
+            i += 2;
+            while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/")) i++;
+            i++;
+            statement += " ";
+        } else if (char === ";") {
+            statements.push(statement);
+            statement = "";
+        } else statement += char;
+    }
+    statements.push(statement);
+    return statements.filter((part) => part.trim().length > 0);
+}
+
+/** Install the native deadline layer only on a connection that will serve Pi turns. */
+function installNativeDeadlineRouting(db: BetterSqlite3.Database): void {
+    const rawExec = db.exec.bind(db);
+    const rawPrepare = db.prepare.bind(db);
+    const readTimeout = (): number => {
+        const statement = rawPrepare("PRAGMA busy_timeout");
+        try {
+            return Object.values(statement.get() as Record<string, number>)[0];
+        } finally {
+            (statement as Partial<FinalizableStatement>).finalize?.();
+        }
+    };
+    const timeoutState = { current: readTimeout() };
+    busyTimeoutStates.set(db, timeoutState);
+    const setBusyTimeout = (timeout: number): void => {
+        rawExec(`PRAGMA busy_timeout=${timeout}`);
+        timeoutState.current = timeout;
+    };
+    const withinDeadline = <T>(operation: () => T): T => {
+        const deadline = nativeWaitScope?.getStore();
+        if (!deadline?.active || !deadline.remainingMs) return operation();
+        const remaining = deadline.remainingMs();
+        if (remaining === Infinity) return operation();
+        const previous = timeoutState.current;
+        const timeout = Math.min(previous, Math.max(0, Math.floor(remaining)));
+        if (timeout === previous) return operation();
+        setBusyTimeout(timeout);
+        try {
+            return operation();
+        } finally {
+            setBusyTimeout(previous);
+        }
+    };
+    Object.defineProperty(db, "exec", {
+        configurable: true,
+        writable: true,
+        value: (sql: string) => {
+            const parts = /\bbusy_timeout\b/i.test(sql) ? busyTimeoutStatements(sql) : [];
+            if (parts.length === 1 && BUSY_TIMEOUT_QUERY.test(parts[0])) return rawExec(sql);
+            const singleSetter = parts.length === 1 && BUSY_TIMEOUT_SETTER.test(parts[0]);
+            const setting = singleSetter ? literalBusyTimeout(parts[0]) : undefined;
+            if (singleSetter) {
+                const result = rawExec(sql);
+                timeoutState.current = setting ?? readTimeout();
+                return result;
+            }
+            if (!/\bbusy_timeout\b/i.test(sql)) return withinDeadline(() => rawExec(sql));
+            const setters = parts.filter((part) => BUSY_TIMEOUT_SETTER.test(part));
+            return withinDeadline(() => {
+                try {
+                    const result = rawExec(sql);
+                    if (setters.length)
+                        timeoutState.current =
+                            literalBusyTimeout(setters[setters.length - 1]) ?? readTimeout();
+                    return result;
+                } catch (error) {
+                    // exec can apply a timeout-setting prefix before a later statement
+                    // fails. Only an ambiguous setting needs a native readback.
+                    if (setters.length) timeoutState.current = readTimeout();
+                    throw error;
+                }
+            });
+        },
+    });
+    // Timeout introspection cannot wait on a database lock. Its getter must
+    // report the configured timeout, not a temporary cap that a caller might save.
+    const nativePrepare = (sql: string) =>
+        BUSY_TIMEOUT_QUERY.test(sql) || BUSY_TIMEOUT_SETTER.test(sql)
+            ? rawPrepare(sql)
+            : withinDeadline(() => rawPrepare(sql));
+    Object.defineProperty(db, "prepare", {
+        configurable: true,
+        writable: true,
+        value: (sql: string) => {
+            // biome-ignore lint/suspicious/noExplicitAny: Bun adds values() to the common statement interface.
+            const statement: any = nativePrepare(sql);
+            const normalized = /\bbusy_timeout\b/i.test(sql)
+                ? (busyTimeoutStatements(sql)[0] ?? sql)
+                : sql;
+            const setting = literalBusyTimeout(normalized);
+            const timeoutSetter = BUSY_TIMEOUT_SETTER.test(normalized);
+            const timeoutQuery = BUSY_TIMEOUT_QUERY.test(normalized);
+            // SQLite applies this PRAGMA while preparing it, before get/run.
+            if (timeoutSetter) timeoutState.current = setting ?? readTimeout();
+            for (const method of ["run", "get", "all", "values"] as const) {
+                const execute = statement[method]?.bind(statement);
+                if (!execute) continue;
+                Object.defineProperty(statement, method, {
+                    configurable: true,
+                    // biome-ignore lint/suspicious/noExplicitAny: retain native binding overloads.
+                    value: (...args: any[]) => {
+                        if (timeoutQuery) return execute(...args);
+                        if (!timeoutSetter) return withinDeadline(() => execute(...args));
+                        const result = execute(...args);
+                        timeoutState.current = readTimeout();
+                        return result;
+                    },
+                });
+            }
+            if (typeof statement.iterate === "function") {
+                const iterate = statement.iterate.bind(statement);
+                Object.defineProperty(statement, "iterate", {
+                    configurable: true,
+                    // biome-ignore lint/suspicious/noExplicitAny: retain native binding overloads.
+                    value: (...args: any[]) => {
+                        const iterator =
+                            !timeoutSetter && !timeoutQuery
+                                ? withinDeadline(() => iterate(...args))
+                                : iterate(...args);
+                        const next = iterator.next.bind(iterator);
+                        if (timeoutSetter) timeoutState.current = readTimeout();
+                        iterator.next = () => {
+                            if (timeoutQuery) return next();
+                            if (!timeoutSetter) return withinDeadline(next);
+                            const result = next();
+                            timeoutState.current = readTimeout();
+                            return result;
+                        };
+                        return iterator;
+                    },
+                });
+            }
+            return statement;
+        },
+    });
+}
+
+/** Route native Bun and Node transactions through the same acquisition retry.
+ * Native Bun wrappers execute BEGIN internally, so both runtimes use this wrapper.
+ * Deadline routing, when selected, is installed underneath it at connection open. */
 function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean): void {
     const nativeExec = db.exec.bind(db);
     Object.defineProperty(db, "exec", {
@@ -565,6 +741,7 @@ function trackSqliteConnection(
     db: BetterSqlite3.Database,
     filename: unknown,
     options: unknown,
+    turnDeadlines = false,
 ): BetterSqlite3.Database {
     const originalClose = db.close.bind(db) as (...args: unknown[]) => unknown;
     const sequence = nextSqliteConnectionSequence++;
@@ -582,6 +759,7 @@ function trackSqliteConnection(
             ((options as { readonly?: unknown }).readonly === true ||
                 (options as { readOnly?: unknown }).readOnly === true),
     };
+    if (turnDeadlines) installNativeDeadlineRouting(db);
     installTransactionRouting(db, metadata.readonly);
     Object.defineProperty(db, "close", {
         configurable: true,
@@ -664,6 +842,18 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
 
 export const Database: typeof BetterSqlite3 = TrackedDatabase;
 
+/** Open a Pi foreground connection with native-deadline routing before statements are prepared. */
+export function createSqliteTurnDatabase(
+    filename?: string | Buffer,
+    options?: BetterSqlite3.Options,
+): Database {
+    return trackSqliteConnection(new DatabaseImpl(filename, options), filename, options, true);
+}
+
+export function hasSqliteTurnDeadlineRouting(db: Database): boolean {
+    return busyTimeoutStates.has(db);
+}
+
 function immutableDatabaseImplementation(): typeof BetterSqlite3 {
     if (!isBun) return DatabaseImpl;
     if (immutableDatabaseImpl) return immutableDatabaseImpl;
@@ -728,6 +918,10 @@ function pragmaValue(db: BetterSqlite3.Database, name: string): unknown {
 }
 
 function pragmaNumber(db: BetterSqlite3.Database, name: string): number | null {
+    if (name === "busy_timeout") {
+        const state = busyTimeoutStates.get(db);
+        if (state) return state.current;
+    }
     try {
         const value = pragmaValue(db, name);
         return typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -934,6 +1128,38 @@ export function prepareCachedStatement(db: Database, sql: string): Statement {
 }
 
 const privilegeDepth = new WeakMap<Database, number>();
+interface NativeWaitLease {
+    active: boolean;
+    remainingMs?: () => number;
+}
+let nativeWaitScope: AsyncLocalStorage<NativeWaitLease | undefined> | undefined;
+
+function releaseNativeWaitLease(lease: NativeWaitLease): void {
+    lease.active = false;
+    // Detached descendants can retain their async-local lease after the turn.
+    // Do not retain the completed request through its deadline callback.
+    lease.remainingMs = undefined;
+}
+
+/** Bound native lock waits for an awaited turn, without changing background timeouts. */
+export function withSqliteTurnDeadline<T>(remainingMs: () => number, operation: () => T): T {
+    const scope = (nativeWaitScope ??= new AsyncLocalStorage<NativeWaitLease | undefined>());
+    const lease: NativeWaitLease = { active: true, remainingMs };
+    return scope.run(lease, () => {
+        try {
+            const result = operation();
+            if (result && typeof (result as { then?: unknown }).then === "function")
+                return Promise.resolve(result).finally(
+                    releaseNativeWaitLease.bind(null, lease),
+                ) as T;
+            releaseNativeWaitLease(lease);
+            return result;
+        } catch (error) {
+            releaseNativeWaitLease(lease);
+            throw error;
+        }
+    });
+}
 const transformPassScope = new AsyncLocalStorage<
     | {
           active: boolean;
@@ -947,7 +1173,8 @@ const backgroundWriterScope = new AsyncLocalStorage<boolean>();
 
 /** Opt in only a writer that can safely defer its work after a busy acquisition. */
 export function withSqliteBackgroundWriter<T>(operation: () => T): T {
-    return backgroundWriterScope.run(true, operation);
+    if (!nativeWaitScope?.getStore()) return backgroundWriterScope.run(true, operation);
+    return nativeWaitScope.run(undefined, () => backgroundWriterScope.run(true, operation));
 }
 
 /** Only an awaited foreground transform may spend the extra acquisition budget.
@@ -984,7 +1211,8 @@ export function withSqliteTransformPass<T>(operation: () => T): T {
 
 /** Start detached maintenance work without borrowing a foreground pass's budget. */
 export function withoutSqliteTransformPass<T>(operation: () => T): T {
-    return transformPassScope.run(undefined, operation);
+    if (!nativeWaitScope?.getStore()) return transformPassScope.run(undefined, operation);
+    return nativeWaitScope.run(undefined, () => transformPassScope.run(undefined, operation));
 }
 
 /** Attach the adapter's existing generation/cancellation/deadline guard to writes. */

package/src/shared/tag-transcript.ts

@@ -63,6 +63,7 @@ import { estimateTokens } from "../hooks/magic-context/read-session-formatting";
 import {
     byteSize,
     prependTag,
+    stripPersistedAssistantText,
     stripTagPrefix,
     stripWellFormedLeadingTagPrefix,
 } from "../hooks/magic-context/tag-content-primitives";
@@ -75,6 +76,8 @@ import type { Transcript, TranscriptMessage, TranscriptPart } from "./transcript
 export { TEXT_TAG_IDENTITY_MARKER };
 
 export interface TagTranscriptOptions {
+    /** Keep tag-only assistant slots inert when their original text must survive stripping. */
+    preserveTagOnlyAssistantText?: boolean;
     /**
      * When true, skip injecting `§N§` prefix into visible text. Tags
      * still get assigned in the DB so historian/drops can reference
@@ -416,6 +419,7 @@ export function tagTranscript(
                     db,
                     targets,
                     skipPrefixInjection,
+                    preserveTagOnlyAssistantText: options.preserveTagOnlyAssistantText,
                     entryFingerprint: options.entryFingerprintByMessageId?.get(messageId) ?? null,
                     reuseIdentity: reuseIdentity || contentDerivedTextIds !== undefined,
                     timing,
@@ -996,6 +1000,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 interface TagTextPartArgs {
+    preserveTagOnlyAssistantText?: boolean;
     sessionId: string;
     message: { info: { id?: string; role: string } };
     messageId: string;
@@ -1022,7 +1027,10 @@ function tagTextPart(args: TagTextPartArgs): void {
     // into a tag-bearing part that later strip logic could mistake for content.
     if (
         args.message.info.role === "assistant" &&
-        stripWellFormedLeadingTagPrefix(text).trim().length === 0
+        (stripWellFormedLeadingTagPrefix(text).trim().length === 0 ||
+            (args.preserveTagOnlyAssistantText &&
+                text.includes("§") &&
+                stripPersistedAssistantText(text).length === 0))
     ) {
         if (args.timing) args.timing.identity += performance.now() - identityStart;
         return;

package/dist/wrapup-orchestrator-mnvt2g8m.js

@@ -1,49 +0,0 @@
-import {
-  runManagedWrapup2
-} from "./index-4n7w9rad.js";
-import"./index-jfh3cktr.js";
-import"./index-v7r4td4c.js";
-import"./index-616rsjrv.js";
-import"./index-1pefp8ar.js";
-import"./index-48stjd56.js";
-import"./index-sd3egckz.js";
-import"./index-jr5na10t.js";
-import"./index-2yhtnfcf.js";
-import"./index-y4a3nhtk.js";
-import"./index-4dhv7mqz.js";
-import"./index-spwjbkc7.js";
-import"./index-kc9pn495.js";
-import"./index-qt1qqasc.js";
-import"./index-x4k3f4mf.js";
-import"./index-305y133n.js";
-import"./index-1zx87sdm.js";
-import"./index-11zf2wwc.js";
-import"./index-x8a7jmkh.js";
-import"./index-rrv26qjz.js";
-import"./index-0wthn7fp.js";
-import"./index-wgypt3cs.js";
-import"./index-c4b76d4t.js";
-import"./index-153r2q6z.js";
-import"./index-adk2z5d8.js";
-import"./index-rmd0069m.js";
-import"./index-fb3zxn06.js";
-import"./index-pnjwa6qa.js";
-import"./index-vkc1ca9p.js";
-import"./index-jmycsey7.js";
-import"./index-fr0wbhdn.js";
-import"./index-c7phnbvk.js";
-import"./index-j76ah6d7.js";
-import"./index-x9k3mqrf.js";
-import"./index-58e3y90n.js";
-import"./index-35qc6606.js";
-import"./index-v0p37hm2.js";
-import"./index-t5pck3ss.js";
-import"./index-b88dwwrh.js";
-import"./index-1zx2pa5d.js";
-import"./index-h7tgn49j.js";
-import"./index-g2q4htwp.js";
-import"./index-pavzsdc6.js";
-import"./index-cpjk5jd2.js";
-export {
-  runManagedWrapup2 as runManagedWrapup
-};