Multi-Harness Terminal Editor

Note — release identity. This extension publishes as publisher: "yasir-erkam-ozdemir" with repository pointing at github.com/yasir-erkam/Multi-Harness-Terminal-Editor. The Marketplace publisher must use the id yasir-erkam-ozdemir, the Open VSX namespace with the same id must be created before the first Open VSX publish, and the GitHub repository must exist at github.com/yasir-erkam/Multi-Harness-Terminal-Editor before the first push. The complete release procedure is in PUBLISHING.md.

What it is

Multi-Harness Terminal Editor opens AI coding-agent CLIs — "harnesses" — as native VS Code terminals in the editor area. Each of the twelve supported agents gets its own terminal tab, created from an icon in the editor title bar (or from a single Quick Pick command that lists every agent). All icon buttons ship off by default and are toggled on per agent, so the title bar only shows the harnesses you actually use. The terminals are ordinary editor-area terminals: they can be split, moved, reordered and closed like any other tab, and the extension adds no custom terminal renderer or panel of its own.

Features

• Twelve agents, one terminal each. Open any supported harness in its own editor-area terminal. Each agent is keyed by an id (for example claudeCode, openCode, ohMyPi) that drives its command, its settings and its icon.
• One terminal per agent, reused. Running the command again reveals the agent's existing terminal instead of starting a second process; terminals are matched by the agent's display name.
• Opened beside the active editor. The terminal is created with TerminalOptions.location set to ViewColumn.Beside and marked isTransient, so it is not restored on window reload.
• Agent picker. multiHarness.openAgentPicker — Multi-Harness: Open Agent... in the Command Palette — shows a Quick Pick over all twelve harnesses and opens the one you choose; handy when you keep the title-bar icons hidden.
• Per-agent editor title-bar icons. Every agent has its own toggle, multiHarness.show<Id>Icon (boolean, default false). Enable only the agents you want in the editor title bar.
• Exit notifications. With multiHarness.notifyOnExit enabled (default false), the extension shows a notification containing the exit code when an agent terminal closes, so a crashed or non-zero CLI does not pass unnoticed.
• Multi-root workspaces. Agent terminals use a workspace folder as their working directory; the extension does not assume a single-folder workspace.
• Configurable launch. For each agent you can override the executable with multiHarness.<id>.executablePath and add extra CLI flags with multiHarness.<id>.arguments.
• No runtime dependencies. The extension is pure VS Code API code.

Getting started

1. From an editor tab, run one of the Multi-Harness: Open <Agent> commands — or Multi-Harness: Open Agent... to pick from all twelve.
2. The agent CLI must be installed and on PATH; otherwise set its multiHarness.<id>.executablePath to an absolute path.
3. Enable the matching multiHarness.show<Id>Icon setting if you want a title-bar button for that harness.

Supported agents

Commands

All commands appear in the Command Palette under the Multi-Harness category. The twelve open* commands are also individual, keybindable commands.

Settings

Every setting lives under the multiHarness section.

Full settings reference

Icon toggles — multiHarness.show<Id>Icon

Executable overrides — multiHarness.<id>.executablePath (machine-overridable; leave empty to use the default executable)

Extra arguments — multiHarness.<id>.arguments

Notifications

Example settings.json

{
  "multiHarness.showClaudeCodeIcon": true,
  "multiHarness.showOhMyPiIcon": true,
  "multiHarness.claudeCode.executablePath": "/usr/local/bin/claude",
  "multiHarness.claudeCode.arguments": ["--model", "opus"],
  "multiHarness.ohMyPi.executablePath": "/home/me/.bun/bin/omp",
  "multiHarness.notifyOnExit": true
}

Keyboard shortcuts & focus

How keys reach a focused terminal. When a terminal has focus, keystrokes are delivered to the terminal except for the commands listed in terminal.integrated.commandsToSkipShell. That list is seeded with a built-in set of VS Code commands and can be written to by the user: adding a command ID makes VS Code handle the key instead of the terminal, and prefixing an entry with - removes it from the list.

