2026-10-18 15:39:24 -07:00
// Plan2Code Web Console - connection, the render loop, the page chrome and Send.
//
// The page's core, which every screen sits inside: the draft kept in this
// browser and on the server (save, load), the first state and every frame
// after it (loadState, adopt), the stream and the polling that stands in for
// it (connect, checkIn), the render loop and the place it keeps (render,
// withFocus), the chrome around the screens (the header, Planny's status
// line, the tabs, the rail, the footer, the session meter) and Send.
//
// Only defines: app.js, the entry, is the only file that imports this one and
// the one that starts it. The screens draw through state.js's redraw() and
// keep the draft through saveNow(), never by importing this file.
import { fresh , freshChat , page , redraw , saveNow , scrollMemory } from "../state.js" ;
import {
CATALOG_GROUPS ,
DASHBOARD_COMMAND ,
SKILL_CATALOG ,
STALE_MS ,
agentRepliedAfterSend ,
approvalHint ,
cardAvailability ,
cardPresentation ,
finishPaused ,
handoffText ,
indentReply ,
noteAction ,
noteReplyLines ,
progressTotal ,
recordedAnswer ,
sentAnswer ,
staleLaunchFeedback ,
submittedAwaiting ,
verdictText ,
workflowLabel ,
workflowTitle ,
} from "../answers.js" ;
import {
chatView ,
newestReplyId ,
nextAbout ,
shouldChime ,
unreadDot ,
} from "../chat.js" ;
import { copyButton , el , isMac , textWithCode } from "../render.js" ;
import { isBuild } from "../skills.js" ;
2026-10-19 15:56:52 -07:00
import { startsClean } from "../hops.js" ;
2026-10-18 15:39:24 -07:00
import { faviconState , setFavicon } from "../favicon.js" ;
import { helperRows , showTab } from "../subagents.js" ;
import { FOOTER_TIERS , footerLabel } from "../workspace.js" ;
import {
activity , agentAdrift , agentWorking , asked , awaitingReply , byId , dashboardLive , docs , doingNow ,
finish , gitAwaiting , isDashboard , isGitBoard , isOpen , items , loadOverview , myTurn , openItems ,
overviewSpec , patience , reviewPending , scan , selSpec , sendCollected , stagedCount , stranded ,
topics , workingMs , WORKING_GRACE_MS ,
workspaceFolders ,
} from "../selectors.js" ;
import { sound } from "../sound.js" ;
import { renderConfirm , renderDashboard } from "./dashboard.js" ;
import { renderLaunching , renderWaiting } from "./starting.js" ;
import { heldNotes , noteImages , pendingNotes , removeImage } from "../uploads.js" ;
import { closeMentions } from "../mention-box.js" ;
import { buildPager , fitGrowBox , markFor , markMore , renderCard , renderEndItem , renderNotice } from "./cards.js" ;
import { sendState } from "../send-state.js" ;
import { renderBriefButton , renderDoc , renderOverview } from "./docs.js" ;
import { board , renderGitBoard , resetBoard } from "./git-host.js" ;
import { renderWorkspace , tellFolderIssues } from "./workspace.js" ;
import { openHelpOn } from "./help-dialog.js" ;
import { askOfflineFlipped , askState , declineOpen , renderAside , renderAsk , renderSubagents , renderSubagentsButton } from "./ask.js" ;
import { renderHandoff , renderHomeButton , renderStopButton , renderStopControls , renderStopping , stopInProgress , stopWarning } from "./ending.js" ;
2026-10-19 15:56:52 -07:00
import { renderNotepadButton } from "./notepad.js" ;
2026-10-18 15:39:24 -07:00
// What the entry needs from the screens at start-up, handed on from here: only
// the core imports a screen.
export { wakeHoldsChime , wireDashboard } from "./dashboard.js" ;
export { fillSky } from "./starting.js" ;
export { fitGrowBox , wireCards } from "./cards.js" ;
export { wireDocs } from "./docs.js" ;
export { wireAsk } from "./ask.js" ;
export { syncWorkspaceScope , wireWorkspace } from "./workspace.js" ;
export { maybeWelcome , openHelpOn , wireHelp } from "./help-dialog.js" ;
export { wireCleanup } from "./cleanup.js" ;
export { startLooks , wireLooks } from "./looks.js" ;
export { wireEnding } from "./ending.js" ;
2026-10-19 15:56:52 -07:00
export { wireNotepad } from "./notepad.js" ;
2026-10-18 15:39:24 -07:00
const $ = ( id ) => document . getElementById ( id );
// How long the page waits without contact before it calls itself offline.
// Exported for the page tests, which wait it out.
export const GONE_AFTER_MS = 8000 ;
// Named so a reconnect can clear only THIS banner: a bare banner(null) would
// wipe an unrelated warning that landed while the page was gone (an upload
// failure, a refused send).
const GONE_BANNER =
"Lost contact with Plan2Code. Nothing you have typed is lost. A blip clears by itself; if Plan2Code starts again, it gives you a new link, so open that one." ;
// The server's frame counter as of the last frame, and the last time the page
// heard from the server at all.
let rev = 0 ;
let lastContact = Date . now ();
// The tab the DOM currently shows, which page.view stops naming the moment a
// tab click sets it.
let drawnView = null ;
// The tab ids the strip last drew, so a tab the agent or page adds (a posted
// document, a spec's overview) can replay the runway chevrons. Null until the
// first draw, which the load pulse already covers.
let drawnTabs = null ;
// The one EventSource, and how many errors in a row it has had.
let es = null ;
let esErrors = 0 ;
// The server's name for the exact view this page last drew from. Handed back
// when the stream opens, so the server can skip resending what is on screen.
let lastHave = null ;
let pollTimer = null ;
// After the stream gives up, polling keeps the page alive and a good poll tries
// the stream again, no sooner than `esRetryAt`. The wait doubles on each give-up
// (capped) and resets once a stream opens, so a flaky server is not
// thrashed with new connections.
const ES_RETRY_MIN_MS = 3000 ;
const ES_RETRY_MAX_MS = 60000 ;
let esRetryMs = ES_RETRY_MIN_MS ;
let esRetryAt = 0 ;
let draftTimer = null ;
// What the about tracker last saw, so only a change is an event.
const aboutSeen = { view : null , selected : undefined , spec : undefined };
/* -------------------------------------------------------------- the draft */
function storeKey () {
return "p2c-console:" + ( page . S ? page . S . sid : "pending" );
}
export function save () {
try {
localStorage . setItem ( storeKey (), JSON . stringify ( page . local ));
} catch {}
clearTimeout ( draftTimer );
draftTimer = setTimeout ( pushDraft , 600 );
}
function load () {
try {
const raw = localStorage . getItem ( storeKey ());
if ( raw ) page . local = { ... fresh (), ... JSON . parse ( raw ) };
} catch {
page . local = fresh ();
}
// Saved before context became a pick: an about set on its own must not
// survive the upgrade. Asked of the saved copy, before freshChat() fills
// in an empty history.
const upgraded = ! Array . isArray ( page . local . chat && page . local . chat . history );
page . local . chat = { ... freshChat (), ...( page . local . chat || {}) };
if ( upgraded ) {
page . local . chat . history = [];
page . local . chat . about = null ;
}
delete page . local . chat . frozen ;
delete page . local . chat . dropped ;
// A "Skipped" beat is a moment, not something to come back to on a reload.
delete page . local . skipFlash ;
// A chat send still on its way when the page went died with the old page:
// offered for Retry, never left saying "Sending…". If it did land, the
// frame's echo still hides it.
for ( const p of page . local . chat . pending ) if ( ! p . seq ) p . failed = true ;
settleStaleUploads ();
}
// An upload still marked in flight when the page loads died with the old page.
function settleStaleUploads () {
for ( const list of [... Object . values ( page . local . images || {}), page . local . chat . images ]) {
for ( const img of list ) if ( img . status === "uploading" ) img . status = "failed" ;
}
}
async function pushDraft () {
try {
await fetch ( "/draft" , {
method : "POST" ,
headers : { "content-type" : "application/json" },
body : JSON . stringify ({ staged : page . local . staged , drafts : page . local . drafts , images : page . local . images }),
});
} catch {}
}
// Questions that are theirs and still have no answer on them. This is what
// decides which control is the loud one: while this is non-empty the next
// question is the step, and Send is merely available.
const unanswered = () => myTurn (). filter (( i ) => ! page . local . staged [ i . id ]);
function agentStale () {
if ( ! page . agentLastSeen ) return false ;
return Date . now () - Date . parse ( page . agentLastSeen ) > patience ( STALE_MS );
}
export async function loadState () {
try {
const res = await fetch ( "/state" , { cache : "no-store" });
if ( ! res . ok ) throw new Error ( String ( res . status ));
const body = await res . json ();
// The same rev is the same state: adopting it again would redraw the page
// every few seconds while polling for nothing. Still proof of life, though.
if ( page . S && typeof body . rev === "number" && body . rev === rev ) {
lastContact = Date . now ();
page . agentLastSeen = body . agentLastSeen || page . agentLastSeen ;
markGone ();
} else {
adopt ( body );
}
retryStream ();
} catch {
markGone ();
}
}
export function adopt ( body ) {
const firstLoad = page . S === null ;
// What was already theirs to answer, measured BEFORE the new state lands,
// so what is theirs afterwards can be told apart from what just arrived.
const before = firstLoad ? null : new Set ( myTurn (). map (( i ) => i . id ));
const openBefore = firstLoad ? [] : openItems (). map (( i ) => i . id );
const wasFinished = Boolean ( finish ());
const prevWorkflow = page . S ? page . S . workflow : null ;
const prevSpecDir = page . S ? page . S . specDir : null ;
rev = body . rev ;
lastHave = body . have || null ;
page . S = body . state ;
page . agentLastSeen = body . agentLastSeen || null ;
page . pendingResult = Boolean ( body . pendingResult );
// A "still being picked up" banner is over once the send is: it said a
// moment, and left up it reads as a fault through every later screen.
if ( ! page . pendingResult && page . pendingBannerUp ) {
page . pendingBannerUp = false ;
banner ( null );
}
page . pendingStop = Boolean ( body . pendingStop );
page . chatFrame = body . chat || null ;
if ( body . workspace ) page . wsFrame = body . workspace ;
if ( body . meter ) page . meterFrame = body . meter ;
// Always replaced: an absent key means no update.
page . updateFrame = body . update || null ;
// Always replaced too: an older server sends none, and then there is no switch.
page . subagentsFrame = body . subagents || null ;
lastContact = Date . now ();
if ( page . gone ) {
page . gone = false ;
if ( $ ( "banner" ). textContent === GONE_BANNER ) banner ( null );
}
if ( firstLoad ) {
load ();
// A draft the server kept wins if this browser has nothing, which is how a
// second device or a cleared profile still picks up where you left off.
if ( ! Object . keys ( page . local . staged ). length && body . draft && body . draft . staged ) {
page . local . staged = body . draft . staged ;
page . local . drafts = body . draft . drafts || {};
page . local . images = body . draft . images || {};
settleStaleUploads ();
}
}
2026-10-19 15:56:52 -07:00
// A hop that starts clean (hops.js: a launch from the dashboard menu, back
// to it, or into Git from anywhere). The server already blanked the
// session; what this page kept for the last skill -- the question on
// screen, the open tab, anything staged or typed against its item ids --
// goes too. The launch in flight and the dashboard's spec pick are about the
// hand-off itself, so they stay. A skill run inline from another (a quick
// task's review) keeps all of it.
if ( startsClean ( prevWorkflow , page . S . workflow )) {
2026-10-18 15:39:24 -07:00
// The pick rides into the skill it launched, never back home: arriving at
// the dashboard, the picker starts on the most recently touched spec still
// in play, the one the agent's fresh menu recommends for.
const keepPick = page . S . workflow !== "dashboard" && "specSel" in page . local ;
page . local = { ... fresh (), launching : page . local . launching , ...( keepPick ? { specSel : page . local . specSel } : {}) };
save ();
page . selected = null ;
page . view = "questions" ;
// And forget which tab is drawn, or the next render would store the old
// skill's offset straight back under a tab id the new one may reuse.
scrollMemory . clear ();
drawnView = null ;
drawnTabs = null ;
// The board's search, picks, open panel and tab belonged to that git run too.
resetBoard ();
board . settled . clear ();
}
// The welcome belongs to the dashboard: a pick made under it (or a hop
// the agent made) leaves it behind, over a skill it says nothing about.
if ( prevWorkflow === "dashboard" && page . S . workflow !== "dashboard" && $ ( "welcome-modal" ). open ) $ ( "welcome-modal" ). close ();
// A hop away from git that did not go through the dashboard (changelog and
// back, say) lets go of it the same way — the persisted copy too.
if ( prevWorkflow === "git" && page . S . workflow !== "git" ) {
resetBoard ();
page . local . gitBoard = null ;
}
adoptChat ();
// On the git board, a card the agent settled stays in the card slot until
// the next click on the board, so its outcome is not whisked away.
if ( page . S . workflow === "git" ) {
for ( const id of openBefore ) {
const item = byId ( id );
if ( item && ! isOpen ( item )) board . settled . add ( id );
}
} else board . settled . clear ();
// The finish a review was asked from has gone: the agent took the review
// up. A later finish (after the review, or after a second phase) starts
// with its own offer unanswered.
if ( ! finish () && page . local . afterBuild ) {
page . local . afterBuild = null ;
save ();
}
// A way home that ended in a finish instead (the agent paused rather than
// resuming as the dashboard) is over: the finish screen says the rest.
if ( finish () && page . local . homeward ) {
page . local . homeward = null ;
save ();
}
// The end of the session is a page of its own in the rail. Landing there
// the moment the finish arrives keeps it where the current design already
// put it: on top. A finish that goes away (a review taken up) drops the
// page back to the questions with it.
const endLanded = Boolean ( finish ()) && ! wasFinished ;
if ( endLanded ) {
page . view = "end" ;
// The closing chime -- unless this page only just loaded into an already
// finished session, in which case the opening one IS this sound.
if ( ! firstLoad ) sound ( "sessionEnd" );
}
if ( ! finish () && page . view === "end" ) page . view = "questions" ;
// A launch ends the moment the launched skill turns the page: it resumes the
// session under its own workflow, so `dashboard` stops being what the state
// says it is. A finish while still on the dashboard is the launch declined
// or the session ended; either way the menu is not mid-handoff any more.
if ( ! isDashboard () || finish ()) page . dashPick = null ;
// A launch (or an ending) mid wake-up: cut it short rather than play on
// over a page that is no longer the menu.
if ( page . wake && ( ! isDashboard () || finish ())) page . wake . abort . abort ();
if ( page . local . launching && ( ! isDashboard () || finish ())) {
const was = page . local . launching ;
page . local . launching = null ;
save ();
// A resume that lands before the skill has said anything turns the page
// into its starting screen, which is not "ready" yet: the chime and the
// banner wait for the first thing it actually puts on the page.
if ( ! finish () && ( asked (). length || doingNow () || docs (). length )) {
sound ( "skillReady" );
banner ( ` ${ was . title } is ready.` , "good" );
clearTimeout ( arrivalBannerTimer );
arrivalBannerTimer = setTimeout (() => ! page . gone && banner ( null ), 4000 );
}
}
// Anything the agent has now recorded is no longer "staged" or in flight.
for ( const id of Object . keys ( page . local . staged )) {
const item = byId ( id );
if ( ! item || ! isOpen ( item )) delete page . local . staged [ id ];
}
// A question stops being in flight when the agent has dealt with it: either
// it settled the question, or it has replied and left it open, which means it
// is asking again and the person may answer again.
const replied = ! page . pendingResult && ! agentWorking ();
for ( const id of Object . keys ( page . local . sent || {})) {
const item = byId ( id );
if ( ! item || ! isOpen ( item ) || replied ) {
// Re-asked in its thread rather than settled: the question is theirs
// again, and what they sent goes back on the form to edit, not away.
// A reordered and renamed list, say, would otherwise have to be redone.
// One-click answers (a verdict, a yes) are not put back: re-clicking is
// free, and a pre-staged "I want changes" is one Send from going twice.
const effort = [ "list" , "text" , "multi" , "checklist" , "choice" ]. includes ( item && item . kind );
// A card collected and left open (a partial settle) is the same: theirs
// again, with what they sent still on it.
// Never on a finished (or paused) session: nothing more can be sent there.
if ( effort && ! finish () && isOpen ( item ) && replied && ! page . local . staged [ id ] && ( agentRepliedAfterSend ( item ) || sendCollected ( item ))) {
const back = sentAnswer ( page . local . sent [ id ]);
if ( back ) page . local . staged [ id ] = back ;
}
delete page . local . sent [ id ];
}
}
// A retracted send suppresses exactly that send. Once the item moves --
// settled, sent again (a new `at`), or answered by an agent reply -- the
// mark is stale and keeping it would hide a send that is not that one.
for ( const id of Object . keys ( page . local . retract || {})) {
const item = byId ( id );
const r = page . local . retract [ id ];
const live =
item &&
isOpen ( item ) &&
submittedAwaiting ( item ) &&
( r === "any" || ( item . submitted && item . submitted . at === r ));
if ( ! live ) delete page . local . retract [ id ];
}
// New work: a question that is theirs to answer now and was not a moment ago.
// That covers a brand new question and one the agent reopened or answered
// with a follow-up, and not the first load, which has nothing to compare to.
const arrived = before && ! finish () ? myTurn (). filter (( i ) => ! before . has ( i . id )) : [];
let announce = null ;
if ( arrived . length ) {
// Their turn again, announced by ear as well as by eye: the chime matters
// most exactly when the banner is the fallback, because they are busy
// somewhere else on the page.
sound ( "question" );
if ( typingHere ()) {
// Mid-sentence somewhere. Moving the page under their cursor would lose
// their place for the sake of telling them something that can wait.
banner (
arrived . length === 1
? "A new question from Plan2Code. It is in the list on the left."
: ` ${ arrived . length } new questions from Plan2Code. They are in the list on the left.` ,
"info"
);
clearTimeout ( arrivalBannerTimer );
arrivalBannerTimer = setTimeout (() => ! page . gone && banner ( null ), 8000 );
} else {
page . selected = arrived [ 0 ]. id ;
page . view = "questions" ;
announce = arrived ;
}
}
if ( ! page . selected || ! byId ( page . selected )) page . selected = pickDefault ();
// A reply that lands while another tab is open: a dot on Ask, and one chime.
// Not on the first load, which has nothing new to announce.
const dot = unreadDot ({ lastSeenReplyId : page . local . chat . lastSeenReplyId , frameChat : page . chatFrame , viewIsAsk : page . view === "ask" });
if ( ! firstLoad && shouldChime ( page . chatDot , dot )) sound ( "chatReply" );
page . chatDot = dot ;
render ();
if ( $ ( "workspace-modal" ). open ) renderWorkspace ();
tellFolderIssues ();
// The Overview tab's file changes under a build, so a tab you are watching
// refetches on every new frame too, not only on the click that opened it.
if ( firstLoad || page . S . specDir !== prevSpecDir || page . S . workflow !== prevWorkflow || page . view === "overview" ) loadOverview ();
if ( announce ) showArrival ( announce );
// New entries land at the bottom of the rail. Gliding down to them beats
// leaving the list parked where it was while it grew underneath.
if ( arrived . length ) scrollRail ( "end" );
// The ending item lands at the TOP of the rail, above a list that may be
// scrolled well down, so the rail goes up to show the page now on screen.
if ( endLanded ) scrollRail ( "top" );
}
// The chat's half of adopt(). A new conversation (New conversation pressed in
// any tab, or a skill switch) is a clean page: nothing typed or waiting for
// the old one carries over. Conversations only ever count up, so a frame that
// names an older one than this page already moved to is a late frame, not a
// switch. Sends the server has now echoed stop being pending.
function adoptChat () {
const conv = page . chatFrame ? page . chatFrame . conversation : null ;
if ( conv != null && conv !== page . local . chat . conversation ) {
if ( page . local . chat . conversation == null ) page . local . chat . conversation = conv ;
else if ( conv > page . local . chat . conversation ) {
// What they were typing, and what they had attached to it, is theirs:
// a new conversation started elsewhere (another tab, a skill switch)
// must not wipe a message they have not sent yet.
page . local . chat = { ... freshChat (), history : page . local . chat . history , draft : page . local . chat . draft , images : page . local . chat . images , about : null , conversation : conv };
page . chatError = "" ;
page . askRowCount = 0 ;
declineOpen . clear ();
}
save ();
}
if ( page . local . chat . pending . length ) {
const shown = new Set (
chatView ( page . chatFrame , { pendingSends : page . local . chat . pending })
. rows . filter (( r ) => r . pending )
. map (( r ) => r . tempId )
);
const still = page . local . chat . pending . filter (( p ) => shown . has ( p . tempId ));
if ( still . length !== page . local . chat . pending . length ) {
page . local . chat . pending = still ;
save ();
}
}
}
// Top or bottom of the session outline, smoothly unless the person has asked
// the browser for less motion.
function scrollRail ( where ) {
const rail = $ ( "sidebar" );
rail . scrollTo ({
top : where === "top" ? 0 : rail . scrollHeight ,
behavior : matchMedia ( "(prefers-reduced-motion: reduce)" ). matches ? "auto" : "smooth" ,
});
}
let arrivalBannerTimer = null ;
// Typing in any text field, the question's own or the notes beside it.
function typingHere () {
const a = document . activeElement ;
if ( ! a ) return false ;
return a . tagName === "TEXTAREA" || ( a . tagName === "INPUT" && ( a . type === "text" || a . type === "date" ));
}
// The moment the ball comes back.
//
// After Send the person has usually looked away: to the terminal, to another
// window, to the doc tab. The page has already moved them to the first new
// question; this is what makes the move legible instead of a page that
// silently changed while they were not looking. It covers everything
// for a beat, says what happened, and gets out of the way by itself. Any
// click or key dismisses it at once, and it never takes focus from a dialog.
function showArrival ( arrived ) {
// A dialog is in the browser's top layer, above anything this could draw,
// so the overlay would play unseen behind it. The move has still happened.
if ( document . querySelector ( "dialog[open]" )) return ;
const old = document . querySelector ( ".arrival" );
if ( old ) old . remove ();
const layer = el ( "div" , "arrival" );
layer . setAttribute ( "aria-hidden" , "true" ); // the status line announces it
const box = el ( "div" , "arrival-box" );
box . appendChild ( el ( "p" , "arrival-kicker" , "Plan2Code is back" ));
box . appendChild ( el ( "p" , "arrival-title" , arrived . length === 1 ? "Next question" : "Next questions" ));
box . appendChild ( el ( "p" , "arrival-what" , arrived [ 0 ]. title ));
if ( arrived . length > 1 ) {
const more = arrived . length - 1 ;
box . appendChild ( el ( "p" , "arrival-more" , `and ${ more } more after it` ));
}
layer . appendChild ( box );
document . body . appendChild ( layer );
let done = false ;
const close = () => {
if ( done ) return ;
done = true ;
layer . classList . add ( "is-leaving" );
removeEventListener ( "keydown" , close , true );
setTimeout (() => layer . remove (), 320 );
// Where the eye goes next. Not the first field: that would scroll and
// put a caret in front of someone who has not read the question yet.
if ( ! document . querySelector ( "dialog[open]" )) $ ( "main" ). focus ({ preventScroll : true });
};
layer . addEventListener ( "click" , close );
addEventListener ( "keydown" , close , true );
setTimeout ( close , 1900 );
}
function pickDefault () {
// What is theirs first: an open question whose answer is already with the
// agent is reference, not work, and landing on it buries the one that
// still needs them.
const open = myTurn (). length ? myTurn () : openItems ();
if ( open . length ) return open [ 0 ]. id ;
const all = asked ();
return all . length ? all [ all . length - 1 ]. id : null ;
}
// An open EventSource is itself proof of life. Without this the page would
// declare itself offline during any quiet stretch, since a healthy session
// sends no state events while the agent is thinking.
function connected () {
if ( es && es . readyState === EventSource . OPEN ) return true ;
return Date . now () - lastContact <= GONE_AFTER_MS ;
}
function markGone () {
const bad = ! connected ();
if ( bad && ! page . gone ) {
page . gone = true ;
// After a finish the server going away IS the ending: the agent stops it
// on its way out. Saying "lost contact" and promising to reconnect would
// dress the expected last step of a session up as a fault, and it would
// land on top of the hand-off a few seconds after they got there.
// Same for a stop in progress: the wrapping-up screen says what the loss
// of the server means there, and a banner promising a reconnect would
// argue with it.
if ( ! finish () && ! stopInProgress ()) {
banner ( GONE_BANNER , "warn" );
}
render ();
} else if ( ! bad && page . gone ) {
page . gone = false ;
if ( $ ( "banner" ). textContent === GONE_BANNER ) banner ( null );
render ();
}
}
// Exactly one EventSource for the life of the page. Browsers cap HTTP/1.1 at
// about six connections per origin and a stream holds one permanently, so a
// second stream per tab across a few tabs wedges the origin with no error.
export function connect () {
esErrors = 0 ;
try {
es = new EventSource ( lastHave ? "/events?have=" + encodeURIComponent ( lastHave ) : "/events" );
} catch {
es = null ;
return startPolling ();
}
es . addEventListener ( "state" , ( e ) => {
esErrors = 0 ;
try {
adopt ( JSON . parse ( e . data ));
} catch {}
});
es . addEventListener ( "submitted" , ( e ) => {
// Drop only what was actually sent.
//
// This event fires for a send from ANY tab of this session, which is why it
// clears anything at all: a second tab must not keep offering answers that
// have already gone. But it also fires for a brief request, which carries
// no answers, and the blanket clear threw away everything the person had
// staged and not yet sent. A missing `ids` means an older server, where
// clearing everything is still the best guess available.
let ids = null ;
try {
ids = JSON . parse ( e . data ). ids ;
} catch {}
if ( Array . isArray ( ids )) for ( const id of ids ) delete page . local . staged [ id ];
else page . local . staged = {};
save ();
render ();
});
es . onopen = () => {
esErrors = 0 ;
esRetryMs = ES_RETRY_MIN_MS ;
lastContact = Date . now ();
// Back on the stream: polling was only ever the stand-in.
if ( pollTimer ) {
clearInterval ( pollTimer );
pollTimer = null ;
}
};
es . onerror = () => {
esErrors ++ ;
if ( esErrors >= 3 ) {
try {
es . close ();
} catch {}
es = null ;
startPolling ();
}
markGone ();
};
}
function startPolling () {
if ( pollTimer ) return ;
esRetryAt = Date . now () + esRetryMs ;
esRetryMs = Math . min ( esRetryMs * 2 , ES_RETRY_MAX_MS );
pollTimer = setInterval ( loadState , 3000 );
}
// While polling, every answer from the server is a cue to try the stream
// again, so polling lasts only as long as the outage did. Polling carries on
// while an attempt is open, so startPolling() never runs for a failed one; the
// wait is pushed back here instead, or a dead stream would be retried on every
// poll. One attempt at a time, since `es` is set while it is trying.
function retryStream () {
if ( ! pollTimer || es || Date . now () < esRetryAt ) return ;
esRetryAt = Date . now () + esRetryMs ;
esRetryMs = Math . min ( esRetryMs * 2 , ES_RETRY_MAX_MS );
connect ();
}
// Every five seconds: tell the server the page is still here, and hear back
// whether the agent is, whether a state frame went missing, and whether a
// send is still waiting to be picked up.
export function checkIn () {
fetch ( "/ping" , { method : "POST" })
. then (( r ) => ( r . ok ? r . json () : null ))
. then (( body ) => {
if ( ! body ) return ;
lastContact = Date . now ();
page . agentLastSeen = body . agentLastSeen || page . agentLastSeen ;
retryStream ();
// A rev we have not seen means a state frame went missing -- a dropped
// SSE reconnect, a tab asleep in a background window. Ask for it rather
// than waiting for the next change to come along.
if ( typeof body . rev === "number" && body . rev !== rev ) return loadState ();
if ( body . pendingResult !== page . pendingResult || Boolean ( body . pendingStop ) !== page . pendingStop ) {
page . pendingResult = body . pendingResult ;
page . pendingStop = Boolean ( body . pendingStop );
render ();
}
})
. catch (() => {})
. finally (() => {
markGone ();
renderStatus ();
});
}
let rendering = false ;
export function render () {
if ( ! page . S ) return ;
// A handler that fires while the DOM is being replaced (a blur as its element
// is removed, say) must not start a second render inside the first.
if ( rendering ) return ;
rendering = true ;
try {
trackAbout ();
const enteringAsk = page . view === "ask" && drawnView !== "ask" ;
const switchingTab = drawnView !== null && page . view !== drawnView ;
let tabAdded = false ;
rememberScroll ();
withFocus (() => {
renderChrome ();
renderStatus ();
renderBriefButton ();
renderSubagentsButton ();
renderStopButton ();
2026-10-19 15:56:52 -07:00
renderNotepadButton ();
2026-10-18 15:39:24 -07:00
renderHomeButton ();
tabAdded = renderViews ();
renderSidebar ();
renderMain ();
restoreScroll ();
renderAside ();
renderFooter ();
});
// The box an `@` list belonged to was just redrawn away.
if ( page . mentionPop && ! page . mentionPop . box . isConnected ) closeMentions ();
if ( enteringAsk ) {
const box = $ ( "ask-input" );
if ( box && ! box . disabled ) box . focus ({ preventScroll : true });
}
if ( switchingTab || tabAdded ) replayViewsArrow ();
if ( tabAdded ) sound ( "newTab" );
renderStopping ();
} finally {
rendering = false ;
}
}
// The runway chevrons beside the tabs pulse a few times on load and then rest.
// Moving to another tab, or a new tab turning up, runs them again: clearing
// the animation, forcing a reflow, then handing it back restarts it from the
// top. The CSS still gates the animation on prefers-reduced-motion, so this is
// a no-op there.
function replayViewsArrow () {
const arrows = document . querySelectorAll ( ".views-arrow svg" );
for ( const svg of arrows ) svg . style . animation = "none" ;
void document . querySelector ( ".views-arrow" ) ? . offsetWidth ;
for ( const svg of arrows ) svg . style . animation = "" ;
}
// The places + Add context offers, fed from where the person has been: the
// question card on screen, the doc block they left, the dashboard's spec.
// Only changes are events, and they only ever feed history: nothing here sets
// what a message is about.
function trackAbout () {
const before = page . local . chat ;
let st = { history : before . history , about : before . about };
const apply = ( event ) => ( st = nextAbout ( st , event ));
const moved = aboutSeen . view !== page . view ;
if ( moved && aboutSeen . view && aboutSeen . view . startsWith ( "doc:" ) && page . docInView ? . docId === aboutSeen . view . slice ( 4 )) {
apply ({ type : "section" , ... page . docInView });
}
if ( isDashboard ()) {
const spec = selSpec ();
const dir = spec ? spec . dir : null ;
if ( dir !== aboutSeen . spec ) {
aboutSeen . spec = dir ;
if ( spec ) apply ({ type : "spec" , dir : spec . dir , label : spec . name });
}
} else if ( page . selected !== aboutSeen . selected ) {
aboutSeen . selected = page . selected ;
const item = byId ( page . selected );
if ( item && item . kind !== "notice" ) apply ({ type : "card" , id : item . id , label : item . title });
}
if ( moved ) aboutSeen . view = page . view ;
if ( st . history !== before . history || st . about !== before . about ) {
Object . assign ( page . local . chat , st );
save ();
}
}
// Keeping the person's place across a full render: what had focus, where the
// text cursor sat, and how far down the card they had scrolled.
//
// A re-render replaces the card wholesale, and the card is the thing that
// scrolls. Ticking the fifth box in a long list threw the list back to the top
// with the box just aimed at now off screen, and dropped focus off the control
// that was pressed, which is worse for a keyboard user than for a mouse: they
// lose their position in the group as well as on the page. Every control that
// stages an answer went through this path -- checkboxes, radios, the Yes/No
// buttons -- because staging an answer is a full render.
//
// Not only a question card: the finished screen's card and the dashboard
// menu scroll themselves too, and a doc or the Overview scrolls the column.
// Each of those lost its place on every redraw (a click that staged a send,
// an agent post landing mid-read), until all of them came through here.
//
// The scroll is restored only while the same thing is on screen: the same
// question, the same kind of card, the same tab. Moving to another one should
// start at its top, not part-way down it. The git board keeps its own place
// per tab, so it is left to itself.
const MAIN_SCROLLERS = ":scope > .card, :scope > .dash, :scope > .launching, :scope > .dash-confirm, :scope > .waiting-pane" ;
// What a scrolling card shows: the question it holds, asked of the card
// itself, else its kind ("card handoff"), without the state classes a redraw
// may change. The `selected` variable is no use here: the rail and the pager
// both set it and then call render, so by now it already names where we are
// going.
function scrollerKey ( node ) {
if ( node . dataset . item ) return "item:" + node . dataset . item ;
return [... node . classList ]. filter (( c ) => ! c . startsWith ( "is-" ) && ! c . startsWith ( "has-" )). join ( " " );
}
function mainPlace () {
const main = $ ( "main" );
if ( main . querySelector ( ":scope > .git-board" )) return null ;
const inner = main . querySelector ( MAIN_SCROLLERS );
if ( inner && inner . scrollTop ) return { inner : true , key : scrollerKey ( inner ), top : inner . scrollTop };
if ( main . scrollTop ) return { inner : false , key : drawnView , top : main . scrollTop };
return null ;
}
function restoreMainPlace ( place ) {
if ( ! place ) return ;
const main = $ ( "main" );
if ( main . querySelector ( ":scope > .git-board" )) return ;
if ( ! place . inner ) {
if ( drawnView === place . key ) main . scrollTop = place . top ;
return ;
}
const inner = main . querySelector ( MAIN_SCROLLERS );
if ( inner && scrollerKey ( inner ) === place . key ) inner . scrollTop = place . top ;
}
function withFocus ( fn ) {
const a = document . activeElement ;
const keep =
a && ( a . tagName === "TEXTAREA" || a . tagName === "INPUT" || a . tagName === "SELECT" ) && a . id
? { id : a . id , start : a . selectionStart , end : a . selectionEnd }
: null ;
const place = mainPlace ();
fn ();
// Scroll first, then focus: focusing an element that is off screen scrolls it
// into view, which would undo the restore we just did.
restoreMainPlace ( place );
if ( keep ) {
const n = $ ( keep . id );
if ( n ) {
n . focus ();
try {
n . setSelectionRange ( keep . start , keep . end );
} catch {}
}
}
}
// Scroll memory across tab switches. withFocus() above keeps a card's place
// while the SAME tab re-renders; these two cover moving BETWEEN tabs, which
// withFocus() cannot see, because by the time it measures, the old tab's
// content is already gone. A re-render within one tab leaves `drawnView`
// equal to `view`, so restoreScroll() stands aside and withFocus() does it.
//
// The element that scrolls: the main column on a doc or the Overview, the
// question card on the questions tab, and nothing worth keeping elsewhere
// (the dashboard menu, the end page).
function currentScroller () {
if ( ! drawnView ) return null ;
if ( drawnView . startsWith ( "doc:" ) || drawnView === "overview" ) return $ ( "main" );
if ( drawnView === "questions" ) return $ ( "main" ). querySelector ( ":scope > .card.question" );
if ( drawnView === "ask" ) return $ ( "main" ). querySelector ( ".ask-list" );
return null ;
}
function rememberScroll () {
const scroller = currentScroller ();
if ( scroller ) scrollMemory . set ( drawnView , { top : scroller . scrollTop , item : scroller . dataset . item });
}
// A question card comes back to its place only while it is the same question:
// moving to another one still starts at its top. A doc with nothing stored
// starts at the top too, rather than inheriting the last doc's offset from the
// main column they share.
function restoreScroll () {
if ( page . view === drawnView ) return ;
drawnView = page . view ;
// The chat places its own list: back where it was, or at the newest row.
if ( page . view === "ask" ) return ;
const scroller = currentScroller ();
if ( ! scroller ) return ;
const saved = scrollMemory . get ( page . view );
if ( page . view === "questions" ) {
if ( saved && saved . item === scroller . dataset . item ) scroller . scrollTop = saved . top ;
return ;
}
scroller . scrollTop = saved ? saved . top : 0 ;
}
// `extras` are nodes shown after the text: a copyable hint, an action.
export function banner ( text , kind , extras ) {
const n = $ ( "banner" );
if ( ! text ) {
n . hidden = true ;
n . textContent = "" ;
return ;
}
n . hidden = false ;
n . className = "banner " + ( kind || "" );
n . textContent = text ;
for ( const node of extras || []) n . appendChild ( node );
}
// The session meter's pill, straight from the frame's `meter` (meter.js did
// the counting). Hidden until a frame carries it.
function renderMeter () {
const pill = $ ( "meter-pill" );
if ( ! page . meterFrame ) {
pill . hidden = true ;
return ;
}
pill . hidden = false ;
pill . dataset . level = page . meterFrame . level ;
const fraction = Math . max ( 0 , Math . min ( 1 , Number ( page . meterFrame . fraction ) || 0 ));
$ ( "meter-fill" ). setAttribute ( "stroke-dashoffset" , String ( Math . round (( 1 - fraction ) * 1000 ) / 10 ));
$ ( "meter-words" ). textContent = page . meterFrame . words ;
pill . title = page . meterFrame . tooltip ;
$ ( "meter-tip" ). textContent = page . meterFrame . tooltip ;
// What the points are made of: one row per piece of work that scored.
const list = $ ( "meter-list" );
const rows = Array . isArray ( page . meterFrame . items ) ? page . meterFrame . items : [];
list . hidden = ! rows . length ;
list . replaceChildren (
... rows . map (( row ) => {
const li = el ( "li" );
li . appendChild ( el ( "span" , "meter-item-label" , row . label ));
li . appendChild ( el ( "span" , "meter-item-points" , "+" + row . points ));
return li ;
})
);
// Once the session is past fresh, say how to start a new one.
const fresh = $ ( "meter-fresh" );
fresh . hidden = page . meterFrame . level === "green" ;
if ( fresh . hidden || fresh . dataset . built ) return ;
fresh . dataset . built = "1" ;
const text = handoffText ({ command : DASHBOARD_COMMAND });
const code = el ( "code" , "handoff-code" , text );
const row = el ( "div" , "handoff-command meter-fresh-row" );
row . append ( code , copyButton ( text , "btn small ghost handoff-copy" , code ));
fresh . append (
textWithCode ( "p" , "meter-fresh-text" , `To start a new session, run \` ${ DASHBOARD_COMMAND } \` in a new conversation:` ),
row
);
}
function renderChrome () {
renderMeter ();
$ ( "title" ). textContent = page . S . title || "Session" ;
$ ( "badge" ). textContent = workflowLabel ( page . S . workflow );
renderTabTitle ();
const h = page . S . headline || {};
// A build counts tasks, which get done rather than answered.
const building = isBuild ( page . S . workflow );
// On a finished session an open item is frozen: the send on it counts as
// done, and only a question that was never touched stays outstanding.
const answeredCount = () => asked (). filter (( i ) => ! isOpen ( i ) || ( finish () && Boolean ( recordedAnswer ( i )))). length ;
// The agent's own count wins once it gives a total, 0 done included: a
// phase starting at "cleared": 0 is 0 done, not the cards answered before
// it. A build between counts (a review starting at total 0) shows its stage.
// A fresh session's headline is 0 of 0 too, so that alone means "unset".
let done ;
let total ;
if ( Number ( h . total ) > 0 ) {
// A question workflow that set a total and never moved `cleared` still
// fills as cards are answered; a build's 0 is a fact about its tasks.
done = building ? Math . max ( 0 , Number ( h . cleared ) || 0 ) : Number ( h . cleared ) || answeredCount ();
total = progressTotal ( done , Number ( h . total ));
} else if ( building && h . stage ) {
done = 0 ;
total = 0 ;
} else {
done = answeredCount ();
total = progressTotal ( done , asked (). length );
}
const pct = total ? Math . round (( done / total ) * 100 ) : 0 ;
// The menu has no questions to count: an empty bar there reads as a stall.
document . querySelector ( ".progress-block" ). hidden = ( isDashboard () || page . S . workflow === "git" ) && ! finish ();
$ ( "progress-text" ). textContent = total
? ` ${ done } of ${ total } ${ building ? "done" : "answered" } `
: h . stage || "Getting started" ;
$ ( "confidence" ). textContent = h . confidence || "" ;
$ ( "progress-fill" ). style . width = pct + "%" ;
const bar = $ ( "progress-bar" );
// A stage with nothing to count (a review starting) says its words, no track.
bar . hidden = ! total && Boolean ( h . stage );
bar . setAttribute ( "aria-valuenow" , String ( done ));
bar . setAttribute ( "aria-valuemin" , "0" );
bar . setAttribute ( "aria-valuemax" , String ( total ));
}
// Planny and the line beside him are one surface, and this is the only thing
// that writes to it. He carries four moods:
//
// point something is yours to do, and the line says what
// work the agent has it, star turning, feet walking
// happy nothing outstanding
// done the session is over, and there is one thing left to do elsewhere
// adrift the server is up but nothing is listening at the other end
// gone no server, eye shut
//
// Each mood is a family: v0 is the plain drawing and the rest are alternates
// (a hop, star-scanning, sparkles, Z's -- see the "mood variants"
// section of app.css). A new variant is rolled only when the mood CHANGES, so
// the once-a-second status tick does not restart his animation every time it
// runs, and the same state keeps the same face until the state itself moves.
const MOOD_VARIANTS = { point : 3 , work : 3 , happy : 3 , done : 2 , adrift : 2 , gone : 2 };
let moodNow = null ;
let moodVar = 0 ;
export function renderStatus () {
if ( ! page . S ) return ;
const bot = $ ( "planny" );
const text = $ ( "agent-text" );
const tick = $ ( "agent-tick" );
// SVG className is not a plain string, so setAttribute is the way in.
// `line` goes in the live region and changes rarely; `count` is the running
// clock and is kept out of it, or the page reads the seconds aloud.
// `spin` marks the lines where something really is happening at the other
// end right now, and it flies too: the ring and the stars mean the same
// thing. Never on the stale or adrift lines: a turning ring beside
// "has not checked in" would contradict the sentence it sits next to.
// `check` adds a "What to check" button that opens Help on the stuck tab.
const say = ( mood , line , count , spin , check ) => {
if ( mood !== moodNow ) {
moodNow = mood ;
moodVar = Math . floor ( Math . random () * MOOD_VARIANTS [ mood ]);
}
bot . setAttribute ( "class" , `planny is- ${ mood } v ${ moodVar } ` );
const shown = check ? ` ${ line } |check` : line ;
if ( text . dataset . line !== shown ) {
text . dataset . line = shown ;
const parts = line . split ( /\*\*(.+?)\*\*/ ). map (( part , i ) => {
if ( i % 2 === 0 ) return document . createTextNode ( part );
const key = document . createElement ( "strong" );
key . className = "agent-key" ;
key . textContent = part ;
return key ;
});
if ( check ) {
const help = document . createElement ( "button" );
help . type = "button" ;
help . className = "status-help" ;
help . textContent = "What to check" ;
help . addEventListener ( "click" , () => openHelpOn ( "stuck" ));
parts . push ( document . createTextNode ( " " ), help );
}
text . replaceChildren (... parts );
}
tick . textContent = count || "" ;
$ ( "agent-spin" ). hidden = ! spin ;
$ ( "dock" ). classList . toggle ( "is-flying" , Boolean ( spin ));
// The tab icon's bar says the same thing from another tab (favicon.js).
setFavicon ( faviconState ({ mood , spin , finished : Boolean ( finish ()) }));
};
// Before `gone`, deliberately. Once a session has finished, no server is the
// expected state, and Planny shutting his eye over it reads as a breakage.
if ( finish ()) {
// A finish with the review or the way back to the dashboard still on
// offer has something left to press here, and only while the server is
// there to take the press.
if ( page . local . afterBuild === "dashboard" && ! page . gone ) return say ( "work" , "Opening the dashboard…" , "" , true );
if ( page . local . afterBuild === "commit" && ! page . gone ) return say ( "work" , "Opening Git…" , "" , true );
2026-10-19 17:55:37 -07:00
if ( page . local . afterBuild === "changelog" && ! page . gone ) return say ( "work" , "Opening Changelog…" , "" , true );
if ( page . local . afterBuild === "launch" && ! page . gone ) return say ( "work" , "Starting the next step…" , "" , true );
2026-10-18 15:39:24 -07:00
const offer = reviewPending ();
if ( dashboardLive ( finish ()) && ! page . gone && ! offer ) {
return say ( "point" , "Done. Head back to the dashboard, or close this tab." );
}
if ( offer === "asked" ) return say ( "work" , "Review requested. Plan2Code is starting it." , "" , true );
if ( offer === "open" ) return say ( "point" , "Done. Review it here first, or close this tab." );
// A stop past a warning kept nothing, so it promises no saved place.
if ( finishPaused ( finish ()))
return say ( "done" , stopWarning () ? "Paused. The command above starts it again." : "Paused. Your place is saved: the command above picks it up." );
return say ( "done" , "All done. You can close this tab." );
}
if ( page . gone ) return say ( "gone" , "Not connected. Your answers are saved." , "" , false , true );
// On the way home: the request is sent, and the page stays this skill's
// until the agent resumes the session as the dashboard.
if ( page . local . homeward && ! isDashboard ()) {
return agentAdrift ()
? say ( "adrift" , "Your way back to the dashboard is saved and waiting for Plan2Code." )
: say ( "work" , "Saving your place and opening the dashboard…" , "" , true );
}
// The dashboard's three states, ahead of the question logic it never
// reaches: the pick is theirs to make, it is being looked at, or it is on
// its way to becoming a skill.
if ( isDashboard ()) {
if ( page . local . launching ) {
const stale = staleLaunchFeedback ( page . local . launching . title , agentAdrift ());
return stale
? say ( "adrift" , ` ${ page . local . launching . title } is saved and waiting for Plan2Code.` )
: say ( "work" , `Waking up ${ page . local . launching . title } …` , "" , true );
}
if ( page . dashPick ) return say ( "point" , `Start ${ page . dashPick . title } when you're ready.` );
// The cards work before the agent's menu lands, so a pick is always
// theirs; the line still says what the agent is up to, or that it went quiet.
if ( agentAdrift ()) return say ( "adrift" , "Plan2Code has gone quiet. A pick still waits here for it." );
const doing = page . S . agent && typeof page . S . agent . activity === "string" ? page . S . agent . activity . trim () : "" ;
if ( agentWorking () && ! page . S . menu ) return say ( "point" , `Pick what we are doing today. ${ doing || "Plan2Code is looking over the project." } ` );
return say ( "point" , "Your move: pick what we are doing today." );
}
// A build can run a long while before it has anything to ask. Once the agent
// says what it is doing, the working line below says that instead, rather
// than promising questions that may never come.
if ( ! asked (). length && ! doingNow () && ! isGitBoard ()) {
return say ( "work" , `Starting ${ workflowTitle ( page . S . workflow ) } …` , "" , true );
}
// Show the AGENT's liveness, not the server's: if the agent's turn crashed
// the server is still happily up, and a plain spinner would lie forever.
if ( agentWorking ()) {
if ( agentStale ()) {
return say (
"work" ,
"Still working on it. Longer tasks can go a few minutes between updates. Your answers are saved. If it stays quiet for a long while, check your terminal (it may be waiting on a permission approval)." ,
"" ,
false ,
true
);
}
// Same clock as agentStale(), so the soft line at 30 s hands over to the
// stale message at two minutes on one timeline.
const hint = page . agentLastSeen ? approvalHint ( page . S . agent , Date . now () - Date . parse ( page . agentLastSeen )) : "" ;
return say ( "work" , hint || activity () || "Plan2Code is thinking…" , fmtMs ( workingMs ()), true , Boolean ( hint ));
}
// Between pressing Send and the agent picking it up, the agent's own status
// is still "waiting" because it has not started yet. Reading that as "your
// turn" told someone who had just answered everything that the ball was back
// with them. Their own send is the thing that has moved.
// Before the ordinary "sent, waiting" line, which is true for a minute and
// a lie after twenty.
if ( agentAdrift ()) {
return say (
"adrift" ,
stranded ()
? "Plan2Code is not running. Your answers are saved and waiting for it. If the terminal is idle, type **continue** there and it will pick them up; it may also be waiting for your permission approval."
: "Plan2Code is not running right now. Anything you answer here is saved. If the terminal is idle, type **continue** there to wake it; it may also be waiting for your permission approval." ,
"" ,
false ,
true
);
}
const mine = myTurn (). length ;
// A board click names no question, so nothing above has said it went.
if ( isGitBoard () && ( page . pendingResult || gitAwaiting ()) && ! awaitingReply (). length ) {
return say ( "work" , "Sent. Waiting for Plan2Code." , "" , true );
}
if ( awaitingReply (). length ) {
return mine
? say ( "point" , `Sent. ${ mine } question ${ mine === 1 ? "" : "s" } still for you.` )
: say ( "work" , "Sent. Waiting for Plan2Code." , "" , true );
}
if ( ! mine && isGitBoard ()) return say ( "point" , "The board is yours. Pick what to do next." );
if ( ! mine ) return say ( "happy" , "All caught up." );
// Everything in front of them is answered and only Send is left. This is the
// one moment the page can name the next step and be certain it is right.
if ( ! unanswered (). length ) return say ( "point" , "That is all of them. Send it over." );
const todo = unanswered (). length ;
if ( todo === mine ) return say ( "point" , `Your turn: ${ mine } question ${ mine === 1 ? "" : "s" } waiting.` );
// An optional card (required: false) left blank owes nothing: Send is the
// step once only those remain.
const owed = unanswered (). filter (( i ) => i . required !== false ). length ;
if ( ! owed ) return say ( "point" , "Ready to send. The rest are optional." );
return say ( "point" , ` ${ owed } still to answer, then send.` );
}
function renderViews () {
const nav = $ ( "views" );
nav . replaceChildren ();
// Sent and not yet picked up: the same ring as Ask, until Plan2Code moves on
// or goes quiet (a turning ring would pass a dead session for a slow one).
const sentBusy = page . pendingResult && ! page . gone && ! agentAdrift ();
const tabs = [
{
id : "questions" ,
label : isDashboard () ? "Dashboard" : page . S . workflow === "git" ? "Git" : "Questions" ,
count : myTurn (). length ,
busy : sentBusy ,
},
];
// Built in rather than posted: present exactly while the spec in view has
// an overview.md. A tab that vanishes under the person sends them home.
const hasOverview = typeof page . overview . text === "string" && page . overview . key === overviewSpec ();
if ( hasOverview ) tabs . push ({ id : "overview" , label : "Overview" , count : 0 });
else if ( page . view === "overview" ) page . view = "questions" ;
for ( const d of docs ()) tabs . push ({ id : "doc:" + d . id , label : d . title || "Document" , count : 0 });
// The helpers the agent reported, from the first one on; cleared by a
// dashboard hop, which sends the person home like the Overview tab does.
if ( showTab ( page . subagentsFrame , page . S . helpers )) {
// From the rows the tab draws, so the badge never counts helpers the
// working-alone note hides.
const running = helperRows ( page . S . helpers ). rows . filter (( r ) => r . state === "running" ). length ;
tabs . push ({ id : "subagents" , label : "Subagents" , count : running , busy : running > 0 });
} else if ( page . view === "subagents" ) page . view = "questions" ;
// Always last, on every workflow and after a finish: the Quick question chat.
// The ring left of "Ask" shows exactly when the conversation's own ring does:
// a question the agent picked up and has not answered yet.
const ask = askState ();
const askBusy = ask . view . rows . some (( r ) => r . working ) && ask . send . state !== "offline" && ! agentAdrift ();
tabs . push ({ id : "ask" , label : "Ask" , count : 0 , dot : page . chatDot , busy : askBusy });
for ( const t of tabs ) {
const b = el ( "button" , "view-tab" , t . label );
b . type = "button" ;
// A long doc title is cut on the tab (CSS); the whole of it is the tooltip.
if ( ! b . title ) b . title = t . label ;
if ( t . busy ) {
const spin = el ( "span" , "spinner tiny tab-spin" );
spin . setAttribute ( "aria-hidden" , "true" );
b . prepend ( spin );
const titles = { ask : "Plan2Code is working on an answer" , subagents : "Subagents are running" };
b . title = titles [ t . id ] || "Sent. Waiting for Plan2Code" ;
}
b . setAttribute ( "aria-current" , String ( page . view === t . id || ( t . id === "questions" && page . view === "end" )));
if ( t . count ) {
const c = el ( "span" , "tab-count" , String ( t . count ));
b . appendChild ( c );
}
if ( t . dot ) {
const dot = el ( "span" , "tab-dot" );
dot . setAttribute ( "aria-label" , "New reply" );
b . appendChild ( dot );
}
b . addEventListener ( "click" , () => {
if ( t . id === "ask" ) {
page . local . chat . lastSeenReplyId = newestReplyId ( page . chatFrame );
page . chatDot = false ;
save ();
}
page . view = t . id === "questions" && finish () ? "end" : t . id ;
// The cached text paints at once; the fresh read repaints if the file
// changed on disk since.
render ();
if ( t . id === "overview" ) loadOverview ();
});
nav . appendChild ( b );
}
// Reports whether a tab appeared that the last draw did not have.
const ids = new Set ( tabs . map (( t ) => t . id ));
const added = drawnTabs !== null && [... ids ]. some (( id ) => ! drawnTabs . has ( id ));
drawnTabs = ids ;
return added ;
}
export function renderSidebar () {
const rail = $ ( "sidebar" );
rail . replaceChildren ();
const fin = finish ();
if ( fin ) rail . appendChild ( renderEndItem ( fin ));
// On the dashboard the rail is the same menu in outline form, so a person
// who learned the page on a workflow session finds the picks where the
// session outline usually lives. The card that is mid-launch gets the
// half-filled mark the page uses for "sent, on its way".
if ( isDashboard () && ! fin ) {
const menu = ( page . S && page . S . menu ) || {};
for ( const g of CATALOG_GROUPS ) {
const box = el ( "div" , "rail-group" );
const head = el ( "p" , "rail-title" );
head . appendChild ( el ( "span" , null , g . title ));
box . appendChild ( head );
for ( const e of SKILL_CATALOG . filter (( x ) => x . group === g . id )) {
const av = cardPresentation ( e , scan (), selSpec (), menu );
// Unavailable for the selected spec fades hard; the brief greying
// while a launch is in flight or the server is away does not.
const b = el (
"button" ,
"rail-item" + ( av . on ? "" : " is-unavailable" ) + ( av . recommended ? " is-suggested" : "" )
);
b . type = "button" ;
b . disabled = Boolean ( page . local . launching ) || page . gone || page . pendingResult || ! av . on ;
if ( ! av . on && av . reason ) b . title = av . reason ;
b . setAttribute ( "aria-current" , String ( Boolean ( page . dashPick && page . dashPick . skill === e . skill )));
2026-10-19 15:56:52 -07:00
const isGoing = page . local . launching && ( page . local . launching . skill === e . skill || page . local . launching . skill === e . review );
2026-10-18 15:39:24 -07:00
const isPicked = page . dashPick && page . dashPick . skill === e . skill ;
const mark = el (
"span" ,
"rail-mark " + ( isGoing || isPicked ? "staged" : "open" ),
isGoing ? "◐" : isPicked ? "●" : "○"
);
mark . title = isGoing ? "starting" : isPicked ? "picked" : "pick to start" ;
b . appendChild ( mark );
b . appendChild ( el ( "span" , null , e . title ));
// The center pane's own "Suggested" pill scrolls out of view, so the
// rail repeats the call-out here as a small dot next to the title.
if ( av . recommended ) {
const dot = el ( "span" , "rail-suggested-dot" , "" );
dot . title = "Suggested next step" ;
b . appendChild ( dot );
}
// Same as a card click: the pick goes to the confirm pane, never
// straight to a launch. From the Overview tab too, so the pane shows.
b . addEventListener ( "click" , () => {
page . dashPick = e ;
page . view = "questions" ;
render ();
});
box . appendChild ( b );
}
rail . appendChild ( box );
}
return ;
}
const list = asked ();
if ( ! list . length ) {
rail . appendChild ( el ( "p" , "rail-empty" , "Nothing here yet." ));
return ;
}
const groups = new Map ();
for ( const item of list ) {
const key = item . topic || "_" ;
if ( ! groups . has ( key )) groups . set ( key , []);
groups . get ( key ). push ( item );
}
for ( const [ key , group ] of groups ) {
const topic = topics (). find (( t ) => t . id === key );
const box = el ( "div" , "rail-group" );
const head = el ( "p" , "rail-title" );
head . appendChild ( el ( "span" , null , topic ? topic . title : "Questions" ));
const settled = group . filter (( i ) => ! isOpen ( i ) || ( finish () && Boolean ( recordedAnswer ( i )))). length ;
head . appendChild ( el ( "span" , null , ` ${ settled } / ${ group . length } ` ));
box . appendChild ( head );
for ( const item of group ) {
const b = el ( "button" , "rail-item" );
b . type = "button" ;
// Only while the questions view is actually on screen: on the end page
// the question that was last selected is not the thing being looked at.
b . setAttribute ( "aria-current" , String ( page . view === "questions" && page . selected === item . id ));
const m = markFor ( item );
const mark = el ( "span" , "rail-mark " + m . cls , m . glyph );
mark . title = m . label ;
b . appendChild ( mark );
b . appendChild ( el ( "span" , null , item . title ));
b . addEventListener ( "click" , () => {
page . selected = item . id ;
page . view = "questions" ;
render ();
$ ( "main" ). focus ();
});
box . appendChild ( b );
}
rail . appendChild ( box );
}
}
function renderMain () {
const main = $ ( "main" );
page . heldPose = main . querySelector ( ":scope > [data-pose]" );
for ( const child of [... main . children ]) if ( child !== page . heldPose ) child . remove ();
try {
paintMain ( main );
} finally {
// Nothing took it up: this screen is not the same pose.
page . heldPose ? . remove ();
page . heldPose = null ;
}
// Inside the render pass, before withFocus restores the card's scroll, so
// the restore is measured against the box's final height.
fitGrowBox ();
markMore ();
}
function paintMain ( main ) {
main . classList . toggle ( "is-doc" , page . view . startsWith ( "doc:" ) || page . view === "overview" );
main . classList . toggle ( "is-ask" , page . view === "ask" );
if ( page . view . startsWith ( "doc:" )) return renderDoc ( main , page . view . slice ( 4 ));
if ( page . view === "overview" ) return renderOverview ( main );
if ( page . view === "ask" ) return renderAsk ( main );
if ( page . view === "subagents" ) return renderSubagents ( main );
// The session's own page, reached from the PAUSED / SESSION ENDED item at
// the top of the rail. The hand-off lives here alone now, rather than
// sitting on top of whatever question happens to be selected.
if ( page . view === "end" && finish ()) {
const card = renderHandoff ( finish ());
card . classList . add ( "is-primary" );
main . appendChild ( card );
return ;
}
// The dashboard has no questions to walk: its whole main column is the menu,
// or the getting-ready screen while a pick turns into a session. A finish
// falls through to the ordinary path below, which hands it the card.
if ( isDashboard () && ! finish ()) {
if ( page . local . launching ) renderLaunching ( main );
else if ( page . dashPick ) {
// A spec-switch under an open confirm can grey the pick out. Rather
// than offer START on a card that cannot launch, drop back to the
// menu — the picker's new selection speaks for itself there.
if ( cardAvailability ( page . dashPick , scan (), selSpec ()). on ) renderConfirm ( main , page . dashPick );
else {
page . dashPick = null ;
renderDashboard ( main );
}
} else renderDashboard ( main );
return ;
}
// The git board stays up after every action until Done with git. The
// agent's confirm and result cards sit in the board's cardSlot, under the
// tab strip and above the tab's content (FR-8); its `git-result` notice is
// the board's own result line instead.
if ( isGitBoard () && ! finish ()) {
// At most one card, matching the one-card rule elsewhere. The rail lists
// every item, so a settled card the pane stopped tracking still shows when
// the rail picks it. Non-git-result notices fold into the card — and a
// notice with no card to fold into still gets one, or the agent's word
// would render nowhere.
const cards = asked (). filter (( i ) => isOpen ( i ) || board . settled . has ( i . id ));
const sel = byId ( page . selected );
const item = cards . find (( i ) => i . id === page . selected ) || ( sel && sel . kind !== "notice" ? sel : null ) || cards [ 0 ];
const notices = items (). filter (( i ) => i . kind === "notice" && i . id !== "git-result" );
let card = null ;
let pager = null ;
if ( item || notices . length ) {
card = item ? renderCard ( item ) : el ( "div" , "card" );
for ( const n of notices ) card . appendChild ( renderNotice ( n ));
card . classList . add ( "is-primary" );
pager = item ? buildPager ( item ) : null ;
}
renderGitBoard ( main , card , pager );
return ;
}
const list = asked ();
if ( ! list . length ) {
// A session can end before it asked anything at all (a build that needed
// nobody), and the hand-off still has to be somewhere they can see it.
if ( finish ()) {
const card = renderHandoff ( finish ());
card . classList . add ( "is-primary" );
main . appendChild ( card );
return ;
}
return renderWaiting ( main );
}
const item = byId ( page . selected ) || list [ 0 ];
if ( ! item ) return renderWaiting ( main );
// One card is all a page shows. Anything the column used to stack as extra
// cards -- the "all caught up" lull above and the session notes below --
// folds into this one, because two boxes on one page read as two things
// needing attention where there is only ever one.
const card = renderCard ( item );
// No lull note on a finished session: "leave this tab open, the next
// question will appear" is true of a pause between questions and false of
// an ending, and until there was a way to tell the two apart the page said
// it in both. The ending has its own page now, reached from the rail.
if ( ! finish () && ! myTurn (). length && ! stagedCount ()) {
const lull = el ( "div" , "card-note card-lead" );
lull . appendChild ( el ( "p" , "note-kicker" , "All caught up" ));
lull . appendChild ( el ( "h3" , "note-title" , "Nothing needs you right now" ));
lull . appendChild (
el (
"p" ,
null ,
"Plan2Code has everything it asked for. Leave this tab open: the next question will appear here on its own."
)
);
// Between questions in a build, the answer to "what now?" is what it is
// building.
if ( activity ()) lull . appendChild ( el ( "p" , "help" , "Right now: " + activity ()));
card . insertBefore ( lull , card . firstChild );
}
for ( const n of items (). filter (( i ) => i . kind === "notice" )) {
card . appendChild ( renderNotice ( n ));
}
card . classList . add ( "is-primary" );
main . appendChild ( card );
const pager = buildPager ( item );
if ( pager ) main . appendChild ( pager );
}
export function renderFooter () {
// The dashboard has no Send: a card click is the answer and it goes on its
// own. An empty "Nothing to send yet" bar under a menu is noise, so only the
// workspace label stays.
const foot = document . querySelector ( ".footer" );
if ( foot ) foot . classList . toggle ( "is-dash" , Boolean ( isDashboard () && ! finish ()));
// A finished dashboard keeps its summary line but still has nothing to send.
if ( foot ) foot . classList . toggle ( "is-dash-done" , Boolean ( isDashboard () && finish ()));
const summary = $ ( "footer-summary" );
const notes = pendingNotes ();
const n = stagedCount ();
summary . replaceChildren ();
const sent = awaitingReply ();
if ( ! n && ! notes . length && sent . length ) {
// "Answer a question above" is nonsense when everything answerable has
// already gone. Say what is actually outstanding instead: their own send.
summary . appendChild ( el ( "strong" , null , stranded () ? ` ${ sent . length } saved, not picked up yet` : ` ${ sent . length } with Plan2Code` ));
summary . appendChild ( document . createTextNode ( " · " + sent . map (( i ) => i . title ). join ( " · " )));
} else if ( finish ()) {
// Not "nothing to send yet". There is no yet.
const fin = finish ();
summary . appendChild ( el ( "strong" , null , finishPaused ( fin ) ? "Paused." : "All done." ));
summary . appendChild (
document . createTextNode (
n || notes . length
? " Anything still waiting here was never sent."
: finishPaused ( fin )
? " Run the command above to pick this up."
: fin . command
? " The next step is above."
: " Nothing left to run."
)
);
} else if ( ! n && ! notes . length ) {
summary . appendChild (
document . createTextNode (
myTurn (). length
? "Nothing to send yet. Answer a question above, then press Send."
: "Nothing to send yet."
)
);
} else {
const strong = el ( "strong" , null , ` ${ n + notes . length } ready` );
summary . appendChild ( strong );
const bits = [];
for ( const [ id , v ] of Object . entries ( page . local . staged )) {
const item = byId ( id );
if ( ! item ) continue ;
// The label the person clicked, not the id the agent reads.
const verdict = v . verdict && ( item . verdicts || []). find (( x ) => x . id === v . verdict );
const said = v . k || ( verdict ? verdictText ( verdict ) : v . verdict );
bits . push ( item . title + ( said ? ` → ${ said } ` : "" ));
}
for ( const note of notes ) {
const item = byId ( note . id );
bits . push ( `note on ${ item ? item . title : "a question" } ` );
}
summary . appendChild ( document . createTextNode ( " · " + bits . join ( " · " )));
}
const held = finish () ? 0 : heldNotes (). length ;
if ( held ) {
summary . appendChild (
el (
"div" ,
"footer-held" ,
held === 1
? "1 note is waiting on an upload and will not go with this send."
: ` ${ held } notes are waiting on an upload and will not go with this send.`
)
);
}
const state = sendState ();
const btn = $ ( "btn-send" );
btn . disabled = state . disabled ;
// Filled accent means "this is the step". That is only true of Send once
// nothing is left to answer; before then it is the quieter of the two, so
// the next question wins the eye. Still one click either way: someone who
// means to send one answer on its own is not stopped, only not steered.
const sendIsStep = ! state . disabled && ! unanswered (). length ;
btn . classList . toggle ( "primary" , state . disabled || sendIsStep );
btn . classList . toggle ( "standby" , ! state . disabled && ! sendIsStep );
const hint = $ ( "send-hint" );
hint . replaceChildren ();
hint . title = state . why ;
// Something is turning while the turn is not theirs. A line of grey text
// saying "one moment" reads the same whether the agent is working on it or
// has quietly died; a spinner is the difference between the two at a glance.
// A spinner says "something is happening". Nothing is, once the other end
// has stopped answering, and a permanent one is how a dead session passes
// for a slow one.
if ( ! page . gone && ! agentAdrift () && ( page . pendingResult || agentWorking ())) {
hint . appendChild ( el ( "span" , "spinner tiny" ));
}
// An empty `short` means the spinner says it all: a routine wait, already
// spelled out with a live clock in the dock. The words are for states that
// want something from the person or have gone wrong.
if ( state . short ) {
hint . appendChild ( el ( "span" , "hint-text" , state . short ));
} else if ( ! state . disabled ) {
hint . appendChild ( document . createTextNode ( "or press " ));
hint . appendChild ( el ( "kbd" , null , isMac () ? "⌘" : "Ctrl" ));
hint . appendChild ( document . createTextNode ( " + " ));
hint . appendChild ( el ( "kbd" , null , "Enter" ));
}
$ ( "btn-clear" ). hidden = ! ( n || notes . length || held );
if ( foot ) foot . hidden = false ;
renderWhere ();
if ( foot ) foot . hidden = foot . classList . contains ( "is-dash" ) && $ ( "footer-where" ). hidden ;
}
// The workspace label in the footer's middle: `plan2code + 2 folders ·
// branch`, falling back tier by tier (workspace.js) until it fits the slot.
// Before a frame carries the workspace it is today's `folder · branch`, and a
// session opened before the server wrote `worktree` has nothing to show, so
// the slot stays hidden. The footer renders on every tick, so the DOM is only
// touched when the labels change, or when a resize clears the key.
// The project's name: the workspace's original folder, or the session's
// worktree folder before a frame carries the workspace.
function projectName () {
const folders = workspaceFolders ();
if ( folders . length && folders [ 0 ]. name ) return folders [ 0 ]. name ;
const path = ( page . S && page . S . worktree ) || "" ;
return path ? path . split ( /[\\/]/ ). filter ( Boolean ). pop () || path : "" ;
}
// The browser tab's title, led by the project so tabs from different
// projects are told apart. Called from the chrome and the footer, since the
// workspace frame can arrive after either.
function renderTabTitle () {
if ( ! page . S ) return ;
const name = projectName ();
const title = page . S . title || "Session" ;
// A title that defaulted to the folder name says it once, not twice.
const lead = name && name !== title ? name + " · " : "" ;
document . title = lead + title + " · #" + String ( page . S . sid || "" ). slice ( - 6 ) + " · Plan2Code" ;
}
export function renderWhere () {
const b = $ ( "footer-where" );
const folders = workspaceFolders ();
const path = page . S . worktree || "" ;
renderTabTitle ();
const alert = Boolean ( folders . length && (( page . wsFrame . missing || []). length || ( page . wsFrame . issues || []). length ));
const labels = folders . length
? Array . from ({ length : FOOTER_TIERS }, ( _ , tier ) => footerLabel ({ folders , branch : page . S . branch }, tier ))
: [ path ? ( path . split ( /[\\/]/ ). filter ( Boolean ). pop () || path ) + ( page . S . branch ? " · " + page . S . branch : "" ) : "" ];
const key = labels . join ( "\n" ) + ( alert ? "\n!" : "" );
if ( b . dataset . key === key ) return ;
b . dataset . key = key ;
b . hidden = ! labels [ 0 ];
if ( b . hidden ) return ;
let label = labels [ 0 ];
for ( const text of labels ) {
label = text ;
// The project name takes the highlight color, so several consoles side by
// side tell apart at a glance; the rest of the label stays quiet.
const name = projectName ();
b . textContent = "" ;
if ( name && text . startsWith ( name )) {
b . appendChild ( el ( "span" , "where-project" , name ));
b . appendChild ( document . createTextNode ( text . slice ( name . length )));
} else {
b . textContent = text ;
}
if ( alert ) {
const dot = el ( "span" , "where-alert" );
dot . setAttribute ( "aria-hidden" , "true" );
b . appendChild ( dot );
}
if ( b . scrollWidth <= b . clientWidth ) break ;
}
b . title = "Open workspace" ;
b . setAttribute ( "aria-label" , "Open workspace: " + label + ( alert ? " (a folder needs attention)" : "" ));
}
// Everything staged, in the shape /submit takes. Shared by Send and by Stop
// session, which has to carry the same answers the same way: a stop that
// dropped someone's last answers on the floor would be worse than no button.
export function stagedPayload () {
const actions = [];
const replyLines = [];
const sentIds = new Set ();
const summaries = {};
// Kept so the card can state the answer back in words while it is in flight,
// the same way a settled one does. `staged` is cleared by the send itself.
const values = {};
for ( const [ id , v ] of Object . entries ( page . local . staged )) {
const item = byId ( id );
if ( ! item ) continue ;
sentIds . add ( id );
values [ id ] = v ;
actions . push ({ i : id , ... v });
// The literal token the terminal flow would have received. This is what
// lets the agent treat a click exactly like a typed word, so no workflow
// needs a second code path.
const tok = tokenFor ( item , v );
summaries [ id ] = tok ;
if ( tok ) replyLines . push ( ` ${ item . title } : ${ indentReply ( tok ) } ` );
}
// Which notes, and which of their images, went: markSent clears exactly
// those, so a note held back on an upload stays drafted.
const sentNotes = {};
for ( const note of pendingNotes ()) {
sentIds . add ( note . id );
sentNotes [ note . id ] = new Set ( note . images . map (( img ) => img . key ));
actions . push ( noteAction ( note . id , note . text , note . images ));
const item = byId ( note . id );
replyLines . push (... noteReplyLines ( item ? item . title : note . id , note . text , note . images ));
}
return { actions , replyLines , sentIds , sentNotes , summaries , values };
}
// After /submit took it: what went is now in flight, and nothing of it stays
// staged or drafted to be sent a second time.
export function markSent ({ sentIds , sentNotes = {}, summaries , values }) {
// Clear every draft belonging to an item in this batch, not just the
// thread notes. A surviving draft re-populates the field with text that
// was already sent, and the next keystroke re-stages it WITHOUT the
// verdict that went with it, which is how an approval gets lost.
// A note held back on an image upload stays drafted, attachments and all,
// even when an answer on the same item went. The sent images' files stay
// on disk for the agent; the sweep cleans them up.
for ( const id of sentIds ) {
for ( const prefix of [ "other-" , "text-" , "note-" ]) delete page . local . drafts [ prefix + id ];
if ( sentNotes [ id ]) {
delete page . local . drafts [ "thread-" + id ];
const rest = noteImages ( id ). filter (( img ) => ! sentNotes [ id ]. has ( img . key ));
if ( rest . length ) page . local . images [ id ] = rest ;
else delete page . local . images [ id ];
} else if ( ! page . local . images [ id ]) {
delete page . local . drafts [ "thread-" + id ];
}
page . local . sent [ id ] = { at : Date . now (), summary : summaries [ id ] || "" , value : values [ id ] || null };
}
page . local . staged = {};
save ();
}
export async function send () {
if ( sendState (). disabled ) return ;
const payload = stagedPayload ();
const { actions , replyLines } = payload ;
if ( ! actions . length ) return ;
const btn = $ ( "btn-send" );
btn . disabled = true ;
btn . textContent = "Sending…" ;
try {
const res = await fetch ( "/submit" , {
method : "POST" ,
headers : { "content-type" : "application/json" },
body : JSON . stringify ({ actions , reply : replyLines . join ( "\n" ) }),
});
if ( res . status === 409 ) {
const e = new Error ( "pending" );
e . pending = true ;
throw e ;
}
if ( ! res . ok ) throw new Error ( String ( res . status ));
markSent ( payload );
banner ( "Sent. Plan2Code is picking it up now." , "good" );
setTimeout (() => banner ( null ), 4000 );
} catch ( err ) {
if ( err && err . pending ) {
banner (
"Your last answers are still being picked up. Nothing is lost, and nothing was sent twice. Try again in a moment." ,
"info"
);
page . pendingBannerUp = true ;
page . pendingResult = true ;
} else {
banner ( "That did not go through. Nothing was lost, try Send again." , "warn" );
}
} finally {
btn . textContent = "Send to Plan2Code" ;
render ();
}
}
const STATE_WORDS = { done : "all done" , blocked : "blocked" , help : "need help" , defer : "later" };
// Turn a staged answer into the words the person would have typed in the
// terminal. The agent reads `reply` as their message, so every part of an
// answer has to survive: a verdict AND its note, a checklist state AND what
// they wrote, a reordered list AND its new order. Anything dropped here is
// something the agent never hears.
function tokenFor ( item , v ) {
const map = item . token || {};
if ( v . skipped ) return v . text ? `skip; ${ v . text } ` : "skip" ;
const parts = [];
if ( v . k ) parts . push ( map [ v . k ] || v . k );
if ( Array . isArray ( v . ks ) && v . ks . length ) parts . push ( v . ks . map (( k ) => map [ k ] || k ). join ( ", " ));
if ( v . verdict ) parts . push ( map [ v . verdict ] || v . verdict );
if ( typeof v . yes === "boolean" ) parts . push ( map [ v . yes ? "yes" : "no" ] || ( v . yes ? "yes" : "no" ));
if ( typeof v . ok === "boolean" ) parts . push ( v . ok ? "confirmed" : "needs changes" );
if ( v . state ) parts . push ( map [ v . state ] || STATE_WORDS [ v . state ] || v . state );
if ( Array . isArray ( v . done ) && v . done . length ) parts . push ( `did steps ${ v . done . map (( n ) => n + 1 ). join ( ", " ) } ` );
if ( Array . isArray ( v . rows )) {
// What changed against the agent's rows, said in words: `reply` is what
// the agent reads, and an order alone hides a rename or a removal. The
// whole list always comes too, called a new order only when one moved.
const before = new Map (( item . rows || []). map (( r ) => [ r . id , r ]));
const after = new Set ( v . rows . map (( r ) => r . id ));
const kept = ( item . rows || []). filter (( r ) => after . has ( r . id )). map (( r ) => r . id );
const moved = v . rows . filter (( r ) => before . has ( r . id )). some (( r , i ) => r . id !== kept [ i ]);
parts . push (( moved ? "new order: " : "the list: " ) + v . rows . map (( r ) => r . title ). join ( ", then " ));
const renamed = v . rows . filter (( r ) => before . has ( r . id ) && before . get ( r . id ). title !== r . title );
const added = v . rows . filter (( r ) => ! before . has ( r . id ));
const removed = ( item . rows || []). filter (( r ) => ! after . has ( r . id ));
if ( renamed . length ) parts . push ( "renamed " + renamed . map (( r ) => ` ${ before . get ( r . id ). title } to ${ r . title } ` ). join ( ", " ));
if ( added . length ) parts . push ( "added " + added . map (( r ) => r . title ). join ( ", " ));
if ( removed . length ) parts . push ( "removed " + removed . map (( r ) => r . title ). join ( ", " ));
}
if ( v . text ) parts . push ( v . text );
return parts . join ( "; " );
}
function fmtMs ( ms ) {
const s = Math . round ( ms / 1000 );
if ( s < 60 ) return ` ${ s } s` ;
const m = Math . floor ( s / 60 );
return ` ${ m } m ${ s % 60 } s` ;
}
/* ----------------------------------------------------------- page chrome */
function toggleMeterPop ( open ) {
const pop = $ ( "meter-pop" );
const show = open ?? pop . hidden ;
pop . hidden = ! show ;
$ ( "meter-pill" ). setAttribute ( "aria-expanded" , String ( show ));
}
let whereResizeTimer = null ;
// The listeners that belong to no screen: leaving the page, the session meter's
// pop-over, the footer's label on a resize, Send, Clear, and the page-wide keys.
export function wireChrome () {
addEventListener ( "pagehide" , () => {
try {
navigator . sendBeacon ( "/bye" );
} catch {}
});
$ ( "meter-pill" ). addEventListener ( "click" , () => toggleMeterPop ());
$ ( "meter-help" ). addEventListener ( "click" , () => {
toggleMeterPop ( false );
openHelpOn ( "meter" );
});
document . addEventListener ( "keydown" , ( e ) => {
if ( e . key !== "Escape" || $ ( "meter-pop" ). hidden ) return ;
toggleMeterPop ( false );
$ ( "meter-pill" ). focus ();
});
document . addEventListener ( "click" , ( e ) => {
if ( ! $ ( "meter-pop" ). hidden && ! e . target . closest ( ".meter-slot" )) toggleMeterPop ( false );
});
addEventListener ( "resize" , () => {
clearTimeout ( whereResizeTimer );
whereResizeTimer = setTimeout (() => {
if ( ! page . S ) return ;
delete $ ( "footer-where" ). dataset . key ;
renderWhere ();
}, 100 );
});
$ ( "btn-send" ). addEventListener ( "click" , send );
$ ( "btn-clear" ). addEventListener ( "click" , () => {
if ( ! confirm ( "Clear everything you have not sent yet?" )) return ;
page . local . staged = {};
// Every typed box, the same set markSent clears: a draft left behind would
// refill its box on the next render and look as if nothing was cleared.
const typed = [ "thread-" , "other-" , "text-" , "note-" ];
for ( const key of Object . keys ( page . local . drafts )) if ( typed . some (( p ) => key . startsWith ( p ))) delete page . local . drafts [ key ];
for ( const [ itemId , list ] of Object . entries ( page . local . images )) {
for ( const img of list ) removeImage ( itemId , img . key );
}
saveNow ();
redraw ();
});
document . addEventListener ( "keydown" , ( e ) => {
if (( e . metaKey || e . ctrlKey ) && e . key === "Enter" ) {
// Not from behind an open dialog (Brief, Stop, Home, Looks, Help,
// Workspace): the answers staged underneath are not what is on screen.
if ( document . querySelector ( "dialog[open]" )) return ;
e . preventDefault ();
send ();
return ;
}
// Escape is the confirm pane's Back — but not while a dialog has it. Native
// dialogs close themselves on the same key; backing out of the pick at the
// same time would be two undos for one press.
if ( e . key === "Escape" && page . dashPick && isDashboard () && ! finish () && ! document . querySelector ( "dialog[open]" )) {
page . dashPick = null ;
redraw ();
}
});
}
// The clock, and the one piece of state that changes without anybody doing
// anything: the agent falling silent. renderStatus alone was not enough --
// Planny went quiet and the footer below him carried on promising "one
// moment" with a spinner beside it, because the footer is only drawn by a full
// render and nothing was triggering one. Watch the flip and draw the rest.
let wasAdrift = false ;
let wasPastGrace = false ;
export function startClock () {
setInterval ( checkIn , 5000 );
setInterval (() => {
renderStatus ();
const now = agentAdrift ();
if ( now !== wasAdrift ) {
wasAdrift = now ;
if ( page . S ) {
renderFooter ();
renderStopControls ();
}
}
// Crossing the working grace period is the same kind of quiet change: the
// footer's "wait" line becomes "busy a while" without anybody clicking, and
// a staged answer's send hatch opens on time instead of at the next render.
const past = agentWorking () && workingMs () > patience ( WORKING_GRACE_MS );
if ( past !== wasPastGrace ) {
wasPastGrace = past ;
if ( page . S ) renderFooter ();
}
// The agent coming or going changes whether the chat can be used, with no
// frame to say so: redraw the Ask pane when that flips. Even mid-typing:
// the draft is saved on every keystroke and withFocus() keeps the caret,
// and a composer that looks open while the agent has gone is the worse lie.
if ( page . S && page . view === "ask" && askOfflineFlipped ()) redraw ();
}, 1000 );
}