Coding Sessions

A session is a live conversation with Claude Code running inside a cloud VM. You send messages, Claude writes code, and you see changes in real time.

Starting a Session

There are two ways to start a session:

• Create a task with a prompt. The session starts automatically.
• Open an existing task and start a new session from the task detail view.

When a session starts, Wallfacer boots a VM from your environment's snapshot or from a fresh image (which takes longer if no snapshot exists). Once the VM is ready, Claude Code is running and waiting for instructions.

Waiting for a Machine

Sometimes no machine is free when a session asks for one. The session parks in a waiting state and retries on its own, and the chat screen says so rather than showing an indefinite "Starting up". A Waiting for a machine notice sits above the composer with a counter for how long the wait has run, and explains that every machine is busy and the session starts as soon as one frees up.

The composer stays live while you wait, because queueing more instructions is legitimate. Anything you send reads Queued -- waiting for a machine and delivers in order once the session starts.

If capacity never frees up, the platform stops retrying rather than leaving the session queued forever. It retries for over an hour and then closes the session, and a wait that outlives any retry schedule is closed by a sweep instead. Either way the notice becomes No machine was available with the platform's own explanation of what happened, and you get a notification.

Both of those closes are resumable. Send another message and the session starts a fresh attempt.

Task Setup and Recent Activity on iPhone

On iPhone, Wallfacer shows the current system step, such as preparing a VM or Git branch, in the task header. The chat does not repeat that system status. Agent startup and thinking belong to the turn's activity indicator in the chat.

While a system status is visible, tap it to open System activity. The popover shows the five most recently received system updates for the selected session, newest first, with each update's state and receive time. Progress and completion updates for the same step appear as separate rows. New updates do not close an open popover, and reopening the task does not add copies of the same fetched status. This recent history is held in the app's memory and clears when the app relaunches.

On iPad, Android, and web, system status remains in the chat rather than the iPhone task header.

Task Updates on iPhone, iPad, and Android

While a task screen is in front, the app checks its session status and transcript for updates. If you open another task, the earlier screen stops those checks. Return to it to refresh its current status and messages. Realtime updates continue while the screen is behind another task.

When a Machine Fails

A chat turn can retry twice on fresh VMs after a machine failure. Its session returns to waiting between attempts, with the transcript preserved. If the retry budget is spent, the session closes with close_reason: vm_failed; error_message names the underlying cause. A VM failure during an active session between turns closes that session. An already idle session does not enter this recovery path.

During a playbook action, the failed session closes immediately with close_reason: vm_failed. The step can still retry in a new session, so inspect the task's retry status before treating the action as finished. A VM failure while the step awaits a person's answer fails the action and follows its configured failure route.

The Chat Interface

Type messages in the input at the bottom of the screen. Cmd+Enter (or Enter) to send. On iPhone Duo, the composer stays above the software keyboard when you reopen an existing task or show or hide the sidebar.

For a conversation that started outside the app, the banner names the channel that owns replies. When Wallfacer knows the other person's identity, it also shows a With line. For email, this reads Name <address> when the sender has a name, or just the address otherwise. Other channels use the name that channel knows. This text is not a link. When the person is unknown, including in conversations recorded before this field existed, the banner names only the channel. The session API provides the label in send_restriction.counterpart and, when the agent opened the conversation, in conversation_opening.counterpart.

Claude's responses render as rich content:

• Text explanations with headings, lists, task lists, tables, and linked URLs
• Code blocks with syntax highlighting and a Copy code action
• File operations (create, edit, delete)
• Tool use results (terminal commands, file reads, search results)

Shell commands during a turn

An agent can run shell commands in its session computer, including builds and test suites that take longer than a single tool request. Wallfacer keeps a running command active across the request boundary and returns its final output to the agent as the result of the original tool call. The agent does not need to start or collect a separate job. The turn's activity shows the command while it runs.

The command's configured timeout still applies. If it expires, Wallfacer stops the command and reports the timeout to the agent. Interrupting the turn or closing the session also stops a running command. Large tool outputs may appear as size-labeled placeholders in the chat transcript; see Large images and payloads.

Answer bubbles and artifact cards

A final agent answer groups consecutive paragraphs into rounded text bubbles. Short answers fit their text, while long bubbles leave a narrow margin between the message and the edge of the transcript. Bubble colors adjust with the light or dark theme.

Pull request, issue, screenshot, and code cards stay outside the bubbles in the order the agent placed them. Text after a card starts a new bubble. Thinking, tool activity, the byline, message actions, and turn details also remain outside the answer bubbles.

A code card previews the first eight lines. Select View code to open the complete block in a tall tray, scroll through it, copy it with Copy code, or dismiss it with Close code.

