@tarcisiopgs/lisa 1.18.0 → 1.19.0

package/README.md

@@ -1,18 +1,15 @@
 # Lisa
 
 <p align="center">
-  <strong>Label an issue. Walk away. Come back to a PR.</strong>
+  <img src="assets/lisa.png" width="200" alt="Lisa" />
 </p>
 
 <p align="center">
-  <a href="https://www.npmjs.com/package/@tarcisiopgs/lisa"><img src="https://img.shields.io/npm/v/@tarcisiopgs/lisa.svg" alt="npm version" /></a>
-  <a href="https://www.npmjs.com/package/@tarcisiopgs/lisa"><img src="https://img.shields.io/npm/dm/@tarcisiopgs/lisa.svg" alt="npm downloads" /></a>
-  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License: MIT" /></a>
-  <img src="https://img.shields.io/node/v/%40tarcisiopgs%2Flisa" alt="Node.js version" />
+  <strong>Label an issue. Walk away. Come back to a PR.</strong>
 </p>
 
 <p align="center">
-  <img src="assets/demo.gif?v=2" alt="Lisa demo" width="800" />
+  Lisa is an autonomous issue resolver that turns your backlog into pull requests — no babysitting required.
 </p>
 
 ---
@@ -21,46 +18,61 @@
 
 ```bash
 npm install -g @tarcisiopgs/lisa
-lisa init        # interactive setup — picks your source + provider
-lisa run         # start resolving issues
+lisa init
+lisa run
 ```
 
-Verify your setup first with `lisa run --once --dry-run` — no issues will be fetched, no code written, no PRs created.
+That's it. Lisa picks up the next labeled issue, implements it, pushes a branch, opens a pull request, and moves the ticket to "In Review" — all without you touching it.
 
-Lisa picks up the next labeled issue, implements it, pushes a branch, opens a pull request, and moves the ticket to "In Review" — all without you touching it.
+## Try it safely first
 
----
+Before letting Lisa touch real issues, verify your configuration with `--dry-run`. No issues will be fetched, no code will be written, no PRs will be created.
+
+```bash
+lisa run --once --dry-run
+```
 
-## How It Works
+Example output:
 
 ```
-┌─────────┐    ┌──────────┐    ┌───────────┐    ┌──────────┐    ┌────┐    ┌────────┐
-│  Fetch   │───▶│ Activate │───▶│ Implement │───▶│ Validate │───▶│ PR │───▶│ Update │
-└─────────┘    └──────────┘    └───────────┘    └──────────┘    └────┘    └────────┘
+[dry-run] Would fetch issue from linear (Engineering/Web App)
+[dry-run] Workflow mode: worktree
+[dry-run] Models priority: claude/claude-sonnet-4-6
+[dry-run] Then implement, push, create PR, and update issue status
 ```
 
-1. **Fetch and activate** — Pulls the next priority-sorted issue matching your configured label and moves it to `in_progress`.
-2. **Implement** — Builds a structured prompt with full issue context and sends it to the AI agent. The agent works in a worktree or branch, implements the change, runs tests, and commits.
-3. **Push and PR** — Pushes the branch, creates a pull request referencing the original issue. If pre-push hooks fail, re-invokes the agent with the error output and retries.
-4. **Update and loop** — Moves the issue to `done`, removes the pickup label, and picks the next issue. Stops when the queue is empty.
+If the output looks correct, you're ready to run Lisa for real.
 
----
+## What Lisa Does
+
+Lisa follows a deterministic pipeline:
 
-## Issue Sources
+```
+┌─────────┐    ┌──────────┐    ┌─────────┐    ┌───────────┐    ┌──────────┐    ┌────┐    ┌────────┐
+│  Fetch   │───▶│ Activate │───▶│ Context │───▶│ Implement │───▶│ Validate │───▶│ PR │───▶│ Update │
+└─────────┘    └──────────┘    └─────────┘    └───────────┘    └──────────┘    └────┘    └────────┘
+```
 
