diff --git a/frontend/app/block/block.tsx b/frontend/app/block/block.tsx
index 350f984563..81896572f7 100644
--- a/frontend/app/block/block.tsx
+++ b/frontend/app/block/block.tsx
@@ -27,7 +27,7 @@ import { getWaveObjectAtom, makeORef, useWaveObjectValue } from "@/store/wos";
 import { focusedBlockId, getElemAsStr } from "@/util/focusutil";
 import { isBlank, useAtomValueSafe } from "@/util/util";
 import { HelpViewModel } from "@/view/helpview/helpview";
-import { TermViewModel } from "@/view/term/term";
+import { TermViewModel } from "@/view/term/term-model";
 import { WaveAiModel } from "@/view/waveai/waveai";
 import { WebViewModel } from "@/view/webview/webview";
 import clsx from "clsx";
diff --git a/frontend/app/element/iconbutton.tsx b/frontend/app/element/iconbutton.tsx
index 45e5771099..318e2cbbee 100644
--- a/frontend/app/element/iconbutton.tsx
+++ b/frontend/app/element/iconbutton.tsx
@@ -5,7 +5,7 @@ import { useLongClick } from "@/app/hook/useLongClick";
 import { makeIconClass } from "@/util/util";
 import clsx from "clsx";
 import { atom, useAtom } from "jotai";
-import { forwardRef, memo, useMemo, useRef } from "react";
+import { CSSProperties, forwardRef, memo, useMemo, useRef } from "react";
 import "./iconbutton.scss";
 
 type IconButtonProps = { decl: IconButtonDecl; className?: string };
@@ -15,6 +15,10 @@ export const IconButton = memo(
         const spin = decl.iconSpin ?? false;
         useLongClick(ref, decl.click, decl.longClick, decl.disabled);
         const disabled = decl.disabled ?? false;
+        const styleVal: CSSProperties = {};
+        if (decl.iconColor) {
+            styleVal.color = decl.iconColor;
+        }
         return (
             <button
                 ref={ref}
@@ -24,7 +28,7 @@ export const IconButton = memo(
                 })}
                 title={decl.title}
                 aria-label={decl.title}
-                style={{ color: decl.iconColor ?? "inherit" }}
+                style={styleVal}
                 disabled={disabled}
             >
                 {typeof decl.icon === "string" ? <i className={makeIconClass(decl.icon, true, { spin })} /> : decl.icon}
