Update is the bubbletea entry point: it dispatches to update()'s typed handlers then drains the outbox into a single tea.Println, so lines land in scr

newTestModel wires a model against a mock OpenAI SSE server so we can exercise submit → stream → done without the real stack. The server is torn down

Value returns the prompt text with every chip label expanded to its original content, what goes to the LLM on submit.

String reassembles head + tail. The in-band seam marker keeps the two halves from reading as contiguous; the accurate size report lives in the caller'

Bootstrap returns the config for the current project, creating .codehamr/ and config.yaml on first use. config.yaml is never overwritten; the prompt i

New builds a Client governed by the caller's context, not http.Client.Timeout. That timeout is end-to-end (it covers body reads) and would kill a slow

ActiveProfile returns the selected profile. Bootstrap guarantees c.Active names a real one, so this is a straight map lookup.

stripANSI removes CSI escape sequences (`\x1b[…m`) so tests can match the visible text through glamour's per-word styling, which splits "foo bar" into

appendLine queues a styled line for tea.Println on the next Update cycle, so the terminal, not us, owns the scrollback. scroll is a passive write-only

Chat streams an assistant response on the returned channel, closing it when the stream ends. Reasoning runs at `high` effort by default; if the server

SetValue installs a plain-text value, dropping any chip state. Used by the slash popover's Tab-completion path, where no chip can be injected.

newChippablePrompt returns a realistically-sized promptInput. Width matters: cursor navigation walks the wrapped grid; height is irrelevant here.

pasteKey builds the bracketed-paste KeyMsg bubbletea emits on paste. Paste=true is the flag Update keys off of.

DisplayValue returns the text as shown, chip labels stay collapsed. Used for echo-to-scroll on submit and the ↑/↓ history snapshot.

popoverOpen reports whether the slash-autocomplete popover should render and consume ↑/↓/Tab/Esc.

runSlash dispatches a slash-prefixed submission; unknown commands produce a quiet hint, not an error. config.yaml is re-read before every slash so han

Pack keeps whole messages newest-first until the budget is full, then returns them chronologically. The newest message is always kept, even if it alon

dbgWritef appends one timestamped record. No-op when logging is off. The timestamp carries the date too (not just the clock) so a shared log is unambi

makePaste returns a string with exactly n lines (n-1 newlines).

typeInto feeds text one rune at a time, as a keyboard would, exercising the refreshSuggest hook on the KeyRunes fall-through.

View renders only the live bottom region: in-flight streaming tokens, the popover, a divider, the prompt, and the status bar. Everything else has alre

setCursorRuneOffset moves the cursor to an absolute rune position. textarea has no (row, col) setter, so we step CursorUp/Down to the target row then

Bash runs one shell command through /bin/sh -c and returns combined stdout+stderr. Non-zero exit is not an error; the model sees the failure and react

EditFile replaces old_string with new_string in path. old_string must match EXACTLY ONCE; otherwise the file is untouched and an error string is retur

Execute runs a tool call and returns the (possibly truncated) result ready to be appended to the conversation as a `tool` message.

hashOf returns the sha256 hex digest, matching goreleaser's manifest format.

installTurnContext cancels any in-flight turn context and installs a fresh per-turn root on m.turnCtx / m.cancel. Cancel-old-then-install-new keeps Ct

sseOK writes an OpenAI-style streamed response plus a [DONE] terminator. The budget header travels on the 200 like in production.

submit commits a user prompt. sendText is the expanded form sent to the LLM (chip labels replaced by their original paste content); echoText is the co

loadPromptHistory returns every saved prompt oldest-first, matching the in-memory append order so historyUp/Down walk the same direction for typed and

ResolvedKey returns the profile's key, expanding it against the process environment when the WHOLE key is a `${VAR}` reference (the advertised form; s

Save rewrites config.yaml.

appendPromptHistory writes value as one more entry, trimming to historyMaxEntries to bound growth. Empty prompts are skipped so stray ↵ presses don't

countSystem counts RoleSystem messages, the shape every nudge appends.

Reset clears the typed text and all chip state. nextID is preserved so ids stay monotonic within a session.

Tokens approximates token count as char/4, good enough for budgeting.

handleProbe consumes an activation-time Probe result. Success stores the live context window and prints the activation line; failure surfaces the erro

handleStream dispatches one llm.Event to the matching apply* helper and re-arms the stream reader; EventError unwinds the turn instead of looping. Eve

handleStreamClosed drives what happens after one round's stream finishes: dispatch the next pending tool call, or, if none, finalize the turn and hand

platformAsset is the asset name Apply expects for the current runtime, via the same assetName helper production uses.

withReleaseURLs swaps checksumsURL and releaseBase for one test; safe only because these tests don't run in parallel.

Apply downloads the current platform's binary, verifies its sha256 against the published codehamr_checksums.txt, and atomically replaces execPath. The