-| Source | Key |
-|--------|-----|
-| Linear | `linear` |
-| GitHub Issues | `github-issues` |
-| Jira | `jira` |
-| GitLab Issues | `gitlab-issues` |
-| Trello | `trello` |
-| Plane | `plane` |
-| Shortcut | `shortcut` |
+1. **Fetch** — Pulls the next issue from Linear, Trello, Plane, Shortcut, GitLab Issues, GitHub Issues, or Jira matching the configured label, team, and project. Issues are sorted by priority. Blocked issues are skipped.
+2. **Activate** — Moves the issue to `in_progress` so your team knows it's being worked on.
+3. **Context** — On first run, Lisa analyzes your codebase and generates `.lisa/context.md` — a concise project guide (stack, conventions, constraints) injected into every agent prompt. Skipped automatically if the file already exists.
+4. **Implement** — Builds a structured prompt with full issue context and sends it to the AI agent. The agent works in a worktree or branch, implements the change, runs tests, and commits.
+5. **Validate** — If the agent's tests pass and pre-push hooks succeed, the branch is pushed. If hooks fail, Lisa re-invokes the agent with the error output and retries.
+6. **PR** — Pushes the branch and creates a pull request referencing the original issue.
+7. **Update** — Moves the issue to the `done` status and removes the pickup label.
+8. **Next** — Picks the next issue. When there are no more matching issues, Lisa stops.
 
----
+### What makes it different
+
+- **Deterministic, not hopeful** — Each issue follows a structured pipeline with clear stages. No blind retries, no speculative loops.
+- **Token efficiency** — Each issue gets one focused prompt. No wasted retries, no idle polling.
+- **Multi-repo awareness** — Plans across multiple repos, executes in the correct order, creates one PR per repo.
+- **Model fallback** — Configure a chain of models. Transient errors (429, quota, timeout) trigger the next model automatically.
+- **Workflow integration** — Issues move through your board in real time. Your team always knows what's being worked on.
+- **Self-healing** — Orphan issues stuck in "In Progress" are recovered on startup. Pre-push failures trigger the agent to fix and retry.
+- **Guardrails** — Past failures are logged and injected into future prompts so the agent avoids repeating mistakes.
 
-## AI Providers
+## Providers
 
 | Provider | Key | Command |
 |----------|-----|---------|
@@ -77,7 +89,7 @@ At least one provider must be installed and available in your PATH.
 
 ### Fallback Chain
 
-Configure multiple models — Lisa tries each in order. Transient errors (429, quota, timeout, network) trigger the next model automatically.
+Configure multiple models — Lisa tries each in order. Transient errors (429, quota, timeout, network) trigger the next model; non-transient errors stop the chain.
 
 ```yaml
 provider: claude
@@ -87,69 +99,166 @@ models:
   - claude-haiku-4-5    # fallback 2
 ```
 
----
-
-## PR Platforms
+When the TUI is active, the sidebar shows a **Model Queue** — the currently active model is highlighted with a bullet (●).
 
-| Platform | Key | Auth |
-|----------|-----|------|
-| GitHub CLI | `cli` | `gh auth login` |
-| GitHub API | `token` | `GITHUB_TOKEN` |
-| GitLab | `gitlab` | `GITLAB_TOKEN` |
-| Bitbucket | `bitbucket` | `BITBUCKET_TOKEN` + `BITBUCKET_USERNAME` |
+## Install
 
----
+```bash
+npm install -g @tarcisiopgs/lisa
+```
 
 ## Environment Variables
 
