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

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

@@ -4,7 +4,13 @@ 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";
 const CONTROL_STYLE_RESET = "\u001b]8;;\u001b\\\u001b[0m";
+// Invariant: scrollbar chrome closes source links and decoration without clearing
+// the row surface painted beneath its dedicated, non-semantic gutter.
+const GUTTER_DECORATION_RESET = "\u001b]8;;\u001b\\\u001b[22;23;24;25;27;28;29;39;54;55m";
 const IDENTITY_ROW = (row) => row;
+function documentSelectionAnchor(row, source) {
+    return { kind: "document", row, source, identity: stripAnsi(source).trimEnd() };
+}
 const DEFAULT_CONFIG = {
     scrollbarAppearance: "auto",
     scrollbarStyle: "thin",
@@ -32,6 +38,7 @@ export class TranscriptViewport {
     #railDragging = false;
     #stickyHovered = false;
     #selection;
+    #selectionAnchors;
     #selectionClick;
     #selectionRevision = 0;
     #copyableSelection = false;
@@ -49,6 +56,8 @@ export class TranscriptViewport {
     #promptAnchors = [];
     #contentWidth = 0;
     #selectionWidth = 0;
+    #viewportHeight = 0;
+    #selectionRowAnchors = [];
     #frameId = 0;
     #frame = null;
     get scrollTop() { return this.#scrollTop; }
@@ -81,24 +90,29 @@ export class TranscriptViewport {
     get hasSelection() { return orderedTextSelection(this.#selection) !== undefined; }
     pressSelection(column, frameRow, now = Date.now()) {
         const frameHeight = this.#frame?.rows.length ?? 0;
-        if (frameRow < 1 || frameRow > frameHeight || column < 1 || column > this.#selectionWidth)
+        const selectionWidth = frameRow <= (this.#frame?.hits.viewportHeight ?? 0)
+            ? this.#contentWidth
+            : this.#selectionWidth;
+        if (frameRow < 1 || frameRow > frameHeight || column < 1 || column > selectionWidth)
             return false;
         const line = frameRow - 1;
         const pressed = pressTextSelection({
             line,
             column,
-            contentWidth: this.#selectionWidth,
+            contentWidth: selectionWidth,
             lineText: this.#selectionRows[line] ?? "",
             lineContent: usefulTextLineContent(this.#selectionRows[line] ?? ""),
             ...(this.#selectionClick === undefined ? {} : { previousClick: this.#selectionClick }),
             now,
         });
         this.#selection = pressed.selection;
+        const rowAnchor = this.#selectionAnchorAt(line);
+        this.#selectionAnchors = pressed.selection === undefined || rowAnchor === undefined
+            ? undefined
+            : { anchor: rowAnchor, head: rowAnchor };
         this.#selectionClick = pressed.click;
         this.#selectionRevision += 1;
         this.#updateCopyableSelection();
-        if (this.#copyableSelection)
-            this.#followingEnd = false;
         return true;
     }
     extendSelection(column, frameRow, now = Date.now(), autoScroll = true) {
@@ -113,19 +127,26 @@ export class TranscriptViewport {
         else if (autoScroll && frameRow <= 1 && this.#scrollTop > 0)
             this.scrollBy(-1, now);
         const line = clamp(frameRow - 1, 0, this.#selectionRows.length - 1);
+        const selectionWidth = line < (this.#frame?.hits.viewportHeight ?? 0)
+            ? this.#contentWidth
+            : this.#selectionWidth;
         const targetColumn = selection.fullRow
-            ? textSelectionLineExtendColumn(selection, line, this.#selectionWidth)
-            : clamp(column, 1, this.#selectionWidth);
+            ? textSelectionLineExtendColumn(selection, line, selectionWidth)
+            : clamp(column, 1, selectionWidth);
         const point = selection.fullRow
             ? { line, column: targetColumn }
             : textSelectionPointAt(line, targetColumn, this.#selectionRows[line] ?? "");
         const next = extendTextSelection(selection, point);
         if (next !== selection) {
+            const headAnchor = this.#selectionAnchorAt(line);
+            if (headAnchor === undefined || this.#selectionAnchors === undefined) {
+                this.clearSelection();
+                return true;
+            }
             this.#selection = next;
+            this.#selectionAnchors = { ...this.#selectionAnchors, head: headAnchor };
             this.#selectionRevision += 1;
             this.#updateCopyableSelection();
-            if (this.#copyableSelection)
-                this.#followingEnd = false;
         }
         return true;
     }
@@ -133,6 +154,8 @@ export class TranscriptViewport {
         if (this.#selection?.selecting !== true)
             return false;
         this.#selection = releaseTextSelection(this.#selection);
+        if (this.#selection === undefined)
+            this.#selectionAnchors = undefined;
         this.#selectionRevision += 1;
         this.#updateCopyableSelection();
         return true;
@@ -141,12 +164,13 @@ export class TranscriptViewport {
         if (this.#selection === undefined)
             return false;
         this.#selection = undefined;
+        this.#selectionAnchors = undefined;
         this.#copyableSelection = false;
         this.#selectionRevision += 1;
         return true;
     }
     selectedText() {
-        const selection = orderedTextSelection(this.#selection);
+        const selection = visibleTextSelection(orderedTextSelection(this.#selection), this.#selectionRows.length);
         if (selection === undefined)
             return null;
         const text = textSelectionText(selection, this.#selectionRows, line => usefulTextLineContent(this.#selectionRows[line] ?? ""));
@@ -240,8 +264,10 @@ export class TranscriptViewport {
         if (this.#selection !== undefined)
             this.#selectionRevision += 1;
         this.#selection = undefined;
+        this.#selectionAnchors = undefined;
         this.#copyableSelection = false;
         this.#selectionRows = [];
+        this.#selectionRowAnchors = [];
         this.#selectionClick = undefined;
         this.#paintedRowCache.clear();
         this.#baseRowCache.clear();
@@ -253,6 +279,7 @@ export class TranscriptViewport {
         this.#promptAnchors = [];
         this.#contentWidth = 0;
         this.#selectionWidth = 0;
+        this.#viewportHeight = 0;
         this.clearTransient();
         this.#frame = null;
     }
@@ -311,9 +338,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.
+        // Invariant: dock rows remain selectable at full width; scrollable source rows
+        // use contentWidth and leave the gutter outside semantic selection.
         this.#selectionWidth = width;
+        this.#viewportHeight = viewportHeight;
         const paintDocumentRow = input.paintDocumentRow ?? IDENTITY_ROW;
         const cacheLimit = Math.max(32, viewportHeight * 6);
         trimCache(this.#paintedRowCache, cacheLimit);
@@ -348,8 +376,26 @@ export class TranscriptViewport {
             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);
+        // Invariant: selection uses exact visible source rows within the rendered
+        // content boundary; paint-only guards and the rail gutter stay presentation-only.
+        this.#selectionRows = [
+            ...visibleSource.map(row => truncateToWidth(row, contentWidth)),
+            ...dock,
+        ].slice(0, height);
+        const visibleAnchors = Array.from({ length: viewportHeight }, (_value, row) => {
+            const documentRow = this.#scrollTop + row;
+            return documentRow < documentRows.length
+                ? documentSelectionAnchor(documentRow, documentRows[documentRow] ?? "")
+                : { kind: "screen", row, source: this.#selectionRows[row] ?? "" };
+        });
+        if (stickyActive && governing !== null && visibleAnchors.length > 0) {
+            visibleAnchors[0] = documentSelectionAnchor(governing.firstRow, documentRows[governing.firstRow] ?? governing.sourceRow);
+        }
+        this.#selectionRowAnchors = [
+            ...visibleAnchors,
+            ...dock.map((_row, index) => ({ kind: "dock", fromBottom: dock.length - index - 1 })),
+        ].slice(0, height);
+        this.#projectSelection(documentRows, dock, 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.
@@ -394,17 +440,20 @@ export class TranscriptViewport {
         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 rowSelectionWidth = row < viewportHeight ? contentWidth : width;
+            const range = selectionRangeForLine(orderedSelection, row, this.#selectionRows.length, rowSelectionWidth);
             const padded = row < viewportHeight || range !== null;
-            const base = cachedString(this.#baseRowCache, `${width}\u0000${padded}\u0000${painted}`, cacheLimit, () => padded ? padRowPreservingBackground(painted, width) : painted);
+            const base = cachedString(this.#baseRowCache, `${width}\u0000${contentWidth}\u0000${row < viewportHeight}\u0000${padded}\u0000${painted}`, cacheLimit, () => row < viewportHeight
+                ? padViewportRowWithGutter(painted, contentWidth, width)
+                : 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.
+            // Invariant: paint the rail after selection over the gutter's continued row
+            // background. Source content and selection still end at the preceding cell.
             let railCell = "";
             if (row < viewportHeight && presentation.visible && geometry !== null && row > 0) {
                 const trackRow = row - 1;
@@ -412,11 +461,19 @@ 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, { inheritStartStyle: true }));
+            const overlayLimit = row < viewportHeight ? contentWidth : width;
+            const overlayText = input.frameOverlay?.row === row + 1
+                ? truncateToWidth(input.frameOverlay.text, overlayLimit)
+                : "";
+            const overlayWidth = displayWidth(overlayText);
+            const final = cachedString(this.#finalRowCache, `${width}\u0000${railCell}\u0000${overlayText}\u0000${selected.value}`, cacheLimit, () => {
+                const withRail = railCell.length === 0 ? selected.value : overlaySpan(selected.value, width - 1, width, `${GUTTER_DECORATION_RESET}${railCell}`, { inheritStartStyle: true });
+                return overlayWidth === 0 ? withRail : overlaySpan(padRowPreservingBackground(withRail, width), overlayLimit - overlayWidth, overlayLimit, `${CONTROL_STYLE_RESET}${overlayText}`);
+            });
             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}`;
+            const state = `${width}\u0000${row}\u0000${painted}\u0000${rangeKey}\u0000${range === null ? "" : selectionPainterId}\u0000${railCell}\u0000${overlayText}`;
             visibleStates.push(state);
             if (this.#previousVisibleStates[row] !== state)
                 selectionDamagedRows.push(row + 1);
@@ -563,12 +620,95 @@ export class TranscriptViewport {
         this.#functionIds.set(value, id);
         return id;
     }
+    #selectionAnchorAt(line) {
+        if (line < 0 || line >= this.#selectionRows.length)
+            return undefined;
+        if (line < this.#viewportHeight) {
+            const existing = this.#selectionRowAnchors[line];
+            if (this.#frame?.scrollTop === this.#scrollTop)
+                return existing;
+            // Concurrency: selection edge auto-scroll updates scrollTop before the next frame is
+            // composed. Resolve ordinary viewport rows from that latest position instead of stale paint.
+            const documentRow = this.#scrollTop + line;
+            if (documentRow >= 0 && documentRow < this.#documentRows.length) {
+                return documentSelectionAnchor(documentRow, this.#documentRows[documentRow] ?? "");
+            }
+        }
+        return this.#selectionRowAnchors[line];
+    }
+    #projectSelection(documentRows, dockRows, height) {
+        const selection = this.#selection;
+        const anchors = this.#selectionAnchors;
+        if (selection === undefined || anchors === undefined)
+            return;
+        const project = (anchor) => {
+            if (anchor.kind === "dock") {
+                const dockIndex = dockRows.length - anchor.fromBottom - 1;
+                return dockIndex < 0 || dockIndex >= dockRows.length
+                    ? undefined
+                    : { line: height - dockRows.length + dockIndex, anchor };
+            }
+            if (anchor.kind === "screen") {
+                return anchor.row < 0 || anchor.row >= this.#selectionRows.length
+                    || this.#selectionRows[anchor.row] !== anchor.source
+                    ? undefined
+                    : { line: anchor.row, anchor };
+            }
+            if (anchor.row >= 0 && anchor.row < documentRows.length
+                && stripAnsi(documentRows[anchor.row] ?? "").trimEnd() === anchor.identity) {
+                const current = documentSelectionAnchor(anchor.row, documentRows[anchor.row] ?? "");
+                const visible = this.#selectionRowAnchors.findIndex(candidate => candidate?.kind === "document"
+                    && candidate.row === current.row && candidate.identity === current.identity);
+                return { line: visible >= 0 ? visible : current.row - this.#scrollTop, anchor: current };
+            }
+            // Invariant: reflow may move a retained source row, but remapping is allowed only when
+            // that exact source has one visible identity. Ambiguous or off-screen replacement clears it.
+            const visibleMatches = this.#selectionRowAnchors
+                .map((candidate, line) => ({ candidate, line }))
+                .filter((entry) => entry.candidate?.kind === "document" && entry.candidate.identity === anchor.identity);
+            return visibleMatches.length === 1
+                ? { line: visibleMatches[0].line, anchor: visibleMatches[0].candidate }
+                : undefined;
+        };
+        const projectedAnchor = project(anchors.anchor);
+        const projectedHead = project(anchors.head);
+        if (projectedAnchor === undefined || projectedHead === undefined) {
+            this.clearSelection();
+            return;
+        }
+        this.#selectionAnchors = { anchor: projectedAnchor.anchor, head: projectedHead.anchor };
+        if (selection.anchor.line === projectedAnchor.line && selection.head.line === projectedHead.line)
+            return;
+        this.#selection = {
+            ...selection,
+            anchor: { ...selection.anchor, line: projectedAnchor.line },
+            head: { ...selection.head, line: projectedHead.line },
+        };
+    }
     #updateCopyableSelection() {
-        const selection = orderedTextSelection(this.#selection);
+        const selection = visibleTextSelection(orderedTextSelection(this.#selection), this.#selectionRows.length);
         this.#copyableSelection = selection !== undefined
             && textSelectionText(selection, this.#selectionRows, line => usefulTextLineContent(this.#selectionRows[line] ?? "")).length > 0;
     }
 }
+function visibleTextSelection(selection, rowCount) {
+    if (selection === undefined || rowCount <= 0 || selection.end.line < 0 || selection.start.line >= rowCount)
+        return undefined;
+    const startLine = Math.max(0, selection.start.line);
+    const endLine = Math.min(rowCount - 1, selection.end.line);
+    return {
+        start: {
+            line: startLine,
+            column: selection.start.line < 0 ? 0 : selection.start.column,
+        },
+        end: {
+            line: endLine,
+            column: selection.end.line >= rowCount ? Number.MAX_SAFE_INTEGER : selection.end.column,
+        },
+        ...(selection.fullRow ? { fullRow: true } : {}),
+        ...(selection.throughFinalColumn ? { throughFinalColumn: true } : {}),
+    };
+}
 function selectionRangeForLine(selection, documentLine, selectableRowCount, width) {
     if (selection === undefined || documentLine >= selectableRowCount
         || documentLine < selection.start.line || documentLine > selection.end.line)
@@ -626,18 +766,37 @@ function governingPrompt(anchors, scrollTop) {
     }
     return result;
 }
+function padViewportRowWithGutter(line, contentWidth, frameWidth) {
+    const boundedContentWidth = Math.min(Math.max(1, contentWidth), frameWidth);
+    const content = padRowPreservingBackground(line, boundedContentWidth);
+    const gutterWidth = frameWidth - boundedContentWidth;
+    if (gutterWidth === 0)
+        return content;
+    // Invariant: render no source glyph beyond contentWidth, but reuse the established
+    // row-padding background before stripping source foreground, links, and emphasis.
+    const gutterStyle = explicitBackgroundPaddingStyle(line);
+    return `${content}${GUTTER_DECORATION_RESET}${gutterStyle?.on ?? ""}${" ".repeat(gutterWidth)}${gutterStyle?.off ?? ""}`;
+}
+function explicitBackgroundPaddingStyle(line) {
+    const background = /\u001b\[(?:4[0-8]|10[0-7]|48;(?:2;\d+;\d+;\d+|5;\d+))m/.exec(line)?.[0];
+    return background === undefined ? null : { on: background, off: "\u001b[49m" };
+}
+function rowPaddingStyle(line) {
+    const background = explicitBackgroundPaddingStyle(line);
+    if (background !== null)
+        return background;
+    const reverse = /\u001b\[(?:7(?:;[0-9]+)*|[0-9;]*;7(?:;[0-9]+)*)m/.exec(line)?.[0];
+    return reverse === undefined ? null : { on: reverse, off: "\u001b[27m" };
+}
 function padRowPreservingBackground(line, width) {
     const shown = displayWidth(line) > width ? truncateToWidth(line, width) : line;
     const padding = Math.max(0, width - displayWidth(shown));
     if (padding === 0)
         return shown;
-    const background = /\u001b\[(?:4[0-8]|10[0-7]|48;(?:2;\d+;\d+;\d+|5;\d+))m/.exec(line)?.[0];
-    const reverse = /\u001b\[(?:7(?:;[0-9]+)*|[0-9;]*;7(?:;[0-9]+)*)m/.exec(line)?.[0];
-    if (background)
-        return `${shown}${background}${" ".repeat(padding)}\u001b[49m`;
-    if (reverse)
-        return `${shown}${reverse}${" ".repeat(padding)}\u001b[27m`;
-    return shown + " ".repeat(padding);
+    const style = rowPaddingStyle(line);
+    return style === null
+        ? shown + " ".repeat(padding)
+        : `${shown}${style.on}${" ".repeat(padding)}${style.off}`;
 }
 export function assertTranscriptViewportFrameDescriptor(descriptor) {
     if (!Number.isSafeInteger(descriptor.frameId) || descriptor.frameId < 1)

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

@@ -91,6 +91,15 @@ its own `core` facade layer; A1 is a product, so the port adapts imports and kee
   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.
+- **Surface-relative frame selection and layout-neutral copy feedback.** Bare A1's complete-frame
+  selection extends the reference transcript selector across scrollable document and pinned dock
+  surfaces. Selection endpoints retain those surface identities: followed agent output carries its
+  highlight with the source row, while footer, status, prompt, widget, and notice selection remains
+  pinned. The copied-character acknowledgement is final-frame paint over the existing row above the
+  input, not a dock child, so appearing, replacement, and expiry do not reallocate the viewport or
+  move editor, footer, controls, or selection. Bounded row provenance clears ambiguous reflow rather
+  than transferring selection to unrelated terminal cells. The comparison profile retains pinned Pi
+  selection and notification behavior.
 - **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/local-worktree-cleanup.md

@@ -24,7 +24,9 @@ node scripts/governance/local-worktree-cleanup.mjs sweep --repo D:/Git/a1
 
 ### Nothing left to remove
 
-A released entry whose evidence can never verify (for example `delivery-content-drift` after a stale-base merge, or `source-association` for a PR without an `openspec-implementation` fence) would otherwise be re-verified and reported `blocked` on every sweep. When such an entry's worktree path is gone, Git holds no live row for it (its own dangling row is retired), and its local topic ref is absent, the sweep and `complete` ask GitHub only whether the pull request merged into `develop` in this repository and then mark the journal `done` with `retired-nothing-left` and the original evidence reason. Nothing is deleted; a present path, row, or ref keeps the entry blocked, an unmerged PR keeps it `pending` or `awaiting-discard`, a deferred failure such as `remote-budget` is never treated as unverifiable, and preview retires nothing. For an all-absent entry whose PR is not merged, the maintainer runs the explicit form, which reads nothing from GitHub and deletes nothing:
+A released entry whose evidence can never verify (for example `delivery-content-drift` after a stale-base merge, or `source-association` for a PR without an `openspec-implementation` fence) would otherwise be re-verified and reported `blocked` on every sweep. One narrow exception repairs an integrated unassociated delivery without rewriting its merged body: current `develop` must contain exactly one archived `association-repair.json` for the registered change, naming the exact original PR/head/merge and successful validation run, and its named corrective version-3 PR must itself have authorized manual merge, current exact-head CI, synchronized specs, a valid archive, and absent original/corrective remote refs. Only then does cleanup continue through all ordinary worktree identity, ownership, cleanliness, disposable-content, non-force removal, journaling, and local-ref safeguards. A mismatch remains blocked and generic merge/archive evidence never substitutes.
+
+When no valid corrective association exists and such an entry's worktree path is gone, Git holds no live row for it (its own dangling row is retired), and its local topic ref is absent, the sweep and `complete` ask GitHub only whether the pull request merged into `develop` in this repository and then mark the journal `done` with `retired-nothing-left` and the original evidence reason. Nothing is deleted; a present path, row, or ref keeps the entry blocked, an unmerged PR keeps it `pending` or `awaiting-discard`, a deferred failure such as `remote-budget` is never treated as unverifiable, and preview retires nothing. For an all-absent entry whose PR is not merged, the maintainer runs the explicit form, which reads nothing from GitHub and deletes nothing:
 
 ```bash
 node scripts/governance/local-worktree-cleanup.mjs forget --repo D:/Git/a1 --id REGISTRATION_ID --confirm-nothing-left

package/docs/openspec-archive-automation.md

@@ -148,6 +148,10 @@ The commit is pushed with a lease on the head the run read, so a developer push
 
 Because the branch gains commits from the archive App, pull before pushing. A rebase that drops them is harmless: the next push is reconciled from whatever the head contains. Do not revert a finalization commit to make a fix; push the fix and let the workflow re-finalize. When the workflow fails, its summary names the finalization code (`tasks-incomplete`, `acceptance-*`, `delivery-known-gaps`, `openspec-operation`, `finalization-merge-conflict`, ...), nothing is pushed, and `Finalized delivery validation` on the unfinalized head reports that automated finalization is pending.
 
+A missing fence is not an ordinary ready PR when immutable base/head evidence shows that the candidate introduces or restores an active change, or mixes active-change edits with code or operational paths. Base-controlled readiness and finalization both fail with `missing-implementation-association`; deleting editable body metadata cannot bypass finalization. Existing active-change documentation-only revisions and ordinary code PRs without active delivery paths retain their established routes.
+
+If an unassociated implementation has already integrated, do not edit its merged body or publish an archive-only follow-up. A corrective implementation-bound PR for the same still-active change must add the prevention fix and an exact `association-repair.json` record naming the original PR/head/merge/validation and the corrective PR. Normal version-3 finalization then synchronizes and archives the change; the corrective PR's authorized manual merge accepts that repair without pretending the original PR was finalized retroactively.
+
 ## Finalization command
 
 The local command remains available for inspection or when a developer prefers to finalize before marking the PR ready; the workflow then verifies the head and pushes nothing. It has inspection mode by default and an explicit `--write` mode. It never commits, pushes, edits GitHub, marks a PR ready, or merges. Use a temporary body file so the operation can update exact version-3 paths without mutating remote PR state:

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.
 
-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.
+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. A ready unassociated PR also fails closed when immutable base/head evidence shows that it introduces or restores active delivery content, or combines active-change edits with code or operational paths; it does not fall through to ordinary validation merely because its body fence is absent. Existing active-change documentation-only revisions and ordinary code PRs without active delivery paths retain their established routes. 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.572",
+  "version": "0.1.8-dev.581",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",