feinai 0.6.4 → 0.6.6

package/CHANGELOG.md

@@ -12,23 +12,23 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## [0.5.0] - 2026-06-10
 
 ### Added
-- `tasca git <cmd>` — safe git wrapper subcommand. Passes through to `opengit`, enforcing a worktree-only whitelist (blocks branch, merge, rebase, checkout, etc.)
-- `opengit` shipped as a binary alongside `tasca` — `bun install -g tasca` now installs both
-- `tasca unblock <TASK-ID> --dep <TASK-ID>` — remove a specific dependency from a task
-- `tasca edit --clear-blocked-by` — clear all dependencies from a task
-- Live Agents Monitor: working directory, repo name, and `.tasca` path shown per agent card
+- `feinai git <cmd>` — safe git wrapper subcommand. Passes through to `opengit`, enforcing a worktree-only whitelist (blocks branch, merge, rebase, checkout, etc.)
+- `opengit` shipped as a binary alongside `feinai` — `bun install -g feinai` now installs both
+- `feinai unblock <TASK-ID> --dep <TASK-ID>` — remove a specific dependency from a task
+- `feinai edit --clear-blocked-by` — clear all dependencies from a task
+- Live Agents Monitor: working directory, repo name, and `.feinai` path shown per agent card
 - Live Agents Monitor: presence indicator — gray dot when idle, green dot with ripple animation when agents are active
 - Live Agents Monitor: elapsed time and spec ID per card
-- `tasca init` now auto-adds `.tasca/` to `.gitignore` if in a git repo
-- Skills: `tasca-implement` — claim one pending task, implement in isolated worktree, run quality gates, push to main
+- `feinai init` now auto-adds `.feinai/` to `.gitignore` if in a git repo
+- Skills: `feinai-implement` — claim one pending task, implement in isolated worktree, run quality gates, push to main
 
 ### Changed
 - Dashboard is now English-only — removed i18n/language selector
-- `tasca-implement` SKILL.md updated to use `tasca git` instead of `opengit` directly
+- `feinai-implement` SKILL.md updated to use `feinai git` instead of `opengit` directly
 - `package.json`: added `repository`, `homepage`, `bugs` fields
 
 ### Skills included
-`tasca-sdd` · `tasca-write-spec` · `tasca-write-tasks` · `tasca-dispatch` · `tasca-implement`
+`feinai-sdd` · `feinai-write-spec` · `feinai-write-tasks` · `feinai-dispatch` · `feinai-implement`
 
 ---
 
@@ -37,11 +37,11 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 Initial public release. Core CLI with specs, plans, tasks, HTTP dashboard, and SDD skills.
 
 ### Features
-- `tasca init / status / list / add / show / take / done / fail / block / release / reopen / edit`
-- `tasca spec` — spec lifecycle (add, start, done, archive, set-content, edit)
-- `tasca plan` — plan revisions per spec
-- `tasca server` — HTTP dashboard + REST API + SSE live updates
+- `feinai init / status / list / add / show / take / done / fail / block / release / reopen / edit`
+- `feinai spec` — spec lifecycle (add, start, done, archive, set-content, edit)
+- `feinai plan` — plan revisions per spec
+- `feinai server` — HTTP dashboard + REST API + SSE live updates
 - Live Agents Monitor — real-time view of in-progress tasks with worktree state
 - Atomic `take` — SQL-level concurrency safety for parallel agents
 - Append-only events audit log
-- Skills: `tasca-sdd`, `tasca-write-spec`, `tasca-write-tasks`, `tasca-dispatch`
+- Skills: `feinai-sdd`, `feinai-write-spec`, `feinai-write-tasks`, `feinai-dispatch`

package/README.md

@@ -1,73 +1,134 @@
 # feinai
 
-**Multi-agent development breaks down without coordination infrastructure.**
+Local coordination layer for multi‑agent coding workflows.
 
-Skills and prompts get agents started. They don't solve what happens when five agents run in parallel: stale state, token waste reading giant markdown files, tasks claimed twice, agents stepping on each other's work, no visibility into what's actually happening.
+When multiple coding agents work on the same repo, things break long before the model runs out of IQ: duplicated work, inconsistent task state, agents trampling each other's branches, and no clear visibility into what is happening where.
 
-feinai is the missing layer.
+**feinai** focuses on one thing: make that coordination deterministic, auditable, and safe for your git repo – locally, without a cloud service.
 
 ---
 
-## The problems it solves
+## Why feinai
 
-**Token waste.** Agents reading `QUEUE.md` or `BACKLOG.md` to find their next task burn context on irrelevant state. A 200-line plan file costs tokens every time — most of it noise for any given agent. feinai gives each agent exactly what it needs in a single call.
+Multi‑agent development breaks down without coordination infrastructure. Skills and prompts get agents started, but they do not solve the ugly parts of running several agents in parallel:
 