Messages are laid out by who wrote them. Your own messages sit on the right. Everyone else's, another account member, an agent, or someone writing in from a connected Slack channel, sit on the left with their name and avatar, so a thread with more than one participant reads without guesswork.

Attach an image to a message with the + button next to the composer. See Task Attachments for the sources available on each platform.

Three dots orbit beside the turn's Thoughts chip while the agent works. Their motion stays continuous as startup gives way to active work, and updates from another session on the same task do not change the indicator for the session you have open. The chip shows a work verb and elapsed time while the turn runs. A finished turn's dots settle into a triangle; only the newest completed turn keeps moving. An interrupted turn shows Interrupted. Wait for the turn to finish before evaluating the result; the agent may make several changes in sequence.

Tap Thoughts to read the turn's intermediate activity. On web it expands below the chip; on iPhone, iPad, and Android it opens in a sheet. Tool work collapses into activity lines: one line per call, and a summary line such as ran 3 commands, changed 2 files for a run of them. Tap a line to read the detail behind it. On web it opens under the line; on iPhone, iPad, and Android it opens in a sheet titled with the line you tapped, so the conversation stays where it was.

Who answered and what it cost

A finished turn is signed under the answer with the avatar and first name of the agent that ran it. The turn's own details sit behind that byline: the agent's full name, the coding agent and model behind it, the reasoning effort, the subscription seat billed when a seat rather than an API key paid for it, the tokens used, the API cost, and the time the turn was sent. A fact the vendor does not report is left out rather than shown as zero.

• On iPhone, iPad, and Android, tap the agent's name or avatar under the answer. A turn that names no agent prints no byline and shows its timestamp there instead, and that opens the same details.
• On web, the byline is not a trigger: hover the timestamp under the answer.

Phone and tablet transcripts print no timestamp line under each answer. To see when messages were sent, drag the transcript to the left: every row slides over and shows its time in the gutter that opens on the right.

Sub-Tasks

An agent can hand part of a job to a sub-task: a second run it briefs and then waits on. The brief is machine-to-machine traffic rather than a message to you, so the transcript shows it as one collapsed line in the same muted style as tool activity, labeled with the kind of sub-task and what it was asked to do (for example, → Explore sub-task: Compare the seeded users). Tap the line to read the full brief, and tap again to collapse it.

Dictating a Message

Tap the microphone beside the composer to dictate instead of typing. Your words appear in the composer as you speak, and tapping the button again stops the recording and leaves the text there to edit before you send it. In a browser, Ctrl+D toggles dictation from the keyboard.

Dictation keeps listening through pauses, so stopping to think does not end the recording. It runs until you stop it, or until a five-minute limit it warns you about 30 seconds ahead. The iPhone and iPad composer keeps the microphone available beside a draft, so dictating there appends to what you typed rather than replacing it.

On iPhone and iPad the composer shows a live waveform, the elapsed time, and a stop button on one row while you dictate. Other platforms show a compact recording indicator beside the microphone. Dictation is available on iOS, Android, and browsers with speech recognition, which excludes Firefox, and is not available in the desktop app. The first use asks for microphone permission.

Links to Issues and Pull Requests

A GitHub issue or pull request link in an agent's message renders as a card after its paragraph instead of a bare URL. The card stays outside the answer's text bubble and carries the title, an owner/repo · #number line, and the state: Open or Closed for an issue, and Open, Draft, Merged, or Closed for a pull request. View issue and View PR open it, in Wallfacer when the task attached it and on GitHub otherwise.

The title and the state come from the copy Wallfacer already holds as an attachment on the task. A link to something the task never attached still renders as a card with its repo and number, without a title or a state.

When a Tool or File Operation Fails

A failed operation does not turn its row red or print the error into the conversation. The row keeps its ordinary icon and label, and a small red exclamation sits after the label. Tap the exclamation to read the operation's output: in a browser it opens a card under the row, and on a phone or tablet it opens an Error output sheet, so a long error does not push the conversation off the screen.

The collapsed activity summary counts the failures, reading "used 4 tools" with a trailing "1 error" in the same muted text as the rest of the line. Expand it to find the row the exclamation is on.

Copying a Message, or a Link to One

On iOS and Android, long-press an agent message's text to open its message action sheet. Choose Copy Message to copy the full answer, Select Text to copy part of it, or Share to open your device's share sheet. Copy Message Link appears when the message has a link. Share uses that link when available and the message text otherwise.

Select Text opens the message as readable plain text in a read-only, scrollable view. It keeps paragraph breaks, removes Markdown formatting, link markup, and inline HTML, and decodes common HTML entities. Use your device's selection handles and Copy to take a word or a passage across paragraphs, then dismiss the view to return to the conversation. Copy Message and Share behave as before. Long-pressing the original message text opens the action sheet without a second text selection menu. Tapping a link or attachment still opens it as usual.

