@shepai/cli 1.156.0 → 1.157.0-pr498.211219f

package/README.md

@@ -1,66 +1,62 @@
 <div align="center">
 
-# Shep AI
+<h1>
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="src/presentation/web/public/favicon-light.svg">
+    <source media="(prefers-color-scheme: light)" srcset="src/presentation/web/public/favicon-dark.svg">
+    <img src="src/presentation/web/public/favicon-light.svg" alt="Shep logo" width="28" valign="middle" />
+  </picture>
+  Shep
+</h1>
 
-### AI-assisted feature development with human checkpoints
+### Run multiple AI agents in parallel. Each in its own worktree.
 
-_Describe a feature in plain English. Shep builds it step by step — researching, planning, coding, and testing — pausing for your approval at every critical decision._
+_Manage 10 features at once — isolated branches, automatic commits, CI watching, and PRs — from a dashboard or the terminal._
 
-[![CI](https://github.com/shep-ai/cli/actions/workflows/ci.yml/badge.svg)](https://github.com/shep-ai/cli/actions/workflows/ci.yml)
+[![CI](https://github.com/shep-ai/shep/actions/workflows/ci.yml/badge.svg)](https://github.com/shep-ai/shep/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/@shepai/cli.svg?color=cb3837&logo=npm)](https://www.npmjs.com/package/@shepai/cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-[How It Works](#how-it-works) · [Quick Start](#quick-start) · [Trust & Safety](#trust--safety) · [CLI Reference](#cli-reference) · [FAQ](#faq)
+[Quick Start](#quick-start) · [How It Works](#how-it-works) · [Features](#features) · [Trust & Safety](#trust--safety) · [FAQ](#faq)
 
 <br />
 
-<img src="docs/screenshots/cover.png" alt="Shep AI" width="900" />
+<img src="docs/screenshots/cover.png" alt="Shep — Parallel AI Agent Sessions" width="900" />
 
 </div>
 
 ---
 
-## Who is Shep for?
+## Why Shep?
 
-Solo developers and small teams who use AI coding agents (Claude Code, Cursor, Gemini CLI) and want structure around the messy parts — turning a feature idea into a clear plan, keeping work isolated per feature, and not losing context when switching between tasks.
+You're already using AI coding agents. The problem isn't the coding — it's everything around it.
 
-Shep is not a replacement for your coding agent. It's the orchestration layer that sits above it: it manages requirements, plans, git branches, and review gates so you can focus on the parts that need human judgment.
+Switching branches. Stashing changes. Watching CI. Assembling PRs. Losing context when you juggle three things at once. One agent session is fine. Five is chaos.
 
----
-
-## How It Works
-
-Every feature moves through a structured pipeline. You control how much autonomy the agent gets.
+**Shep gives each feature its own isolated world** — a git worktree, a branch, an agent session — and handles the boring parts: committing, pushing, opening PRs, watching CI, and fixing failures. You manage it all from one dashboard or the CLI.
 
-```
- You describe       Shep generates       Shep researches       Shep writes         Shep codes          Shep opens
- a feature    →     requirements    →    your codebase    →    a plan         →    + tests        →    a PR
-                         ▲                                       ▲                                       ▲
-                     Gate 1: PRD                             Gate 2: Plan                            Gate 3: Merge
-                   (approve/edit)                          (approve/edit)                          (approve/reject)
+```bash
+shep feat new "add stripe payments" --push --pr
+shep feat new "add dark mode toggle" --push --pr
+shep feat new "fix login redirect bug" --push --pr
+# Three agents running in parallel. Zero branch conflicts. You monitor from one place.
 ```
 
-**Three approval gates.** Each one pauses execution and waits for you to review, edit, or approve before the agent continues. You choose which gates to enable:
+---
 
-| Flag | Gate | What you're approving |
-|------|------|-----------------------|
-| `--allow-prd` | Requirements | Auto-approve the generated PRD |
-| `--allow-plan` | Plan | Auto-approve the implementation plan |
-| `--allow-merge` | Merge | Auto-approve the final PR |
-| `--allow-all` | All three | Fully autonomous — agent handles everything |
+## Quick Start
 
-**With no flags**, every gate requires your explicit approval. You see exactly what the agent intends to do before it does it.
+### Prerequisites
 
-### What happens when things go wrong
+- **Node.js 22+** and **npm** (or install via `nvm`)
+- **Git** and **GitHub CLI** (`gh`) — [install guide](https://cli.github.com/)
+- **An AI coding agent**, authenticated and ready:
+  - **Claude Code**: `claude` · **Cursor CLI**: `cursor` · **Gemini CLI**: `gemini`
+  - If prompted to log in, complete auth first — Shep can't authenticate on your behalf.
 
-- **CI fails after PR creation.** Shep reads the CI logs, diagnoses the failure, and pushes a fix. It retries up to 3 times before pausing and asking for your input.
-- **Agent gets stuck or produces bad output.** The feature enters a `Blocked` state. You get notified and can provide feedback, reject the current phase, or restart from a checkpoint.
-- **You don't like the plan.** Reject it with comments. Shep regenerates the plan incorporating your feedback.
-- **You want to take over mid-feature.** The code lives in a standard git worktree on a named branch. You can open it in your IDE and work on it directly at any point.
+> **Sandbox mode note:** Some agents restrict network access by default. If operations like `npm install` fail, configure allowed hosts in your agent's settings or disable sandbox for Shep features. See [Agent Permissions](#agent-permissions).
 
----
-
-## Quick Start
+### Install and run
 
 ```bash
 # Try it instantly — no install needed
@@ -69,195 +65,310 @@ npx @shepai/cli
 # Or install globally
 npm i -g @shepai/cli
 
-# Start Shep — opens the web dashboard at http://localhost:4050
+# Start Shep — opens the web dashboard at localhost:4050
 shep
 ```
 
 ### Your first feature
 
 ```bash
-# With approval gates (recommended to start)
-shep feat new "add a /health endpoint that returns uptime and version"
+cd ~/projects/my-app        # Any git repo. Shep uses the repo you're in.
+shep feat new "add a /health endpoint that returns uptime and version" --push --pr
 
-# Shep will pause at each gate for your review.
-# Once you're comfortable, try autonomous mode:
-shep feat new "add rate limiting to the API" --allow-all --push --pr
+# Shep creates a worktree, runs your agent, commits, pushes, and opens a PR.
 ```
 
-### Parallel features
+Not in a git repo? Shep initializes one for you — `git init`, creates a branch, and starts working.
+
+Or use the dashboard — describe what you need, configure automation, and hit create:
 
-Each feature gets its own git worktree — no stashing, no branch conflicts:
+<div align="center">
+<img src="docs/screenshots/create-feature.png" alt="Shep — Create Feature with configurable automation" width="900" />
+</div>
+
+### Go parallel
 
 ```bash
 shep feat new "add stripe payments" --push --pr
 shep feat new "add dark mode toggle" --push --pr
-# Both run simultaneously in isolated worktrees
+shep feat new "refactor auth middleware" --push --pr
+# All three run simultaneously in the same repo. Each in its own worktree.
+```
+
+Launch from CLI or dashboard — monitor everything in one place. Open any feature in your IDE, terminal, or file manager with one click:
+
+<div align="center">
+<img src="docs/screenshots/parallel-features.png" alt="Shep — Three features running in parallel" width="900" />
+</div>
+
+Or work across multiple repos:
+
+```bash
+shep feat new "add payments" --repo ~/projects/backend --push --pr
+shep feat new "add checkout UI" --repo ~/projects/frontend --push --pr
+```
+
+Manage multiple repos from one dashboard. Start a local dev server per feature, chat with Shep for questions or HTML previews — all without leaving the UI:
+
+<div align="center">
+<img src="docs/screenshots/multi-repo.png" alt="Shep — Multiple repos with global chat and HTML preview" width="900" />
+</div>
+
+---
+
+## How It Works
+
+The default flow is simple: **prompt → implement → commit → push → PR**.
+
+```
+ You describe       Agent codes         Shep commits        Shep pushes         Shep opens
+ a feature    →     in a worktree  →    the changes    →    to remote      →    a PR
+```
+
+Shep creates an isolated git worktree, hands your prompt to the agent, and handles everything after: committing, pushing, and opening a PR. If CI fails, Shep reads the logs, fixes the issue, and retries (configurable).
+
+### Configure everything
+
+Every step of the pipeline is configurable. Turn things on or off per feature or set defaults:
+
+| Flag | What it does | Default |
+|------|-------------|---------|
+| `--push` | Auto-push after implementation | off |
+| `--pr` | Auto-create PR after push | off |
+| `--fast` | Skip spec-driven phases, go straight to coding | on |
+| `--allow-merge` | Auto-merge the PR after CI passes | off |
+| `--allow-all` | Enable all automations | off |
+| `--model` | Choose which AI model to use | agent default |
+| `--attach` | Attach reference files for context | — |
+
+Use `shep settings workflow` to set your defaults so you don't repeat flags.
+
+### Optional: Spec-Driven Development
+
+For complex features, enable the full structured pipeline with requirements, research, and planning phases:
+
+```bash
+# Disable --fast to get the full pipeline
+shep feat new "redesign the payment system" --no-fast --push --pr
+```
+
+This adds **approval gates** where Shep pauses for your review:
+
+```
+ Prompt  →  Requirements  →  Research  →  Plan  →  Implement  →  Commit  →  PR
+                 ▲                          ▲                                ▲
+             Gate 1: PRD              Gate 2: Plan                    Gate 3: Merge
 ```
 
+Each gate produces a YAML artifact you can read, edit, and approve before the agent continues. Use `--allow-prd` and `--allow-plan` to auto-approve individual gates, or keep them manual for full control.
+
+> **[Spec-Driven Development guide →](./docs/development/spec-driven-workflow.md)**
+
+---
+
+## Features
+
+### Parallel Sessions
+
+Run multiple features at once. Each gets its own git worktree — isolated branch, isolated files, zero conflicts. Monitor all of them from one dashboard.
+
+### Prompt to PR
+
+One command: `shep feat new "do X" --push --pr`. Agent implements, Shep commits, pushes, opens a PR. Done.
+
+### Agent-Agnostic
+
+Use Claude Code, Cursor CLI, or Gemini CLI. Swap per feature, per repo, anytime. If it runs in a terminal, Shep can orchestrate it.
+
+### Web Dashboard + CLI
+
+Two ways to manage everything. The dashboard at `localhost:4050` shows a visual graph of all repos and features with real-time status, diff review, and interactive chat. The CLI gives you the same control from the terminal.
+
+### CI Watch & Auto-Fix
+
+Shep watches your CI pipeline after push. If it fails, the agent reads the logs, diagnoses the problem, and pushes a fix. Retries are configurable (default: 3). Works best when CI produces clear error messages.
+
+### Everything Configurable
+
+Push, PR, merge, CI watch, CI fix retries, timeouts, model selection, agent type — configure per feature with flags or set global defaults with `shep settings`. Nothing is hardcoded.
+
+### 100% Local
+
+All data lives in `~/.shep/` as SQLite. No cloud, no account, no tracking. Your code is only sent to whichever AI agent you configure, under that agent's own terms.
+
+### Optional: Spec-Driven Development
+
+When you need more structure — requirements, technical research, implementation plans with approval gates. Produces versioned YAML artifacts you review before any code is written. Enable per feature with `--no-fast`.
+
+---
+
+## What Happens When Things Go Wrong
+
+- **CI fails.** Shep reads the logs, diagnoses the problem, and pushes a fix. Retries up to 3 times (configurable), then pauses and asks you.
+- **Agent gets stuck.** The feature enters a `Blocked` state. You get notified and can provide feedback or restart from a checkpoint.
+- **You need to stop immediately.** Run `shep agent stop <id>` or hit the stop button in the dashboard. The worktree is preserved — resume or take over manually.
+- **You want to take over.** The code lives in a standard git worktree on a named branch. Open it in your IDE at any point.
+- **Too many features in flight.** Each feature is independent. Stop, pause, or delete any of them without affecting the others.
+
 ---
 
 ## Trust & Safety
 
-Shep runs entirely on your machine. Here's the security model:
+Shep runs entirely on your machine.
 
 | Concern | How Shep handles it |
 |---------|-------------------|
-| **Data stays local** | All data lives in `~/.shep/` as SQLite databases. Nothing is sent to Shep servers — there are none. |
-| **Agent sandboxing** | Shep delegates coding to your chosen agent (Claude Code, Cursor CLI, Gemini CLI). The agent's own permission model applies. Shep does not grant additional permissions. |
-| **Git isolation** | Every feature runs in its own git worktree branched from your main branch. Your working directory is never modified. |
-| **No credential access** | Shep never reads, stores, or transmits your API keys. Agent authentication is handled by the agent itself. |
-| **Review before merge** | Unless you explicitly pass `--allow-merge`, no code is merged without your approval. PRs are created as drafts when using `--pr`. |
-| **Audit trail** | Every agent action, approval, and state transition is logged. View with `shep feat logs <id>`. |
+| **Data stays local** | All data in `~/.shep/` as SQLite. Nothing sent to Shep servers — there are none. |
+| **Agent permissions** | Shep runs your agent with permission-bypass flags to avoid blocking the automated pipeline. See [Agent Permissions](#agent-permissions) below. |
+| **Git isolation** | Every feature runs in its own worktree branched from main. Your working directory is never modified. |
+| **No credential access** | Shep never reads, stores, or transmits your API keys. |
+| **Agent mistakes** | Shep creates a draft PR. Your CI, linters, and security scanners run before any merge. Shep does not merge code that fails CI. |
+| **Review before merge** | Unless you pass `--allow-merge`, no code is merged without your approval. |
+| **Full audit trail** | Every action and state transition is logged. View with `shep feat logs <id>`. |
 
-**What `--allow-all` actually means:** The agent will auto-approve requirements, auto-approve the plan, and auto-merge the PR. It does _not_ bypass CI — your CI pipeline still runs and must pass. Use this for low-risk tasks on repos with good test coverage, not for changes to production infrastructure.
+### Agent Permissions
 
----
+Shep runs your agent non-interactively — it can't pause for "allow this command?" prompts mid-pipeline. By default, it passes permission-bypass flags (e.g., `--dangerously-skip-permissions` for Claude Code — each agent has an equivalent).
 
-## Features
+**Your safety net is three layers deep:**
+1. **Worktree isolation** — the agent works on a copy, not your checkout
+2. **Draft PRs** — you review the diff before anything is merged
+3. **CI pipeline** — your tests, linters, and security scanners run before merge
 
-- **Structured lifecycle** — Requirements, research, planning, implementation, and review as distinct phases, not one opaque prompt
-- **Three configurable approval gates** — Full control, full autonomy, or anything in between
-- **Parallel features via worktrees** — Multiple features in flight at once with zero branch conflicts
-- **Agent-agnostic** — Claude Code, Cursor CLI, or Gemini CLI — swap anytime per feature or per repo
-- **Web dashboard** — Interactive graph of repos and features with real-time status, diff review, and approval actions at `localhost:4050`
-- **CI fix loop** — When CI fails, the agent reads logs, diagnoses, and retries before asking for help
-- **100% local** — SQLite storage, no cloud dependency, no account needed
+The skip-permissions flag is a default, not a requirement. Configure your agent's permission model independently if you need tighter control.
 
-> **[Full features guide with screenshots →](./docs/FEATURES.md)**
+**What Shep does NOT protect you from:** If your CI doesn't catch a vulnerability, Shep won't either. Shep is an orchestration layer, not a security scanner.
 
 ---
 
-## CLI Reference
+## Supported Agents & Tools
 
-### Daemon
+| Category | Supported |
+|----------|-----------|
+| **AI Agents** | Claude Code, Cursor CLI, Gemini CLI |
+| **IDEs** | VS Code, Cursor, Zed, Windsurf, and more |
+| **Required** | Git, GitHub CLI (`gh`) |
 
-```
-shep                                  Start daemon + onboarding (first run)
-shep start [--port <number>]          Start web UI daemon (background, default port 4050)
-shep stop                             Stop the running daemon
-shep restart                          Restart the daemon
-shep status                           Show daemon status and live metrics
-shep ui [--port] [--no-open]          Start the web UI in the foreground
-```
+---
+
+## CLI Reference
 
-### Feature Management
+### Core Commands
 
 ```
-shep feat new <description>           Create a new feature
-      [--repo] [--push] [--pr]
+shep                              Start daemon + onboarding (first run)
+shep feat new <description>       Create a new feature
+      [--push] [--pr] [--fast] [--model] [--attach]
       [--allow-prd] [--allow-plan] [--allow-merge] [--allow-all]
-      [--parent] [--fast] [--model] [--attach]
-shep feat ls [--repo]                 List features
-shep feat show <id>                   Show feature details
-shep feat del <id>                    Delete a feature
-shep feat resume <id>                 Resume a paused feature
-shep feat review <id>                 Review a feature
-shep feat approve <id> [--comments]   Approve a feature
-shep feat reject <id> [--feedback]    Reject a feature
-shep feat logs <id>                   View feature logs
+shep feat ls                      List features
+shep feat show <id>               Show feature details
+shep feat resume <id>             Resume a paused feature
+shep feat approve <id>            Approve current phase (spec-driven mode)
+shep feat reject <id> --feedback  Reject with feedback (spec-driven mode)
+shep feat logs <id>               View feature logs
 ```
 
-### Agent Management
+### Stopping a Feature
 
 ```
-shep agent ls                         List agents
-shep agent show <id>                  Show agent details
-shep agent stop <id>                  Stop a running agent
-shep agent logs <id>                  View agent logs
-shep agent delete <id>                Delete an agent
-shep agent approve <id>               Approve an agent action
-shep agent reject <id>                Reject an agent action
+shep agent stop <id>              Stop a running agent immediately
+shep agent ls                     Find the agent ID for a feature
 ```
 
-### Repository & Session Management
-
-```
-shep repo ls                          List repositories
-shep repo show <id>                   Show repository details
-shep session ls                       List sessions
-shep session show <id>                Show session details
-```
+The web dashboard also has a stop button on every in-progress feature.
 
-### Settings
+### Daemon & Dashboard
 
 ```
-shep settings                         Launch setup wizard
-shep settings show                    Display current configuration
-shep settings init                    Initialize settings
-shep settings agent                   Configure AI coding agent
-shep settings ide                     Configure IDE
-shep settings workflow                Configure workflow
-shep settings model                   Configure model
+shep start [--port]               Start web daemon (default: 4050)
+shep stop                         Stop the daemon
+shep status                       Show daemon status and metrics
+shep ui                           Start web UI in foreground
 ```
 
-### Tools
+### Settings & Configuration
 
 ```
-shep tools list                       List tools with install status
-shep install <tool> [--how]           Install a dev tool
-shep ide-open [--ide] [--dir]         Open IDE in directory
+shep settings                     Launch setup wizard
+shep settings workflow            Configure default flags (push, pr, ci watch, etc.)
+shep settings agent               Configure AI coding agent
+shep settings ide                 Configure IDE
+shep settings model               Configure default model
 ```
 
-### Other
+### Agent & Repo Management
 
 ```
-shep version                          Show version info
-shep upgrade                          Upgrade to latest version
-shep run <agent> [-p prompt] [-r repo] [-s]   Run an agent directly
+shep agent ls                     List agent runs
+shep agent stop <id>              Stop a running agent
+shep agent logs <id>              View agent logs
+shep repo ls                      List repositories
 ```
 
+> **[Full CLI reference →](./docs/cli/architecture.md)**
+
 ---
 
 ## FAQ
 
-**How is this different from just using Claude Code / Cursor directly?**
-Those tools are excellent at writing code given a prompt. Shep adds the layer above: breaking a feature into structured phases, managing requirements and plans as reviewable artifacts, isolating work in git worktrees, and handling the PR/CI lifecycle. Think of it as a project manager for your AI coding agent.
+**How is this different from just using an AI coding agent directly?**
+
+Your agent writes the code. Shep manages the session: creating the worktree, committing, pushing, opening PRs, watching CI, and retrying failures. The difference is most obvious when you're running 3-5 features in parallel — Shep keeps them organized and isolated while you focus on what matters.
+
+**How is this different from Superset?**
+
+Superset is a terminal multiplexer for agents — it runs them in parallel tabs. Shep manages the development lifecycle: worktrees, commits, pushes, PRs, CI. They're complementary. Use Superset for the execution environment, Shep for the workflow.
 
 **What happens if the agent writes bad code?**
-The same thing that happens in a normal code review. Shep creates a PR. Your CI runs. If tests fail, Shep attempts to fix them. If the fix loop exhausts retries, the feature pauses and you're notified. You can also reject at any approval gate with feedback, and Shep will regenerate.
+
+Shep creates a draft PR. Your CI runs. If tests fail, the agent reads the logs and attempts a fix (up to 3 retries, configurable). If that fails, the feature pauses and you're notified. The agent never merges code that fails CI.
+
+**What about agent sandbox / permission modes?**
+
+Shep runs the agent with permission-bypass flags by default so the pipeline isn't blocked by interactive prompts. Your protection is worktree isolation, draft PRs, and your CI pipeline. See [Agent Permissions](#agent-permissions).
 
 **Does this work on large codebases?**
-Shep's research phase scans your codebase to build context before planning. The quality of the output depends on the underlying agent's ability to handle your repo. If Claude Code or Cursor works well on your codebase directly, Shep will too — it adds structure, not limitations.
+
+Yes. The practical limit is the underlying agent's context window, not Shep. If your agent handles your repo well directly, Shep will too. For monorepos, scope features to specific packages with `--repo`.
 
 **Can I use this on a team?**
-Shep runs locally and operates on your git repo. Multiple team members can each run Shep independently. Features are just branches and PRs — your existing review process applies. There is no shared server or collaboration layer today.
+
+Shep runs locally on your git repo. Multiple team members can run Shep independently. Features are just branches and PRs — your existing review process applies.
 
 **Is my code sent anywhere?**
-Not by Shep. Your code is sent to whichever AI agent you configure (Claude, Cursor, Gemini) under that agent's own privacy terms. Shep itself stores everything in local SQLite and makes no network calls.
 
----
+Not by Shep. Your code is sent to whichever AI agent you configure, under that agent's own privacy terms. Shep stores everything locally and makes no network calls.
 
-## Architecture
+**What's the spec-driven mode?**
 
-Shep follows Clean Architecture with four layers. If you're interested in contributing or understanding the internals:
+An optional structured pipeline that adds requirements, research, and planning phases with approval gates before any code is written. Useful for complex features where you want to review the approach first. Enable with `--no-fast`. [Learn more →](./docs/development/spec-driven-workflow.md)
 
-| Layer | Path | Responsibility |
-|-------|------|---------------|
-| Domain | `packages/core/src/domain/` | Business logic, TypeSpec-generated types |
-| Application | `packages/core/src/application/` | Use cases, port interfaces |
-| Infrastructure | `packages/core/src/infrastructure/` | SQLite, LangGraph agents, DI |
-| Presentation | `src/presentation/` | CLI, TUI, Web UI |
+**How do I stop a feature that's running?**
 
-> **[Full architecture docs →](./docs/architecture/overview.md)**
+CLI: `shep agent stop <id>`. Dashboard: click the stop button. The worktree is preserved — resume with `shep feat resume <id>` or work on it manually.
 
 ---
 
-## Supported Agents & Tools
+## Architecture
 
-| Category | Supported |
-|----------|-----------|
-| AI Agents | Claude Code, Cursor CLI, Gemini CLI |
-| IDEs | VS Code, Cursor, Zed, Windsurf, and [more](./docs/FEATURES.md) |
-| Required | Git, GitHub CLI |
+Shep follows Clean Architecture with four layers. For contributors and the curious:
+
+| Layer | Responsibility |
+|-------|---------------|
+| **Domain** | Business logic, TypeSpec-generated types |
+| **Application** | Use cases, port interfaces |
+| **Infrastructure** | SQLite, LangGraph agents, DI |
+| **Presentation** | CLI, Web UI |
+
+> **[Full architecture docs →](./docs/architecture/overview.md)**
 
 ---
 
 ## Contributing
 
-We welcome contributions from humans and AI agents alike.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for humans and [CONTRIBUTING-AGENTS.md](./CONTRIBUTING-AGENTS.md) for AI agents.
 
-- **Humans**: See [CONTRIBUTING.md](./CONTRIBUTING.md)
-- **AI Agents**: See [CONTRIBUTING-AGENTS.md](./CONTRIBUTING-AGENTS.md)
+---
 
 ## License
 

package/apis/json-schema/Language.yaml

@@ -0,0 +1,13 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: Language.yaml
+type: string
+enum:
+  - en
+  - ru
+  - pt
+  - es
+  - ar
+  - he
+  - fr
+  - de
+description: Supported UI language for i18n

package/apis/json-schema/UserProfile.yaml

@@ -11,4 +11,7 @@ properties:
   githubUsername:
     type: string
     description: GitHub username (optional, for PR attribution)
+  preferredLanguage:
+    $ref: Language.yaml
+    description: "Preferred UI language (default: English)"
 description: User profile information

package/dist/packages/core/src/application/use-cases/agents/approve-agent-run.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"approve-agent-run.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/agents/approve-agent-run.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gEAAgE,CAAC;AAC7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAE1G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAO9E,qBACa,sBAAsB;IAG/B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAEnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAElC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBANrB,kBAAkB,EAAE,mBAAmB,EAEvC,cAAc,EAAE,2BAA2B,EAE3C,iBAAiB,EAAE,kBAAkB,EAErC,qBAAqB,EAAE,sBAAsB;IAG1D,OAAO,CACX,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAqGlD"}
+{"version":3,"file":"approve-agent-run.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/agents/approve-agent-run.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gEAAgE,CAAC;AAC7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAE1G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAO9E,qBACa,sBAAsB;IAG/B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAEnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAElC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBANrB,kBAAkB,EAAE,mBAAmB,EAEvC,cAAc,EAAE,2BAA2B,EAE3C,iBAAiB,EAAE,kBAAkB,EAErC,qBAAqB,EAAE,sBAAsB;IAG1D,OAAO,CACX,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CA0GlD"}

package/dist/packages/core/src/application/use-cases/agents/approve-agent-run.use-case.js

@@ -111,6 +111,11 @@ let ApproveAgentRunUseCase = class ApproveAgentRunUseCase {
             resumeFromInterrupt: true,
             push: feature?.push ?? false,
             openPr: feature?.openPr ?? false,
+            forkAndPr: feature?.forkAndPr ?? false,
+            commitSpecs: feature?.commitSpecs ?? true,
+            ciWatchEnabled: feature?.ciWatchEnabled ?? true,
+            enableEvidence: feature?.enableEvidence ?? false,
+            commitEvidence: feature?.commitEvidence ?? false,
             ...(payload ? { resumePayload: JSON.stringify(payload) } : {}),
             agentType: run.agentType,
             ...(run.modelId ? { model: run.modelId } : {}),

package/dist/packages/core/src/application/use-cases/agents/reject-agent-run.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reject-agent-run.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/agents/reject-agent-run.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gEAAgE,CAAC;AAC7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAa1G,qBACa,qBAAqB;IAG9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAEnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAElC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBANrB,kBAAkB,EAAE,mBAAmB,EAEvC,cAAc,EAAE,2BAA2B,EAE3C,iBAAiB,EAAE,kBAAkB,EAErC,qBAAqB,EAAE,sBAAsB;IAG1D,OAAO,CACX,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC;QACT,QAAQ,EAAE,OAAO,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,CAAC;CA2HH"}
+{"version":3,"file":"reject-agent-run.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/agents/reject-agent-run.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gEAAgE,CAAC;AAC7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAa1G,qBACa,qBAAqB;IAG9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAEnC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAElC,OAAO,CAAC,QAAQ,CAAC,qBAAqB;gBANrB,kBAAkB,EAAE,mBAAmB,EAEvC,cAAc,EAAE,2BAA2B,EAE3C,iBAAiB,EAAE,kBAAkB,EAErC,qBAAqB,EAAE,sBAAsB;IAG1D,OAAO,CACX,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,WAAW,CAAC,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC;QACT,QAAQ,EAAE,OAAO,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;KAC5B,CAAC;CAkIH"}

package/dist/packages/core/src/application/use-cases/agents/reject-agent-run.use-case.js

@@ -127,7 +127,14 @@ let RejectAgentRunUseCase = class RejectAgentRunUseCase {
             resumeFromInterrupt: true,
             push: feature?.push ?? false,
             openPr: feature?.openPr ?? false,
+            forkAndPr: feature?.forkAndPr ?? false,
+            commitSpecs: feature?.commitSpecs ?? true,
+            ciWatchEnabled: feature?.ciWatchEnabled ?? true,
+            enableEvidence: feature?.enableEvidence ?? false,
+            commitEvidence: feature?.commitEvidence ?? false,
             resumePayload: JSON.stringify(rejectionPayload),
+            agentType: run.agentType,
+            ...(run.modelId ? { model: run.modelId } : {}),
             ...(feature.fast ? { fast: true } : {}),
         });
         return {

package/dist/packages/core/src/application/use-cases/features/check-and-unblock-features.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-and-unblock-features.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/features/check-and-unblock-features.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAGhH,qBACa,8BAA8B;IAET,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE1D,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAFkB,WAAW,EAAE,kBAAkB,EAE7D,YAAY,EAAE,2BAA2B;IAG5D;;;;OAIG;IACG,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAiCtD"}
+{"version":3,"file":"check-and-unblock-features.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/features/check-and-unblock-features.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAGhH,qBACa,8BAA8B;IAET,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE1D,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAFkB,WAAW,EAAE,kBAAkB,EAE7D,YAAY,EAAE,2BAA2B;IAG5D;;;;OAIG;IACG,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA4CtD"}

package/dist/packages/core/src/application/use-cases/features/check-and-unblock-features.use-case.js

@@ -60,7 +60,17 @@ let CheckAndUnblockFeaturesUseCase = class CheckAndUnblockFeaturesUseCase {
             await this.featureRepo.update(child);
             // Spawn agent using fields set at feature creation time
             if (child.agentRunId && child.specPath) {
-                this.agentProcess.spawn(child.id, child.agentRunId, child.repositoryPath, child.specPath, child.worktreePath);
+                this.agentProcess.spawn(child.id, child.agentRunId, child.repositoryPath, child.specPath, child.worktreePath, {
+                    approvalGates: child.approvalGates,
+                    push: child.push,
+                    openPr: child.openPr,
+                    forkAndPr: child.forkAndPr,
+                    commitSpecs: child.commitSpecs,
+                    ciWatchEnabled: child.ciWatchEnabled,
+                    enableEvidence: child.enableEvidence,
+                    commitEvidence: child.commitEvidence,
+                    ...(child.fast ? { fast: true } : {}),
+                });
             }
         }
     }

package/dist/packages/core/src/application/use-cases/features/resume-feature.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/features/resume-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAE7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AAQlG,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,qBACa,oBAAoB;IAG7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;gBANf,WAAW,EAAE,kBAAkB,EAE/B,OAAO,EAAE,mBAAmB,EAE5B,cAAc,EAAE,2BAA2B,EAE3C,eAAe,EAAE,gBAAgB;IAG9C,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAClC,OAAO,CAAC,mBAAmB,CAAC;CAyGhC"}
+{"version":3,"file":"resume-feature.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/features/resume-feature.use-case.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAE7E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iEAAiE,CAAC;AAC1G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6DAA6D,CAAC;AACvG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAChH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2DAA2D,CAAC;AAQlG,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,qBACa,oBAAoB;IAG7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAE5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;gBANf,WAAW,EAAE,kBAAkB,EAE/B,OAAO,EAAE,mBAAmB,EAE5B,cAAc,EAAE,2BAA2B,EAE3C,eAAe,EAAE,gBAAgB;IAG9C,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAClC,OAAO,CAAC,mBAAmB,CAAC;CA4GhC"}

package/dist/packages/core/src/application/use-cases/features/resume-feature.use-case.js

@@ -111,6 +111,9 @@ let ResumeFeatureUseCase = class ResumeFeatureUseCase {
             openPr: feature.openPr,
             forkAndPr: feature.forkAndPr,
             commitSpecs: feature.commitSpecs,
+            ciWatchEnabled: feature.ciWatchEnabled,
+            enableEvidence: feature.enableEvidence,
+            commitEvidence: feature.commitEvidence,
             agentType: lastRun.agentType,
             ...(feature.fast ? { fast: true } : {}),
             ...(lastRun.modelId ? { model: lastRun.modelId } : {}),