diff --git a/frontend/app/view/term/shellblocking.ts b/frontend/app/view/term/shellblocking.ts
new file mode 100644
index 0000000000..9df67c5bd8
--- /dev/null
+++ b/frontend/app/view/term/shellblocking.ts
@@ -0,0 +1,117 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// Always block (TUIs / pagers / multiplexers / known interactive UIs)
+const ALWAYS_BLOCK = [
+    // multiplexers
+    "tmux", "screen", "byobu", "dtach", "abduco", "tmate",
+    // editors/pagers
+    "vim", "nvim", "emacs", "nano", "less", "more", "man", "most", "view",
+    // TUIs / tools
+    "htop", "top", "btop", "fzf", "ranger", "mc", "nnn", "k9s", "nmtui", "alsamixer",
+    "tig", "gdb", "lldb",
+    // mail/irc
+    "mutt", "neomutt", "alpine", "weechat", "irssi",
+    // dialog UIs
+    "dialog", "whiptail",
+    // DB shells
+    "psql", "mysql", "sqlite3", "mongo", "redis-cli",
+];
+
+// Bare REPLs only block when no args
+const BARE_REPLS = [
+    "python", "python3", "python2", "node", "ruby", "perl", "php", "lua", "ipython", "bpython", "irb",
+];
+
+// Shells: block only if interactive/new shell
+const SHELLS = [
+    "bash", "sh", "zsh", "fish", "ksh", "mksh", "dash", "ash", "tcsh", "csh",
+    "xonsh", "elvish", "nu", "nushell", "pwsh", "powershell", "cmd",
+];
+
+// Wrappers to skip
+const WRAPPERS = [
+    "sudo", "doas", "pkexec", "rlwrap", "env", "time", "nice", "nohup",
+    "chrt", "stdbuf", "script", "scriptreplay", "sshpass",
+];
+
+function looksInteractiveShellArgs(args: string[]): boolean {
+    return (
+        args.length === 0 ||
+        args.includes("-i") ||
+        args.includes("--login") ||
+        args.includes("-l") ||
+        args.includes("-s")
+    );
+}
+
+function isNonInteractiveShellExec(args: string[]): boolean {
+    return (
+        args.includes("-c") ||
+        args.some((a) => a === "-Command" || a.startsWith("-Command")) ||
+        args.some((a) => a.endsWith(".sh") || a.includes("/"))
+    );
+}
+
+function isAttachLike(cmd: string, args: string[]): boolean {
+    if (cmd === "docker" || cmd === "podman") {
+        if (args[0] === "attach") return true;
+        if (args[0] === "exec") return args.some((a) => a === "-it" || a === "-i" || a === "-t");
+    }
+    if (cmd === "kubectl" || cmd === "k3s" || cmd === "oc") {
+        if (args[0] === "attach") return true;
+        if (args[0] === "exec") return args.some((a) => a === "-it" || a === "-i" || a === "-t");
+    }
+    if (cmd === "lxc" && args[0] === "exec") return args.some((a) => a === "-t" || a === "-T");
+    return false;
+}
+
+function isSshInteractive(args: string[]): boolean {
+    const hasForcedTty = args.includes("-t") || args.includes("-tt");
+    const hasRemoteCmd = args.some((a) => !a.startsWith("-") && a.includes(" "));
+    return hasForcedTty || !hasRemoteCmd;
+}
+
+export function getBlockingCommand(lastCommand: string | null, inAltBuffer: boolean): string | null {
+    if (!lastCommand) return null;
+
+    let words = lastCommand.trim().split(/\s+/);
+    if (words.length === 0) return null;
+
+    while (words.length && WRAPPERS.includes(words[0])) {
+        words.shift();
+    }
+    if (!words.length) return null;
+
+    const first = words[0].split("/").pop()!;
+    const args = words.slice(1);
+
+    if (inAltBuffer) return first;
+
+    if (ALWAYS_BLOCK.includes(first)) return first;
+
+    if (isAttachLike(first, args)) return first;
+
+    if (first === "ssh" || first === "mosh" || first === "telnet" || first === "rlogin") {
+        if (isSshInteractive(args)) return first;
+        return null;
+    }
+
+    if (first === "su" || first === "machinectl" || first === "chroot" || first === "nsenter" || first === "lxc") {
+        if (!args.length || SHELLS.includes(args[args.length - 1]?.split("/").pop() || "")) return first;
+        return null;
+    }
+
+    if (SHELLS.includes(first)) {
+        if (looksInteractiveShellArgs(args)) return first;
+        if (isNonInteractiveShellExec(args)) return null;
+        return null;
+    }
+
+    if (BARE_REPLS.includes(first)) {
+        if (args.length === 0) return first;
+        return null;
+    }
+
+    return null;
+}
\ No newline at end of file
diff --git a/frontend/app/view/term/term-model.ts b/frontend/app/view/term/term-model.ts
new file mode 100644
index 0000000000..296b8d58fc
--- /dev/null
+++ b/frontend/app/view/term/term-model.ts
@@ -0,0 +1,789 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Block } from "@/app/block/block";
+import { BlockNodeModel } from "@/app/block/blocktypes";
+import { waveEventSubscribe } from "@/app/store/wps";
+import { RpcApi } from "@/app/store/wshclientapi";
+import { makeFeBlockRouteId } from "@/app/store/wshrouter";
+import { DefaultRouter, TabRpcClient } from "@/app/store/wshrpcutil";
+import { TerminalView } from "@/app/view/term/term";
+import { TermWshClient } from "@/app/view/term/term-wsh";
+import { VDomModel } from "@/app/view/vdom/vdom-model";
+import { WorkspaceLayoutModel } from "@/app/workspace/workspace-layout-model";
+import {
+    atoms,
+    getAllBlockComponentModels,
+    getBlockComponentModel,
+    getBlockMetaKeyAtom,
+    getConnStatusAtom,
+    getOverrideConfigAtom,
+    getSettingsKeyAtom,
+    globalStore,
+    useBlockAtom,
+    WOS,
+} from "@/store/global";
+import * as services from "@/store/services";
+import * as keyutil from "@/util/keyutil";
+import { boundNumber, stringToBase64 } from "@/util/util";
+import * as jotai from "jotai";
+import * as React from "react";
+import { computeTheme, DefaultTermTheme } from "./termutil";
+import { TermWrap } from "./termwrap";
+import { getBlockingCommand } from "./shellblocking";
+
+export class TermViewModel implements ViewModel {
+    viewType: string;
+    nodeModel: BlockNodeModel;
+    connected: boolean;
+    termRef: React.MutableRefObject<TermWrap> = { current: null };
+    blockAtom: jotai.Atom<Block>;
+    termMode: jotai.Atom<string>;
+    blockId: string;
+    viewIcon: jotai.Atom<string>;
+    viewName: jotai.Atom<string>;
+    viewText: jotai.Atom<HeaderElem[]>;
+    blockBg: jotai.Atom<MetaType>;
+    manageConnection: jotai.Atom<boolean>;
+    filterOutNowsh?: jotai.Atom<boolean>;
+    connStatus: jotai.Atom<ConnStatus>;
+    termWshClient: TermWshClient;
+    vdomBlockId: jotai.Atom<string>;
+    vdomToolbarBlockId: jotai.Atom<string>;
+    vdomToolbarTarget: jotai.PrimitiveAtom<VDomTargetToolbar>;
+    fontSizeAtom: jotai.Atom<number>;
+    termThemeNameAtom: jotai.Atom<string>;
+    termTransparencyAtom: jotai.Atom<number>;
+    noPadding: jotai.PrimitiveAtom<boolean>;
+    endIconButtons: jotai.Atom<IconButtonDecl[]>;
+    shellProcFullStatus: jotai.PrimitiveAtom<BlockControllerRuntimeStatus>;
+    shellProcStatus: jotai.Atom<string>;
+    shellProcStatusUnsubFn: () => void;
+    isCmdController: jotai.Atom<boolean>;
+    isRestarting: jotai.PrimitiveAtom<boolean>;
+    searchAtoms?: SearchAtoms;
+
+    constructor(blockId: string, nodeModel: BlockNodeModel) {
+        this.viewType = "term";
+        this.blockId = blockId;
+        this.termWshClient = new TermWshClient(blockId, this);
+        DefaultRouter.registerRoute(makeFeBlockRouteId(blockId), this.termWshClient);
+        this.nodeModel = nodeModel;
+        this.blockAtom = WOS.getWaveObjectAtom<Block>(`block:${blockId}`);
+        this.vdomBlockId = jotai.atom((get) => {
+            const blockData = get(this.blockAtom);
+            return blockData?.meta?.["term:vdomblockid"];
+        });
+        this.vdomToolbarBlockId = jotai.atom((get) => {
+            const blockData = get(this.blockAtom);
+            return blockData?.meta?.["term:vdomtoolbarblockid"];
+        });
+        this.vdomToolbarTarget = jotai.atom<VDomTargetToolbar>(null) as jotai.PrimitiveAtom<VDomTargetToolbar>;
+        this.termMode = jotai.atom((get) => {
+            const blockData = get(this.blockAtom);
+            return blockData?.meta?.["term:mode"] ?? "term";
+        });
+        this.isRestarting = jotai.atom(false);
+        this.viewIcon = jotai.atom((get) => {
+            const termMode = get(this.termMode);
+            if (termMode == "vdom") {
+                return "bolt";
+            }
+            const isCmd = get(this.isCmdController);
+            if (isCmd) {
+            }
+            return "terminal";
+        });
+        this.viewName = jotai.atom((get) => {
+            const blockData = get(this.blockAtom);
+            const termMode = get(this.termMode);
+            if (termMode == "vdom") {
+                return "Wave App";
+            }
+            if (blockData?.meta?.controller == "cmd") {
+                return "";
+            }
+            return "Terminal";
+        });
+        this.viewText = jotai.atom((get) => {
+            const termMode = get(this.termMode);
+            if (termMode == "vdom") {
+                return [
+                    {
+                        elemtype: "iconbutton",
+                        icon: "square-terminal",
+                        title: "Switch back to Terminal",
+                        click: () => {
+                            this.setTermMode("term");
+                        },
+                    },
+                ];
+            }
+            const vdomBlockId = get(this.vdomBlockId);
+            const rtn: HeaderElem[] = [];
+            if (vdomBlockId) {
+                rtn.push({
+                    elemtype: "iconbutton",
+                    icon: "bolt",
+                    title: "Switch to Wave App",
+                    click: () => {
+                        this.setTermMode("vdom");
+                    },
+                });
+            }
+            const isCmd = get(this.isCmdController);
+            if (isCmd) {
+                const blockMeta = get(this.blockAtom)?.meta;
+                let cmdText = blockMeta?.["cmd"];
+                let cmdArgs = blockMeta?.["cmd:args"];
+                if (cmdArgs != null && Array.isArray(cmdArgs) && cmdArgs.length > 0) {
+                    cmdText += " " + cmdArgs.join(" ");
+                }
+                rtn.push({
+                    elemtype: "text",
+                    text: cmdText,
+                    noGrow: true,
+                });
+                const isRestarting = get(this.isRestarting);
+                if (isRestarting) {
+                    rtn.push({
+                        elemtype: "iconbutton",
+                        icon: "refresh",
+                        iconColor: "var(--success-color)",
+                        iconSpin: true,
+                        title: "Restarting Command",
+                        noAction: true,
+                    });
+                } else {
+                    const fullShellProcStatus = get(this.shellProcFullStatus);
+                    if (fullShellProcStatus?.shellprocstatus == "done") {
+                        if (fullShellProcStatus?.shellprocexitcode == 0) {
+                            rtn.push({
+                                elemtype: "iconbutton",
+                                icon: "check",
+                                iconColor: "var(--success-color)",
+                                title: "Command Exited Successfully",
+                                noAction: true,
+                            });
+                        } else {
+                            rtn.push({
+                                elemtype: "iconbutton",
+                                icon: "xmark-large",
+                                iconColor: "var(--error-color)",
+                                title: "Exit Code: " + fullShellProcStatus?.shellprocexitcode,
+                                noAction: true,
+                            });
+                        }
+                    }
+                }
+            }
+            const isMI = get(atoms.isTermMultiInput);
+            if (isMI && this.isBasicTerm(get)) {
+                rtn.push({
+                    elemtype: "textbutton",
+                    text: "Multi Input ON",
+                    className: "yellow !py-[2px] !px-[10px] text-[11px] font-[500]",
+                    title: "Input will be sent to all connected terminals (click to disable)",
+                    onClick: () => {
+                        globalStore.set(atoms.isTermMultiInput, false);
+                    },
+                });
+            }
+            return rtn;
+        });
+        this.manageConnection = jotai.atom((get) => {
+            const termMode = get(this.termMode);
+            if (termMode == "vdom") {
+                return false;
+            }
+            const isCmd = get(this.isCmdController);
+            if (isCmd) {
+                return false;
+            }
+            return true;
+        });
+        this.filterOutNowsh = jotai.atom(false);
+        this.termThemeNameAtom = useBlockAtom(blockId, "termthemeatom", () => {
+            return jotai.atom<string>((get) => {
+                return get(getOverrideConfigAtom(this.blockId, "term:theme")) ?? DefaultTermTheme;
+            });
+        });
+        this.termTransparencyAtom = useBlockAtom(blockId, "termtransparencyatom", () => {
+            return jotai.atom<number>((get) => {
+                let value = get(getOverrideConfigAtom(this.blockId, "term:transparency")) ?? 0.5;
+                return boundNumber(value, 0, 1);
+            });
+        });
+        this.blockBg = jotai.atom((get) => {
+            const fullConfig = get(atoms.fullConfigAtom);
+            const themeName = get(this.termThemeNameAtom);
+            const termTransparency = get(this.termTransparencyAtom);
+            const [_, bgcolor] = computeTheme(fullConfig, themeName, termTransparency);
+            if (bgcolor != null) {
+                return { bg: bgcolor };
+            }
+            return null;
+        });
+        this.connStatus = jotai.atom((get) => {
+            const blockData = get(this.blockAtom);
+            const connName = blockData?.meta?.connection;
+            const connAtom = getConnStatusAtom(connName);
+            return get(connAtom);
+        });
+        this.fontSizeAtom = useBlockAtom(blockId, "fontsizeatom", () => {
+            return jotai.atom<number>((get) => {
+                const blockData = get(this.blockAtom);
+                const fsSettingsAtom = getSettingsKeyAtom("term:fontsize");
+                const settingsFontSize = get(fsSettingsAtom);
+                const connName = blockData?.meta?.connection;
+                const fullConfig = get(atoms.fullConfigAtom);
+                const connFontSize = fullConfig?.connections?.[connName]?.["term:fontsize"];
+                const rtnFontSize = blockData?.meta?.["term:fontsize"] ?? connFontSize ?? settingsFontSize ?? 12;
+                if (typeof rtnFontSize != "number" || isNaN(rtnFontSize) || rtnFontSize < 4 || rtnFontSize > 64) {
+                    return 12;
+                }
+                return rtnFontSize;
+            });
+        });
+        this.noPadding = jotai.atom(true);
+        this.endIconButtons = jotai.atom((get) => {
+            const blockData = get(this.blockAtom);
+            const shellProcStatus = get(this.shellProcStatus);
+            const connStatus = get(this.connStatus);
+            const isCmd = get(this.isCmdController);
+            const rtn: IconButtonDecl[] = [];
+
+            const isAIPanelOpen = get(WorkspaceLayoutModel.getInstance().panelVisibleAtom);
+            if (isAIPanelOpen) {
+                const shellIntegrationButton = this.getShellIntegrationIconButton(get);
+                if (shellIntegrationButton) {
+                    rtn.push(shellIntegrationButton);
+                }
+            }
+
+            if (blockData?.meta?.["controller"] != "cmd" && shellProcStatus != "done") {
+                return rtn;
+            }
+            if (connStatus?.status != "connected") {
+                return rtn;
+            }
+            let iconName: string = null;
+            let title: string = null;
+            const noun = isCmd ? "Command" : "Shell";
+            if (shellProcStatus == "init") {
+                iconName = "play";
+                title = "Click to Start " + noun;
+            } else if (shellProcStatus == "running") {
+                iconName = "refresh";
+                title = noun + " Running. Click to Restart";
+            } else if (shellProcStatus == "done") {
+                iconName = "refresh";
+                title = noun + " Exited. Click to Restart";
+            }
+            if (iconName != null) {
+                const buttonDecl: IconButtonDecl = {
+                    elemtype: "iconbutton",
+                    icon: iconName,
+                    click: this.forceRestartController.bind(this),
+                    title: title,
+                };
+                rtn.push(buttonDecl);
+            }
+            return rtn;
+        });
+        this.isCmdController = jotai.atom((get) => {
+            const controllerMetaAtom = getBlockMetaKeyAtom(this.blockId, "controller");
+            return get(controllerMetaAtom) == "cmd";
+        });
+        this.shellProcFullStatus = jotai.atom(null) as jotai.PrimitiveAtom<BlockControllerRuntimeStatus>;
+        const initialShellProcStatus = services.BlockService.GetControllerStatus(blockId);
+        initialShellProcStatus.then((rts) => {
+            this.updateShellProcStatus(rts);
+        });
+        this.shellProcStatusUnsubFn = waveEventSubscribe({
+            eventType: "controllerstatus",
+            scope: WOS.makeORef("block", blockId),
+            handler: (event) => {
+                let bcRTS: BlockControllerRuntimeStatus = event.data;
+                this.updateShellProcStatus(bcRTS);
+            },
+        });
+        this.shellProcStatus = jotai.atom((get) => {
+            const fullStatus = get(this.shellProcFullStatus);
+            return fullStatus?.shellprocstatus ?? "init";
+        });
+    }
+
+    getShellIntegrationIconButton(get: jotai.Getter): IconButtonDecl | null {
+        if (!this.termRef.current?.shellIntegrationStatusAtom) {
+            return null;
+        }
+        const shellIntegrationStatus = get(this.termRef.current.shellIntegrationStatusAtom);
+        if (shellIntegrationStatus == null) {
+            return {
+                elemtype: "iconbutton",
+                icon: "sparkles",
+                className: "text-muted",
+                title: "No shell integration — Wave AI unable to run commands.",
+                noAction: true,
+            };
+        }
+        if (shellIntegrationStatus === "ready") {
+            return {
+                elemtype: "iconbutton",
+                icon: "sparkles",
+                className: "text-accent",
+                title: "Shell ready — Wave AI can run commands in this terminal.",
+                noAction: true,
+            };
+        }
+        if (shellIntegrationStatus === "running-command") {
+            let title = "Shell busy — Wave AI unable to run commands while another command is running.";
+
+            if (this.termRef.current) {
+                const inAltBuffer = this.termRef.current.terminal?.buffer?.active?.type === "alternate";
+                const lastCommand = get(this.termRef.current.lastCommandAtom);
+                const blockingCmd = getBlockingCommand(lastCommand, inAltBuffer);
+                if (blockingCmd) {
+                    title = `Wave AI integration disabled while you're inside ${blockingCmd}.`;
+                }
+            }
+
+            return {
+                elemtype: "iconbutton",
+                icon: "sparkles",
+                className: "text-warning",
+                title: title,
+                noAction: true,
+            };
+        }
+        return null;
+    }
+
+    get viewComponent(): ViewComponent {
+        return TerminalView as ViewComponent;
+    }
+
+    isBasicTerm(getFn: jotai.Getter): boolean {
+        const termMode = getFn(this.termMode);
+        if (termMode == "vdom") {
+            return false;
+        }
+        const blockData = getFn(this.blockAtom);
+        if (blockData?.meta?.controller == "cmd") {
+            return false;
+        }
+        return true;
+    }
+
+    multiInputHandler(data: string) {
+        const tvms = getAllBasicTermModels();
+        for (const tvm of tvms) {
+            if (tvm != this) {
+                tvm.sendDataToController(data);
+            }
+        }
+    }
+
+    sendDataToController(data: string) {
+        const b64data = stringToBase64(data);
+        RpcApi.ControllerInputCommand(TabRpcClient, { blockid: this.blockId, inputdata64: b64data });
+    }
+
+    setTermMode(mode: "term" | "vdom") {
+        if (mode == "term") {
+            mode = null;
+        }
+        RpcApi.SetMetaCommand(TabRpcClient, {
+            oref: WOS.makeORef("block", this.blockId),
+            meta: { "term:mode": mode },
+        });
+    }
+
+    triggerRestartAtom() {
+        globalStore.set(this.isRestarting, true);
+        setTimeout(() => {
+            globalStore.set(this.isRestarting, false);
+        }, 300);
+    }
+
+    updateShellProcStatus(fullStatus: BlockControllerRuntimeStatus) {
+        if (fullStatus == null) {
+            return;
+        }
+        const curStatus = globalStore.get(this.shellProcFullStatus);
+        if (curStatus == null || curStatus.version < fullStatus.version) {
+            globalStore.set(this.shellProcFullStatus, fullStatus);
+        }
+    }
+
+    getVDomModel(): VDomModel {
+        const vdomBlockId = globalStore.get(this.vdomBlockId);
+        if (!vdomBlockId) {
+            return null;
+        }
+        const bcm = getBlockComponentModel(vdomBlockId);
+        if (!bcm) {
+            return null;
+        }
+        return bcm.viewModel as VDomModel;
+    }
+
+    getVDomToolbarModel(): VDomModel {
+        const vdomToolbarBlockId = globalStore.get(this.vdomToolbarBlockId);
+        if (!vdomToolbarBlockId) {
+            return null;
+        }
+        const bcm = getBlockComponentModel(vdomToolbarBlockId);
+        if (!bcm) {
+            return null;
+        }
+        return bcm.viewModel as VDomModel;
+    }
+
+    dispose() {
+        DefaultRouter.unregisterRoute(makeFeBlockRouteId(this.blockId));
+        if (this.shellProcStatusUnsubFn) {
+            this.shellProcStatusUnsubFn();
+        }
+    }
+
+    giveFocus(): boolean {
+        if (this.searchAtoms && globalStore.get(this.searchAtoms.isOpen)) {
+            console.log("search is open, not giving focus");
+            return true;
+        }
+        let termMode = globalStore.get(this.termMode);
+        if (termMode == "term") {
+            if (this.termRef?.current?.terminal) {
+                this.termRef.current.terminal.focus();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    keyDownHandler(waveEvent: WaveKeyboardEvent): boolean {
+        if (keyutil.checkKeyPressed(waveEvent, "Cmd:Escape")) {
+            const blockAtom = WOS.getWaveObjectAtom<Block>(`block:${this.blockId}`);
+            const blockData = globalStore.get(blockAtom);
+            const newTermMode = blockData?.meta?.["term:mode"] == "vdom" ? null : "vdom";
+            const vdomBlockId = globalStore.get(this.vdomBlockId);
+            if (newTermMode == "vdom" && !vdomBlockId) {
+                return;
+            }
+            this.setTermMode(newTermMode);
+            return true;
+        }
+        const blockData = globalStore.get(this.blockAtom);
+        if (blockData.meta?.["term:mode"] == "vdom") {
+            const vdomModel = this.getVDomModel();
+            return vdomModel?.keyDownHandler(waveEvent);
+        }
+        return false;
+    }
+
+    handleTerminalKeydown(event: KeyboardEvent): boolean {
+        const waveEvent = keyutil.adaptFromReactOrNativeKeyEvent(event);
+        if (waveEvent.type != "keydown") {
+            return true;
+        }
+        if (this.keyDownHandler(waveEvent)) {
+            event.preventDefault();
+            event.stopPropagation();
+            return false;
+        }
+        if (keyutil.checkKeyPressed(waveEvent, "Shift:Enter")) {
+            const shiftEnterNewlineAtom = getOverrideConfigAtom(this.blockId, "term:shiftenternewline");
+            const shiftEnterNewlineEnabled = globalStore.get(shiftEnterNewlineAtom) ?? false;
+            if (shiftEnterNewlineEnabled) {
+                this.sendDataToController("\u001b\n");
+                event.preventDefault();
+                event.stopPropagation();
+                return false;
+            }
+        }
+        if (keyutil.checkKeyPressed(waveEvent, "Ctrl:Shift:v")) {
+            const p = navigator.clipboard.readText();
+            p.then((text) => {
+                this.termRef.current?.terminal.paste(text);
+            });
+            event.preventDefault();
+            event.stopPropagation();
+            return false;
+        } else if (keyutil.checkKeyPressed(waveEvent, "Ctrl:Shift:c")) {
+            const sel = this.termRef.current?.terminal.getSelection();
+            navigator.clipboard.writeText(sel);
+            event.preventDefault();
+            event.stopPropagation();
+            return false;
+        } else if (keyutil.checkKeyPressed(waveEvent, "Cmd:k")) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.termRef.current?.terminal?.clear();
+            return false;
+        }
+        const shellProcStatus = globalStore.get(this.shellProcStatus);
+        if ((shellProcStatus == "done" || shellProcStatus == "init") && keyutil.checkKeyPressed(waveEvent, "Enter")) {
+            this.forceRestartController();
+            return false;
+        }
+        return true;
+    }
+
+    setTerminalTheme(themeName: string) {
+        RpcApi.SetMetaCommand(TabRpcClient, {
+            oref: WOS.makeORef("block", this.blockId),
+            meta: { "term:theme": themeName },
+        });
+    }
+
+    forceRestartController() {
+        if (globalStore.get(this.isRestarting)) {
+            return;
+        }
+        this.triggerRestartAtom();
+        const termsize = {
+            rows: this.termRef.current?.terminal?.rows,
+            cols: this.termRef.current?.terminal?.cols,
+        };
+        const prtn = RpcApi.ControllerResyncCommand(TabRpcClient, {
+            tabid: globalStore.get(atoms.staticTabId),
+            blockid: this.blockId,
+            forcerestart: true,
+            rtopts: { termsize: termsize },
+        });
+        prtn.catch((e) => console.log("error controller resync (force restart)", e));
+    }
+
+    getSettingsMenuItems(): ContextMenuItem[] {
+        const fullConfig = globalStore.get(atoms.fullConfigAtom);
+        const termThemes = fullConfig?.termthemes ?? {};
+        const termThemeKeys = Object.keys(termThemes);
+        const curThemeName = globalStore.get(getBlockMetaKeyAtom(this.blockId, "term:theme"));
+        const defaultFontSize = globalStore.get(getSettingsKeyAtom("term:fontsize")) ?? 12;
+        const transparencyMeta = globalStore.get(getBlockMetaKeyAtom(this.blockId, "term:transparency"));
+        const blockData = globalStore.get(this.blockAtom);
+        const overrideFontSize = blockData?.meta?.["term:fontsize"];
+
+        termThemeKeys.sort((a, b) => {
+            return (termThemes[a]["display:order"] ?? 0) - (termThemes[b]["display:order"] ?? 0);
+        });
+        const fullMenu: ContextMenuItem[] = [];
+        const submenu: ContextMenuItem[] = termThemeKeys.map((themeName) => {
+            return {
+                label: termThemes[themeName]["display:name"] ?? themeName,
+                type: "checkbox",
+                checked: curThemeName == themeName,
+                click: () => this.setTerminalTheme(themeName),
+            };
+        });
+        submenu.unshift({
+            label: "Default",
+            type: "checkbox",
+            checked: curThemeName == null,
+            click: () => this.setTerminalTheme(null),
+        });
+        const transparencySubMenu: ContextMenuItem[] = [];
+        transparencySubMenu.push({
+            label: "Default",
+            type: "checkbox",
+            checked: transparencyMeta == null,
+            click: () => {
+                RpcApi.SetMetaCommand(TabRpcClient, {
+                    oref: WOS.makeORef("block", this.blockId),
+                    meta: { "term:transparency": null },
+                });
+            },
+        });
+        transparencySubMenu.push({
+            label: "Transparent Background",
+            type: "checkbox",
+            checked: transparencyMeta == 0.5,
+            click: () => {
+                RpcApi.SetMetaCommand(TabRpcClient, {
+                    oref: WOS.makeORef("block", this.blockId),
+                    meta: { "term:transparency": 0.5 },
+                });
+            },
+        });
+        transparencySubMenu.push({
+            label: "No Transparency",
+            type: "checkbox",
+            checked: transparencyMeta == 0,
+            click: () => {
+                RpcApi.SetMetaCommand(TabRpcClient, {
+                    oref: WOS.makeORef("block", this.blockId),
+                    meta: { "term:transparency": 0 },
+                });
+            },
+        });
+
+        const fontSizeSubMenu: ContextMenuItem[] = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18].map(
+            (fontSize: number) => {
+                return {
+                    label: fontSize.toString() + "px",
+                    type: "checkbox",
+                    checked: overrideFontSize == fontSize,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:fontsize": fontSize },
+                        });
+                    },
+                };
+            }
+        );
+        fontSizeSubMenu.unshift({
+            label: "Default (" + defaultFontSize + "px)",
+            type: "checkbox",
+            checked: overrideFontSize == null,
+            click: () => {
+                RpcApi.SetMetaCommand(TabRpcClient, {
+                    oref: WOS.makeORef("block", this.blockId),
+                    meta: { "term:fontsize": null },
+                });
+            },
+        });
+        fullMenu.push({
+            label: "Themes",
+            submenu: submenu,
+        });
+        fullMenu.push({
+            label: "Font Size",
+            submenu: fontSizeSubMenu,
+        });
+        fullMenu.push({
+            label: "Transparency",
+            submenu: transparencySubMenu,
+        });
+        fullMenu.push({ type: "separator" });
+        fullMenu.push({
+            label: "Force Restart Controller",
+            click: this.forceRestartController.bind(this),
+        });
+        const isClearOnStart = blockData?.meta?.["cmd:clearonstart"];
+        fullMenu.push({
+            label: "Clear Output On Restart",
+            submenu: [
+                {
+                    label: "On",
+                    type: "checkbox",
+                    checked: isClearOnStart,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "cmd:clearonstart": true },
+                        });
+                    },
+                },
+                {
+                    label: "Off",
+                    type: "checkbox",
+                    checked: !isClearOnStart,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "cmd:clearonstart": false },
+                        });
+                    },
+                },
+            ],
+        });
+        const runOnStart = blockData?.meta?.["cmd:runonstart"];
+        fullMenu.push({
+            label: "Run On Startup",
+            submenu: [
+                {
+                    label: "On",
+                    type: "checkbox",
+                    checked: runOnStart,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "cmd:runonstart": true },
+                        });
+                    },
+                },
+                {
+                    label: "Off",
+                    type: "checkbox",
+                    checked: !runOnStart,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "cmd:runonstart": false },
+                        });
+                    },
+                },
+            ],
+        });
+        if (blockData?.meta?.["term:vdomtoolbarblockid"]) {
+            fullMenu.push({ type: "separator" });
+            fullMenu.push({
+                label: "Close Toolbar",
+                click: () => {
+                    RpcApi.DeleteSubBlockCommand(TabRpcClient, { blockid: blockData.meta["term:vdomtoolbarblockid"] });
+                },
+            });
+        }
+        const debugConn = blockData?.meta?.["term:conndebug"];
+        fullMenu.push({
+            label: "Debug Connection",
+            submenu: [
+                {
+                    label: "Off",
+                    type: "checkbox",
+                    checked: !debugConn,
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:conndebug": null },
+                        });
+                    },
+                },
+                {
+                    label: "Info",
+                    type: "checkbox",
+                    checked: debugConn == "info",
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:conndebug": "info" },
+                        });
+                    },
+                },
+                {
+                    label: "Verbose",
+                    type: "checkbox",
+                    checked: debugConn == "debug",
+                    click: () => {
+                        RpcApi.SetMetaCommand(TabRpcClient, {
+                            oref: WOS.makeORef("block", this.blockId),
+                            meta: { "term:conndebug": "debug" },
+                        });
+                    },
+                },
+            ],
+        });
+        return fullMenu;
+    }
+}
+
+export function getAllBasicTermModels(): TermViewModel[] {
+    const termModels: TermViewModel[] = [];
+    const bcms = getAllBlockComponentModels();
+    for (const bcm of bcms) {
+        if (bcm?.viewModel?.viewType == "term") {
+            const tvm = bcm.viewModel as TermViewModel;
+            if (tvm.isBasicTerm((atom) => globalStore.get(atom))) {
+                termModels.push(tvm);
+            }
+        }
+    }
+    return termModels;
+}
+
+export function makeTerminalModel(blockId: string, nodeModel: BlockNodeModel): TermViewModel {
+    return new TermViewModel(blockId, nodeModel);
+}
diff --git a/frontend/app/view/term/term-wsh.tsx b/frontend/app/view/term/term-wsh.tsx
index 099e4bb7e4..782a174913 100644
--- a/frontend/app/view/term/term-wsh.tsx
+++ b/frontend/app/view/term/term-wsh.tsx
@@ -6,7 +6,7 @@ import { makeORef, splitORef } from "@/app/store/wos";
 import { RpcResponseHelper, WshClient } from "@/app/store/wshclient";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { makeFeBlockRouteId } from "@/app/store/wshrouter";