-Set the tokens for your chosen source and PR platform:
-
 ```bash
-# PR platform
-GITHUB_TOKEN          # GitHub (platform: cli or token)
-GITLAB_TOKEN          # GitLab (platform: gitlab)
-BITBUCKET_TOKEN       # Bitbucket app password (platform: bitbucket)
-BITBUCKET_USERNAME    # Bitbucket username
-
-# Issue sources
-LINEAR_API_KEY        # source: linear
-TRELLO_API_KEY        # source: trello
-TRELLO_TOKEN
-SHORTCUT_API_TOKEN    # source: shortcut
-PLANE_API_TOKEN       # source: plane
-PLANE_BASE_URL        # optional, defaults to https://api.plane.so
-GITLAB_TOKEN          # source: gitlab-issues
-GITLAB_BASE_URL       # optional, defaults to https://gitlab.com
-GITHUB_TOKEN          # source: github-issues
-JIRA_BASE_URL         # source: jira (e.g. https://yourorg.atlassian.net)
-JIRA_EMAIL
-JIRA_API_TOKEN        # generate at id.atlassian.com — expires, regenerate if 401
-
-# Aider provider (one of)
-GEMINI_API_KEY
-OPENAI_API_KEY
-ANTHROPIC_API_KEY
+# Required for PR creation (at least one)
+export GITHUB_TOKEN=""    # or have `gh` CLI authenticated
+export GITLAB_TOKEN=""    # platform: gitlab
+export BITBUCKET_TOKEN="" # platform: bitbucket
+export BITBUCKET_USERNAME=""
+
+# Required when source = linear
+export LINEAR_API_KEY=""
+
+# Required when source = trello
+export TRELLO_API_KEY=""
+export TRELLO_TOKEN=""
+
+# Required when source = plane
+export PLANE_API_TOKEN=""
+export PLANE_BASE_URL=""  # optional; defaults to https://api.plane.so
+
+# Required when source = shortcut
+export SHORTCUT_API_TOKEN=""
+
+# Required when source = gitlab-issues
+export GITLAB_TOKEN=""
+export GITLAB_BASE_URL=""  # optional; defaults to https://gitlab.com
+
+# Required when source = github-issues
+export GITHUB_TOKEN=""     # same token used for PR creation
+
+# Required when source = jira
+export JIRA_BASE_URL=""        # e.g. https://yourcompany.atlassian.net
+export JIRA_EMAIL=""           # Atlassian account email
+export JIRA_API_TOKEN=""       # Atlassian API token
+
+# Required when provider = aider (one of)
+export GEMINI_API_KEY=""
+export OPENAI_API_KEY=""
+export ANTHROPIC_API_KEY=""
 ```
 
----
-
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `lisa run` | Run the agent loop |
 | `lisa run --once` | Process a single issue |
-| `lisa run --once --dry-run` | Preview config without executing |
-| `lisa run --watch` | Poll for new issues every 60s after queue empties |
+| `lisa run --once --dry-run` | **Recommended first step** — preview config without executing |
+| `lisa run --watch` | Keep running after queue empties — poll for new issues every 60s |
 | `lisa run --issue ID` | Process a specific issue by identifier or URL |
 | `lisa run --concurrency N` | Process N issues in parallel (each in its own worktree) |
+| `lisa run --limit N` | Stop after processing N issues |
+| `lisa run --provider NAME` | Override AI provider |
+| `lisa run --source NAME` | Override issue source |
+| `lisa run --label NAME` | Override label filter |
+| `lisa run --platform NAME` | Override PR platform (`cli`, `token`, `gitlab`, `bitbucket`) |
+| `lisa run --no-bell` | Disable terminal bell on completion/failure |
+| `lisa run --demo` | Run an animated demo of the Kanban UI with fake issues |
 | `lisa init` | Create `.lisa/config.yaml` interactively |
 | `lisa config --show` | Print current config |
-| `lisa status` | Show session stats |
+| `lisa status` | Show session stats and log file location |
+| `lisa context` | Show the current `.lisa/context.md` for all repos |
+| `lisa context refresh` | Regenerate `.lisa/context.md` |
+| `lisa context refresh --repo NAME` | Regenerate context for a specific repo (multi-repo only) |
+| `lisa feedback --pr URL` | Inject PR review feedback from a closed PR into guardrails |
 
-Run `lisa run --help` for all available flags.
+## TUI
 