-**Inconsistent task state.** Two agents claim the same task. One overwrites the other's work. You find out when the merge fails. feinai's `take` is an atomic SQL operation — if two agents race, one wins and one gets rejected. No duplicates, no silent overwrites.
-
-**No isolation.** Agents sharing a branch corrupt each other's work mid-task. feinai-dispatch puts every agent in its own git worktree, linked to a specific task, visible in the dashboard. Work is isolated until it's ready to merge.
-
-**Zero visibility.** You don't know which agent is doing what, which files it touched, how long it's been running, or whether it's stuck. The feinai dashboard shows all of this live.
-
-**Skill-based approaches hit a ceiling.** Skills and prompt instructions are probabilistic — the model can ignore them, misinterpret them, or hallucinate state. Deterministic coordination requires a tool, not a suggestion. feinai makes the workflow atomic, auditable, and race-free at the infrastructure level.
+- **Token waste on shared Markdown.** Agents reading `QUEUE.md` or `BACKLOG.md` to find their next task burn context on irrelevant state. A 200‑line plan file costs tokens every time – most of it noise for any given agent. feinai gives each agent exactly what it needs in a single call.
+- **Inconsistent task state.** Two agents claim the same task. One overwrites the other's work. You find out when the merge fails. `feinai take` is an atomic SQL operation – if two agents race, one wins and one gets rejected. No duplicates, no silent overwrites.
+- **No isolation in git.** Agents sharing a branch corrupt each other's work mid‑task. `feinai-dispatch` puts every agent in its own git worktree, linked to a specific task, visible in the dashboard. Work is isolated until it's ready to merge.
+- **Zero visibility.** You don't know which agent is doing what, which files it touched, how long it has been running, or whether it's stuck. The feinai dashboard shows all of this live.
+- **Skills hit a ceiling.** Skills and prompt instructions are probabilistic – the model can ignore them, misinterpret them, or hallucinate state. Deterministic coordination requires a tool, not a suggestion. feinai makes the workflow atomic, auditable, and race‑free at the infrastructure level.
 
 ---
 
 ## What feinai is
 
-A CLI + HTTP API + dashboard that serves as the single source of truth for multi-agent development workflows.
+feinai is a **CLI + HTTP API + dashboard** that acts as the single source of truth for multi‑agent development workflows on a git repo.
+
+It manages four core primitives:
+
+- **Specs** – what to build and why.
+- **Plans** – how to build it.
+- **Tasks** – atomic units of work, with dependencies, quality gates, and worktree links.
+- **Events** – append‑only audit log of every state change.
 
-- **Specs** — what to build and why
-- **Plans** — how to build it
-- **Tasks** — atomic units of work, with dependencies, quality gates, and worktree links
-- **Dashboard** — live view of every agent, every worktree, every file being touched
+Agents never read raw Markdown queues. They ask feinai for work:
 