drain advances the model until no async commands remain, a synchronous bubbletea mini-runtime. tea.BatchMsg arrives when Update wraps multiple Cmds (e

wrapForScrollback hard-wraps every line of s to the terminal width before it goes to tea.Println. bubbletea's standard renderer dumps queued Println l

sendEvent puts e on out, bailing if parent cancels first, so a slow or vanished consumer after Ctrl+C can't wedge the stream goroutine on a full buffe

ActiveURL is the endpoint every dial-out uses: the runtime override if set, else the active profile's URL. Use this over ActiveProfile().URL so CODEHA

InlineStatus is the one-liner the TUI prints per tool call.

WriteFile writes content to path, creating parent dirs. Errors return as part of the output string (bash convention), never as a Go error, so the mode

recomputeLayout caps the textarea height so a long paste can't push the status bar off-screen: leave minViewport rows of breathing room above it. Chea

ReadFile returns path's contents, truncated to the shared tool-output budget (Truncate). The model gets exact bytes, not a shell-mangled approximation

appendStatus wraps one segment in styleStatus and appends it, keeping renderStatusBar readable instead of repeating the wrap at each call site.

assetName mirrors the name_template in .goreleaser.yaml. Every goos goreleaser builds for must have a case here; a missing one silently locks that pla

maybeRunawayNudge appends one soft system note when a turn crosses maxToolRounds tool calls without finishing. The runawayNudged latch fires it exactl

setPromptText overwrites the textarea, parks the cursor at the end, and refreshes the popover. Centralises the SetValue + CursorEnd + refreshSuggest d

Budget subtracts the fixed reservations from the total context size, then leaves a headroom margin (see budgetHeadroomDivisor) so a char/4 undercount

FromHeaders reads the budget header. Missing (e.g. local Ollama) yields the zero value and the UI skips the segment. Out-of-range values are clamped,

SetActive switches the active profile and persists. Fails on an unknown name, no silent coercion. On Save failure it reverts in-memory Active so the l

activeContextSize returns the context window the packer should aim at: the live server-reported value for the active profile if known, else the on-dis

backendLabel renders the connection signal. Connected: profile name, bold, no colour. Disconnected: bold yellow plus a `!` marker, so the state stays

cursorRuneOffset returns the cursor as an absolute rune index into Value(). textarea only exposes (row, col) plus LineInfo, so we reconstruct it by wa

endTurn zeroes per-turn state after a turn finishes or aborts. Pair to beginTurn. Cancels the per-turn context unconditionally to release the CancelFu

maxTextareaHeight caps the textarea: terminal minus chrome, breathing room, the active popover, and the queued-prompt box. Shared by recomputeLayout a

recordAndNudge replays Update's toolResultMsg "queue drained" branch: record the outcome, then consider the failure nudge. Lets the streak tests exerc

toolCallLeakWarning returns a user-facing diagnostic when the newest assistant message carries a tool-call opener (`<tool_call>`) in its text instead

visualPromptLines counts the *visual* rows the textarea needs (a line that wraps to three screen rows wants a three-row textarea), via wrapRows which

Check reports whether the local binary's sha256 differs from the remote asset's recorded hash. ctx propagates a startup Ctrl+C into the HTTP request.

CleanupOld removes the execPath+".old" left by a previous Apply. Run at the start of the next launch: on Windows the .old is locked for the prior proc

EnsureHamrpass returns the hamrpass profile, re-creating it from the seed if the user deleted it. Lets /hamrpass activate by pasting a key without a r

ModelNames returns the profile names sorted, so the popover cycles deterministically regardless of map iteration order.

OpenDebugLog truncates <dir>/log.txt and opens it for writing. On failure it reports once on stderr and disables logging: the log must never block the

Restore replays a history entry: sets the display text, installs the snapshot's chip state, drops the cursor at the end.

StatusSuffix builds the " · 73% pass" status-bar tail; "" before the first snapshot. Rounded to nearest percent so it doesn't jitter on every token.

applyDone closes one LLM round: harvest the live context window, accumulate turn/session tokens, append the assistant message, flush streaming. A turn

chipAtBoundary returns the chip whose start (atStart=true) or end (atStart=false) coincides with cur, the check Backspace/Delete/Left/Right share.

commandByName returns the registered command for a slash name, or nil. Centralises the linear scan shared by completion, dispatch, and runSlash.

dbgEnabled reports whether logging is on. Callers use it to skip building expensive log payloads (e.g. accumulating a round's reasoning) when the log

errorMessage maps a stream error into a one-line TUI hint, same format across all profiles.

finalizeTurn freezes the finished turn's wall-clock summary into the status bar (shown at idle until the next submit) and logs the totals. outcome is

humanTokens renders a token count compactly: `900 tok`, `1.2k tok`, `1.5M tok`. The k/M ranges always keep one decimal (`2.0k`, not `2k`) so the live

maybeVerifyNudge appends one re-grounding system note when a substantial turn (>= verifyNudgeMinRounds tool calls) is about to finish with a clean, no

popoverMoveSelection wraps the selection index modulo the filtered list.

readEvent drains one event from the LLM stream as a tea.Msg, re-scheduled until the channel closes. Tags ch so Update can spot stale prior-turn events

renderPopover draws the suggestion list: value flush left, description right aligned, one row each. Selection is a colour change (stylePopoverSelected

schemaToTool unwraps a tool schema (the map[string]any shape shared by bash and the file tools) into the typed llm.Tool the chat payload expects.

snapCursorOutOfChip snaps a cursor sitting strictly inside a chip to the nearer boundary. Returns the (possibly adjusted) offset so callers skip a sec