fix(send): Apply sends in one click and identical nodes always ask

Preview is now optional. Apply is enabled once a window and node are selected
and fetches its own ticket. It stays closed after a send, so a double click sends
once. A linked field or a workflow changed since discovery still refuses, and a
host refusal no longer reads as "may have applied". Two or more eligible nodes
are never selected for the user, and every node option reads "#<id> <title>".

TESTING.md

@@ -4235,6 +4235,24 @@ the per-section hand-off panel, was retired by S12 (#329): every section is nati
   makes the page see a restore run and finish deterministically. A refused file toasts "This file can't be restored: <validator reason>.". A
   review value may wrap anywhere (`#modal-body > dl.meta-grid dd`, CSS under D105), so a
   long file name keeps the concept's two equal columns at phone width.
+- **D173** (#535, amends D106; maintainer 2026-10-30): "always asks" now means asks when
+  there is a choice. One eligible window is selected, and a selected window with exactly
+  one eligible node selects that node; two or more nodes are never selected. A node whose
+  requested field is linked is not offered (`linkedRoles` on each destination), and the
+  status line says which case applies: linked, wrong roles, no node, or no window. It
+  counts the other nodes that cannot receive, and the review names the node and window.
+- **D174** (#535): the window option shows the tab's current title, read at each discovery
+  (a getter on the host options, which the Toolkit reads per discover), without the old
+  "PromptManager —" prefix. Same-named windows get " (window 2)", numbered by host id so the
+  number is stable while the tabs stay loaded. Every node option reads "#<id> <title>", so
+  identical nodes can be told apart. Discovery waits 300 ms, as System does.
+- **D175** (#535, maintainer 2026-10-30): the concept README previews before applying;
+  production makes Preview optional. Apply is enabled once a window and node are selected
+  and requests the ticket itself, in one click. It stays closed after "Sent to ComfyUI.",
+  so a double click sends once, and after an unknown outcome until a new preview or
+  choice. The host's checks still refuse a linked field or a changed workflow, and the
+  sender also refuses if the destination's `revision` (node object plus graph version)
+  moved since discovery; it is undefined on an older tab, which skips the comparison. A host error reads as a refusal, not "may have applied".
 - **D106** (Integrations, S10, Q8): the send bridge always asks for the ComfyUI window
   and node, and the nodes always follow ComfyUI's own renderer, so "Default send
   destination" offers only "Ask each time" and "Host compatibility" only "Follow host

docs/prompt-send-bridge.md

@@ -18,9 +18,13 @@ protocol and peer checks reject unrelated messages. Same-origin scripts are
 trusted; this transport is not authentication against other scripts on that origin.
 Unsupported messaging is reported without breaking existing ComfyUI nodes.
 
+Apply works in one click: without a preview, the sender requests the ticket itself
+and applies it. Preview remains optional, and shows the exact change first.
+
 An apply timeout or abort after posting means the outcome is unknown. It cannot
 prove the host cancelled the write. The sender must inspect a fresh destination
-preview before deciding to send again; automatic retry must not overwrite edits.
+preview or choose the destination again before sending again; automatic retry must
+not overwrite edits. An error the host returned is a refusal: nothing was written.
 
 ## PromptManager adapter
 
@@ -31,7 +35,9 @@ field. Unknown/ambiguous metadata must not become an empty string.
 
 Previews show original and requested text plus positive prepend/append composition.
 Connected composition is marked unknown rather than guessing upstream values.
-Connected destination fields reject writes. Applying rechecks graph, node, widgets,
+Connected destination fields reject writes. The sender compares the destination's revision
+(node object and graph version) from discovery with the one at the preview, and refuses if the workflow changed.
+Applying rechecks graph, node, widgets,
 values and connections. Ordinary serialization cache synchronization is accepted
 only when it preserves live values. Both requested roles are checked before writing.
 

tests/browser/full-inspector.spec.mjs

@@ -415,7 +415,7 @@ test('full inspector preserves long role text and exact sends',async({page,reque
         await fullFixture(page,request);const panel=inspector(page);const positive=panel.locator('.prompt-section.positive .prompt-text');await expect(positive).toContainText('猫 😀');const text=await positive.textContent();expect(text.length).toBeGreaterThan(1000);
         await panel.locator('.detail-footer button.send').click();const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
         await expect(sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).locator('option')).toContainText(['Exact host']);
-        await sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).selectOption({label:'Exact host'});await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'Exact pair'});
+        await sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).selectOption({label:'Exact host'});await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#pair Exact pair'});
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();await sender.getByRole('button',{name:'Apply to ComfyUI',exact:true}).click();await expect(sender).toContainText('Sent to ComfyUI.');
         expect(await host.evaluate(()=>window.sent)).toEqual([{positive:text,negative:'blurred edges, watermark'}]);
     } finally {await host.evaluate(()=>window.bridge.dispose());await host.close();}

tests/browser/history-canonical-comparison.mjs

@@ -107,7 +107,7 @@ export async function exerciseCurrentPairSend(page, roles) {
         const send = viewer.getByRole('button', { name: /^Send prompt pair to ComfyUI: / });await send.click();
         const sender = page.getByRole('dialog', { name: 'Send to ComfyUI', exact: true });await expect(sender).toBeVisible();
         await sender.getByRole('combobox', { name: 'ComfyUI window', exact: true }).selectOption({ label: 'Canonical ComfyUI' });
-        await sender.getByRole('combobox', { name: 'Destination node', exact: true }).selectOption({ label: 'Canonical destination' });
+        await sender.getByRole('combobox', { name: 'Destination node', exact: true }).selectOption({ label: '#canonical-pair Canonical destination' });
         await sender.getByRole('button', { name: 'Preview changes', exact: true }).click();
         await expect(sender).toContainText(roles.positive);await expect(sender).toContainText(roles.negative);
         await sender.getByRole('button', { name: 'Apply to ComfyUI', exact: true }).click();await expect(sender).toContainText('Sent to ComfyUI.');

tests/browser/history-concept.spec.mjs

@@ -194,7 +194,7 @@ function productionSent(host) {
     return async page=>{
         const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
         await sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).selectOption({label:'Concept ComfyUI'});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'Concept destination'});
+        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#pair-1 Concept destination'});
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         await expect.poll(()=>host.evaluate(()=>window.previewed.length)).toBe(1);
         const roles=await host.evaluate(()=>window.previewed.pop());

tests/browser/inspector-concept.spec.mjs

@@ -259,7 +259,7 @@ async function productionSendOf(page,context) {
         const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});await expect(sender).toBeVisible();
         const windows=sender.getByRole('combobox',{name:'ComfyUI window',exact:true});
         await expect(windows.locator('option')).toContainText(['Test ComfyUI']);await windows.selectOption({label:'Test ComfyUI'});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'My prompt pair'});
+        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#pair-1 My prompt pair'});
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         await sender.getByRole('button',{name:'Apply to ComfyUI',exact:true}).click();
         await expect(sender).toContainText('Sent to ComfyUI.');

tests/browser/library-concept.spec.mjs

@@ -233,7 +233,7 @@ function productionSent(host) {
     return async page=>{
         const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
         await sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).selectOption({label:'Concept ComfyUI'});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'Concept destination'});
+        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#pair-1 Concept destination'});
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         await expect.poll(()=>host.evaluate(()=>window.previewed.length)).toBe(1);
         const roles=await host.evaluate(()=>window.previewed.pop());

tests/browser/prompt-inspector.spec.mjs

@@ -33,7 +33,7 @@ async function chooseDestination(page) {
     const host=sender.getByRole('combobox',{name:'ComfyUI window',exact:true});
     await expect(host.locator('option')).toContainText(['Test ComfyUI']);
     await host.selectOption({label:'Test ComfyUI'});
-    await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'My prompt pair'});
+    await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#pair-1 My prompt pair'});
     return sender;
 }
 