-```bash
+```sh
 feinai take TASK-121-A
 # → {id, subject, description, workplan, packages, quality_gates, worktree, ...}
 # One call. Everything the agent needs. Nothing it doesn't.
 ```
 
-State lives in a local SQLite file. No cloud, no server, no account.
+State lives in a local SQLite file. No cloud, no external service, no account.
 
 ---
 
-## Install
+## Core concepts
 
-Requires [Bun](https://bun.sh) 1.3+.
+- **Specs**  
+  High‑level product requirements: why a feature exists and what "done" means. Specs link to plans and tasks.
 
-```bash
-bun install -g feinai
-```
+- **Plans**  
+  Versioned implementation plans for a spec. A plan explains how to build it – steps, trade‑offs, constraints.
 
-Installs two binaries: `feinai` and `opengit` (safe git wrapper for parallel worktrees).
+- **Tasks**  
+  Atomic units of work with:
+  - An ID (`TASK-001-A`)
+  - Subject and description
+  - Optional `blocked_by` dependencies
+  - `quality_gates` (commands/tests that must pass)
+  - A dedicated git worktree path
 
-### PATH setup
+- **Events**  
+  Append‑only log of everything that happens: `{parent_process}:{pid}:{user}`, timestamps, transitions. Every mutation to specs, plans, tasks or worktrees is recorded.
 
-Works out of the box in interactive terminals and for local AI agents (Claude Code, opencode).
+- **Worktrees**  
+  Each task gets its own git worktree. Agents commit and push from there. The main branch stays clean until the work is ready to integrate.
 
-**Non-interactive SSH sessions only** (e.g. `ssh host 'feinai status'`) need a one-time fix:
+---
 
-```bash
-sudo ln -sf ~/.bun/bin/feinai /usr/local/bin/feinai
-sudo ln -sf ~/.bun/bin/opengit /usr/local/bin/opengit
-sudo ln -sf ~/.bun/bin/bun /usr/local/bin/bun
-```
+## Runtime & footprint
+
+- Implemented on top of **Bun 1.3+**.
+- Installs two binaries:
+  - `feinai` – main CLI + embedded HTTP server and dashboard.
+  - `opengit` – safe git wrapper for parallel worktrees.
+- Stores all state in a single SQLite file: `.feinai/feinai.db`, discovered by walking up from the current directory (like `.git`).
 
-### Activate Claude Code skills
+No background services are required beyond the optional dashboard server.
+
+---
 
-```bash
+## Supply chain & safety
+
+feinai is designed to be "boring" infrastructure:
+
+- **Local‑only state.** All coordination lives in `.feinai/feinai.db` in your repo. There is no remote backend.
+- **Explicit operations.** Every change to specs, plans, tasks and worktrees goes through the CLI or HTTP API and is logged in `events`.
+- **Safe git workflow.** `feinai git` wraps git and blocks operations that can corrupt parallel worktrees (branch, checkout, merge, rebase, reset, fetch, pull, clone).
+- **Auditability.** Every task has a clear chain: spec → plan → task → worktree → events. Every agent identity can be traced (`$FEINAI_USER` override supported).
+
+---
+
+## Using feinai with coding agents
+
+feinai is built to sit **under** coding agents (Claude Code, pi‑style harnesses, etc.) as a coordination layer.
+
+A typical pattern:
+
+1. Human or design agent writes a spec and plan.
+2. feinai decomposes the plan into tasks with dependencies and quality gates.
+3. Worker agents:
+   - Call `feinai take` to claim a task atomically.
+   - Work in the dedicated worktree for that task.
+   - Run quality gates (tests, linters, typechecks).
+   - Mark the task as `done` or `fail` with a structured result.
+4. A human (or integration agent) reviews and merges.
+
+Agents don't parse `QUEUE.md`. They talk to a small local coordination service instead.
+
+---
+
+## Claude Code skills
+
+feinai ships five Claude Code skills covering the full development loop. They activate automatically when `.feinai/feinai.db` is present:
+
+| Skill               | Purpose                                                |
+|---------------------|--------------------------------------------------------|
+| `feinai-sdd`        | Teaches Claude the feinai workflow and concepts        |
+| `feinai-write-spec` | Writes spec + plan into feinai from a design thread    |
+| `feinai-write-tasks`| Decomposes a plan into atomic tasks with parallelism   |
+| `feinai-dispatch`   | Orchestrates subagents in isolated git worktrees       |
+| `feinai-implement`  | Claims and executes one task end‑to‑end                |
+
+Together they cover: design → spec → plan → tasks → parallel execution → merge.
+
+### Activating skills in Claude Code
+
+```sh
 mkdir -p ~/.claude/skills
 SKILLS=~/.bun/install/global/node_modules/feinai/skills
+
 for skill in feinai-sdd feinai-write-spec feinai-write-tasks feinai-dispatch feinai-implement; do
   ln -sf "$SKILLS/$skill" ~/.claude/skills/$skill
 done
@@ -75,53 +136,79 @@ done
 
 ---
 
-## Quick start
+## Installation
 
-```bash
-cd my-project
-feinai init              # creates .tasca/tasca.db, adds to .gitignore
+Requires [Bun](https://bun.sh/) 1.3+.
 
-feinai spec add SPEC-001 "User authentication" --content "..."
-feinai plan add SPEC-001 --content "..."
-feinai add TASK-001-A "Create auth schema" --spec SPEC-001 --gate "pnpm typecheck"
+```sh
+bun install -g feinai
+```
 
-feinai take TASK-001-A   # atomic claim — returns full task payload
-feinai done TASK-001-A --result "typecheck ✓"
+This installs:
 
-feinai server            # live dashboard at http://127.0.0.1:8272
+- `feinai`
+- `opengit` (safe git wrapper for parallel worktrees)
+
+### PATH setup (non‑interactive SSH)
+
+In interactive shells and for local agents (Claude Code, opencode) it should work out of the box.
+
+For non‑interactive SSH sessions (e.g. `ssh host 'feinai status'`), you may need a one‑time setup:
+
+```sh
+sudo ln -sf ~/.bun/bin/feinai /usr/local/bin/feinai
+sudo ln -sf ~/.bun/bin/opengit /usr/local/bin/opengit
+sudo ln -sf ~/.bun/bin/bun /usr/local/bin/bun
 ```
 
 ---
 
-## Skills
+## Quick start
+
+```sh
+cd my-project
+
+# Initialize local state
+feinai init              # creates .feinai/feinai.db, adds to .gitignore
+
+# Add a spec and plan
+feinai spec add SPEC-001 "User authentication" --content "..."
+feinai plan add SPEC-001 --content "..."
+
+# Create a task with a quality gate
+feinai add TASK-001-A "Create auth schema" \
+  --spec SPEC-001 \
+  --gate "pnpm typecheck"
 
-feinai ships five Claude Code skills covering the full development lifecycle:
+# Agent claims a task (atomic)
+feinai take TASK-001-A   # returns full task payload as JSON
 
-| Skill | Purpose |
-|---|---|
-| `feinai-sdd` | Activates when `.tasca/tasca.db` exists — teaches Claude the workflow |
-| `feinai-write-spec` | Writes spec + plan into feinai from a design conversation |
-| `feinai-write-tasks` | Decomposes plan into atomic tasks with parallelism analysis |
-| `feinai-dispatch` | Orchestrates subagents in isolated git worktrees |
-| `feinai-implement` | Claims and executes one task end-to-end |
+# Agent completes work
+feinai done TASK-001-A --result "typecheck ✓"
 
-Full lifecycle: design → spec → tasks → parallel execution → merge.
+# Start dashboard server
+feinai server            # live dashboard at http://127.0.0.1:8272
+```
 
 ---
 
 ## Commands
 
-```
-feinai init                        Create .tasca/tasca.db
-feinai status                      Pending / in_progress / completed counts
+High‑level CLI:
+
+```text
+feinai init                        Create .feinai/feinai.db
+feinai status                      Show counts: pending / in_progress / completed
 feinai list [--pending] [--spec X] List tasks
 feinai add ID "subject"            Create task
 feinai take ID                     Atomic claim — returns full task JSON
 feinai done ID --result "..."      Mark completed
 feinai fail ID --error "..."       Mark failed
 feinai release ID                  Release back to pending
+
 feinai spec add/list/show/done     Spec lifecycle
 feinai plan add/show               Plan versions
+
 feinai git <cmd>                   Safe git wrapper (blocks merge/rebase/checkout)
 feinai server [--port N] [-d]      Dashboard + REST API
 ```
@@ -130,34 +217,57 @@ feinai server [--port N] [-d]      Dashboard + REST API
 
 ## Dashboard
 
-```bash
+Run:
+
+```sh
 feinai server -d          # background, port 8272
 feinai server --port 9000 # custom port
 ```
 
-Shows per agent: task ID, worktree path, repo, files being modified, elapsed time. Green ripple when agents are active, gray when idle. Real-time via SSE.
+The dashboard shows per agent:
+
+- Current task ID
+- Worktree path and repo
+- Files being modified
+- Elapsed time
+
+Active agents ripple in green, idle ones in gray. Updates stream in real time via SSE.
 
 ---
 
 ## `feinai git`
 
-Safe git wrapper that enforces worktree-only workflow. Blocks operations that break parallel work:
+`feinai git` is a safety wrapper around git for parallel worktrees.
+
+Allowed operations include:
 
-```bash
+```sh
 feinai git worktree add .worktrees/TASK-001 origin/main
-feinai git add . && feinai git commit -m "feat: ..."
+feinai git add .
+feinai git commit -m "feat: ..."
 feinai git push origin HEAD:main
 feinai git complete   # sync main after push
 ```
 
-Blocked: `branch`, `checkout`, `merge`, `rebase`, `reset`, `fetch`, `pull`, `clone`.
+The following are blocked when they would break the parallel workflow:
+
+- `branch`
+- `checkout`
+- `merge`
+- `rebase`
+- `reset`
+- `fetch`
+- `pull`
+- `clone`
+
+Use your normal git tooling inside each worktree; use `feinai git` when operating on shared branches.
 
 ---
 
 ## Architecture
 
-```
-<project>/.tasca/tasca.db    local SQLite, walks up from cwd like .git
+```text
+<project>/.feinai/feinai.db    # local SQLite database (discovered like .git)
 
 specs   — what to build
 plans   — how to build it (versioned)
@@ -165,10 +275,16 @@ tasks   — atomic work units with blocked_by, quality_gates, worktree
 events  — append-only audit log: {parent_process}:{pid}:{user}
 ```
 
-Every mutation is logged. Every agent is identified. Override identity with `$FEINAI_USER`.
+Every mutation is logged. Every agent is identified. You can override identity using:
+
+```sh
+export FEINAI_USER="ci-bot-01"
+```
 
 ---
 
 ## License
 
-MIT — built with ❤️ in Barcelona. *Feina* means "work" in Catalan.
+MIT — built with ❤️ in Barcelona.
+
+"Feina" means "work" in Catalan. feinai is a tiny piece of infrastructure to keep that work coordinated.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feinai",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Task & spec manager for AI agents — parallel worktrees, live dashboard, SDD skills",
   "type": "module",
   "bin": {

package/skills/feinai-dispatch/SKILL.md

@@ -66,7 +66,7 @@ PATH issue in non-interactive SSH session. `~/.bun/bin` is not loaded. Tell the
 
 ---
 
-### Failure: `feinai status` exits with code 2 (`no .tasca/tasca.db found`)
+### Failure: `feinai status` exits with code 2 (`no .feinai/feinai.db found`)
 
 feinai is installed but no DB in this project. Ask the user:
 
@@ -206,7 +206,7 @@ Spawn a subagent with this prompt template:
 
 ### Step E — Wait for results
 
-Each subagent returns `done` or `fail`. The tasca DB is the source of truth — re-query it:
+Each subagent returns `done` or `fail`. The feinai DB is the source of truth — re-query it:
 
 ```bash
 feinai show TASK-X --json

package/skills/feinai-implement/SKILL.md

@@ -1,17 +1,17 @@
 ---
 name: feinai-implement
-description: Use when a feinai task needs to be executed. Claims one pending task from tasca, implements it in an isolated worktree, runs quality gates, and pushes to main. Designed to be dispatched by feinai-dispatch or run standalone for a single task.
+description: Use when a feinai task needs to be executed. Claims one pending task from feinai, implements it in an isolated worktree, runs quality gates, and pushes to main. Designed to be dispatched by feinai-dispatch or run standalone for a single task.
 ---
 
 # feinai-implement
 
-Claim one pending task from tasca, implement it in an isolated worktree, run quality gates, push to main.
+Claim one pending task from feinai, implement it in an isolated worktree, run quality gates, push to main.
 
 ## Preconditions
 
 1. `feinai status` succeeds and there is at least one pending task
 2. Current working directory is a clean git repo
-3. `feinai git status` works (feinai git is bundled with tasca — no separate setup needed)
+3. `feinai git status` works (feinai git is bundled with feinai — no separate setup needed)
 
 If any fails: stop and report. Do not improvise.
 
@@ -79,7 +79,7 @@ Gates fallan → seguí "Si algo falla".
 **Done = 3 hechos observables:**
 1. Quality gates pasan sin errores
 2. Los archivos de la tarea existen con contenido correcto
-3. Commit limpio en `main` y tarea en estado `completed` en tasca
+3. Commit limpio en `main` y tarea en estado `completed` en feinai
 
 ---
 
@@ -102,7 +102,7 @@ Gates fallan, push falla, o error en cualquier paso:
 
 ## Git — `feinai git` exclusivamente
 
-`git` y `gh` están bloqueados. Usá `feinai git` para todo — es opengit bundleado con tasca.
+`git` y `gh` están bloqueados. Usá `feinai git` para todo — es opengit bundleado con feinai.
 
 **Permitido:**
 - `feinai git worktree add/list/lock/unlock`
@@ -125,7 +125,7 @@ Si `feinai git` falla → **STOP**. No reintentes, no uses `git`. Reportá al us
 **No modifiques:**
 - `AGENTS.md`, `CLAUDE.md`
 - Archivos de configuración de CI/CD, infra, o secretos (`.env`, `.env.*`)
-- La DB de tasca directamente
+- La DB de feinai directamente
 
 **Código:**
 - Sin `any` sin comentario justificado en la misma línea

package/skills/feinai-sdd/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: feinai-sdd
-description: Use when working in spec-driven development (SDD) workflows that involve brainstorming, writing-plans, or subagent-driven-development AND the project has a `\.feinai/feinai.db` file. Replaces creating markdown files in `docs/superpowers/specs/` and `docs/superpowers/plans/` with atomic `feinai` CLI calls, keeping state queryable, race-free, and audit-logged. Also use when the user asks to create a spec, add a task, claim work, or mark progress, in a project that uses tasca.
+description: Use when working in spec-driven development (SDD) workflows that involve brainstorming, writing-plans, or subagent-driven-development AND the project has a `\.feinai/feinai.db` file. Replaces creating markdown files in `docs/superpowers/specs/` and `docs/superpowers/plans/` with atomic `feinai` CLI calls, keeping state queryable, race-free, and audit-logged. Also use when the user asks to create a spec, add a task, claim work, or mark progress.
 ---
 
 # feinai SDD integration
@@ -21,7 +21,7 @@ Invoke when **all** of the following are true:
 
 1. The project has a `\.feinai/feinai.db` file (walk up the directory tree from
    the current working directory; feinai uses the same discovery pattern as git).
-   Check with: `feinai status` (exit code 0 = tasca is set up).
+   Check with: `feinai status` (exit code 0 = feinai is set up).
 2. You are about to:
    - Write a spec via the `brainstorming` skill, OR
    - Write a plan via the `writing-plans` skill, OR
@@ -274,7 +274,7 @@ field will read `bun:<pid>:<user>` for everyone.
 
 | Need | Command |
 |---|---|
-| Is tasca set up here? | `feinai status` |
+| Is feinai set up here? | `feinai status` |
 | Next pending task | `feinai list --pending --json` |
 | Claim a task atomically | `feinai take TASK-X` |
 | Read a spec | `feinai spec content SPEC-X` |

package/skills/feinai-write-spec/SKILL.md

@@ -1,15 +1,15 @@
 ---
 name: feinai-write-spec
-description: Use when the user wants to design a new feature, refactor, or change in a project that has `.tasca/tasca.db`. Writes a complete spec + plan into tasca in a single session. Replaces `brainstorming` + `writing-plans` from superpowers when feinai is active. Reads project context (CLAUDE.md, ARCHITECTURE.md, README.md), asks clarifying questions only when context has gaps, and produces spec+plan atomically with one `feinai spec add` + one `feinai plan add`.
+description: Use when the user wants to design a new feature, refactor, or change in a project that has `.feinai/feinai.db`. Writes a complete spec + plan into feinai in a single session. Replaces `brainstorming` + `writing-plans` from superpowers when feinai is active. Reads project context (CLAUDE.md, ARCHITECTURE.md, README.md), asks clarifying questions only when context has gaps, and produces spec+plan atomically with one `feinai spec add` + one `feinai plan add`.
 ---
 
 # feinai-write-spec
 
-Write a spec + plan for a feature in one session. Output goes to tasca, not markdown files.
+Write a spec + plan for a feature in one session. Output goes to feinai, not markdown files.
 
 ## Preconditions
 
-Run `feinai status` (exit 0 = tasca is active). If not active, stop and ask the
+Run `feinai status` (exit 0 = feinai is active). If not active, stop and ask the
 user if they want `feinai init` or to fall back to vanilla superpowers.
 
 ## The flow — three entry modes
@@ -163,7 +163,7 @@ These come up mid-session. Ask them inline, one at a time, brief:
 
 If you delegate the spec drafting to a subagent (e.g. for parallel research),
 the subagent must NOT use this skill — it has no context. Hand it concrete
-findings and let it return text; you write to tasca yourself.
+findings and let it return text; you write to feinai yourself.
 
 ---
 

package/skills/feinai-write-tasks/SKILL.md

@@ -5,7 +5,7 @@ description: Use when a spec + plan already exist in feinai (written by `feinai-
 
 # feinai-write-tasks
 
-Read an existing spec + plan from tasca, produce the executable task set.
+Read an existing spec + plan from feinai, produce the executable task set.
 
 ## Preconditions
 

package/src/cli.ts

@@ -381,9 +381,9 @@ async function cmdDestroy(args: ParsedArgs): Promise<void> {
     }
   }
 
-  const tascaDir = dbPath.replace(/\/tasca\.db$/, "");
-  rmSync(tascaDir, { recursive: true, force: true });
-  console.log(`Destroyed ${tascaDir}`);
+  const feinaiDir = dbPath.replace(/\/feinai\.db$/, "");
+  rmSync(feinaiDir, { recursive: true, force: true });
+  console.log(`Destroyed ${feinaiDir}`);
 }
 
 function cmdInit(args: ParsedArgs): void {
@@ -770,7 +770,7 @@ function cmdSpec(rest: string[], args: ParsedArgs, format: OutputFormat): void {
 async function cmdServer(args: ParsedArgs): Promise<void> {
   const port = Number(args.options.port ?? "8272");
 
-  // --down: kill whatever is listening on the tasca port
+  // --down: kill whatever is listening on the feinai port
   if (args.flags["down"]) {
     if (Number.isNaN(port) || port < 1 || port > 65535) {
       console.error("Error: --port must be a valid port number");
@@ -785,7 +785,7 @@ async function cmdServer(args: ParsedArgs): Promise<void> {
     for (const pid of pids) {
       try {
         process.kill(Number(pid), "SIGTERM");
-        console.log(`Stopped tasca server (PID ${pid}).`);
+        console.log(`Stopped feinai server (PID ${pid}).`);
       } catch {
         console.error(`Failed to kill PID ${pid}.`);
       }
@@ -812,8 +812,8 @@ async function cmdServer(args: ParsedArgs): Promise<void> {
       : [process.execPath, ...process.argv.slice(1).filter(noDaemon)];
     const child = Bun.spawn(childArgs, { detached: true, stdio: ["ignore", "ignore", "ignore"] });
     child.unref();
-    console.log(`tasca dashboard → http://${host}:${port}`);
-    console.log(`Stop with: tasca server --down`);
+    console.log(`feinai dashboard → http://${host}:${port}`);
+    console.log(`Stop with: feinai server --down`);
     return;
   }
 
@@ -821,8 +821,8 @@ async function cmdServer(args: ParsedArgs): Promise<void> {
   const { startServer } = await import("./server");
   const server = startServer({ port, host });
 
-  console.log(`tasca dashboard listening at ${server.url}`);
-  console.log(`Stop with: tasca server --down`);
+  console.log(`feinai dashboard listening at ${server.url}`);
+  console.log(`Stop with: feinai server --down`);
 
   // Keep process alive until SIGINT
   process.on("SIGINT", () => {

package/src/dashboard.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>tasca dashboard</title>
+  <title>feinai dashboard</title>
   <style>
     :root {
       --bg: #0f1117;
@@ -672,7 +672,7 @@
   <header>
     <h1>
       <span class="live-indicator" id="live"></span>
-      tasca
+      feinai
     </h1>
     <div class="stats" id="stats"></div>
     <div class="header-actions">
@@ -723,7 +723,7 @@
     </section>
   </main>
 
-  <footer>tasca · streaming live · click any item for details &amp; actions · <span id="dash-version">v—</span></footer>
+  <footer>feinai · streaming live · click any item for details &amp; actions · <span id="dash-version">v—</span></footer>
 
   <div class="modal-bg" id="modal-bg">
     <div class="modal" id="modal">
@@ -784,7 +784,7 @@
     // -------- Confirm modal --------
     function confirm(message, skipKey) {
       return new Promise((resolve) => {
-        if (localStorage.getItem("tasca-skip-" + skipKey) === "1") { resolve(true); return; }
+        if (localStorage.getItem("feinai-skip-" + skipKey) === "1") { resolve(true); return; }
         const overlay = document.createElement("div");
         overlay.style.cssText = "position:fixed;inset:0;background:rgba(0,0,0,.6);z-index:9999;display:flex;align-items:center;justify-content:center;";
         overlay.innerHTML = `
@@ -800,7 +800,7 @@
           </div>`;
         document.body.appendChild(overlay);
         overlay.querySelector("#confirm-ok").onclick = () => {
-          if (overlay.querySelector("#skip-cb").checked) localStorage.setItem("tasca-skip-" + skipKey, "1");
+          if (overlay.querySelector("#skip-cb").checked) localStorage.setItem("feinai-skip-" + skipKey, "1");
           document.body.removeChild(overlay); resolve(true);
         };
         overlay.querySelector("#confirm-cancel").onclick = () => { document.body.removeChild(overlay); resolve(false); };
@@ -827,7 +827,7 @@
     async function api(method, path, body) {
       const res = await fetch(path, {
         method,
-        headers: body ? { "Content-Type": "application/json", "X-Tasca-Actor": "dashboard" } : { "X-Tasca-Actor": "dashboard" },
+        headers: body ? { "Content-Type": "application/json", "X-Feinai-Actor": "dashboard" } : { "X-Feinai-Actor": "dashboard" },
         body: body ? JSON.stringify(body) : undefined,
       });
       if (!res.ok) {
@@ -1456,7 +1456,7 @@
           : '';
         const workingDir = task.worktree || appContext.repoRoot || "—";
         const repoName = appContext.repoName || "—";
-        const tascaLoc = appContext.tascaPath || "—";
+        const feinaiLoc = appContext.feinaiPath || "—";
         const card = document.createElement('div');
         card.className = 'worktree-card';
         card.setAttribute('data-worktree-task', task.id);
@@ -1469,7 +1469,7 @@
             <div class="worktree-context">
               <div class="context-row"><span class="context-label">Working directory</span><span class="context-value">${escapeHtml(workingDir)}</span></div>
               <div class="context-row"><span class="context-label">Repo</span><span class="context-value">${escapeHtml(repoName)}</span></div>
-              <div class="context-row"><span class="context-label">.feinai</span><span class="context-value">${escapeHtml(tascaLoc)}</span></div>
+              <div class="context-row"><span class="context-label">.feinai</span><span class="context-value">${escapeHtml(feinaiLoc)}</span></div>
             </div>
             <span class="elapsed-time" data-elapsed="${escapeHtml(task.taken_at ?? '')}"></span>
           </div>

package/src/db.ts

@@ -1,47 +1,10 @@
-import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { openSqlite, type DbAdapter } from "./sqlite-adapter";
 
 const DB_DIR = ".feinai";
 const DB_FILE = "feinai.db";
 
-// v0.5.x migration: rename .tasca/tasca.db → .feinai/feinai.db
-// TODO: remove in v0.7
-function migrateLegacyDir(dir: string): void {
-  const legacyDir = join(dir, ".tasca");
-  const legacyDb = join(legacyDir, "tasca.db");
-  const newDir = join(dir, ".feinai");
-  const newDb = join(newDir, "feinai.db");
-  if (!existsSync(legacyDb) || existsSync(newDb)) return;
-
-  // Prompt user — only works in TTY contexts
-  if (process.stdout.isTTY) {
-    process.stdout.write(
-      `\n⚠  Found legacy .tasca/tasca.db at ${legacyDir}\n` +
-      `   Rename to .feinai/feinai.db? [Y/n] `
-    );
-    const buf = Buffer.alloc(4);
-    let answer = "y";
-    try {
-      const n = require("node:fs").readSync(0, buf, 0, 4, null);
-      answer = buf.slice(0, n).toString().trim().toLowerCase() || "y";
-    } catch {}
-    if (answer !== "y" && answer !== "") {
-      process.stdout.write("Skipped. Run 'feinai init' to create a new DB.\n\n");
-      return;
-    }
-  } else {
-    // Non-interactive (agent/CI): migrate silently
-  }
-
-  if (!existsSync(newDir)) mkdirSync(newDir, { recursive: true });
-  renameSync(legacyDb, newDb);
-  try { require("node:fs").rmdirSync(legacyDir); } catch {}
-  if (process.stdout.isTTY) {
-    process.stdout.write(`✓ Migrated to .feinai/feinai.db\n\n`);
-  }
-}
-
 export type DbInstance = DbAdapter;
 
 /**
@@ -189,8 +152,6 @@ function applySchema(db: DbInstance): void {
 export function findDbPath(startDir: string = process.cwd()): string | null {
   let current = resolve(startDir);
   while (true) {
-    // migrate legacy .tasca/tasca.db → .feinai/feinai.db if found
-    migrateLegacyDir(current);
     const candidate = join(current, DB_DIR, DB_FILE);
     if (existsSync(candidate)) return candidate;
     const parent = dirname(current);
@@ -204,11 +165,11 @@ export function findDbPath(startDir: string = process.cwd()): string | null {
  * Returns the absolute path of the created DB file.
  */
 export function initDb(dir: string = process.cwd()): string {
-  const tascaDir = join(dir, DB_DIR);
-  const dbPath = join(tascaDir, DB_FILE);
+  const feinaiDir = join(dir, DB_DIR);
+  const dbPath = join(feinaiDir, DB_FILE);
 
-  if (!existsSync(tascaDir)) {
-    mkdirSync(tascaDir, { recursive: true });
+  if (!existsSync(feinaiDir)) {
+    mkdirSync(feinaiDir, { recursive: true });
   }
 
   const db = openSqlite(dbPath, { create: true });

package/src/format.ts

@@ -96,7 +96,7 @@ export function formatSpec(
     if (opts.includeContent) {
       for (const line of spec.content.split("\n")) lines.push(`    ${line}`);
     } else {
-      lines.push(`    ${c(format, "dim", "(use --full to view; tasca spec content " + spec.id + " to export)")}`);
+      lines.push(`    ${c(format, "dim", "(use --full to view; feinai spec content " + spec.id + " to export)")}`);
     }
   }
   if (opts.plan) {
@@ -104,7 +104,7 @@ export function formatSpec(
     if (opts.includeContent) {
       for (const line of opts.plan.content.split("\n")) lines.push(`    ${line}`);
     } else {
-      lines.push(`    ${c(format, "dim", "(use --full to view; tasca plan show " + spec.id + " to export)")}`);
+      lines.push(`    ${c(format, "dim", "(use --full to view; feinai plan show " + spec.id + " to export)")}`);
     }
   }
   return lines.join("\n");
@@ -154,7 +154,7 @@ export function formatStatus(
   if (format === "json") return JSON.stringify(stats, null, 2);
   const serverLine = stats.serverRunning
     ? c(format, "green", `server:      running → http://127.0.0.1:${stats.serverPort}`)
-    : c(format, "dim",   `server:      stopped  (tasca server -d to start)`);
+    : c(format, "dim",   `server:      stopped  (feinai server -d to start)`);
   return [
     `${c(format, "yellow", `pending:     ${stats.pending}`)}`,
     `${c(format, "blue",   `in_progress: ${stats.in_progress}`)}`,

package/src/server.ts

@@ -250,7 +250,7 @@ function serverError(err: unknown): Response {
 
 /**
  * Determine actor for an inbound HTTP mutation. Priority:
- *   1. X-Tasca-Actor header (explicit)
+ *   1. X-Feinai-Actor header (explicit)
  *   2. derived from request: "dashboard:<host>" or "api:<user-agent>"
  */
 function actorFromRequest(req: Request): string {
@@ -258,7 +258,7 @@ function actorFromRequest(req: Request): string {
   // iterate manually to be safe.
   let explicit: string | undefined;
   for (const [k, v] of req.headers.entries()) {
-    if (k.toLowerCase() === "x-tasca-actor") {
+    if (k.toLowerCase() === "x-feinai-actor") {
       explicit = v;
       break;
     }
@@ -294,9 +294,9 @@ async function resolveDashboardVersion(): Promise<string> {
   const root = findRepoRoot();
   if (!root) return "";
   try {
-    const countResult = await Bun.$`git log --oneline -- tools/tasca/src/dashboard.html | wc -l`.cwd(root).text();
+    const countResult = await Bun.$`git log --oneline -- src/dashboard.html | wc -l`.cwd(root).text();
     const count = parseInt(countResult.trim(), 10);
-    const hashResult = await Bun.$`git log -1 --format=%h -- tools/tasca/src/dashboard.html`.cwd(root).text();
+    const hashResult = await Bun.$`git log -1 --format=%h -- src/dashboard.html`.cwd(root).text();
     const hash = hashResult.trim();
     cachedDashboardVersion = `dashboard-v${count} (${hash})`;
   } catch {
@@ -325,7 +325,7 @@ export function startServer(opts: ServerOptions): { url: string; stop: () => voi
           headers: {
             "Access-Control-Allow-Origin": "*",
             "Access-Control-Allow-Methods": "GET, POST, DELETE, PATCH, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type, X-Tasca-Actor",
+            "Access-Control-Allow-Headers": "Content-Type, X-Feinai-Actor",
           },
         });
       }
@@ -441,18 +441,18 @@ export function startServer(opts: ServerOptions): { url: string; stop: () => voi
           return json(agents);
         }
 
-        // GET /api/context — repo and tasca DB context info for dashboard
+        // GET /api/context — repo and feinai DB context info for dashboard
         if (path === "/api/context" && method === "GET") {
           const repoRoot = findRepoRoot();
           const dbPath = findDbPath();
           const home = homedir();
-          const tascaPath = dbPath?.startsWith(home)
+          const feinaiPath = dbPath?.startsWith(home)
             ? `~${dbPath.slice(home.length)}`
             : (dbPath ?? null);
           return json({
             repoRoot: repoRoot ?? null,
             repoName: repoRoot ? basename(repoRoot) : null,
-            tascaPath,
+            feinaiPath,
           });
         }
 

package/src/sqlite-adapter.ts

@@ -114,7 +114,7 @@ export function getSqliteConstructor(): DbConstructor {
 
   if (!_constructor) {
     console.error(`
-Error: No SQLite backend found. tasca requires one of:
+Error: No SQLite backend found. feinai requires one of:
   • Bun 1.0+       (current runtime)
   • Node.js 22.5+  (built-in node:sqlite)
   • better-sqlite3 (npm install -g better-sqlite3)