CloseDebugLog flushes and closes the log. Idempotent.

ContextWindowFromHeaders reads X-Context-Window. Returns 0 when missing, malformed, or out of sane range; the caller reads 0 as "use the fallback". Lo

Entry snapshots state for the history buffer, cloning store and spans so later edits to the live promptInput don't mutate the recorded entry.

Reachable GETs baseURL/v1/models with ctx as deadline; any HTTP response (even 401/404) counts as reachable, only transport errors/timeouts don't. Bac

Truncate collapses oversized tool outputs to first 2k + last 2k tokens; inputs at or under 6k pass through unchanged. Head/tail can't overlap: >6k tok

chipLabel is the visible form inserted into the textarea. Plain text, no ANSI, since textarea doesn't render inline styling inside its value.

clearPromptHistory removes the on-disk file so /clear also wipes recall. A missing file is not an error: the empty-history intent already holds.

countCmdLeaves runs cmd, recurses into the slice-shaped []tea.Cmd payload of tea.BatchMsg / tea.sequenceMsg (both unexported), and counts leaves where

drainFinal submits a prompt and pumps the whole turn to completion, returning the settled model. Centralises the submit+drain dance the empty-reply te

fetchHash downloads codehamr_checksums.txt and returns the hash for asset. The manifest is one line per asset, "<hex-sha256> <filename>"; we match th

flushStreaming ends the content phase: render the streaming buffer through glamour, queue it for tea.Println, reset. No-op on an empty buffer. Glamour

forwardToTextarea passes msg to the textarea and refreshes the popover to match. The "let the textarea handle it" fallback shared by handleKey, handle

hamrpassValidate is the single source of truth for whether a key is acceptable and what the UI says about it. Shared by the inline /hamrpass handler a

humanRate renders throughput: `25 tok/s`, `5.3 tok/s`. Returns "" on degenerate input (no tokens or zero elapsed) so the caller omits the segment. Sub

