When Copilot starts the premium request tracking, this will be a massive problem because I have to use additional requests to work around the failed output. The agent also uses requests to resolve something that is not real.

It ended up zsh problem, switching to bash fixed the problem.

shift + cmd + p, type "Terminal: select default profile" choose bash

Investigation Report: GitHub Copilot Cannot Capture Output from Long-Running Terminal Commands

I've conducted a systematic investigation into the issue where GitHub Copilot fails to capture output from certain terminal commands. Here are my findings:

Test Environment

• Platform: Linux development environment
• Project: Go-based API server with Docker containerization
• Commands tested: Various types including simple utilities and complex test suites

Test Results

✅ Commands that work correctly:

uuidgen -r
# Output: Successfully captured UUID like "795e6cbe-96d0-4551-9f97-c24f4fee2eb6"

❌ Commands that fail to capture output:

# run go test in docker container 
make test-pkg PKG=./my_pkg  2>&1      

# run go test command in local 
go test -v ./my_pkg

# go build 
go build -o /dev/null ./my_pkg

These commands return empty output despite producing substantial terminal output when run manually.

✅ Workaround that works:

go test -v ./my_pkg > /tmp/test_output.log 2>&1
# Then reading the file with read_file tool works perfectly

Analysis

The issue appears to be specifically related to:

1. Long-running commands (test suites, build processes)
2. Commands with complex output streams (multiple stdout/stderr interleaving)
3. Interactive or buffered processes (Go test runner, make targets)

Short, simple commands like uuidgen, ls, echo work fine, but anything involving:

• Test execution frameworks
• Build systems (make, go build)
• Commands that run for more than a few seconds
• Processes that use sophisticated output buffering

Impact

This significantly limits Copilot's ability to:

• Analyze test failures in real-time
• Debug build issues
• Provide context-aware assistance for development workflows
• Help with CI/CD troubleshooting

Current Workaround

The only reliable method is to redirect output to a temporary file and then read it:

command_with_complex_output > /tmp/output.log 2>&1
# Then use read_file tool to access /tmp/output.log

Request

Could the GitHub Copilot team investigate and improve the terminal command execution tool to handle:

1. Long-running processes with streaming output
2. Commands that produce large amounts of output
3. Better handling of stdout/stderr redirection
4. Timeout mechanisms for commands that might hang

This would greatly enhance Copilot's utility for development workflows and debugging scenarios.

This was the solution cloude gave me, and its working for my specific enviroment

✅ Complete Fix for GitHub Copilot Terminal Completion Detection Bug

Problem Summary

GitHub Copilot agents fail to detect when terminal commands complete, causing infinite hangs especially with:

• ZSH with oh-my-zsh + powerlevel10k theme
• Commands with progress bars or complex output
• Any prompt with RPROMPT or custom decorations

Root Causes

1. Outdated powerlevel10k theme (pre-2023 versions)
2. RPROMPT interference - right-side prompts break detection
3. Missing VS Code shell integration
4. Prompt pattern detection failure - Copilot expects clean newline after prompt

Complete Solution (macOS/Linux + ZSH)

Step 1: Update Powerlevel10k Theme

cd ~/.oh-my-zsh/custom/themes/powerlevel10k
git pull

Verify update:

git log -1 --format="%ai"

Should show 2023 or later.

Step 2: Update VS Code Settings

Add these settings to your settings.json (Cmd+Shift+P → "Preferences: Open User Settings (JSON)"):

{
  "terminal.integrated.shellIntegration.enabled": true,
  "terminal.integrated.shellIntegration.decorationsEnabled": "both",
  "terminal.integrated.shellIntegration.showWelcome": false,
  "terminal.integrated.commandTimeout": 30000
}

What this does:

• Enables VS Code's built-in shell integration
• Shows command decorations for better tracking
• Sets 30-second timeout for longer operations

Step 3: Add Shell Integration to .zshrc

Append this to the END of your ~/.zshrc file:

# ============================================
# VS Code Shell Integration for Copilot
# Fix for terminal completion detection issue
# https://github.com/orgs/community/discussions/161238
# ============================================

# VS Code shell integration - must be at the end of .zshrc
if [[ "$TERM_PROGRAM" == "vscode" ]]; then
    # Load VS Code shell integration if available
    [[ -f "${HOME}/.config/vscode-shell-integration.zsh" ]] && source "${HOME}/.config/vscode-shell-integration.zsh"
    
    # Disable RPROMPT in VS Code (causes detection issues)
    unset RPROMPT
    
    # Ensure simple prompt format for command detection
    # This helps Copilot detect when commands finish
    typeset -g POWERLEVEL9K_DISABLE_RPROMPT=true
    
    # Increase command timeout for longer operations
    export VSCODE_SHELL_INTEGRATION_TIMEOUT=30000
fi

What this does:

• Only affects VS Code terminals (keeps your regular terminal prompt)
• Disables RPROMPT which interferes with detection
• Configures powerlevel10k to play nice with Copilot

Step 4: Apply Changes

# Reload shell configuration
source ~/.zshrc

