diff --git a/frontend/app/aipanel/aimessage.tsx b/frontend/app/aipanel/aimessage.tsx
index 1bfadd121d..9491a56076 100644
--- a/frontend/app/aipanel/aimessage.tsx
+++ b/frontend/app/aipanel/aimessage.tsx
@@ -124,6 +124,7 @@ const AIMessagePart = memo(({ part, role, isStreaming }: AIMessagePartProps) =>
                     text={content}
                     parseIncompleteMarkdown={isStreaming}
                     className="text-gray-100"
+                    onClickSaveCommand={(cmd) => model.addSavedCommand(cmd)}
                     codeBlockMaxWidthAtom={model.codeBlockMaxWidth}
                 />
             );
diff --git a/frontend/app/aipanel/aipanel.tsx b/frontend/app/aipanel/aipanel.tsx
index 112a4cc79e..24bf0386a8 100644
--- a/frontend/app/aipanel/aipanel.tsx
+++ b/frontend/app/aipanel/aipanel.tsx
@@ -23,6 +23,7 @@ import { AIPanelHeader } from "./aipanelheader";
 import { AIPanelInput } from "./aipanelinput";
 import { AIPanelMessages } from "./aipanelmessages";
 import { AIRateLimitStrip } from "./airatelimitstrip";
+import { SavedCommandsPanel } from "./savedcommandspanel";
 import { WaveUIMessage } from "./aitypes";
 import { BYOKAnnouncement } from "./byokannouncement";
 import { TelemetryRequiredMessage } from "./telemetryrequired";
@@ -596,6 +597,7 @@ const AIPanelComponentInner = memo(() => {
                             />
                         )}
                         <AIErrorMessage />
+                        <SavedCommandsPanel />
                         <AIDroppedFiles model={model} />
                         <AIPanelInput onSubmit={handleSubmit} status={status} model={model} />
                     </>
diff --git a/frontend/app/aipanel/aitypes.ts b/frontend/app/aipanel/aitypes.ts
index fbce463a73..48955a532b 100644
--- a/frontend/app/aipanel/aitypes.ts
+++ b/frontend/app/aipanel/aitypes.ts
@@ -39,6 +39,13 @@ export type UseChatSetMessagesType = (
     messages: WaveUIMessage[] | ((messages: WaveUIMessage[]) => WaveUIMessage[])
 ) => void;
 