In a browser, agent answers keep Copy Message and Copy Message Link in the footer beside the agent's name. Copy Message copies the answer's text. Copy Message Link copies a link to that message. Opening the link goes to the task and scrolls to the message, loading older history until it finds it. If the message is no longer in the task, the transcript says so at the top.

In a browser your own messages carry the same pair beside their timestamp, shown when you hover over the message or reach it with the keyboard. Other members' messages show their timestamp only. A message still queued to send has no link yet, because it has no id until the server accepts it.

Large images and payloads

A transcript loads a trimmed copy of each message so a screenshot-heavy task opens quickly. Large images and oversize tool inputs and outputs are not sent with the message; the transcript shows them in place as a labeled placeholder with the size that was left out, such as [82 KB elided], and a sized grey tile for an image or screenshot. Everything else, including the text of the message and the structure of the tool call, arrives as usual, and the transcript keeps filling in live while you read it.

Where the Chat Opens

Reopening a session puts you where you left off, not at the top of the history. If you have unread turns, the chat opens at the New divider, the line that marks the first message you haven't seen. If you're caught up, it opens at the latest turn.

Scrolling up into the history stops the chat from following new messages, so you can read without being pulled back down. Scroll to the bottom again to resume following.

Message Queue

Messages you send while Claude is responding are queued. They're delivered automatically when Claude finishes the current turn.

This also applies during VM boot. Type your follow-up while the VM is still starting. It will be delivered as soon as the session is active.

If a turn is interrupted before it finishes, either because you stopped it or the session was interrupted, your queued messages are not dropped. They stay queued and deliver when you resume the session.

A queued message reads like any other message you have sent, with a Queued chip marking it as not yet delivered. You can remove one before it goes out: on the web, hover the message and click the X that appears; on your phone, long-press it and choose Delete. Once a message has been delivered to the agent it can no longer be deleted, and the control is gone.

When a Send Fails

A dropped connection doesn't cost you the message. If sending a message, changing a task, or attaching a file fails because the network blipped, the app retries it twice on its own before telling you anything.

If it still fails, an alert appears with Cancel and Retry, and it names what actually went wrong: your device is offline, your device is online and Wallfacer could not be reached, or the request timed out and may still have gone through. The alert carries a short reference that identifies the failure in our records, worth quoting if you write to us about it.

Retry repeats the same action, so you don't retype the message or reselect the attachment, and attachments that already uploaded aren't uploaded again. Cancel keeps your work: the message you typed and the images you attached go back into the composer instead of being discarded. The same holds when the app refuses a send outright, for example while an agent's computer is still starting.

Retrying is safe. Each write carries a key the API uses to recognize a repeat, so a message that did get through the first time isn't sent twice. Rejected requests and permission errors are not retried; they show the server's message with a single OK. A rate-limit refusal instead shows Too many requests with an estimated wait and no Retry button. The limit clears on its own.

That key stops being usable after ten minutes. A retry the app scheduled for itself, such as a send that failed while you were offline and was still waiting when you left the app, only goes out if it runs inside that window. Later than that, the app can no longer tell a send that never left from one whose reply was lost, so it refuses the attempt instead of risking a second copy of your message: you get "We could not confirm this went through, so it was not sent again. Check the conversation before sending it again.", and your text goes back in the message box. Pressing Retry yourself, or sending from the message box again, counts as a new send and is never refused this way.

While your device is offline, the app pauses work instead of retrying it. See Notifications for what happens offline and on reconnect.

Idling and Resuming

Sessions default to a 5-minute idle timeout, configurable between 60 and 900 seconds when you create the task or session. When the timeout elapses, Wallfacer marks the session idle and destroys the VM to release resources.

Send a new message to reactivate an idle session. Wallfacer boots a fresh VM from the environment snapshot, restores the transcript, and delivers the queued message when the session is active again. On iOS and Android, you can send that message straight from the session's idle push notification without opening the app. See Notifications.

When the agent's conversation state cannot be restored, the session still runs. The first turn in the fresh conversation may answer without recall of earlier turns. On the following turn, Wallfacer includes the missing person messages and agent text from the task history in the agent's prompt. The task history remains readable in the session. Tool calls, tool results, and analysis are not replayed, so check the task history or workspace before repeating an earlier external action.

Closing a Session

Close a session to release VM resources when an attempt is done. Conversation history remains available in the task, and sending a new message can reactivate the session when the platform can safely do so.

Snapshots make re-opening faster than a fresh setup, but failed environments, missing capacity, or terminal session failures can still block a resume.