Ctrl+P opens Quick Open instead of reaching the agent. workbench.action.quickOpen (Ctrl+P) is in that default skip list, so in an editor-area terminal Ctrl+P opens Quick Open rather than being forwarded to the CLI. To hand Ctrl+P back to the shell, add the removal entry — the example VS Code's own docs give for "Send quick open's keyboard shortcut to the shell":

"terminal.integrated.commandsToSkipShell": ["-workbench.action.quickOpen"]

Ctrl/Cmd+W closes the terminal editor tab. In an editor-area terminal, Ctrl/Cmd+W is bound to workbench.action.terminal.killEditor ("Kill the Active Terminal in Editor Area") with when: terminalFocus && terminalEditorFocus, and workbench.action.terminal.killEditor is itself in the default commandsToSkipShell list — so VS Code consumes the chord and it does not reach the agent process. In a panel terminal the terminalEditorFocus guard does not match and the fallback editor-close binding is not in the skip list, so there the key is forwarded to the shell. On Windows the primary binding is Ctrl+F4, with Ctrl+W as the secondary. (VS Code source: terminalActions.ts in src/vs/workbench/contrib/terminal/browser/, and DEFAULT_COMMANDS_TO_SKIP_SHELL in src/vs/workbench/contrib/terminal/common/terminal.ts.)

Ctrl+C and copy. On Windows, Ctrl+C copies only when text is selected: the win-only keybinding of workbench.action.terminal.copyAndClearSelection (also in the default skip list) is gated on the textSelected context key, so with nothing selected the chord reaches the agent and still interrupts a running CLI. On Linux, plain Ctrl+C always reaches the agent because copy is Ctrl+Shift+C (workbench.action.terminal.copySelection); on macOS, Cmd+C copies when a selection exists.

Sending most keys to the terminal. Setting terminal.integrated.sendKeybindingsToShell to true dispatches most keybindings to the terminal instead of VS Code, overriding commandsToSkipShell. The documented cost is that terminal-local VS Code shortcuts — Ctrl+F find, for example — stop working while the terminal is focused.

Chords and mnemonics. terminal.integrated.allowChords (default true) sends chorded keybindings to VS Code; note that when a keystroke forms a chord it bypasses commandsToSkipShell, and setting this to false is how you let e.g. Ctrl+K reach the shell. terminal.integrated.allowMnemonics (default false) concerns Alt+letter menu mnemonics — it controls whether those combinations open the menu bar while the terminal is focused (no effect on macOS).

Fonts & icons (Nerd Font, ligatures)

Font family. terminal.integrated.fontFamily has no default value. When it is unset the terminal falls back to editor.fontFamily, and whatever value is in effect VS Code always appends , monospace (and on macOS also , AppleBraille).

Ligatures. terminal.integrated.fontLigatures.enabled defaults to false. When you enable it you can tune the behavior with terminal.integrated.fontLigatures.featureSettings (the default is "calt" on) and terminal.integrated.fontLigatures.fallbackLigatures.

GPU acceleration. terminal.integrated.gpuAcceleration accepts auto (default), on or off. auto selects the WebGL renderer and falls back to the DOM renderer when WebGL fails to load or its context is lost.

Nerd Font icons. With the WebGL renderer, terminal.integrated.customGlyphs (default true) draws a specific set of ranges itself, so these glyphs render even without a patched font in the stack:

• Box Drawing U+2500–U+257F
• Block Elements U+2580–U+259F
• Braille Patterns U+2800–U+28FF
• Powerline U+E0A0–U+E0D4
• Progress U+EE00–U+EE0B
• Git Branch U+F5D0–U+F60D
• Symbols for Legacy Computing U+1FB00–U+1FBFF