@@ -165,7 +165,8 @@ test('host apply rejection retains the current text and requires a new preview',
         await page.goto(workspace);await select(page,'0:shared/same.png');await details(page).getByRole('button',{name:/^Send positive prompt to ComfyUI: /}).click();
         const sender=await chooseDestination(page);await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         await sender.getByRole('button',{name:'Apply to ComfyUI',exact:true}).click();await expect(sender).toContainText(/Workflow changed/);
-        await expect(sender.getByRole('button',{name:'Apply to ComfyUI',exact:true})).toBeDisabled();
+        // D175: a refusal wrote nothing, so Apply may try again.
+        await expect(sender.getByRole('button',{name:'Apply to ComfyUI',exact:true})).toBeEnabled();
         expect(await host.evaluate(()=>window.hostValues.positive)).toBe('Existing positive');
     } finally {await host.evaluate(()=>window.fixtureHost.dispose());await host.close();}
 });
@@ -193,7 +194,7 @@ test('empty negative send clears only the negative destination and preserves its
 test('no open ComfyUI window is actionable and rediscovery finds a newly opened host',async({page,context})=>{
     await page.goto(workspace);await select(page,'0:shared/same.png');
     await details(page).getByRole('button',{name:/^Send positive prompt to ComfyUI: /}).click();
-    const sender=dialog(page);await expect(sender).toContainText('No compatible ComfyUI windows found.');
+    const sender=dialog(page);await expect(sender).toContainText('No ComfyUI window answered in this browser');
     const host=await fakeHost(context,page);
     try {
         await sender.getByRole('button',{name:'Find ComfyUI windows',exact:true}).click();

tests/browser/system-integrations-concept.spec.mjs

@@ -88,7 +88,7 @@ function measureIntegrations(mainSelector) {
     };
 }
 
-const SEND_REASON = 'Sending always asks for the ComfyUI window and node, so “Ask each time” is the only option.';
+const SEND_REASON = 'Sending asks when there is more than one ComfyUI window or node, so “Ask each time” is the only option.';
 const RENDERER_REASON = 'Prompt Manager nodes always follow ComfyUI’s own renderer setting.';
 const RENDERER_NONE = 'No ComfyUI window is open in this browser, so its renderer is not known.';
 const RETURN_REASON = 'Not available: sending applies the text in ComfyUI and keeps this page open.';

tests/browser/workspace-history.spec.mjs

@@ -468,7 +468,7 @@ test('frozen Effective pair uses the shared acknowledged sender and Escape close
         const positive=await exact(dialog(page).getByRole('region',{name:'Positive prompt',exact:true}).locator('p.prompt-text'));
         const send=dialog(page).getByRole('button',{name:'Send prompt pair',exact:true});await send.click();
         const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});await sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).selectOption({label:'History ComfyUI'});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'History destination'});await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
+        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#history-pair History destination'});await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         await expect(sender.getByRole('button',{name:'Apply to ComfyUI',exact:true})).toBeEnabled();await sender.getByRole('button',{name:'Apply to ComfyUI',exact:true}).click();await expect(sender).toContainText('Sent to ComfyUI.');
         expect(await host.evaluate(()=>window.historyApplied)).toEqual([{positive,negative:'  \n\t '}]);
         await page.keyboard.press('Escape');await expect(sender).toHaveCount(0);await expect(dialog(page)).toBeVisible();await expect(send).toBeFocused();

tests/browser/workspace-inspect.spec.mjs

@@ -975,7 +975,7 @@ async function sendPair(page) {
     await rail(page).getByRole('button', { name: /^Send prompt pair to ComfyUI: / }).click();
     const sender = page.getByRole('dialog', { name: 'Send to ComfyUI', exact: true });
     await sender.getByRole('combobox', { name: 'ComfyUI window', exact: true }).selectOption({ label: 'Inspect ComfyUI' });
-    await sender.getByRole('combobox', { name: 'Destination node', exact: true }).selectOption({ label: 'Inspect destination' });
+    await sender.getByRole('combobox', { name: 'Destination node', exact: true }).selectOption({ label: '#pair-1 Inspect destination' });
     await sender.getByRole('button', { name: 'Preview changes', exact: true }).click();
     await sender.getByRole('button', { name: 'Apply to ComfyUI', exact: true }).click();
     await expect(sender).toContainText('Sent to ComfyUI.');

tests/browser/workspace-library.spec.mjs

@@ -364,7 +364,7 @@ test('history shares real image metadata, vendored Viewer and the acknowledged p
         const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
         const hosts=sender.getByRole('combobox',{name:'ComfyUI window',exact:true});
         await expect(hosts.locator('option')).toHaveCount(2);await hosts.selectOption({label:'Library ComfyUI'});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'Library destination'});
+        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#pair-1 Library destination'});
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();await expect(sender).toContainText(chosenNegative||'(empty)');
         await sender.getByRole('button',{name:'Apply to ComfyUI',exact:true}).click();await expect(sender).toContainText('Sent to ComfyUI.');
         expect(await host.evaluate(()=>window.libraryApplied)).toEqual([{positive:'Cat portrait',negative:chosenNegative}]);
@@ -716,7 +716,7 @@ test('long prompt is clamped to two lines while copy sends the full text',async(
         await card.locator('.card-footer .row-actions > button.send').click();
         const sender=page.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
         await sender.getByRole('combobox',{name:'ComfyUI window',exact:true}).selectOption({label:'Card ComfyUI'});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'Card destination'});
+        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({label:'#positive-1 Card destination'});
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         await sender.getByRole('button',{name:'Apply to ComfyUI',exact:true}).click();await expect(sender).toContainText('Sent to ComfyUI.');
         expect(await host.evaluate(()=>window.cardApplied)).toEqual([{positive:longPrompt}]);

tests/browser/workspace-system-integrations.spec.mjs

@@ -99,7 +99,7 @@ test('send destination offers Ask each time; unsupported options disabled with t
         .toEqual([['Ask each time', false], ['Selected Prompt Manager node', true], ['Create a Prompt Manager (+/-) node', true]]);
     await expect(send.locator('select')).toHaveValue('Ask each time');
     await expect(send.locator('p.small')).toHaveText(
-        'Sending always asks for the ComfyUI window and node, so “Ask each time” is the only option.');
+        'Sending asks when there is more than one ComfyUI window or node, so “Ask each time” is the only option.');
     const renderer = settingOf(page, 'Host compatibility');
     expect(await renderer.locator('option').evaluateAll(options => options.map(option => [option.textContent, option.disabled])))
         .toEqual([['Follow host renderer', false], ['Classic', true], ['Nodes 2.0', true]]);

tests/comfyui/inspect-sender.spec.mjs

@@ -93,7 +93,7 @@ test('local file roles send exactly across renderer transitions',async({page,con
                 } finally {await restore(page);}
             }
         }