-import { TermViewModel } from "@/app/view/term/term";
+import { TermViewModel } from "@/app/view/term/term-model";
 import { isBlank } from "@/util/util";
 import debug from "debug";
 
@@ -122,6 +122,44 @@ export class TermWshClient extends WshClient {
         const totalLines = buffer.length;
         const lines: string[] = [];
 
+        if (data.lastcommand) {
+            if (globalStore.get(termWrap.shellIntegrationStatusAtom) == null) {
+                throw new Error("Cannot get last command data without shell integration");
+            }
+
+            let startLine = 0;
+            if (termWrap.promptMarkers.length > 0) {
+                const lastMarker = termWrap.promptMarkers[termWrap.promptMarkers.length - 1];
+                const markerLine = lastMarker.line;
+                startLine = totalLines - markerLine;
+            }
+
+            const endLine = totalLines;
+            for (let i = startLine; i < endLine; i++) {
+                const bufferIndex = totalLines - 1 - i;
+                const line = buffer.getLine(bufferIndex);
+                if (line) {
+                    lines.push(line.translateToString(true));
+                }
+            }
+
+            lines.reverse();
+
+            let returnLines = lines;
+            let returnStartLine = startLine;
+            if (lines.length > 1000) {
+                returnLines = lines.slice(lines.length - 1000);
+                returnStartLine = startLine + (lines.length - 1000);
+            }
+
+            return {
+                totallines: totalLines,
+                linestart: returnStartLine,
+                lines: returnLines,
+                lastupdated: termWrap.lastUpdated,
+            };
+        }
+
         const startLine = Math.max(0, data.linestart);
         const endLine = Math.min(totalLines, data.lineend);
 
diff --git a/frontend/app/view/term/term.tsx b/frontend/app/view/term/term.tsx
index 37f146838d..b232e886ac 100644
--- a/frontend/app/view/term/term.tsx
+++ b/frontend/app/view/term/term.tsx
@@ -2,31 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Block, SubBlock } from "@/app/block/block";
-import { BlockNodeModel } from "@/app/block/blocktypes";
 import { Search, useSearch } from "@/app/element/search";