----
+When running in an interactive terminal, `lisa run` renders a real-time Kanban board:
+
+```
+┌──────────────────────────┐ ┌───────────────────────────┐ ┌───────────────────────────┐
+│ ▶ BACKLOG            [3] │ │ ▶ IN PROGRESS         [1] │ │ ▶ IN REVIEW           [2] │
+│                          │ │                           │ │                           │
+│ ┌────────────────────┐   │ │ ┌─────────────────────┐   │ │ ┌─────────────────────┐   │
+│ │ ENG-42             │   │ │ │ ● ENG-38             │   │ │ │ ✓ ENG-35            │   │
+│ │ Add dark mode      │   │ │ │ Fix login redirect   │   │ │ │ Update dependencies │   │
+│ │ ready              │   │ │ │ ~1m running          │   │ │ │ PR created          │   │
+│ └────────────────────┘   │ │ └─────────────────────┘   │ │ └─────────────────────┘   │
+└──────────────────────────┘ └───────────────────────────┘ └───────────────────────────┘
+```
+
+### Keyboard shortcuts
+
+| Key | Action |
+|-----|--------|
+| `←` `→` | Switch columns |
+| `↑` `↓` | Navigate cards within a column |
+| `↵` | Open issue detail view (streams provider output) |
+| `p` | Pause / resume (suspends the active provider process) |
+| `k` | Kill the selected in-progress issue (marks it for retry) |
+| `s` | Skip the selected in-progress issue (moves back to Backlog) |
+| `q` | Quit |
+| `Esc` | Return to board from detail view |
+| `o` | Open PR URL in browser (detail view, when PR exists) |
+
+The terminal tab title updates in real time: it shows a spinner with the active issue ID while work is in progress, and a checkmark when done.
+
+### State Persistence
+
+The Kanban board state is saved automatically to the OS cache directory and restored when you restart `lisa run`. Cards survive process restarts — issues that completed remain visible in "Done", and issues that were mid-flight are correctly re-queued as Backlog.
+
+### PR Merge Detection
+
+For GitHub and GitLab PRs, Lisa polls every 60 seconds and marks cards in the Done column as **merged** once the PR is merged — live, without restarting.
+
+## Project Context
+
+On first run, Lisa automatically analyzes your codebase and writes `.lisa/context.md` — a concise document covering your stack, exact tool commands, file conventions, and constraints. This file is injected into every agent prompt so the agent works correctly from the start without rediscovering project-specific patterns.
+
+Context is generated once and reused on subsequent runs. To regenerate it (e.g. after switching stacks or adding tooling):
+
+```bash
+lisa context refresh
+```
+
+For multi-repo workspaces, Lisa generates a per-repo `context.md` for each repository plus a global workspace context describing cross-repo relationships and execution ordering rules.
+
+```bash
+lisa context refresh --repo my-api   # regenerate a single repo's context
+```
+
+If context generation fails, Lisa logs a warning and continues — it is never a blocker.
+
+## Writing Issues
+
+Issue quality is the single biggest factor in PR quality. Lisa validates issues before accepting them — vague tickets without clear criteria are skipped and labelled `needs-spec`.
+
+Issues must contain acceptance criteria: markdown checklists (`- [ ]`) or keywords like `acceptance criteria`, `expected`, `should`.
+
+### Example
+
+```markdown
+Title: Add rate limiting to /api/users endpoint
+
+Description:
+Implement rate limiting on the `/api/users` endpoint to prevent abuse.
+
+Relevant files:
+- src/routes/users.ts
+- src/middleware/auth.ts
+
+Acceptance criteria:
+- [ ] Requests exceeding 100/min per IP return HTTP 429
+- [ ] Rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining) included in all responses
+- [ ] Rate limit state stored in Redis (use existing connection from src/lib/redis.ts)
+- [ ] Existing tests still pass
+
+Stack: Express, Redis
+```
+
+Including **relevant files**, **technical constraints**, and **stack information** in the description leads to better results.
 
 ## Configuration
 
