Commands Oda runs

While DataMind Oda works on a task, it sometimes runs commands on your computer, in Bash or PowerShell. Each one appears in your chat as a step row: a one-line summary to scan, and a terminal card to expand for the output. This page covers those rows and cards; your own terminal in the side panel is a separate surface, described in The terminal.

What the row shows

• The collapsed row carries a one-line summary: the short description Oda writes for the command, or the command itself when no description is recorded.
• While the command runs, the row shows a running state. When it settles, the row shows how it ended: a command that ended with a non-zero exit code or a signal is shown as failed, even though the step itself settled.
• The row also carries its state as hidden text for screen readers: running, failed or stopped.
• The row is one step of the task; the general model of step rows is described in Oda's steps and tool results.

Expand the command

1. Click the row, or select it and press Enter or Space. The same action collapses it again.
2. The card shows the command that ran: each command line gets its own prompt row.
3. The full output sits in a scrolling area inside the card, never cut off in the middle. Scroll inside the card to read it all; the command's description stays visible while you do.
4. A run-state indicator shows where the command stands: running while it works, done once it settles.
5. The copy control on the card copies its recorded content, ready to paste elsewhere.

How the command ended

The card reports how the command ended:

• Command results carry a trailing marker for the ending: [exit code: N] or [killed by signal: ...]. The card reads the ending from the marker and removes it from the shown output.
• A result with no marker reads as exit 0: the command finished cleanly. Other bracketed notes stay in the output, for example a note that the command timed out.
• A non-zero exit code or a signal shows the row as failed; the expanded card still reads done, because the card reports that the command finished, while the row reports how it ended.
• When a command produces no output, the card says so instead of showing an empty space.

The folder the command ran in

• The card shows the working folder the command ran in, tidied for reading: an absolute folder is shown as it is, and a relative one is resolved under the chat's workspace folder.
• . and .. are collapsed, and a path that climbs above the drive's root is dropped. A network share keeps its full root.

Long results, background runs and other fallbacks

The terminal card is drawn from the recorded result. When that is not possible, the row falls back to simpler forms:

• Very long results. A result too big to keep in the chat is stored separately; its row shows the plain block with IN and OUT sections, and never shows an exit-code pill.
• Background starts. A command that Oda starts in the background shows a short acknowledgement row that stays collapsed: there is nothing to expand there.
• Persistent shells. While a persistent-shell command runs, its card is shown; once it settles, the plain block is shown instead. See Persistent shells.
• Unusual records. If the recorded data cannot be drawn as a card, the row stays plain, showing the recorded input and output.

For how commands run, time out and move to background jobs, see Shell commands.

Writing into a running terminal

When Oda sends input into a running terminal, the row names the terminal it wrote into, for example Terminal pty-3. A send that carries no text of its own reads (send input).

Questions, answered

Why does a command show as failed when the step itself completed?

Because the command itself ended with a non-zero exit code or a signal, and Oda reports that on the row. The step still settles, and the card still reads done: the card says the command finished, the row says how it ended. If the failure matters for your task, ask Oda to run it again or to try another way.

Does the card show the whole output, even for a long command?

Yes. The output scrolls inside the card and is never cut off in the middle. A result too big to keep in the chat is stored separately, and its row shows a plain block instead.

Why is there no exit code on a very long command's result?

A result too big to keep in the chat is stored in a file, and its row shows the plain IN and OUT block instead of a terminal card. Those blocks never show an exit-code pill; you can ask Oda to read the stored result if you need to check the ending.

Why can't I expand a background command?

The row for a background start is only an acknowledgement, not a result: it stays collapsed and has nothing to expand. The command runs on while the chat continues; Shell commands explains how background runs are followed.

Why does a persistent-shell command show only a plain block once it settles?

While a command runs in a persistent shell, its card is shown; once it settles, the row shows the plain IN and OUT block instead. Persistent shells and what resets them are described in Persistent shells.

What do IN and OUT mean?

They are the two sections of the plain block: IN holds what Oda sent, the command as recorded, and OUT holds what came back. The block appears when the terminal card cannot be drawn from the recorded result.

What does (send input) mean?

It is shown when Oda sends input into a running terminal without any text of its own. The row also names the terminal it wrote into, for example Terminal pty-3.

How do I copy what the card shows?

Expand the row and use the copy control on the card; it copies the card's recorded content, ready to paste where you need it.

Which folder does the card show, and why is it shortened?

It shows the working folder the command ran in. An absolute folder is shown as it is; a relative one is resolved under the chat's workspace folder, . and .. are collapsed, and a path that climbs above the root is dropped. A network share keeps its full root.

What does the card show while the command is still running?

The same card in its running state: the run-state indicator reads running, and the output area holds what has arrived so far. When the command settles, the indicator reads done.