@cortexkit/opencode-magic-context 0.42.6 → 0.43.0

package/src/shared/tag-transcript.ts

@@ -66,7 +66,7 @@ import {
     stripWellFormedLeadingTagPrefix,
 } from "../hooks/magic-context/tag-content-primitives";
 import type { TagTarget } from "../hooks/magic-context/tag-messages";
-import type { Transcript, TranscriptPart } from "./transcript";
+import type { Transcript, TranscriptMessage, TranscriptPart } from "./transcript";
 
 export const TEXT_TAG_IDENTITY_MARKER = ":mc-text-v1:";
 
@@ -236,6 +236,8 @@ export function tagTranscript(
     // atomicity we need. Removing the wrapper matches OpenCode's
     // tag-messages.ts design — see the long comment there for the
     // rationale (cache-bust amplifier story).
+    const conversationEnd = new ConversationEndGuard(transcript.messages);
+
     for (let msgIndex = 0; msgIndex < transcript.messages.length; msgIndex += 1) {
         const message = transcript.messages[msgIndex];
         if (message === undefined) continue;
@@ -436,6 +438,7 @@ export function tagTranscript(
                         aggregate: existing,
                         targets,
                         timing,
+                        conversationEnd,
                     });
                     if (part.kind === "tool_result") {
                         markToolAggregateResolved(
@@ -566,6 +569,7 @@ export function tagTranscript(
                     aggregate,
                     targets,
                     timing,
+                    conversationEnd,
                 });
                 if (part.kind === "tool_result") {
                     markToolAggregateResolved(callId, aggregateKey, openToolAggregateKeysByCallId);
@@ -678,6 +682,56 @@ interface ApplyToolPrefixAndTargetArgs {
     aggregate: ToolAggregate;
     targets: Map<number, TagTarget>;
     timing: TagTranscriptTiming | undefined;
+    conversationEnd: ConversationEndGuard;
+}
+
+function partHasContent(part: TranscriptPart): boolean {
+    return part.kind !== "text" || (part.getText() ?? "").trim().length > 0;
+}
+
+/**
+ * Keeps structural tool removal from ending the provider request on an
+ * assistant turn, which models without assistant prefill support reject.
+ *
+ * The request ends with the newest message that has any content. Tool results
+ * there are what close the conversation with a user turn, so removal may take
+ * one only while that message keeps other content. Shared by every target one
+ * tagging pass builds, so drops earlier in the same pass count as removed.
+ */
+class ConversationEndGuard {
+    private readonly end: TranscriptMessage | undefined;
+    private readonly removed = new Set<unknown>();
+
+    constructor(messages: readonly TranscriptMessage[]) {
+        for (let index = messages.length - 1; index >= 0 && !this.end; index -= 1) {
+            const message = messages[index];
+            if (message?.parts.some(partHasContent)) this.end = message;
+        }
+    }
+
+    wouldStrand(occurrences: readonly ToolOccurrence[]): boolean {
+        const end = this.end;
+        if (!end || !occurrences.some((occ) => occ.message === end)) return false;
+        const leaving = new Set(occurrences.map((occ) => partKey(occ.part)));
+        const survives = (part: TranscriptPart) =>
+            !leaving.has(partKey(part)) && !this.removed.has(partKey(part));
+        return end.info.role === "assistant"
+            ? !end.parts.some((part) => part.kind === "tool_result" && survives(part))
+            : !end.parts.some((part) => partHasContent(part) && survives(part));
+    }
+
+    noteRemoved(occurrences: readonly ToolOccurrence[]): void {
+        for (const occ of occurrences) this.removed.add(partKey(occ.part));
+    }
+}
+
+/**
+ * Adapters may hand out a fresh proxy object per read of `message.parts`, so
+ * tool parts are matched by kind and tool-call id; parts without an id fall
+ * back to object identity.
+ */
+function partKey(part: TranscriptPart): unknown {
+    return part.id === undefined ? part : `${part.kind}\u0000${part.id}`;
 }
 
 function applyToolPrefixAndTarget(args: ApplyToolPrefixAndTargetArgs): void {
@@ -693,6 +747,7 @@ function applyToolPrefixAndTarget(args: ApplyToolPrefixAndTargetArgs): void {
             args.tagId,
             args.aggregate.occurrences,
             args.aggregate.requiresToolArcSkeleton,
+            args.conversationEnd,
         ),
     );
     if (args.timing) args.timing.targets += performance.now() - targetStart;
@@ -1030,11 +1085,60 @@ function buildAggregateTarget(
     tagId: number,
     occurrences: ToolOccurrence[],
     requiresToolArcSkeleton: boolean,
+    conversationEnd?: ConversationEndGuard,
 ): TagTarget {
     const role = occurrences[0]?.message.info.role ?? "user";
     const messageId = occurrences[0]?.message.info.id;
 
+    const truncate = (): "truncated" | "absent" => {
+        // Keep the tool call and its result, but replace the call arguments with
+        // a non-executable marker and the result content with the dropped marker.
+        const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
+        let any = false;
+        for (const occ of occurrences) {
+            if (occ.kind === "tool_use" && occ.part.setToolInput) {
+                if (occ.part.setToolInput(droppedInputMarker(tagId))) any = true;
+            } else if (setToolContentOrText(occ.part, sentinel)) {
+                any = true;
+            }
+        }
+        return any ? "truncated" : "absent";
+    };
+
     return {
+        measureReclaim(skeleton) {
+            let beforeTools = 0;
+            let afterTools = 0;
+            const authorization = occurrences.map((occ) => occ.part.canRemove?.());
+            const removable =
+                !requiresToolArcSkeleton &&
+                occurrences.every(
+                    (occ, index) =>
+                        occ.part.remove &&
+                        authorization[index] !== false &&
+                        authorization[index] !== "defer",
+                );
+            for (const occ of occurrences) {
+                const before =
+                    occ.kind === "tool_use"
+                        ? JSON.stringify(occ.part.getToolInput?.() ?? {})
+                        : (occ.part.getText() ?? "");
+                beforeTools += estimateTokens(before);
+                if (skeleton || !removable) {
+                    const after =
+                        occ.kind === "tool_use"
+                            ? JSON.stringify(droppedInputMarker(tagId))
+                            : `[dropped §${tagId}§]`;
+                    afterTools += estimateTokens(after);
+                }
+            }
+            return {
+                beforeTools,
+                afterTools: !skeleton && authorization.includes("defer") ? beforeTools : afterTools,
+                beforeProse: 0,
+                afterProse: 0,
+            };
+        },
         setContent(content: string): boolean {
             // Walk all occurrences; mutate every one. Return true if at
             // least one occurrence's content actually changed (used to
@@ -1058,7 +1162,7 @@ function buildAggregateTarget(
             }
             return occurrences[0]?.part.getText() ?? null;
         },
-        drop(): "removed" | "absent" | "incomplete" {
+        drop(): "removed" | "truncated" | "absent" | "incomplete" {
             const complete =
                 occurrences.some((occ) => occ.kind === "tool_use") &&
                 occurrences.some((occ) => occ.kind === "tool_result");
@@ -1073,8 +1177,16 @@ function buildAggregateTarget(
                         (occ, index) => occ.part.remove && authorization[index] !== false,
                     )
                 ) {
+                    // If removing this call's result would leave the provider
+                    // request ending on an assistant turn, keep a call skeleton
+                    // plus placeholder result instead. "truncated" tells callers
+                    // to persist that mode, so later passes serve the same bytes.
+                    // (The sentinel fallback below keeps call and result in place,
+                    // so it needs no exception.)
+                    if (conversationEnd?.wouldStrand(occurrences)) return truncate();
                     let removed = false;
                     for (const occ of occurrences) removed = occ.part.remove?.() || removed;
+                    if (removed) conversationEnd?.noteRemoved(occurrences);
                     return removed ? "removed" : "absent";
                 }
             }
@@ -1086,20 +1198,7 @@ function buildAggregateTarget(
             }
             return any ? "removed" : "absent";
         },
-        truncate(): "truncated" | "absent" {
-            // Keep the paired call shell, but replace its arguments with one
-            // non-executable marker; result halves carry the matching sentinel.
-            const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
-            let any = false;
-            for (const occ of occurrences) {
-                if (occ.kind === "tool_use" && occ.part.setToolInput) {
-                    if (occ.part.setToolInput(droppedInputMarker(tagId))) any = true;
-                } else if (setToolContentOrText(occ.part, sentinel)) {
-                    any = true;
-                }
-            }
-            return any ? "truncated" : "absent";
-        },
+        truncate,
         editMarker(): "truncated" | "absent" {
             // Edit-marker: preserve the tool_use input's filePath + a region
             // hint of the diff, sentinelize the result half. Separate from

package/src/shared/tail-hygiene-status.ts

@@ -58,8 +58,16 @@ export function resolveTailHygieneStatus(
     };
 }
 
+/**
+ * The reclaimable share and the two masses it is computed from.
+ *
+ * The tokenizer calibration makes `u` and `t` fractional, but a token count is
+ * a whole number to the reader: `63,063.522 tok` reads as a measurement error,
+ * not as precision. Both masses are rounded here, at the one formatter every
+ * host prints, so the dialog, the sidebar and Pi cannot disagree.
+ */
 export function formatTailHygiene(status: TailHygieneStatus): string {
     const percentage = (status.severity * 100).toFixed(1);
     const state = status.evaluable ? "" : " · held until baseline refresh";
-    return `${percentage}% · ${status.u.toLocaleString()} / ${status.t.toLocaleString()} tok${state}`;
+    return `${percentage}% · ${Math.round(status.u).toLocaleString()} / ${Math.round(status.t).toLocaleString()} tok${state}`;
 }

package/src/shared/user-facing-codes.test.ts

@@ -64,10 +64,10 @@ describe("user-facing failure codes", () => {
             "Finish the provider setup, or set a fallback provider in the embedding settings, then run /ctx-embed start again. (MC-E06)",
         );
         expect(renderUserFacingFailure("configuration_warning")).toContain(
-            "Fix the configuration warning shown in /ctx-status diagnostics, then restart. (MC-S03)",
+            "Fix the configuration warning shown in /ctx-status, then restart. (MC-S03)",
         );
-        expect(renderUserFacingFailure("session_upgrade_unavailable")).toContain(
-            "Run /ctx-recomp instead. (MC-C07)",
+        expect(renderUserFacingFailure("partial_history_unavailable")).toContain(
+            "Run /ctx-recomp without a range. (MC-C06)",
         );
     });
 
@@ -92,7 +92,6 @@ describe("user-facing failure codes", () => {
             "note_access",
             "context_cleanup",
             "partial_history",
-            "session_upgrade",
             "smart_note_condition",
             "history_compression",
             "context_service",

package/src/shared/user-facing-codes.ts

@@ -7,6 +7,11 @@ export const USER_FACING_FAILURES = {
         sentence: "History compression could not finish this turn.",
         action: "It will retry automatically.",
     },
+    hidden_cleanup_unbound: {
+        code: "MC-H02",
+        sentence: "Some finished background sessions could not be removed from this host.",
+        action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service.",
+    },
     recomp_unavailable: {
         code: "MC-R01",
         sentence: "History compression could not be rebuilt.",
@@ -47,6 +52,17 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory maintenance could not finish.",
         action: "Run /ctx-dream again.",
     },
+    dreamer_tick_blocked: {
+        code: "MC-D09",
+        sentence:
+            "Background maintenance is not running: its last pass stopped before it reached the scheduled tasks.",
+        action: "It is retried automatically; if it keeps happening, check the Magic Context log for the stage that stopped and run `npx @cortexkit/magic-context doctor`.",
+    },
+    dream_task_needs_tool_loop: {
+        code: "MC-D08",
+        sentence: "Some memory maintenance tasks need a tool loop this host does not provide.",
+        action: "The remaining tasks still run; the listed ones are skipped on this host.",
+    },
     embedding_substitution_rejected: {
         code: "MC-E01",
         sentence: "Search indexing could not use the selected model.",
@@ -120,7 +136,7 @@ export const USER_FACING_FAILURES = {
     configuration_warning: {
         code: "MC-S03",
         sentence: "Some configuration settings could not be applied.",
-        action: "Fix the configuration warning shown in /ctx-status diagnostics, then restart.",
+        action: "Fix the configuration warning shown in /ctx-status, then restart.",
     },
     status_log_unavailable: {
         code: "MC-S04",
@@ -157,11 +173,6 @@ export const USER_FACING_FAILURES = {
         sentence: "Partial history compression is not available in the current mode.",
         action: "Run /ctx-recomp without a range.",
     },
-    session_upgrade_unavailable: {
-        code: "MC-C07",
-        sentence: "Session upgrade is not available in the current mode.",
-        action: "Run /ctx-recomp instead.",
-    },
     smart_note_conditions_unavailable: {
         code: "MC-C08",
         sentence: "Conditional notes are not available in the current mode.",
@@ -177,6 +188,12 @@ export const USER_FACING_FAILURES = {
         sentence: "Magic Context is temporarily unavailable.",
         action: "Retry in a moment.",
     },
+    compaction_marker_missing: {
+        code: "MC-C11",
+        sentence:
+            "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
+        action: "It is retried on every message; if this persists, run `/ctx-flush`.",
+    },
     memory_mirror_stalled: {
         code: "MC-M01",
         sentence: "Memory synchronization stopped before the host mirror caught up.",
@@ -187,6 +204,16 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory authority is inconsistent between the host and module.",
         action: "Run `ck doctor drain-authority` before changing Rust mode.",
     },
+    rust_mode_unsupported: {
+        code: "MC-S06",
+        sentence: "Experimental Rust transform mode is not available on this OpenCode host.",
+        action: 'Magic Context is running its TypeScript mode instead; set `transform_mode` to "ts" to stop requesting Rust.',
+    },
+    dreamer_task_failing: {
+        code: "MC-S05",
+        sentence: "A background maintenance task keeps failing on its schedule.",
+        action: "Check the Magic Context log for the failing task and its error.",
+    },
 } as const;
 
 export type UserFacingFailureKey = keyof typeof USER_FACING_FAILURES;
@@ -213,7 +240,6 @@ export type CapabilityRefusal =
     | "note_access"
     | "context_cleanup"
     | "partial_history"
-    | "session_upgrade"
     | "smart_note_condition"
     | "history_compression"
     | "context_service";
@@ -225,7 +251,6 @@ const CAPABILITY_FAILURES: Record<CapabilityRefusal, UserFacingFailureKey> = {
     note_access: "note_access_unavailable",
     context_cleanup: "context_cleanup_paused",
     partial_history: "partial_history_unavailable",
-    session_upgrade: "session_upgrade_unavailable",
     smart_note_condition: "smart_note_conditions_unavailable",
     history_compression: "history_compression_paused",
     context_service: "context_service_unavailable",

package/src/shared/window-geometry.test.ts

@@ -6,6 +6,7 @@ import { resolveLimit, resolveOutputReserve } from "./models-dev-cache";
 import {
     applyProvenInputFloor,
     deriveWindowGeometry,
+    formatCompactTokens,
     formatWindowDerivationLine,
     parseWindowOverlay,
     placeholderFilteredOutput,
@@ -372,15 +373,32 @@ describe("window geometry", () => {
         }
     });
 
-    test("display percentage uses the same usableSoft scheduler base", () => {
+    test("prints one line without the internal geometry tag or a second percentage", () => {
         const result = deriveWindowGeometry("openai", "model", {
             context: 204_000,
             output: 30_600,
         }) as NonNullable<ReturnType<typeof deriveWindowGeometry>>;
-        const input = 105_900;
-        const schedulerPercentage = (input / result.usableSoft) * 100;
-        expect(formatWindowDerivationLine(input, result)).toContain(
-            `(${schedulerPercentage.toFixed(1)}%)`,
+        const line = formatWindowDerivationLine(105_900, result);
+        // The headline row above this line already carries the percentage, and
+        // the bracketed geometry mode is window-geometry's own vocabulary.
+        expect(line).not.toContain("%");
+        expect(line).not.toContain("[");
+        expect(line).not.toContain("—");
+        expect(line).toBe(
+            `105.9k / ${formatCompactTokens(result.usableSoft)} usable · window ${formatCompactTokens(result.derivation.window)} · ${formatCompactTokens(result.derivation.reserve)} output reserve`,
         );
     });
+
+    test("fits one line at the dialog's narrowest content width", () => {
+        // The narrowest dialog content width is 56 columns (an 88-column dialog
+        // less its padding); a longer line wraps onto a second row. The 1m
+        // window with a 128k output reserve is the shape the dialog shows.
+        const result = deriveWindowGeometry("openai", "model", {
+            context: 1_000_000,
+            output: 128_000,
+        }) as NonNullable<ReturnType<typeof deriveWindowGeometry>>;
+        const line = formatWindowDerivationLine(533_700, result);
+        expect(line).toBe("533.7k / 872k usable · window 1m · 128k output reserve");
+        expect(line.length).toBeLessThanOrEqual(56);
+    });
 });

package/src/shared/window-geometry.ts

@@ -16,7 +16,12 @@ export const OPENCODE_OUTPUT_CAP = 32_000;
  * real window, so every denominator check shares this one floor.
  */
 export const MIN_PLAUSIBLE_CONTEXT_LIMIT = 1_024;
-const OUTPUT_RESERVE_CAP_RATIO = 0.25;
+export const OUTPUT_RESERVE_CAP_RATIO = 0.25;
+
+/** Catalog output ceilings are not requested output; reserve at most a quarter of a shared window. */
+export function catalogOutputReserve(window: number, output: number | undefined): number {
+    return Math.min(output ?? 0, Math.floor(window * OUTPUT_RESERVE_CAP_RATIO));
+}
 
 export type WindowGeometry = "shared_upfront" | "shared_truncating" | "separate";
 export type WindowReserveSource = "output_catalog" | "output_config" | "wall_margin" | "none";
@@ -692,14 +697,19 @@ export function formatWindowDerivationLine(
     inputTokens: number,
     result: WindowGeometryResult,
 ): string {
-    const percentage = result.usableSoft > 0 ? (inputTokens / result.usableSoft) * 100 : 0;
     const reserveLabel =
         result.derivation.reserveSource === "wall_margin"
             ? "wall margin"
             : result.derivation.reserveSource === "none"
               ? "reserve"
               : "output reserve";
-    return `Context: ${formatCompactTokens(inputTokens)} / ${formatCompactTokens(result.usableSoft)} usable (${percentage.toFixed(1)}%) — window ${formatCompactTokens(result.derivation.window)} − ${formatCompactTokens(result.derivation.reserve)} ${reserveLabel} [${result.geometry}]`;
+    // One line at the dialog's narrowest width, and no geometry vocabulary: the
+    // bracketed derivation tag (`[shared_truncating]`) names an internal
+    // window-geometry mode, and the percentage is already on the headline row
+    // above this one. The `Context:` prefix is dropped for the same reason — it
+    // pushed the line past the narrowest dialog's content width, where it
+    // wrapped onto a second row.
+    return `${formatCompactTokens(inputTokens)} / ${formatCompactTokens(result.usableSoft)} usable · window ${formatCompactTokens(result.derivation.window)} · ${formatCompactTokens(result.derivation.reserve)} ${reserveLabel}`;
 }
 
 export function formatCompactTokens(value: number): string {

package/src/tui/data/context-db.ts

@@ -246,33 +246,68 @@ export async function requestRecomp(sessionId: string): Promise<boolean> {
     }
 }
 
-/** Run `/ctx-session-upgrade` for the session (full recomp + once-per-project
- *  memory migration). Fired from the upgrade dialog's "Run upgrade now" action. */
-export async function requestUpgrade(sessionId: string): Promise<boolean> {
+/** Start a manual `/ctx-dream` run (optionally one named task) via RPC. The
+ *  server starts the pass in the background and pushes the summary when done. */
+export async function requestDream(sessionId: string, task?: string): Promise<boolean> {
     if (!rpcClient) return false;
     try {
-        const result = await rpcClient.call<{ ok: boolean }>("upgrade", { sessionId });
+        const result = await rpcClient.call<{ ok: boolean }>("dream", {
+            sessionId,
+            ...(task ? { task } : {}),
+        });
         return result.ok ?? false;
     } catch {
         return false;
     }
 }
 
-/** Mark the upgrade reminder dismissed (the user made an explicit Confirm/Cancel
- *  choice), setting the durable stamp so the FRESH dialog won't re-show. Resume
- *  prompts are staging-driven and unaffected. */
-export async function dismissUpgradeReminder(sessionId: string): Promise<boolean> {
-    if (!rpcClient) return false;
+/** What a command RPC reports back: finished text, an acknowledgement that
+ *  background work started (no text yet), or the failure. */
+export type CommandRpcResult =
+    | { ok: true; message?: string; started?: boolean }
+    | { ok: false; error?: string };
+
+async function callCommandRpc(
+    method: string,
+    params: Record<string, unknown>,
+): Promise<CommandRpcResult> {
+    if (!rpcClient) return { ok: false };
     try {
-        const result = await rpcClient.call<{ ok: boolean }>("dismiss-upgrade-reminder", {
-            sessionId,
-        });
-        return result.ok ?? false;
-    } catch {
-        return false;
+        const result = await rpcClient.call<CommandRpcResult>(method, params);
+        return result.ok === true
+            ? result
+            : { ok: false, error: (result as { error?: string }).error };
+    } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
 
+/** Run `/ctx-flush` for the session: apply the queued operations now. */
+export async function requestFlush(sessionId: string): Promise<CommandRpcResult> {
+    return callCommandRpc("flush", { sessionId });
+}
+
+/** Start `/ctx-wrapup`: compact the older live tail, keeping the newest N raw. */
+export async function requestWrapup(
+    sessionId: string,
+    messagesToKeep: number,
+): Promise<CommandRpcResult> {
+    return callCommandRpc("wrapup", { sessionId, messagesToKeep });
+}
+
+/** `/ctx-embed`: read coverage, or start/pause the history embedding drain. */
+export async function requestEmbed(
+    sessionId: string,
+    action: "status" | "start" | "pause",
+    directory?: string,
+): Promise<CommandRpcResult> {
+    return callCommandRpc("embed", {
+        sessionId,
+        action,
+        ...(directory ? { directory } : {}),
+    });
+}
+
 /** Resolve global toast duration from server config via RPC. */
 export async function loadToastDurationMs(): Promise<number> {
     if (!rpcClient) return 5000;

package/src/tui/dialogs/status-dialog-colors.test.ts

@@ -0,0 +1,58 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Every `<text>` in the status dialog must set `fg`.
+ *
+ * A text element without it takes OpenTUI's default foreground, which is the
+ * terminal's default colour — on a light theme that is the same colour as the
+ * dialog's background, so the row renders as blank space. That is exactly how
+ * the old collapsed summary shipped: its rows carried no `fg` and the dialog
+ * looked empty. Nothing else catches it, because a colourless row still lays
+ * out, still has the right text, and only disappears on themes the author is
+ * not using.
+ *
+ * The check reads the source rather than a rendered frame because `fg` is set
+ * per element in this file; a row that loses it loses it here.
+ */
+const DIALOG_SOURCE = join(import.meta.dir, "status-dialog.tsx");
+
+/**
+ * Opening tags for `element`, terminated by the `>` that is not inside a JSX
+ * expression. Tracking brace depth keeps a `>` inside `fg={a > b ? x : y}` from
+ * ending the tag early.
+ */
+export function openingTags(source: string, element: string): string[] {
+    const tags: string[] = [];
+    const marker = `<${element}`;
+    let cursor = source.indexOf(marker);
+    while (cursor !== -1) {
+        let depth = 0;
+        let end = cursor + marker.length;
+        while (end < source.length) {
+            const character = source[end];
+            if (character === "{") depth += 1;
+            else if (character === "}") depth -= 1;
+            else if (character === ">" && depth === 0) break;
+            end += 1;
+        }
+        tags.push(source.slice(cursor, end + 1));
+        cursor = source.indexOf(marker, end);
+    }
+    return tags;
+}
+
+test("every text row in the status dialog sets an explicit foreground colour", () => {
+    const source = readFileSync(DIALOG_SOURCE, "utf8");
+    const tags = openingTags(source, "text");
+    // A file that stopped containing text elements would pass the loop below
+    // without checking anything.
+    expect(tags.length).toBeGreaterThan(8);
+    expect(tags.filter((tag) => !tag.includes("fg="))).toEqual([]);
+});
+
+test("the tag scanner does not stop at a > inside a JSX expression", () => {
+    const sample = "<text fg={a > b ? c : d}>x</text><text>y</text>";
+    expect(openingTags(sample, "text")).toEqual(["<text fg={a > b ? c : d}>", "<text>"]);
+});