@@ -158,7 +267,7 @@ Config lives in `.lisa/config.yaml`. Run `lisa init` to create it interactively.
 ```yaml
 provider: claude
 source: linear
-workflow: worktree          # "worktree" (isolated) or "branch" (in-place)
+workflow: worktree
 
 source_config:
   team: Engineering
@@ -168,105 +277,156 @@ source_config:
   in_progress: In Progress
   done: In Review
 
-platform: cli               # "cli", "token", "gitlab", or "bitbucket"
+platform: cli        # "cli" (gh), "token" (GITHUB_TOKEN), "gitlab", or "bitbucket"
 workspace: .
 base_branch: main
 
-# Multi-repo (optional)
 repos:
   - name: my-api
     path: ./api
     base_branch: main
-    match: "[API]"           # route issues by title prefix
+    match: "[API]"        # route issues whose title starts with "[API]" to this repo
   - name: my-app
     path: ./app
     base_branch: main
 
 loop:
-  cooldown: 10               # seconds between issues
-  max_sessions: 0            # 0 = unlimited
-  session_timeout: 0         # seconds per provider run (0 = disabled)
+  cooldown: 10             # seconds between issues
+  max_sessions: 0          # 0 = unlimited
+  session_timeout: 0       # seconds per provider run (0 = disabled)
 
 # Optional — kill stuck providers
 overseer:
   enabled: true
-  check_interval: 30         # seconds between git status checks
-  stuck_threshold: 300       # seconds without changes before killing
+  check_interval: 30       # seconds between git status checks
+  stuck_threshold: 300     # seconds without git changes before killing
+
+# Optional — Docker infrastructure management (disabled by default)
+lifecycle:
+  mode: auto               # "auto" = start/stop services, "skip" = disabled (default), "validate-only" = fail if not running
+  timeout: 30              # seconds per service to wait on startup
 
 # Optional — skip issues without acceptance criteria
 validation:
   require_acceptance_criteria: true
 ```
 
-### Source-specific notes
-
-**GitHub Issues / GitLab Issues** — `pick_from`, `in_progress`, and `done` are **labels**, not statuses. Make sure `in_progress` differs from `pick_from`; using the same value causes Lisa to re-pick issues that are already being worked on.
-
-**Trello** — `team`, `pick_from`, `in_progress`, and `done` are list **names** (not IDs).
+### Source-Specific Fields
 