liveElapsed renders a running wall-clock duration for the status bar: whole seconds under a minute (no sub-second decimal spinning at the spinner's re

mkfifo creates a FIFO in a temp dir; opening it for read OR write would block forever with no peer, which is exactly what the guards must prevent.

newPromptInput builds the configured textarea and chip bookkeeping. All styling lives here so model.go never touches textarea internals directly.

rebuildClient swaps in a fresh llm.Client for the now-active profile. Replacing the pointer (not mutating fields) drops the prior Client's sticky stat

reconcile re-finds each chip's label in the value (searching past the prior span's end) and updates offsets. A span whose label has vanished (e.g. par

timeoutC bounds the hang these tests exist to catch, well under go test's own package timeout so a regression fails fast with a named cause.

toolTargetKey is the stable identity used to detect a repeated-failure loop: tool name + its target (the path for file tools, the command's first line

AuthHeader returns the Bearer header a cloud-routed request needs.

EditFileSchema is the OpenAI tool definition for edit_file. The description steers the model toward edit_file over write_file for small changes so it

PrintHelp writes the canonical human-readable command list. Used by --help.

Probe sends a minimal hello chat just to harvest response headers in one round trip: status validates the URL/model/key combo, X-Context-Window gives

ReadFileSchema is the OpenAI tool definition for read_file. The description nudges the model toward read_file over `cat` so it stops piping source thr

ResponseReserve is the slice Budget keeps free for the model's response. Scales as ctxSize/8 so reasoning models get room (262k→32k, 1M→125k), floored

abortTurn winds down a turn that did not complete normally: flush in-flight text so the partial block lands in scrollback, post the explanatory banner

assetNameSupported returns the set of platforms assetName resolves, with their names. It probes a generous candidate universe UNION the matrix's own v

buildTools exposes the four local tools every turn: bash, read_file, write_file, edit_file. No loop/control tool; a turn ends when the model stops emi

confirmActive emits the activation line for the active profile and returns its reachability cmd. Keyed profiles (cloud) probe: the success line is del

countLines returns a paste's visual line count. Terminals disagree on separators (\n unix, \r old-mac, \r\n Windows); max of the \n and \r counts hand

dbgWriteMessage records a chmctx.Message readably: content and tool calls each get a labeled section. No-op when logging is off, so callers needn't gu

deleteSpan removes the chip's label from the value and drops it from spans and store. Cursor lands at the vacated start; reconcile re-validates later

dispatchNextTool pops the next pending tool call and runs it. Every tool flows through runToolCall; none are special-cased. lastToolKey records this c

doPost performs one round-trip, mapping status into the typed cloud errors Probe and sendChat share. On 200 it returns the live response with body ope

dropDanglingToolCalls removes any assistant message whose tool_calls include an id with no answering tool message in the kept slice: the mirror of dro

dropOrphanTools removes tool messages that are not part of the contiguous tool run answering the assistant directly before them: sending one alone 400

droppedBytes is how many middle bytes the ring discarded; 0 while the whole output still fits head+tail.

goreleaserMatrix is the source of truth: every os/arch goreleaser builds for.

humanInt formats a non-negative integer with commas so a context window like 262144 reads as "262,144" rather than a wall of digits.

idleTimeoutFromEnv resolves CODEHAMR_IDLE_TIMEOUT to a duration, falling back to streamIdleTimeout when unset or unparseable. Accepts a Go duration st

isHex reports whether s is non-empty lowercase hex, the shape of a git abbreviated commit hash.

isLocalBuild reports whether the binary came from a working tree rather than an official release. `go run` leaves version "dev"; `make install` inject

maybeFailureNudge appends one system-role note once the same target has failed maxToolFailStreak times running, then resets the streak so it fires at

newestAssistantEmpty reports whether the turn's final assistant message carried neither text nor a structured tool call. A clean finish always has a s

pingBackend issues a short GET to baseURL/v1/models via cloud.Reachable. Any HTTP response counts as reachable; transport errors and timeouts mean dis

popoverHeight is the rows the popover occupies in View(): 0 when closed, capped at popoverCap to leave the viewport breathing room.

postChat dispatches via doPost; on a 400 rejecting reasoning it drops reasoning_effort for this Client's lifetime and retries once. Two wild flavours,

probeBackend wraps llm.Client.Probe in a tea.Cmd, bounded by probeTimeout so a hung backend never freezes activation. silent=true (startup probe) skip

recordToolOutcome updates the failure streak from one finished tool result. A success (or a failure of a different target) resets the streak; a same-

redactSlash strips the /hamrpass <key> bearer token before it lands in any log. A central hook covers any future secret-bearing command from one place

refreshSuggest recomputes the popover from the textarea: command level before the first space, argument level after it.

reloadConfigFromDisk re-runs config.Bootstrap and replaces m.cfg so hand-edits to config.yaml between slash commands take effect immediately. URLOverr

renderQueued draws the pending-prompt box shown above the divider while a turn runs: a faint title line plus a rounded panel with the collapsed echo,

runToolCall executes one tool call off the UI goroutine. parent is the per-turn root: Ctrl+C aborts the tool mid-run, and the toolResultMsg carries th

runTurn wires a model against handler, submits `text`, drains the command chain, and returns the Model. token, when non-empty, is installed on both th

runeIndex is a rune-level strings.Index: first occurrence of needle in haystack, or -1. promptInput works in runes throughout because textarea's curso

setPopover swaps in a new suggestion set. Selection priority: the current row (e.g. active profile), else the first.

splashLines builds the identity block for tea.Println. Below wordmarkWidth the ASCII art soft-wraps into garbage, so collapse to plain text.

toolResultFailed reports whether a tool result is an error the model should react to. File tools wrap errors in parens ("(write error: ...)", "(not fo

typeChars feeds each rune of s as a separate KeyMsg, rendering View() after each. Non-cosmetic: the viewport only populates its `lines` slice (and thu

wrapRows mirrors bubbles/textarea.wrap()'s row count so the prompt's auto-grow stays in lock step with what the textarea renders: word-boundary aware

BashSchema is the OpenAI tool definition for bash, exposed by every profile.

IsCloudProfile reports whether a profile's context_size is server-managed.

WriteFileSchema is the OpenAI tool definition for write_file. The description steers the model away from bash heredocs (shell-quoting failure mode) fo

activateHamrpass writes the key onto the hamrpass profile (seeding the entry if the user removed it from config.yaml), switches active, rebuilds the c

anchorUserMessage guarantees the packed window carries a user-role message whenever history has one. The newest-first walk drops oldest-first, so a lo

appendUserTurn appends a user-role message to history and starts a turn. The only path that does so; used by submit.

applyContent writes one streamed text chunk to the live buffer and promotes phase from thinking to streaming on the first chunk so the status bar show

applyEnvOverrides folds runtime env vars into cfg. CODEHAMR_URL overrides the active profile's URL (devcontainers / CI), held on a non-serialised fiel

applyError unwinds the turn on a stream error: preserve content streamed before the error (so the user keeps failure context), emit the one-line hint,

applyToolCall queues a streamed tool call for later dispatch. flushStreaming up front commits this round's text to scroll before the inline tool-call

beginTurn installs a fresh per-turn context, flips phase to thinking, and returns the chat stream-reader Cmd. Every path starting a new LLM round funn

buildSystem appends the working-directory anchor to the embedded system prompt so "hier" / "here" resolves to a concrete path.

countHistoryLines tallies lines without parsing them: fast path for the trim decision in appendPromptHistory.

currentSuggestion returns the highlighted popover row, or false when the popover is closed or empty.

cursorOnFirstLine: true when ↑ should walk prompt history instead of moving the textarea's own cursor. cursorOnLastLine is the mirror for ↓.

dbgWriteRequest records, per LLM round, what newest-first packing actually sent: how much of history survived the budget and how many tool outputs are

dbgWriteSession records the active backend and context budget once at startup. Behaviour differs sharply by model (different model families fail in di

demoteSystemMessages rewrites every system-role message in the packed history to a user message. buildMessages always prepends the embedded system pro

differsOnlyInWhitespace reports whether oldString matches content at exactly one spot once every whitespace run is collapsed: i.e. the sole mismatch i

dispatchDelta forwards reasoning and content as events, then accumulates streamed tool-call fragments into index-keyed slots. Reasoning stays out of f

errorMessageFromBody extracts the user-facing string from a non-2xx body. hamrpass wraps errors as `{"error":{"message":...,"provider_hint":...}}`; we