review

func (Area) Empty ¶

func (a Area) Empty() bool

Empty reports whether the area carries no rectangle (zero-value). Used by the controller (validate non-empty before persisting) and the template (only render the pending-overlay when set).

func (Area) JSON ¶

func (a Area) JSON() string

JSON encodes a as the compact JSON blob persisted in the CSV's `area` column. Returns "" for the zero value so the column stays empty for non-area rows.

func (Area) PercentH ¶

func (a Area) PercentH() string

func (Area) PercentW ¶

func (a Area) PercentW() string

func (Area) PercentX ¶

func (a Area) PercentX() string

PercentX/Y/W/H render the area's coords as CSS percentage strings for the template to drop straight into `style="left:...; top:...;"`. Multiply by 100 to convert fraction → percent; 4 decimal places is enough precision for sub-pixel positioning on any sane image size.

func (Area) PercentY ¶

func (a Area) PercentY() string

func (Comment) AnchorEdited ¶ added in v0.25.0

func (c Comment) AnchorEdited() bool

AnchorEdited reports that exactly the commented lines were edited in place (the recorded text changed but its surrounding context is intact) — a deterministic "likely addressed" hint. Unlike outdated it stays ACTIONABLE: edited is not proof the point was correctly handled, so it is badged, never hidden, until the reviewer resolves it.

func (Comment) AnchorMoved ¶

func (c Comment) AnchorMoved() bool

AnchorMoved reports that the comment was auto-shifted to follow its content after the file changed (purely informational in the UI).

func (Comment) AnchorOutdated ¶

func (c Comment) AnchorOutdated() bool

AnchorOutdated reports that re-location could not confidently place the comment — its line numbers no longer point at the intended content and a human (or the skill) must re-anchor or resolve it. File-level and area-level comments never go outdated (no anchor).

func (Comment) IsAreaLevel ¶

func (c Comment) IsAreaLevel() bool

IsAreaLevel reports whether this comment overlays an image region (kind="area" with a populated Area). Parallel to IsFileLevel; both share the "no anchor to drift, skip in relocate" contract.

func (Comment) IsFileLevel ¶

func (c Comment) IsFileLevel() bool

IsFileLevel reports whether this comment applies to the whole file rather than a line range. The CSV-side persistence reads `kind=file` and FromLine=0; this method is the single in-process predicate so callers (anchor.relocate, template ranges, skill exports) don't re-implement the test.

func (Comment) IsRegionLevel ¶

func (c Comment) IsRegionLevel() bool

IsRegionLevel reports whether this comment annotates a region of a live page in --external mode (kind="region" with a populated Area + URL). Parallel to IsAreaLevel; shares the "no anchor to drift, skip in relocate" contract.

func (Comment) IsTextLevel ¶ added in v0.15.0

func (c Comment) IsTextLevel() bool

IsTextLevel reports whether this comment anchors to a character range (kind="text" with FromCol/ToCol delimiting the selected substring). Unlike file/area/region, a text comment DOES drift — it reuses the line-anchor relocate machinery, so it is not skipped there.

func (Comment) LineSpan ¶

func (c Comment) LineSpan() string

LineSpan returns "L42" for single-line, "L42-L48" for ranges, "file" for whole-file comments, "area" for image-area comments, and "region" for live-site comments — used in the template badge and the composer label, so every kind renders a recognisable span.

func (Comment) QueueState ¶ added in v0.18.0

func (c Comment) QueueState() string

QueueState classifies a comment for the queue view. Resolved and outdated comments have left the queue (the human closed them / the anchor vanished) and return "" — the panel skips them. The #164 unread-reply reopen is layered ON TOP of this by reopenIfReplied at the state level (this method has no thread access), so a replied-on resolved/outdated/done comment counts as "queued" again.

func (Comment) Snippet ¶ added in v0.15.1

func (c Comment) Snippet() string

Snippet returns the exact selected phrase for a kind=text comment (empty otherwise) — shown as a quote on the card so the reviewer sees what the comment is about, especially for rendered-view (Preview) comments that anchor line-level.

func (CommentAnchor) Empty ¶

func (a CommentAnchor) Empty() bool

Empty reports whether there is nothing to re-locate against (legacy pre-migration comments, or a capture that found no content).

func (CommentAnchor) JSON ¶

func (a CommentAnchor) JSON() string

JSON serializes the anchor for the opaque `anchor` CSV column. Empty anchor → "" (keeps legacy/zero rows clean).

func (*EventStream) EmitEnd ¶ added in v0.22.0

func (e *EventStream) EmitEnd(ts time.Time) error

EmitEnd emits the single terminator — the only event the consumer loop should treat as "stop".

func (*EventStream) EmitReady ¶

func (e *EventStream) EmitReady(repo, csvPath string, paused, skillUpdated bool, ts time.Time) error

EmitReady announces the session is live. Emitted once, after the READY/REPO/STORE stdout preamble, so the preamble parse is never interleaved with JSON.

func (*EventStream) EmitSnapshot ¶ added in v0.22.0

func (e *EventStream) EmitSnapshot(comments []Comment, suggestions []Suggestion, decided map[string]SuggestionDecision, threadByID map[string][]ThreadEntry, applied map[string]bool, quizzes []StreamQuiz, paused bool, ts time.Time) error

EmitSnapshot emits a full actionable snapshot — one per queue mutation (or the final EndSession flush): the open comments AND the reviewer's decisions on the LLM's suggestions. Both snapshots are always non-nil slices so their keys are always present (`[]` when nothing is actionable). decided is the fingerprint-matched decision map (state.DecisionsBySuggestion) — only decided, non-outdated suggestions ship.

func (*PrereviewController) AcceptSuggestion ¶ added in v0.17.0

func (c *PrereviewController) AcceptSuggestion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