+export interface SavedCommand {
+    id: string;
+    text: string;
+    createdts?: number;
+    updatedts?: number;
+}
+
 export type UseChatSendMessageType = (
     message?:
         | (Omit<WaveUIMessage, "id" | "role"> & {
diff --git a/frontend/app/aipanel/savedcommandspanel.tsx b/frontend/app/aipanel/savedcommandspanel.tsx
new file mode 100644
index 0000000000..bef5fdd39c
--- /dev/null
+++ b/frontend/app/aipanel/savedcommandspanel.tsx
@@ -0,0 +1,125 @@
+// Copyright 2026, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { IconButton } from "@/app/element/iconbutton";
+import { useAtomValue } from "jotai";
+import { memo, useEffect, useState } from "react";
+import { SavedCommand } from "./aitypes";
+import { WaveAIModel } from "./waveai-model";
+
+const formatCommandPreview = (text: string): string => {
+    const firstLine = text.trim().split("\n")[0] ?? "";
+    return firstLine.length > 72 ? `${firstLine.slice(0, 69)}...` : firstLine;
+};
+
+const SavedCommandCard = memo(({ command }: { command: SavedCommand }) => {
+    const model = WaveAIModel.getInstance();
+
+    return (
+        <div className="rounded-md border border-white/10 bg-black/30 p-2">
+            <div className="mb-2 flex items-center justify-between gap-3">
+                <div className="truncate text-[11px] uppercase tracking-[0.18em] text-white/45">
+                    {formatCommandPreview(command.text || "Untitled command")}
+                </div>
+                <div className="flex items-center gap-1">
+                    <IconButton
+                        decl={{
+                            elemtype: "iconbutton",
+                            icon: "regular@square-terminal",
+                            title: "Run in focused terminal",
+                            click: () => void model.runSavedCommand(command.text),
+                            disabled: command.text.trim().length === 0,
+                        }}
+                    />
+                    <IconButton
+                        decl={{
+                            elemtype: "iconbutton",
+                            icon: "plus",
+                            title: "Insert into prompt",
+                            click: () => model.appendText(command.text, true, { scrollToBottom: true }),
+                            disabled: command.text.trim().length === 0,
+                        }}
+                    />
+                    <IconButton
+                        decl={{
+                            elemtype: "iconbutton",
+                            icon: "trash",
+                            title: "Remove saved command",
+                            click: () => model.removeSavedCommand(command.id),
+                        }}
+                    />
+                </div>
+            </div>
+            <textarea
+                value={command.text}
+                onChange={(e) => model.updateSavedCommand(command.id, e.target.value)}
+                spellCheck={false}
+                rows={Math.min(Math.max(command.text.split("\n").length || 1, 2), 6)}
+                placeholder="Enter a command..."
+                className="w-full resize-y rounded-md border border-white/10 bg-zinc-900 px-2 py-2 font-mono text-xs text-primary outline-none focus:border-accent"
+            />
+        </div>
+    );
+});
+
+SavedCommandCard.displayName = "SavedCommandCard";
+
+export const SavedCommandsPanel = memo(() => {
+    const model = WaveAIModel.getInstance();
+    const commands = useAtomValue(model.savedCommandsAtom);
+    const [isOpen, setIsOpen] = useState(commands.length > 0);
+
+    useEffect(() => {
+        if (commands.length > 0) {
+            setIsOpen(true);
+        }
+    }, [commands.length]);
+
+    return (
+        <div className="mx-2 mb-2 rounded-lg border border-white/10 bg-zinc-950/70">
+            <button
+                className="flex w-full items-center justify-between gap-3 px-3 py-2 text-left cursor-pointer"
+                onClick={() => setIsOpen(!isOpen)}
+            >
+                <div className="flex items-center gap-2 min-w-0">
+                    <i
+                        className={`fa-solid ${isOpen ? "fa-chevron-down" : "fa-chevron-right"} text-[11px] text-white/60`}
+                    />
+                    <span className="text-sm font-medium text-primary">Saved Commands</span>
+                    <span className="rounded-full bg-white/8 px-2 py-0.5 text-[11px] text-secondary">
+                        {commands.length}
+                    </span>
+                </div>
+                <div className="text-[11px] text-secondary">Reusable command snippets</div>
+            </button>
+            {isOpen && (
+                <div className="border-t border-white/10 px-3 py-3">
+                    <div className="mb-3 flex items-center justify-between gap-3">
+                        <div className="text-xs text-secondary">
+                            Save shell commands from AI replies, edit them here, and insert them back into the prompt.
+                        </div>
+                        <button
+                            className="rounded-md border border-white/10 px-2.5 py-1 text-xs text-primary hover:bg-white/5 cursor-pointer"
+                            onClick={() => model.addSavedCommand("")}
+                        >
+                            Add Command
+                        </button>
+                    </div>
+                    {commands.length === 0 ? (
+                        <div className="rounded-md border border-dashed border-white/10 px-3 py-4 text-sm text-secondary">
+                            No saved commands yet.
+                        </div>
+                    ) : (
+                        <div className="flex max-h-56 flex-col gap-3 overflow-y-auto pr-1">
+                            {commands.map((command) => (
+                                <SavedCommandCard key={command.id} command={command} />
+                            ))}
+                        </div>
+                    )}
+                </div>
+            )}
+        </div>
+    );
+});
+
+SavedCommandsPanel.displayName = "SavedCommandsPanel";
diff --git a/frontend/app/aipanel/waveai-model.tsx b/frontend/app/aipanel/waveai-model.tsx
index 9af1d88508..fab2b394dc 100644
--- a/frontend/app/aipanel/waveai-model.tsx
+++ b/frontend/app/aipanel/waveai-model.tsx
@@ -2,13 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import {
+    SavedCommand,
     UseChatSendMessageType,
     UseChatSetMessagesType,
     WaveUIMessage,
     WaveUIMessagePart,
 } from "@/app/aipanel/aitypes";
 import { FocusManager } from "@/app/store/focusManager";
-import { atoms, createBlock, getOrefMetaKeyAtom, getSettingsKeyAtom } from "@/app/store/global";
+import {
+    atoms,
+    createBlock,
+    getBlockComponentModel,
+    getFocusedBlockId,
+    getOrefMetaKeyAtom,
+    getSettingsKeyAtom,
+} from "@/app/store/global";
 import { globalStore } from "@/app/store/jotaiStore";
 import { isBuilderWindow } from "@/app/store/windowtype";
 import * as WOS from "@/app/store/wos";
@@ -65,6 +73,7 @@ export class WaveAIModel {
     errorMessage: jotai.PrimitiveAtom<string> = jotai.atom(null) as jotai.PrimitiveAtom<string>;
     containerWidth: jotai.PrimitiveAtom<number> = jotai.atom(0);
     codeBlockMaxWidth!: jotai.Atom<number>;
+    savedCommandsAtom: jotai.PrimitiveAtom<SavedCommand[]> = jotai.atom([]);
     inputAtom: jotai.PrimitiveAtom<string> = jotai.atom("");
     isLoadingChatAtom: jotai.PrimitiveAtom<boolean> = jotai.atom(false);
     isChatEmptyAtom: jotai.PrimitiveAtom<boolean> = jotai.atom(true);
@@ -282,6 +291,102 @@ export class WaveAIModel {
         this.useChatSetMessages?.([]);
     }
 
+    private normalizeSavedCommands(commands: ObjRTInfo["waveai:savedcommands"]): SavedCommand[] {
+        if (!Array.isArray(commands)) {
+            return [];
+        }
+        return commands
+            .filter((command): command is SavedCommand => command != null && typeof command.text === "string")
+            .map((command) => ({
+                id: command.id || crypto.randomUUID(),
+                text: command.text,
+                createdts: command.createdts ?? Date.now(),
+                updatedts: command.updatedts ?? command.createdts ?? Date.now(),
+            }));
+    }
+
+    private persistSavedCommands(commands: SavedCommand[]) {
+        globalStore.set(this.savedCommandsAtom, commands);
+        void RpcApi.SetRTInfoCommand(TabRpcClient, {
+            oref: this.orefContext,
+            data: { "waveai:savedcommands": commands.length > 0 ? commands : null },
+        }).catch((error) => {
+            console.error("Failed to persist saved commands:", error);
+        });
+    }
+
+    addSavedCommand(text: string): string {
+        const normalizedText = text.replace(/\n$/, "");
+        const now = Date.now();
+        const currentCommands = globalStore.get(this.savedCommandsAtom);
+        const existing = currentCommands.find(
+            (command) => command.text.trim() === normalizedText.trim() && normalizedText.trim().length > 0
+        );
+        if (existing) {
+            this.persistSavedCommands(
+                currentCommands.map((command) =>
+                    command.id === existing.id ? { ...command, updatedts: now } : command
+                )
+            );
+            return existing.id;
+        }
+
+        const nextCommand: SavedCommand = {
+            id: crypto.randomUUID(),
+            text: normalizedText,
+            createdts: now,
+            updatedts: now,
+        };
+        this.persistSavedCommands([nextCommand, ...currentCommands]);
+        return nextCommand.id;
+    }
+
+    updateSavedCommand(id: string, text: string) {
+        const now = Date.now();
+        this.persistSavedCommands(
+            globalStore.get(this.savedCommandsAtom).map((command) =>
+                command.id === id ? { ...command, text, updatedts: now } : command
+            )
+        );
+    }
+
+    removeSavedCommand(id: string) {
+        this.persistSavedCommands(globalStore.get(this.savedCommandsAtom).filter((command) => command.id !== id));
+    }
+
+    async runSavedCommand(text: string) {
+        const commandText = text.trim();
+        if (!commandText) {
+            return;
+        }
+        if (this.inBuilder) {
+            this.setError("Running saved commands in the terminal is not available from the builder.");
+            return;
+        }
+
+        const focusedBlockId = getFocusedBlockId();
+        if (!focusedBlockId) {
+            this.setError("Focus a terminal block, then run the saved command again.");
+            return;
+        }
+        const blockAtom = WOS.getWaveObjectAtom<Block>(WOS.makeORef("block", focusedBlockId));
+        const blockData = globalStore.get(blockAtom);
+        if (blockData?.meta?.view !== "term") {
+            this.setError("Focus a terminal block, then run the saved command again.");
+            return;
+        }
+        const blockComponentModel = getBlockComponentModel(focusedBlockId);
+        const termViewModel = blockComponentModel?.viewModel as { sendDataToController?: (data: string) => void };
+        if (typeof termViewModel?.sendDataToController !== "function") {
+            this.setError("The focused terminal is not ready to receive commands.");
+            return;
+        }
+
+        const commandWithNewline = text.endsWith("\n") ? text : `${text}\n`;
+        termViewModel.sendDataToController(commandWithNewline);
+        this.requestNodeFocus();
+    }
+
     setError(message: string) {
         globalStore.set(this.errorMessage, message);
     }
@@ -449,6 +554,7 @@ export class WaveAIModel {
         const rtInfo = await RpcApi.GetRTInfoCommand(TabRpcClient, {
             oref: this.orefContext,
         });
+        globalStore.set(this.savedCommandsAtom, this.normalizeSavedCommands(rtInfo?.["waveai:savedcommands"]));
         let chatIdValue = rtInfo?.["waveai:chatid"];
         if (chatIdValue == null) {
             chatIdValue = crypto.randomUUID();
diff --git a/frontend/app/element/streamdown.test.ts b/frontend/app/element/streamdown.test.ts
new file mode 100644
index 0000000000..86a2f73c5c
--- /dev/null
+++ b/frontend/app/element/streamdown.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+
+import { canSaveCommand } from "./streamdown";
+
+describe("canSaveCommand", () => {
+    it("accepts explicit shell code blocks", () => {
+        expect(canSaveCommand("bash", "npm run build")).toBe(true);
+        expect(canSaveCommand("pwsh", "Get-ChildItem")).toBe(true);
+    });
+
+    it("accepts shell-looking unlabeled blocks", () => {
+        expect(canSaveCommand("text", "$ git status\n$ npm test")).toBe(true);
+        expect(canSaveCommand("text", "docker compose up")).toBe(true);
+    });
+
+    it("rejects empty or obviously non-command blocks", () => {
+        expect(canSaveCommand("text", "")).toBe(false);
+        expect(canSaveCommand("javascript", "const x = 1;\nconsole.log(x);")).toBe(false);
+        expect(canSaveCommand("text", "This is explanatory prose, not a command.")).toBe(false);
+    });
+});
diff --git a/frontend/app/element/streamdown.tsx b/frontend/app/element/streamdown.tsx
index 2426f385e2..58100d738d 100644
--- a/frontend/app/element/streamdown.tsx
+++ b/frontend/app/element/streamdown.tsx
@@ -121,10 +121,45 @@ export function Code({ className = "", children }: { className?: string; childre
 type CodeBlockProps = {
     children: React.ReactNode;
     onClickExecute?: (cmd: string) => void;
+    onClickSaveCommand?: (cmd: string) => void;
     codeBlockMaxWidthAtom?: Atom<number>;
 };
 
-const CodeBlock = ({ children, onClickExecute, codeBlockMaxWidthAtom }: CodeBlockProps) => {
+const shellLanguages = new Set(["bash", "sh", "zsh", "shell", "fish", "console", "terminal", "powershell", "pwsh"]);
+
+export function canSaveCommand(language: string, text: string): boolean {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return false;
+    }
+    const normalizedLanguage = language.toLowerCase();
+    if (shellLanguages.has(normalizedLanguage)) {
+        return true;
+    }
+    if (normalizedLanguage !== "text" && normalizedLanguage !== "") {
+        return false;
+    }
+    const lines = trimmed
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0 || lines.length > 12) {
+        return false;
+    }
+    return lines.every((line) => {
+        if (!/^(?:[$>#]\s+)?[a-zA-Z0-9_.\/~-]+/.test(line)) {
+            return false;
+        }
+        const normalizedLine = line.replace(/^(?:[$>#]\s+)/, "");
+        const firstToken = normalizedLine.split(/\s+/)[0] ?? "";
+        if (/^[A-Z][a-z]+$/.test(firstToken)) {
+            return false;
+        }
+        return !/[.!?]$/.test(normalizedLine);
+    });
+}
+
+const CodeBlock = ({ children, onClickExecute, onClickSaveCommand, codeBlockMaxWidthAtom }: CodeBlockProps) => {
     const codeBlockMaxWidth = useAtomValueSafe(codeBlockMaxWidthAtom);
     const getLanguage = (children: any): string => {
         if (children?.props?.className) {
@@ -147,7 +182,14 @@ const CodeBlock = ({ children, onClickExecute, codeBlockMaxWidthAtom }: CodeBloc
         }
     };
 
+    const handleSave = (e: React.MouseEvent) => {
+        const cmd = extractText(children).replace(/\n$/, "");
+        onClickSaveCommand?.(cmd);
+    };
+
     const language = getLanguage(children);
+    const commandText = extractText(children).replace(/\n$/, "");
+    const showSaveCommand = onClickSaveCommand != null && canSaveCommand(language, commandText);
 
     return (
         <div
@@ -162,6 +204,16 @@ const CodeBlock = ({ children, onClickExecute, codeBlockMaxWidthAtom }: CodeBloc
                 <span className="text-[11px] text-white/50">{language}</span>
                 <div className="flex items-center gap-2">
                     <CopyButton onClick={handleCopy} title="Copy" />
+                    {showSaveCommand && (
+                        <IconButton
+                            decl={{
+                                elemtype: "iconbutton",
+                                icon: "bookmark",
+                                title: "Save to Saved Commands",
+                                click: handleSave,
+                            }}
+                        />
+                    )}
                     {onClickExecute && (
                         <IconButton
                             decl={{
@@ -202,6 +254,7 @@ interface WaveStreamdownProps {
     parseIncompleteMarkdown?: boolean;
     className?: string;
     onClickExecute?: (cmd: string) => void;
+    onClickSaveCommand?: (cmd: string) => void;
     codeBlockMaxWidthAtom?: Atom<number>;
 }
 
@@ -210,6 +263,7 @@ export const WaveStreamdown = ({
     parseIncompleteMarkdown,
     className,
     onClickExecute,
+    onClickSaveCommand,
     codeBlockMaxWidthAtom,
 }: WaveStreamdownProps) => {
     const components = useMemo(
@@ -219,6 +273,7 @@ export const WaveStreamdown = ({
                 <CodeBlock
                     children={props.children}
                     onClickExecute={onClickExecute}
+                    onClickSaveCommand={onClickSaveCommand}
                     codeBlockMaxWidthAtom={codeBlockMaxWidthAtom}
                 />
             ),
diff --git a/frontend/types/gotypes.d.ts b/frontend/types/gotypes.d.ts
index ddcb4a63e7..4b2ada32bf 100644
--- a/frontend/types/gotypes.d.ts
+++ b/frontend/types/gotypes.d.ts
@@ -1206,6 +1206,7 @@ declare global {
         "waveai:chatid"?: string;
         "waveai:mode"?: string;
         "waveai:maxoutputtokens"?: number;
+        "waveai:savedcommands"?: WaveAISavedCommand[];
     };
 
     // wshrpc.PathCommandData
@@ -1959,6 +1960,14 @@ declare global {
         name?: string;
     };
 
+    // waveobj.WaveAISavedCommand
+    type WaveAISavedCommand = {
+        id: string;
+        text: string;
+        createdts?: number;
+        updatedts?: number;
+    };
+
     // wshrpc.WaveAIStreamRequest
     type WaveAIStreamRequest = {
         clientid?: string;
diff --git a/pkg/waveobj/objrtinfo.go b/pkg/waveobj/objrtinfo.go
index a7b35bbd86..ef5fb7bde1 100644
--- a/pkg/waveobj/objrtinfo.go
+++ b/pkg/waveobj/objrtinfo.go
@@ -3,6 +3,13 @@
 
 package waveobj
 
+type WaveAISavedCommand struct {
+	Id        string `json:"id"`
+	Text      string `json:"text"`
+	CreatedTs int64  `json:"createdts,omitempty"`
+	UpdatedTs int64  `json:"updatedts,omitempty"`
+}
+
 type ObjRTInfo struct {
 	TsunamiAppMeta any `json:"tsunami:appmeta,omitempty" tstype:"AppMeta"`
 	TsunamiSchemas any `json:"tsunami:schemas,omitempty"`
@@ -23,7 +30,8 @@ type ObjRTInfo struct {
 	BuilderAppId  string             `json:"builder:appid,omitempty"`
 	BuilderEnv    map[string]string  `json:"builder:env,omitempty"`
 
-	WaveAIChatId          string `json:"waveai:chatid,omitempty"`
-	WaveAIMode            string `json:"waveai:mode,omitempty"`
-	WaveAIMaxOutputTokens int    `json:"waveai:maxoutputtokens,omitempty"`
+	WaveAIChatId          string               `json:"waveai:chatid,omitempty"`
+	WaveAIMode            string               `json:"waveai:mode,omitempty"`
+	WaveAIMaxOutputTokens int                  `json:"waveai:maxoutputtokens,omitempty"`
+	WaveAISavedCommands   []WaveAISavedCommand `json:"waveai:savedcommands,omitempty"`
 }