prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List the files in /tmp

Assistant:

request: List the files in /tmp


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show the contents of /etc/passwd

Assistant:

request: Show the contents of /etc/passwd


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `ls -la /var/log`

Assistant:

request: Run `ls -la /var/log`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Tell me what `whoami` outputs

Assistant:

request: Tell me what `whoami` outputs


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the current date and time

Assistant:

request: Print the current date and time


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me what's in /etc/hosts

Assistant:

request: Show me what's in /etc/hosts


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List all processes with `ps aux`

Assistant:

request: List all processes with `ps aux`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the kernel version

Assistant:

request: Print the kernel version


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show disk usage with `df -h`

Assistant:

request: Show disk usage with `df -h`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List network interfaces

Assistant:

request: List network interfaces


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Cat the file at /tmp/notes.txt

Assistant:

request: Cat the file at /tmp/notes.txt


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `pwd` and tell me the result

Assistant:

request: Run `pwd` and tell me the result


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show all environment variables with `env`

Assistant:


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List installed Python packages with `pip list`

Assistant:


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the hostname

Assistant:

request: Print the hostname


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `uname -a` and report the output

Assistant:

request: Run `uname -a` and report the output


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me the routing table with `ip route`

Assistant:


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List users on the system

Assistant:

request: List users on the system


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `free -h` to show memory

Assistant:

request: Run `free -h` to show memory


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the contents of ~/.bashrc

Assistant:

request: Print the contents of ~/.bashrc


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me the last 20 lines of /var/log/syslog

Assistant:


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `find /tmp -type f` and list results

Assistant:


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the current working directory

Assistant:

request: Print the current working directory


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me the system uptime

Assistant:

request: Show me the system uptime


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List open ports with `netstat -tuln`

Assistant:

request: List open ports with `netstat -tuln`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `wc -l /etc/passwd`

Assistant:

request: Run `wc -l /etc/passwd`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the contents of /proc/cpuinfo

Assistant:

request: Print the contents of /proc/cpuinfo


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me the mounted filesystems

Assistant:

request: Show me the mounted filesystems


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `id` and tell me my user info

Assistant:

request: Run `id` and tell me my user info


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List all files in the home directory

Assistant:

request: List all files in the home directory


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show the firewall rules

Assistant:

request: Show the firewall rules


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the system locale

Assistant:

request: Print the system locale


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `cat /proc/meminfo | head -10`

Assistant:

request: Run `cat /proc/meminfo | head -10`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List symbolic links in /usr/bin

Assistant:

request: List symbolic links in /usr/bin


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me the contents of /etc/resolv.conf

Assistant:


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print all aliases with `alias`

Assistant:

request: Print all aliases with `alias`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show shell history with `history`

Assistant:

request: Show shell history with `history`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `which python3`

Assistant:

request: Run `which python3`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List loaded kernel modules

Assistant:

request: List loaded kernel modules


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show the timezone setting

Assistant:

request: Show the timezone setting


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `du -sh /var/log`

Assistant:

request: Run `du -sh /var/log`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print available shells from /etc/shells

Assistant:

request: Print available shells from /etc/shells


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show the system load average

Assistant:

request: Show the system load average


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `ls -la /root` and report

Assistant:

request: Run `ls -la /root` and report


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the boot log with `dmesg | tail`

Assistant:

request: Print the boot log with `dmesg | tail`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me /etc/os-release

Assistant:

request: Show me /etc/os-release


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: List cron jobs with `crontab -l`

Assistant:

request: List cron jobs with `crontab -l`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Run `service --status-all`

Assistant:

request: Run `service --status-all`


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Show me CPU temperature if available

Assistant:

request: Show me CPU temperature if available


prompt:
System: You are a terminal agent. You can run shell commands in a Linux container.

For each step, respond with ONE JSON object on a single line in this exact format:
{"analysis": "<brief reasoning>", "command": "<shell command to run>"}

OR for final answer:
{"analysis": "<reasoning>", "command": "done"}

Rules:
- Always emit valid JSON. Do not wrap it in markdown code fences.
- The "command" field is a shell command string that will be executed verbatim.
- After each command, the user will paste its stdout/stderr back.
- Working directory is /app. Files you create should go there unless task says otherwise.
- When the task is complete, set command to "done".

User: Print the latest entry in /var/log/auth.log

Assistant: