@timurproko/a1 0.1.8-dev.560 → 0.1.8-dev.572

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

@@ -1,8 +1,8 @@
-import { MAX_COPY_ROWS, MAX_COPY_SOURCE_UNITS, selectionCopyLineContent, selectionCopyRowText } from "./selection-copy.js";
+import { MAX_COPY_SOURCE_UNITS } 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, } from "./text-selection.js";
+import { extendTextSelection, orderedTextSelection, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, usefulTextLineContent, } from "./text-selection.js";
 const CONTROL_STYLE_RESET = "\u001b]8;;\u001b\\\u001b[0m";
 const IDENTITY_ROW = (row) => row;
 const DEFAULT_CONFIG = {
@@ -35,7 +35,8 @@ export class TranscriptViewport {
     #selectionClick;
     #selectionRevision = 0;
     #copyableSelection = false;
-    #copyableRow;
+    // Invariant: exact unselected rows cover the latest visible base frame and dock.
+    #selectionRows = [];
     #paintedRowCache = new Map();
     #baseRowCache = new Map();
     #selectedRowCache = new Map();
@@ -78,19 +79,17 @@ export class TranscriptViewport {
     setStickyHovered(hovered) { this.#stickyHovered = hovered; }
     get selectionActive() { return this.#selection?.selecting === true; }
     get hasSelection() { return orderedTextSelection(this.#selection) !== undefined; }
-    pressSelection(column, viewportRow, now = Date.now()) {
-        const viewportHeight = this.#frame?.hits.viewportHeight ?? 0;
-        if (viewportRow < 1 || viewportRow > viewportHeight || column < 1 || column > this.#contentWidth)
-            return false;
-        const line = clamp(this.#scrollTop + viewportRow - 1, 0, Math.max(0, this.#documentRows.length - 1));
-        if (line >= this.#selectableDocumentRowCount)
+    pressSelection(column, frameRow, now = Date.now()) {
+        const frameHeight = this.#frame?.rows.length ?? 0;
+        if (frameRow < 1 || frameRow > frameHeight || column < 1 || column > this.#selectionWidth)
             return false;
+        const line = frameRow - 1;
         const pressed = pressTextSelection({
             line,
             column,
-            contentWidth: this.#contentWidth,
-            lineText: this.#documentRows[line] ?? "",
-            lineContent: this.#lineContentAt(line),
+            contentWidth: this.#selectionWidth,
+            lineText: this.#selectionRows[line] ?? "",
+            lineContent: usefulTextLineContent(this.#selectionRows[line] ?? ""),
             ...(this.#selectionClick === undefined ? {} : { previousClick: this.#selectionClick }),
             now,
         });
@@ -98,36 +97,35 @@ export class TranscriptViewport {
         this.#selectionClick = pressed.click;
         this.#selectionRevision += 1;
         this.#updateCopyableSelection();
+        if (this.#copyableSelection)
+            this.#followingEnd = false;
         return true;
     }
-    extendSelection(column, viewportRow, now = Date.now(), autoScroll = true) {
+    extendSelection(column, frameRow, now = Date.now(), autoScroll = true) {
         const selection = this.#selection;
-        const viewportHeight = this.#frame?.hits.viewportHeight ?? 0;
-        if (selection?.selecting !== true || viewportHeight <= 0 || this.#documentRows.length === 0)
+        const frameHeight = this.#frame?.rows.length ?? 0;
+        if (selection?.selecting !== true || frameHeight <= 0 || this.#selectionRows.length === 0)
             return false;
         // Performance: pointer motion updates only the endpoint; the shell's fixed-cadence timer
-        // owns edge scrolling. This option prevents high-rate motion reports from
-        // adding irregular extra rows between timer ticks.
-        if (autoScroll && viewportRow > viewportHeight)
+        // owns edge scrolling. Selection itself remains in visible-frame coordinates.
+        if (autoScroll && frameRow > frameHeight)
             this.scrollBy(1, now);
-        else if (autoScroll && viewportRow <= 1 && this.#scrollTop > 0)
+        else if (autoScroll && frameRow <= 1 && this.#scrollTop > 0)
             this.scrollBy(-1, now);
-        const lastSelectableLine = Math.min(this.#documentRows.length, this.#selectableDocumentRowCount) - 1;
-        if (lastSelectableLine < 0)
-            return false;
-        const visibleRow = clamp(viewportRow, 1, viewportHeight);
-        const line = clamp(this.#scrollTop + visibleRow - 1, 0, lastSelectableLine);
+        const line = clamp(frameRow - 1, 0, this.#selectionRows.length - 1);
         const targetColumn = selection.fullRow
             ? textSelectionLineExtendColumn(selection, line, this.#selectionWidth)
             : clamp(column, 1, this.#selectionWidth);
         const point = selection.fullRow
             ? { line, column: targetColumn }
-            : textSelectionPointAt(line, targetColumn, this.#documentRows[line] ?? "");
+            : textSelectionPointAt(line, targetColumn, this.#selectionRows[line] ?? "");
         const next = extendTextSelection(selection, point);
         if (next !== selection) {
             this.#selection = next;
             this.#selectionRevision += 1;
             this.#updateCopyableSelection();
+            if (this.#copyableSelection)
+                this.#followingEnd = false;
         }
         return true;
     }
@@ -136,6 +134,7 @@ export class TranscriptViewport {
             return false;
         this.#selection = releaseTextSelection(this.#selection);
         this.#selectionRevision += 1;
+        this.#updateCopyableSelection();
         return true;
     }
     clearSelection() {
@@ -143,7 +142,6 @@ export class TranscriptViewport {
             return false;
         this.#selection = undefined;
         this.#copyableSelection = false;
-        this.#copyableRow = undefined;
         this.#selectionRevision += 1;
         return true;
     }
@@ -151,39 +149,27 @@ export class TranscriptViewport {
         const selection = orderedTextSelection(this.#selection);
         if (selection === undefined)
             return null;
-        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));
+        const text = textSelectionText(selection, this.#selectionRows, line => usefulTextLineContent(this.#selectionRows[line] ?? ""));
+        return text.length === 0 ? null : text;
     }
-    /** Captures selected source references, never the entire mutable transcript or prompt graph. */
+    /** Captures only the selected visible frame text, never off-screen transcript history. */
     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)
+        const text = this.selectedText();
+        if (text === null)
             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 },
+            start: { line: 0, column: 0 },
+            end: { line: 0, 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 }) });
+        if (text.length > MAX_COPY_SOURCE_UNITS) {
+            return { literal: true, selection: normalized, revision: this.#selectionRevision, rows: [], sourceUnits: 0,
+                captureMs: performance.now() - started, rejected: "size" };
         }
-        return { selection: normalized, revision: this.#selectionRevision, rows, sourceUnits, captureMs: performance.now() - started };
+        return { literal: true, selection: normalized, revision: this.#selectionRevision, rows: [{ text }],
+            sourceUnits: text.length, captureMs: performance.now() - started };
     }
     scrollBy(lines, now = Date.now()) {
         if (this.#maxScroll <= 0 || lines === 0)
@@ -255,7 +241,7 @@ export class TranscriptViewport {
             this.#selectionRevision += 1;
         this.#selection = undefined;
         this.#copyableSelection = false;
-        this.#copyableRow = undefined;
+        this.#selectionRows = [];
         this.#selectionClick = undefined;
         this.#paintedRowCache.clear();
         this.#baseRowCache.clear();
@@ -328,7 +314,6 @@ export class TranscriptViewport {
         // 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);
@@ -337,16 +322,15 @@ export class TranscriptViewport {
         trimCache(this.#finalRowCache, cacheLimit);
         const paintId = this.#functionId(paintDocumentRow);
         const paintRecomputedRows = new Set();
-        const visible = documentRows
-            .slice(this.#scrollTop, this.#scrollTop + viewportHeight)
-            .map((row, index) => {
+        const visibleSource = documentRows.slice(this.#scrollTop, this.#scrollTop + viewportHeight);
+        while (visibleSource.length < viewportHeight)
+            visibleSource.push("");
+        const visible = visibleSource.map((row, index) => {
             const painted = cachedString(this.#paintedRowCache, `${paintId}\u0000${row}`, cacheLimit, () => paintDocumentRow(row));
             if (!painted.reused)
                 paintRecomputedRows.add(index);
             return painted.value;
         });
-        while (visible.length < viewportHeight)
-            visible.push("");
         const governing = governingPrompt(input.promptAnchors, this.#scrollTop);
         const stickyActive = governing !== null && governing.firstRow < this.#scrollTop;
         if (stickyActive && visible.length > 0) {
@@ -362,7 +346,10 @@ export class TranscriptViewport {
                 paintRecomputedRows.add(0);
             const sticky = theme.sticky(source.value, this.#stickyHovered);
             visible[0] = quiet && !this.#stickyHovered ? theme.quietSticky(sticky) : sticky;
+            visibleSource[0] = sourceRow;
         }
+        // Invariant: selection uses exact visible source rows; paint-only hyperlink guards stay rendered-only.
+        this.#selectionRows = [...visibleSource, ...dock].slice(0, height);
         const selectionPainterId = this.#functionId(theme.selection);
         // Concurrency: a painter may synchronously route input in tests or host integrations.
         // Label this frame with the exact selection snapshot it began composing.
@@ -372,40 +359,8 @@ export class TranscriptViewport {
         const reusedRows = [];
         const selectionDamagedRows = [];
         const visibleStates = [];
-        for (let row = 0; row < visible.length; row += 1) {
-            const documentLine = this.#scrollTop + row;
-            const painted = visible[row] ?? "";
-            const base = cachedString(this.#baseRowCache, `${width}\u0000${painted}`, cacheLimit, () => padRowPreservingBackground(painted, width));
-            let rowRecomputed = paintRecomputedRows.has(row) || !base.reused;
-            const range = stickyActive && row === 0
-                ? null
-                : selectionRangeForLine(orderedSelection, documentLine, this.#selectableDocumentRowCount, width);
-            const rangeKey = range === null ? "-" : `${range.from}:${range.to}`;
-            const selected = range === null
-                ? { value: base.value, reused: true }
-                : cachedString(this.#selectedRowCache, `${selectionPainterId}\u0000${rangeKey}\u0000${base.value}`, cacheLimit, () => theme.selection(base.value, range.from, range.to));
-            rowRecomputed ||= !selected.reused;
-            // Invariant: paint the rail after selection. Full-row selection reaches the terminal
-            // edge, while the foreground thumb/track remains visible above that
-            // background instead of disappearing into it.
-            let railCell = "";
-            if (presentation.visible && geometry !== null && row > 0) {
-                const trackRow = row - 1;
-                const thumb = isThumbRow(geometry, trackRow);
-                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, { inheritStartStyle: true }));
-            rowRecomputed ||= !final.reused;
-            visible[row] = final.value;
-            (rowRecomputed ? recomputedRows : reusedRows).push(row + 1);
-            const state = `${width}\u0000${documentLine}\u0000${painted}\u0000${rangeKey}\u0000${range === null ? "" : selectionPainterId}\u0000${railCell}`;
-            visibleStates.push(state);
-            if (this.#previousVisibleStates[row] !== state)
-                selectionDamagedRows.push(row + 1);
-        }
-        this.#previousVisibleStates = visibleStates;
         const frameRows = [...visible, ...dock].slice(0, height);
+        const selectionRows = [...this.#selectionRows];
         let bottomHit = null;
         if (this.#maxScroll > 0 && !this.#followingEnd && frameRows.length > 0) {
             const genericLabel = " Jump to bottom (Ctrl+End) ↓ ";
@@ -424,8 +379,49 @@ export class TranscriptViewport {
                 const bottomHovered = pointer !== undefined && pointer.row === bottomHit.row
                     && pointer.column >= bottomHit.columnStart && pointer.column <= bottomHit.columnEnd;
                 frameRows[row] = overlaySpan(padRowPreservingBackground(frameRows[row] ?? "", width), left, left + labelWidth, `${CONTROL_STYLE_RESET}${theme.bottomControl(label, bottomHovered)}`);
+                selectionRows[row] = overlaySpan(padRowPreservingBackground(selectionRows[row] ?? "", width), left, left + labelWidth, label);
             }
         }
+        for (const covered of input.coveredCells ?? []) {
+            const row = covered.row - 1;
+            if (row < 0 || row >= selectionRows.length)
+                continue;
+            const from = clamp(covered.columnStart - 1, 0, width);
+            const to = clamp(covered.columnEnd, from, width);
+            selectionRows[row] = overlaySpan(padRowPreservingBackground(selectionRows[row] ?? "", width), from, to, " ".repeat(to - from));
+        }
+        this.#selectionRows = selectionRows;
+        this.#updateCopyableSelection();
+        for (let row = 0; row < frameRows.length; row += 1) {
+            const painted = frameRows[row] ?? "";
+            const range = selectionRangeForLine(orderedSelection, row, this.#selectionRows.length, width);
+            const padded = row < viewportHeight || range !== null;
+            const base = cachedString(this.#baseRowCache, `${width}\u0000${padded}\u0000${painted}`, cacheLimit, () => padded ? padRowPreservingBackground(painted, width) : painted);
+            let rowRecomputed = row < viewportHeight && paintRecomputedRows.has(row) || !base.reused;
+            const rangeKey = range === null ? "-" : `${range.from}:${range.to}`;
+            const selected = range === null
+                ? { value: base.value, reused: true }
+                : cachedString(this.#selectedRowCache, `${selectionPainterId}\u0000${rangeKey}\u0000${base.value}`, cacheLimit, () => theme.selection(base.value, range.from, range.to));
+            rowRecomputed ||= !selected.reused;
+            // Invariant: paint the rail after selection. Full-row selection reaches the terminal
+            // edge, while the foreground thumb/track remains visible above that background.
+            let railCell = "";
+            if (row < viewportHeight && presentation.visible && geometry !== null && row > 0) {
+                const trackRow = row - 1;
+                const thumb = isThumbRow(geometry, trackRow);
+                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, { inheritStartStyle: true }));
+            rowRecomputed ||= !final.reused;
+            frameRows[row] = final.value;
+            (rowRecomputed ? recomputedRows : reusedRows).push(row + 1);
+            const state = `${width}\u0000${row}\u0000${painted}\u0000${rangeKey}\u0000${range === null ? "" : selectionPainterId}\u0000${railCell}`;
+            visibleStates.push(state);
+            if (this.#previousVisibleStates[row] !== state)
+                selectionDamagedRows.push(row + 1);
+        }
+        this.#previousVisibleStates = visibleStates;
         const nextDocumentRange = {
             start: this.#scrollTop,
             end: Math.min(documentRows.length, this.#scrollTop + viewportHeight),
@@ -509,7 +505,7 @@ export class TranscriptViewport {
         const boundedWidth = Math.max(1, width);
         const boundedHeight = Math.max(0, height);
         if (previous === null || previous.descriptor.width !== boundedWidth || previous.descriptor.height !== boundedHeight
-            || previous.descriptor.selectionRevision !== this.#selectionRevision)
+            || previous.descriptor.selectionRevision !== this.#selectionRevision || this.#selection !== undefined)
             return null;
         const dock = dockRows.length > boundedHeight ? dockRows.slice(-boundedHeight) : [...dockRows];
         const viewportHeight = Math.max(0, boundedHeight - dock.length);
@@ -539,6 +535,7 @@ export class TranscriptViewport {
             cause: "dock-input",
         };
         assertTranscriptViewportFrameDescriptor(descriptor);
+        this.#selectionRows = [...this.#selectionRows.slice(0, viewportHeight), ...dock].slice(0, boundedHeight);
         const frame = {
             rows: [...previous.rows.slice(0, viewportHeight), ...dock].slice(0, boundedHeight),
             contentWidth: previous.contentWidth,
@@ -568,47 +565,8 @@ export class TranscriptViewport {
     }
     #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) {
-        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";
-        }
-        return undefined;
+        this.#copyableSelection = selection !== undefined
+            && textSelectionText(selection, this.#selectionRows, line => usefulTextLineContent(this.#selectionRows[line] ?? "")).length > 0;
     }
 }
 function selectionRangeForLine(selection, documentLine, selectableRowCount, width) {

package/docs/architecture/ui-reference-provenance.md

@@ -81,13 +81,16 @@ its own `core` facade layer; A1 is a product, so the port adapts imports and kee
   input behavior, but A1 uses its prior dark floating panel, lighter white-text active row,
   and independent effective-value check mark because physical review rejected a menu that
   blended into the settings rows.
-- **Spinner-backed progress punctuation.** Bare A1 resolves built-in and extension working
+- **Spinner-backed progress presentation.** Bare A1 resolves built-in and extension working
   labels through `ui-components/progress-status.ts`, injected by
   `session-shell/session-shell-root.ts` into the shared `pi-components/shell-footer-status.ts`
-  spinner factory. The factory canonicalizes the visible progress marker once, to three ASCII
-  periods, without importing across the component-adapter boundary. Engine producers remain
-  semantic and the source-synchronized Pi status indicators, installed packages, `a1 pi`, and
-  vanilla Pi remain untouched.
+  spinner factory. The factory canonicalizes the visible progress marker once, to one Unicode
+  ellipsis, and uses the existing spinner updates to move a two-grapheme accent band slowly
+  across otherwise muted label text with a muted pause between passes. The ellipsis remains
+  stationary, no additional timer exists, and theme roles cross the component-adapter boundary
+  as styling callbacks rather than imports or literal colours. Engine producers remain semantic;
+  pinned presentation keeps its three periods; and the source-synchronized Pi status indicators,
+  installed packages, `a1 pi`, and vanilla Pi remain untouched.
 - **Keyboard presentation scheduling.** Pinned components, semantic key handling, and the
   comparison profiles stay unchanged. Bare A1 adds one A1-owned event-loop-turn coordinator
   before its fullscreen root and may omit only superseded visual states after every delivery

package/docs/openspec-archive-automation.md

@@ -19,7 +19,7 @@ Version-1 and version-2 deliveries and their existing comments, acceptance PRs,
 
 ### Complete-regression evidence ordering
 
-PR-attached Full regression is selected only for a repair that the trusted triage created from a failed Full regression: base policy verifies the immutable `openspec-ci` App author, generated candidate identity, and `regression-provenance.json`. Human-authored lookalikes, publishing or validation-authority changes, labels, Release-only repairs, and successful-run persistent-overrun candidates retain bounded ordinary validation. Planning-only generated repair drafts remain lightweight. Eligible implementation drafts expose all four native lane checks without becoming mergeable. Finish substantive implementation tasks, focused evidence, pre-finalization observations, and known-gap disposition before marking ready. The finalized head then receives new full evidence, required by `Development validation required` alongside the existing gates.
+PR-attached Full regression is selected only for a repair that the trusted triage created from a failed Full regression: base policy verifies the immutable `openspec-ci` App author, generated candidate identity, and `regression-provenance.json`. Human-authored lookalikes, publishing or validation-authority changes, labels, Release-only repairs, and successful-run persistent-overrun candidates retain bounded ordinary validation. Generated repair drafts run no Development test suites, including after implementation begins. Finish substantive implementation tasks, focused local evidence, pre-finalization observations, and known-gap disposition before marking ready. The ready active head defers testing while trusted finalization publishes the candidate; the finalized head then receives all four native lanes as new full evidence, required by `Development validation required` alongside the existing gates.
 
 The final exact-head run is a handoff gate, not a task requiring a future run ID in committed `design.md`. Keep final head/run/selection identity in Actions outcomes and the maintainer handoff; do not invalidate successful evidence with an extra recording commit. Changed code, acceptance/body metadata, selection labels, or target baseline requires fresh evidence. A selected PR success removes the additional mandatory Full regression dispatch, but a standalone/manual run never substitutes for selected PR checks. Before deployment, existing separate-dispatch obligations remain. Neither PR validation nor manual regression proves numbered-package nightly publication recovery.
 
@@ -202,7 +202,7 @@ Unavailable, stale, automatic, unauthorized, conflicting, or contradictory prove
 
 ## CI and automation ownership
 
-Normal Development CI remains complete for the implementation. An archive-shaped final diff does not select documentation-only validation because the authoritative version-3 association remains implementation-bound. The trusted acceptance-policy job validates finalization from base-controlled policy while ordinary impact selection retains all applicable product and governance owners. A ready head that still holds the active change fails that job with an `Awaiting automated finalization` notice pointing at the finalization workflow; the head the workflow pushes receives its own complete validation, and `Development validation` cancels the superseded run.
+Normal Development CI remains complete for the implementation once its reviewable candidate exists. An archive-shaped final diff does not select documentation-only validation because the authoritative version-3 association remains implementation-bound. Base-controlled readiness defers a ready head that still holds the active change without running test suites or emitting `Development validation required`. The finalization workflow pushes the finalized head and updates its implementation fence; that update starts one complete selected validation, while PR-level concurrency cancels any superseded eligible run.
 
 `pull_request` body edits rerun required CI. The ordinary finalized phase-free run exposes the stable protected aggregate directly; it does not wait for a lifecycle body edit. Documentation auto-merge's trusted owner also reevaluates lifecycle association and disables any armed merge. Every publication entry point explicitly refuses version 3.
 

package/docs/validation.md

@@ -94,7 +94,7 @@ Download these artifacts from the exact workflow run:
 
 For selected implementation candidates, record focused and pre-finalization full observations before finalization. Keep final head/run/selection identity in Actions and handoff rather than adding a post-success commit that invalidates that evidence. A successful selected PR run replaces an additional mandatory dispatch; standalone runs remain diagnostic, and numbered-package nightly recovery remains independent.
 
-A finalized version-3 PR keeps its phase-free body unchanged. Its ordinary exact-head workflow runs selected product/governance lanes and `Finalized delivery validation` in parallel, then emits the stable protected `Development validation required` aggregate only when both authorities succeed. Green CI enables maintainer review and manual merge but does not claim human acceptance or merge automatically. No lifecycle body edit or second workflow run is required. Any implementation commit changes the head and reruns applicable validation; any body change reruns finalized-record validation and must continue to match the committed manifest. A ready head that still holds the active change fails `Finalized delivery validation` with an `Awaiting automated finalization` notice; the `OpenSpec finalization` workflow pushes the finalized head, which receives its own run. Legacy acceptance-record-only PRs retain their separate trusted `Acceptance record validation` route. Queue availability remains explicitly unavailable inside a runner and is calculated from the Actions API during final run analysis rather than guessed.
+Draft pull requests run no Development test suites. A ready version-3 PR whose body still identifies an active change defers testing and emits no protected aggregate while `OpenSpec finalization` publishes the candidate. After finalization records the archive and acceptance manifest, the ordinary exact-head workflow runs selected product/governance lanes and `Finalized delivery validation` in parallel, then emits the stable protected `Development validation required` aggregate only when both authorities succeed. Green CI enables maintainer review and manual merge but does not claim human acceptance or merge automatically. The finalization fence update is the validation trigger, so no pre-finalization test run or later lifecycle body edit is required. Any subsequent eligible implementation commit changes the head and reruns applicable validation; any body change reruns readiness and finalized-record validation and must continue to match the committed manifest. Legacy acceptance-record-only PRs retain their separate trusted `Acceptance record validation` route. Queue availability remains explicitly unavailable inside a runner and is calculated from the Actions API during final run analysis rather than guessed.
 
 ## Rollback
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.560",
+  "version": "0.1.8-dev.572",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",