-import { appHandleKeyDown } from "@/app/store/keymodel";
 import { waveEventSubscribe } from "@/app/store/wps";
 import { RpcApi } from "@/app/store/wshclientapi";
-import { makeFeBlockRouteId } from "@/app/store/wshrouter";
-import { DefaultRouter, TabRpcClient } from "@/app/store/wshrpcutil";
-import { TermWshClient } from "@/app/view/term/term-wsh";
-import { VDomModel } from "@/app/view/vdom/vdom-model";
-import {
-    atoms,
-    getAllBlockComponentModels,
-    getBlockComponentModel,
-    getBlockMetaKeyAtom,
-    getConnStatusAtom,
-    getOverrideConfigAtom,
-    getSettingsKeyAtom,
-    getSettingsPrefixAtom,
-    globalStore,
-    useBlockAtom,
-    WOS,
-} from "@/store/global";
-import * as services from "@/store/services";
-import * as keyutil from "@/util/keyutil";
-import { boundNumber, fireAndForget, stringToBase64, useAtomValueSafe } from "@/util/util";
+import { TabRpcClient } from "@/app/store/wshrpcutil";
+import type { TermViewModel } from "@/app/view/term/term-model";
+import { atoms, getOverrideConfigAtom, getSettingsPrefixAtom, globalStore, WOS } from "@/store/global";
+import { fireAndForget, useAtomValueSafe } from "@/util/util";
 import { computeBgStyleFromMeta } from "@/util/waveutil";
 import { ISearchOptions } from "@xterm/addon-search";
 import clsx from "clsx";
@@ -35,7 +17,7 @@ import * as jotai from "jotai";
 import * as React from "react";
 import { TermStickers } from "./termsticker";
 import { TermThemeUpdater } from "./termtheme";
-import { computeTheme, DefaultTermTheme } from "./termutil";
+import { computeTheme } from "./termutil";
 import { TermWrap } from "./termwrap";
 import "./xterm.css";
 
@@ -46,721 +28,6 @@ type InitialLoadDataType = {
     heldData: Uint8Array[];
 };
 