AcceptSuggestion records an "accept" AND auto-rejects every OTHER suggestion in the same artifact-area group (#117): alternatives for the same text are mutually exclusive, like a radio button, so the reviewer no longer rejects the rest by hand. The sibling rejects override whatever verdict they had and are marked Auto (so clearing the accept re-opens the group — see ClearSuggestionDecision). All batched into one persist.

func (*PrereviewController) AddComment ¶

func (c *PrereviewController) AddComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

AddComment validates body+selection, appends a Comment, writes the CSV atomically, and clears selection + draft for the next round. Save enqueues (the comment is actionable); the draft path is materializeDraft.

func (*PrereviewController) AnswerQuestion ¶ added in v0.25.0

func (c *PrereviewController) AnswerQuestion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

AnswerQuestion records the reviewer's choice for one question and reveals its explanation. Answers are the reviewer's, so they go in the server-owned file — never into the agent's append-only quiz.jsonl.

An out-of-range choice is rejected rather than stored: the index is used to read Options in the template, so a bad one would render nothing (or panic a future caller) with no clue why.

func (*PrereviewController) CancelReply ¶ added in v0.23.0

func (c *PrereviewController) CancelReply(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CancelReply closes the reply form without posting.

func (*PrereviewController) CheckpointBaseline ¶ added in v0.18.0

func (c *PrereviewController) CheckpointBaseline()

CheckpointBaseline records the v0 snapshot of the review scope. Exported for the launch wiring (server.go) to call once at startup, before the agent edits anything. Idempotent-ish: a second call with an unchanged scope is skipped by the store, so it never duplicates the baseline.

func (*PrereviewController) ClearFlash ¶ added in v0.14.0

func (c *PrereviewController) ClearFlash(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ClearFlash dismisses the transient status toast (auto-clicked after a few seconds, or via the toast's manual dismiss button).

func (*PrereviewController) ClearSelection ¶

func (c *PrereviewController) ClearSelection(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ClearSelection wipes the line selection and any draft. Bound to a "Cancel" button next to the composer and to ESC keydown on the body.

func (*PrereviewController) ClearSuggestionDecision ¶ added in v0.17.0

func (c *PrereviewController) ClearSuggestionDecision(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ClearSuggestionDecision removes a recorded decision (undo), returning the suggestion to undecided. If the cleared decision was an ACCEPT, the whole group it auto-rejected re-opens too (#117): clear every Auto reject on a sibling in the same group, so undoing the accept restores the group to undecided rather than leaving it permanently all-rejected. Batched into one persist.

func (*PrereviewController) CloseFiles ¶

func (c *PrereviewController) CloseFiles(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CloseFiles unconditionally hides the file drawer. Distinct from ToggleFiles because the backdrop tap should only close, never open.

func (*PrereviewController) CloseMoreMenu ¶

func (c *PrereviewController) CloseMoreMenu(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CloseMoreMenu is the explicit close action — bound to the menu backdrop so tapping outside dismisses without toggling the open state to "true" on a subsequent click.

func (*PrereviewController) CloseSearch ¶ added in v0.16.0

func (c *PrereviewController) CloseSearch(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CloseSearch hides the palette (the close button; Esc also closes it via ClearSelection). Keeps the query so a reopen resumes where the user left off.

func (*PrereviewController) CloseTOC ¶

func (c *PrereviewController) CloseTOC(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CloseTOC dismisses the mobile TOC overlay. Bound to two things: the backdrop tap (close-without-jump) and the click on a heading link inside the overlay (close-and-jump — the <a href="#…"> performs the native anchor scroll, this action closes the overlay in the same gesture). Browser-level anchor navigation is unaffected because event-delegation.ts only preventDefault's submit and drag events.

func (*PrereviewController) CursorDown ¶ added in v0.14.0

func (c *PrereviewController) CursorDown(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CursorDown / CursorUp move the keyboard line cursor through the diff (bound to ArrowDown / ArrowUp). The cursor line button is highlighted, scrolled into view, and focused, so Enter activates it (→ the line composer). j/k still switch files.

func (*PrereviewController) CursorUp ¶ added in v0.14.0

func (c *PrereviewController) CursorUp(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

func (*PrereviewController) CycleScheme ¶ added in v0.14.0

func (c *PrereviewController) CycleScheme(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CycleScheme advances the curated color scheme (the Theme axis, issue from the UI-overhaul plan), cycling through gitdiff.Schemes in registry order. Persisted per-user; the page re-renders with the new data-scheme attribute and the cascade re-skins chrome + diff — no JS, no CSS refetch (/syntax.css carries every scheme). Like CycleTheme, leaves the overflow menu open so a click from inside it can cycle again in place.

func (*PrereviewController) CycleTheme ¶ added in v0.14.0

func (c *PrereviewController) CycleTheme(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

CycleTheme advances the Light/Dark/System color mode (issue #60), cycling System → Light → Dark → System. Persisted per-user; the page re-renders with the new data-mode attribute (omitted for System) and the cascade does the rest — no JS, no CSS refetch (/syntax.css already carries both modes). The overflow menu is left open so a click from inside it can cycle again in place; the toolbar button is the primary control.

func (*PrereviewController) DeleteComment ¶

func (c *PrereviewController) DeleteComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

DeleteComment removes the named comment, rewrites the CSV, and stashes the deleted comment in state.LastDeletedComment so the user can undo for the remainder of the session (or until another mutation).

func (*PrereviewController) DiffVersion ¶ added in v0.18.0

func (c *PrereviewController) DiffVersion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

DiffVersion shows a prior version diffed against the CURRENT working-tree file ("Diff vs current") — a read-only view mode like ViewVersion, but the pane renders the line diff (via gitdiff.DiffContents, a pure-Go Myers diff over the two blobs — no git). A tombstone (the file didn't exist at that version) diffs as an all-addition against nothing. No disk change.

func (*PrereviewController) DismissQuizNav ¶ added in v0.25.0

func (c *PrereviewController) DismissQuizNav(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

DismissQuizNav puts the navigator away for this session.

func (*PrereviewController) DismissUndo ¶ added in v0.15.0

func (c *PrereviewController) DismissUndo(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

DismissUndo clears the undo affordance WITHOUT restoring the comment — the deletion stands. This backs the undo toast's ✕ button, the manual counterpart to UndoDelete's restore. Mirror of ClearFlash: a one-field clear with no persistence (the CSV already reflects the deletion).

func (*PrereviewController) EditComment ¶

func (c *PrereviewController) EditComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

EditComment seeds the composer with an existing comment's body + line range so the user can rewrite it. The original comment stays in state.Comments — AddComment detects EditingCommentID and updates in place rather than appending. This keeps Cancel non-destructive: if the user opens Edit and changes their mind, the original survives.

func (*PrereviewController) EndSession ¶

func (c *PrereviewController) EndSession(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

EndSession is the agent-mode terminator. It first flushes a final snapshot snapshot — so comments left since the last emitted snapshot still reach the consumer (dedup-by-id makes a redundant snapshot harmless, and the alternative would silently strand them in the CSV but never the stream) — then emits the single end event (the only event the consumer loop treats as "stop") and shuts the server down on the same delay as Quit, so the framework renders the "session ended" banner before the WebSocket is torn down. The LLM's background job completing is the second, redundant terminator.

func (*PrereviewController) EnqueueComment ¶ added in v0.18.0

func (c *PrereviewController) EnqueueComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

EnqueueComment is the per-card "Enqueue" / "Re-enqueue" action.

func (*PrereviewController) ExitVersionView ¶ added in v0.18.0

func (c *PrereviewController) ExitVersionView(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ExitVersionView leaves the read-only historical view and returns to the live diff. No disk change.

func (*PrereviewController) FocusComment ¶

func (c *PrereviewController) FocusComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

FocusComment marks a region annotation as the one to locate: its on-page pin renders highlighted and the client (via the beacon) navigates the iframe to its page + scrolls it into view. FocusSeq bumps every call so re-tapping the same annotation re-fires the client even with an unchanged id.

func (*PrereviewController) HideComment ¶ added in v0.16.0

func (c *PrereviewController) HideComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

HideComment individually re-hides a RESOLVED comment (issue #88): it stays out of the diff + overview even while "Show resolved" is on, without turning the whole resolved group back off. A view-only flag — the comment is untouched otherwise (still resolved, still in the CSV, already excluded from the handoff). Recovered in bulk via UnhideAllResolved. Mirrors ToggleResolved's persist-and-rollback shape.

func (*PrereviewController) HideSuggestion ¶ added in v0.20.0

func (c *PrereviewController) HideSuggestion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

HideSuggestion hides a single suggestion from view (pinned to its current content, so a later revision un-hides it). A pure declutter — the suggestion stays open and still reaches the LLM on hand-off.

func (*PrereviewController) HideSuggestionGroup ¶ added in v0.20.0

func (c *PrereviewController) HideSuggestionGroup(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

HideSuggestionGroup hides every alternative in the same artifact-area group as the given suggestion (#117) in one atomic write — the "hide these alternatives" affordance. A lone suggestion (no group) hides just itself.

func (*PrereviewController) JumpToComment ¶

func (c *PrereviewController) JumpToComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

JumpToComment closes the all-comments view, selects the comment's file, and sets ScrollToCommentID so the framework's `lvt-fx:scroll="into-view"` directive on the matching inline comment scrolls it into view on the next render. Pure declarative wiring — no custom app-level JS.

func (*PrereviewController) JumpToQuizLine ¶ added in v0.25.0

func (c *PrereviewController) JumpToQuizLine(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

JumpToQuizLine leaves the quiz and scrolls to the lines a question cites, so "go look at the code" is one tap. It deliberately closes the quiz view (like every other jump handler) rather than trying to show both: the reviewer asked to see the code, and toggling back is one tap the other way.

func (*PrereviewController) JumpToReadFrontier ¶ added in v0.20.0

func (c *PrereviewController) JumpToReadFrontier(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

JumpToReadFrontier is the "resume reading" action: a one-shot scroll to the furthest-read element, so the reviewer lands back where they left off.

func (*PrereviewController) JumpToSearchResult ¶ added in v0.16.0

func (c *PrereviewController) JumpToSearchResult(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

JumpToSearchResult selects the hit's file and, for a content hit, reveals the full raw file and scrolls to the matched line (RevealFile + CursorKey — mirrors JumpToComment). A filename hit (no line) just opens the file. Closes the palette.

func (*PrereviewController) JumpToSuggestion ¶ added in v0.23.0

func (c *PrereviewController) JumpToSuggestion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

JumpToSuggestion selects the file an accepted suggestion lives in, from its row in the queue panel (#159). It stops at file selection — suggestions have no per-item scroll target today (unlike ScrollToCommentID), so the reviewer lands on the file with the inline suggestion box visible; a precise scroll can ride along with the collapse-to-badge work.

func (*PrereviewController) LLMStatusChanged ¶ added in v0.16.0

func (c *PrereviewController) LLMStatusChanged(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

LLMStatusChanged is dispatched by the watcher (via Session.TriggerAction) to every open tab when the status file changes. Fan-out re-runs this handler against each tab's OWN state, so it must re-read the file itself rather than rely on any payload.

func (*PrereviewController) Mount ¶

func (c *PrereviewController) Mount(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

Mount runs on every HTTP GET and WebSocket connect. It rebuilds the file list from `git diff` so the user sees current state without restarting the binary.

func (*PrereviewController) NavigateToHeading ¶

func (c *PrereviewController) NavigateToHeading(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

NavigateToHeading is the server-side bookkeeping for a TOC heading link click. It dismisses both the mobile TOC overlay AND the all-comments overview, then records ScrollToHeadingID so the framework's `lvt-fx:scroll="into-view"` directive on the matching MarkdownBlock scrolls the section into view on the next render — the same declarative pattern JumpToComment uses for comments.

Fixes issue #12: previously the TOC link only closed the overlay (closeTOC); from inside all-comments view the heading was never in the DOM, so the native anchor scroll missed and the user stayed stuck on the comments overview.

data-id on the link supplies the slugified heading id (matches the `id="..."` goldmark's WithAutoHeadingID writes into the rendered HTML and that ExtractHeadings reads back).

func (*PrereviewController) NextComment ¶ added in v0.14.0

func (c *PrereviewController) NextComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

NextComment jumps to the next comment in the all-comments order, wrapping from the last back to the first. Keyboard counterpart to clicking a comment in the overview.

func (*PrereviewController) NextFile ¶

func (c *PrereviewController) NextFile(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

NextFile selects the next file in state.Files relative to SelectedFile. Wraps to the first file from the last. If no file is selected, picks the first file. Falls back to no-op for an empty file list.

func (*PrereviewController) OnConnect ¶ added in v0.16.0

func (c *PrereviewController) OnConnect(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

OnConnect captures the connecting group's Session so the background llm-status watcher can fan updates out to every open tab. It also refreshes the status fields from the file: LLMState is not persisted, so the restored connect-time state has it blank, and the connect render must reflect the current file (the same value the initial GET/SSR rendered) or a tab that opened mid-work would desync from its own server-rendered DOM.

func (*PrereviewController) OpenFileComment ¶

func (c *PrereviewController) OpenFileComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

OpenFileComment opens the composer in "comment on whole file" mode. Distinct from SelectLine in that no line range is involved; the resulting Comment persists with Kind="file", FromLine=0, ToLine=0. Clears any pending line selection / edit / re-anchor so the composer renders once at the file head rather than twice. Mirrors the markdown raw-toggle's "close the overflow menu" behaviour so mobile clicks don't leave the menu hanging open over the composer.

func (*PrereviewController) OpenReply ¶ added in v0.23.0

func (c *PrereviewController) OpenReply(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

OpenReply opens the inline reply form on the given comment/suggestion, draft empty.

func (*PrereviewController) OpenSearch ¶ added in v0.16.0

func (c *PrereviewController) OpenSearch(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

OpenSearch shows the search palette. Bound to the Mod+k keybinding and the toolbar magnifier. Closes the overflow menu so the two overlays don't stack. Leaves SearchQuery/SearchHits intact so reopening shows the last search.

func (*PrereviewController) OpenTOC ¶

func (c *PrereviewController) OpenTOC(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

OpenTOC opens the mobile Table-of-Contents overlay. Bound to the "Table of contents" entry in the 3-dots menu, so the menu must close at the same time — otherwise the dropdown stays drawn over the overlay it just summoned. Desktop never renders this entry; the TOC is a permanent right sidebar there.

func (*PrereviewController) PickPrompt ¶ added in v0.23.0

func (c *PrereviewController) PickPrompt(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

PickPrompt opens a file-level comment PRE-FILLED with a chosen "ask for suggestions" prompt (#147): it mirrors OpenFileComment, then seeds DraftBody with the prompt's body, so the reviewer sees the instruction in the composer, can tweak/scope it, and hits Save — creating an ordinary kind=file comment the agent answers with `prereview suggest`. An unknown slug is a no-op (a stale picker click).

func (*PrereviewController) PostReply ¶ added in v0.23.0

func (c *PrereviewController) PostReply(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

PostReply records the reviewer's reply on a comment/suggestion (#149): appends a reviewer ThreadEntry to the server-owned reviewer-replies.jsonl, reloads the threads so the card shows it immediately, and re-arms the snapshot emit so the agent's watch sees it. It does NOT touch Resolved — a reply is a steer, not a reopen; the unread-reply overlay (threadActionable) re-surfaces a resolved comment on the wire.

func (*PrereviewController) PrevComment ¶ added in v0.14.0

func (c *PrereviewController) PrevComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

PrevComment jumps to the previous comment, wrapping from the first to the last.

func (*PrereviewController) PrevFile ¶

func (c *PrereviewController) PrevFile(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

PrevFile selects the previous file. Wraps to the last file from the first.

func (*PrereviewController) Quit ¶

func (c *PrereviewController) Quit(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

Quit gracefully shuts the HTTP server down. The actual shutdown is dispatched on a delay so the framework gets to render `Quitting=true` back to the client before the WebSocket is torn down — otherwise the browser sees a sudden disconnect with no UI feedback.

func (*PrereviewController) ReanchorComment ¶

func (c *PrereviewController) ReanchorComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ReanchorComment starts re-placing an outdated comment: it jumps to the comment's file and arms ReanchorCommentID, but deliberately does NOT pre-seed the (stale) line selection — the user must pick the new location. The body is preserved in the composer. The next Save (AddComment, ReanchorCommentID branch) re-points the comment and re-captures its content anchor. This is the only sanctioned way to move an outdated comment; Edit is hidden for outdated comments precisely so it can't silently re-anchor against stale content.

func (*PrereviewController) ReenqueueComment ¶ added in v0.18.0

func (c *PrereviewController) ReenqueueComment(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ReenqueueComment is the queue-panel ↺ action — the same unified path.

func (*PrereviewController) RefreshDiff ¶ added in v0.16.0

func (c *PrereviewController) RefreshDiff(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

RefreshDiff rebuilds the file list + diff (picking up the agent's edits, since loadDiffCached invalidates on mtime) and re-anchors comments, then clears the pending-refresh nudge. It reuses Mount so the rebuild logic lives in exactly one place.

func (*PrereviewController) RejectSuggestion ¶ added in v0.17.0

func (c *PrereviewController) RejectSuggestion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

RejectSuggestion records a "reject" verdict.

func (*PrereviewController) ReportViewport ¶ added in v0.20.0

func (c *PrereviewController) ReportViewport(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ReportViewport records the client's read-progress report for the selected file: bottomKey advances the high-water mark (furthest new-side line seen), topKey becomes the scroll-restore target for the next time this file is opened. Both are per-file. A report with no selected file, or with unparseable keys, is a no-op. Never emits or persists to disk — pure session view-state.

func (*PrereviewController) RequestQuiz ¶ added in v0.25.0

func (c *PrereviewController) RequestQuiz(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

RequestQuiz asks the agent for a quiz about the selected file, by SAVING a file-level comment whose body is the quiz prompt.

It deliberately sends immediately rather than pre-filling the composer the way PickPrompt does (#147). "Quiz me" should be one tap — this tool is mostly used from a phone — and unlike a suggestions prompt there is rarely anything to tweak. The cost is that the request is VISIBLE in the reviewer's own queue: an earlier design hoped to hide it with Comment.Hidden, but that flag only applies to RESOLVED comments ("Hidden is meaningless on them", state.go), so there is no way to hide it and no reason to invent one. A saved Prompt comment already behaves exactly this way, and the visible row doubles as a record of what was asked, with the agent's reply threaded under it.

func (*PrereviewController) RequestRevert ¶ added in v0.23.0

func (c *PrereviewController) RequestRevert(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

RequestRevert asks the agent to UNDO an already-applied accept (#159 M4.2): it sets the Revert flag on the suggestion's accept decision, so the next snapshot carries it to the agent as verdict="revert". The agent restores the original text on disk and acks with `prereview reverted <id>` — that drops the suggestion out of the applied set, at which point DecisionsBySuggestion filters the now-revert-complete decision back to undecided. prereview still never writes the file itself; the agent does.

func (*PrereviewController) RestoreVersion ¶ added in v0.18.0

func (c *PrereviewController) RestoreVersion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

RestoreVersion rolls the selected file back to a prior version — the payoff of the whole milestone. It performs the anti-desync sequence in order: (1) force-pause the agent so it stops applying while the reviewer re-steers (this is what prevents desync with the LLM's own /rewind checkpoint stack), (2) write the version's bytes to disk (or delete the file for a tombstone), (3) record a new rollback checkpoint so history stays append-only (never rewritten), and (4) return to the live diff + nudge a refresh. The rollback is itself a new version, so it too is undoable.

func (*PrereviewController) ResumeAgent ¶ added in v0.18.0

func (c *PrereviewController) ResumeAgent(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ResumeAgent clears the pause and releases the drain: the batch accumulated while paused ships on the next emit. Bound to the "Resume — send batch" button on the batching banner (the manual Pause is the only thing that sets it now — rollback no longer force-pauses, see RestoreVersion).

func (*PrereviewController) RetakeQuiz ¶ added in v0.25.0

func (c *PrereviewController) RetakeQuiz(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

RetakeQuiz clears every answer for the current quiz so the reviewer can run it again — retrieval practice works by repetition, and a quiz you can only take once is a test, not a study tool.

func (*PrereviewController) SaveDraft ¶

func (c *PrereviewController) SaveDraft(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SaveDraft updates DraftBody as the user types. Bound to the textarea's change event so the draft survives reconnect (state has lvt:"persist").

func (*PrereviewController) SaveReplyDraft ¶ added in v0.23.0

func (c *PrereviewController) SaveReplyDraft(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SaveReplyDraft autosaves the reply textarea so it survives a reconnect.

func (*PrereviewController) SelectBlock ¶

func (c *PrereviewController) SelectBlock(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SelectBlock selects a whole source block in one shot: a rendered- Markdown block, a region drawn over the rendered-HTML preview, or a region drawn over the code view (issue #26 region comments). A block IS a range, so unlike SelectLine's two-click anchor/extend, this sets the full source line span at once — for the previews, data-from/data-to are the real source lines the client's region-select directive resolved the drawn box to. The existing composer/AddComment flow then anchors the comment to those lines, so it round-trips with the raw view and the CSV unchanged.

`side` is optional and defaults to "new" (rendered Markdown/HTML have no diff sides; deep-link line numbers are post-diff). The code-view region path passes the side of the box's first matched row so a comment on a deleted ("old") row anchors correctly.

A block, like a line, is ONE conversation (#174): CLICKING a rendered block that already carries a comment OPENS that thread instead of composing a second one on top of it — see openThreadOnBlock. A brand-new comment on that block is still reachable by selecting a phrase inside it (kind=text, data-surface="block").

func (*PrereviewController) SelectFile ¶

func (c *PrereviewController) SelectFile(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SelectFile loads the diff for the file path supplied as a hidden form input (`name="path"`). Resets any line selection. Auto-closes the mobile file drawer so tapping a file goes straight to the diff — the user doesn't have to also close the drawer manually.

func (*PrereviewController) SelectImageArea ¶

func (c *PrereviewController) SelectImageArea(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SelectImageArea opens the composer in "area" mode with a captured rectangle. Fired by the client's lvt-fx:area-select directive on pointerup with the final 0..1-fraction coords. Sets CommentMode + SelectionArea and clears any pending line/file selection so the area composer is the only one visible.

func (*PrereviewController) SelectLine ¶

func (c *PrereviewController) SelectLine(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SelectLine implements two-click range selection. data-line and data-side arrive from <button lvt-on:click="selectLine" data-line="N" data-side="new">.

• First click on a line: anchor = end = N.
• Second click on a different line: end = N (range complete).
• Third click: reseat as a new anchor.

Side is captured on the first click and locked thereafter so a range can't accidentally span sides of the diff.

EXCEPT when the line already carries a comment (#174): a line is ONE conversation, so clicking it OPENS that thread rather than starting a second comment on top of it — see openThreadOnLine. Further input belongs in the thread as a reply. A separate comment on an already-commented line is still reachable by selecting text on it (kind=text).

func (*PrereviewController) SelectRegion ¶

func (c *PrereviewController) SelectRegion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SelectRegion arms the composer for a region annotation on the current proxied page: a rectangle in document-fraction coordinates (computed client-side from the drag box + the beacon's scroll/document metrics), dispatched from the overlay's lvt-fx:region-select="selectRegion" data-surface="page" directive. Mirrors SelectImageArea but anchors to CurrentURL instead of a file.

func (*PrereviewController) SelectText ¶ added in v0.15.0

func (c *PrereviewController) SelectText(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SelectText opens the composer for a CHARACTER range (a word / phrase / span across lines), dispatched from the client's lvt-fx:text-select directive when a native selection settles inside the diff. Payload: from_line/from_col + to_line/to_col (rune offsets, doc-ordered so from precedes to), side, and the exact selected text. It reuses the line composer's placement — SelectionAnchor /End are the line span, so the existing SelectionEndMax gate renders the composer under the range's last line — and adds the columns + snippet that distinguish a kind=text comment from a whole-line one.

func (*PrereviewController) SetBase ¶

func (c *PrereviewController) SetBase(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetBase changes the comparison ref. The picker is a dropdown of refs we enumerated this Mount (HEAD~N presets + local/remote branches), so the value is already a valid ref. The rev-parse check stays as cheap defense against a race (a branch deleted between Mount and select); on a miss we just no-op and keep the current base.

On success, rebuilds the file list against the new base. If the previously selected file no longer exists in the new file list, SelectedFile is cleared.

func (*PrereviewController) SetFileFilter ¶

func (c *PrereviewController) SetFileFilter(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetFileFilter updates the search filter applied to the file drawer. Bound to the search input via lvt-on:input with a debounce modifier.

func (*PrereviewController) SetFileViewMode ¶

func (c *PrereviewController) SetFileViewMode(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetFileViewMode is the setter counterpart of ToggleFileView for the desktop radio group (Diff / File). Reads form field `view`; "file" → FileView true, anything else (incl. "diff") → false.

func (*PrereviewController) SetHTMLView ¶

func (c *PrereviewController) SetHTMLView(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetHTMLView is the idempotent setter behind the HTML Preview/Raw radio group. Mirrors SetMarkdownView: "raw" → line view, anything else → iframe preview.

func (*PrereviewController) SetMarkdownView ¶

func (c *PrereviewController) SetMarkdownView(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetMarkdownView is the idempotent setter behind the desktop radio group (Rendered / Raw). Reads form field `view`; anything other than "raw" resolves to rendered. Unlike ToggleRawMarkdown, clicking the already-active radio is a no-op for state — the value reflects the final mode, not a flip.

func (*PrereviewController) SetProxyURL ¶

func (c *PrereviewController) SetProxyURL(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetProxyURL records the proxied page the iframe is currently showing, reported by the injected beacon on load / pushState / popstate. It scopes which region annotations render (RegionComments) and where new ones anchor. Navigating to a different page drops any in-progress region composer — it belonged to the page we just left.

func (*PrereviewController) SetSearchQuery ¶ added in v0.16.0

func (c *PrereviewController) SetSearchQuery(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetSearchQuery updates the live query and recomputes the hit list. Bound to the palette input via lvt-on:input + a debounce modifier (mirrors SetFileFilter).

func (*PrereviewController) SetURLHash ¶

func (c *PrereviewController) SetURLHash(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

SetURLHash dispatches from the client's url-hash directive when `location.hash` changes (page-load with a hash, address-bar edit, back-button, permalink click). Parses the hash via gitdiff.ParseHash and updates state.SelectedFile + selection range + anchor; loads the diff if the path changed and resolves to a known file. Tolerant of bogus hashes (an unrelated `#confirm-delete-xyz` dialog hash resolves to a non-existent file and is silently dropped) — the existing dialog/popover/details hash machinery in setupHashLink handles those independently.

On a successful path match, also clears any in-progress composer state from the previous file (mirror of SelectFile), since the user just navigated.

func (*PrereviewController) ShowHiddenSuggestions ¶ added in v0.20.0

func (c *PrereviewController) ShowHiddenSuggestions(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ShowHiddenSuggestions clears the SELECTED file's hides (the "show N hidden" recovery), bringing them back into view. Other files' hides are untouched, so the count next to the affordance stays scoped to the page. Mirrors UnhideAllResolved for comments.

func (*PrereviewController) SweepGoneFiles ¶ added in v0.24.0

func (c *PrereviewController) SweepGoneFiles()

SweepGoneFiles flags every comment whose file no longer exists as outdated, ONCE at startup, and self-heals the CSV.

relocateAll already does this, but it only runs on a live path (a snapshot emit, opening the all-comments view). The CLI readers — `prereview comments` / `done` — read the CSV directly, so until something relocated, they kept handing the agent work on files that no longer exist while the UI had already stopped showing it. Doing the sweep at launch means the store is TRUE from the first moment and every reader agrees.

Cheap: one os.Stat per commented file, no git.

func (*PrereviewController) ToggleAgentPause ¶ added in v0.18.0

func (c *PrereviewController) ToggleAgentPause(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleAgentPause flips the agent between paused and running (#119). Pausing holds the drain so the reviewer can batch up work; resuming releases it and re-arms the emit so the accumulated batch ships in one snapshot.

func (*PrereviewController) ToggleAnnotations ¶

func (c *PrereviewController) ToggleAnnotations(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleAnnotations opens/closes the --external annotations sidebar (collapsed by default so the live site gets full width). Pure flip.

func (*PrereviewController) ToggleCommentList ¶

func (c *PrereviewController) ToggleCommentList(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleCommentList flips between the diff viewer and the all-comments overview pane. Bound to the "N comments" entry in the overflow menu. Closes the menu so the user sees the result immediately.

func (*PrereviewController) ToggleFileScope ¶

func (c *PrereviewController) ToggleFileScope(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleFileScope flips the drawer file list between changed-only (default) and all tracked files. See PrereviewState.ShowAllFiles and scopedFiles. Lives in the drawer, so no overflow-menu interaction.

func (*PrereviewController) ToggleFileView ¶

func (c *PrereviewController) ToggleFileView(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleFileView flips between diff-overlay mode (default) and plain file-view mode. See PrereviewState.FileView. Closes the overflow menu so the effect on the diff is immediately visible.

func (*PrereviewController) ToggleFiles ¶

func (c *PrereviewController) ToggleFiles(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleFiles flips the mobile file-drawer's open state. Bound to the hamburger button and to the drawer's backdrop "close" form.

func (*PrereviewController) ToggleFocusMode ¶

func (c *PrereviewController) ToggleFocusMode(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleFocusMode flips the distraction-free reading view. When on, the desktop file drawer (left) and TOC sidebar (right) are hidden so the center reading surface gets the full width. Persisted per-user. Closes the overflow menu so the effect is visible immediately (the menu entry is the mobile control; the desktop control is a toolbar button).

func (*PrereviewController) ToggleKeyboardHelp ¶ added in v0.14.0

func (c *PrereviewController) ToggleKeyboardHelp(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleKeyboardHelp opens/closes the keyboard-shortcuts help overlay. Triggered by the "?" key and the toolbar help button (both dispatch toggleKeyboardHelp); Esc closes it via ClearSelection. Closes the overflow menu so the two overlays don't stack.

func (*PrereviewController) ToggleMarks ¶ added in v0.23.0

func (c *PrereviewController) ToggleMarks(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleMarks flips whether the per-line comment/suggestion count badges (#151) and their inline cards are shown in the diff. Off by default (badges visible); when on, the diff reads clean so a reviewer can scan the raw code. Persisted per-user. Closes the overflow menu so the effect is visible immediately.

func (*PrereviewController) ToggleMoreMenu ¶

func (c *PrereviewController) ToggleMoreMenu(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleMoreMenu opens/closes the 3-dots overflow menu in the top bar. Mirrors the file-drawer pattern: state-driven boolean + CSS class toggle. No JS. Backdrop tap submits CloseMoreMenu.

func (*PrereviewController) ToggleQueueScope ¶ added in v0.24.0

func (c *PrereviewController) ToggleQueueScope(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleQueueScope switches the queue panel between THIS FILE's work (the default — the queue is about the document in front of you) and the whole review's (#171). Persisted per-user, so the choice survives the relaunch-per-review workflow.

A view filter only: the agent is always handed every actionable item in the review, so flipping this can never strand work it would otherwise have picked up.

func (*PrereviewController) ToggleQuiz ¶ added in v0.25.0

func (c *PrereviewController) ToggleQuiz(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleQuiz flips between the diff viewer and the comprehension-quiz view for the selected file. Mirrors ToggleCommentList: closes the overflow menu so the result is visible immediately, and is not persisted — reopening the browser starts back in the diff.

func (*PrereviewController) ToggleRawHTML ¶

func (c *PrereviewController) ToggleRawHTML(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleRawHTML is the .html/.htm equivalent of ToggleRawMarkdown: flips the iframe preview off and the syntax-highlighted line view on (and back). Closes the overflow menu so the change is visible on mobile.

func (*PrereviewController) ToggleRawMarkdown ¶

func (c *PrereviewController) ToggleRawMarkdown(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleRawMarkdown flips a Markdown file between the rendered view (default) and the raw line view. Closes the overflow menu so the effect is immediately visible on mobile.

func (*PrereviewController) ToggleRegionSelect ¶

func (c *PrereviewController) ToggleRegionSelect(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleRegionSelect flips the "draw a box to comment" overlay for the current preview on/off. Bound to the "Select region" toggle button. Off by default so one-finger gestures scroll; on, the parent-document overlay (lvt-fx:region-select) captures a drag and resolves it to a pixel rect (image) or a source line range (rendered HTML / code).

func (*PrereviewController) ToggleResolved ¶

func (c *PrereviewController) ToggleResolved(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleResolved flips the Resolved flag on the named comment and rewrites the CSV. Unlike DeleteComment, this keeps the comment as a historical record; the skill should treat resolved comments as "addressed" and only act on unresolved ones.

func (*PrereviewController) ToggleRow ¶ added in v0.24.0

func (c *PrereviewController) ToggleRow(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleRow flips one row's annotation cards away from their default visibility (#174) — the count badge's click. Green badge: peek the done cards (what it always did). Yellow badge: collapse the open comment/suggestion behind the badge, so it can be set aside and come back to later without being resolved.

Server-side on purpose: the old `peek-done` was a client-only class the server never emitted, so any re-render morphed it away and silently re-collapsed a card the reviewer had just opened (#173). Now the server owns it and the morph converges.

The row key is the badge's own: "<line>-<side>" in the diff, "MB-<start>-<end>" in the md-view. Deleting rather than storing false keeps the persisted map to just the rows the reviewer actually flipped.

func (*PrereviewController) ToggleSearchScope ¶ added in v0.16.0

func (c *PrereviewController) ToggleSearchScope(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleSearchScope flips the search between the changed set (default) and all files, recomputing against the new scope.

func (*PrereviewController) ToggleShowResolved ¶

func (c *PrereviewController) ToggleShowResolved(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleShowResolved flips whether resolved comments are visible in the inline diff and the all-comments overview. Default off — resolved comments add noise once they're handled. Bound to an entry in the overflow menu. Closes the menu so the user can immediately see the effect on the diff.

func (*PrereviewController) ToggleSuggestions ¶ added in v0.17.0

func (c *PrereviewController) ToggleSuggestions(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleSuggestions shows/hides the inline LLM suggestion boxes for the current view (issue #98). A declutter toggle only — it never touches the underlying suggestions. Session-scoped (HideSuggestions is lvt:"persist"), so it isn't a durable per-user pref; closes the overflow menu so the effect is visible on mobile.

func (*PrereviewController) ToggleTOC ¶ added in v0.24.3

func (c *PrereviewController) ToggleTOC(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleTOC flips the desktop table-of-contents sidebar (the right column). Bound to the bar's contents button and the "t" shortcut. Independent of the file drawer (left) and of Focus mode, which hides both at once (#137). A durable view preference like Focus mode, so it's saved to disk to survive a relaunch.

func (*PrereviewController) ToggleViewed ¶

func (c *PrereviewController) ToggleViewed(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ToggleViewed flips the "reviewed" flag for the file passed via the hidden `path` input. Bound to a per-file checkbox/button in the drawer.

func (*PrereviewController) UndoDelete ¶

func (c *PrereviewController) UndoDelete(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

UndoDelete restores the most recently deleted comment to state.Comments and rewrites the CSV. No-op if LastDeletedComment is nil (the undo affordance shouldn't even render in that case, but defending in depth).

func (*PrereviewController) UnhideAllResolved ¶ added in v0.16.0

func (c *PrereviewController) UnhideAllResolved(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

UnhideAllResolved clears the individual-hide flag on every comment at once — the recovery for HideComment, surfaced as "Unhide N" next to the Show-resolved toggle. Rewrites the CSV; rolls back the in-memory flags on a write error so disk and memory stay in sync.

func (*PrereviewController) ViewVersion ¶ added in v0.18.0

func (c *PrereviewController) ViewVersion(state PrereviewState, ctx *livetemplate.Context) (PrereviewState, error)

ViewVersion opens a historical version of the selected file read-only in the right pane (the store hands back the exact bytes; RenderBytesAsFile turns them into the same *FileDiff the live pane renders). It's a view MODE, not a file write — nothing on disk changes. Selection/compose affordances are cleared because historical line coords don't match disk (see the template's !ViewingVersion gate).

func (*PrereviewController) WatchLLMStatus ¶ added in v0.16.0

func (c *PrereviewController) WatchLLMStatus(stop <-chan struct{}, poll time.Duration)

WatchLLMStatus polls the status file and, whenever it changes, fans a LLMStatusChanged action out to every connected tab of the current session. One goroutine per server (not per connection): the status file is a single global signal and TriggerAction already fans out to all tabs, so a per-connection watcher would multiply re-renders by the number of tabs. It runs only in skill/stream mode (the only modes with an agent writing status) and returns when stop is closed (server shutdown).

func (PrereviewState) AgentWorking ¶ added in v0.18.0

func (s PrereviewState) AgentWorking() bool

AgentWorking mirrors the llm-status echo: true while the agent is applying a batch. Drives the "in progress" state of the queue (the queued set is being worked) and a live pill.

func (PrereviewState) AgentWorkingLabel ¶ added in v0.24.3

func (s PrereviewState) AgentWorkingLabel() string

AgentWorkingLabel is the text for the live "working" pill/toast — non-empty only while the agent is working (llm-status=working). It prefers the agent's own status message; with none, it tells the reviewer what is happening: applying their reply(ies) when any still await a response (#164 secondary — the reviewer wants to see their reply being applied), else the generic handoff message. Empty when the agent is idle, so the caller can gate on it directly.

func (PrereviewState) AllRegionComments ¶

func (s PrereviewState) AllRegionComments() []Comment

AllRegionComments returns every visible region annotation for the --external sidebar, in creation order. Unlike RegionComments it is NOT scoped to the current page, so the sidebar can show annotations across every page the user has visited.

func (PrereviewState) AnnotationAcceptedLines ¶ added in v0.23.1

func (s PrereviewState) AnnotationAcceptedLines() map[string]bool

AnnotationAcceptedLines reports, per row, whether the row has any accepted-but-unapplied suggestion (#165) — the badge is accentuated yellow (else it falls through to open→yellow or done→green). Only suggestions have an accepted state. The template checks it AFTER AnnotationOpenLines, so open wins on a mixed row.

func (PrereviewState) AnnotationCountLines ¶ added in v0.23.1

func (s PrereviewState) AnnotationCountLines() map[string]int

AnnotationCountLines is the per-row TOTAL — comments + suggestions — driving the one unified right-margin badge (#165: a single badge per line, not one per kind).

func (PrereviewState) AnnotationOpenLines ¶ added in v0.23.1

func (s PrereviewState) AnnotationOpenLines() map[string]bool

AnnotationOpenLines reports, per row, whether ANY annotation is open (unresolved comment / undecided suggestion) — the unified badge is yellow.

func (PrereviewState) AreaComments ¶

func (s PrereviewState) AreaComments() []Comment

AreaComments returns the selected file's visible image-area comments (Kind == "area") in creation order. Rendered as semi-transparent rectangle overlays inside the image wrapper, with paired list entries for body + Resolve/Edit/Delete actions in the file-comments section. Same shape as FileLevelComments — parallel iteration.

func (PrereviewState) AwaitingAgent ¶ added in v0.23.0

func (s PrereviewState) AwaitingAgent() map[string]bool

AwaitingAgent maps each target ID whose thread ends with a REVIEWER entry — the reviewer replied and is waiting on the agent (#149) — so a card can badge itself "awaiting agent". Zero-arg for the framework; nil when none.

func (PrereviewState) AwaitingApplyCount ¶ added in v0.24.0

func (s PrereviewState) AwaitingApplyCount() int

AwaitingApplyCount is how many suggestions the reviewer has ACCEPTED but the agent has not yet written to the file (#171).

Accepting only records a verdict — prereview never writes user files (#103); the agent applies the edit and acks with `prereview applied <id>`. That works while an agent is looping on `prereview watch`, but accept an edit after its turn has ended and nothing ever applies it: the verdict sits in suggestion-decisions.jsonl, the file is untouched, and the card has already collapsed to an amber badge (#165) that is trivially missed. The document silently never becomes clean.

This is the count that makes that state impossible to ignore — surfaced in the queue and warned about on End session. Revert-aware, because s.Applied nets reverted.jsonl: undoing an applied edit correctly puts it back in the awaiting-apply pile.

Deliberately scoped to the whole REVIEW, not the current file — unlike the rest of the queue panel (#171). It is a "you are about to lose work" guard, not a work list: a count that only saw the file you happen to be looking at would cheerfully let you end the session with unapplied accepts stranded on another file, which is the exact failure it exists to prevent.

func (PrereviewState) AwaitingLines ¶ added in v0.23.0

func (s PrereviewState) AwaitingLines() map[string]bool

AwaitingLines reports, per line-row ("<line>-<side>"), whether any comment or suggestion rendered there is awaiting the agent (the reviewer replied last, #149) — so the #151 count badge on that row can show an unread dot. Derived from the same filtered ByEndLine maps as the badges, gated by AwaitingAgent. Zero-arg; nil when nothing is awaiting.

func (PrereviewState) AwaitingReplyCount ¶ added in v0.24.3

func (s PrereviewState) AwaitingReplyCount() int

AwaitingReplyCount tallies, across the WHOLE REVIEW, every reviewer reply still awaiting an agent response — the trailing run of reviewer entries on each comment/suggestion thread (#164). It is a per-REPLY counter, not per-comment: three replies in a row on one comment count as three, so the reviewer sees each reply register, and the tally drops to zero for a thread the moment the agent replies.

reopenIfReplied separately reopens a replied-on comment as "queued" in the per-file counts, but QueuedCount/HasQueue are per-file (#171): reply on a comment, then look at another file, and that work vanishes from the toolbar. So — like AwaitingApplyCount, and for the same "don't strand cross-file work" reason — this tally is deliberately whole-review and surfaced independently of the per-file HasQueue gate, so replies are always visible on the Queue badge whatever file you are on. A draft never has a thread, so it never contributes.

func (PrereviewState) BinaryKind ¶

func (s PrereviewState) BinaryKind() string

BinaryKind classifies an IsBinary FileDiff by extension so the viewer can render a real preview (<img>, <iframe>, <video>, <audio>) instead of the bare "Binary file — cannot display" message. Returns "" for formats with no in-browser viewer (e.g. .zip, .so, unknown ext) so the template falls back to the cannot-display copy. Extensions must be a subset of staticAllowedExt in main.go — the static fallback only serves what's on that allowlist, and an <img>/<iframe> pointing at a 404 would just show a broken icon.

func (PrereviewState) BlockAnnotations ¶ added in v0.23.1

func (s PrereviewState) BlockAnnotations() map[string]BlockAnn

BlockAnnotations aggregates the selected file's inline annotations into each rendered Markdown block by source line range, keyed "MB-<start>-<end>" (the template's $mbkey). Zero-arg; nil when none.

func (PrereviewState) BlockDiffStatus ¶ added in v0.22.0

func (s PrereviewState) BlockDiffStatus() map[string]string

BlockDiffStatus maps a rendered-Markdown block's data-key ("MB-<start>-<end>") to a diff-highlight class: "added" when every new-side line the block spans is an addition, "changed" when the block spans a mix of added and context lines. Blocks that span only unchanged (context) lines are omitted, so `{{index $.BlockDiffStatus $mbkey}}` yields "" and no class is applied.

This is what makes issue #110 — "diff highlighting should also show up in preview mode" — work: the code view colours each add/del line green/red, and this surfaces the same add signal on the rendered blocks. Only ADDED/CHANGED content is representable here: the preview renders the NEW side of the file, so a purely-deleted region has no block to mark (a documented gap, not a bug — interleaving old content would be a different feature).

Zero-arg by design (livetemplate only auto-invokes NumIn()==0 state methods), mirroring LineDisplay / ScrollHeadingBlockKey: the per-block predicate is precomputed into a map the template looks up by key.

Returns nil (no highlighting) when the rendered view isn't showing, when the reviewer picked File over Diff (the toolbar's Diff/File toggle — File mode shows the plain document, exactly as it drops the add/del colouring in the code view via `.code.file-view`), when a historical version is being viewed (block ranges are in the version's coordinates while CurrentDiff.Lines is the live diff — matching them is meaningless), or for a wholly-added / wholly-deleted file (Note "file added" / "file deleted"): the code view drops its green wall there too (`.code.pure-add`), so the preview stays consistent.

func (PrereviewState) CSVBasename ¶

func (s PrereviewState) CSVBasename() string

CSVBasename returns just the filename portion of CSVPath — useful for compact toast/banner display where the full repo path is noise.

func (PrereviewState) ChangedFilesCount ¶

func (s PrereviewState) ChangedFilesCount() int

ChangedFilesCount is how many files differ from the base. Zero-arg so the template can label the scope toggle without computing.

func (PrereviewState) CommentCount ¶ added in v0.24.0

func (s PrereviewState) CommentCount() int

CommentCount is the number of in-scope comments — the all-comments view's header total. Zero-arg because livetemplate only pre-computes zero-arg methods; the template can't do `len` over a scoped slice itself without one.

func (PrereviewState) CommentCountLines ¶ added in v0.23.0

func (s PrereviewState) CommentCountLines() map[string]int

CommentCountLines reports, per line-row (keyed "<toLine>-<side>", e.g. "4-new"), HOW MANY comments render on that row — driving the #151 right-margin count badge (and, via count>0, the #136 presence marks). Derived from the SAME filtered map the cards render from (CommentsByEndLine), so the badge's number always equals the cards actually rendered — side, individually-hidden, resolved filter, and file scope are all inherited. Zero-arg so the framework pre-computes it (a method WITH an arg silently breaks rendering); the row looks itself up as {{index $.CommentCountLines (printf "%d-%s" $ln $lside)}}. Nil when none, so a missing key indexes to 0. (SuggestionCountLines is its counterpart below.)

func (PrereviewState) CommentOpenLines ¶ added in v0.23.1

func (s PrereviewState) CommentOpenLines() map[string]bool

CommentOpenLines reports, per line-row, whether the row has any OPEN (unresolved) comment (#165). Drives the badge colour: yellow when open work remains, else green (all resolved). "Yellow wins on a mixed line" falls out — one open comment flags it.

func (PrereviewState) CommentsByEndLine ¶

func (s PrereviewState) CommentsByEndLine() map[int][]Comment

CommentsByEndLine groups the current comments by their ToLine — the line the comment trails. The template renders each line N, then inlines any comment whose ToLine == N right after it (GitHub-mobile-style). Zero-arg for the same reason as SelectedLines: the livetemplate framework only pre-computes zero-arg methods into the data map.

Restricted to the currently-selected file. Resolved comments are filtered out when ShowResolved is false so the diff stays focused on open issues.

func (PrereviewState) CurrentQuiz ¶ added in v0.25.0

func (s PrereviewState) CurrentQuiz() *Quiz

CurrentQuiz returns the quiz for the selected file, or nil. The agent can revise a quiz by re-appending its id (the loader keeps the last write), and can also submit a genuinely new one for the same file — in which case the newest wins, since that is the one the reviewer just asked for.

func (PrereviewState) DataMode ¶ added in v0.14.0

func (s PrereviewState) DataMode() string

DataMode is the value for the .theme-root data-mode attribute: "light" or "dark" when the mode is forced, "" for System (in which case the template omits the attribute and prefers-color-scheme drives the theme). Zero-arg so the page template can emit `{{with .DataMode}} data-mode="{{.}}"{{end}}`.

func (PrereviewState) DataScheme ¶ added in v0.14.0

func (s PrereviewState) DataScheme() string

DataScheme is the value for the .theme-root data-scheme attribute: the persisted SchemeName when it names a registered scheme, else the default (gitdiff.Schemes[0]). Always non-empty so the wrapper always carries a scheme — mirrors DataMode's fall-through-to-default contract. Zero-arg so the page template can emit `data-scheme="{{.DataScheme}}"`.

func (PrereviewState) DecisionCount ¶ added in v0.17.0

func (s PrereviewState) DecisionCount() int

DecisionCount is the number of current suggestions carrying a live (fingerprint- matching) decision — drives the "N decisions recorded" status. Zero-arg.

func (PrereviewState) DecisionsBySuggestion ¶ added in v0.17.0

func (s PrereviewState) DecisionsBySuggestion() map[string]SuggestionDecision

DecisionsBySuggestion maps each CURRENT in-scope suggestion's ID to its recorded decision, but ONLY when the decision's fingerprint still matches the suggestion's content. A same-id revision (new proposed text) changes the fingerprint, so its stale decision drops and the suggestion reads as undecided again; orphan decisions (the suggestion is gone) are dropped too. Zero-arg so the framework pre-computes it; the suggestionCard looks up its own ID via {{index $.DecisionsBySuggestion .ID}}.

Keyed off scopedSuggestions, so DecisionCount (its len) counts only this review's decisions — and the by-ID lookups it serves are all made from already-scoped cards.

func (PrereviewState) DoneCount ¶ added in v0.18.0

func (s PrereviewState) DoneCount() int

DoneCount is the number of comments the agent marked worked-on + suggestions it applied.

func (PrereviewState) DraftCount ¶ added in v0.18.0

func (s PrereviewState) DraftCount() int

DraftCount is the number of held (not-yet-enqueued) comments.

func (PrereviewState) FileBrowserHTML ¶ added in v0.13.0

func (s PrereviewState) FileBrowserHTML() template.HTML

FileBrowserHTML renders the drawer file browser (folder tree when unfiltered, flat path list while filtering) for injection into prereview.tmpl. Zero-arg so the template can emit `{{.FileBrowserHTML}}`; re-executed each render so selection / viewed / filter stay current.

func (PrereviewState) FileComments ¶

func (s PrereviewState) FileComments() []Comment

FileComments returns the selected file's visible LINE-anchored comments (honoring ShowResolved) as a flat slice. Zero-arg so the rendered-Markdown view can, per block, show the comments whose ToLine falls in that block's source range — the line-view path uses CommentsByEndLine (exact-line map) instead.

File-level (Kind=="file") and area-level (Kind=="area") comments are excluded here so they don't accidentally try to anchor at line 0 inside a block range. They're rendered in their own sections via FileLevelComments() and AreaComments().

func (PrereviewState) FileHeadAnnotationCount ¶ added in v0.25.0

func (s PrereviewState) FileHeadAnnotationCount() int

FileHeadAnnotationCount is how many annotations sit at the file head — the number the shared row badge shows there. Counts file-level and area comments alongside the head quiz questions, because they all collapse together.

func (PrereviewState) FileHeadHasOpen ¶ added in v0.25.0

func (s PrereviewState) FileHeadHasOpen() bool

FileHeadHasOpen reports whether anything at the file head is still open work, which is what makes the shared badge read "open" rather than "done".

func (PrereviewState) FileLevelComments ¶

func (s PrereviewState) FileLevelComments() []Comment

FileLevelComments returns the selected file's visible whole-file comments (Kind == "file") in creation order. Rendered in a dedicated section above the per-line body so reviewers see "comments on the file itself" before any line-anchored feedback.

func (PrereviewState) FileQuizItems ¶ added in v0.25.0

func (s PrereviewState) FileQuizItems() []QuizItem

FileQuizItems are the questions that have no valid position inside the diff, so they render at the file head — exactly where a kind=file COMMENT renders.

Two groups land here, for different reasons:

• kind=file: about the change as a whole, or about something absent from it. It never had a line, by design.
• UNGROUNDED: it claims a line the diff does not contain, so there is nowhere to anchor it. These MUST still render. Anchoring questions inline means an unresolvable anchor has no home, and quietly dropping it would HIDE a hallucinated question instead of surfacing it — undoing the entire point of the grounding check. The reviewer needs to see that the agent asked about code that isn't there.

func (PrereviewState) FileSuggestions ¶ added in v0.17.0

func (s PrereviewState) FileSuggestions() []Suggestion

FileSuggestions returns the selected file's suggestions as a flat slice (nil when toggled off), so the rendered-Markdown view can, per block, show the suggestions whose ToLine falls in that block's source range — the parallel of FileComments for the block view. The line/code view uses SuggestionsByEndLine.

func (PrereviewState) FileTree ¶ added in v0.13.0

func (s PrereviewState) FileTree() []*TreeNode

FileTree builds the directory tree from the scoped file list (so the Changed/All scope toggle applies exactly as it does to FilteredFiles). The search filter is intentionally NOT applied here: the template shows the flat FilteredFiles list while a filter is active and the tree only when it's empty.

Zero-arg so the framework pre-computes it once per render and the template can range `$.FileTree`. Returns the top-level nodes (depth 0).

func (PrereviewState) FilteredFileNodes ¶ added in v0.13.0

func (s PrereviewState) FilteredFileNodes() []*TreeNode

FilteredFileNodes wraps FilteredFiles as flat leaf TreeNodes so the flat (filter-active) list and the tree can share one `fileRow` template. Name is the full path here — the flat list shows full paths so a search reveals where each match lives; the tree sets Name to just the final segment.

Zero-arg so the template can range `$.FilteredFileNodes`.

func (PrereviewState) FilteredFiles ¶

func (s PrereviewState) FilteredFiles() []gitdiff.FileEntry

FilteredFiles returns the scoped files (see scopedFiles) further narrowed by FileFilter (case-insensitive substring match against path). Zero-arg so the framework pre-computes it once per render and the template can iterate `$.FilteredFiles`.

func (PrereviewState) FocusedComment ¶

func (s PrereviewState) FocusedComment() *Comment

FocusedComment returns the region annotation the user tapped to locate (FocusedCommentID), or nil. The template reads its URL + Area to tell the client which page to show and where to scroll the iframe.

func (PrereviewState) HasMarks ¶ added in v0.23.0

func (s PrereviewState) HasMarks() bool

HasMarks reports whether the selected file has any per-line comment/suggestion badges — i.e. whether the "Hide annotations" toggle (ToggleMarks) has anything to act on. Gates that menu entry. Reads the same memoized count maps the badges use.

func (PrereviewState) HasQueue ¶ added in v0.18.0

func (s PrereviewState) HasQueue() bool

HasQueue reports whether there's anything to show in the queue panel (any draft/queued/done comment or accepted/applied suggestion). Gates the toolbar indicator so it stays hidden on an empty review.

func (PrereviewState) HasQuiz ¶ added in v0.25.0

func (s PrereviewState) HasQuiz() bool

HasQuiz reports whether the selected file has a quiz to show — the gate for offering the quiz entry in the menus at all.

func (PrereviewState) HasReadFrontier ¶ added in v0.20.0

func (s PrereviewState) HasReadFrontier() bool

HasReadFrontier reports whether there's a meaningful "resume reading" jump to offer — some progress, but not the whole file read. Gates the Resume affordance. Zero-arg.

func (PrereviewState) HiddenResolvedCount ¶ added in v0.16.0

func (s PrereviewState) HiddenResolvedCount() int

HiddenResolvedCount returns how many in-scope resolved comments have been individually re-hidden — drives the "Unhide N" affordance next to the Show-resolved toggle.

func (PrereviewState) HiddenSuggestionCount ¶ added in v0.20.0

func (s PrereviewState) HiddenSuggestionCount() int

HiddenSuggestionCount is how many of the SELECTED file's suggestions are currently hidden (fingerprint-matching), driving the "N hidden · show" affordance. Scoped to the selected file so the count matches what a reviewer could reveal on the page they're looking at. Zero-arg.

func (PrereviewState) IsHTML ¶

func (s PrereviewState) IsHTML() bool

IsHTML reports whether the selected file is an HTML file (.html/.htm). Drives the Preview/Raw toolbar toggle and the iframe branch in the viewer template, parallel to IsMarkdown.

func (PrereviewState) IsMarkdown ¶

func (s PrereviewState) IsMarkdown() bool

IsMarkdown reports whether the selected file is Markdown.

func (PrereviewState) KeyBindings ¶ added in v0.14.0

func (s PrereviewState) KeyBindings() []KeyBinding

KeyBindings exposes the keymap to the template. Zero-arg so livetemplate's evaluator auto-invokes it; the template ranges over it for both the hidden window bindings and the help overlay. StreamOnly rows are dropped outside --agent mode so a repo-only reviewer gets neither a live binding nor a help row for the agent-queue Pause/Resume shortcut (there's no queue for them).

func (PrereviewState) KeyHint ¶ added in v0.16.0

func (s PrereviewState) KeyHint() map[string]string

KeyHint maps a button name to its Display key, so a button that a shortcut fires can surface the same key in its label (issue #89 / #118) — {{with index $.KeyHint "toggleFocusMode"}}<kbd>{{.}}</kbd>{{end}}. Keyed by both Action (the window-bound rows: nextFile, toggleFocusMode, …) and Button (rows fired from their own template binding: Save via Mod+Enter → "addComment", Cancel via Esc → "clearSelection"). Plain Enter — documented in the help overlay but with no toolbar button — has neither, so it never leaks a chip. Single-sourced from the same keyBindings slice as the live bindings and the help overlay, so a chip can never show a stale key.

Not filtered by AgentMode (unlike KeyBindings): a hint for a control that isn't rendered (the agent-only Pause button in repo mode) has no button to attach to, so it's harmless — and leaving it in keeps the lookup a pure map over the keymap. Zero-arg so livetemplate auto-invokes it (a method-with-arg would silently break rendering).

func (PrereviewState) LineDisplay ¶ added in v0.15.0

func (s PrereviewState) LineDisplay() map[string]template.HTML

LineDisplay maps each visible diff line's key ("L<old>-<new>", matching the template's $lkey) to its rendered content with every character-range (kind=text) comment wrapped in a <mark class="comment-span">. Zero-arg so livetemplate pre-computes it into the data map (it only pre-computes zero-arg methods — a method taking the line as an argument does NOT render); the template indexes it with {{index $.LineDisplay $lkey}}, mirroring how CommentsByEndLine / SelectedLines are consumed. (OldNum,NewNum) is unique per line — adds are (0,n), dels (m,0), ctx (m,n) — so the key never collides.

func (PrereviewState) NextScheme ¶ added in v0.14.0

func (s PrereviewState) NextScheme() string

NextScheme is the scheme the picker advances to from the current one, cycling gitdiff.Schemes in registry order and wrapping back to the first. Drives both the CycleScheme action and the picker's "switch to" label.

func (PrereviewState) NextSchemeLabel ¶ added in v0.14.0

func (s PrereviewState) NextSchemeLabel() string

func (PrereviewState) NextThemeMode ¶ added in v0.14.0

func (s PrereviewState) NextThemeMode() string

NextThemeMode is the mode the toolbar toggle advances to from the current one, cycling System → Light → Dark → System. Drives both the CycleTheme action and the toggle's label/icon ("show what a click switches TO").

func (PrereviewState) NextThemeModeLabel ¶ added in v0.14.0

func (s PrereviewState) NextThemeModeLabel() string

func (PrereviewState) OutdatedCount ¶

func (s PrereviewState) OutdatedCount() int

OutdatedCount returns how many non-resolved in-scope comments could not be confidently re-anchored (their line numbers no longer point at the intended content) — drives the header "N need re-anchoring" hint so drift is discoverable without opening every file.

func (PrereviewState) QueueHiddenCount ¶ added in v0.24.0

func (s PrereviewState) QueueHiddenCount() int

QueueHiddenCount is how many queue rows the CURRENT filter is hiding — the work that exists elsewhere in the review. Zero when Global (nothing is hidden) and zero in a single-file review (there is nowhere else). It is what stops the per-file default from concealing a backlog: the switch advertises what is behind it.

func (PrereviewState) QueueItems ¶ added in v0.18.0

func (s PrereviewState) QueueItems() []QueueItem

QueueItems returns the queue rows ordered by lifecycle — queued (remaining) first, then done, then drafts — so the panel leads with what still needs the agent's attention. Resolved/outdated comments and un-queued suggestions are excluded (QueueState "") — UNLESS the reviewer replied on one last (#164), which reopens it as "queued" work via reopenIfReplied.

func (PrereviewState) QueueScopeLabel ¶ added in v0.24.0

func (s PrereviewState) QueueScopeLabel() string

QueueScopeLabel names what the queue is currently showing — the switch's label, and the honest answer to "why is this count different from the one I saw a second ago".

func (PrereviewState) QueuedCount ¶ added in v0.18.0

func (s PrereviewState) QueuedCount() int

QueuedCount is the number of enqueued-but-not-yet-done comments + accepted-but- not-yet-applied suggestions — the "remaining" work the agent still has to pick up.

func (PrereviewState) QuizAnsweredCount ¶ added in v0.25.0

func (s PrereviewState) QuizAnsweredCount() int

QuizAnsweredCount is how many of them have been answered.

func (PrereviewState) QuizByEndLine ¶ added in v0.25.0

func (s PrereviewState) QuizByEndLine() map[int][]QuizItem

QuizByEndLine groups the current quiz's LINE-anchored questions by the line they end on, so the diff view can render each one inline right under the code it asks about — the same shape CommentsByEndLine and SuggestionsByEndLine use.

This is what makes a quiz question just another annotation. The first version put the quiz on its own screen and then had to reproduce the cited code inside it, which was a worse re-implementation of the diff view; anchoring the question to the line makes the code its own context.

func (PrereviewState) QuizComplete ¶ added in v0.25.0

func (s PrereviewState) QuizComplete() bool

QuizComplete reports that every question has been answered.

func (PrereviewState) QuizCorrectCount ¶ added in v0.25.0

func (s PrereviewState) QuizCorrectCount() int

QuizCorrectCount is how many were answered correctly.

func (PrereviewState) QuizCountLines ¶ added in v0.25.0

func (s PrereviewState) QuizCountLines() map[string]int

QuizCountLines counts the quiz questions anchored to each row, keyed "<line>-<side>" exactly like CommentCountLines — so a question contributes to the row's annotation badge and can be collapsed with everything else on that line. A quiz question is an annotation; it collapses like one.

func (PrereviewState) QuizItems ¶ added in v0.25.0

func (s PrereviewState) QuizItems() []QuizItem

QuizItems is the current quiz's questions with the reviewer's progress folded in. Empty when there is no quiz, so the template can range over it directly.

func (PrereviewState) QuizNavLabel ¶ added in v0.25.0

func (s PrereviewState) QuizNavLabel() string

QuizNavLabel summarises the navigator's state, e.g. "2/5 answered · 1 right".

Progress and score are DIFFERENT fractions, and an earlier version showed "1/5 answered" beside a "0/5" chip — two ratios side by side that looked like they should agree. They are one phrase now, and the chip says what it does ("Overview") rather than carrying a competing number.

func (PrereviewState) QuizOpenLines ¶ added in v0.25.0

func (s PrereviewState) QuizOpenLines() map[string]bool

QuizOpenLines marks rows carrying an UNANSWERED question — open work, so the badge reads open (yellow) rather than done, matching an unresolved comment.

func (PrereviewState) QuizPending ¶ added in v0.25.0

func (s PrereviewState) QuizPending() bool

QuizPending reports that a "Quiz me" request for the selected file is awaiting an answer, so the control shows a disabled "Quiz requested…" rather than inviting a second tap that would queue a duplicate.

func (PrereviewState) QuizQuestionCount ¶ added in v0.25.0

func (s PrereviewState) QuizQuestionCount() int

QuizQuestionCount is the number of questions in the current quiz.

func (PrereviewState) QuizResults ¶ added in v0.25.0

func (s PrereviewState) QuizResults() []StreamQuiz

QuizResults reports every quiz's outcome for the agent snapshot (#191).

It is ADVISORY: it never gates a verdict, it just lets the agent tell "accepted after a comprehension check" from "accepted without one". That distinction is the whole point — an accept records that the reviewer clicked, and this is the only signal that says whether they also understood.

Unlike the view helpers it walks every quiz, not just the selected file's, since the snapshot is not scoped to whatever file happens to be open — but it IS scoped to the review (inScope), the same as scopedComments and scopedSuggestions. Without that, a single-file review sharing a pre-#199 store reported the sibling file's quizzes as this file's comprehension record.

func (PrereviewState) QuizScoreLabel ¶ added in v0.25.0

func (s PrereviewState) QuizScoreLabel() string

QuizScoreLabel renders the running score for the quiz header, e.g. "2/5".

func (PrereviewState) ReadFrontierKey ¶ added in v0.20.0

func (s PrereviewState) ReadFrontierKey() string

ReadFrontierKey returns the data-key of the element at the read frontier — the furthest-read line/block — for the CURRENT view (#128), so a "resume reading" jump can scroll straight to where the reviewer left off. It matches the exact key the template stamps on that element (a code line "L<old>-<new>" or a rendered-markdown block "MB-<start>-<end>"), so lvt-fx:scroll finds it. Empty when nothing's read or no diff is loaded. Zero-arg.

func (PrereviewState) ReadPercent ¶ added in v0.20.0

func (s PrereviewState) ReadPercent() int

ReadPercent is how far through the selected file the reviewer has read (0..100): the read high-water mark (ReadThrough — the furthest new-side line scrolled past) as a fraction of the file's line count. Drives the top reading-progress bar (#128). Zero-arg; 0 when nothing's been read or the file length is unknown. Because it's the high-water mark, it only grows — scrolling back up doesn't shrink it (you've still reviewed that far).

func (PrereviewState) RegionComments ¶

func (s PrereviewState) RegionComments() []Comment

RegionComments returns the visible region annotations (kind="region") for the CURRENT proxied page (--external mode), in creation order. Rendered as the re-pin overlay markers + paired list entries. Scoped by CurrentURL (the page the iframe is on) rather than SelectedFile, since external mode has no file. Zero-arg so the template can range over it.

func (PrereviewState) RenderedHTML ¶

func (s PrereviewState) RenderedHTML() []gitdiff.HTMLBlock

RenderedHTML is the block list for the rendered HTML view (nil unless ShowRenderedHTML). Each block carries its real source line range so comments stay line-accurate across rendered and raw views — same contract as RenderedMarkdown. The preview itself renders in a single iframe (RenderedHTMLDoc); these ranges drive the comments list below it.

func (PrereviewState) RenderedHTMLDoc ¶

func (s PrereviewState) RenderedHTMLDoc() string

RenderedHTMLDoc is the preview document for the iframe srcdoc (empty unless ShowRenderedHTML). The whole file rendered with real-document fidelity; the client wires clicks inside it back to a block via the data-from/data-to ranges.

func (PrereviewState) RenderedHeadings ¶

func (s PrereviewState) RenderedHeadings() []gitdiff.Heading

RenderedHeadings returns the TOC entries for the current Markdown file, filtered to h1–h3 (deeper levels create visual noise without adding navigational value for typical docs). Returns nil when the rendered view isn't showing OR when there are fewer than two headings — a TOC with one entry is pointless and just steals horizontal real estate from the prose.

func (PrereviewState) RenderedMarkdown ¶

func (s PrereviewState) RenderedMarkdown() []gitdiff.MarkdownBlock

RenderedMarkdown is the block list for the rendered view (nil unless ShowRenderedMarkdown). Each block carries its real source line range so comments stay line-accurate across rendered and raw views.

func (PrereviewState) ResolvedCount ¶

func (s PrereviewState) ResolvedCount() int

ResolvedCount returns how many of the in-scope comments are resolved — useful for "(N resolved hidden)" status copy. Counts every resolved comment, individually-hidden or not (it gates the "Show resolved" toggle's visibility).

func (PrereviewState) Revealing ¶ added in v0.16.0

func (s PrereviewState) Revealing() bool

Revealing reports whether the currently-selected file is being shown as its full RAW source because a search-jump set RevealFile to it — see RevealFile. Zero-arg so VisibleLines / ShowRendered* can gate on it.

func (PrereviewState) RowToggled ¶ added in v0.24.1

func (s PrereviewState) RowToggled() map[string]bool

RowToggled reports which rows currently render flipped away from their default — the `row-toggled` class the templates emit. Zero-arg so livetemplate pre-computes it.

A toggle EXPIRES when the row's default changes underneath it. A toggle means "flip THIS row away from THIS default"; once the default is no longer that, the instruction is stale and re-applying it inverts the reviewer's intent. Concretely: peek a done suggestion (the row is collapsed-by-default, so the toggle means SHOW), then click Undo — the suggestion goes back to undecided, the row's default becomes open, and the stale toggle would now mean HIDE, vanishing the card the reviewer is working on. Same for reopening a resolved comment. Dropping the stale entry restores the default view, which is what the reviewer wants to see the moment the row's state changes.

func (PrereviewState) SchemeLabel ¶ added in v0.14.0

func (s PrereviewState) SchemeLabel() string

SchemeLabel / NextSchemeLabel are the human names (gitdiff.Scheme.Label) of the current and next schemes, for the picker's tooltip ("Theme: Solarized — switch to Gruvbox") and the overflow-menu item.

func (PrereviewState) ScopeFileCount ¶ added in v0.14.0

func (s PrereviewState) ScopeFileCount() int

ScopeFileCount / ScopeViewedCount drive the "X/Y viewed" toolbar progress so it counts against the files actually in the review SCOPE (what the drawer shows) — changed-only by default. So a repo with 144 tracked files and 1 changed reads "0/1 viewed", not "0/144". Falls back to all files when the scope is all (clean tree or ShowAllFiles), consistent with scopedFiles. Zero-arg so the template can read them directly.

func (PrereviewState) ScopeViewedCount ¶ added in v0.14.0

func (s PrereviewState) ScopeViewedCount() int

func (PrereviewState) ScrollHeadingBlockKey ¶

func (s PrereviewState) ScrollHeadingBlockKey() string

ScrollHeadingBlockKey returns the `data-key` (e.g. "MB-5-10") of the MarkdownBlock containing the heading currently targeted by ScrollToHeadingID — or "" when no scroll is requested or the heading is not found. The template compares this against each block's own data-key to gate a `lvt-fx:scroll="into-view"` directive; see NavigateToHeading and issue #12.

Zero-arg by design: livetemplate's template evaluator (livetemplate/internal/parse/eval.go callMethod) only auto-invokes methods with NumIn() == 0, so a "does this block match" predicate taking the block's range as arguments isn't reachable from the template. Precomputing the matching key here and comparing with the builtin `eq`/`printf` keeps the hot path in Go.

func (PrereviewState) SearchScopeCount ¶ added in v0.16.0

func (s PrereviewState) SearchScopeCount() int

SearchScopeCount is the number of files the current search scope covers — changed files by default, or every file when SearchScopeAll. Drives the scope toggle's count. Zero-arg for the template.

func (PrereviewState) SearchScopeLabel ¶ added in v0.16.0

func (s PrereviewState) SearchScopeLabel() string

SearchScopeLabel is the human label for the current search scope toggle.

func (PrereviewState) SearchTruncated ¶ added in v0.16.0

func (s PrereviewState) SearchTruncated() bool

SearchTruncated reports whether the result list hit the cap (so the palette can note "showing first N"). Zero-arg for the template.

func (PrereviewState) SelectedFileBase ¶ added in v0.20.0

func (s PrereviewState) SelectedFileBase() string

SelectedFileBase / SelectedFileDir split the selected file's path for the file-head: the basename is shown bold and always in full (it identifies the file), the directory prefix is muted and truncates when the header is tight, so a long/deep path never wraps into a multi-line block that shoves the action chips off-screen. Dir includes a trailing "/"; empty for a top-level file. Zero-arg state methods (safe — a method on the nested *FileDiff wouldn't render).

func (PrereviewState) SelectedFileDir ¶ added in v0.20.0

func (s PrereviewState) SelectedFileDir() string

func (PrereviewState) SelectedLines ¶

func (s PrereviewState) SelectedLines() map[int]bool

SelectedLines returns a set of line numbers currently selected. Zero-arg so the livetemplate framework eagerly pre-computes it once per render (the framework only pre-computes zero-arg methods, so a SelectionContains(n) helper would not be callable from the template). The template membership-tests with `{{index $.SelectedLines $n}}` — index returns the zero value (false) for missing keys, which is exactly what we want for unselected lines.

func (PrereviewState) SelectionEmpty ¶

func (s PrereviewState) SelectionEmpty() bool

SelectionEmpty reports whether nothing is currently selected.

func (PrereviewState) SelectionEndMax ¶

func (s PrereviewState) SelectionEndMax() int

SelectionEndMax returns max(SelectionAnchor, SelectionEnd) — the line after which the inline composer should render. Zero means "no selection, don't render the composer". Order-independent so the user can pick anchor=10 → end=5 and the composer still lands after line 10.

func (PrereviewState) SelectionLabel ¶

func (s PrereviewState) SelectionLabel() string

SelectionLabel returns the human-readable form of the current selection (e.g. "L42" or "L42-L48"; for a text selection "L42:6-12" or "L42:6-L48:3"). Empty string when nothing is selected. Kept consistent with Comment.LineSpan so the composer heading matches the saved card's badge.

func (PrereviewState) ShowQuizNav ¶ added in v0.25.0

func (s PrereviewState) ShowQuizNav() bool

ShowQuizNav gates the navigator: it appears whenever the open file has a quiz, unless dismissed or the overview is already showing (where it would duplicate the list it sits above).

func (PrereviewState) ShowRenderedHTML ¶

func (s PrereviewState) ShowRenderedHTML() bool

ShowRenderedHTML is true when the viewer should swap the line view for the inline-blocks view: an HTML file, not toggled to raw, with at least one rendered block. Mirrors ShowRenderedMarkdown — a deleted / empty file falls through to the line view (showing the diff) instead of an empty preview pane.

func (PrereviewState) ShowRenderedMarkdown ¶

func (s PrereviewState) ShowRenderedMarkdown() bool

ShowRenderedMarkdown is true when the viewer should show the rendered-Markdown blocks instead of the line view: a Markdown file, not toggled to raw, with at least one rendered block. Zero-arg so the template can branch on `$.ShowRenderedMarkdown`.

func (PrereviewState) SuggestionAcceptedLines ¶ added in v0.23.1

func (s PrereviewState) SuggestionAcceptedLines() map[string]bool

SuggestionAcceptedLines reports, per line-row, whether the row has any ACCEPTED-but- unapplied suggestion (#165) — drives the accentuated-yellow "accepted" badge. Loses to "open" on a mixed row (an undecided item is more urgent), which the template's is-open→is-accepted→is-done ladder enforces.

func (PrereviewState) SuggestionCount ¶ added in v0.17.0

func (s PrereviewState) SuggestionCount() int

SuggestionCount is the number of suggestions on the selected file, used to label the toolbar toggle and gate its visibility. Counts regardless of the HideSuggestions toggle (it's the total available, not the shown count).

func (PrereviewState) SuggestionCountLines ¶ added in v0.23.0

func (s PrereviewState) SuggestionCountLines() map[string]int

SuggestionCountLines counts ALL suggestions per row (#165) — open + accepted. The badge colour (yellow if any open, else green) comes from SuggestionOpenLines; the accepted ones collapse to that badge via CSS rather than being excluded here.

func (PrereviewState) SuggestionGroups ¶ added in v0.20.0

func (s PrereviewState) SuggestionGroups() map[string]SuggestionGroupInfo

SuggestionGroups maps each suggestion ID that belongs to a multi-member alternatives group (same File/Side/range/OriginalText) to its position + group size, so the card can show "N of M" + a shared visual — a clear signal that the suggestions are alternatives, not independent edits. Zero-arg so the framework pre-computes it; the card looks up {{index $.SuggestionGroups .ID}}. Computed over the SAME visible set the views render (hidden suggestions don't count), so the "N of M" never over- or under-states what the reviewer can see.

func (PrereviewState) SuggestionOpenLines ¶ added in v0.23.1

func (s PrereviewState) SuggestionOpenLines() map[string]bool

SuggestionOpenLines reports, per line-row, whether the row has any UNDECIDED suggestion (#165) — drives the yellow "open" badge. An accepted-pending suggestion is NOT open (it gets the accentuated-yellow badge via SuggestionAcceptedLines); an applied/rejected one is done (green).

func (PrereviewState) SuggestionsByEndLine ¶ added in v0.17.0

func (s PrereviewState) SuggestionsByEndLine() map[int][]Suggestion

SuggestionsByEndLine renders ALL of the selected file's suggestions inline (#165); an applied suggestion collapses to a green count badge via CSS, not by exclusion here (so the reviewer can still peek it open for the M4 status/revert controls).

func (PrereviewState) ThemeModeLabel ¶ added in v0.14.0

func (s PrereviewState) ThemeModeLabel() string

ThemeModeLabel / NextThemeModeLabel are the human names of the current and next modes, for the toggle's tooltip ("Theme: System — switch to Light") and the overflow-menu item. (The button's icon is chosen by an explicit ladder in the template, since Go templates can't take a dynamic {{template}} name.)

func (PrereviewState) Threads ¶ added in v0.23.0

func (s PrereviewState) Threads() map[string][]ThreadEntry

Threads groups the loaded conversation entries (#149) by target ID (a comment or suggestion ID), so a card renders its own thread with {{index $.Threads .ID}}. Entries arrive already sorted (loadThreads), so each group is chronological. Zero-arg so the framework pre-computes it; nil when there are no threads.

func (PrereviewState) URLHash ¶

func (s PrereviewState) URLHash() string

URLHash returns the canonical hash string for the current state, suitable for placement in `data-lvt-url-hash` on the body. Returns "" when no file is selected (the directive then no-ops on mirror). Order of precedence: SelectedFile + SelectionAnchor/End (line range is the most specific target a user is viewing) > SelectedFile + URLHashScrollAnchor > SelectedFile alone. The line-range form matches the gutter `<a>` permalinks; the anchor form survives a markdown TOC click or an HTML deep link until the user moves.

func (PrereviewState) ViewedCount ¶

func (s PrereviewState) ViewedCount() int

ViewedCount returns the number of files in state.Files marked as viewed. Zero-arg so the template can show "N of M reviewed" without computing.

func (PrereviewState) VisibleComments ¶

func (s PrereviewState) VisibleComments() []Comment

VisibleComments returns the in-scope Comments filtered by the resolved/hidden view rule. Zero-arg so the framework eagerly evaluates and the template iterates the filtered list directly. Note there is no `if ShowResolved { return all }` fast-path: an individually-hidden resolved comment must stay out even when the group is shown.

func (PrereviewState) VisibleLines ¶

func (s PrereviewState) VisibleLines() []gitdiff.DiffLine

VisibleLines is the line set the viewer renders for the selected file, per the current mode:

• File view (FileView == true): the entire current working-tree file — every line that exists on the new side (add + ctx), deletions excluded since they aren't in the file anymore. No diff, no folds.
• Diff view (FileView == false): a real diff — only changed lines plus 3 lines of context, long unchanged gaps replaced by fold markers (see gitdiff.CollapseToHunks). An unchanged file has no diff, so CollapseToHunks returns it whole.

Zero-arg so the framework pre-computes it once per render and the template ranges `$.VisibleLines`. Line numbers are identical across modes, so comments anchored in one mode resolve in the other.

func (Question) AnchorLabel ¶ added in v0.25.0

func (q Question) AnchorLabel() string

AnchorLabel is the badge for a question's line reference: "L42", "L42-L48", or empty when the question is deliberately about something absent.

func (Question) Anchorless ¶ added in v0.25.0

func (q Question) Anchorless() bool

Anchorless reports that the question carries no line anchor. It is now a property of the KIND (file/area/region) rather than a from_line==0 sentinel, so "this question is about the change as a whole, or about something absent from it" is stated in the same vocabulary comments use.

Still distinct from Ungrounded: anchorless is a declared position, ungrounded is a claimed line that does not resolve.

func (Question) EndLine ¶ added in v0.25.0

func (q Question) EndLine() int

EndLine is the line a question trails — the row its inline card renders under. Clamped up to FromLine so a malformed to_line (reachable only from a hand-appended quiz.jsonl line; NormalizeQuiz fixes the write path) never underflows the row key.

func (Question) Jumpable ¶ added in v0.25.0

func (q Question) Jumpable() bool

Jumpable reports whether this question offers a "jump to the code" link — only when it both claims an anchor AND that anchor resolved in the current diff. An ungrounded question must never offer a jump: the link would land on code that has nothing to do with the question.

func (Question) LineAnchored ¶ added in v0.25.0

func (q Question) LineAnchored() bool

LineAnchored reports that the question points at a line range — the kinds the grounding check applies to.

func (Question) LineGrounded ¶ added in v0.25.0

func (q Question) LineGrounded() bool

LineGrounded reports that the question is anchored to a line AND that line resolves in the current diff — i.e. it renders inline under its code rather than at the file head. Its negation is the head set: unanchored kinds and hallucinated (ungrounded) anchors alike lose their inline home.

NOT the same as Jumpable, which is stricter (AnchorStatus == "ok"): an unset AnchorStatus (grounding not yet run) counts as grounded here but is not jumpable, matching every site that partitions head-vs-line by !Ungrounded().

func (Question) Ungrounded ¶ added in v0.25.0

func (q Question) Ungrounded() bool

Ungrounded reports that the question claimed a line range that does not resolve in the current diff — a hallucinated anchor, rendered with a warning.

func (QuizItem) NavState ¶ added in v0.25.0

func (it QuizItem) NavState() string

NavState is the badge state for one question: "correct", "wrong" or "open". Precomputed because a template cannot call a method with arguments.

func (StreamEvent) CommentList ¶

func (e StreamEvent) CommentList() []StreamComment

CommentList returns the event's comment snapshot, or nil for events that carry none (ready / end).

func (StreamEvent) DecisionList ¶ added in v0.17.0

func (e StreamEvent) DecisionList() []StreamDecision

DecisionList returns the event's suggestion-decision snapshot, or nil for events that carry none.

func (Suggestion) AnchorMoved ¶ added in v0.17.0

func (s Suggestion) AnchorMoved() bool

AnchorMoved reports that the suggestion was auto-shifted to follow its target text after the file changed (informational). Parallels Comment.AnchorMoved.

func (Suggestion) AnchorOutdated ¶ added in v0.17.0

func (s Suggestion) AnchorOutdated() bool

AnchorOutdated reports that the suggestion's OriginalText could no longer be confidently located — the reviewer/LLM must re-derive it. Parallels Comment.AnchorOutdated.

func (Suggestion) LineSpan ¶ added in v0.17.0

func (s Suggestion) LineSpan() string

LineSpan renders "L42" / "L42-L48" for the card badge, matching Comment's line-level span (suggestions are always line-anchored).

func (ThreadEntry) When ¶ added in v0.23.0

func (e ThreadEntry) When() string

When renders At as a compact wall-clock time for the card (e.g. "3:04 PM").

func (*TreeNode) DepthStyle ¶ added in v0.13.0

func (n *TreeNode) DepthStyle() template.CSS

DepthStyle is the inline style carrying the node's nesting depth as a CSS custom property the stylesheet multiplies into a left-indent. Typed template.CSS so html/template injects it verbatim (a bare {{.Depth}} in a style="" attribute trips the CSS-context filter).

func (*TreeNode) Ext ¶ added in v0.14.0

func (n *TreeNode) Ext() string

Ext is the extension of a leaf's label (".go", ".tar.gz" → ".gz"), or "" for directories, extensionless names ("Makefile"), and dotfiles whose only dot is leading (".gitignore"). NameStem is the label minus Ext. The drawer renders them as separate spans so a long filename truncates within the stem while the extension stays visible (issue #56). Zero-arg so the template can call them.

func (*TreeNode) NameStem ¶ added in v0.14.0

func (n *TreeNode) NameStem() string

NameStem is the label (full path in the flat list, bare name in the tree) with Ext trimmed off.

func (*VersionStore) Blob ¶ added in v0.18.0

func (s *VersionStore) Blob(sha string) ([]byte, error)

Blob returns the raw content stored under sha.

func (*VersionStore) Checkpoint ¶ added in v0.18.0

func (s *VersionStore) Checkpoint(refs []FileRef, trigger, changelog string) (cp Checkpoint, created bool, err error)

Checkpoint snapshots every ref and appends a timeline entry. Each file is hashed; unchanged content reuses its existing blob (dedup). A ref whose file is absent is recorded as a tombstone (SHA "") rather than failing the whole checkpoint — a deleted file is still restorable state. To keep the timeline meaningful, a checkpoint whose scope is byte-identical to the previous one is skipped (created=false) — EXCEPT the very first (baseline), which always lands.

func (*VersionStore) Checkpoints ¶ added in v0.18.0

func (s *VersionStore) Checkpoints() ([]Checkpoint, error)

Checkpoints returns the full timeline in order. Missing timeline ⇒ empty.

func (*VersionStore) FileHistory ¶ added in v0.18.0

func (s *VersionStore) FileHistory(path string) ([]FileHistoryEntry, error)

FileHistory returns path's timeline: one entry per checkpoint where the file's content changed (or first appeared), oldest first. A tombstone (deletion) is included as an entry with SHA "".

func (*VersionStore) Restore ¶ added in v0.18.0

func (s *VersionStore) Restore(path string, seq int) ([]byte, error)

Restore returns path's content as recorded at checkpoint seq. It returns ErrVersionTombstone when the file was absent at that checkpoint (the caller restores by deleting the working file), and an error when seq is out of range or the path is not in that checkpoint.