@@ -36,6 +36,10 @@ Beyond chat, Modelforge includes an **agentic mode** — the model can read/writ
 - **Per-session and per-project overrides** — pin a specific prompt, model, temperature, seed, top-K/top-P, repeat penalty, context length, GPU offload, or stop sequences to a single chat or an entire project, falling back to sane defaults. Provider-specific parameters (e.g. seed isn't supported by Claude, top-K isn't supported by ChatGPT) are automatically disabled when they don't apply to the selected model.
 - **Prompt library** — save and reuse system prompts across chats. Prompts can include `{{variables}}` (e.g. `{{topic}}`) that you fill in each time you apply one, and edits keep version history so a bad change can be restored.
 - **Command palette** (`Ctrl/Cmd+K`) — jump between chats, projects, and settings without touching the mouse.
+- **Full-text search** — the sidebar search box matches message content across every chat, not just titles.
+- **Tags** — label chats with freeform tags and filter the sidebar by them; lighter-weight than Projects for ad-hoc organization.
+- **Pin messages** — bookmark any message in a chat and jump straight to it from a "Pinned" panel in the toolbar.
+- **Fork a conversation** — branch a new chat from any earlier message, keeping everything up to that point and continuing independently from there.
 
 **Files & retrieval**
 - Attach files, folders, images, video, and PDFs directly into a conversation.
@@ -134,11 +138,14 @@ Click **Agent** in the chat toolbar and pick a folder — that becomes the model
 | `list_dir` | List files and subdirectories |
 | `search_files` | Search for a text string across the workspace |
 | `run_command` | Execute a shell command in the workspace (or a subfolder), with a 60s timeout |
+| `run_code` | Run a Python or JavaScript snippet — a convenience over shell-quoting multi-line code through `run_command`, not a new capability |
+| `git_status`, `git_diff`, `git_log` | Read-only git helpers (auto-approvable, like the file tools) so the model doesn't need to guess flag syntax |
+| `git_commit` | Stage everything and commit — requires approval, like `write_file` |
 
 **Safety model:**
 - `read_file`, `write_file`, `list_dir`, and `search_files` are genuinely confined to the chosen workspace folder — path-traversal attempts (`../../etc`, absolute paths elsewhere on disk) are rejected before anything runs.