-class TermViewModel implements ViewModel {
-    viewType: string;
-    nodeModel: BlockNodeModel;
-    connected: boolean;
-    termRef: React.MutableRefObject<TermWrap> = { current: null };
-    blockAtom: jotai.Atom<Block>;
-    termMode: jotai.Atom<string>;
-    blockId: string;
-    viewIcon: jotai.Atom<string>;
-    viewName: jotai.Atom<string>;
-    viewText: jotai.Atom<HeaderElem[]>;
-    blockBg: jotai.Atom<MetaType>;
-    manageConnection: jotai.Atom<boolean>;
-    filterOutNowsh?: jotai.Atom<boolean>;
-    connStatus: jotai.Atom<ConnStatus>;
-    termWshClient: TermWshClient;
-    vdomBlockId: jotai.Atom<string>;
-    vdomToolbarBlockId: jotai.Atom<string>;
-    vdomToolbarTarget: jotai.PrimitiveAtom<VDomTargetToolbar>;
-    fontSizeAtom: jotai.Atom<number>;
-    termThemeNameAtom: jotai.Atom<string>;
-    termTransparencyAtom: jotai.Atom<number>;
-    noPadding: jotai.PrimitiveAtom<boolean>;
-    endIconButtons: jotai.Atom<IconButtonDecl[]>;
-    shellProcFullStatus: jotai.PrimitiveAtom<BlockControllerRuntimeStatus>;
-    shellProcStatus: jotai.Atom<string>;
-    shellProcStatusUnsubFn: () => void;
-    isCmdController: jotai.Atom<boolean>;
-    isRestarting: jotai.PrimitiveAtom<boolean>;
-    searchAtoms?: SearchAtoms;
-
-    constructor(blockId: string, nodeModel: BlockNodeModel) {
-        this.viewType = "term";
-        this.blockId = blockId;
-        this.termWshClient = new TermWshClient(blockId, this);
-        DefaultRouter.registerRoute(makeFeBlockRouteId(blockId), this.termWshClient);
-        this.nodeModel = nodeModel;
-        this.blockAtom = WOS.getWaveObjectAtom<Block>(`block:${blockId}`);
-        this.vdomBlockId = jotai.atom((get) => {
-            const blockData = get(this.blockAtom);
-            return blockData?.meta?.["term:vdomblockid"];
-        });
-        this.vdomToolbarBlockId = jotai.atom((get) => {
-            const blockData = get(this.blockAtom);
-            return blockData?.meta?.["term:vdomtoolbarblockid"];
-        });
-        this.vdomToolbarTarget = jotai.atom<VDomTargetToolbar>(null) as jotai.PrimitiveAtom<VDomTargetToolbar>;
-        this.termMode = jotai.atom((get) => {
-            const blockData = get(this.blockAtom);
-            return blockData?.meta?.["term:mode"] ?? "term";
-        });
-        this.isRestarting = jotai.atom(false);
-        this.viewIcon = jotai.atom((get) => {
-            const termMode = get(this.termMode);
-            if (termMode == "vdom") {
-                return "bolt";
-            }
-            const isCmd = get(this.isCmdController);
-            if (isCmd) {
-            }
-            return "terminal";
-        });
-        this.viewName = jotai.atom((get) => {
-            const blockData = get(this.blockAtom);
-            const termMode = get(this.termMode);
-            if (termMode == "vdom") {
-                return "Wave App";
-            }
-            if (blockData?.meta?.controller == "cmd") {
-                return "";
-            }
-            return "Terminal";
-        });
-        this.viewText = jotai.atom((get) => {
-            const termMode = get(this.termMode);
-            if (termMode == "vdom") {
-                return [
-                    {
-                        elemtype: "iconbutton",
-                        icon: "square-terminal",
-                        title: "Switch back to Terminal",
-                        click: () => {
-                            this.setTermMode("term");
-                        },
-                    },
-                ];
-            }
-            const vdomBlockId = get(this.vdomBlockId);
-            const rtn: HeaderElem[] = [];
-            if (vdomBlockId) {
-                rtn.push({
-                    elemtype: "iconbutton",
-                    icon: "bolt",
-                    title: "Switch to Wave App",
-                    click: () => {
-                        this.setTermMode("vdom");
-                    },
-                });
-            }
-            const isCmd = get(this.isCmdController);
-            if (isCmd) {
-                const blockMeta = get(this.blockAtom)?.meta;
-                let cmdText = blockMeta?.["cmd"];
-                let cmdArgs = blockMeta?.["cmd:args"];
-                if (cmdArgs != null && Array.isArray(cmdArgs) && cmdArgs.length > 0) {
-                    cmdText += " " + cmdArgs.join(" ");
-                }
-                rtn.push({
-                    elemtype: "text",
-                    text: cmdText,
-                    noGrow: true,
-                });
-                const isRestarting = get(this.isRestarting);
-                if (isRestarting) {
-                    rtn.push({
-                        elemtype: "iconbutton",
-                        icon: "refresh",
-                        iconColor: "var(--success-color)",
-                        iconSpin: true,
-                        title: "Restarting Command",
-                        noAction: true,
-                    });
-                } else {
-                    const fullShellProcStatus = get(this.shellProcFullStatus);
-                    if (fullShellProcStatus?.shellprocstatus == "done") {
-                        if (fullShellProcStatus?.shellprocexitcode == 0) {
-                            rtn.push({
-                                elemtype: "iconbutton",
-                                icon: "check",
-                                iconColor: "var(--success-color)",
-                                title: "Command Exited Successfully",
-                                noAction: true,
-                            });
-                        } else {
-                            rtn.push({
-                                elemtype: "iconbutton",
-                                icon: "xmark-large",
-                                iconColor: "var(--error-color)",
-                                title: "Exit Code: " + fullShellProcStatus?.shellprocexitcode,
-                                noAction: true,
-                            });
-                        }
-                    }
-                }
-            }
-            const isMI = get(atoms.isTermMultiInput);
-            if (isMI && this.isBasicTerm(get)) {
-                rtn.push({
-                    elemtype: "textbutton",
-                    text: "Multi Input ON",
-                    className: "yellow !py-[2px] !px-[10px] text-[11px] font-[500]",
-                    title: "Input will be sent to all connected terminals (click to disable)",
-                    onClick: () => {
-                        globalStore.set(atoms.isTermMultiInput, false);
-                    },
-                });
-            }
-            return rtn;
-        });
-        this.manageConnection = jotai.atom((get) => {
-            const termMode = get(this.termMode);
-            if (termMode == "vdom") {
-                return false;
-            }
-            const isCmd = get(this.isCmdController);
-            if (isCmd) {
-                return false;
-            }
-            return true;
-        });
-        this.filterOutNowsh = jotai.atom(false);
-        this.termThemeNameAtom = useBlockAtom(blockId, "termthemeatom", () => {
-            return jotai.atom<string>((get) => {
-                return get(getOverrideConfigAtom(this.blockId, "term:theme")) ?? DefaultTermTheme;
-            });
-        });
-        this.termTransparencyAtom = useBlockAtom(blockId, "termtransparencyatom", () => {
-            return jotai.atom<number>((get) => {
-                let value = get(getOverrideConfigAtom(this.blockId, "term:transparency")) ?? 0.5;
-                return boundNumber(value, 0, 1);
-            });
-        });
-        this.blockBg = jotai.atom((get) => {
-            const fullConfig = get(atoms.fullConfigAtom);
-            const themeName = get(this.termThemeNameAtom);
-            const termTransparency = get(this.termTransparencyAtom);
-            const [_, bgcolor] = computeTheme(fullConfig, themeName, termTransparency);
-            if (bgcolor != null) {
-                return { bg: bgcolor };
-            }
-            return null;
-        });
-        this.connStatus = jotai.atom((get) => {
-            const blockData = get(this.blockAtom);
-            const connName = blockData?.meta?.connection;
-            const connAtom = getConnStatusAtom(connName);
-            return get(connAtom);
-        });
-        this.fontSizeAtom = useBlockAtom(blockId, "fontsizeatom", () => {
-            return jotai.atom<number>((get) => {
-                const blockData = get(this.blockAtom);
-                const fsSettingsAtom = getSettingsKeyAtom("term:fontsize");
-                const settingsFontSize = get(fsSettingsAtom);
-                const connName = blockData?.meta?.connection;
-                const fullConfig = get(atoms.fullConfigAtom);
-                const connFontSize = fullConfig?.connections?.[connName]?.["term:fontsize"];
-                const rtnFontSize = blockData?.meta?.["term:fontsize"] ?? connFontSize ?? settingsFontSize ?? 12;
-                if (typeof rtnFontSize != "number" || isNaN(rtnFontSize) || rtnFontSize < 4 || rtnFontSize > 64) {
-                    return 12;
-                }
-                return rtnFontSize;
-            });
-        });
-        this.noPadding = jotai.atom(true);
-        this.endIconButtons = jotai.atom((get) => {
-            const blockData = get(this.blockAtom);
-            const shellProcStatus = get(this.shellProcStatus);
-            const connStatus = get(this.connStatus);
-            const isCmd = get(this.isCmdController);
-            if (blockData?.meta?.["controller"] != "cmd" && shellProcStatus != "done") {
-                return [];
-            }
-            if (connStatus?.status != "connected") {
-                return [];
-            }
-            let iconName: string = null;
-            let title: string = null;
-            const noun = isCmd ? "Command" : "Shell";
-            if (shellProcStatus == "init") {
-                iconName = "play";
-                title = "Click to Start " + noun;
-            } else if (shellProcStatus == "running") {
-                iconName = "refresh";
-                title = noun + " Running. Click to Restart";
-            } else if (shellProcStatus == "done") {
-                iconName = "refresh";
-                title = noun + " Exited. Click to Restart";
-            }
-            if (iconName == null) {
-                return [];
-            }
-            const buttonDecl: IconButtonDecl = {
-                elemtype: "iconbutton",
-                icon: iconName,
-                click: this.forceRestartController.bind(this),
-                title: title,
-            };
-            const rtn = [buttonDecl];
-            return rtn;
-        });
-        this.isCmdController = jotai.atom((get) => {
-            const controllerMetaAtom = getBlockMetaKeyAtom(this.blockId, "controller");
-            return get(controllerMetaAtom) == "cmd";
-        });
-        this.shellProcFullStatus = jotai.atom(null) as jotai.PrimitiveAtom<BlockControllerRuntimeStatus>;
-        const initialShellProcStatus = services.BlockService.GetControllerStatus(blockId);
-        initialShellProcStatus.then((rts) => {
-            this.updateShellProcStatus(rts);
-        });
-        this.shellProcStatusUnsubFn = waveEventSubscribe({
-            eventType: "controllerstatus",
-            scope: WOS.makeORef("block", blockId),
-            handler: (event) => {
-                let bcRTS: BlockControllerRuntimeStatus = event.data;
-                this.updateShellProcStatus(bcRTS);
-            },
-        });
-        this.shellProcStatus = jotai.atom((get) => {
-            const fullStatus = get(this.shellProcFullStatus);
-            return fullStatus?.shellprocstatus ?? "init";
-        });
-    }
-
-    get viewComponent(): ViewComponent {
-        return TerminalView;
-    }
-
-    isBasicTerm(getFn: jotai.Getter): boolean {
-        // needs to match "const isBasicTerm" in TerminalView()
-        const termMode = getFn(this.termMode);
-        if (termMode == "vdom") {
-            return false;
-        }
-        const blockData = getFn(this.blockAtom);
-        if (blockData?.meta?.controller == "cmd") {
-            return false;
-        }
-        return true;
-    }
-
-    multiInputHandler(data: string) {
-        let tvms = getAllBasicTermModels();
-        // filter out "this" from the list
-        tvms = tvms.filter((tvm) => tvm != this);
-        if (tvms.length == 0) {
-            return;
-        }
-        for (const tvm of tvms) {
-            tvm.sendDataToController(data);
-        }
-    }
-
-    sendDataToController(data: string) {
-        const b64data = stringToBase64(data);
-        RpcApi.ControllerInputCommand(TabRpcClient, { blockid: this.blockId, inputdata64: b64data });
-    }
-
-    setTermMode(mode: "term" | "vdom") {
-        if (mode == "term") {
-            mode = null;
-        }
-        RpcApi.SetMetaCommand(TabRpcClient, {
-            oref: WOS.makeORef("block", this.blockId),
-            meta: { "term:mode": mode },
-        });
-    }
-
-    triggerRestartAtom() {
-        globalStore.set(this.isRestarting, true);
-        setTimeout(() => {
-            globalStore.set(this.isRestarting, false);
-        }, 300);
-    }
-
-    updateShellProcStatus(fullStatus: BlockControllerRuntimeStatus) {
-        if (fullStatus == null) {
-            return;
-        }
-        const curStatus = globalStore.get(this.shellProcFullStatus);
-        if (curStatus == null || curStatus.version < fullStatus.version) {
-            globalStore.set(this.shellProcFullStatus, fullStatus);
-        }
-    }
-
-    getVDomModel(): VDomModel {
-        const vdomBlockId = globalStore.get(this.vdomBlockId);
-        if (!vdomBlockId) {
-            return null;
-        }
-        const bcm = getBlockComponentModel(vdomBlockId);
-        if (!bcm) {
-            return null;
-        }
-        return bcm.viewModel as VDomModel;
-    }
-
-    getVDomToolbarModel(): VDomModel {
-        const vdomToolbarBlockId = globalStore.get(this.vdomToolbarBlockId);
-        if (!vdomToolbarBlockId) {
-            return null;
-        }
-        const bcm = getBlockComponentModel(vdomToolbarBlockId);
-        if (!bcm) {
-            return null;
-        }
-        return bcm.viewModel as VDomModel;
-    }
-
-    dispose() {
-        DefaultRouter.unregisterRoute(makeFeBlockRouteId(this.blockId));
-        if (this.shellProcStatusUnsubFn) {
-            this.shellProcStatusUnsubFn();
-        }
-    }
-
-    giveFocus(): boolean {
-        if (this.searchAtoms && globalStore.get(this.searchAtoms.isOpen)) {
-            console.log("search is open, not giving focus");
-            return true;
-        }
-        let termMode = globalStore.get(this.termMode);
-        if (termMode == "term") {
-            if (this.termRef?.current?.terminal) {
-                this.termRef.current.terminal.focus();
-                return true;
-            }
-        }
-        return false;
-    }
-
-    keyDownHandler(waveEvent: WaveKeyboardEvent): boolean {
-        if (keyutil.checkKeyPressed(waveEvent, "Cmd:Escape")) {
-            const blockAtom = WOS.getWaveObjectAtom<Block>(`block:${this.blockId}`);
-            const blockData = globalStore.get(blockAtom);
-            const newTermMode = blockData?.meta?.["term:mode"] == "vdom" ? null : "vdom";
-            const vdomBlockId = globalStore.get(this.vdomBlockId);
-            if (newTermMode == "vdom" && !vdomBlockId) {
-                return;
-            }
-            this.setTermMode(newTermMode);
-            return true;
-        }
-        const blockData = globalStore.get(this.blockAtom);
-        if (blockData.meta?.["term:mode"] == "vdom") {
-            const vdomModel = this.getVDomModel();
-            return vdomModel?.keyDownHandler(waveEvent);
-        }
-        return false;
-    }
-
-    handleTerminalKeydown(event: KeyboardEvent): boolean {
-        const waveEvent = keyutil.adaptFromReactOrNativeKeyEvent(event);
-        if (waveEvent.type != "keydown") {
-            return true;
-        }
-        if (this.keyDownHandler(waveEvent)) {
-            event.preventDefault();
-            event.stopPropagation();
-            return false;
-        }
-        // deal with terminal specific keybindings
-        if (keyutil.checkKeyPressed(waveEvent, "Shift:Enter")) {
-            // Check if shift+enter newline is enabled via config
-            const shiftEnterNewlineAtom = getOverrideConfigAtom(this.blockId, "term:shiftenternewline");
-            const shiftEnterNewlineEnabled = globalStore.get(shiftEnterNewlineAtom) ?? false;
-            if (shiftEnterNewlineEnabled) {
-                // Support for claude code - send escape sequence + newline instead of carriage return
-                this.sendDataToController("\u001b\n");
-                event.preventDefault();
-                event.stopPropagation();
-                return false;
-            }
-        }
-        if (keyutil.checkKeyPressed(waveEvent, "Ctrl:Shift:v")) {
-            const p = navigator.clipboard.readText();
-            p.then((text) => {
-                this.termRef.current?.terminal.paste(text);
-            });
-            event.preventDefault();
-            event.stopPropagation();
-            return false;
-        } else if (keyutil.checkKeyPressed(waveEvent, "Ctrl:Shift:c")) {
-            const sel = this.termRef.current?.terminal.getSelection();
-            navigator.clipboard.writeText(sel);
-            event.preventDefault();
-            event.stopPropagation();
-            return false;
-        } else if (keyutil.checkKeyPressed(waveEvent, "Cmd:k")) {
-            event.preventDefault();
-            event.stopPropagation();
-            this.termRef.current?.terminal?.clear();
-            return false;
-        }
-        const shellProcStatus = globalStore.get(this.shellProcStatus);
-        if ((shellProcStatus == "done" || shellProcStatus == "init") && keyutil.checkKeyPressed(waveEvent, "Enter")) {
-            this.forceRestartController();
-            return false;
-        }
-        const appHandled = appHandleKeyDown(waveEvent);
-        if (appHandled) {
-            event.preventDefault();
-            event.stopPropagation();
-            return false;
-        }
-        return true;
-    }
-
-    setTerminalTheme(themeName: string) {
-        RpcApi.SetMetaCommand(TabRpcClient, {
-            oref: WOS.makeORef("block", this.blockId),
-            meta: { "term:theme": themeName },
-        });
-    }
-
-    forceRestartController() {
-        if (globalStore.get(this.isRestarting)) {
-            return;
-        }
-        this.triggerRestartAtom();
-        const termsize = {
-            rows: this.termRef.current?.terminal?.rows,
-            cols: this.termRef.current?.terminal?.cols,
-        };
-        const prtn = RpcApi.ControllerResyncCommand(TabRpcClient, {
-            tabid: globalStore.get(atoms.staticTabId),
-            blockid: this.blockId,
-            forcerestart: true,
-            rtopts: { termsize: termsize },
-        });
-        prtn.catch((e) => console.log("error controller resync (force restart)", e));
-    }
-
-    getSettingsMenuItems(): ContextMenuItem[] {
-        const fullConfig = globalStore.get(atoms.fullConfigAtom);
-        const termThemes = fullConfig?.termthemes ?? {};
-        const termThemeKeys = Object.keys(termThemes);
-        const curThemeName = globalStore.get(getBlockMetaKeyAtom(this.blockId, "term:theme"));
-        const defaultFontSize = globalStore.get(getSettingsKeyAtom("term:fontsize")) ?? 12;
-        const transparencyMeta = globalStore.get(getBlockMetaKeyAtom(this.blockId, "term:transparency"));
-        const blockData = globalStore.get(this.blockAtom);
-        const overrideFontSize = blockData?.meta?.["term:fontsize"];
-
-        termThemeKeys.sort((a, b) => {
-            return (termThemes[a]["display:order"] ?? 0) - (termThemes[b]["display:order"] ?? 0);
-        });
-        const fullMenu: ContextMenuItem[] = [];
-        const submenu: ContextMenuItem[] = termThemeKeys.map((themeName) => {
-            return {
-                label: termThemes[themeName]["display:name"] ?? themeName,
-                type: "checkbox",
-                checked: curThemeName == themeName,
-                click: () => this.setTerminalTheme(themeName),
-            };
-        });
-        submenu.unshift({
-            label: "Default",
-            type: "checkbox",
-            checked: curThemeName == null,
-            click: () => this.setTerminalTheme(null),
-        });
-        const transparencySubMenu: ContextMenuItem[] = [];
-        transparencySubMenu.push({
-            label: "Default",
-            type: "checkbox",
-            checked: transparencyMeta == null,
-            click: () => {
-                RpcApi.SetMetaCommand(TabRpcClient, {
-                    oref: WOS.makeORef("block", this.blockId),
-                    meta: { "term:transparency": null },
-                });
-            },
-        });
-        transparencySubMenu.push({
-            label: "Transparent Background",
-            type: "checkbox",
-            checked: transparencyMeta == 0.5,
-            click: () => {
-                RpcApi.SetMetaCommand(TabRpcClient, {
-                    oref: WOS.makeORef("block", this.blockId),
-                    meta: { "term:transparency": 0.5 },
-                });
-            },
-        });
-        transparencySubMenu.push({
-            label: "No Transparency",
-            type: "checkbox",
-            checked: transparencyMeta == 0,
-            click: () => {
-                RpcApi.SetMetaCommand(TabRpcClient, {
-                    oref: WOS.makeORef("block", this.blockId),
-                    meta: { "term:transparency": 0 },
-                });
-            },
-        });
-
-        const fontSizeSubMenu: ContextMenuItem[] = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18].map(
-            (fontSize: number) => {
-                return {
-                    label: fontSize.toString() + "px",
-                    type: "checkbox",
-                    checked: overrideFontSize == fontSize,
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "term:fontsize": fontSize },
-                        });
-                    },
-                };
-            }
-        );
-        fontSizeSubMenu.unshift({
-            label: "Default (" + defaultFontSize + "px)",
-            type: "checkbox",
-            checked: overrideFontSize == null,
-            click: () => {
-                RpcApi.SetMetaCommand(TabRpcClient, {
-                    oref: WOS.makeORef("block", this.blockId),
-                    meta: { "term:fontsize": null },
-                });
-            },
-        });
-        fullMenu.push({
-            label: "Themes",
-            submenu: submenu,
-        });
-        fullMenu.push({
-            label: "Font Size",
-            submenu: fontSizeSubMenu,
-        });
-        fullMenu.push({
-            label: "Transparency",
-            submenu: transparencySubMenu,
-        });
-        fullMenu.push({ type: "separator" });
-        fullMenu.push({
-            label: "Force Restart Controller",
-            click: this.forceRestartController.bind(this),
-        });
-        const isClearOnStart = blockData?.meta?.["cmd:clearonstart"];
-        fullMenu.push({
-            label: "Clear Output On Restart",
-            submenu: [
-                {
-                    label: "On",
-                    type: "checkbox",
-                    checked: isClearOnStart,
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "cmd:clearonstart": true },
-                        });
-                    },
-                },
-                {
-                    label: "Off",
-                    type: "checkbox",
-                    checked: !isClearOnStart,
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "cmd:clearonstart": false },
-                        });
-                    },
-                },
-            ],
-        });
-        const runOnStart = blockData?.meta?.["cmd:runonstart"];
-        fullMenu.push({
-            label: "Run On Startup",
-            submenu: [
-                {
-                    label: "On",
-                    type: "checkbox",
-                    checked: runOnStart,
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "cmd:runonstart": true },
-                        });
-                    },
-                },
-                {
-                    label: "Off",
-                    type: "checkbox",
-                    checked: !runOnStart,
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "cmd:runonstart": false },
-                        });
-                    },
-                },
-            ],
-        });
-        if (blockData?.meta?.["term:vdomtoolbarblockid"]) {
-            fullMenu.push({ type: "separator" });
-            fullMenu.push({
-                label: "Close Toolbar",
-                click: () => {
-                    RpcApi.DeleteSubBlockCommand(TabRpcClient, { blockid: blockData.meta["term:vdomtoolbarblockid"] });
-                },
-            });
-        }
-        const debugConn = blockData?.meta?.["term:conndebug"];
-        fullMenu.push({
-            label: "Debug Connection",
-            submenu: [
-                {
-                    label: "Off",
-                    type: "checkbox",
-                    checked: !debugConn,
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "term:conndebug": null },
-                        });
-                    },
-                },
-                {
-                    label: "Info",
-                    type: "checkbox",
-                    checked: debugConn == "info",
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "term:conndebug": "info" },
-                        });
-                    },
-                },
-                {
-                    label: "Verbose",
-                    type: "checkbox",
-                    checked: debugConn == "debug",
-                    click: () => {
-                        RpcApi.SetMetaCommand(TabRpcClient, {
-                            oref: WOS.makeORef("block", this.blockId),
-                            meta: { "term:conndebug": "debug" },
-                        });
-                    },
-                },
-            ],
-        });
-        return fullMenu;
-    }
-}
-
-function getAllBasicTermModels(): TermViewModel[] {
-    const allBCMs = getAllBlockComponentModels();
-    const rtn: TermViewModel[] = [];
-    for (const bcm of allBCMs) {
-        if (bcm.viewModel?.viewType != "term") {
-            continue;
-        }
-        const termVM = bcm.viewModel as TermViewModel;
-        if (termVM.isBasicTerm(globalStore.get)) {
-            rtn.push(termVM);
-        }
-    }
-    return rtn;
-}
-
-function makeTerminalModel(blockId: string, nodeModel: BlockNodeModel): TermViewModel {
-    return new TermViewModel(blockId, nodeModel);
-}
-
 interface TerminalViewProps {
     blockId: string;
     model: TermViewModel;
@@ -1106,4 +373,4 @@ const TerminalView = ({ blockId, model }: ViewComponentProps<TermViewModel>) =>
     );
 };
 