-        // A connected destination input rejects the whole preview: neither role changes, nothing queues or loads.
+        // A connected destination input blocks the whole send: neither role changes, nothing queues or loads.
         const link=await page.evaluate(async id=>{
             const {app}=await import('/scripts/app.js');const {convertToInput}=await import('/extensions/core/widgetInputs.js');
             const node=app.graph.getNodeById(id);const widget=node.widgets.find(item=>item.name==='negative_text');
@@ -108,8 +108,11 @@ test('local file roles send exactly across renderer transitions',async({page,con
             const before=await nodeState(page,id);
             expect(before.widgets).toMatchObject({text:'Before positive',negative_text:'Before negative'});
             const rail=await inspect(workspace,FILES[1]);
-            const sender=await preview(workspace,rail);
-            await expect(sender.getByRole('alert')).toContainText(/connected/i);
+            // #535: the linked node is not offered, and the status line says why.
+            await rail.getByRole('button',{name:/^Send prompt pair to ComfyUI: /}).click();
+            const sender=workspace.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
+            await expect(sender).toContainText(/has its negative prompt linked to another node/);
+            await expect(sender.getByRole('button',{name:'Preview changes',exact:true})).toBeDisabled();
             await expect(sender.getByRole('button',{name:'Apply to ComfyUI',exact:true})).toBeDisabled();
             const rejected=await nodeState(page,id);
             expect(rejected.effects).toEqual({queue:0,load:0});

tests/comfyui/library-sender.spec.mjs

@@ -117,10 +117,9 @@ test('native editor preview sends exact saved roles across renderer transitions'
         try {
             await send.click();
             const sender=workspace.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
-            const hosts=sender.getByRole('combobox',{name:'ComfyUI window',exact:true});await expect(hosts.locator('option')).toHaveCount(2);await hosts.selectOption({index:1});
-            await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({index:1});
-            await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
-            await expect(sender.getByRole('alert')).toContainText(/connected/i);
+            // #535: the linked node is not offered, and the status line says why.
+            await expect(sender).toContainText(/has its negative prompt linked to another node/);
+            await expect(sender.getByRole('button',{name:'Preview changes',exact:true})).toBeDisabled();
             await expect(sender.getByRole('button',{name:'Apply to ComfyUI',exact:true})).toBeDisabled();
             const rejected=await page.evaluate(async id=>{
                 const {app}=await import('/scripts/app.js');const node=app.graph.getNodeById(id);const serialized=node.serialize();

tests/comfyui/prompt-sender.spec.mjs

@@ -68,8 +68,14 @@ test('native image inspector previews and sends a pair into real visible widgets
         const sender=workspace.getByRole('dialog',{name:'Send to ComfyUI',exact:true});
         const hosts=sender.getByRole('combobox',{name:'ComfyUI window',exact:true});
         await expect(hosts.locator('option')).toHaveCount(2);
-        await hosts.selectOption({index:1});
-        await sender.getByRole('combobox',{name:'Destination node',exact:true}).selectOption({index:1});
+        // #535: the window is named by its tab, and one window with one node needs no choosing.
+        const tabTitle=await page.title();
+        await expect(hosts.locator('option').nth(1)).toHaveText(tabTitle);
+        expect(tabTitle).not.toContain('PromptManager');
+        await expect(hosts).not.toHaveValue('');
+        await expect(sender.getByRole('combobox',{name:'Destination node',exact:true})).not.toHaveValue('');
+        await expect(sender.getByRole('status')).toContainText(`in ${tabTitle}. Apply to send it, or preview the changes first.`);
+        await expect(sender.getByRole('combobox',{name:'Destination node',exact:true}).locator('option').nth(1)).toHaveText(new RegExp(`^#${id} `));
         await sender.getByRole('button',{name:'Preview changes',exact:true}).click();
         for(const text of ['Before positive','Before negative',positive,negative,`LoRA trigger ${positive} fine detail`])await expect(sender).toContainText(text);
         await expect(nodeRoot.getByRole('textbox',{name:'Positive prompt',exact:true})).toHaveValue('Before positive');
@@ -86,5 +92,66 @@ test('native image inspector previews and sends a pair into real visible widgets
         for(const name of ['inputs','serialized'])expect(state[name]).toMatchObject({text:positive,negative_text:negative,prepend_text:'LoRA trigger',append_text:'fine detail'});
         expect(state.effects).toEqual({queue:0,load:0});expect(errors).toEqual([]);
         await workspace.screenshot({path:testInfo.outputPath('full-inspector-host-send.png')});
+        // #535 D175: Apply without Preview, one click, and a double click sends once.
+        const apply=sender.getByRole('button',{name:'Apply to ComfyUI',exact:true});
+        const find0=sender.getByRole('button',{name:'Find ComfyUI windows',exact:true});
+        const positiveBox=nodeRoot.getByRole('textbox',{name:'Positive prompt',exact:true});
+        await positiveBox.fill('Typed before one click');
+        await find0.click();
+        await expect(apply).toBeEnabled();
+        await apply.dblclick();
+        await expect(sender).toContainText('Sent to ComfyUI.');
+        await expect(positiveBox).toHaveValue(positive);
+        await expect(apply).toBeDisabled();
+        // Edited in ComfyUI after the send: a stray second send would overwrite this.
+        await positiveBox.fill('Typed after the send');
+        await expect(positiveBox).toHaveValue('Typed after the send');
+        // A changed workflow since discovery refuses through one-click Apply, and writes nothing.
+        await find0.click();
+        await expect(apply).toBeEnabled();
+        await page.evaluate(async()=>{const {app}=await import('/scripts/app.js');await app.loadGraphData(app.graph.serialize());});
+        await apply.click();
+        await expect(sender.getByRole('alert')).toContainText(/workflow changed/i);
+        await expect(positiveBox).toHaveValue('Typed after the send');
+        // A field linked after discovery refuses the same way.
+        await find0.click();
+        await expect(apply).toBeEnabled();
+        await page.evaluate(async id=>{
+            const {app}=await import('/scripts/app.js');const {convertToInput}=await import('/extensions/core/widgetInputs.js');
+            const node=app.graph.getNodeById(id);const widget=node.widgets.find(widget=>widget.name==='negative_text');
+            if(!node.inputs.some(input=>input.name==='negative_text'))convertToInput(node,widget);
+            const source=LiteGraph.createNode('PrimitiveString');app.graph.add(source);
+            source.connect(0,node,node.inputs.findIndex(input=>input.name==='negative_text'));
+        },id);
+        await apply.click();
+        await expect(sender.getByRole('alert')).toContainText(/connected/i);
+        await expect(positiveBox).toHaveValue('Typed after the send');
+        await page.evaluate(async id=>{const {app}=await import('/scripts/app.js');const node=app.graph.getNodeById(id);node.disconnectInput(node.inputs.findIndex(input=>input.name==='negative_text'));},id);
+        // Two identical nodes are never selected for you, and read "#<id> <title>".
+        const twinId=await page.evaluate(async()=>{const {app}=await import('/scripts/app.js');const node=LiteGraph.createNode('PromptManagerPair');app.graph.add(node);return node.id;});
+        await find0.click();
+        const targets=sender.getByRole('combobox',{name:'Destination node',exact:true});
+        await expect(targets.locator('option')).toHaveCount(3);
+        await expect(targets).toHaveValue('');
+        await expect(apply).toBeDisabled();
+        await expect(targets.locator('option').nth(2)).toHaveText(new RegExp(`^#${twinId} `));
+        await page.evaluate(async twinId=>{const {app}=await import('/scripts/app.js');app.graph.remove(app.graph.getNodeById(twinId));},twinId);
+        // #535: the status line says why a window cannot receive.
+        const find=sender.getByRole('button',{name:'Find ComfyUI windows',exact:true});
+        const preview=sender.getByRole('button',{name:'Preview changes',exact:true});
+        await page.evaluate(async id=>{
+            const {app}=await import('/scripts/app.js');const {convertToInput}=await import('/extensions/core/widgetInputs.js');
+            const node=app.graph.getNodeById(id);const widget=node.widgets.find(widget=>widget.name==='text');
+            if(!node.inputs.some(input=>input.name==='text'))convertToInput(node,widget);
+            const source=LiteGraph.createNode('PrimitiveString');app.graph.add(source);
+            source.connect(0,node,node.inputs.findIndex(input=>input.name==='text'));
+        },id);
+        await find.click();
+        await expect(sender).toContainText(/has its positive prompt linked to another node/);
+        await expect(preview).toBeDisabled();
+        await page.evaluate(async()=>{const {app}=await import('/scripts/app.js');app.graph.clear();});
+        await find.click();
+        await expect(sender).toContainText('has no Prompt Manager node.');
+        await expect(preview).toBeDisabled();
     } finally {await workspace.close();}
 });

tests/js/prompt-bridge-adapter.test.js

@@ -151,3 +151,22 @@ test('callback failure preserves serialization normalized between preview and ap
     node.widgets_values=node.widgets.map(item=>item.value); widget('text').callback=()=>{throw new Error('callback failed');};
     assert.throws(()=>adapter.apply(snapshot),/failed/); assert.equal(node.widgets_values[0],'old'); assert.equal(widget('text').value,'old');
 });
+
+test('listTargets reports which roles are linked to an upstream node',async()=>{
+    const {createPromptAdapter}=await import('../../web/js/prompt-bridge-adapter.js');
+    const widgets=[{name:'text',value:''},{name:'negative_text',value:''}];
+    const app={graph:{_nodes:[{id:1,type:'PromptManagerPair',widgets,inputs:[{name:'text',link:null},{name:'negative_text',link:4}]},{id:2,type:'PromptManager',widgets,inputs:[]}]}};
+    const [pair,plain]=createPromptAdapter(app,{runtime:{}}).listTargets();
+    assert.deepEqual(pair.linkedRoles,['negative']);assert.deepEqual(plain.linkedRoles,[]);
+});
+
+test('the revision moves when the graph is edited and when a load replaces the node, even at the same version',async()=>{
+    const {createPromptAdapter}=await import('../../web/js/prompt-bridge-adapter.js');
+    const node=()=>({id:1,type:'PromptManager',widgets:[{name:'text',value:''}],inputs:[]});
+    const app={graph:{_version:9,_nodes:[node()]}};
+    const adapter=createPromptAdapter(app,{runtime:{}});
+    const first=adapter.listTargets()[0].revision;
+    assert.equal(adapter.preview('1',{positive:'x'}).preview.revision,first);
+    app.graph._version=10;const edited=adapter.listTargets()[0].revision;assert.notEqual(edited,first);
+    app.graph={_version:10,_nodes:[node()]};assert.notEqual(adapter.listTargets()[0].revision,edited);
+});

tests/js/prompt-bridge-host.test.js

@@ -1,6 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { installPromptBridge } from '../../web/js/prompt-bridge-host.js';
+import { createBridgeClient, createBridgeHost } from '../../web/js/shared/toolkit/prompt-bridge.js';
 
 function fixture() {
     const runtime = new EventTarget();
@@ -19,7 +20,10 @@ test('host uses the exact deployment prefix and explicit pack label', () => {
     assert.equal(f.hosts.length, 1);
     assert.equal(f.hosts[0].config.namespace, '/team/');
     assert.equal(f.hosts[0].config.origin, 'https://comfy.example');
-    assert.equal(f.hosts[0].config.label, 'PromptManager — My workflow');
+    assert.equal(f.hosts[0].config.label, 'My workflow');
+    f.runtime.document.title = '';
+    assert.equal(f.hosts[0].config.label, 'ComfyUI');
+    f.runtime.document.title = 'My workflow';
     assert.equal(f.hosts[0].config.adapter, f.adapter);
     assert.equal(installPromptBridge(app, f.options), controller);
     controller.dispose(); controller.dispose();
@@ -66,3 +70,24 @@ test('deployment namespace rejects external origins and unexpected paths', () =>
         assert.equal(f.hosts.length, 0);
     }
 });
+
+test('each discovery reports the title the tab has now, through the real Toolkit host', async () => {
+    const f = fixture();
+    f.runtime.location = { origin: 'https://comfy.example', href: 'https://comfy.example/' };
+    f.options.baseUrl = '/prompt_manager/';
+    const listeners = new Set();
+    const channelFactory = () => { const own = new Set(); return {
+        addEventListener(type, listener) { if (type === 'message') { own.add(listener); listeners.add(listener); } }, removeEventListener(type, listener) { listeners.delete(listener); },
+        postMessage(data) { for (const listener of [...listeners]) if (!own.has(listener)) queueMicrotask(() => listener({ data: structuredClone(data), origin: 'https://comfy.example' })); }, close() {},
+    }; };
+    // Not spread: a copy would freeze the title the host must keep reading.
+    f.options.hostFactory = config => { config.channelFactory = channelFactory; return createBridgeHost(config); };
+    f.adapter.listTargets = () => []; f.adapter.preview = () => {}; f.adapter.apply = () => {};
+    f.runtime.document.title = 'ComfyUI';
+    const controller = installPromptBridge({}, f.options);
+    const client = createBridgeClient({ namespace: '/', origin: 'https://comfy.example', channelFactory });
+    f.runtime.document.title = '*Unsaved Workflow - ComfyUI';
+    try {
+        assert.equal((await client.discover({ waitMs: 100 }))[0].label, '*Unsaved Workflow - ComfyUI');
+    } finally { client.dispose(); controller.dispose(); }
+});

tests/js/prompt-sender.test.js

@@ -11,18 +11,17 @@ function setup(createSendSession, overrides = {}, roles = {positive:'new'}) {
 }
 test('sender requires explicit compatible host and target, preview, then acknowledged apply', async () => {
     const {createSendSession} = await source; const s=setup(createSendSession);
-    await s.session.discover(); assert.equal(s.session.state.hostId,'');assert.equal(s.session.state.targetId,'');
+    await s.session.discover(); assert.equal(s.session.state.hostId,'host');assert.equal(s.session.state.targetId,'');
     await s.session.preview(); assert.equal(s.calls.length,0);
-    s.session.selectHost('host');assert.equal(s.session.state.targetId,''); s.session.selectTarget('one');
-    await s.session.apply();assert.equal(s.calls.length,0);
+    s.session.selectTarget('one');
     await s.session.preview();assert.equal(s.session.state.phase,'ready');assert.equal(s.session.state.preview.composition.after,'prefix new');
     await s.session.apply();assert.equal(s.session.state.phase,'success');assert.equal(s.calls.filter(call=>call[0]==='apply').length,1);
     await s.session.apply();assert.equal(s.calls.filter(call=>call[0]==='apply').length,1); s.session.dispose();
 });
-test('pair roles filter incompatible nodes and do not silently choose the sole destination', async()=>{
+test('pair roles filter incompatible nodes and select the sole destination', async()=>{
     const {createSendSession}=await source;const s=setup(createSendSession,{}, {positive:'',negative:'bad'});
     await s.session.discover();assert.deepEqual(s.session.state.hosts[0].targets.map(target=>target.id),['pair']);
-    s.session.selectHost('host');s.session.selectTarget('one');assert.equal(s.session.state.targetId,'');
+    assert.equal(s.session.state.targetId,'pair');s.session.selectTarget('one');assert.equal(s.session.state.targetId,'');
     s.session.selectTarget('pair');assert.equal(s.session.state.targetId,'pair');s.session.dispose();
 });
 test('late previews are ignored after target changes; aborted and disposed work cannot update state',async()=>{
@@ -44,20 +43,127 @@ test('only matching explicit acknowledgements count as success',async()=>{
     }
 });
 test('discovery, empty results and stale preview errors remain actionable',async()=>{
-    const {createSendSession}=await source;const s=setup(createSendSession,{discover:async()=>[]});await s.session.discover();assert.match(s.session.state.message,/No compatible/i);s.session.dispose();
+    const {createSendSession}=await source;const s=setup(createSendSession,{discover:async()=>[]});await s.session.discover();assert.match(s.session.state.message,/No ComfyUI window answered/i);s.session.dispose();
     const failed=setup(createSendSession,{discover:async()=>{throw Error('unavailable');}});await failed.session.discover();assert.match(failed.session.state.message,/unavailable/);failed.session.dispose();
     const stale=setup(createSendSession,{preview:async()=>{throw Error('Workflow changed. Preview again.');}});await stale.session.discover();stale.session.selectHost('host');stale.session.selectTarget('one');await stale.session.preview();assert.match(stale.session.state.message,/Workflow changed/);stale.session.dispose();
 });
 test('rediscovery invalidates selections and old discovery cannot replace new results',async()=>{
     const {createSendSession}=await source;let resolve;let count=0;const s=setup(createSendSession,{discover:()=>++count===1?new Promise(done=>resolve=done):Promise.resolve(hosts)});
     const first=s.session.discover();await s.session.discover();resolve([]);await first;assert.equal(s.session.state.hosts.length,1);
-    s.session.selectHost('host');s.session.selectTarget('one');await s.session.preview();await s.session.discover();assert.equal(s.session.state.hostId,'');assert.equal(s.session.state.preview,null);s.session.dispose();
+    s.session.selectHost('host');s.session.selectTarget('one');await s.session.preview();await s.session.discover();assert.equal(s.session.state.hostId,'host');assert.equal(s.session.state.targetId,'');assert.equal(s.session.state.preview,null);s.session.dispose();
 });
 test('pending apply explains closing cannot undo the sent update',async()=>{
     const {createSendSession}=await source;let done;const s=setup(createSendSession,{apply:()=>new Promise(resolve=>done=resolve)});
     await s.session.discover();s.session.selectHost('host');s.session.selectTarget('one');await s.session.preview();const pending=s.session.apply();
     assert.match(s.session.state.message,/Closing this dialog does not undo/i);s.session.dispose();done({targetId:'one',values:{positive:'new'}});await pending;
 });
+const window1=(targets,label='Flow - ComfyUI',hostId='a')=>({hostId,label,targets});
+const pm=(id,roles=['positive'],extra={})=>({id,label:`Node ${id}`,roles,...extra});
+async function discovered(createSendSession,found,roles={positive:'new'}) {
+    const s=setup(createSendSession,{discover:async()=>found},roles);await s.session.discover();return s;
+}
+test('one window with one eligible node is selected so Preview is available at once',async()=>{
+    const {createSendSession}=await source;const s=await discovered(createSendSession,[window1([pm('1')])]);
+    assert.equal(s.session.state.hostId,'a');assert.equal(s.session.state.targetId,'1');
+    assert.match(s.session.state.message,/#1 Node 1 in Flow - ComfyUI.*Apply/);
+    await s.session.preview();assert.equal(s.session.state.phase,'ready');s.session.dispose();
+});
+test('several windows are left to choose, and choosing one with a single node selects that node',async()=>{
+    const {createSendSession}=await source;const s=await discovered(createSendSession,[window1([pm('1')],'A','a'),window1([pm('2'),pm('3')],'B','b')]);
+    assert.equal(s.session.state.hostId,'');assert.equal(s.session.state.targetId,'');assert.match(s.session.state.message,/Choose a ComfyUI window/);
+    s.session.selectHost('a');assert.equal(s.session.state.targetId,'1');
+    s.session.selectHost('b');assert.equal(s.session.state.targetId,'');assert.match(s.session.state.message,/Choose a destination node in B/);
+    s.session.selectHost('');assert.match(s.session.state.message,/Choose a ComfyUI window/);
+    s.session.selectHost('b');s.session.selectTarget('2');s.session.selectTarget('');assert.match(s.session.state.message,/Choose a destination node/);s.session.dispose();
+});
+test('a window that cannot receive says why, naming the window and the node',async()=>{
+    const {createSendSession}=await source;
+    let s=await discovered(createSendSession,[window1([])]);
+    assert.match(s.session.state.message,/Flow - ComfyUI has no Prompt Manager node/);assert.equal(s.session.state.hosts.length,0);s.session.dispose();
+    s=await discovered(createSendSession,[window1([]),window1([],'Other','b')]);
+    assert.match(s.session.state.message,/None of the 2 ComfyUI windows has a Prompt Manager node/);s.session.dispose();
+    s=await discovered(createSendSession,[window1([pm('1',['positive'],{linkedRoles:['positive']})])]);
+    assert.match(s.session.state.message,/Node 1 in Flow - ComfyUI has its positive prompt linked/);assert.equal(s.session.state.hosts.length,0);s.session.dispose();
+    s=await discovered(createSendSession,[window1([pm('1')])],{positive:'p',negative:'n'});
+    assert.match(s.session.state.message,/Flow - ComfyUI has no Prompt Manager node that accepts a positive and negative prompt.*\(\+\/-\)/);s.session.dispose();
+});
+test('a linked node is not offered beside an eligible one, and an unlinked role still is',async()=>{
+    const {createSendSession}=await source;
+    let s=await discovered(createSendSession,[window1([pm('1',['positive'],{linkedRoles:['positive']}),pm('2')])]);
+    assert.deepEqual(s.session.state.hosts[0].targets.map(target=>target.id),['2']);assert.equal(s.session.state.targetId,'2');s.session.dispose();
+    s=await discovered(createSendSession,[window1([pm('1',['positive','negative'],{linkedRoles:['negative']})])]);
+    assert.equal(s.session.state.targetId,'1');s.session.dispose();
+});
+test('an auto-selected destination says how many other nodes cannot receive, and the review names the destination',async()=>{
+    const {createSendSession}=await source;
+    const s=await discovered(createSendSession,[window1([pm('2')],'A','a'),window1([pm('1',['positive'],{linkedRoles:['positive']})],'B','b')]);
+    assert.equal(s.session.state.targetId,'2');assert.match(s.session.state.message,/1 other Prompt Manager node cannot receive/);
+    await s.session.preview();s.session.dispose();
+    const named=setup(createSendSession,{discover:async()=>[window1([pm('one')])],preview:async(_,id)=>({ticket:'t',target:{id,label:'Live title'},fields:[{role:'positive',before:'',after:'new'}]})});
+    await named.session.discover();await named.session.preview();assert.match(named.session.state.message,/Sending to #one Live title in Flow - ComfyUI/);named.session.dispose();
+});
+test('window order and numbering do not depend on which tab answered first',async()=>{
+    const {createSendSession}=await source;const s=await discovered(createSendSession,[window1([pm('1')],'T','b'),window1([pm('2')],'T','a')]);
+    assert.deepEqual(s.session.state.hosts.map(host=>[host.hostId,host.label]),[['a','T'],['b','T (window 2)']]);s.session.dispose();
+});
+const applied=calls=>calls.filter(call=>call[0]==='apply').length;
+test('Apply without Preview fetches the ticket and applies in one click',async()=>{
+    const {createSendSession}=await source;const s=setup(createSendSession,{discover:async()=>[window1([pm('one')])]});
+    await s.session.discover();await s.session.apply();
+    assert.equal(s.session.state.phase,'success');assert.deepEqual(s.calls.map(call=>call[0]),['preview','apply']);s.session.dispose();
+});
+test('a double click applies once, during the send and after it',async()=>{
+    const {createSendSession}=await source;const s=setup(createSendSession,{discover:async()=>[window1([pm('one')])]});
+    await s.session.discover();const first=s.session.apply();const second=s.session.apply();await Promise.all([first,second]);
+    assert.equal(applied(s.calls),1);await s.session.apply();assert.equal(applied(s.calls),1);s.session.dispose();
+});
+test('Apply after a preview uses its ticket and does not preview again',async()=>{
+    const {createSendSession}=await source;const s=setup(createSendSession,{discover:async()=>[window1([pm('one')])]});
+    await s.session.discover();await s.session.preview();await s.session.apply();
+    assert.deepEqual(s.calls.map(call=>call[0]),['preview','apply']);assert.equal(s.session.state.phase,'success');s.session.dispose();
+});
+test('Apply needs a destination',async()=>{
+    const {createSendSession}=await source;const s=setup(createSendSession);
+    await s.session.discover();await s.session.apply();assert.equal(s.calls.length,0);s.session.dispose();
+});
+test('a refusal at the fetched preview says so plainly and writes nothing; Apply can try again',async()=>{
+    const {createSendSession}=await source;let refuse=true;
+    const s=setup(createSendSession,{discover:async()=>[window1([pm('one')])],preview:async(_,id)=>{if(refuse)throw Error('positive is connected to an upstream input.');return{ticket:'t',target:{id},fields:[{role:'positive',before:'',after:'new'}]};}});
+    await s.session.discover();await s.session.apply();
+    assert.equal(s.session.state.phase,'error');assert.match(s.session.state.message,/connected/);assert.doesNotMatch(s.session.state.message,/may have applied/);
+    refuse=false;await s.session.apply();assert.equal(s.session.state.phase,'success');s.session.dispose();
+});
+test('a host refusal at apply is a refusal; only a lost reply is an unknown outcome',async()=>{
+    const {createSendSession}=await source;
+    const s=setup(createSendSession,{discover:async()=>[window1([pm('one')])],apply:async()=>{throw Error('Workflow or prompt changed. Preview again.');}});
+    await s.session.discover();await s.session.apply();assert.match(s.session.state.message,/Workflow or prompt changed/);assert.doesNotMatch(s.session.state.message,/may have applied/);s.session.dispose();
+    const lost=setup(createSendSession,{discover:async()=>[window1([pm('one')])],apply:async()=>{throw Error('Bridge request timed out');}});
+    await lost.session.discover();await lost.session.apply();assert.match(lost.session.state.message,/may have applied/);
+    await lost.session.apply();assert.equal(lost.calls.filter(call=>call[0]==='preview').length,1);
+    lost.session.selectTarget('one');await lost.session.apply();assert.equal(lost.calls.filter(call=>call[0]==='preview').length,2);lost.session.dispose();
+});
+test('a workflow changed since discovery refuses before anything is written',async()=>{
+    const {createSendSession}=await source;
+    for(const op of ['apply','preview']){
+        const s=setup(createSendSession,{discover:async()=>[window1([pm('one',['positive'],{revision:'1:4'})])],preview:async(_,id)=>({ticket:'t',revision:'1:5',target:{id},fields:[{role:'positive',before:'',after:'new'}]})});
+        await s.session.discover();await s.session[op]();
+        assert.equal(s.session.state.phase,'error');assert.match(s.session.state.message,/workflow changed/i);assert.equal(applied(s.calls),0);s.session.dispose();
+    }
+    const stale=setup(createSendSession,{discover:async()=>[window1([pm('one')])]});await stale.session.discover();await stale.session.apply();assert.equal(stale.session.state.phase,'success');stale.session.dispose();
+});
+test('two or more eligible nodes are never auto-selected, and each option shows id and title',async()=>{
+    const {createSendSession}=await source;const twin=id=>({id,label:'Prompt Manager (+/-)',roles:['positive']});
+    const s=await discovered(createSendSession,[window1([twin('72'),twin('73')])]);
+    assert.equal(s.session.state.targetId,'');assert.deepEqual(s.session.state.hosts[0].targets.map(target=>target.label),['#72 Prompt Manager (+/-)','#73 Prompt Manager (+/-)']);
+    await s.session.apply();assert.equal(s.calls.length,0);s.session.dispose();
+    const one=await discovered(createSendSession,[window1([twin('72')])]);assert.equal(one.session.state.hosts[0].targets[0].label,'#72 Prompt Manager (+/-)');assert.equal(one.session.state.targetId,'72');one.session.dispose();
+});
+test('same-named windows and nodes stay distinguishable',async()=>{
+    const {createSendSession}=await source;const twin=id=>({id,label:'Same',roles:['positive']});
+    const s=await discovered(createSendSession,[window1([twin('7'),twin('8')],'T','a'),window1([pm('1')],'T','b')]);
+    assert.deepEqual(s.session.state.hosts.map(host=>host.label),['T','T (window 2)']);
+    assert.deepEqual(s.session.state.hosts[0].targets.map(target=>target.label),['#7 Same','#8 Same']);s.session.dispose();
+});
 function fakeDOM() {
     class Node extends EventTarget {
         constructor(tag){super();this.tagName=tag;this.children=[];this.attributes={};this.dataset={};this.value='';this.textContent='';this.isConnected=true;this.open=false;}
@@ -89,7 +195,7 @@ test('native sender dialog uses prefixed namespace, full safe text, explicit cho
         assert.deepEqual(options,{namespace:'/prefix/',origin:'https://example.test'});
         const dialog=dom.body.children.at(-1);assert.equal(dialog.open,true);assert.equal(dialog.attributes['aria-label'],'Send to ComfyUI');
         const host=dom.find(dialog,node=>node.id==='prompt-sender-host');const target=dom.find(dialog,node=>node.id==='prompt-sender-target');
-        assert.equal(host.value,'');assert.equal(target.value,'');host.value='host';host.dispatchEvent(new Event('change'));target.value='one';target.dispatchEvent(new Event('change'));
+        assert.equal(host.value,'host');assert.equal(target.value,'');target.value='one';target.dispatchEvent(new Event('change'));
         dom.find(dialog,node=>node.textContent==='Preview changes').dispatchEvent(new Event('click'));await tick();
         assert.ok(dom.find(dialog,node=>node.tagName==='code' && node.textContent==='(empty)'));assert.ok(dom.find(dialog,node=>node.tagName==='code' && node.textContent==='<unsafe>new</unsafe>'));
         const apply=dom.find(dialog,node=>node.textContent==='Apply to ComfyUI');assert.equal(apply.className,'ca-primary');assert.equal(apply.disabled,false);apply.dispatchEvent(new Event('click'));await tick();

web/js/prompt-bridge-adapter.js

@@ -12,6 +12,7 @@ const compositionNames = ['prepend_text','append_text'];
 function nodes(graph) { return graph?._nodes || []; }
 function target(node) { return {id:String(node.id),label:String(node.title || node.type),type:node.type}; }
 function connected(node,name) { return Boolean(node.inputs?.some(input => input.name === name && input.link != null)); }
+function linkedRoles(node) { return Object.entries(schemas.get(node.type)).filter(([,name]) => connected(node,name)).map(([role]) => role); }
 function links(node) { return JSON.stringify((node.inputs || []).map(input => [input.name,input.link ?? null])); }
 function capture(node,name) {
     const widget = node.widgets?.find(item => item.name === name);
@@ -57,9 +58,16 @@ function renderer(runtime) {
 
 export function createPromptAdapter(app, {runtime = globalThis} = {}) {
     const snapshots = new WeakMap();
+    // Loading a workflow makes new node objects but can land on the same graph version, so a revision needs both.
+    const nodeSerials = new WeakMap();
+    let lastSerial = 0;
+    function revision(node) {
+        if (!nodeSerials.has(node)) nodeSerials.set(node,++lastSerial);
+        return `${nodeSerials.get(node)}:${app.graph?._version}`;
+    }
     function listTargets() {
         const drawn = renderer(runtime);
-        return nodes(app.graph).filter(node => schemas.has(node.type)).map(node => ({...target(node),roles:Object.keys(schemas.get(node.type)),...drawn}));
+        return nodes(app.graph).filter(node => schemas.has(node.type)).map(node => ({...target(node),roles:Object.keys(schemas.get(node.type)),linkedRoles:linkedRoles(node),revision:revision(node),...drawn}));
     }
     function preview(targetId,rawRoles) {
         const roles = validateRoles(rawRoles);
@@ -77,7 +85,7 @@ export function createPromptAdapter(app, {runtime = globalThis} = {}) {
         });
         const snapshot = Object.freeze({});
         snapshots.set(snapshot,{graph,node,type:node.type,id:String(node.id),version:graph._version,widgets:node.widgets,widgetOrder:[...node.widgets],fields,links:links(node),requested});
-        return {preview:{target:target(node),fields:requested.map(({role,after,field}) => ({role,before:String(field.value ?? ''),after})),composition:composition(node,fields,roles)},snapshot};
+        return {preview:{target:target(node),revision:revision(node),fields:requested.map(({role,after,field}) => ({role,before:String(field.value ?? ''),after})),composition:composition(node,fields,roles)},snapshot};
     }
     function apply(snapshot) {
         const state = snapshots.get(snapshot);

web/js/prompt-bridge-host.js

@@ -16,7 +16,8 @@ export function installPromptBridge(app, { baseUrl, runtime = globalThis,
         if (host || disposed) return;
         try {
             host = hostFactory({ namespace, origin: runtime.location.origin,
-                label: `PromptManager — ${runtime.document.title || 'ComfyUI'}`, adapter: adapterFactory(app) });
+                // A getter: the Toolkit reads this on every discovery, and the tab title follows the open workflow.
+                get label() { return runtime.document.title || 'ComfyUI'; }, adapter: adapterFactory(app) });
         } catch (error) {
             runtime.console.warn('[PromptManager] Prompt sending is unavailable:', error.message);
         }

web/js/workspace/prompt-sender.mjs

@@ -1,51 +1,117 @@
 import {createBridgeClient, validateRoles} from '../shared/toolkit/prompt-bridge.js';
 import {createButton, createField, createScope, createSelect} from '../shared/toolkit/core.js';
 
+// The same wait as System's renderer line, so a busy tab is not reported as missing.
+const DISCOVERY_WAIT_MS = 300;
+const roleNames = roles => Object.keys(roles).join(' and ');
+const roleOf = target => Array.isArray(target.roles) ? target.roles : [];
+const accepts = (target,roles) => typeof target.id==='string' && Object.keys(roles).every(role=>roleOf(target).includes(role));
+const linkedTo = (target,roles) => Object.keys(roles).filter(role=>Array.isArray(target.linkedRoles) && target.linkedRoles.includes(role));
+
+const nodeLabel = target => `#${target.id} ${target.label}`;
+// A lost reply leaves the outcome unknown; anything else the host said is a refusal, and nothing was written.
+const LOST_REPLY = /timed out|aborted|disposed/i;
+
+/** Why nothing in the discovered windows can receive these roles, most specific first (D173). */
+function unavailableMessage(found,roles) {
+    if (!found.length) return 'No ComfyUI window answered in this browser at this address. Open ComfyUI here, then find windows again.';
+    for (const host of found) for (const target of host.targets) {
+        const linked = accepts(target,roles) ? linkedTo(target,roles) : [];
+        if (linked.length) return `${nodeLabel(target)} in ${host.label} has its ${linked.join(' and ')} prompt linked to another node, so it cannot receive text. Disconnect the link, then find windows again.`;
+    }
+    const where = found.length===1 ? found[0].label : `None of the ${found.length} ComfyUI windows`;
+    const verb = found.length===1 ? 'has no' : 'has a';
+    if (found.some(host=>host.targets.length)) {
+        const need = Object.hasOwn(roles,'negative') ? ' Add a Prompt Manager (+/-) node, then find windows again.' : ' Add one, then find windows again.';
+        return `${where} ${verb} Prompt Manager node that accepts a ${roleNames(roles)} prompt.${need}`;
+    }
+    return `${where} ${verb} Prompt Manager node. Add one to the workflow, then find windows again.`;
+}
+/** Keeps same-named windows apart: tabs on one workflow. */
+function distinctLabels(items,suffix) {
+    const seen = new Map();
+    const totals = new Map();
+    for (const item of items) totals.set(item.label,(totals.get(item.label) || 0)+1);
+    return items.map(item => {
+        const count = (seen.get(item.label) || 0)+1;seen.set(item.label,count);
+        return totals.get(item.label)>1 ? {...item,label:suffix(item,count)} : item;
+    });
+}
+
 export function createSendSession({client, roles:rawRoles, onChange}) {
     const roles = Object.freeze(validateRoles(rawRoles));
-    let state = {phase:'idle',hosts:[],hostId:'',targetId:'',preview:null,message:''};
+    let state = {phase:'idle',hosts:[],hostId:'',targetId:'',preview:null,outcomeUnknown:false,message:''};
     let operation, generation = 0, disposed = false;
     const emit = patch => { if (!disposed) { state = Object.freeze({...state,...patch}); onChange(state); } };
     function invalidate() { generation++; operation?.abort(); operation = null; }
-    function begin(phase) { invalidate(); operation = new AbortController(); emit({phase,preview:null,message:''}); return {signal:operation.signal,version:generation}; }
+    function begin(phase) { invalidate(); operation = new AbortController(); emit({phase,preview:null,outcomeUnknown:false,message:''}); return {signal:operation.signal,version:generation}; }
     const current = request => !disposed && generation === request.version;
     const selected = () => state.hosts.find(host=>host.hostId===state.hostId)?.targets.find(target=>target.id===state.targetId);
+    async function fetchPreview(request) {
+        const preview=await client.preview(state.hostId,state.targetId,roles,{signal:request.signal});
+        if (!current(request)) return null;
+        const fields=preview?.fields;
+        if(typeof preview?.ticket!=='string' || !preview.ticket || preview.target?.id!==state.targetId || !Array.isArray(fields) || fields.length!==Object.keys(roles).length || new Set(fields.map(field=>field?.role)).size!==fields.length || Array.from(fields).some(field=>!field || !Object.hasOwn(roles,field.role) || typeof field.before!=='string' || field.after!==roles[field.role])) throw Error('ComfyUI returned an unexpected preview. Find the destination and preview again.');
+        // Undefined on a tab still running older code, which has nothing to compare.
+        const found=selected()?.revision;
+        if(found!==undefined && preview.revision!==found) throw Error('The workflow changed since this window was found. Nothing was sent. Find windows again.');
+        return preview;
+    }
+    function hostChoice(host) {
+        if (host.targets.length>1) return {hostId:host.hostId,targetId:'',message:`Choose a destination node in ${host.label}.`};
+        const [target] = host.targets;
+        return {hostId:host.hostId,targetId:target.id,message:`Sending to ${target.label} in ${host.label}. Apply to send it, or preview the changes first.`};
+    }
     return {
         get state() { return state; },
         async discover() {
             if (disposed) return;
             const request = begin('discovering'); emit({hosts:[],hostId:'',targetId:'',message:'Looking for ComfyUI windows…'});
             try {
-                const found = await client.discover({signal:request.signal});
+                const found = (await client.discover({signal:request.signal,waitMs:DISCOVERY_WAIT_MS})).map(host=>({...host,targets:host.targets.filter(target=>target && typeof target==='object')}));
                 if (!current(request)) return;
-                const hosts = found.map(host=>({...host,targets:host.targets.filter(target=>typeof target.id==='string' && Array.isArray(target.roles) && Object.keys(roles).every(role=>target.roles.includes(role)))})).filter(host=>host.targets.length);
-                emit({phase:'select',hosts,message:hosts.length ? 'Choose a ComfyUI window and destination node.' : 'No compatible ComfyUI windows found. Open a workflow with a compatible Prompt Manager node, then find windows again.'});
+                const hosts = distinctLabels(found.toSorted((a,b)=>a.hostId<b.hostId?-1:1).map(host=>({...host,targets:host.targets.filter(target=>accepts(target,roles) && !linkedTo(target,roles).length).map(target=>({...target,label:nodeLabel(target)}))})).filter(host=>host.targets.length),(host,count)=>count>1 ? `${host.label} (window ${count})` : host.label);
+                // Nodes left out are counted so an auto-selected destination never hides the one the user meant.
+                const skipped = found.reduce((total,host)=>total+host.targets.length,0)-hosts.reduce((total,host)=>total+host.targets.length,0);
+                const note = skipped ? ` ${skipped} other Prompt Manager ${skipped===1?'node':'nodes'} cannot receive this prompt.` : '';
+                if (!hosts.length) emit({phase:'select',hosts,message:unavailableMessage(found,roles)});
+                else if (hosts.length>1) emit({phase:'select',hosts,message:`Choose a ComfyUI window.${note}`});
+                else { const choice=hostChoice(hosts[0]); emit({phase:'select',hosts,...choice,message:choice.message+note}); }
             } catch (error) { if (current(request)) emit({phase:'error',message:error.message}); }
         },
-        selectHost(hostId) { if (disposed) return; invalidate(); emit({phase:'select',hostId:state.hosts.some(host=>host.hostId===hostId)?hostId:'',targetId:'',preview:null,message:'Choose a destination node, then preview changes.'}); },
-        selectTarget(targetId) { if (disposed) return; invalidate(); const host=state.hosts.find(host=>host.hostId===state.hostId); emit({phase:'select',targetId:host?.targets.some(target=>target.id===targetId)?targetId:'',preview:null,message:'Preview changes before applying.'}); },
+        selectHost(hostId) { if (disposed) return; invalidate(); const host=state.hosts.find(host=>host.hostId===hostId); emit({phase:'select',preview:null,outcomeUnknown:false,...(host ? hostChoice(host) : {hostId:'',targetId:'',message:'Choose a ComfyUI window.'})}); },
+        selectTarget(targetId) { if (disposed) return; invalidate(); const host=state.hosts.find(host=>host.hostId===state.hostId); const chosen=host?.targets.some(target=>target.id===targetId); emit({phase:'select',outcomeUnknown:false,targetId:chosen?targetId:'',preview:null,message:chosen?'Apply to send it, or preview the changes first.':'Choose a destination node, then preview changes.'}); },
         async preview() {
             if (disposed || !selected() || ['previewing','applying'].includes(state.phase)) return;
             const request=begin('previewing');
             try {
-                const preview=await client.preview(state.hostId,state.targetId,roles,{signal:request.signal});
-                if (!current(request)) return;
-                const fields=preview?.fields;
-                if(typeof preview?.ticket!=='string' || !preview.ticket || preview.target?.id!==state.targetId || !Array.isArray(fields) || fields.length!==Object.keys(roles).length || new Set(fields.map(field=>field?.role)).size!==fields.length || Array.from(fields).some(field=>!field || !Object.hasOwn(roles,field.role) || typeof field.before!=='string' || field.after!==roles[field.role])) throw Error('ComfyUI returned an unexpected preview. Find the destination and preview again.');
-                emit({phase:'ready',preview,message:'Review the complete changes, then apply.'});
+                const preview=await fetchPreview(request);
+                if (!preview) return;
+                const windowLabel=state.hosts.find(host=>host.hostId===state.hostId)?.label;
+                emit({phase:'ready',preview,message:`Sending to ${nodeLabel({id:preview.target.id,label:preview.target.label ?? ''})} in ${windowLabel}. Review the complete changes, then apply.`});
             } catch(error) { if(current(request)) emit({phase:'error',preview:null,message:error.message}); }
         },
         async apply() {
-            if(disposed || state.phase!=='ready' || !state.preview) return;
-            const {ticket}=state.preview; const targetId=state.targetId; const hostId=state.hostId;
+            // Success stays closed: the second click of a double click must not send again.
+            if(disposed || !selected() || !['select','ready','error'].includes(state.phase) || state.outcomeUnknown) return;
+            const held=state.phase==='ready' ? state.preview : null;
+            const targetId=state.targetId; const hostId=state.hostId;
             const request=begin('applying');
             emit({message:'Waiting for ComfyUI confirmation. Closing this dialog does not undo a sent update.'});
+            let posted=false;
             try {
-                const acknowledgement=await client.apply(hostId,ticket,{signal:request.signal});
+                const preview=held ?? await fetchPreview(request);
+                if(!preview || !current(request)) return;
+                posted=true;
+                const acknowledgement=await client.apply(hostId,preview.ticket,{signal:request.signal});
                 if(!current(request)) return;
                 if(acknowledgement?.targetId!==targetId || !acknowledgement.values || Object.keys(acknowledgement.values).length!==Object.keys(roles).length || Object.keys(roles).some(role=>!Object.hasOwn(acknowledgement.values,role) || acknowledgement.values[role]!==roles[role])) throw Error('ComfyUI returned an unexpected acknowledgement.');
                 emit({phase:'success',message:'Sent to ComfyUI.'});
-            } catch(error) { if(current(request)) emit({phase:'error',preview:null,message:`No confirmation received. The update may have applied. Check ComfyUI, then preview again. ${error.message}`}); }
+            } catch(error) {
+                if(!current(request)) return;
+                const unknown=posted && (LOST_REPLY.test(error.message) || /unexpected acknowledgement/.test(error.message));
+                emit({phase:'error',preview:null,outcomeUnknown:unknown,message:unknown ? `No confirmation received. The update may have applied. Check ComfyUI, then preview again. ${error.message}` : error.message});
+            }
         },
         dispose() { if(disposed) return; disposed=true; invalidate(); client.dispose(); },
     };
@@ -82,7 +148,7 @@ export function createPromptSender({scope,baseUrl=window.ApiClient.resolveUrl('/
         const header=element('header',undefined,'prompt-sender-header');
         const title=element('h2','Send to ComfyUI');const dismiss=createButton('Close');
         header.append(title,dismiss);
-        const description=element('p','Choose where to send this prompt. Nothing changes until you approve the preview.');
+        const description=element('p','Choose where to send this prompt. Apply writes it to that node. Preview changes shows the result first, if you want to check it.');
         const status=element('p','', 'prompt-sender-status');status.setAttribute('role','status');status.setAttribute('aria-live','polite');
         const host=createSelect([['','Choose a ComfyUI window']], '');
         const target=createSelect([['','Choose a destination node']], '');
@@ -123,7 +189,7 @@ export function createPromptSender({scope,baseUrl=window.ApiClient.resolveUrl('/
             const selected=state.hosts.find(item=>item.hostId===state.hostId);
             options(target,'Choose a destination node',(selected?.targets || []).map(item=>[item.id,item.label]),state.targetId);
             host.disabled=busy;target.disabled=busy || !selected;
-            find.disabled=busy;inspect.disabled=busy || !state.targetId;apply.disabled=state.phase!=='ready';
+            find.disabled=busy;inspect.disabled=busy || !state.targetId;apply.disabled=busy || !state.targetId || state.phase==='success' || state.outcomeUnknown;
             preview.replaceChildren();
             if(state.preview) {
                 preview.append(element('h3','Review changes'));

web/js/workspace/system-integrations.mjs

@@ -2,7 +2,7 @@
  * System › Integrations (#249 System S10 Task 27): the concept's `renderSystem` "integrations" body (app.js 682–684).
  *
  * - "ComfyUI": Default send destination, Host compatibility and Return to canvas after send. D106 (Q8): the send
- *   bridge always asks for the window and node, and the nodes always follow ComfyUI's own renderer, so only "Ask each
+ *   bridge asks for the window and node when there is a choice, and the nodes always follow ComfyUI's own renderer, so only "Ask each
  *   time" and "Follow host renderer" can be chosen; the other options and the return toggle are disabled, with the
  *   reason under the row, and nothing is stored for them. Host compatibility also says which renderer the open
  *   ComfyUI windows use, as the send bridge reports it (`renderer` on each Prompt Manager node it lists).
@@ -42,7 +42,7 @@ export const LORA_KEYS = Object.freeze(['lora_enabled', 'lora_trigger_words_enab
 
 /** D106: why the options the bridge cannot honour are disabled. */
 export const REASONS = Object.freeze({
-    send: 'Sending always asks for the ComfyUI window and node, so “Ask each time” is the only option.',
+    send: 'Sending asks when there is more than one ComfyUI window or node, so “Ask each time” is the only option.',
     renderer: 'Prompt Manager nodes always follow ComfyUI’s own renderer setting.',
     returnCanvas: 'Not available: sending applies the text in ComfyUI and keeps this page open.',
 });