gsd-pi 0.1.0

package/README.md

@@ -0,0 +1,341 @@
+<div align="center">
+
+# GSD
+
+**The evolution of [Get Shit Done](https://github.com/glittercowboy/get-shit-done) — now a real coding agent.**
+
+The original GSD went viral as a prompt framework for Claude Code. It worked, but it was fighting the tool — injecting prompts through slash commands, hoping the LLM would follow instructions, with no actual control over context windows, sessions, or execution.
+
+This version is different. GSD is now a standalone CLI built on the [Pi SDK](https://github.com/nicholasgasior/pi-coding-agent), which gives it direct TypeScript access to the agent harness itself. That means GSD can actually *do* what v1 could only *ask* the LLM to do: clear context between tasks, inject exactly the right files at dispatch time, manage git branches, track cost and tokens, detect stuck loops, recover from crashes, and auto-advance through an entire milestone without human intervention.
+
+One command. Walk away. Come back to a built project with clean git history.
+
+```bash
+npm install -g @glittercowboy/gsd
+gsd
+```
+
+</div>
+
+---
+
+## What Changed From v1
+
+The original GSD was a collection of markdown prompts installed into `~/.claude/commands/`. It relied entirely on the LLM reading those prompts and doing the right thing. That worked surprisingly well — but it had hard limits:
+
+- **No context control.** The LLM accumulated garbage over a long session. Quality degraded.
+- **No real automation.** "Auto mode" was the LLM calling itself in a loop, burning context on orchestration overhead.
+- **No crash recovery.** If the session died mid-task, you started over.
+- **No observability.** No cost tracking, no progress dashboard, no stuck detection.
+
+GSD v2 solves all of these because it's not a prompt framework anymore — it's a TypeScript application that *controls* the agent session.
+
+| | v1 (Prompt Framework) | v2 (Agent Application) |
+|---|---|---|
+| Runtime | Claude Code slash commands | Standalone CLI via Pi SDK |
+| Context management | Hope the LLM doesn't fill up | Fresh session per task, programmatic |
+| Auto mode | LLM self-loop | State machine reading `.gsd/` files |
+| Crash recovery | None | Lock files + session forensics |
+| Git strategy | LLM writes git commands | Programmatic branch-per-slice, squash merge |
+| Cost tracking | None | Per-unit token/cost ledger with dashboard |
+| Stuck detection | None | Retry once, then stop with diagnostics |
+| Timeout supervision | None | Soft/idle/hard timeouts with recovery steering |
+| Context injection | "Read this file" | Pre-inlined into dispatch prompt |
+| Roadmap reassessment | Manual | Automatic after each slice completes |
+| Skill discovery | None | Auto-detect and install relevant skills during research |
+
+---
+
+## How It Works
+
+GSD structures work into a hierarchy:
+
+```
+Milestone  →  a shippable version (4-10 slices)
+  Slice    →  one demoable vertical capability (1-7 tasks)
+    Task   →  one context-window-sized unit of work
+```
+
+The iron rule: **a task must fit in one context window.** If it can't, it's two tasks.
+
+### The Loop
+
+Each slice flows through phases automatically:
+
+```
+Research → Plan → Execute (per task) → Complete → Reassess Roadmap → Next Slice
+```
+
+**Research** scouts the codebase and relevant docs. **Plan** decomposes the slice into tasks with must-haves (mechanically verifiable outcomes). **Execute** runs each task in a fresh context window with only the relevant files pre-loaded. **Complete** writes the summary, UAT script, marks the roadmap, and commits. **Reassess** checks if the roadmap still makes sense given what was learned.
+
+### `/gsd auto` — The Main Event
+
+This is what makes GSD different. Run it, walk away, come back to built software.
+
+```
+/gsd auto
+```
+
+Auto mode is a state machine driven by files on disk. It reads `.gsd/STATE.md`, determines the next unit of work, creates a fresh agent session, injects a focused prompt with all relevant context pre-inlined, and lets the LLM execute. When the LLM finishes, auto mode reads disk state again and dispatches the next unit.
+
+**What happens under the hood:**
+
+1. **Fresh session per unit** — Every task, every research phase, every planning step gets a clean 200k-token context window. No accumulated garbage. No "I'll be more concise now."
+
+2. **Context pre-loading** — The dispatch prompt includes inlined task plans, slice plans, prior task summaries, dependency summaries, roadmap excerpts, and decisions register. The LLM starts with everything it needs instead of spending tool calls reading files.
+
+3. **Git branch-per-slice** — Each slice gets its own branch (`gsd/M001/S01`). Tasks commit atomically on the branch. When the slice completes, it's squash-merged to main as one clean commit.
+
+4. **Crash recovery** — A lock file tracks the current unit. If the session dies, the next `/gsd auto` reads the surviving session file, synthesizes a recovery briefing from every tool call that made it to disk, and resumes with full context.
+
+5. **Stuck detection** — If the same unit dispatches twice (the LLM didn't produce the expected artifact), it retries once with a deep diagnostic. If it fails again, auto mode stops with the exact file it expected.
+
+6. **Timeout supervision** — Soft timeout warns the LLM to wrap up. Idle watchdog detects stalls. Hard timeout pauses auto mode. Recovery steering nudges the LLM to finish durable output before giving up.
+
+7. **Cost tracking** — Every unit's token usage and cost is captured, broken down by phase, slice, and model. The dashboard shows running totals and projections. Budget ceilings can pause auto mode before overspending.
+
+8. **Adaptive replanning** — After each slice completes, the roadmap is reassessed. If the work revealed new information that changes the plan, slices are reordered, added, or removed before continuing.
+
+9. **Escape hatch** — Press Escape to pause. The conversation is preserved. Interact with the agent, inspect what happened, or just `/gsd auto` to resume from disk state.
+
+### The `/gsd` Wizard
+
+When you're not in auto mode, `/gsd` reads disk state and shows contextual options:
+
+- **No `.gsd/` directory** → Start a new project. Discussion flow captures your vision, constraints, and preferences.
+- **Milestone exists, no roadmap** → Discuss or research the milestone.
+- **Roadmap exists, slices pending** → Plan the next slice, or jump straight to auto.
+- **Mid-task** → Resume from where you left off.
+
+The wizard is the on-ramp. Auto mode is the highway.
+
+---
+
+## Getting Started
+
+### Install
+
+```bash
+npm install -g @glittercowboy/gsd
+```
+
+Requires Node.js ≥ 20.6.0. Installs Chromium via Playwright for browser-based verification (non-fatal if it fails).
+
+### First Run
+
+```bash
+cd your-project
+gsd
+```
+
+On first launch, GSD prompts for optional API keys:
+- **Brave Search** — for web research during planning
+- **Context7** — for up-to-date library documentation
+- **Jina** — for web page content extraction
+
+All optional. Press Enter to skip any. Keys are stored in `~/.gsd/agent/auth.json` and loaded automatically on subsequent launches.
+
+### Start Building
+
+The wizard walks you through describing what you want to build. Once you approve the roadmap:
+
+```
+/gsd auto
+```
+
+Walk away. GSD will research, plan, execute, verify, commit, and advance through every slice until the milestone is complete.
+
+### Commands
+
+| Command | What it does |
+|---------|-------------|
+| `/gsd` | Contextual wizard — reads state, shows what's next |
+| `/gsd auto` | Start auto mode (fresh session per unit, loops until done) |
+| `/gsd stop` | Stop auto mode gracefully |
+| `/gsd status` | Progress dashboard overlay |
+| `/gsd queue` | Queue future milestones (safe during auto mode) |
+| `/gsd discuss` | Discuss implementation decisions before planning |
+| `/gsd prefs` | Manage skill preferences (global/project) |
+| `/gsd doctor` | Validate `.gsd/` integrity, find and fix issues |
+| `Ctrl+Alt+G` | Toggle dashboard overlay |
+
+---
+
+## What GSD Manages For You
+
+### Context Engineering
+
+Every dispatch is carefully constructed. The LLM never wastes tool calls on orientation.
+
+| Artifact | Purpose |
+|----------|---------|
+| `PROJECT.md` | Living doc — what the project is right now |
+| `DECISIONS.md` | Append-only register of architectural decisions |
+| `STATE.md` | Quick-glance dashboard — always read first |
+| `M001-ROADMAP.md` | Milestone plan with slice checkboxes, risk levels, dependencies |
+| `M001-CONTEXT.md` | User decisions from the discuss phase |
+| `M001-RESEARCH.md` | Codebase and ecosystem research |
+| `S01-PLAN.md` | Slice task decomposition with must-haves |
+| `T01-PLAN.md` | Individual task plan with verification criteria |
+| `T01-SUMMARY.md` | What happened — YAML frontmatter + narrative |
+| `S01-UAT.md` | Human test script derived from slice outcomes |
+
+### Git Strategy
+
+Branch-per-slice with squash merge. Fully automated.
+
+```
+main:
+  feat(M001/S03): auth and session management
+  feat(M001/S02): API endpoints and middleware
+  feat(M001/S01): data model and type system
+
+gsd/M001/S01 (preserved):
+  feat(S01/T03): file writer with round-trip fidelity
+  feat(S01/T02): markdown parser for plan files
+  feat(S01/T01): core types and interfaces
+```
+
+One commit per slice on main. Per-task history preserved on branches. Git bisect works. Individual slices are revertable.
+
+### Verification
+
+Every task has must-haves — mechanically checkable outcomes:
+
+- **Truths** — Observable behaviors ("User can sign up with email")
+- **Artifacts** — Files that must exist with real implementation, not stubs
+- **Key Links** — Imports and wiring between artifacts
+
+The verification ladder: static checks → command execution → behavioral testing → human review (only when the agent genuinely can't verify itself).
+
+### Dashboard
+
+`Ctrl+Alt+G` or `/gsd status` opens a real-time overlay showing:
+
+- Current milestone, slice, and task progress
+- Auto mode elapsed time and phase
+- Per-unit cost and token breakdown by phase, slice, and model
+- Cost projections based on completed work
+- Completed and in-progress units
+
+---
+
+## Configuration
+
+### Preferences
+
+GSD preferences live in `~/.gsd/preferences.md` (global) or `.gsd/preferences.md` (project). Manage with `/gsd prefs`.
+
+```yaml
+---
+version: 1
+models:
+  research: claude-sonnet-4-6
+  planning: claude-opus-4-6
+  execution: claude-sonnet-4-6
+  completion: claude-sonnet-4-6
+skill_discovery: suggest
+auto_supervisor:
+  soft_timeout_minutes: 20
+  idle_timeout_minutes: 10
+  hard_timeout_minutes: 30
+budget_ceiling: 50.00
+---
+```
+
+**Key settings:**
+
+| Setting | What it controls |
+|---------|-----------------|
+| `models.*` | Per-phase model selection (Opus for planning, Sonnet for execution, etc.) |
+| `skill_discovery` | `auto` / `suggest` / `off` — how GSD finds and applies skills |
+| `auto_supervisor.*` | Timeout thresholds for auto mode supervision |
+| `budget_ceiling` | USD ceiling — auto mode pauses when reached |
+| `uat_dispatch` | Enable automatic UAT runs after slice completion |
+| `always_use_skills` | Skills to always load when relevant |
+| `skill_rules` | Situational rules for skill routing |
+
+### Bundled Tools
+
+GSD ships with 11 extensions, all loaded automatically:
+
+| Extension | What it provides |
+|-----------|-----------------|
+| **GSD** | Core workflow engine, auto mode, commands, dashboard |
+| **Browser Tools** | Playwright-based browser for UI verification |
+| **Search the Web** | Brave Search + Jina page extraction |
+| **Context7** | Up-to-date library/framework documentation |
+| **Background Shell** | Long-running process management with readiness detection |
+| **Subagent** | Delegated tasks with isolated context windows |
+| **Plan Mode** | Structured planning before execution |
+| **Slash Commands** | Custom command creation |
+| **Worktree** | Git worktree management |
+| **Ask User Questions** | Structured user input with single/multi-select |
+| **Secure Env Collect** | Masked secret collection without manual .env editing |
+
+### Bundled Agents
+
+Three specialized subagents for delegated work:
+
+| Agent | Role |
+|-------|------|
+| **Scout** | Fast codebase recon — returns compressed context for handoff |
+| **Researcher** | Web research — finds and synthesizes current information |
+| **Worker** | General-purpose execution in an isolated context window |
+
+---
+
+## Architecture
+
+GSD is a TypeScript application that embeds the Pi coding agent SDK.
+
+```
+gsd (CLI binary)
+  └─ loader.ts          Sets PI_PACKAGE_DIR, GSD env vars, dynamic-imports cli.ts
+      └─ cli.ts         Wires SDK managers, loads extensions, starts InteractiveMode
+          ├─ wizard.ts       First-run API key collection (Brave/Context7/Jina)
+          ├─ app-paths.ts    ~/.gsd/agent/, ~/.gsd/sessions/, auth.json
+          ├─ resource-loader.ts  Syncs bundled extensions + agents to ~/.gsd/agent/
+          └─ src/resources/
+              ├─ extensions/gsd/    Core GSD extension (auto, state, commands, ...)
+              ├─ extensions/...     10 supporting extensions
+              ├─ agents/            scout, researcher, worker
+              ├─ AGENTS.md          Agent routing instructions
+              └─ GSD-WORKFLOW.md    Manual bootstrap protocol
+```
+
+**Key design decisions:**
+
+- **`pkg/` shim directory** — `PI_PACKAGE_DIR` points here (not project root) to avoid Pi's theme resolution collision with our `src/` directory. Contains only `piConfig` and theme assets.
+- **Two-file loader pattern** — `loader.ts` sets all env vars with zero SDK imports, then dynamic-imports `cli.ts` which does static SDK imports. This ensures `PI_PACKAGE_DIR` is set before any SDK code evaluates.
+- **Always-overwrite sync** — `npm update -g` takes effect immediately. Bundled extensions and agents are synced to `~/.gsd/agent/` on every launch, not just first run.
+- **State lives on disk** — `.gsd/` is the source of truth. Auto mode reads it, writes it, and advances based on what it finds. No in-memory state survives across sessions.
+
+---
+
+## Requirements
+
+- **Node.js** ≥ 20.6.0
+- **Anthropic API key** — handled by Pi's built-in auth flow on first launch
+- **Git** — initialized automatically if missing
+
+Optional:
+- Brave Search API key (web research)
+- Context7 API key (library docs)
+- Jina API key (page extraction)
+
+---
+
+## License
+
+MIT
+
+---
+
+<div align="center">
+
+**The original GSD showed what was possible. This version delivers it.**
+
+**`npm install -g @glittercowboy/gsd && gsd`**
+
+</div>

package/dist/app-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const appRoot: string;
+export declare const agentDir: string;
+export declare const sessionsDir: string;
+export declare const authFilePath: string;

package/dist/app-paths.js

@@ -0,0 +1,6 @@
+import { homedir } from 'os';
+import { join } from 'path';
+export const appRoot = join(homedir(), '.gsd');
+export const agentDir = join(appRoot, 'agent');
+export const sessionsDir = join(appRoot, 'sessions');
+export const authFilePath = join(agentDir, 'auth.json');

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,35 @@
+import { AuthStorage, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, } from '@mariozechner/pi-coding-agent';
+import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
+import { buildResourceLoader, initResources } from './resource-loader.js';
+import { loadStoredEnvKeys, runWizardIfNeeded } from './wizard.js';
+const authStorage = AuthStorage.create(authFilePath);
+loadStoredEnvKeys(authStorage);
+await runWizardIfNeeded(authStorage);
+const modelRegistry = new ModelRegistry(authStorage);
+const settingsManager = SettingsManager.create(agentDir);
+// GSD always uses quiet startup — the gsd extension renders its own branded header
+if (!settingsManager.getQuietStartup()) {
+    settingsManager.setQuietStartup(true);
+}
+// Collapse changelog by default — avoid wall of text on updates
+if (!settingsManager.getCollapseChangelog()) {
+    settingsManager.setCollapseChangelog(true);
+}
+const sessionManager = SessionManager.create(process.cwd(), sessionsDir);
+initResources(agentDir);
+const resourceLoader = buildResourceLoader(agentDir);
+await resourceLoader.reload();
+const { session, extensionsResult } = await createAgentSession({
+    authStorage,
+    modelRegistry,
+    settingsManager,
+    sessionManager,
+    resourceLoader,
+});
+if (extensionsResult.errors.length > 0) {
+    for (const err of extensionsResult.errors) {
+        process.stderr.write(`[gsd] Extension load error: ${err.error}\n`);
+    }
+}
+const interactiveMode = new InteractiveMode(session);
+await interactiveMode.run();

package/dist/loader.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/loader.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import { dirname, resolve, join } from 'path';
+import { readFileSync } from 'fs';
+import { agentDir } from './app-paths.js';
+// pkg/ is a shim directory: contains gsd's piConfig (package.json) and pi's
+// theme assets (dist/modes/interactive/theme/) without a src/ directory.
+// This allows config.js to:
+//   1. Read piConfig.name → "gsd" (branding)
+//   2. Resolve themes via dist/ (no src/ present → uses dist path)
+const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'pkg');
+// MUST be set before any dynamic import of pi SDK fires — this is what config.js
+// reads to determine APP_NAME and CONFIG_DIR_NAME
+process.env.PI_PACKAGE_DIR = pkgDir;
+process.title = 'gsd';
+// GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.pi/agent/
+process.env.GSD_CODING_AGENT_DIR = agentDir;
+// NODE_PATH — make gsd's own node_modules available to extensions loaded via jiti.
+// Without this, extensions (e.g. browser-tools) can't resolve dependencies like
+// `playwright` because jiti resolves modules from pi-coding-agent's location, not gsd's.
+// Prepending gsd's node_modules to NODE_PATH fixes this for all extensions.
+const gsdRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const gsdNodeModules = join(gsdRoot, 'node_modules');
+process.env.NODE_PATH = process.env.NODE_PATH
+    ? `${gsdNodeModules}:${process.env.NODE_PATH}`
+    : gsdNodeModules;
+// Force Node to re-evaluate module search paths with the updated NODE_PATH.
+// Must happen synchronously before cli.js imports → extension loading.
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { Module } = await import('module');
+Module._initPaths?.();
+// GSD_VERSION — expose package version so extensions can display it
+try {
+    const gsdPkg = JSON.parse(readFileSync(join(gsdRoot, 'package.json'), 'utf-8'));
+    process.env.GSD_VERSION = gsdPkg.version || '0.0.0';
+}
+catch {
+    process.env.GSD_VERSION = '0.0.0';
+}
+// GSD_BIN_PATH — absolute path to this loader (dist/loader.js), used by patched subagent
+// to spawn gsd instead of pi when dispatching workflow tasks
+process.env.GSD_BIN_PATH = process.argv[1];
+// GSD_WORKFLOW_PATH — absolute path to bundled GSD-WORKFLOW.md, used by patched gsd extension
+// when dispatching workflow prompts (dist/loader.js → ../src/resources/GSD-WORKFLOW.md)
+const resourcesDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'src', 'resources');
+process.env.GSD_WORKFLOW_PATH = join(resourcesDir, 'GSD-WORKFLOW.md');
+// GSD_BUNDLED_EXTENSION_PATHS — colon-joined list of all bundled extension entry point absolute
+// paths, used by patched subagent to pass --extension <path> to spawned gsd processes.
+// IMPORTANT: paths point to agentDir (~/.gsd/agent/extensions/) NOT src/resources/extensions/.
+// initResources() syncs bundled extensions to agentDir before any extension loading occurs,
+// so these paths are always valid at runtime. Using agentDir paths matches what buildResourceLoader
+// discovers (it scans agentDir), so pi's deduplication works correctly and extensions are not
+// double-loaded in subagent child processes.
+// Note: shared/ is NOT included — it's a library imported by gsd and ask-user-questions, not an entry point.
+process.env.GSD_BUNDLED_EXTENSION_PATHS = [
+    join(agentDir, 'extensions', 'gsd', 'index.ts'),
+    join(agentDir, 'extensions', 'bg-shell', 'index.ts'),
+    join(agentDir, 'extensions', 'browser-tools', 'index.ts'),
+    join(agentDir, 'extensions', 'context7', 'index.ts'),
+    join(agentDir, 'extensions', 'search-the-web', 'index.ts'),
+    join(agentDir, 'extensions', 'slash-commands', 'index.ts'),
+    join(agentDir, 'extensions', 'subagent', 'index.ts'),
+    join(agentDir, 'extensions', 'worktree', 'index.ts'),
+    join(agentDir, 'extensions', 'plan-mode', 'index.ts'),
+    join(agentDir, 'extensions', 'ask-user-questions.ts'),
+    join(agentDir, 'extensions', 'get-secrets-from-user.ts'),
+].join(':');
+// Dynamic import defers ESM evaluation — config.js will see PI_PACKAGE_DIR above
+await import('./cli.js');

package/dist/modes/interactive/theme/dark.json

@@ -0,0 +1,85 @@
+{
+	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "dark",
+	"vars": {
+		"cyan": "#00d7ff",
+		"blue": "#5f87ff",
+		"green": "#b5bd68",
+		"red": "#cc6666",
+		"yellow": "#ffff00",
+		"gray": "#808080",
+		"dimGray": "#666666",
+		"darkGray": "#505050",
+		"accent": "#8abeb7",
+		"selectedBg": "#3a3a4a",
+		"userMsgBg": "#343541",
+		"toolPendingBg": "#282832",
+		"toolSuccessBg": "#283228",
+		"toolErrorBg": "#3c2828",
+		"customMsgBg": "#2d2838"
+	},
+	"colors": {
+		"accent": "accent",
+		"border": "blue",
+		"borderAccent": "cyan",
+		"borderMuted": "darkGray",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "gray",
+		"dim": "dimGray",
+		"text": "",
+		"thinkingText": "gray",
+
+		"selectedBg": "selectedBg",
+		"userMessageBg": "userMsgBg",
+		"userMessageText": "",
+		"customMessageBg": "customMsgBg",
+		"customMessageText": "",
+		"customMessageLabel": "#9575cd",
+		"toolPendingBg": "toolPendingBg",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolTitle": "",
+		"toolOutput": "gray",
+
+		"mdHeading": "#f0c674",
+		"mdLink": "#81a2be",
+		"mdLinkUrl": "dimGray",
+		"mdCode": "accent",
+		"mdCodeBlock": "green",
+		"mdCodeBlockBorder": "gray",
+		"mdQuote": "gray",
+		"mdQuoteBorder": "gray",
+		"mdHr": "gray",
+		"mdListBullet": "accent",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "gray",
+
+		"syntaxComment": "#6A9955",
+		"syntaxKeyword": "#569CD6",
+		"syntaxFunction": "#DCDCAA",
+		"syntaxVariable": "#9CDCFE",
+		"syntaxString": "#CE9178",
+		"syntaxNumber": "#B5CEA8",
+		"syntaxType": "#4EC9B0",
+		"syntaxOperator": "#D4D4D4",
+		"syntaxPunctuation": "#D4D4D4",
+
+		"thinkingOff": "darkGray",
+		"thinkingMinimal": "#6e6e6e",
+		"thinkingLow": "#5f87af",
+		"thinkingMedium": "#81a2be",
+		"thinkingHigh": "#b294bb",
+		"thinkingXhigh": "#d183e8",
+
+		"bashMode": "green"
+	},
+	"export": {
+		"pageBg": "#18181e",
+		"cardBg": "#1e1e24",
+		"infoBg": "#3c3728"
+	}
+}

package/dist/modes/interactive/theme/light.json

@@ -0,0 +1,84 @@
+{
+	"$schema": "https://raw.githubusercontent.com/badlogic/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"name": "light",
+	"vars": {
+		"teal": "#5a8080",
+		"blue": "#547da7",
+		"green": "#588458",
+		"red": "#aa5555",
+		"yellow": "#9a7326",
+		"mediumGray": "#6c6c6c",
+		"dimGray": "#767676",
+		"lightGray": "#b0b0b0",
+		"selectedBg": "#d0d0e0",
+		"userMsgBg": "#e8e8e8",
+		"toolPendingBg": "#e8e8f0",
+		"toolSuccessBg": "#e8f0e8",
+		"toolErrorBg": "#f0e8e8",
+		"customMsgBg": "#ede7f6"
+	},
+	"colors": {
+		"accent": "teal",
+		"border": "blue",
+		"borderAccent": "teal",
+		"borderMuted": "lightGray",
+		"success": "green",
+		"error": "red",
+		"warning": "yellow",
+		"muted": "mediumGray",
+		"dim": "dimGray",
+		"text": "",
+		"thinkingText": "mediumGray",
+
+		"selectedBg": "selectedBg",
+		"userMessageBg": "userMsgBg",
+		"userMessageText": "",
+		"customMessageBg": "customMsgBg",
+		"customMessageText": "",
+		"customMessageLabel": "#7e57c2",
+		"toolPendingBg": "toolPendingBg",
+		"toolSuccessBg": "toolSuccessBg",
+		"toolErrorBg": "toolErrorBg",
+		"toolTitle": "",
+		"toolOutput": "mediumGray",
+
+		"mdHeading": "yellow",
+		"mdLink": "blue",
+		"mdLinkUrl": "dimGray",
+		"mdCode": "teal",
+		"mdCodeBlock": "green",
+		"mdCodeBlockBorder": "mediumGray",
+		"mdQuote": "mediumGray",
+		"mdQuoteBorder": "mediumGray",
+		"mdHr": "mediumGray",
+		"mdListBullet": "green",
+
+		"toolDiffAdded": "green",
+		"toolDiffRemoved": "red",
+		"toolDiffContext": "mediumGray",
+
+		"syntaxComment": "#008000",
+		"syntaxKeyword": "#0000FF",
+		"syntaxFunction": "#795E26",
+		"syntaxVariable": "#001080",
+		"syntaxString": "#A31515",
+		"syntaxNumber": "#098658",
+		"syntaxType": "#267F99",
+		"syntaxOperator": "#000000",
+		"syntaxPunctuation": "#000000",
+
+		"thinkingOff": "lightGray",
+		"thinkingMinimal": "#767676",
+		"thinkingLow": "blue",
+		"thinkingMedium": "teal",
+		"thinkingHigh": "#875f87",
+		"thinkingXhigh": "#8b008b",
+
+		"bashMode": "green"
+	},
+	"export": {
+		"pageBg": "#f8f8f8",
+		"cardBg": "#ffffff",
+		"infoBg": "#fffae6"
+	}
+}