# Verify VS Code terminal detection
echo $TERM_PROGRAM
# Should output: vscode

Restart VS Code terminal or open a new terminal tab for changes to take effect.

Testing the Fix

Run these commands to verify completion detection works:

# Quick command (should complete immediately)
echo "Test 1: OK"

# Delayed command (should complete after 2 seconds)
sleep 2 && echo "Test 2: OK"

# Package manager command
npm --version  # or pnpm --version, yarn --version

If Copilot now detects completion correctly, you're all set! ✅

Still Having Issues?

For Bash Users

Add to ~/.bashrc:

if [[ "$TERM_PROGRAM" == "vscode" ]]; then
    unset PROMPT_COMMAND
    PS1='\u@\h:\w\$ '
fi

For Fish Users

Add to ~/.config/fish/config.fish:

if test "$TERM_PROGRAM" = "vscode"
    function fish_prompt
        echo (prompt_pwd) '> '
    end
end

If Commands Still Hang

1. Increase timeout: Change commandTimeout to 60000 (60 seconds) in settings.json
2. Use background flag: For long-running processes (servers, watch mode), Copilot should set isBackground: true
3. Simplify prompt: Temporarily switch to a minimal theme to isolate the issue

Known Limitations

• Progress bars (like npm install with progress) may still cause issues
• Interactive commands (like vim, nano) won't be detected as "complete"
• Long operations (>30s) might timeout - this is expected behavior

Additional Workarounds for Projects

Create .github/copilot-instructions.md in your project:

## Terminal Command Guidelines

When running terminal commands in this project:
- Prefer explicit output over silent operations
- Use `--verbose` flags when available
- For long operations, set `isBackground: true`
- Break down operations into smaller steps if timeout occurs

Common commands and expected duration:
- `npm install` - 10-30 seconds
- `npm run dev` - Background process
- `npm run build` - 30-90 seconds
- `git status` - <1 second

This helps Copilot understand your project's typical command durations.

System Tested

• ✅ macOS Sonoma/Sequoia (arm64)
• ✅ ZSH 5.9 with oh-my-zsh
• ✅ Powerlevel10k (latest)
• ✅ VS Code 1.95+
• ✅ GitHub Copilot (October 2024)

Also works on Linux (Ubuntu, Debian, Fedora) with similar configurations.

Credits

Based on community research from:

• https://github.com/orgs/community/discussions/161238
• https://github.com/microsoft/vscode/issues/...
• https://github.com/romkatv/powerlevel10k/issues/...

Special thanks to all contributors who identified the root causes! 🙏

Quick Summary (TL;DR)

For ZSH + Powerlevel10k users:

# 1. Update powerlevel10k
cd ~/.oh-my-zsh/custom/themes/powerlevel10k && git pull

# 2. Add to VS Code settings.json
# terminal.integrated.shellIntegration.enabled: true
# terminal.integrated.commandTimeout: 30000

# 3. Add to end of ~/.zshrc
if [[ "$TERM_PROGRAM" == "vscode" ]]; then
    unset RPROMPT
    typeset -g POWERLEVEL9K_DISABLE_RPROMPT=true
fi

# 4. Reload
source ~/.zshrc

Restart VS Code terminal and test! 🚀

I was able to resolve this by removing my ZSH theme (ZSH_THEME="sorin") from my .zshrc.

I’d like to re-enable it, but for now the drawbacks outweigh the benefits - so a bug fix would be appreciated!

How I confirmed the issue, and how you might find your own cause of the issue:

I recommend this approach, as your issue might be related to a different theme or plugin.

• I used the chat debug view and noticed that the Response from the run_in_terminal tool was missing the command output.
  The first terminal call worked fine, but subsequent calls failed to return output.
• I could reproduce this consistently. As a workaround, I either outputted to a file or deleted the terminal Copilot was using, forcing it to create a new one each time.
• Switching to bash resolved the issue. Using a minimal zsh config (without plugins/themes) also worked.
• I then systematically disabled each plugin/theme and then re-tested until I identified the root cause.
• Retested by deleting the existing terminal, and then asking co pilot to run a command twice, ensuring the second command contains the response in the debug logs

I found that my installation of powerlevel10k in ~/.oh-my-zsh/custom/themes/powerlevel10k was out of date. I had previously cloned it from github rather than installing with any package manager. A quick git pull and now Copilot seems to successfully see the output from terminal command executions, more specifically the terminal output from the second command onwards.

Same issue.
I have to press enter in Terminal to signal copilot that task ended

I had the same issue using zsh/oh-my-zsh. But I'm not using powerlevel10k.
Switching to plain bash worked well, as well as disabling themes completely.
I'm using the built-in af-magic theme, and Copilot's helped find the solution which was to disable the RPS1 in prompt. Below is its answer.

TL;DR: adding the below snippet to .zshrc fixes the issue (for me at least)

Based on the GitHub issue and your theme configuration, the problem is with the right-side prompt (RPS1) in your af-magic.zsh-theme. This is a known issue with VS Code's Copilot terminal integration.

The Problem

Your theme defines:

RPS1="%(?..%{$fg[red]%}%? ↵%{$reset_color%})"
RPS1+='$(virtualenv_prompt_info)'
RPS1+=" ${FG[237]}%n@%m%{$reset_color%}"

The RPROMPT (right-side prompt) interferes with VS Code's shell integration, causing Copilot to fail detecting when commands complete.

The Solution

Add VS Code-specific configuration to your ~/.zshrc file (after the theme is loaded):

# ...existing code...

# VS Code Shell Integration for Copilot
# Fix for terminal completion detection issue
if [[ "$TERM_PROGRAM" == "vscode" ]]; then
    # Disable RPROMPT in VS Code (causes detection issues)
    unset RPROMPT
    unset RPS1
    
    # Load VS Code shell integration
    [[ -f "$(code --locate-shell-integration-path zsh)" ]] && \
        . "$(code --locate-shell-integration-path zsh)"
fi

Alternative: Modify the Theme Directly

If you prefer to fix it in the theme itself:

# ...existing code...

# right prompt: return code, virtualenv and context (user@host)
# Disable RPS1 in VS Code to fix Copilot command detection
if [[ "$TERM_PROGRAM" != "vscode" ]]; then
    RPS1="%(?..%{$fg[red]%}%? ↵%{$reset_color%})"
    if (( $+functions[virtualenv_prompt_info] )); then
      RPS1+='$(virtualenv_prompt_info)'
    fi
    RPS1+=" ${FG[237]}%n@%m%{$reset_color%}"
fi

# ...existing code...

The only solution that worked for me was changing the default VSCode terminal to the naked bash. It's quite invoncenient as you need to use this small dropdown next to the "plus" button to add terminal of a choice but it's better than having to copy-paste each terminal output.

Just for reference my default terminal is (was?) power10k zsh. The actions are following:

Open VSCode
Press Cmd + Shift + P (Mac) or Ctrl + Shift + P (Windows/Linux)
Type "Terminal: Select Default Profile" and choose it
Select bash (or any other unmodded shell you think might work)

The problem also occurs in the pycharm copilot plugin, the agent starts shells then does not understand commands have completed until the terminal pane is closed.

Switching to a simpler / unthemed shell (e.g. /bin/sh) does allow the agent to figure things out, at the cost of breaking "normal" shell interactions in the IDE since the richer shell features stop working.

It does not seem like there is a way to customise terminal on a per-plugin, but given the plugin is apparently able to name the terminal tab name it seems like it should be able to probe for a working shell setting on its own, or at least probe if it can work with the default terminal settings and request configuration if not.

Note that this is not using p10k, you can do the same by hand by customising $PROMPT or $PS1 or whatever.

run chat in agent mode and specify @terminal before writing your prompt/message.


just write @terminal and hit tab


now write your message


don't use that terminal tab that is spawned by github copilot sometimes it also cases the problem.

@MarkWard0110 - I've encountered the exact same issue and have done some investigation that might
help you and others experiencing this problem.

🔍 Root Cause Analysis

After extensive testing, I believe the issue is related to newline-terminated prompt pattern detection.
The run_in_terminal tool appears to wait for a prompt pattern followed by a newline character, but when
commands complete, the cursor often remains on the same line as the prompt.

What the tool expects: PS X:\Path\To\Directory>\n (prompt + newline)
What actually happens: PS X:\Path\To\Directory> (prompt without newline)

This explains why pressing Enter (which creates the newline) immediately allows the agent to continue.

✅ Working Workaround - 100% Success Rate

I've discovered a reliable workaround that eliminates the need for manual Enter presses:

Append ; echo "" to all PowerShell commands:

# Instead of:
npm install

# Use:
npm install; echo ""

This forces a newline after command completion and provides the completion signal the detection mechanism needs.

🧪 Testing Results

I've tested this workaround across various command types with 100% success:

• Package management (npm install; echo "")
• File operations (ls; echo "")
• Development tools (markdownlint-cli2 --fix file.md; echo "")
• Git operations (git status; echo "")

🔧 Environment Confirmation

Your setup: VSCode from WSL terminal
My setup: Windows 11, PowerShell 7+, VS Code 1.101.0

This confirms the issue affects multiple environments, not just WSL.

🚀 Automated Solution

To make this workaround automatic, I've created GitHub Copilot project instructions:

.github/copilot-instructions.md:

**CRITICAL: Always append `; echo ""` to PowerShell commands when using `run_in_terminal`**

This ensures the workaround is applied automatically in all interactions.

📊 Additional Benefits

Beyond fixing completion detection, this workaround also:

• Eliminates the "agent gets weird and sidetracked" behavior you mentioned
• Prevents the agent from undoing correct code due to perceived failures
• Maintains proper context flow throughout sessions

🔧 Suggested Fix for Developers

If my analysis is correct, the official fix would involve modifying the prompt detection logic to:

1. Match prompt patterns without requiring trailing newlines
2. Use process state detection as a fallback
3. Implement timeout-based completion detection

Hope this helps everyone experiencing this frustrating issue! The ; echo "" workaround has completely
eliminated the problem in my workflow.