Interactive console

Enter prompts, objects and your own R

Ask in ordinary language. @x attaches a visible R object by name, and @analysis.R adds the beginning of a text file. Quote a path containing spaces as @"analysis notes.txt". Files take precedence when a mention matches both a file and an object. A file mention sends at most its first 40 lines; binary files contribute a description rather than their contents. For a larger file, ask the agent to read the relevant section.

peter> Compare @mtcars columns mpg and wt.
peter> Explain the approach in @analysis.R.
peter> !head(mtcars[, c("mpg", "wt")])
peter> Now suggest a diagnostic plot.

!code runs your R code immediately in the console environment, prints its output and adds a compact note of the code and output to the next model prompt. It does not send a prompt or spend model tokens by itself. The note is bounded to about 300 estimated tokens, so inspect large results in R and send the part the model needs.

!!code also runs immediately, but does not add that code/output note. Changes it makes are still part of the workspace that later calls can inspect or describe. Neither prefix passes through the model’s permission gate: you are explicitly running your own R code. Do not paste unreviewed code merely because the agent suggested it.

In terminal R with readline, R in an IDE’s Terminal tab included, Tab completes R names and file paths after ! and !!. RStudio’s console completes R code at peter> too; radian and Positron’s console offer no completion there.

peter> !fit = lm(mpg ~ wt, data = mtcars)
peter> !coef(fit)
peter> Explain the slope I just fitted.
peter> !!local_note = "Check the measurement units later"

For multiple lines, use a triple-quoted prompt, a trailing backslash to continue a prompt, or a fenced R block. A fence marked r, R, {r} or unmarked behaves like !code; any other fence, such as one marked python, is sent as prompt text. Incomplete !/!! R expressions continue at the + prompt until they parse. Very long single lines can exceed R’s console input limit; use an @file or a multiline prompt instead.

In CRAN’s R for macOS in a terminal a pasted block is one input: its lines join the first one and ... waits for Enter, where text you type is added. A pasted fence or """ block is read up to its closer at once, and a block pasted at an approval or a choice is dropped and the question asked again. A last pasted line without a newline waits for Enter at the next prompt, so a two-line paste without a final newline answers with its first line. Homebrew or conda R, Linux terminals, RStudio, R.app, Positron and Windows deliver pasted lines one at a time, so wrap a multi-line paste in """ there. Lines typed, pasted or run from a script before a question appears (an approval, a choice, the pause menu) are discarded and never answer it; answer after the prompt.

peter> """
... Fit mpg on wt.
... Explain the units and give one diagnostic.
... """

peter> ```r
... fit = lm(mpg ~ wt, data = mtcars)
... coef(fit)
... ```

These input forms apply inside Peter’s chat; at the ordinary R prompt, use normal R syntax. Console inputs may enter R’s history (gptr.history), and an enabled transcript can record user-run code. !! is a control over the next prompt note, not a privacy boundary.

Commands

These are all built-in slash commands. Arguments in brackets are optional. /help lists the commands available in the current session, including any supplied by plugins or prompt templates.

Undo and rewind report partial restores when something cannot be captured or restored. External side effects are not generally reversible. See ?gptr_rewind and ?gptr_security before relying on restoration.

Approve, interrupt and continue

In manual, known read-only actions and actions covered by existing allow rules run directly; other changes ask for approval. The prompt lists the flagged calls, riskiest first (at most five; ? shows all), and offers y for this action, a for a session rule covering them when one can be written, n to deny, and ? for details. A sub-agent’s prompt starts with its name (sub-agent A > r ...); an answer that is none of these is explained, and five such answers refuse the action. edits allows project file edits while still asking about R changes unless an allow rule applies; auto allows ordinary actions while retaining critical and secret guards. plan offers read-only tools and level-1 R exploration in a scratch environment, where intermediate bindings can change while the user workspace is preserved. Settings and policies are described in Configuration and ?gptr_security.

In a terminal (terminal R or an IDE’s Terminal tab; not Windows), a line you type while an answer runs steers it: the agent reads it at its next step, after the current tool results, and gptr confirms with [gptr] steering: '<text>'. Lines typed or pasted together are one message. The terminal does not echo while an answer runs: a typed line shows after Enter, in gptr’s notice, and never mixes into the answer. gptr_config(type_ahead = "follow_up", .scope = "user") queues them for when the agent would otherwise stop instead. /commands and !code typed during an answer run at the next prompt; an interrupt drops them. On the CLI routes (claude-cli, codex) a steer reaches the model after the CLI’s current response. The RStudio, Positron and R.app consoles hold typed input until R reads again, so there a line typed during an answer becomes the next prompt; type-ahead during peter("...") at R’s prompt stays R’s next input.

While an answer or tool runs in a supported terminal, Ctrl-C opens a pause menu:

• Steer delivers a new instruction after the current tool results.
• Follow-up queues a prompt for when the agent would otherwise stop.
• Continue resumes the current work.
• Abort stops it and retains the partial session.

A foreground call, including a chat turn, can also offer background when that experimental capability is available. It returns to peter> while the run remains active. Another prompt steers the running session; !!gptr::gptr_wait(gptr::gptr_last()) waits for completion without adding a code/output note to the next prompt. Returning to the chat prompt does not guarantee progress while it waits for input. Under Rscript, background runs advance only inside blocking gptr calls. Inline R tools still occupy the same R process while they execute.

At the chat prompt, one interrupt prints a hint; two consecutive interrupts leave the chat. Use Ctrl-C in a terminal, an IDE’s Terminal tab included, and the front end’s interrupt key in an IDE console: Esc in RStudio, R.app, RGui and Positron. IDEs that cannot resume an interrupted evaluation use an abort fallback; pause/resume behavior is not uniformly verified across front ends.

The equivalent session verbs work from R:

gptr_steer(session, "Use the existing fit instead of fitting again.")
gptr_steer(session, "Summarize the diagnostics at the end.", as = "follow_up")
gptr_wait(session)
gptr_cancel(session)

For persistent conversation storage, initialize a project with gptr_init(path) and review its trust decision. gptr_sessions() lists stored sessions, and gptr_resume(id) recovers one. Script as history covers document recording, replay and transcripts; Language models covers scripted calls that need no interactive console.