2026-10-18 15:39:24 -07:00
// Plan2Code Web Console - the Ask chat, the Subagents tab, and attaching files to notes.
import { page , saveNow , redraw , freshChat , hooks , scrollMemory , setDraft } from "../state.js" ;
2026-11-02 12:00:12 -08:00
import { chatAnswering , chatOffline , chatView , sendState as chatSendState , newestReplyId , CHAT_MAX_CHARS , nextAbout , CHAT_MAX_ATTACHMENTS , contextOptions } from "../chat.js" ;
import { finish , activity , agentAdrift , isDashboard , selSpec , byId , isOpen , loopAskLocked , loopDriving } from "../selectors.js" ;
2026-10-18 15:39:24 -07:00
import { el , md , isMac , lightDismiss , shortTime } from "../render.js" ;
import { startersFor } from "../starters.js" ;
import { looks } from "../looks.js" ;
2026-11-03 03:24:39 -08:00
import { thumbs , uploadUrl , docChip , attachTray , CHAT_IMAGES , attachFiles , incomingFiles , deleteUrl , sentAttachments , noteImages , attachRow , openPicview , refocusThumb } from "../uploads.js" ;
2026-10-18 15:39:24 -07:00
import { attachMentions } from "../mention-box.js" ;
2026-11-08 13:48:28 -08:00
import { destroyFields , makeMdField } from "../md-field.js" ;
2026-10-18 15:39:24 -07:00
import { pickerAccept , attachmentKind , noteAwaiting , threadWho , threadText } from "../answers.js" ;
import { postJson } from "../net.js" ;
2026-11-05 10:03:09 -08:00
import { reconnectOffer } from "../continue-button.js" ;
2026-11-04 12:39:16 -08:00
import { suggestState } from "../send-state.js" ;
2026-10-25 15:33:35 -07:00
import { CHECKIN_LINE , helperRows , showSwitch , switchLabel , defaultInstruction , PATHFINDER_RESEARCH_LINE , STRENGTHS , DEFAULT_STRENGTH , STRENGTH_HELP } from "../subagents.js" ;
2026-10-18 15:39:24 -07:00
const $ = ( id ) => document . getElementById ( id );
// The Quick question chat's page-local state, gone on a reload (the frame's
// own `chat` block, the Ask tab's dot and the rest are on `page`, state.js).
let chatSending = false ;
let chatResetting = false ;
let askPaintedOffline = false ;
export const declineOpen = new Map ();
const deciding = new Set ();
2026-11-08 13:48:28 -08:00
// The Subagents dialog's instruction box, a Markdown field made the first
// time the dialog needs it, into its #subagents-instruction mount: made at
// start-up, it would pull CodeMirror into every page load (md-field.js).
2026-11-03 03:24:39 -08:00
let instrField = null ;
2026-11-08 13:48:28 -08:00
function instr () {
if ( ! instrField ) {
instrField = makeMdField ({ className : "subagents-instruction" , label : "Instruction" , maxLength : 2000 });
$ ( "subagents-instruction" ). appendChild ( instrField . el );
}
return instrField ;
}
2026-10-18 15:39:24 -07:00
// The frame's chat block, with `offline` worked out now rather than when the
// frame was sent: the agent comes and goes between frames, and /ping keeps
// agentLastSeen current. The frame's own verdict stands when there is no clock.
function askFrame () {
const base = page . chatFrame || { conversation : 0 , messages : [], typed : 0 , limit : 10 , offline : false };
if ( ! page . S || ! page . agentLastSeen ) return base ;
const offline = chatOffline ({
finish : finish (),
agent : page . S . agent ,
agentLastSeenMs : Date . parse ( page . agentLastSeen ),
now : Date . now (),
2026-11-02 12:00:12 -08:00
answering : chatAnswering ( base ),
2026-10-18 15:39:24 -07:00
});
return { ... base , offline };
}
export function askState () {
const frame = askFrame ();
const shown = chatView ( frame , { pendingSends : page . local . chat . pending , agentActivity : activity () });
const pendingSendCount = shown . rows . filter (( r ) => r . pending && ! r . failed ). length ;
2026-11-02 12:00:12 -08:00
const send = chatSendState ({ frameChat : frame , gone : page . gone , pendingSendCount });
// The Implementation Loop locks Ask like everything else it drives (FR-15),
// unless a question waits for the person (FR-14).
if ( send . canType && loopAskLocked ()) {
return { frame , view : shown , send : { state : "ok" , text : "Ask is off while the loop builds." , canType : false } };
}
return { frame , view : shown , send };
2026-10-18 15:39:24 -07:00
}
// The conversation a send belongs to. The page's own record wins over the
// frame for the moment after a 409 stale, before the new frame lands.
const askConversation = () => page . local . chat . conversation ?? askFrame (). conversation ;
2026-11-08 13:48:28 -08:00
export function renderAsk ( main , held = null ) {
2026-10-18 15:39:24 -07:00
const { frame , view : v , send : ss } = askState ();
// Anything drawn here has been seen: no dot for it later.
const newest = newestReplyId ( frame );
if ( newest && page . local . chat . lastSeenReplyId !== newest ) {
page . local . chat . lastSeenReplyId = newest ;
saveNow ();
}
page . chatDot = false ;
askPaintedOffline = ss . state === "offline" ;
const head = el ( "div" , "ask-head" );
head . appendChild ( el ( "h2" , null , "Quick question" ));
head . appendChild ( el ( "span" , "ask-counter" , v . counterText ));
const reset = el ( "button" , "btn small ghost" , "New conversation" );
reset . type = "button" ;
reset . disabled = ss . state === "offline" || chatResetting ;
reset . addEventListener ( "click" , newConversation );
head . appendChild ( reset );
2026-11-08 13:48:28 -08:00
// The list is a live region (role="log"): one taken up from the last render
// keeps every row that would draw the same, so a redraw announces nothing
// and a new message is one appended row, the only thing read out.
const kept = held && held . querySelector ( ":scope > .ask-list" );
const list = kept || el ( "div" , "ask-list" );
if ( ! kept ) {
list . setAttribute ( "role" , "log" );
list . setAttribute ( "aria-live" , "polite" );
}
2026-10-18 15:39:24 -07:00
const notes = new Map ( v . rows . filter (( r ) => r . kind === "decision" ). map (( r ) => [ r . re , r . text ]));
2026-11-08 13:48:28 -08:00
const wanted = v . rows . length
? v . rows . map (( r ) => [ askRowKey ( r , ss , notes ), () => askRow ( r , ss , notes )])
: [[ askStartersKey ( ss ), () => askStarters ( ss )]];
syncRows ( list , wanted );
const composer = askComposer ( ss );
if ( kept ) {
const oldHead = held . querySelector ( ":scope > .ask-head" );
const oldComposer = held . querySelector ( ":scope > .ask-composer" );
if ( oldHead ) oldHead . replaceWith ( head );
else held . insertBefore ( head , list );
if ( oldComposer ) {
destroyFields ( oldComposer );
oldComposer . replaceWith ( composer );
} else held . appendChild ( composer );
if ( held . parentNode !== main ) main . appendChild ( held );
} else {
if ( held ) {
destroyFields ( held );
held . remove ();
}
const pane = el ( "section" , "ask-pane" );
pane . append ( head , list , composer );
main . appendChild ( pane );
}
2026-10-18 15:39:24 -07:00
// Back where the person left the list, unless something new arrived (or it
// is the first look), which brings the newest row into view.
const saved = scrollMemory . get ( "ask" );
const grew = v . rows . length > page . askRowCount ;
page . askRowCount = v . rows . length ;
list . scrollTop = ! saved || grew ? list . scrollHeight : saved . top ;
}
2026-11-08 13:48:28 -08:00
// What a row draws from: the row itself and every outside fact askRow() reads,
// so two equal keys draw the same row and the one on the page can stay.
// Each outside fact counts only on the rows that read it, or a send in flight
// (chatSending) would redraw every row in the log.
function askRowKey ( r , ss , notes ) {
const offline = ss . state === "offline" ;
if ( r . kind === "decision" ) return JSON . stringify ([ r ]);
if ( r . kind === "agent" ) {
const open = Boolean ( r . proposal && ! r . decided );
return JSON . stringify ([ r , notes . get ( r . id ) ?? null , open && [ offline , deciding . has ( r . id ), declineOpen . has ( r . id )]]);
}
return JSON . stringify ([
r ,
r . pending && r . failed ? [ offline , chatSending ] : null ,
! r . pending && r . waiting && r . working ? [ offline , agentAdrift ()] : null ,
( r . images || []). map (( img ) => thumbs . get ( img . key ) || "" ),
]);
}
const askStartersKey = ( ss ) =>
JSON . stringify ([ "starters" , ss . canType , page . S . workflow , looks . role , Boolean ( page . local . chat . about )]);
// Brings the live list's children in line with `wanted` ([key, make] pairs,
// in order): a child whose key matches stays untouched, a changed one is
// redrawn in its place, new ones are appended and leftovers removed.
function syncRows ( list , wanted ) {
const have = [... list . children ];
wanted . forEach (([ key , make ], i ) => {
const cur = have [ i ];
if ( cur && cur . dataset . rowKey === key ) return ;
const node = make ();
node . dataset . rowKey = key ;
if ( cur ) cur . replaceWith ( node );
else list . appendChild ( node );
});
for ( const extra of have . slice ( wanted . length )) extra . remove ();
}
2026-10-18 15:39:24 -07:00
// An empty conversation offers a few questions for this step, the role's
// first. A click only fills the box: nothing is ever sent for the person.
function askStarters ( ss ) {
const box = el ( "div" , "ask-starters" );
box . appendChild ( el ( "p" , "ask-starters-lead" , "Not sure what to ask? Try one of these:" ));
for ( const starter of startersFor ( page . S . workflow , looks . role , { hasContext : Boolean ( page . local . chat . about ) })) {
const b = el ( "button" , "ask-starter" , starter . text );
b . type = "button" ;
b . disabled = ! ss . canType ;
b . addEventListener ( "click" , () => {
page . local . chat . draft = starter . text ;
saveNow ();
redraw ();
const ta = $ ( "ask-input" );
2026-11-03 03:59:50 -08:00
if ( ! ta || ! ta . field ) return ;
ta . field . focus ();
ta . field . setSelectionRange ( ta . field . value . length , ta . field . value . length );
2026-10-18 15:39:24 -07:00
});
box . appendChild ( b );
}
return box ;
}
function askRow ( r , ss , notes ) {
if ( r . kind === "decision" ) {
const row = el ( "div" , "ask-row decision" );
2026-11-03 03:24:39 -08:00
const working = r . decision === "approve" && ! r . done ;
const line = el ( "p" , working ? "ask-decision working" : "ask-decision" );
if ( working ) line . appendChild ( el ( "span" , "spinner tiny" ));
line . appendChild ( document . createTextNode ( r . decision !== "approve" ? "You declined the edit." : r . done ? "You approved the edit." : "You approved the edit, please wait..." ));
row . appendChild ( line );
2026-10-18 15:39:24 -07:00
if ( r . text ) row . appendChild ( el ( "p" , "ask-text" , r . text ));
return row ;
}
if ( r . kind === "agent" ) {
const row = el ( "div" , "ask-row agent" );
row . appendChild ( el ( "div" , "msg-who" , "Plan2Code" ));
row . appendChild ( md ( r . md , "md" ));
if ( r . proposal ) row . appendChild ( askProposal ( r , ss , notes . get ( r . id )));
if ( Array . isArray ( r . changed ) && r . changed . length ) {
const ul = el ( "ul" , "ask-changed" );
for ( const c of r . changed ) {
const li = el ( "li" );
li . appendChild ( el ( "code" , null , c . file ));
li . appendChild ( el ( "span" , "ask-changed-count" , ` + ${ c . added } − ${ c . removed } ` ));
ul . appendChild ( li );
}
row . appendChild ( ul );
}
return row ;
}
const row = el ( "div" , "ask-row person" + ( r . pending ? " pending" : "" ));
if ( r . about && r . about . label ) row . appendChild ( el ( "p" , "ask-about" , "About: " + r . about . label ));
row . appendChild ( el ( "p" , "ask-text" , r . text ));
const hasImages = r . images && r . images . length ;
const hasFiles = r . files && r . files . length ;
if ( hasImages || hasFiles ) {
const tray = el ( "div" , "attach-tray" );
2026-11-03 03:24:39 -08:00
// A message echoed by the server has no key (it keeps path and name), so
// the thumbnail's refocus token is the picture's own URL, which is unique
// and the same for a pending send and its echo: the token survives a
// redraw while the picview is open.
( r . images || []). forEach (( img , i ) => {
2026-10-18 15:39:24 -07:00
const fig = el ( "figure" , "attach-thumb is-ready" );
2026-11-03 03:24:39 -08:00
fig . dataset . key = uploadUrl ( img );
2026-10-18 15:39:24 -07:00
const pic = el ( "img" );
pic . src = thumbs . get ( img . key ) || uploadUrl ( img );
pic . alt = img . name || "image" ;
2026-11-03 03:24:39 -08:00
const open = el ( "button" , "attach-open" );
open . type = "button" ;
open . appendChild ( pic );
open . addEventListener ( "click" , () => {
const slides = ( r . images || []). map (( x ) => ({ url : uploadUrl ( x ), alt : x . name || "image" }));
openPicview ( slides , i , () => refocusThumb ( fig . dataset . key ));
});
fig . appendChild ( open );
2026-10-18 15:39:24 -07:00
tray . appendChild ( fig );
2026-11-03 03:24:39 -08:00
});
2026-10-18 15:39:24 -07:00
for ( const file of r . files || []) tray . appendChild ( docChip ( file , "ready" ));
row . appendChild ( tray );
}
if ( r . pending && r . failed ) {
const fail = el ( "p" , "ask-waiting ask-failed" , "Not sent — retry" );
const retry = el ( "button" , "btn tiny" , "Retry" );
retry . type = "button" ;
retry . disabled = ss . state === "offline" || chatSending ;
retry . addEventListener ( "click" , () => retryChat ( r . tempId ));
fail . appendChild ( retry );
row . appendChild ( fail );
} else if ( r . pending ) {
row . appendChild ( el ( "p" , "ask-waiting" , "Sending…" ));
} else if ( r . waiting ) {
const wait = el ( "p" , "ask-waiting" );
// Picked up and still answering: the ring says so, unless the agent has
// gone quiet, when a turning ring would pass a dead session for a slow one.
if ( r . working && ss . state !== "offline" && ! agentAdrift ()) {
const spin = el ( "span" , "spinner tiny" );
spin . setAttribute ( "aria-hidden" , "true" );
wait . appendChild ( spin );
}
wait . appendChild ( el ( "span" , null , r . waitingText ));
row . appendChild ( wait );
if ( r . activity ) row . appendChild ( el ( "p" , "ask-waiting" , "Right now: " + r . activity ));
}
return row ;
}
function askProposal ( r , ss , note ) {
const box = el ( "div" , "ask-proposal" );
box . appendChild ( el ( "p" , "note-kicker" , "Proposed change" ));
box . appendChild ( md ( r . proposal . summary , "md" ));
const files = el ( "ul" , "ask-proposal-files" );
for ( const f of r . proposal . files || []) {
const li = el ( "li" );
li . appendChild ( el ( "code" , null , f ));
files . appendChild ( li );
}
box . appendChild ( files );
if ( r . decided ) {
box . appendChild ( el ( "p" , "ask-decided " + r . decided , r . decided === "approve" ? "Approved" : "Declined" ));
if ( note ) box . appendChild ( el ( "p" , "help" , note ));
return box ;
}
const busy = deciding . has ( r . id ) || ss . state === "offline" ;
const row = el ( "div" , "ask-proposal-actions" );
const approve = el ( "button" , "btn small primary" , "Approve" );
approve . type = "button" ;
approve . disabled = busy ;
approve . addEventListener ( "click" , () => decideChat ( r . id , "approve" , "" ));
row . appendChild ( approve );
if ( ! declineOpen . has ( r . id )) {
const decline = el ( "button" , "btn small ghost" , "Decline" );
decline . type = "button" ;
decline . disabled = busy ;
decline . addEventListener ( "click" , () => {
declineOpen . set ( r . id , "" );
redraw ();
$ ( "decline-" + r . id ) ? . focus ();
});
row . appendChild ( decline );
} else {
const input = el ( "input" );
input . type = "text" ;
input . id = "decline-" + r . id ;
input . placeholder = "Why not? (optional)" ;
input . maxLength = CHAT_MAX_CHARS ;
input . value = declineOpen . get ( r . id ) || "" ;
input . addEventListener ( "input" , () => declineOpen . set ( r . id , input . value ));
input . addEventListener ( "keydown" , ( e ) => {
if ( e . key !== "Enter" ) return ;
e . preventDefault ();
e . stopPropagation ();
decideChat ( r . id , "decline" , input . value );
});
row . appendChild ( input );
const go = el ( "button" , "btn small" , "Send decline" );
go . type = "button" ;
go . disabled = busy ;
go . addEventListener ( "click" , () => decideChat ( r . id , "decline" , declineOpen . get ( r . id ) || "" ));
row . appendChild ( go );
}
box . appendChild ( row );
if ( deciding . has ( r . id )) box . appendChild ( el ( "p" , "help" , "Sent. It will show here once Plan2Code has it." ));
return box ;
}
const COUNTER_FROM = 3500 ;
function askComposer ( ss ) {
const comp = el ( "div" , "ask-composer" );
const about = page . local . chat . about ;
if ( about ) {
const chip = el ( "div" , "ask-about-chip" );
chip . appendChild ( el ( "span" , null , "About: " + about . label ));
const x = el ( "button" , "attach-remove" , "× " );
x . type = "button" ;
x . setAttribute ( "aria-label" , "Send without this" );
x . addEventListener ( "click" , () => {
Object . assign ( page . local . chat , nextAbout ( page . local . chat , { type : "drop" }));
saveNow ();
redraw ();
});
chip . appendChild ( x );
comp . appendChild ( chip );
}
if ( page . local . chat . images . length ) comp . appendChild ( attachTray ( CHAT_IMAGES , page . local . chat . images ));
2026-11-03 03:24:39 -08:00
const ta = makeMdField ({
id : "ask-input" ,
placeholder : "Ask anything about this project" ,
label : "Your question" ,
value : page . local . chat . draft || "" ,
disabled : ! ss . canType ,
});
2026-10-18 15:39:24 -07:00
attachMentions ( ta );
2026-11-03 03:24:39 -08:00
comp . appendChild ( ta . el );
2026-10-18 15:39:24 -07:00
const row = el ( "div" , "ask-actions" );
const add = el ( "button" , "btn small ghost" , "+ Attach file" );
add . type = "button" ;
add . setAttribute ( "aria-label" , "Add files to this question" );
add . disabled = ! ss . canType || page . local . chat . images . length >= CHAT_MAX_ATTACHMENTS ;
const picker = el ( "input" );
picker . type = "file" ;
picker . accept = pickerAccept ();
picker . multiple = true ;
picker . hidden = true ;
add . addEventListener ( "click" , () => picker . click ());
picker . addEventListener ( "change" , () => {
attachFiles ( CHAT_IMAGES , picker . files );
picker . value = "" ;
});
row . appendChild ( add );
row . appendChild ( picker );
if ( ! page . local . chat . about ) row . appendChild ( addContext ( ss ));
// Where the counter sits, the reason Send is off when it cannot be typed in:
// the limit, the last question still waiting, or nobody there to answer.
const counter = el ( "span" , "ask-count" );
if ( ! ss . canType ) {
const cls = ss . state === "offline" ? "is-offline" : ss . state === "limit" ? "is-limit" : "is-waiting" ;
row . appendChild ( el ( "p" , "ask-disabled-note " + cls , ss . text ));
} else {
row . appendChild ( counter );
const hint = el ( "span" , "ask-send-hint" );
hint . appendChild ( el ( "kbd" , null , isMac () ? "⌘" : "Ctrl" ));
hint . appendChild ( document . createTextNode ( " + " ));
hint . appendChild ( el ( "kbd" , null , "Enter" ));
row . appendChild ( hint );
}
2026-11-05 10:03:09 -08:00
// No agent there: under the app a button that types continue in its terminal,
// left of Send; in a browser, the line telling the person to.
if ( ss . state === "offline" && ! finish ()) row . appendChild ( reconnectOffer ( "ask-reconnect" ));
2026-10-18 15:39:24 -07:00
const go = el ( "button" , "btn small primary" , "Send" );
go . type = "button" ;
row . appendChild ( go );
comp . appendChild ( row );
if ( page . chatError ) comp . appendChild ( el ( "p" , "ask-error" , page . chatError ));
const held = () => page . local . chat . images . some (( img ) => img . status !== "ready" );
const sync = () => {
const len = ta . value . length ;
counter . textContent = len >= COUNTER_FROM ? ` ${ len } / ${ CHAT_MAX_CHARS } ` : "" ;
counter . classList . toggle ( "is-over" , len > CHAT_MAX_CHARS );
go . disabled = ! ss . canType || chatSending || ! ta . value . trim () || len > CHAT_MAX_CHARS || held ();
};
sync ();
ta . addEventListener ( "input" , () => {
page . local . chat . draft = ta . value ;
saveNow ();
sync ();
});
// Ctrl/Cmd+Enter sends and a plain Enter is a line break. Every Enter stops
// here, so the page-wide Ctrl+Enter never sends the question cards from this box.
ta . addEventListener ( "keydown" , ( e ) => {
if ( e . key !== "Enter" ) return ;
e . stopPropagation ();
if ( ! ( e . ctrlKey || e . metaKey ) || e . isComposing ) return ;
e . preventDefault ();
if ( ! go . disabled ) sendChat ();
});
ta . addEventListener ( "paste" , ( e ) => {
const files = incomingFiles ( e . clipboardData && e . clipboardData . files );
if ( ! files . length || ! ss . canType ) return ;
if ( ! e . clipboardData . getData ( "text/plain" )) e . preventDefault ();
attachFiles ( CHAT_IMAGES , files );
});
const canDrop = ( e ) => ss . canType && e . dataTransfer && [... e . dataTransfer . types ]. includes ( "Files" );
const onOver = ( e ) => {
if ( ! canDrop ( e )) return ;
e . preventDefault ();
comp . classList . add ( "is-dropping" );
};
comp . addEventListener ( "dragenter" , onOver );
comp . addEventListener ( "dragover" , onOver );
comp . addEventListener ( "dragleave" , ( e ) => {
if ( ! comp . contains ( e . relatedTarget )) comp . classList . remove ( "is-dropping" );
});
comp . addEventListener ( "drop" , ( e ) => {
comp . classList . remove ( "is-dropping" );
if ( ! canDrop ( e )) return ;
e . preventDefault ();
attachFiles ( CHAT_IMAGES , e . dataTransfer . files );
});
go . addEventListener ( "click" , sendChat );
return comp ;
}
const CONTEXT_KIND = { card : "Question" , section : "Section" , spec : "Spec" };
// + Add context: the only way a message gets an `about`. A menu of the last
// three places visited, then This spec, built fresh on every render.
function addContext ( ss ) {
const wrap = el ( "span" , "ask-context" );
const spec = isDashboard () ? selSpec () : page . S && page . S . specDir ? { dir : page . S . specDir } : null ;
const options = contextOptions ( page . local . chat , spec );
const btn = el ( "button" , "btn small ghost" , "+ Add context" );
btn . type = "button" ;
btn . setAttribute ( "aria-haspopup" , "menu" );
btn . setAttribute ( "aria-expanded" , "false" );
btn . disabled = ! ss . canType || ! options . length ;
if ( ! options . length ) btn . title = "Visit a question or a document section first" ;
wrap . appendChild ( btn );
let menu = null ;
const outside = ( e ) => {
if ( ! wrap . contains ( e . target )) close ();
};
// Focus moves before the menu goes: removing the focused item fires a
// focusout of its own, which would otherwise re-enter here.
const close = ( refocus ) => {
if ( ! menu ) return ;
const gone = menu ;
menu = null ;
btn . setAttribute ( "aria-expanded" , "false" );
document . removeEventListener ( "pointerdown" , outside , true );
if ( refocus ) btn . focus ();
gone . remove ();
};
const open = () => {
menu = el ( "div" , "ask-context-menu" );
menu . setAttribute ( "role" , "menu" );
menu . setAttribute ( "aria-label" , "Add context" );
for ( const option of options ) {
const item = el ( "button" , "ask-context-item" );
item . type = "button" ;
item . setAttribute ( "role" , "menuitem" );
item . appendChild ( el ( "span" , "ask-context-label" , option . label ));
item . appendChild ( el ( "span" , "ask-context-kind" , CONTEXT_KIND [ option . kind ] || "" ));
item . addEventListener ( "click" , () => {
close ();
Object . assign ( page . local . chat , nextAbout ( page . local . chat , { type : "pick" , about : option }));
saveNow ();
redraw ();
});
menu . appendChild ( item );
}
// A press inside the menu never moves focus. Safari (and Firefox on
// macOS) do not focus a clicked button, so the press would blur the
// focused item to nowhere and the focusout below would close the menu
// before the click landed.
menu . addEventListener ( "mousedown" , ( e ) => e . preventDefault ());
menu . addEventListener ( "keydown" , ( e ) => {
const items = [... menu . querySelectorAll ( '[role="menuitem"]' )];
const at = items . indexOf ( document . activeElement );
if ( e . key === "Escape" ) {
e . preventDefault ();
e . stopPropagation ();
close ( true );
} else if ( e . key === "ArrowDown" || e . key === "ArrowUp" ) {
e . preventDefault ();
const step = e . key === "ArrowDown" ? 1 : - 1 ;
items [( at + step + items . length ) % items . length ]. focus ();
} else if ( e . key === "Home" || e . key === "End" ) {
e . preventDefault ();
items [ e . key === "Home" ? 0 : items . length - 1 ]. focus ();
}
});
wrap . appendChild ( menu );
btn . setAttribute ( "aria-expanded" , "true" );
document . addEventListener ( "pointerdown" , outside , true );
menu . querySelector ( '[role="menuitem"]' ). focus ();
};
btn . addEventListener ( "click" , () => ( menu ? close () : open ()));
wrap . addEventListener ( "focusout" , ( e ) => {
if ( menu && ! wrap . contains ( e . relatedTarget )) close ();
});
return wrap ;
}
const CHAT_ERRORS = {
stale : "A new conversation started. Your message is still here — press Send again." ,
"too-long" : `That message is over ${ CHAT_MAX_CHARS . toLocaleString () } characters. Shorten it and send again.` ,
image : "One of the images could not be attached. Remove it and try again." ,
file : "One of the files could not be attached. Remove it and try again." ,
};
async function sendChat () {
const text = ( page . local . chat . draft || "" ). trim ();
const { send : ss } = askState ();
if ( ! text || chatSending || ! ss . canType || text . length > CHAT_MAX_CHARS ) return ;
if ( page . local . chat . images . some (( img ) => img . status !== "ready" )) return ;
const ofKind = ( kind ) => page . local . chat . images . filter (( a ) => attachmentKind ( a ) === kind );
const pend = {
tempId : crypto . randomUUID (),
text ,
about : page . local . chat . about ,
images : ofKind ( "image" ). map (({ key , path , name , url }) => ({ key , path , name , url })),
files : ofKind ( "file" ). map (({ key , path , name , size }) => ({ key , path , name , size })),
};
page . local . chat . pending . push ( pend );
saveNow ();
await postChat ( pend );
}
function retryChat ( tempId ) {
const pend = page . local . chat . pending . find (( p ) => p . tempId === tempId );
if ( ! pend || chatSending ) return ;
pend . failed = false ;
saveNow ();
postChat ( pend );
}
async function postChat ( pend ) {
chatSending = true ;
page . chatError = "" ;
redraw ();
let res = null ;
let body = {};
try {
res = await fetch ( "/chat" , {
method : "POST" ,
headers : { "content-type" : "application/json" },
body : JSON . stringify ({
text : pend . text ,
about : pend . about || undefined ,
images : pend . images . length ? pend . images . map (({ path , name }) => ({ path , name })) : undefined ,
files : pend . files && pend . files . length ? pend . files . map (({ path , name }) => ({ path , name })) : undefined ,
conversation : askConversation (),
}),
});
body = await res . json (). catch (() => ({}));
} catch {
res = null ;
}
chatSending = false ;
const still = page . local . chat . pending . find (( p ) => p . tempId === pend . tempId );
if ( ! res ) {
if ( still ) still . failed = true ;
} else if ( res . ok ) {
if ( still ) still . seq = body . seq ;
// What was sent leaves the composer, and the context leaves with it: a
// follow-up is a general question unless it is picked again.
Object . assign ( page . local . chat , nextAbout ( page . local . chat , { type : "sent" }));
if (( page . local . chat . draft || "" ). trim () === pend . text ) {
page . local . chat . draft = "" ;
page . local . chat . images = [];
}
} else {
page . local . chat . pending = page . local . chat . pending . filter (( p ) => p . tempId !== pend . tempId );
if ( body . error === "stale" && typeof body . conversation === "number" ) page . local . chat . conversation = body . conversation ;
// A limit or offline refusal needs no words: the disabled composer says why.
if ( body . error !== "limit" && body . error !== "offline" ) {
page . chatError = CHAT_ERRORS [ body . error ] || "That message could not be sent. Try again." ;
}
}
saveNow ();
redraw ();
}
async function newConversation () {
// One reset at a time: a second press would only come back stale and put
// an error under the clean conversation the first one opened.
if ( chatResetting ) return ;
chatResetting = true ;
redraw ();
let res = null ;
let body = {};
try {
res = await fetch ( "/chat" , {
method : "POST" ,
headers : { "content-type" : "application/json" },
body : JSON . stringify ({ reset : true , conversation : askConversation () }),
});
body = await res . json (). catch (() => ({}));
} catch {}
if ( res && res . ok ) {
// An explicit fresh start: the unsent draft and its pictures go too.
for ( const img of page . local . chat . images ) if ( img . id ) fetch ( deleteUrl ( img ), { method : "DELETE" }). catch (() => {});
page . local . chat = { ... freshChat (), history : page . local . chat . history , about : null , conversation : body . conversation };
page . chatError = "" ;
page . askRowCount = 0 ;
declineOpen . clear ();
} else if ( body . error === "stale" && typeof body . conversation === "number" ) {
page . local . chat . conversation = body . conversation ;
page . chatError = "A new conversation had already started." ;
} else if ( body . error !== "offline" ) {
page . chatError = "A new conversation could not be started. Try again." ;
}
chatResetting = false ;
saveNow ();
redraw ();
}
async function decideChat ( re , decision , text ) {
if ( deciding . has ( re )) return ;
deciding . add ( re );
page . chatError = "" ;
redraw ();
let ok = false ;
let body = {};
try {
const res = await fetch ( "/chat/decision" , {
method : "POST" ,
headers : { "content-type" : "application/json" },
body : JSON . stringify ({ re , decision , text : text . trim () || undefined , conversation : askConversation () }),
});
ok = res . ok ;
body = await res . json (). catch (() => ({}));
} catch {}
// Kept in `deciding` on success: the buttons stay off until the frame
// brings the decision back, rather than flashing live again in between.
if ( ok ) declineOpen . delete ( re );
else {
deciding . delete ( re );
page . chatError =
body . error === "stale"
? "That proposal belongs to an earlier conversation."
: "That decision could not be sent. Try again." ;
}
redraw ();
}
2026-11-04 20:13:43 -08:00
// A stopped loop's screen, with its Ask a question button on offer: its agent
// is gone, so a note here would reach nobody, and the panel says how to ask.
const askOffered = () => {
const end = page . S && page . S . loopEnd ;
return Boolean ( end && end . kind !== "finished" && Array . isArray ( end . can ) && end . can . includes ( "ask" ) && ! finish ());
};
const ASK_HINT = "Press Ask a question to wake an agent, then ask in the Ask tab." ;
2026-10-18 15:39:24 -07:00
export function renderAside () {
const aside = $ ( "aside" );
// Redrawing empties the panel, which drops its scroll to the top. An image
// upload redraws two or three times while the person watches its tray, so
// the place is kept while the same question stays on screen.
const place = aside . dataset . item === String ( page . selected ) ? aside . scrollTop : 0 ;
aside . replaceChildren ();
aside . dataset . item = String ( page . selected );
// The end page is about the session, not any one question: the notes that
// belong to a question stay on its own page.
const item = page . view === "end" ? null : byId ( page . selected );
if ( ! item ) {
// The menu has no questions, so no notes either: the pane stays empty.
2026-11-04 20:13:43 -08:00
if ( ! isDashboard ()) aside . appendChild ( el ( "p" , "aside-empty" , askOffered () ? ASK_HINT : "Pick a question to see its notes." ));
2026-10-18 15:39:24 -07:00
return ;
}
// Off the question's own page (a doc tab, Ask) "this" points at nothing on
// screen, so the pane names the question a note here will go to.
const onQuestion = page . view === "questions" || page . view === "end" ;
aside . appendChild ( el ( "h2" , null , onQuestion ? "Notes on this" : `Notes on “ ${ item . title || "this question" } ”` ));
const thread = item . thread || [];
if ( ! thread . length && ! ( isOpen ( item ) && ! finish () && noteAwaiting ( item ))) {
aside . appendChild (
el (
"p" ,
"aside-empty" ,
2026-11-04 20:13:43 -08:00
askOffered ()
? ASK_HINT
: isOpen ( item ) && ! finish ()
? "No back and forth yet. Anything you type here goes with your next send."
: "Nothing was said about this one."
2026-10-18 15:39:24 -07:00
)
);
}
// A note that has been sent but not yet picked up: marked as waiting, so the
// send is seen to have gone, until the agent replies. The server writes the
// note into the thread as it arrives; a session from before that has only
// `sentNote`, which gets a box of its own below.
const waiting = isOpen ( item ) && ! finish () ? noteAwaiting ( item ) : null ;
let waitingShown = false ;
for ( const m of thread ) {
const mine = threadWho ( m ) === "user" ;
const pending = Boolean ( waiting && mine && m . at && m . at === waiting . at );
if ( pending ) waitingShown = true ;
const box = el ( "div" , "msg" + ( mine ? " you" : "" ) + ( pending ? " pending" : "" ));
const who = el ( "div" , "msg-who" );
who . appendChild ( el ( "span" , null , mine ? "You" : "Plan2Code" ));
2026-11-08 07:56:54 -08:00
if ( pending ) who . appendChild ( sentWaitingTag ());
2026-10-18 15:39:24 -07:00
else if ( m . at ) who . appendChild ( el ( "span" , null , shortTime ( m . at )));
box . appendChild ( who );
2026-11-04 12:39:16 -08:00
if ( m . suggest === true ) box . appendChild ( suggestTag ());
2026-10-18 15:39:24 -07:00
const text = threadText ( m );
if ( text ) box . appendChild ( md ( text , "md" ));
const tray = mine ? sentAttachments ( m ) : null ;
if ( tray ) box . appendChild ( tray );
aside . appendChild ( box );
}
2026-11-09 10:08:45 -08:00
// The agent answered a note and has not yet dealt with the question itself:
// say so, because the reply may have changed what the question asks.
const last = thread [ thread . length - 1 ];
if ( item . noted === true && isOpen ( item ) && ! finish () && last && threadWho ( last ) === "agent" ) {
const tag = el ( "p" , "pill noted-tag" , "Plan2Code replied, check this still fits" );
tag . setAttribute ( "role" , "note" );
aside . appendChild ( tag );
}
2026-10-18 15:39:24 -07:00
if ( waiting && ! waitingShown ) {
const box = el ( "div" , "msg you pending" );
const who = el ( "div" , "msg-who" );
who . appendChild ( el ( "span" , null , "You" ));
2026-11-08 07:56:54 -08:00
who . appendChild ( sentWaitingTag ());
2026-10-18 15:39:24 -07:00
box . appendChild ( who );
2026-11-04 12:39:16 -08:00
if ( waiting . suggest === true ) box . appendChild ( suggestTag ());
2026-10-18 15:39:24 -07:00
if ( waiting . text ) box . appendChild ( md ( waiting . text , "md" ));
const tray = sentAttachments ( waiting );
if ( tray ) box . appendChild ( tray );
aside . appendChild ( box );
}
// A finished session has nobody left for a note to reach, so the box would
// be a place to type words that go nowhere.
2026-11-04 20:13:43 -08:00
// A stopped loop has no agent either, even with a question left open.
if ( ! isOpen ( item ) || finish () || askOffered ()) {
2026-10-18 15:39:24 -07:00
aside . scrollTop = place ;
return ;
}
const wrap = el ( "div" , "field" );
const id = "thread-" + item . id ;
const label = el ( "label" , null , "Add a note, attach a file, or ask something" );
label . htmlFor = id ;
wrap . appendChild ( label );
const attached = noteImages ( item . id );
2026-11-04 12:39:16 -08:00
const row = attachRow ( item . id , "Add files to this note" );
2026-11-12 07:54:26 -08:00
if ( ! loopDriving () && ! isDashboard () && SUGGEST_KINDS . includes ( item . kind )) {
const chip = suggestChip ( item );
if ( ! chip . disabled ) row . appendChild ( suggestNudge ());
row . appendChild ( chip );
}
2026-11-04 12:39:16 -08:00
wrap . appendChild ( row );
2026-10-18 15:39:24 -07:00
if ( attached . length ) wrap . appendChild ( attachTray ( item . id , attached ));
2026-11-03 03:24:39 -08:00
const ta = makeMdField ({
id ,
placeholder : "Goes with your next send. It does not answer the question." ,
label : "Add a note, attach a file, or ask something" ,
value : page . local . drafts [ id ] || "" ,
});
2026-10-18 15:39:24 -07:00
attachMentions ( ta );
ta . addEventListener ( "input" , () => {
setDraft ( id , ta . value );
hooks . renderFooter ();
});
ta . addEventListener ( "paste" , ( e ) => {
const files = incomingFiles ( e . clipboardData && e . clipboardData . files );
if ( ! files . length ) return ;
// A copy from some apps carries the picture and its text together; the
// text still pastes as it always did.
if ( ! e . clipboardData . getData ( "text/plain" )) e . preventDefault ();
attachFiles ( item . id , files );
});
2026-11-03 03:24:39 -08:00
label . addEventListener ( "click" , () => ta . focus ());
wrap . appendChild ( ta . el );
2026-10-18 15:39:24 -07:00
aside . appendChild ( wrap );
aside . scrollTop = place ;
}
2026-11-04 12:39:16 -08:00
// The cards with options to pick from, where asking what Plan2Code would pick
// makes sense.
const SUGGEST_KINDS = [ "choice" , "multi" , "confirm" ];
// Ask for suggestions: its own send, beside the main one (core.js). Focus
// stays in the panel: on the chip when it is live again, else the note box.
function suggestChip ( item ) {
const st = suggestState ( item );
const chip = el ( "button" , "btn tiny suggest-chip" , "Ask for suggestions" );
chip . type = "button" ;
chip . id = "suggest-" + item . id ;
chip . setAttribute ( "aria-label" , "Ask Plan2Code for suggestions on this question" );
chip . title = st . why ;
chip . disabled = st . disabled ;
chip . addEventListener ( "click" , async () => {
await hooks . askSuggestions ( item . id );
const again = $ ( "suggest-" + item . id );
if ( again && ! again . disabled ) again . focus ();
else $ ( "thread-" + item . id ) ? . field ? . focus ();
});
return chip ;
}
2026-11-12 07:54:26 -08:00
// The question mark that sways beside a live Ask for suggestions chip, so the
// chip is noticed. The panel is redrawn often, so the sway starts where the
// clock says it should be: a fresh mark never jumps back to its first frame.
const NUDGE_CYCLE_MS = 2800 ;
function suggestNudge () {
const mark = el ( "span" , "nudge suggest-nudge" , "?" );
mark . setAttribute ( "aria-hidden" , "true" );
mark . style . animationDelay = `- ${ Math . round ( performance . now () % NUDGE_CYCLE_MS ) } ms` ;
return mark ;
}
2026-11-08 07:56:54 -08:00
// The label on a note that is sent and not yet picked up, with the page's small
// ring in front so it is plain Plan2Code is still on it. Like the Ask reply
// line, no ring once the agent has gone quiet: a turning ring would pass a
// dead session for a slow one.
function sentWaitingTag () {
const tag = el ( "span" , "sent-wait" );
if ( askState (). send . state !== "offline" && ! agentAdrift ()) {
const spin = el ( "span" , "spinner tiny" );
spin . setAttribute ( "aria-hidden" , "true" );
tag . appendChild ( spin );
}
tag . appendChild ( el ( "span" , null , "Sent, waiting for Plan2Code" ));
return tag ;
}
2026-11-04 12:39:16 -08:00
function suggestTag () {
return el ( "span" , "pill suggest-tag" , "Asked for suggestions" );
}
2026-10-18 15:39:24 -07:00
// The helpers the agent reported, as it last posted them. Everything here is
// the agent's text, so it goes in as text, never as markup.
export function renderSubagents ( main ) {
const card = el ( "section" , "card sa-card" );
card . appendChild ( el ( "h2" , null , "Subagents" ));
card . appendChild ( el ( "p" , "help" , CHECKIN_LINE ));
const { alone , rows } = helperRows ( page . S . helpers );
if ( alone ) {
card . appendChild (
el ( "p" , "sa-alone" , "Working alone: your agent has no way to start helpers here, so it is doing this skill's work itself." )
);
main . appendChild ( card );
return ;
}
const list = el ( "ul" , "sa-list" );
for ( const row of rows ) {
const item = el ( "li" , "sa-row" );
const head = el ( "div" , "sa-head" );
head . appendChild ( el ( "strong" , "sa-title" , row . title ));
const pill = el ( "span" , "pill sa-pill is-" + row . state );
if ( row . state === "running" ) {
const spin = el ( "span" , "spinner tiny" );
spin . setAttribute ( "aria-hidden" , "true" );
pill . appendChild ( spin );
}
pill . appendChild ( document . createTextNode ( row . stateLabel ));
head . appendChild ( pill );
item . appendChild ( head );
item . appendChild ( el ( "p" , "sa-ask" , row . ask ));
2026-10-26 06:03:07 -07:00
if ( row . strengthLine ) {
// Badges for the eye, the plain line for screen readers and the tooltip.
const strength = el ( "p" , "sa-strength" );
strength . setAttribute ( "aria-label" , row . strengthLine );
strength . title = row . strengthLine ;
for ( const badge of row . badges ) {
const chip = el ( "span" , `sa-badge is- ${ badge . kind } lvl- ${ badge . level } ` );
chip . setAttribute ( "aria-hidden" , "true" );
if ( badge . level ) {
const bars = el ( "span" , "sa-bars" );
for ( let i = 1 ; i <= 3 ; i ++ ) bars . appendChild ( el ( "i" , i <= badge . level ? "on" : null ));
chip . appendChild ( bars );
}
chip . appendChild ( document . createTextNode ( badge . label ));
strength . appendChild ( chip );
}
item . appendChild ( strength );
}
2026-10-18 15:39:24 -07:00
if ( row . result ) item . appendChild ( el ( "p" , "sa-result" , row . result ));
list . appendChild ( item );
}
card . appendChild ( list );
main . appendChild ( card );
}
// Shown only where the skill opts in and the agent's console copy can deliver
// it. Lit while helpers are on; a click opens the dialog, never toggles.
export function renderSubagentsButton () {
const btn = $ ( "btn-subagents" );
const offer = showSwitch ( page . subagentsFrame );
btn . hidden = ! offer ;
if ( ! offer ) return ;
const label = switchLabel ( page . subagentsFrame );
btn . setAttribute ( "aria-pressed" , String ( Boolean ( page . subagentsFrame . on )));
btn . title = label ;
btn . setAttribute ( "aria-label" , label );
2026-11-02 12:00:12 -08:00
// The Subagents switch is the person's setting for the next agent; the loop's phases are already started.
btn . disabled = page . gone || loopDriving ();
2026-10-18 15:39:24 -07:00
}
// The Subagents dialog, filled from the frame each time it opens. A null
// instruction is the shipped default, shown as its text so it can be edited.
export function openSubagents () {
if ( ! showSwitch ( page . subagentsFrame )) return ;
const on = Boolean ( page . subagentsFrame . on );
for ( const radio of document . querySelectorAll ( 'input[name="subagents-on"]' )) {
radio . checked = radio . value === ( on ? "on" : "off" );
}
2026-11-08 13:48:28 -08:00
instr (). value = page . subagentsFrame . instruction ?? defaultInstruction ( page . S . workflow );
2026-10-18 15:39:24 -07:00
$ ( "subagents-max" ). value = String ( page . subagentsFrame . max );
2026-10-25 15:33:35 -07:00
const strength = STRENGTHS . includes ( page . subagentsFrame . strength ) ? page . subagentsFrame . strength : DEFAULT_STRENGTH ;
for ( const radio of document . querySelectorAll ( 'input[name="subagents-strength"]' )) radio . checked = radio . value === strength ;
syncStrengthHelp ();
2026-10-18 15:39:24 -07:00
$ ( "subagents-checkin" ). textContent = CHECKIN_LINE ;
const research = $ ( "subagents-research" );
research . textContent = PATHFINDER_RESEARCH_LINE ;
research . hidden = page . S . workflow !== "pathfinder" ;
$ ( "subagents-status" ). textContent = "" ;
$ ( "subagents-save" ). disabled = false ;
syncSubagentsFields ();
$ ( "subagents-modal" ). showModal ();
const checked = document . querySelector ( 'input[name="subagents-on"]:checked' );
if ( checked ) checked . focus ();
}
2026-10-25 15:33:35 -07:00
// Instruction, "at most" and strength only mean anything with helpers on, so
// they are inert under Work alone (kept as picked, for when helpers go back on).
2026-10-18 15:39:24 -07:00
export function syncSubagentsFields () {
const picked = document . querySelector ( 'input[name="subagents-on"]:checked' );
const off = ! picked || picked . value !== "on" ;
2026-11-08 13:48:28 -08:00
instr (). disabled = off ;
2026-11-03 03:24:39 -08:00
for ( const id of [ "subagents-max" , "subagents-default" ]) $ ( id ). disabled = off ;
2026-10-25 15:33:35 -07:00
for ( const radio of document . querySelectorAll ( 'input[name="subagents-strength"]' )) radio . disabled = off ;
}
// The line under the strength radios explains the picked one.
function syncStrengthHelp () {
const picked = document . querySelector ( 'input[name="subagents-strength"]:checked' );
$ ( "subagents-strength-help" ). textContent = STRENGTH_HELP [ picked ? picked . value : DEFAULT_STRENGTH ];
2026-10-18 15:39:24 -07:00
}
const SUBAGENTS_ERRORS = {
max : "Pick a number from 1 to 20." ,
"too-long" : "The instruction is over 2,000 characters." ,
2026-10-25 15:33:35 -07:00
strength : "That strength isn't one of the four choices." ,
2026-10-18 15:39:24 -07:00
"not-offered" : "This skill doesn't use helpers." ,
bad : "That didn't save. Try again." ,
};
const SUBAGENTS_LOST = "Lost contact with Plan2Code. Try again once it's back." ;
export async function saveSubagents () {
const save = $ ( "subagents-save" );
const status = $ ( "subagents-status" );
const picked = document . querySelector ( 'input[name="subagents-on"]:checked' );
2026-11-08 13:48:28 -08:00
const text = instr (). value . trim ();
2026-10-18 15:39:24 -07:00
// The shipped default is stored as null, so a later release's wording
// reaches everyone who never changed it.
const instruction = text === defaultInstruction ( page . S . workflow ) ? null : text ;
2026-10-25 15:33:35 -07:00
const strength = document . querySelector ( 'input[name="subagents-strength"]:checked' );
const body = {
on : Boolean ( picked && picked . value === "on" ),
instruction ,
max : Number ( $ ( "subagents-max" ). value ),
strength : strength ? strength . value : DEFAULT_STRENGTH ,
};
2026-10-18 15:39:24 -07:00
save . disabled = true ;
status . textContent = "" ;
const res = await postJson ( "/subagents" , body );
save . disabled = false ;
// The next state frame redraws the button.
if ( res . status === 200 ) return $ ( "subagents-modal" ). close ();
if ( res . status === 400 ) status . textContent = SUBAGENTS_ERRORS [ res . body && res . body . error ] || SUBAGENTS_ERRORS . bad ;
else if ( res . status === 403 || res . status === 0 ) status . textContent = SUBAGENTS_LOST ;
else status . textContent = SUBAGENTS_ERRORS . bad ;
}
// Whether the agent coming or going has changed what the Ask pane painted,
// with no frame to say so (the page's clock asks, once a second).
export const askOfflineFlipped = () => ( askState (). send . state === "offline" ) !== askPaintedOffline ;
// The Subagents dialog's buttons, and dropping files onto the notes panel.
export function wireAsk () {
for ( const radio of document . querySelectorAll ( 'input[name="subagents-on"]' )) radio . addEventListener ( "change" , syncSubagentsFields );
2026-10-25 15:33:35 -07:00
for ( const radio of document . querySelectorAll ( 'input[name="subagents-strength"]' )) radio . addEventListener ( "change" , syncStrengthHelp );
2026-10-18 15:39:24 -07:00
lightDismiss ( $ ( "subagents-modal" ));
$ ( "btn-subagents" ). addEventListener ( "click" , openSubagents );
$ ( "subagents-default" ). addEventListener ( "click" , () => {
2026-11-08 13:48:28 -08:00
instr (). value = defaultInstruction ( page . S . workflow );
2026-10-18 15:39:24 -07:00
});
$ ( "subagents-save" ). addEventListener ( "click" , saveSubagents );
$ ( "subagents-cancel" ). addEventListener ( "click" , () => $ ( "subagents-modal" ). close ());
$ ( "subagents-modal" ). addEventListener ( "close" , () => $ ( "btn-subagents" ). focus ());
// Dropping files onto the notes panel attaches them to the selected
// question's note. Bound once here: the panel's contents are redrawn on every
// render, the panel itself is not.
{
const aside = $ ( "aside" );
const canDrop = ( e ) => {
const item = page . view === "end" ? null : byId ( page . selected );
return (
Array . from (( e . dataTransfer && e . dataTransfer . types ) || []). includes ( "Files" ) &&
item &&
isOpen ( item ) &&
! finish ()
);
};
const onOver = ( e ) => {
if ( ! canDrop ( e )) return ;
e . preventDefault ();
aside . classList . add ( "is-dropping" );
};
aside . addEventListener ( "dragenter" , onOver );
aside . addEventListener ( "dragover" , onOver );
aside . addEventListener ( "dragleave" , ( e ) => {
// Moving between children fires dragleave too; only leaving the panel counts.
if ( ! aside . contains ( e . relatedTarget )) aside . classList . remove ( "is-dropping" );
});
aside . addEventListener ( "drop" , ( e ) => {
aside . classList . remove ( "is-dropping" );
if ( ! canDrop ( e )) return ;
e . preventDefault ();
attachFiles ( page . selected , e . dataTransfer . files );
});
}
}