-**Jira** — `team` is your project **key** (e.g. `ENG`). `JIRA_API_TOKEN` is generated at [id.atlassian.com](https://id.atlassian.com) and expires — regenerate if you get 401 errors.
+| Field | Linear | Trello | Plane | Shortcut | GitLab Issues | GitHub Issues | Jira |
+|-------|--------|--------|-------|----------|---------------|---------------|------|
+| `team` | Team name | Board name | Workspace slug | Group name (optional) | Project path (`namespace/project`) or numeric ID | `owner/repo` | Project key (e.g. `ENG`) |
+| `project` | Project name | — | Project identifier or UUID | — | — | — | — |
+| `pick_from` | Status to pick issues from | List to pick cards from | State name to pick issues from | Workflow state to pick stories from | — | — | Status to pick issues from |
+| `label` | Label to filter issues | Label to filter cards | Label to filter issues | Label to filter stories | Label to filter issues | Label to filter issues | Label to filter issues |
+| `in_progress` | In-progress status | In-progress column | In-progress state name | In-progress workflow state | Label to apply on activate | Label to apply on activate | In-progress status name |
+| `done` | Destination status after PR | Destination column after PR | Done state name | Done workflow state | Closes the issue | Closes the issue | Destination status after PR |
 
-**Goose** — `lisa init` asks which backend to use (gemini-cli, anthropic, openai, etc.) and saves it to config. No env vars needed. You can also set `GOOSE_PROVIDER` manually — it takes precedence over the config value.
+Plane example:
 
-**Aider** — requires a direct LLM API key (`GEMINI_API_KEY`, `OPENAI_API_KEY`, or `ANTHROPIC_API_KEY`). Does not support OAuth or cached credentials.
-
-**OpenCode** — if `~/.config/opencode/config.json` contains MCP entries, remove them or set the file to `{}` to prevent OpenCode from hanging on startup.
-
----
+```yaml
+source: plane
+source_config:
+  team: my-workspace       # workspace slug (or set PLANE_WORKSPACE env var)
+  project: DEV             # project identifier or UUID
+  label: ready             # issues with this label are picked up
+  pick_from: Todo          # state to fetch issues from
+  in_progress: In Progress # state set when Lisa starts working
+  done: Done               # state set after PR is created
+```
 
-### Workflow Modes
+Shortcut example:
 
-**Branch** — The agent creates a branch in your current checkout. Simple setup, works everywhere.
+```yaml
+source: shortcut
+source_config:
+  label: ready              # stories with this label are picked up
+  pick_from: Ready for Development  # workflow state to fetch stories from
+  in_progress: In Progress  # state set when Lisa starts working
+  done: Done                # state set after PR is created
+```
 
-**Worktree** — Lisa creates an isolated git worktree per issue under `.worktrees/`. Your main checkout stays untouched. Cleaned up automatically after the PR is created.
+GitLab Issues example:
 
-When `--concurrency` is greater than 1, worktree mode is enforced automatically.
+```yaml
+source: gitlab-issues
+source_config:
+  team: my-org/my-repo     # namespace/project path or numeric project ID
+  label: ready              # issues with this label are picked up
+  in_progress: in-progress  # label applied when Lisa starts working
+  done: ""                  # issue is closed after PR (value unused)
+```
 
----
+GitHub Issues example:
 
-### Session Timeout
+```yaml
+source: github-issues
+source_config:
+  team: my-org/my-repo     # owner/repo
+  label: ready              # issues with this label are picked up
+  in_progress: in-progress  # label applied when Lisa starts working
+  done: ""                  # issue is closed after PR (value unused)
+```
 
-If a provider hangs (e.g. misconfigured model, network issue), Lisa can kill it after a configurable duration:
+Jira example:
 
 ```yaml
-loop:
-  session_timeout: 300  # kill provider after 5 minutes (0 = disabled, default)
+source: jira
+source_config:
+  team: ENG                # Jira project key
+  label: lisa              # label to filter issues
+  pick_from: Backlog       # status to pick issues from
+  in_progress: In Progress # status applied when Lisa starts working
+  done: In Review          # status applied after PR is created
 ```
 
-When the timeout fires, the provider process is killed and the error is eligible for fallback — Lisa will try the next model in your chain. This is disabled by default so long-running sessions work uninterrupted.
+### Workflow Modes
 
----
+**Branch** — The AI agent creates a branch directly in your current checkout, implements the changes, and pushes. Simple setup, works everywhere.
 
-## Writing Issues
+**Worktree** — Lisa creates an isolated [git worktree](https://git-scm.com/docs/git-worktree) for each issue under `.worktrees/`. The agent works in the worktree without touching your main checkout. After the PR is created, the worktree is cleaned up automatically. Ideal when you want to keep working in the repo while Lisa resolves issues in the background.
 
-Issue quality is the single biggest factor in PR quality. Lisa validates issues before accepting them — vague tickets without clear criteria are skipped and labelled `needs-spec`.
+**Multi-repo worktree** — When multiple repos are configured, Lisa runs a two-phase flow: a planning agent produces a `.lisa-plan.json` with ordered steps, then Lisa executes each step sequentially — one worktree and one PR per repo. Cross-repo context (branch names, PR URLs) is passed to each subsequent step.
 
-Issues must contain acceptance criteria: markdown checklists (`- [ ]`) or keywords like `acceptance criteria`, `expected`, `should`.
+When `--concurrency` is greater than 1, worktree mode is enforced automatically.
 
-### Example
+### Lifecycle Resources
 
-```markdown
-Title: Add rate limiting to /api/users endpoint
+For repos that need services running during implementation (databases, dev servers):
 
-Description:
-Implement rate limiting on the `/api/users` endpoint to prevent abuse.
+```yaml
+repos:
+  - name: my-api
+    path: ./api
+    base_branch: main
+    lifecycle:
+      resources:
+        - name: postgres
+          check_port: 5432
+          up: "docker compose up -d postgres"
+          down: "docker compose down"
+          startup_timeout: 30
+      setup:
+        - "npx prisma generate"
+        - "npx prisma db push"
+```
 
-Relevant files:
-- src/routes/users.ts
-- src/middleware/auth.ts
+Lisa starts resources before the agent runs, waits for the port to be ready, runs setup commands, then stops everything after the session.
 
-Acceptance criteria:
-- [ ] Requests exceeding 100/min per IP return HTTP 429
-- [ ] Rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining) included in all responses
-- [ ] Rate limit state stored in Redis (use existing connection from src/lib/redis.ts)
-- [ ] Existing tests still pass
+### Recovery Mechanisms
 
-Stack: Express, Redis
-```
+- **Orphan recovery** — On startup, Lisa scans for issues stuck in `in_progress` from interrupted runs and reverts them to `pick_from`.
+- **Push recovery** — If `git push` fails due to pre-push hooks (linter, typecheck, tests), Lisa re-invokes the agent with the error output and retries the push.
+- **Signal handling** — SIGINT/SIGTERM gracefully revert the active issue to its previous status before exiting.
+- **Guardrails** — Failed sessions are logged and injected into future prompts so the agent avoids repeating the same mistakes. Use `lisa feedback --pr URL` to manually inject review feedback from a closed PR.
 
-Including **relevant files**, **technical constraints**, and **stack information** in the description leads to better results.
+### Overseer
 
----
+When enabled, the overseer periodically checks `git status` in the working directory. If no changes are detected within `stuck_threshold` seconds, the provider process is killed and the error is eligible for fallback to the next model.
+
+### Auto-Detection
+
+Lisa auto-detects `vitest` or `jest` from `package.json` dependencies and injects the correct test command into the agent prompt. It also detects the package manager from lockfiles (`bun.lockb`/`bun.lock` → `bun`, `pnpm-lock.yaml` → `pnpm`, `yarn.lock` → `yarn`, otherwise `npm`).
 
 ## License
 

package/dist/{chunk-KDKCASVH.js → chunk-2SHKSRQZ.js}

@@ -647,8 +647,8 @@ function registerBellListeners(bellEnabled) {
     kanbanEmitter.off("work:complete", onComplete);
   };
 }
-function useKanbanState(bellEnabled) {
-  const [cards, setCards] = useState([]);
+function useKanbanState(bellEnabled, initialCards = []) {
+  const [cards, setCards] = useState(initialCards);
   const [isEmpty, setIsEmpty] = useState(false);
   const [isWatching, setIsWatching] = useState(false);
   const [isWatchPrompt, setIsWatchPrompt] = useState(false);
@@ -816,6 +816,15 @@ function useKanbanState(bellEnabled) {
       }
     };
   }, [bellEnabled]);