-- `run_command` is different: a shell command is opaque text that can reference any path on the system regardless of its working directory, so it isn't sandboxed the way the file tools are. As a safety net, commands matching destructive or system-level patterns — deleting outside the workspace, formatting a drive, shutting down the machine, registry deletion, `sudo`/`runas`, piping a remote script into a shell — are **rejected outright**, even if already approved. This blocklist catches the common catastrophic cases, not everything a shell can do — only approve a command you actually understand.
-- Every call (including ones the blocklist doesn't catch) shows an **Allow / Deny** card before it executes — nothing runs without an explicit click. Read-only tools (`read_file`, `list_dir`, `search_files`) can be marked "always allow this session" to cut down on repetitive approvals; `write_file` and `run_command` always require a fresh click, since they have real, potentially irreversible effects.
+- `run_command` and `run_code` are different: a shell command (or a script `run_code` hands to `python3`/`node`) is opaque text that can reference any path on the system regardless of its working directory, so neither is sandboxed the way the file tools are. As a safety net, commands (and `run_code`'s source text) matching destructive or system-level patterns — deleting outside the workspace, formatting a drive, shutting down the machine, registry deletion, `sudo`/`runas`, piping a remote script into a shell — are **rejected outright**, even if already approved. This blocklist catches the common catastrophic cases, not everything a shell or script can do — only approve a command or snippet you actually understand.
+- Every call (including ones the blocklist doesn't catch) shows an **Allow / Deny** card before it executes — nothing runs without an explicit click. Read-only tools (`read_file`, `list_dir`, `search_files`, `git_status`, `git_diff`, `git_log`) can be marked "always allow this session" to cut down on repetitive approvals; `write_file`, `run_command`, `run_code`, and `git_commit` always require a fresh click, since they have real, potentially irreversible effects.
 - A per-turn step limit (25 tool-result → model-continuation round trips) stops a model from looping indefinitely without producing a final answer.
 - The trust list for "always allow" is in-memory only — closing and reopening a chat resets it.
 
 
@@ -2,15 +2,21 @@ import { describe, it, expect, beforeEach } from "vitest";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { execSync } from "node:child_process";
 import {
     readFile,
     writeFile,
     listDir,
     searchFiles,
     executeTool,
     runCommand,
+    runCode,
     rollbackLastWrite,
     detectProjectScripts,
+    gitStatus,
+    gitDiff,
+    gitLog,
+    gitCommit,
 } from "./agent-tools";
 
 describe("agent-tools", () => {
@@ -195,6 +201,64 @@ describe("agent-tools", () => {
         });
     });
 
+    describe("run_code", () => {
+        it("runs a JavaScript snippet via node", async () => {
+            const output = await runCode(workspace, "javascript", "console.log('hi from js')");
+            expect(output).toContain("Exit code: 0");
+            expect(output).toContain("hi from js");
+        });
+
+        it("runs a Python snippet via python3", async () => {
+            const output = await runCode(workspace, "python", "print('hi from py')");
+            expect(output).toContain("Exit code: 0");
+            expect(output).toContain("hi from py");
+        });
+
+        it("blocks code whose text matches the dangerous-command blocklist", async () => {
+            await expect(runCode(workspace, "python", "import os\nos.system('sudo rm -rf /')")).rejects.toThrow(
+                /blocked/
+            );
+        });
+
+        it("cleans up its temp file after running", async () => {
+            const before = fs.readdirSync(os.tmpdir()).filter((f) => f.startsWith("modelforge-code-"));
+            await runCode(workspace, "javascript", "1+1");
+            const after = fs.readdirSync(os.tmpdir()).filter((f) => f.startsWith("modelforge-code-"));
+            expect(after.length).toBe(before.length);
+        });
+    });
+
+    describe("git tools", () => {
+        beforeEach(() => {
+            execSync("git init -q", { cwd: workspace });
+            execSync('git -c user.email=test@test.com -c user.name=Test config commit.gpgsign false', { cwd: workspace });
+            fs.writeFileSync(path.join(workspace, "a.txt"), "hello");
+        });
+
+        it("git_status reports an untracked file", async () => {
+            const output = await gitStatus(workspace);
+            expect(output).toContain("a.txt");
+        });
+
+        it("git_diff shows staged changes when staged=true", async () => {
+            execSync("git add a.txt", { cwd: workspace });
+            const output = await gitDiff(workspace, true);
+            expect(output).toContain("a.txt");
+        });
+
+        it("git_commit stages and commits everything", async () => {
+            const output = await gitCommit(workspace, "initial commit");
+            expect(output).toContain("Exit code: 0");
+            const log = await gitLog(workspace, 5);
+            expect(log).toContain("initial commit");
+        });
+
+        it("git_log returns nothing unusual with no commits yet", async () => {
+            const output = await gitLog(workspace);
+            expect(output).toContain("Exit code:");
+        });
+    });
+
     describe("dangerous command blocking", () => {
         it.each([
             "rm -rf /",
 
@@ -1,7 +1,9 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import { randomUUID } from "node:crypto";
 import type { ToolDefinition } from "./providers/types";
 
 const execAsync = promisify(exec);
@@ -66,6 +68,59 @@ export const AGENT_TOOLS: ToolDefinition[] = [
             required: ["command"],
         },
     },
+    {
+        name: "run_code",
+        description:
+            "Run a Python or JavaScript code snippet in the workspace and return its stdout/stderr/exit code. A convenience over run_command for multi-line code (no shell-quoting to worry about) — it is not a sandbox: the code runs with the same permissions as run_command and is subject to the same safety checks.",
+        parameters: {
+            type: "object",
+            properties: {
+                language: { type: "string", enum: ["python", "javascript"], description: "Which interpreter to run the code with." },
+                code: { type: "string", description: "The full source code to execute." },
+                cwd: { type: "string", description: 'Working directory, relative to the workspace root. Defaults to "."' },
+            },
+            required: ["language", "code"],
+        },
+    },
+    {
+        name: "git_status",
+        description: "Show the working tree status (git status) for the workspace.",
+        parameters: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "git_diff",
+        description: "Show unstaged (or, if staged=true, staged) changes in the workspace as a unified diff.",
+        parameters: {
+            type: "object",
+            properties: {
+                staged: { type: "boolean", description: "Show staged changes (git diff --staged) instead of unstaged." },
+                path: { type: "string", description: "Limit the diff to this file or directory, relative to the workspace root." },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "git_log",
+        description: "Show recent commit history for the workspace.",
+        parameters: {
+            type: "object",
+            properties: {
+                count: { type: "number", description: "How many commits to show. Defaults to 10." },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "git_commit",
+        description: "Stage all changes and create a commit in the workspace. Requires explicit approval, like write_file.",
+        parameters: {
+            type: "object",
+            properties: {
+                message: { type: "string", description: "The commit message." },
+            },
+            required: ["message"],
+        },
+    },
 ];
 
 const MAX_READ_CHARS = 100_000;
@@ -284,6 +339,54 @@ export async function runCommand(workspaceRoot: string, command: string, relativ
     }
 }
 
+// run_code is a thin convenience wrapper over run_command for multi-line
+// snippets (avoids shell-quoting hell for real code) — it carries the exact
+// same risk and is checked against the exact same blocklist as run_command,
+// applied to the source text too since dangerous *content* (not just the
+// invocation) could otherwise slip past a check that only looks at the
+// command line.
+export async function runCode(
+    workspaceRoot: string,
+    language: "python" | "javascript",
+    code: string,
+    relativeCwd = "."
+): Promise<string> {
+    const dangerReason = findDangerousCommandReason(code);
+    if (dangerReason) throw new Error(dangerReason);
+
+    const ext = language === "python" ? "py" : "js";
+    const tmpFile = path.join(os.tmpdir(), `modelforge-code-${randomUUID()}.${ext}`);
+    fs.writeFileSync(tmpFile, code);
+    try {
+        const interpreter = language === "python" ? "python3" : "node";
+        return await runCommand(workspaceRoot, `${interpreter} "${tmpFile}"`, relativeCwd);
+    } finally {
+        fs.rmSync(tmpFile, { force: true });
+    }
+}
+
+function gitCommand(workspaceRoot: string, args: string): Promise<string> {
+    return runCommand(workspaceRoot, `git ${args}`, ".");
+}
+
+export function gitStatus(workspaceRoot: string): Promise<string> {
+    return gitCommand(workspaceRoot, "status");
+}
+
+export function gitDiff(workspaceRoot: string, staged = false, relativePath?: string): Promise<string> {
+    const target = relativePath ? ` -- "${relativePath}"` : "";
+    return gitCommand(workspaceRoot, `diff${staged ? " --staged" : ""}${target}`);
+}
+
+export function gitLog(workspaceRoot: string, count = 10): Promise<string> {
+    return gitCommand(workspaceRoot, `log -n ${Math.max(1, Math.min(count, 100))} --oneline`);
+}
+
+export async function gitCommit(workspaceRoot: string, message: string): Promise<string> {
+    await gitCommand(workspaceRoot, "add -A");
+    return gitCommand(workspaceRoot, `commit -m ${JSON.stringify(message)}`);
+}
+
 export interface ProjectScripts {
     test?: string;
     lint?: string;
@@ -321,6 +424,18 @@ export async function executeTool(workspaceRoot: string, name: string, args: Rec
             return searchFiles(workspaceRoot, String(args.query ?? ""), args.path ? String(args.path) : ".");
         case "run_command":
             return runCommand(workspaceRoot, String(args.command ?? ""), args.cwd ? String(args.cwd) : ".");
+        case "run_code": {
+            const language = args.language === "python" ? "python" : "javascript";
+            return runCode(workspaceRoot, language, String(args.code ?? ""), args.cwd ? String(args.cwd) : ".");
+        }
+        case "git_status":
+            return gitStatus(workspaceRoot);
+        case "git_diff":
+            return gitDiff(workspaceRoot, args.staged === true, args.path ? String(args.path) : undefined);
+        case "git_log":
+            return gitLog(workspaceRoot, typeof args.count === "number" ? args.count : 10);
+        case "git_commit":
+            return gitCommit(workspaceRoot, String(args.message ?? ""));
         default:
             throw new Error(`Unknown tool: ${name}`);
     }
 
@@ -39,6 +39,8 @@ export interface ChatMessage {
     // Present on a "tool" role message: which call this is the result of.
     toolCallId?: string;
     toolName?: string;
+    // User-set bookmark, purely a UI affordance — never sent to a provider.
+    pinned?: boolean;
 }
 
 export interface ChatChunk {
 
@@ -16,6 +16,7 @@ export interface ChatSession {
     systemPrompt?: string | null;
     agentMode?: boolean;
     agentWorkspace?: string | null;
+    tags?: string[];
     createdAt: string;
     updatedAt: string;
 }
@@ -60,7 +61,10 @@ export function createSession(model: string | null, projectId: string | null = n
 export function updateSession(
     id: string,
     partial: Partial<
-        Pick<ChatSession, "title" | "model" | "messages" | "params" | "projectId" | "systemPrompt" | "agentMode" | "agentWorkspace">
+        Pick<
+            ChatSession,
+            "title" | "model" | "messages" | "params" | "projectId" | "systemPrompt" | "agentMode" | "agentWorkspace" | "tags"
+        >
     >
 ): ChatSession | null {
     const all = readAll();
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,8 @@ export interface ChatMessage {`
`39`	`39`	`// Present on a "tool" role message: which call this is the result of.`
`40`	`40`	`toolCallId?: string;`
`41`	`41`	`toolName?: string;`
	`42`	`+ // User-set bookmark, purely a UI affordance — never sent to a provider.`
	`43`	`+ pinned?: boolean;`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`export interface ChatChunk {`