@timurproko/a1 0.1.8-dev.368 → 0.1.8-dev.402

package/dist/ui/components/spans.js

@@ -17,9 +17,10 @@ const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
  * Replaces the visible columns `[from, to)` of `line` with `span`, preserving
  * the styling before it and re-asserting whatever was still open afterwards, so
  * the tail keeps the colour it had. A wide character straddling either edge is
- * replaced by spaces rather than split.
+ * replaced by spaces rather than split. Opt into the replaced cell's boundary
+ * style for background-preserving overlays; the span still owns its decoration.
  */
-export function overlaySpan(line, from, to, span) {
+export function overlaySpan(line, from, to, span, options = {}) {
     let head = "";
     let replay = "";
     let tail = "";
@@ -29,11 +30,19 @@ export function overlaySpan(line, from, to, span) {
         if (!token)
             continue;
         if (token.startsWith("")) {
+            // Protocol: image transfers are one-shot commands, not styling to replay after an overlay.
+            if (token.startsWith("\u001b_G") || token.startsWith("\u001b]1337;File=")) {
+                if (column >= to)
+                    tail += token;
+                else
+                    head += token;
+                continue;
+            }
             if (column >= to) {
                 tail += token;
                 continue;
             }
-            if (column < from) {
+            if (column < from || (options.inheritStartStyle === true && column === from)) {
                 head += token;
                 const link = HYPERLINK.exec(token);
                 if (link)

package/dist/ui/components/text-selection.js

@@ -180,6 +180,8 @@ function characterClass(character) {
 function indexAtDisplayBoundary(plain, column, edge) {
     if (column <= 0)
         return 0;
+    if (column >= Number.MAX_SAFE_INTEGER - 1)
+        return plain.length;
     let width = 0;
     let index = 0;
     for (const { segment } of GRAPHEMES.segment(plain)) {

package/dist/ui/components/text.js

@@ -4,7 +4,7 @@
  * and counting styling escapes as visible width breaks every layout that uses
  * colour.
  */
-const ANSI_PATTERN = /\[[0-9;:?]*[ -/]*[@-~]|\][^]*(?:|\\)|[@-Z\\-_]/g;
+const ANSI_PATTERN = /\[[0-9;:?]*[ -/]*[@-~]|[\]_][^]*(?:|\\)|[@-Z\\-_]/g;
 const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 const WORD_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "word" });
 /**

package/dist/ui/components/transcript-viewport.d.ts

@@ -1,3 +1,4 @@
+import { type SelectionCopySnapshot } from "./selection-copy.js";
 import { type ScrollbarAppearance, type ScrollbarGeometry, type ScrollbarStyle } from "./scrollbar.js";
 export interface TranscriptPromptAnchor {
     readonly id: string;
@@ -5,6 +6,8 @@ export interface TranscriptPromptAnchor {
     readonly lastRow: number;
     /** The source first row, including its submitted-prompt styling and timestamp. */
     readonly sourceRow: string;
+    /** Optional source-styled row used only while prominent and not hovered. */
+    readonly prominentSourceRow?: string;
 }
 export interface TranscriptViewportConfig {
     readonly scrollbarAppearance: ScrollbarAppearance;
@@ -152,6 +155,8 @@ export declare class TranscriptViewport {
     releaseSelection(): boolean;
     clearSelection(): boolean;
     selectedText(): string | null;
+    /** Captures selected source references, never the entire mutable transcript or prompt graph. */
+    captureSelectedText(): SelectionCopySnapshot | null;
     scrollBy(lines: number, now?: number): boolean;
     scrollTo(position: number, now?: number): boolean;
     scrollToEnd(now?: number): boolean;

package/dist/ui/components/transcript-viewport.js

@@ -1,7 +1,8 @@
+import { MAX_COPY_ROWS, MAX_COPY_SOURCE_UNITS, selectionCopyLineContent, selectionCopyRowText } from "./selection-copy.js";
 import { isThumbRow, scrollbarGeometry, scrollbarPresentation, } from "./scrollbar.js";
 import { backgroundSgrSpan, overlaySpan } from "./spans.js";
 import { faint, truncateToWidth, displayWidth, stripAnsi } from "./text.js";
-import { extendTextSelection, orderedTextSelection, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, usefulTextLineContent, } from "./text-selection.js";
+import { extendTextSelection, orderedTextSelection, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, } from "./text-selection.js";
 const CONTROL_STYLE_RESET = "\u001b]8;;\u001b\\\u001b[0m";
 const IDENTITY_ROW = (row) => row;
 const DEFAULT_CONFIG = {
@@ -33,6 +34,8 @@ export class TranscriptViewport {
     #selection;
     #selectionClick;
     #selectionRevision = 0;
+    #copyableSelection = false;
+    #copyableRow;
     #paintedRowCache = new Map();
     #baseRowCache = new Map();
     #selectedRowCache = new Map();
@@ -44,6 +47,7 @@ export class TranscriptViewport {
     #selectableDocumentRowCount = 0;
     #promptAnchors = [];
     #contentWidth = 0;
+    #selectionWidth = 0;
     #frameId = 0;
     #frame = null;
     get scrollTop() { return this.#scrollTop; }
@@ -93,6 +97,7 @@ export class TranscriptViewport {
         this.#selection = pressed.selection;
         this.#selectionClick = pressed.click;
         this.#selectionRevision += 1;
+        this.#updateCopyableSelection();
         return true;
     }
     extendSelection(column, viewportRow, now = Date.now(), autoScroll = true) {
@@ -113,8 +118,8 @@ export class TranscriptViewport {
         const visibleRow = clamp(viewportRow, 1, viewportHeight);
         const line = clamp(this.#scrollTop + visibleRow - 1, 0, lastSelectableLine);
         const targetColumn = selection.fullRow
-            ? textSelectionLineExtendColumn(selection, line, this.#contentWidth)
-            : clamp(column, 1, this.#contentWidth);
+            ? textSelectionLineExtendColumn(selection, line, this.#selectionWidth)
+            : clamp(column, 1, this.#selectionWidth);
         const point = selection.fullRow
             ? { line, column: targetColumn }
             : textSelectionPointAt(line, targetColumn, this.#documentRows[line] ?? "");
@@ -122,6 +127,7 @@ export class TranscriptViewport {
         if (next !== selection) {
             this.#selection = next;
             this.#selectionRevision += 1;
+            this.#updateCopyableSelection();
         }
         return true;
     }
@@ -136,6 +142,8 @@ export class TranscriptViewport {
         if (this.#selection === undefined)
             return false;
         this.#selection = undefined;
+        this.#copyableSelection = false;
+        this.#copyableRow = undefined;
         this.#selectionRevision += 1;
         return true;
     }
@@ -143,7 +151,39 @@ export class TranscriptViewport {
         const selection = orderedTextSelection(this.#selection);
         if (selection === undefined)
             return null;
-        return textSelectionText(selection, this.#documentRows.slice(0, this.#selectableDocumentRowCount), line => this.#lineContentAt(line));
+        const endLine = Math.min(selection.end.line, this.#selectableDocumentRowCount - 1);
+        return textSelectionText({ ...selection, end: { line: endLine, column: endLine === selection.end.line ? selection.end.column : Number.MAX_SAFE_INTEGER } }, this.#documentRows, line => this.#lineContentAt(line));
+    }
+    /** Captures selected source references, never the entire mutable transcript or prompt graph. */
+    captureSelectedText() {
+        if (!this.#copyableSelection)
+            return null;
+        const started = performance.now();
+        const selection = orderedTextSelection(this.#selection);
+        if (selection === undefined)
+            return null;
+        const start = selection.start.line;
+        const end = Math.min(selection.end.line, this.#selectableDocumentRowCount - 1, this.#documentRows.length - 1);
+        if (end < start)
+            return null;
+        const normalized = {
+            start: { line: 0, column: selection.start.column },
+            end: { line: end - start, column: end === selection.end.line ? selection.end.column : Number.MAX_SAFE_INTEGER },
+        };
+        const rejected = () => ({ selection: normalized, revision: this.#selectionRevision, rows: [], sourceUnits: 0, captureMs: performance.now() - started, rejected: "size" });
+        if (end - start + 1 > MAX_COPY_ROWS)
+            return rejected();
+        const rows = [];
+        let sourceUnits = 0;
+        for (let line = start; line <= end; line++) {
+            const text = this.#documentRows[line] ?? "";
+            sourceUnits += text.length;
+            if (sourceUnits > MAX_COPY_SOURCE_UNITS)
+                return rejected();
+            const prompt = this.#promptKindAt(line);
+            rows.push({ text, ...(prompt === undefined ? {} : { prompt }) });
+        }
+        return { selection: normalized, revision: this.#selectionRevision, rows, sourceUnits, captureMs: performance.now() - started };
     }
     scrollBy(lines, now = Date.now()) {
         if (this.#maxScroll <= 0 || lines === 0)
@@ -214,6 +254,8 @@ export class TranscriptViewport {
         if (this.#selection !== undefined)
             this.#selectionRevision += 1;
         this.#selection = undefined;
+        this.#copyableSelection = false;
+        this.#copyableRow = undefined;
         this.#selectionClick = undefined;
         this.#paintedRowCache.clear();
         this.#baseRowCache.clear();
@@ -224,6 +266,7 @@ export class TranscriptViewport {
         this.#selectableDocumentRowCount = 0;
         this.#promptAnchors = [];
         this.#contentWidth = 0;
+        this.#selectionWidth = 0;
         this.clearTransient();
         this.#frame = null;
     }
@@ -282,6 +325,10 @@ export class TranscriptViewport {
         this.#selectableDocumentRowCount = clamp(input.selectableDocumentRowCount ?? input.documentRows.length, 0, input.documentRows.length);
         this.#promptAnchors = input.promptAnchors;
         this.#contentWidth = contentWidth;
+        // Invariant: controls reserve the rail column, but source text beneath it
+        // remains reachable by a drag already owned by transcript selection.
+        this.#selectionWidth = width;
+        this.#updateCopyableSelection();
         const paintDocumentRow = input.paintDocumentRow ?? IDENTITY_ROW;
         const cacheLimit = Math.max(32, viewportHeight * 6);
         trimCache(this.#paintedRowCache, cacheLimit);
@@ -304,10 +351,13 @@ export class TranscriptViewport {
         const stickyActive = governing !== null && governing.firstRow < this.#scrollTop;
         if (stickyActive && visible.length > 0) {
             const quiet = this.#scrollTop > governing.lastRow;
-            // Compatibility: sticky prompts use the same normal/hover surface roles as the bottom
-            // control. Hover always starts from the full source row, so a quiet prompt
-            // becomes prominent again with its timestamp intact.
-            const source = cachedString(this.#paintedRowCache, `${paintId}\u0000${governing.sourceRow}`, cacheLimit, () => paintDocumentRow(governing.sourceRow));
+            // Compatibility: only non-hovered prominent rows may retain source metadata roles.
+            // Quiet and hover keep the established full-row styling; anchors without a
+            // variant retain their existing presentation in every state.
+            const sourceRow = !quiet && !this.#stickyHovered
+                ? governing.prominentSourceRow ?? governing.sourceRow
+                : governing.sourceRow;
+            const source = cachedString(this.#paintedRowCache, `${paintId}\u0000${sourceRow}`, cacheLimit, () => paintDocumentRow(sourceRow));
             if (!source.reused)
                 paintRecomputedRows.add(0);
             const sticky = theme.sticky(source.value, this.#stickyHovered);
@@ -345,7 +395,7 @@ export class TranscriptViewport {
                 const glyph = thumb ? presentation.thumbGlyph : presentation.trackGlyph;
                 railCell = thumb ? theme.thumb(glyph, this.#railHovered || this.#railDragging) : theme.track(glyph);
             }
-            const final = cachedString(this.#finalRowCache, `${width}\u0000${railCell}\u0000${selected.value}`, cacheLimit, () => railCell.length === 0 ? selected.value : overlaySpan(selected.value, width - 1, width, railCell));
+            const final = cachedString(this.#finalRowCache, `${width}\u0000${railCell}\u0000${selected.value}`, cacheLimit, () => railCell.length === 0 ? selected.value : overlaySpan(selected.value, width - 1, width, railCell, { inheritStartStyle: true }));
             rowRecomputed ||= !final.reused;
             visible[row] = final.value;
             (rowRecomputed ? recomputedRows : reusedRows).push(row + 1);
@@ -516,22 +566,49 @@ export class TranscriptViewport {
         this.#functionIds.set(value, id);
         return id;
     }
+    #updateCopyableSelection() {
+        const selection = orderedTextSelection(this.#selection);
+        if (!selection) {
+            this.#copyableSelection = false;
+            this.#copyableRow = undefined;
+            return;
+        }
+        const end = Math.min(selection.end.line, this.#selectableDocumentRowCount - 1);
+        if (end !== selection.start.line) {
+            this.#copyableSelection = end > selection.start.line;
+            this.#copyableRow = undefined;
+            return;
+        }
+        const text = this.#documentRows[end] ?? "";
+        const prompt = this.#promptKindAt(end);
+        const from = selection.start.column, to = end === selection.end.line ? selection.end.column : Number.MAX_SAFE_INTEGER;
+        const cached = this.#copyableRow;
+        if (cached?.text === text && cached.prompt === prompt && cached.from === from && cached.to === to) {
+            this.#copyableSelection = cached.value;
+            return;
+        }
+        // Compatibility: learn whether an actual range is empty while presenting selection, not on Ctrl+C.
+        const value = selectionCopyRowText({ selection: { start: { line: 0, column: from }, end: { line: 0, column: to } } }, { text, ...(prompt === undefined ? {} : { prompt }) }, 0).length > 0;
+        this.#copyableRow = { text, prompt, from, to, value };
+        this.#copyableSelection = value;
+    }
     #lineContentAt(line) {
-        const plain = stripAnsi(this.#documentRows[line] ?? "");
-        const prompt = this.#promptAnchors.find(anchor => line >= anchor.firstRow && line <= anchor.lastRow);
-        if (prompt !== undefined) {
-            if (line === prompt.firstRow) {
-                const timestamp = /\s+\d{2}:\d{2}\s*$/.exec(plain);
-                if (timestamp !== null)
-                    return usefulTextLineContent(plain.slice(0, timestamp.index), 3);
-            }
-            return usefulTextLineContent(plain, 3);
+        return selectionCopyLineContent(this.#documentRows[line] ?? "", this.#promptKindAt(line));
+    }
+    #promptKindAt(line) {
+        // Performance: anchors are ordered, disjoint source ranges; do not scan off-screen prompts per copied row.
+        let low = 0, high = this.#promptAnchors.length - 1;
+        while (low <= high) {
+            const middle = (low + high) >>> 1;
+            const anchor = this.#promptAnchors[middle];
+            if (line < anchor.firstRow)
+                high = middle - 1;
+            else if (line > anchor.lastRow)
+                low = middle + 1;
+            else
+                return line === anchor.firstRow ? "first" : "continuation";
         }
-        const from = plain.trim().length === 0 || (plain.startsWith(" ") && !plain.startsWith("  ")) ? 2 : 1;
-        const content = usefulTextLineContent(plain, from);
-        if (plain.trim().length === 0)
-            return { from, to: from + 1 };
-        return content;
+        return undefined;
     }
 }
 function selectionRangeForLine(selection, documentLine, selectableRowCount, width) {

package/dist/ui/components/visible-hyperlinks.js

@@ -1,6 +1,38 @@
 import { displayWidth } from "./text.js";
-const TOKENS = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|[^\u001b]+|\u001b/gu;
-const LINK = /^\u001b\]8;[^;\u0007\u001b]*;([^\u0007\u001b]*)(?:\u0007|\u001b\\)$/u;
+/** Linear tokenization: a valid large OSC target must not exhaust the regular-expression engine's stack. */
+function* rowTokens(line) {
+    const oscBoundary = /[\u0007\u001b]/g;
+    for (let offset = 0; offset < line.length;) {
+        if (line.charCodeAt(offset) !== 27) {
+            const next = line.indexOf("\u001b", offset);
+            const end = next < 0 ? line.length : next;
+            yield line.slice(offset, end);
+            offset = end;
+            continue;
+        }
+        let end = offset + 1;
+        if (line[offset + 1] === "[") {
+            let cursor = offset + 2;
+            while (line.charCodeAt(cursor) >= 0x30 && line.charCodeAt(cursor) <= 0x3f)
+                cursor++;
+            while (line.charCodeAt(cursor) >= 0x20 && line.charCodeAt(cursor) <= 0x2f)
+                cursor++;
+            if (line.charCodeAt(cursor) >= 0x40 && line.charCodeAt(cursor) <= 0x7e)
+                end = cursor + 1;
+        }
+        else if (line[offset + 1] === "]") {
+            // Performance: search for one boundary, not a quantified alternation over the entire URI.
+            oscBoundary.lastIndex = offset + 2;
+            const boundary = oscBoundary.exec(line);
+            if (boundary?.[0] === "\u0007")
+                end = boundary.index + 1;
+            else if (boundary !== null && line[boundary.index + 1] === "\\")
+                end = boundary.index + 2;
+        }
+        yield line.slice(offset, end);
+        offset = end;
+    }
+}
 const SGR = /^\u001b\[[\d;:]*m$/u;
 const SEMANTIC_ZONE = /^\u001b\]133;[ABC](?:\u0007|\u001b\\)$/u;
 // Platform: this is a conservative cleanup detector, NOT a link-activation
@@ -22,14 +54,14 @@ export function readVisibleHyperlinks(line, widthOf = displayWidth) {
         }
         active = undefined;
     };
-    for (const match of line.matchAll(TOKENS)) {
-        const token = match[0];
+    for (const token of rowTokens(line)) {
         if (token.startsWith("\u001b")) {
-            const link = LINK.exec(token);
-            if (link !== null) {
+            const separator = token.startsWith("\u001b]8;") ? token.indexOf(";", 4) : -1;
+            if (separator !== -1) {
                 finish();
-                if (link[1])
-                    active = { from: column, target: link[1] };
+                const target = token.slice(separator + 1, token.endsWith("\u0007") ? -1 : -2);
+                if (target)
+                    active = { from: column, target };
             }
             else if (!SGR.test(token) && !SEMANTIC_ZONE.test(token))
                 replaySafe = false;

package/docs/architecture/response-copy-delivery.md

@@ -0,0 +1,83 @@
+# Clipboard copy and paste delivery
+
+## Compatibility map and baseline
+
+Accepted change: `fix-response-copy-freeze`, specification PRs #359 and #365. Initial expanded implementation base: `71e97ab6`; the review checkpoint is rebased onto `26b51b0b`, retaining the accepted timestamp, rendering, and truthful right-edge selection changes.
+
+- Bare A1 response selection: `SessionViewportController.handlePreInput` -> `TranscriptViewport.selectedText` -> selection clear/render request -> shell OSC 52 -> runtime's underlying terminal writer. The prompt native clipboard queue is not on this route.
+- Prompt copy/cut, workflow `/copy`, tree copy, and A1-owned paste: one owned write coordinator with literal prompt/workflow payloads and transaction-specific predecessor capture. A paste admitted during a pending write observes that write's result; an independent paste after a settled failure performs a fresh read. Preserve prompt-selection precedence, `/copy`, and terminal-provided paste.
+- Standalone paste: ordinary editor reservation -> clipboard acquisition -> text/path classification or existing image preparation -> replacement of that reservation. Native reads, format detection and command fallbacks run in a child, not the UI. Text/path classification uses a worker within that child; a blocked probe falls back to the same acquired text after one second and cannot strand the UI. Image preparation reuses the existing image worker within the killable child and preserves all image limits.
+- Terminal-provided paste: small non-path text has a fixed synchronous bound (at most 1,000 source code units); larger or path-shaped content uses the same isolated preparation policy, without a redundant native read. The owned framer keeps only a delimiter-sized lookbehind and bounded body fragments rather than repeatedly joining a growing body.
+- Modal/replacement input: the current base permits owned transcript selection behind a modal outside its painted bounds. Preserve that accepted routing rather than restoring the older blanket overlay bypass. `/copy` and Ctrl+C without transcript selection retain their existing command/cancellation handlers.
+- `keep-streaming-ui-responsive-during-selection` owns general selection/wheel/preparation optimization. This change owns selected-range extraction, copy-clearing damage, delivery and its lifecycle. Shared row caches and input coordination remain authoritative.
+- Pinned `a1 pi`, upstream components, installed dependencies, and terminal-owned selection remain unchanged controls.
+
+A generated probe on Windows Node 24.16.0 copied the same eight-character range from 100 and 100,000 rows. Before remediation, selected-text extraction read 101 and 100,001 source rows respectively (about 0.16 and 20.00 ms in that instrumented run). Proxy access counting exaggerates absolute timings; row counts establish the unnecessary whole-history slice. These measurements do **not** reproduce or establish the cause of the user's whole-UI freeze. Clipboard contention, terminal/version, freeze duration, and whether only physical painting stops remain unconfirmed. No clipboard payload or private session content is captured in evidence.
+
+## Lifetimes, limits, and recovery
+
+- Copy: 5-second admission deadline, one executing request and one newest pending request, at most 16 MiB UTF-8 text. Source snapshots retain only selected rows, capped at 65,536 rows and 32 Mi UTF-16 code units; they do not keep an obsolete whole-transcript graph.
+- Paste: eight distinct admitted requests, a 5-second acquisition budget including the captured write wait, and a 15-second deadline through insertion. A canceled executor counts against capacity until its stop fence. Image conversion has one process-wide slot. Copy supersession is deliberately not used for paste edits.
+- Text transfer: 16 MiB UTF-8 cap; IPC fragments are at most 16,384 code units and preserve surrogate pairs. The receiver acknowledges each fragment. Prepared large text is stored behind the existing compact chip rather than inserted as millions of editor characters. Existing source-image, pixel, encoded-output and attachment-count limits remain unchanged.
+- Clipboard executors have a 250 ms stop grace. POSIX command fallbacks share the paste helper's isolated process group; strict command reads use a forceful kill signal. Unconfirmed executor termination retains its capacity instead of allowing unbounded replacements or late A1-controlled writes. No helper inherits the UI terminal or places clipboard payloads in argv, temporary files, or logs.
+- Local copy prefers native delivery outside the terminal. OSC 52 uses the existing writer only on a non-blocking supported output route and is capped at a complete 64 KiB control, or a lower advertised limit. Submission is not clipboard acknowledgment. Remote/multiplexed sessions never silently read or write a different host's clipboard. Native Ctrl+V acquisition is unavailable when only the remote terminal owns the desired clipboard; normal terminal-provided paste remains supported.
+- URL-chip decoration: at most 65,536 UTF-8 bytes of added OSC 8 metadata per editor render pass across rows and repeated occurrences, including opening/closing pairs and cleanup closes. Targets that do not fit are omitted whole before control construction; a UTF-16 length precheck avoids scanning huge backing values. The budget resets each pass. Full chip data, atomic editing and exact copy/history/submission expansion remain intact; ordinary in-budget links retain their targets. Terminal automatic URL recognition is separate from explicit metadata.
+- Path-list presentation: the isolated classifier budgets 4,096 UTF-16 units per paste for existing individual tags plus 20 suffix-reserve units per occurrence. Over-budget lists use one existing text-paste chip backed by all classified full paths concatenated in order, including repetitions, without extra separators or re-normalization. No individual members are adopted into the UI before compaction. Small lists retain their file/folder/image-file chips; failed/timed-out classification retains the existing original-text fallback. Existing draft/history chips and the synchronous compatibility classifier are unchanged.
+- Reservations protect later typing, distinct paste order, selection replacement and undo/redo. Cancellation retires the reservation from history snapshots. Provisional chip ownership prevents failed/canceled pastes retaining unused backing data or deleting a chip reused by another successful paste.
+
+## Optional local diagnostics
+
+Set `A1_CLIPBOARD_DIAGNOSTICS` to an existing-parent local file path to capture metadata in bare A1. It is disabled by default and ignored by comparison/settings-free compositions. Records include copy/paste phases, runtime receipt/composition/write phases, and a 100 ms heartbeat. At most 128 scalar-only rows and one newest pending asynchronous disk snapshot are retained. No copied/pasted text, paths, image data, encoded payloads, raw errors, or extra fields from event objects are serialized. Disk errors remain silent and disk completion is never awaited by input or teardown.
+
+Diagnostic accounting includes the transient incoming copy before its older pending predecessor is superseded (eight pastes plus three transient copy records). Paste-helper exit no longer prematurely clears insertion accounting: request cleanup is recorded after the insertion lifetime. Literal workflow copies do not invent transcript selection-clear events. Composition tests verify explicit/environment opt-in, comparison/settings-free exclusion, destination precedence, and disposal even when construction or shell teardown fails. Request identifiers are local to their source; runtime identifiers are input revisions and negative framing identifiers identify terminal input observations. `pendingBytes` is observed payload/source accounting, not native heap measurement.
+
+A healthy heartbeat with stalled visible painting differs from a blocked application event loop. These diagnostics support attribution but do not themselves establish the user's physical-terminal root cause. The baseline's main-thread path classifier and write/paste barriers are investigated independently of OSC 52.
+
+## URL presentation evidence and approved refinement
+
+Before the approved refinement, a source made from `https://example.com/` plus `16 * 1024 * 1024 - 64` ASCII characters was within the text limit and produced a 46-character editor chip, but its full OSC 8 target produced a 16,777,367-byte terminal write. The earlier regular-expression tokenization overflowed its stack; linear tokenization removed that crash but a subsequent headless run still measured a 305 ms maximum application timer gap. The 4 MiB control measured a 78 ms gap and a 4,194,519-byte write. These observations do not identify the user's physical freeze or measure terminal painting.
+
+With PR #385 open, the user explicitly approved revising its specs and implementation to preserve full URLs and chips while omitting oversized explicit hyperlink metadata. `EditorHyperlinkBudget` now enforces the per-pass limit before OSC construction, including repeated occurrences, multibyte targets, and row cleanup. The former observational-only probe now asserts bounded output, exact expanded submission/history, following typing, and no duplicate native read for bracketed paste; unit tests also check exact copy expansion and rejection without whole-target byte counting.
+
+One augmented synthetic run, including content checks and following typing, recorded 6,563 maximum terminal-write bytes for each near-limit route, with roughly 48 ms native / 55 ms bracketed maximum timer gaps and 632 / 647 ms overall test-observed insertion/check time. This is not an identical timing workload to the earlier probe, a physical latency distribution, or by itself evidence for task 5.3's entire large-text/path/image matrix. Deterministic metadata/output limits gate the regression; broader integrated evidence is recorded below, and physical acceptance is still required.
+
+## Generated baseline and lifecycle evidence
+
+The generated baseline covers 10 and 1,000 historical response blocks, idle and streaming, copy-only, standalone external-value paste-only, and copy/paste overlap. Each case runs once in a fresh shell and twice subsequently (36 samples). Helpers still start per request; warm-shell is not a claim of native-helper reuse. Copy uses the production isolated preparer with an injected clipboard sink; paste uses a supplied external-value reader and production isolated preparation. Neither is a physical clipboard or terminal measurement. Records separate input progress, copy phases, paste predecessor/acquisition/classification/insertion phases, composition/write counts, and timer progress, without payloads.
+
+One focused run observed the following ranges across 12 samples per operation:
+
+| Operation | Following-input handling (ms) | Completion/check time (ms) | Maximum timer gap per sample (ms) |
+| --- | --- | --- | --- |
+| Copy | 5.5–18.0 | 245.1–258.6 | 16.4–20.2 |
+| Independent paste | 4.1–8.3 | 311.8–346.6 | 16.9–21.3 |
+| Combined | 5.4–13.1 | 544.7–601.0 | 16.3–20.4 |
+
+Generated 2 MiB single-line, 100,000-line text, and 1,024-square image controls retained compact presentation and exact text/valid image semantics, with maximum write sizes of 6,563 bytes and timer gaps of approximately 17/18/27 ms in that run. These timings are observations, not shared-CI wall-clock gates or physical input-to-paint distributions.
+
+Lifecycle evidence covers 12 sequential real-helper copy/paste cycles, excess-admission rejection and full eight-helper capacity recovery after cancellation, and eight image helpers sharing exactly one conversion slot. Every observed child exited/disconnected and used ignored terminal descriptors. A reentrant acquisition-cancellation test found and fixed a conversion grant after cancellation. Session-shell tests preserve newer selections and drafts after late copy/text/image completion and verify alternate-screen restoration/no subsequent writes on disposal. Markdown render-call counters remain unchanged during copy-clear, typing, and wheel work on settled content. Cold emitted-helper/package tests remain separate from these source-helper tests.
+
+## Approved compact path-list refinement
+
+Indexed atomic segmentation uses the existing grapheme segmenter's boundary lookup rather than enumerating all discarded chip-interior graphemes. Equivalence tests cover Unicode boundaries and the existing iterable fallback; a structural test requires exactly two boundary lookups per chip rather than full enumeration. No pinned-source file or installed dependency is modified.
+
+A 12,000 short-name path-list observation improved from roughly 208 ms to 109 ms maximum timer gap. However, 6,000 paths with 160-character filename stems still produced 1,014,006 editor characters from 1,409,999 input bytes and a roughly 1,387 ms timer gap. Exact expanded paths were retained and writes remained small, but that application-side presentation work was unacceptable.
+
+The user approved the compact-path-list spec/code refinement in #385. `path-chip-presentation.ts` now shares tag formatting with adoption and selects a compact existing text-paste representation in the isolated preparer. The same 6,000-path source now produces 30 editor characters (including following typing), with approximately 18.3/18.5 ms observed timer gaps for native/bracketed routes in one focused run. A near-16 MiB path candidate (16,777,119 source bytes) exercised the one-second safe classification fallback, retaining all original text behind a 29-character presentation; observed gaps were about 16.8/20.7 ms. All four maximum writes were 6,563 bytes. These augmented workloads are synthetic observations, not physical acceptance.
+
+The former observational path probes now gate compact representation, exact expanded content, following typing, undo/redo, no duplicate native read, and bounded terminal output. Unit tests cover exact budget boundaries, Unicode/duplicates, shared file/folder/image-file framing, stopping tag construction at the allowance, exact literal path expansion for copy/history/submission, no provisional member chips, and stale-result cancellation. Emitted-helper tests prove compaction before UI transfer and that an invalid suffix falls back to the whole original text rather than a classified prefix.
+
+## Integrated automated matrix
+
+The refinement checkpoint passed 597 tests across 24 focused suites plus 35 clipboard/image/preparation/package tests (632 total across 27 suites), with build and typecheck. Coverage supporting tasks 5.3, 5.8, and 6.1 includes:
+
+- Selected-range/transport/coordinator tests: small and large exact payloads, Unicode, bounded source/encoding work, copy supersession, stalls/deadlines, backpressure, destination selection, late-side-effect fences, and cleanup.
+- Paste executor/client, chip lifecycle, and image tests: standalone sources, 16 MiB boundary/rejection, actual blocked probes/native work/command descendants, format/read/preparation failures, recovery, reserved ordering, cancellation/undo, image safety limits and serialized conversion.
+- Shell/editor/controller and diagnostics tests: copy-only/paste-only/combined cold/warm idle/streaming histories, native/bracketed text/URL/path/image presentation, following input/scroll/output, overlay ownership, comparison compatibility, bounded metadata/privacy, and session teardown.
+- Cold emitted helper/image-worker and package-inventory tests: production helper resolution, native fixture read/write, compact and invalid-prefix path lists, images, and included runtime modules. No installed dependency or pinned source is patched.
+
+This completes the integrated automated work, not supported-route physical certification. Required CI must run on the new candidate; tasks 4.3 and 7 remain dependent on actual terminal/clipboard evidence and explicit acceptance.
+
+## Acceptance
+
+Physical acceptance is pending. Automated scheduling and terminal replay cannot certify physical clipboard responsiveness. Test the exact candidate with repeated response Ctrl+C, independent Ctrl+V using content copied outside A1, and combined copy/paste, while idle and streaming. Check copied values in another application and pasted values in the prompt. Record terminal/version, topology, geometry, cold/warm behavior, subsequent-input latency and animation separately from clipboard completion latency. No Esc or other recovery action counts as a fix. Any repeated freeze fails acceptance; native Linux clipboard persistence and remote terminal behavior also require applicable physical evidence rather than inference from mocked transport tests.

package/docs/architecture/tool-image-presentation.md

@@ -0,0 +1,62 @@
+# Owned tool image presentation
+
+## Why this source adaptation exists
+
+The accepted `preserve-agent-content-rendering` design permits a minimal attributed content adaptation when the pinned public component cannot preserve supported behavior. The user explicitly approved this image-lifecycle adaptation after its failing baseline.
+
+Pi 0.84.2's `ToolExecutionComponent` stores converted images by array index. Replacing a JPEG with another JPEG or a PNG can therefore display the previous pixels. Conversion failure has no visible fallback under Kitty. Its public API exposes neither conversion-cache reset nor mount disposal. Reconstructing the entire component on each attachment change would discard extension renderer state and asynchronous previews.
+
+`src/integrations/pi/components/upstream/components/tool-execution.ts` retains that tool shell's composition, lifecycle, fallback, expansion and extension context. Actual built-in renderers still come from the public `create*ToolDefinition` factories; custom renderers receive the original content, MIME types, bytes, details, arguments, state and previous components. The owned shell never edits installed Pi, accesses private fields, patches prototypes, upgrades dependencies, or modifies the explicit Pi comparison route.
+
+The source unit is from MIT-licensed repository <https://github.com/earendil-works/pi>, commit `914cf1472e715297caa30db4b9535d534a9eb718`, path `packages/coding-agent/src/modes/interactive/components/tool-execution.ts`. The source-map hash and local port hash are recorded in `config/baselines/pinned-pi-source-port-ledger.json`. Its small generic-output helper follows `core/tools/render-utils.ts::getTextOutput` and `utils/shell.ts::sanitizeBinaryOutput` from the same package; Node's public `stripVTControlCharacters` replaces the private ANSI helper. The public definition factories replace the private `createAllToolDefinitions` lookup. Public theme and TUI imports are mapped to the existing owned boundaries. No tool filesystem implementation or renderer layout is copied.
+
+## Image ownership and bounded work
+
+`ToolImagePresentation` owns only current image presentation. It shares immutable source strings rather than copying or hashing accumulated image data per chunk. Equal current sources share a conversion entry; entries disappear when their source is removed. The existing admission limits remain 16 references and 20 MiB per image; derived PNGs also receive the per-image limit before retention.
+
+One conversion is active per mounted tool. The waiting set is the newest current source set, not an unbounded queue of superseded snapshots. Hidden images and non-Kitty protocols do not start conversions. Work removed before codec entry is skipped. A public codec call already in progress cannot be cancelled; its eventual result is discarded if the source or mount is obsolete. This limitation is explicit, not claimed as cancellable worker execution.
+
+Pending Kitty conversion has a visible `[Image converting: ...]` marker. Failure, rejection, or oversized converted bytes produces `[Image unavailable: ...]`, without exposing codec diagnostics or changing the operation outcome. Converted pixels never replace the original payload passed to extension renderers. PNG and iTerm presentation use the actual public `Image` component. Hidden and no-image-capability text presentation matches pinned Pi.
+
+Rebuild/disposal releases image ownership and invalidates the previous mount. Reentrant renderer invalidation is suppressed during synchronous reconstruction; valid asynchronous callbacks still request the existing scheduler and update presentation revision, not semantic revision.
+
+## Terminal row boundaries
+
+Kitty APC payloads are zero-column opaque controls, not displayable base64 text. Neutral width/truncation/copy handling preserves or excludes the complete control as appropriate. Rail overlays preserve each image transfer once rather than replaying it as an SGR style. The runtime width guard excludes complete Kitty payloads but still checks all ordinary columns around them; it does not exempt an arbitrary image-bearing row from width validation.
+
+This correction does not introduce an ANSI parser, change link detection, relax text width limits, or change terminal erase policy. Image placement, scaling and clipping remain subject to the existing public Image and viewport visibility policies; physical partially clipped-image behavior is not established by a component byte comparison.
+
+## Evidence
+
+- `transcript-image-conversion.test.ts`: independent pinned stale-cache baseline, JPEG replacement, PNG replacement, hidden/non-Kitty parity, failed-conversion fallback and real scheduled Kitty publication at unchanged semantic revision.
+- `tool-image-presentation.test.ts`: current-source sharing, one active conversion, superseded bursts, removed/disposed callbacks, hidden/iTerm work avoidance, rejection and size fallback without retry loops.
+- `tool-shell-parity.test.ts`: independent actual pinned read/bash/edit/write/grep/find/ls and generic rendering at widths 40/80/192, partial/final/error states, expansion, binary text, and extension default/self shells with original inputs and stable renderer state.
+- Existing attachment-ownership, payload-limit, content-retention and shell tests remain non-regression gates. The wrapped-URL counterexample remains explicitly unresolved under issue #353.
+
+These are automated content and ownership checks, not Windows Terminal visual acceptance. The broader change stays open until scheduled-producer evidence, required CI, and exact-candidate user review satisfy its remaining tasks.
+
+## Upstream license notice
+
+```text
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/docs/ci-release-runbook.md

@@ -98,7 +98,23 @@ node scripts/release/report-resource-sensitive-validation.mjs --repeats 3 --outp
 
 ## Pull request integration
 
-`Development validation required` remains the merge gate for every pull request. For code changes, it also requires a dedicated Defender-enabled exact-package startup matrix on Windows Node 22 and 24. Each matrix lane runs the package-install startup scenarios once: a failed budget remains failed and is never retried to obtain a warmed result. Both post-update profiles must reach input-ready state within five seconds, and both warm profiles must remain within three seconds.
+`Development validation required` remains the merge gate for every pull request. For applicable code changes, it requires the dedicated Defender-enabled exact-package startup lane on Windows Node 22. Development validation (including manual dispatch) does not schedule a Windows Node 24 startup lane. The Node 22 lane retains the complete package-install, image preparation/package, and durable-history checks plus startup evidence artifacts. A missing, cancelled, failed, or unexpectedly skipped required startup result still blocks the aggregate; documentation-only, version-only, and draft exemptions are unchanged.
+
+| Startup runtime | Development validation (PR or manual) | Nightly/release validation | Manual Full regression |
+| --- | --- | --- | --- |
+| Windows Node 22 | Required for applicable changes | Retained | Retained |
+| Windows Node 24 | Not scheduled | Retained | Retained |
+
+Each selected startup lane runs the package-install scenarios once: a failed budget remains failed and is never retried to obtain a warmed result. Both post-update profiles must reach input-ready state within five seconds, and both warm profiles must remain within three seconds. Node 24 runtime support, other PR jobs, Defender, and publication gates are unchanged. Full validation retains every deferred startup, image, and history test through its existing suite owners.
+
+The trade-off is delayed detection: a Node-24-specific regression can reach `develop` before nightly catches it. A green Node 22 PR check does not certify Node 24, and nightly failure still blocks its publication. When Node 24 feedback is needed before nightly, explicitly request the non-publishing Full regression workflow for the desired branch or tag:
+
+```sh
+gh workflow run full-regression.yml --ref <branch-or-tag>
+```
+
+Record the run's resolved source SHA and package evidence; do not substitute an unrelated historical green run for current-head acceptance. This full run is a deliberate additional operation, not an automatic step for every PR.
+
 Documentation auto-merge reads the complete GitHub changed-file response and arms
 squash auto-merge for an eligible pull request while required validation is pending;
 branch protection prevents integration until `Development validation required`
@@ -106,7 +122,7 @@ succeeds. If validation finishes before auto-merge can be armed and GitHub alrea
 reports the pull request clean, the reconciler squash-merges only the validated head
 SHA. Every current and renamed-from path must be under `openspec/**`, under
 `docs/**`, or exactly the root `README.md`. Eligible pull requests must use a
-non-draft branch in this repository and target `develop`.
+non-draft branch in this repository and target `develop`. Implementation-associated PRs and newly introduced active OpenSpec changes are held for manual integration even when their diff is documentation-only. Body edits trigger reconciliation; removing a marker cannot bypass the base/head tree check. Standalone existing-change revisions and archive moves remain eligible.
 
 The exact allowlist covers maintained OpenSpec, architecture, feature, manual,
 runbook, and root README documentation. Other root Markdown files, `LICENSE`,
@@ -119,11 +135,7 @@ inventoried OpenSpec occurrence fails that pull request rather than a later code
 request. A legitimate generated baseline update remains outside the allowlist and
 follows the manually accepted mixed/code path.
 
-A specification request lands as an OpenSpec-only pull request. Implementation
-starts only after that specification merges and the maintainer explicitly requests
-it, in a fresh worktree and pull request based on updated `origin/develop`. Every
-code/operational pull request remains open after CI until the maintainer validates it
-locally and explicitly authorizes manual integration.
+A new implementation-bound specification starts as OpenSpec-only artifacts in one draft PR. Explicit approval to implement continues in that same worktree, branch, history, and PR; the plan does not merge first. Approved refinements reconcile the planning artifacts before code changes. Make the completed PR ready for final review, but leave integration manual after CI, exact-head maintainer acceptance, and explicit merge authorization. Closing a rejected unmerged draft integrates and archives nothing; local unmerged cleanup still needs separate approval. Existing merged plans retain their legacy implementation PRs and require explicit reconciliation if rejected. See [delivery and archive handoff](openspec-archive-automation.md) for the version-2 link and legacy version-1 compatibility.
 
 ## Numbered development previews