+  useEffect(() => {
+    for (const card of initialCards) {
+      if (card.column === "done" && card.prUrls.length > 0 && !card.merged) {
+        for (const url of card.prUrls) {
+          startMergePolling(card.id, url);
+        }
+      }
+    }
+  }, []);
   return { cards, isEmpty, isWatching, isWatchPrompt, workComplete, modelInUse };
 }
 

package/dist/{chunk-GZ2ZAQO4.js → chunk-EK5XS7CB.js}

@@ -44,6 +44,9 @@ function getPlanPath(cwd, issueId) {
   }
   return join(getCacheDir(cwd), "plan.json");
 }
+function getKanbanStatePath(cwd) {
+  return join(getCacheDir(cwd), "kanban-state.json");
+}
 function ensureCacheDir(cwd) {
   const dir = getCacheDir(cwd);
   if (!existsSync(dir)) {
@@ -76,6 +79,7 @@ export {
   getManifestPath,
   getPrCachePath,
   getPlanPath,
+  getKanbanStatePath,
   ensureCacheDir,
   rotateLogFiles
 };

package/dist/{chunk-UQPR5OXK.js → chunk-N35HZN5O.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getGuardrailsPath
-} from "./chunk-GZ2ZAQO4.js";
+} from "./chunk-EK5XS7CB.js";
 
 // src/session/guardrails.ts
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{guardrails-I5ACG5LQ.js → guardrails-OAO4CAIT.js}

@@ -10,8 +10,8 @@ import {
   guardrailsPath,
   migrateGuardrails,
   readGuardrails
-} from "./chunk-UQPR5OXK.js";
-import "./chunk-GZ2ZAQO4.js";
+} from "./chunk-N35HZN5O.js";
+import "./chunk-EK5XS7CB.js";
 export {
   appendEntry,
   appendEntrySync,