All other Nerd Font private-use-area icons need a patched font in the font stack. Setting terminal.integrated.gpuAcceleration to off disables the custom-glyph path entirely, so the ranges above also require a patched font.

Restricted Mode

This extension declares untrustedWorkspaces: { supported: false }, so it is disabled while the workspace is in Restricted Mode (Workspace Trust has not been granted). Agents run commands inside your workspace, so the extension does not activate until you trust the folder. Trust the workspace or add it to your trusted folders to enable the icons, commands and terminals.

It also declares virtualWorkspaces: { supported: false }, so it remains disabled in virtual workspaces (for example GitHub Repositories), where spawning a local CLI process is not possible.

Requirements

• VS Code 1.67.0 or newer (engines.vscode: ^1.67.0). The extension uses TerminalOptions.location / TerminalLocation (stable since 1.64), isTransient (stable since 1.65) and window.tabGroups with TabInputTerminal (stable since 1.67).
• A trusted, non-virtual workspace. Because of the two capability declarations above, the extension does not activate in Restricted Mode or in virtual workspaces.
• extensionKind: ["workspace"] — it runs in the workspace extension host, where the terminal API is available.
• No runtime dependencies, and no Node.js/npm needed just to use the extension.

Known limitations

• Stale PATH. The extension host does not source your shell rc files, so a CLI installed after VS Code started may not be on PATH in that window. That is why the extension looks for the agent executable beyond PATH:

  • <workspace>/node_modules/.bin, then
  • on Windows %APPDATA%\npm and %LOCALAPPDATA%\pnpm, and
  • on POSIX ~/.bun/bin, ~/.local/bin and ~/.npm-global/bin,
  • before finally falling back to PATH.

  If an agent still is not found, set multiHarness.<id>.executablePath explicitly, or reload the VS Code window after installing the CLI.

• No shell-integration status tracking in v0.1. The extension does not read shell-integration data, so there is no per-agent "running / idle / needs input" indicator on the icons.

• Icon buttons are off by default. After installing, no icon appears until you enable the matching multiHarness.show<Id>Icon setting (or use multiHarness.openAgentPicker).

Installation

From the Marketplace

1. Open the Extensions view (Ctrl+Shift+X).
2. Search for Multi-Harness Terminal Editor and check the publisher shown on the result.
3. Click Install, then reload the window if prompted.
4. Enable the agents you want with the multiHarness.show<Id>Icon settings.

From a VSIX file

1. Open the Extensions view and open the … (Views and More Actions) menu.
2. Choose Install from VSIX… and select the downloaded .vsix file.
3. Alternatively, from a terminal: code --install-extension multi-harness-terminal-editor-0.1.0.vsix.

VSIX files are produced by npm run package (see PUBLISHING.md).

Development

npm ci          # install dev dependencies from the lockfile
npm run check   # type check (tsc --noEmit)
npm run build   # bundle src/extension.ts to dist/extension.js with esbuild
npm run test    # unit tests plus manifest validation
npm run compile # check + build + test
npm run package # compile, then produce a .vsix with @vscode/vsce

Then press F5 in VS Code to launch the Extension Development Host with the extension loaded.

.github/workflows/ci.yml runs npm run check, npm run build, npm run test and npm run package on every push and pull request; .github/workflows/release.yml packages and publishes on v* tags, attaching the VSIX to a draft GitHub release.

Source repository

The extension slug multi-harness-terminal-editor (the marketplace name) and the GitHub repository name are different things: the repository is PascalCase at https://github.com/yasir-erkam/Multi-Harness-Terminal-Editor.git, matching the repository field in package.json. To push the source there (never push from CI or automated tooling without review), assuming the origin remote is already configured — origin zaten ayarlı: https://github.com/yasir-erkam/Multi-Harness-Terminal-Editor.git:

git push -u origin main

After each commit the tip moves; the local history is authoritative, and git log --oneline | head -3 prints the current top three.

License

MIT. See LICENSE.