-export { makeTerminalModel, TerminalView, TermViewModel };
+export { TerminalView };
diff --git a/frontend/app/view/term/termtheme.ts b/frontend/app/view/term/termtheme.ts
index e78e38b79f..1ea7631bdd 100644
--- a/frontend/app/view/term/termtheme.ts
+++ b/frontend/app/view/term/termtheme.ts
@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { TermViewModel } from "@/app/view/term/term";
+import type { TermViewModel } from "@/app/view/term/term-model";
 import { computeTheme } from "@/app/view/term/termutil";
 import { TermWrap } from "@/app/view/term/termwrap";
 import { atoms } from "@/store/global";
diff --git a/frontend/app/view/term/termwrap.ts b/frontend/app/view/term/termwrap.ts
index 5d9e64b564..932c1b219f 100644
--- a/frontend/app/view/term/termwrap.ts
+++ b/frontend/app/view/term/termwrap.ts
@@ -16,6 +16,7 @@ import { WebglAddon } from "@xterm/addon-webgl";
 import * as TermTypes from "@xterm/xterm";
 import { Terminal } from "@xterm/xterm";
 import debug from "debug";
+import * as jotai from "jotai";
 import { debounce } from "throttle-debounce";
 import { FitAddon } from "./fitaddon";
 
@@ -171,8 +172,36 @@ function handleOsc7Command(data: string, blockId: string, loaded: boolean): bool
     return true;
 }
 
+// some POC concept code for adding a decoration to a marker
+function addTestMarkerDecoration(terminal: Terminal, marker: TermTypes.IMarker, termWrap: TermWrap): void {
+    const decoration = terminal.registerDecoration({
+        marker: marker,
+        layer: "top",
+    });
+    if (!decoration) {
+        return;
+    }
+    decoration.onRender((el) => {
+        el.classList.add("wave-decoration");
+        el.classList.add("bg-ansi-white");
+        el.dataset.markerline = String(marker.line);
+        if (!el.querySelector(".wave-deco-line")) {
+            const line = document.createElement("div");
+            line.classList.add("wave-deco-line", "bg-accent/20");
+            line.style.position = "absolute";
+            line.style.top = "0";
+            line.style.left = "0";
+            line.style.width = "500px";
+            line.style.height = "1px";
+            el.appendChild(line);
+        }
+    });
+}
+
 // OSC 16162 - Shell Integration Commands
 // See aiprompts/wave-osc-16162.md for full documentation
+type ShellIntegrationStatus = "ready" | "running-command";
+
 type Osc16162Command =
     | { command: "A"; data: {} }
     | { command: "C"; data: { cmd64?: string } }
@@ -181,7 +210,8 @@ type Osc16162Command =
     | { command: "I"; data: { inputempty?: boolean } }
     | { command: "R"; data: {} };
 
-function handleOsc16162Command(data: string, blockId: string, loaded: boolean, terminal: Terminal): boolean {
+function handleOsc16162Command(data: string, blockId: string, loaded: boolean, termWrap: TermWrap): boolean {
+    const terminal = termWrap.terminal;
     if (!loaded) {
         return true;
     }
@@ -206,24 +236,41 @@ function handleOsc16162Command(data: string, blockId: string, loaded: boolean, t
     switch (cmd.command) {
         case "A":
             rtInfo["shell:state"] = "ready";
+            globalStore.set(termWrap.shellIntegrationStatusAtom, "ready");
+            const marker = terminal.registerMarker(0);
+            if (marker) {
+                termWrap.promptMarkers.push(marker);
+                // addTestMarkerDecoration(terminal, marker, termWrap);
+                marker.onDispose(() => {
+                    const idx = termWrap.promptMarkers.indexOf(marker);
+                    if (idx !== -1) {
+                        termWrap.promptMarkers.splice(idx, 1);
+                    }
+                });
+            }
             break;
         case "C":
             rtInfo["shell:state"] = "running-command";
+            globalStore.set(termWrap.shellIntegrationStatusAtom, "running-command");
             if (cmd.data.cmd64) {
                 const decodedLen = Math.ceil(cmd.data.cmd64.length * 0.75);
                 if (decodedLen > 8192) {
                     rtInfo["shell:lastcmd"] = `# command too large (${decodedLen} bytes)`;
+                    globalStore.set(termWrap.lastCommandAtom, rtInfo["shell:lastcmd"]);
                 } else {
                     try {
                         const decodedCmd = atob(cmd.data.cmd64);
                         rtInfo["shell:lastcmd"] = decodedCmd;
+                        globalStore.set(termWrap.lastCommandAtom, decodedCmd);
                     } catch (e) {
                         console.error("Error decoding cmd64:", e);
                         rtInfo["shell:lastcmd"] = null;
+                        globalStore.set(termWrap.lastCommandAtom, null);
                     }
                 }
             } else {
                 rtInfo["shell:lastcmd"] = null;
+                globalStore.set(termWrap.lastCommandAtom, null);
             }
             // also clear lastcmdexitcode (since we've now started a new command)
             rtInfo["shell:lastcmdexitcode"] = null;
@@ -255,6 +302,7 @@ function handleOsc16162Command(data: string, blockId: string, loaded: boolean, t
             }
             break;
         case "R":
+            globalStore.set(termWrap.shellIntegrationStatusAtom, null);
             if (terminal.buffer.active.type === "alternate") {
                 terminal.write("\x1b[?1049l");
             }
@@ -298,6 +346,9 @@ export class TermWrap {
     private toDispose: TermTypes.IDisposable[] = [];
     pasteActive: boolean = false;
     lastUpdated: number;
+    promptMarkers: TermTypes.IMarker[] = [];
+    shellIntegrationStatusAtom: jotai.PrimitiveAtom<"ready" | "running-command" | null>;
+    lastCommandAtom: jotai.PrimitiveAtom<string | null>;
 
     constructor(
         blockId: string,
@@ -312,6 +363,11 @@ export class TermWrap {
         this.dataBytesProcessed = 0;
         this.hasResized = false;
         this.lastUpdated = Date.now();
+        this.promptMarkers = [];
+        this.shellIntegrationStatusAtom = jotai.atom(null) as jotai.PrimitiveAtom<
+            "ready" | "running-command" | null
+        >;
+        this.lastCommandAtom = jotai.atom(null) as jotai.PrimitiveAtom<string | null>;
         this.terminal = new Terminal(options);
         this.fitAddon = new FitAddon();
         this.fitAddon.noScrollbar = PLATFORM === PlatformMacOS;
@@ -358,7 +414,7 @@ export class TermWrap {
             return handleOsc7Command(data, this.blockId, this.loaded);
         });
         this.terminal.parser.registerOscHandler(16162, (data: string) => {
-            return handleOsc16162Command(data, this.blockId, this.loaded, this.terminal);
+            return handleOsc16162Command(data, this.blockId, this.loaded, this);
         });
         this.terminal.attachCustomKeyEventHandler(waveOptions.keydownHandler);
         this.connectElem = connectElem;
@@ -404,6 +460,25 @@ export class TermWrap {
         }
         this.mainFileSubject = getFileSubject(this.blockId, TermFileName);
         this.mainFileSubject.subscribe(this.handleNewFileSubjectData.bind(this));
+        
+        try {
+            const rtInfo = await RpcApi.GetRTInfoCommand(TabRpcClient, {
+                oref: WOS.makeORef("block", this.blockId),
+            });
+            
+            if (rtInfo["shell:integration"]) {
+                const shellState = rtInfo["shell:state"] as ShellIntegrationStatus;
+                globalStore.set(this.shellIntegrationStatusAtom, shellState || null);
+            } else {
+                globalStore.set(this.shellIntegrationStatusAtom, null);
+            }
+            
+            const lastCmd = rtInfo["shell:lastcmd"];
+            globalStore.set(this.lastCommandAtom, lastCmd || null);
+        } catch (e) {
+            console.log("Error loading runtime info:", e);
+        }
+        
         try {
             await this.loadInitialTerminalData();
         } finally {
@@ -413,6 +488,12 @@ export class TermWrap {
     }
 
     dispose() {
+        this.promptMarkers.forEach((marker) => {
+            try {
+                marker.dispose();
+            } catch (_) {}
+        });
+        this.promptMarkers = [];
         this.terminal.dispose();
         this.toDispose.forEach((d) => {
             try {
diff --git a/frontend/types/gotypes.d.ts b/frontend/types/gotypes.d.ts
index 5a44c802a2..ce2c8f3455 100644
--- a/frontend/types/gotypes.d.ts
+++ b/frontend/types/gotypes.d.ts
@@ -296,6 +296,7 @@ declare global {
     type CommandTermGetScrollbackLinesData = {
         linestart: number;
         lineend: number;
+        lastcommand: boolean;
     };
 
     // wshrpc.CommandTermGetScrollbackLinesRtnData
diff --git a/frontend/util/util.ts b/frontend/util/util.ts
index 69e17fceb2..b963a20746 100644
--- a/frontend/util/util.ts
+++ b/frontend/util/util.ts
@@ -104,30 +104,48 @@ function makeIconClass(icon: string, fw: boolean, opts?: { spin?: boolean; defau
         }
         return null;
     }
+
+    let animation: string | null = null;
+    let hasFwModifier = false;
+
+    while (icon.match(/\+(spin|beat|fade|fw)$/)) {
+        const modifierMatch = icon.match(/\+(spin|beat|fade|fw)$/);
+        if (modifierMatch) {
+            const modifier = modifierMatch[1];
+            if (modifier === "fw") {
+                hasFwModifier = true;
+            } else {
+                animation = modifier;
+            }
+            icon = icon.replace(/\+(spin|beat|fade|fw)$/, "");
+        }
+    }
+
+    let baseClass: string;
     if (icon.match(/^(solid@)?[a-z0-9-]+$/)) {
-        // strip off "solid@" prefix if it exists
         icon = icon.replace(/^solid@/, "");
-        return clsx(`fa fa-solid fa-${icon}`, fw ? "fa-fw" : null, opts?.spin ? "fa-spin" : null);
-    }
-    if (icon.match(/^regular@[a-z0-9-]+$/)) {
-        // strip off the "regular@" prefix if it exists
+        baseClass = `fa fa-solid fa-${icon}`;
+    } else if (icon.match(/^regular@[a-z0-9-]+$/)) {
         icon = icon.replace(/^regular@/, "");
-        return clsx(`fa fa-sharp fa-regular fa-${icon}`, fw ? "fa-fw" : null, opts?.spin ? "fa-spin" : null);
-    }
-    if (icon.match(/^brands@[a-z0-9-]+$/)) {
-        // strip off the "brands@" prefix if it exists
+        baseClass = `fa fa-sharp fa-regular fa-${icon}`;
+    } else if (icon.match(/^brands@[a-z0-9-]+$/)) {
         icon = icon.replace(/^brands@/, "");
-        return clsx(`fa fa-brands fa-${icon}`, fw ? "fa-fw" : null, opts?.spin ? "fa-spin" : null);
-    }
-    if (icon.match(/^custom@[a-z0-9-]+$/)) {
-        // strip off the "custom@" prefix if it exists
+        baseClass = `fa fa-brands fa-${icon}`;
+    } else if (icon.match(/^custom@[a-z0-9-]+$/)) {
         icon = icon.replace(/^custom@/, "");
-        return clsx(`fa fa-kit fa-${icon}`, fw ? "fa-fw" : null, opts?.spin ? "fa-spin" : null);
-    }
-    if (opts?.defaultIcon != null) {
-        return makeIconClass(opts.defaultIcon, fw, { spin: opts?.spin });
+        baseClass = `fa fa-kit fa-${icon}`;
+    } else {
+        if (opts?.defaultIcon != null) {
+            return makeIconClass(opts.defaultIcon, fw, { spin: opts?.spin });
+        }
+        return null;
     }
-    return null;
+
+    const shouldAddFw = fw || hasFwModifier;
+    const hasSpin = animation === "spin" || opts?.spin;
+    const animationClass = animation && animation !== "spin" ? `fa-${animation}` : null;
+
+    return clsx(baseClass, shouldAddFw ? "fa-fw" : null, hasSpin ? "fa-spin" : null, animationClass);
 }
 
 /**
diff --git a/package-lock.json b/package-lock.json
index cd1c128bad..24a7815f79 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
     "name": "waveterm",
-    "version": "0.12.1-beta.0",
+    "version": "0.12.1",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "waveterm",
-            "version": "0.12.1-beta.0",
+            "version": "0.12.1",
             "hasInstallScript": true,
             "license": "Apache-2.0",
             "workspaces": [
diff --git a/pkg/aiusechat/tools.go b/pkg/aiusechat/tools.go
index b038848ce9..a270f0c24e 100644
--- a/pkg/aiusechat/tools.go
+++ b/pkg/aiusechat/tools.go
@@ -173,6 +173,7 @@ func GenerateTabStateAndTools(ctx context.Context, tabid string, widgetAccess bo
 		}
 		if viewTypes["term"] {
 			tools = append(tools, GetTermGetScrollbackToolDefinition(tabid))
+			tools = append(tools, GetTermCommandOutputToolDefinition(tabid))
 		}
 		if viewTypes["web"] {
 			tools = append(tools, GetWebNavigateToolDefinition(tabid))
diff --git a/pkg/aiusechat/tools_term.go b/pkg/aiusechat/tools_term.go
index dfbc764855..57c9164bbe 100644
--- a/pkg/aiusechat/tools_term.go
+++ b/pkg/aiusechat/tools_term.go
@@ -81,6 +81,76 @@ func parseTermGetScrollbackInput(input any) (*TermGetScrollbackToolInput, error)
 	return result, nil
 }
 
+func getTermScrollbackOutput(tabId string, widgetId string, rpcData wshrpc.CommandTermGetScrollbackLinesData) (*TermGetScrollbackToolOutput, error) {
+	ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancelFn()
+
+	fullBlockId, err := wcore.ResolveBlockIdFromPrefix(ctx, tabId, widgetId)
+	if err != nil {
+		return nil, err
+	}
+
+	rpcClient := wshclient.GetBareRpcClient()
+	result, err := wshclient.TermGetScrollbackLinesCommand(
+		rpcClient,
+		rpcData,
+		&wshrpc.RpcOpts{Route: wshutil.MakeFeBlockRouteId(fullBlockId)},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	content := strings.Join(result.Lines, "\n")
+	var effectiveLineEnd int
+	if rpcData.LastCommand {
+		effectiveLineEnd = result.LineStart + len(result.Lines)
+	} else {
+		effectiveLineEnd = min(rpcData.LineEnd, result.TotalLines)
+	}
+	hasMore := effectiveLineEnd < result.TotalLines
+
+	var sinceLastOutputSec *int
+	if result.LastUpdated > 0 {
+		sec := max(0, int((time.Now().UnixMilli()-result.LastUpdated)/1000))
+		sinceLastOutputSec = &sec
+	}
+
+	var nextStart *int
+	if hasMore {
+		nextStart = &effectiveLineEnd
+	}
+
+	blockORef := waveobj.MakeORef(waveobj.OType_Block, fullBlockId)
+	rtInfo := wstore.GetRTInfo(blockORef)
+
+	var lastCommand *CommandInfo
+	if rtInfo != nil && rtInfo.ShellIntegration && rtInfo.ShellLastCmd != "" {
+		cmdInfo := &CommandInfo{
+			Command: rtInfo.ShellLastCmd,
+		}
+		if rtInfo.ShellState == "running-command" {
+			cmdInfo.Status = "running"
+		} else if rtInfo.ShellState == "ready" {
+			cmdInfo.Status = "completed"
+			exitCode := rtInfo.ShellLastCmdExitCode
+			cmdInfo.ExitCode = &exitCode
+		}
+		lastCommand = cmdInfo
+	}
+
+	return &TermGetScrollbackToolOutput{
+		TotalLines:         result.TotalLines,
+		LineStart:          result.LineStart,
+		LineEnd:            effectiveLineEnd,
+		ReturnedLines:      len(result.Lines),
+		Content:            content,
+		SinceLastOutputSec: sinceLastOutputSec,
+		HasMore:            hasMore,
+		NextStart:          nextStart,
+		LastCommand:        lastCommand,
+	}, nil
+}
+
 func GetTermGetScrollbackToolDefinition(tabId string) uctypes.ToolDefinition {
 	return uctypes.ToolDefinition{
 		Name:        "term_get_scrollback",
@@ -97,12 +167,12 @@ func GetTermGetScrollbackToolDefinition(tabId string) uctypes.ToolDefinition {
 				"line_start": map[string]any{
 					"type":        "integer",
 					"minimum":     0,
-					"description": "Logical start index where 0 = most recent line (default: 0)",
+					"description": "Logical start index where 0 = most recent line (default: 0).",
 				},
 				"count": map[string]any{
 					"type":        "integer",
 					"minimum":     1,
-					"description": "Number of lines to return from line_start (default: 200)",
+					"description": "Number of lines to return from line_start (default: 200).",
 				},
 			},
 			"required":             []string{"widget_id"},
@@ -126,73 +196,107 @@ func GetTermGetScrollbackToolDefinition(tabId string) uctypes.ToolDefinition {
 				return nil, err
 			}
 
-			ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
-			defer cancelFn()
-
-			fullBlockId, err := wcore.ResolveBlockIdFromPrefix(ctx, tabId, parsed.WidgetId)
-			if err != nil {
-				return nil, err
-			}
-
 			lineEnd := parsed.LineStart + parsed.Count
-
-			rpcClient := wshclient.GetBareRpcClient()
-			result, err := wshclient.TermGetScrollbackLinesCommand(
-				rpcClient,
+			output, err := getTermScrollbackOutput(
+				tabId,
+				parsed.WidgetId,
 				wshrpc.CommandTermGetScrollbackLinesData{
-					LineStart: parsed.LineStart,
-					LineEnd:   lineEnd,
+					LineStart:   parsed.LineStart,
+					LineEnd:     lineEnd,
+					LastCommand: false,
 				},
-				&wshrpc.RpcOpts{Route: wshutil.MakeFeBlockRouteId(fullBlockId)},
 			)
 			if err != nil {
 				return nil, fmt.Errorf("failed to get terminal scrollback: %w", err)
 			}
+			return output, nil
+		},
+	}
+}
+
 
-			content := strings.Join(result.Lines, "\n")
-			effectiveLineEnd := min(lineEnd, result.TotalLines)
-			hasMore := effectiveLineEnd < result.TotalLines
+type TermCommandOutputToolInput struct {
+	WidgetId string `json:"widget_id"`
+}
+
+func parseTermCommandOutputInput(input any) (*TermCommandOutputToolInput, error) {
+	result := &TermCommandOutputToolInput{}
+
+	if input == nil {
+		return nil, fmt.Errorf("widget_id is required")
+	}
+
+	inputBytes, err := json.Marshal(input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal input: %w", err)
+	}
 
-			var sinceLastOutputSec *int
-			if result.LastUpdated > 0 {
-				sec := max(0, int((time.Now().UnixMilli()-result.LastUpdated)/1000))
-				sinceLastOutputSec = &sec
+	if err := json.Unmarshal(inputBytes, result); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal input: %w", err)
+	}
+
+	if result.WidgetId == "" {
+		return nil, fmt.Errorf("widget_id is required")
+	}
+
+	return result, nil
+}
+
+func GetTermCommandOutputToolDefinition(tabId string) uctypes.ToolDefinition {
+	return uctypes.ToolDefinition{
+		Name:        "term_command_output",
+		DisplayName: "Get Last Command Output",
+		Description: "Retrieve output from the most recent command in a terminal widget. Requires shell integration to be enabled. Returns the command text, exit code, and up to 1000 lines of output.",
+		ToolLogName: "term:commandoutput",
+		InputSchema: map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"widget_id": map[string]any{
+					"type":        "string",
+					"description": "8-character widget ID of the terminal widget",
+				},
+			},
+			"required":             []string{"widget_id"},
+			"additionalProperties": false,
+		},
+		ToolInputDesc: func(input any) string {
+			parsed, err := parseTermCommandOutputInput(input)
+			if err != nil {
+				return fmt.Sprintf("error parsing input: %v", err)
+			}
+			return fmt.Sprintf("reading last command output from %s", parsed.WidgetId)
+		},
+		ToolAnyCallback: func(input any) (any, error) {
+			parsed, err := parseTermCommandOutputInput(input)
+			if err != nil {
+				return nil, err
 			}
 
-			var nextStart *int
-			if hasMore {
-				nextStart = &effectiveLineEnd
+			ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancelFn()
+
+			fullBlockId, err := wcore.ResolveBlockIdFromPrefix(ctx, tabId, parsed.WidgetId)
+			if err != nil {
+				return nil, err
 			}
 
 			blockORef := waveobj.MakeORef(waveobj.OType_Block, fullBlockId)
 			rtInfo := wstore.GetRTInfo(blockORef)
-
-			var lastCommand *CommandInfo
-			if rtInfo != nil && rtInfo.ShellIntegration && rtInfo.ShellLastCmd != "" {
-				cmdInfo := &CommandInfo{
-					Command: rtInfo.ShellLastCmd,
-				}
-				if rtInfo.ShellState == "running-command" {
-					cmdInfo.Status = "running"
-				} else if rtInfo.ShellState == "ready" {
-					cmdInfo.Status = "completed"
-					exitCode := rtInfo.ShellLastCmdExitCode
-					cmdInfo.ExitCode = &exitCode
-				}
-				lastCommand = cmdInfo
+			if rtInfo == nil || !rtInfo.ShellIntegration {
+				return nil, fmt.Errorf("shell integration is not enabled for this terminal")
 			}
 
-			return &TermGetScrollbackToolOutput{
-				TotalLines:         result.TotalLines,
-				LineStart:          result.LineStart,
-				LineEnd:            effectiveLineEnd,
-				ReturnedLines:      len(result.Lines),
-				Content:            content,
-				SinceLastOutputSec: sinceLastOutputSec,
-				HasMore:            hasMore,
-				NextStart:          nextStart,
-				LastCommand:        lastCommand,
-			}, nil
+			output, err := getTermScrollbackOutput(
+				tabId,
+				parsed.WidgetId,
+				wshrpc.CommandTermGetScrollbackLinesData{
+					LastCommand: true,
+				},
+			)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get command output: %w", err)
+			}
+			return output, nil
 		},
 	}
 }
diff --git a/pkg/blockcontroller/shellcontroller.go b/pkg/blockcontroller/shellcontroller.go
index 04124153f1..aca0864600 100644
--- a/pkg/blockcontroller/shellcontroller.go
+++ b/pkg/blockcontroller/shellcontroller.go
@@ -200,11 +200,11 @@ func (sc *ShellController) resetTerminalState(logCtx context.Context) {
 	blocklogger.Debugf(logCtx, "[conndebug] resetTerminalState: resetting terminal state\n")
 	// controller type = "shell"
 	var buf bytes.Buffer
-	buf.WriteString("\x1b[0m")     // reset attributes
-	buf.WriteString("\x1b[?25h")   // show cursor
-	buf.WriteString("\x1b[?1000l") // disable mouse tracking
-	buf.WriteString("\x1b[?1007l") // disable alternate scroll mode
-	buf.WriteString(shellutil.FormatOSC(16162, "R")) // OSC 16162 "R" - disable alternate screen mode (only if active)
+	buf.WriteString("\x1b[0m")                       // reset attributes
+	buf.WriteString("\x1b[?25h")                     // show cursor
+	buf.WriteString("\x1b[?1000l")                   // disable mouse tracking
+	buf.WriteString("\x1b[?1007l")                   // disable alternate scroll mode
+	buf.WriteString(shellutil.FormatOSC(16162, "R")) // OSC 16162 "R" - disable alternate screen mode (only if active), reset "shell integration" status.
 	buf.WriteString("\r\n\r\n")
 	err := HandleAppendBlockFile(sc.BlockId, wavebase.BlockFile_Term, buf.Bytes())
 	if err != nil {
diff --git a/pkg/wshrpc/wshrpctypes.go b/pkg/wshrpc/wshrpctypes.go
index f1abf21e04..b4cd905633 100644
--- a/pkg/wshrpc/wshrpctypes.go
+++ b/pkg/wshrpc/wshrpctypes.go
@@ -865,8 +865,9 @@ type CommandSetRTInfoData struct {
 }
 
 type CommandTermGetScrollbackLinesData struct {
-	LineStart int `json:"linestart"`
-	LineEnd   int `json:"lineend"`
+	LineStart   int  `json:"linestart"`
+	LineEnd     int  `json:"lineend"`
+	LastCommand bool `json:"lastcommand"`
 }
 
 type CommandTermGetScrollbackLinesRtnData struct {