v0.7.0 Independent plugin for Claude Code
GitHub Español
Claude Code, but with a team
PLUGIN FOR CLAUDE CODE

A WORK SYSTEM FOR CLAUDE CODE

10 agents, 18 /alfred-dev:* commands, 11 flat skills, SQLite memory, and evidence-backed gates. Aligned with the Claude Code SDK.

10 agents 18 commands SQLite + MCP
Installers by platform Each button opens a popup with the command ready to copy.

CHANGELOG

Latest release v0.7.0
2026-08-15
Added
  • Aligned with the Claude Code SDK: commands, flat skills, exec-form hooks, and official MCP (FastMCP) when the mcp package is installed.
  • Speak without slashes: SessionStart injects the protocol and prompt-route.py suggests fix, quick, or retomar when you write in plain language.
  • Living project docs: index, architecture, compliance, threat model, and ADRs in the user repo, synced by phase.
Changed
  • Public surface cut to 10 agents, 11 flat skills, 18 commands. Entry is /alfred-dev:alfred.
  • Public continuity: alfred, progress, and retomar. config becomes ajustes, verify becomes uat.
  • No Ralph stop-hook and no rewriting settings.json. Secret-guard covers Write, Edit, Bash, and MCP write tools.
A plugin for CLAUDE CODE for working with rigor
10 agents18 commandslocal memoryquality gates

that turn an isolated session into a governed process.

What Alfred actually does
01

Decides the next step

Reads the repo, the session, and the handoff to start with map-codebase, discuss, feature, or uat without assembling the flow by hand.

02

Exposes operational state

Kanban, blockers, handoff, UAT, and the next action stay visible with progress, retomar, and uat.

03

Ships with evidence

The flow forces technical design, TDD, security, QA, documentation, and release work before a phase can be closed.

Team 10 real agents

Eight core agents, Selina when there is a frontend, and Lucius on demand.
09 Core

Operational core

Orchestration, scope, architecture, implementation, security, QA, release, traceability, and design-system direction.

01 Optional

Only optional

The only optional agent is Lucius, a second opinion via Codex CLI.

Commands 18

The 18 public routes, grouped by entry, orientation, build, and operations.
03

Entry

Bootstrap and settings

Load Alfred, set autonomy/Lucius, and update the plugin.

05

Orientation

Context and continuity

Read the repo, pause, retomar, and see state without reopening all context.

06

Build

Delivery and audit

Open real delivery work: features, quick changes, fixes, exploration, ship, and audit.

04

Operations

UAT, memory, and second opinion

Close human acceptance, open Memory UI, mirror GitHub, and ask Lucius.

Skills and playbooks

11 flat skills
11 published skills Process, security, quality, and style

Eleven flat skills: ADRs, dependencies, living docs, memory, threat model, compliance, SBOM, SonarQube, incidents, PRs, and visual direction. There is no 60-skill nested catalog.

Featured examples

Write ADRThreat ModelStyle DirectionCompliance CheckMemory
Reusable, versioned procedures inside the plugin, not ad-hoc prompts.
Process 4 skills
Evaluate Dependency · Memory · Sync Project Docs · Write ADR
Security 3 skills
Compliance Check · Sbom Generate · Threat Model
Quality 3 skills
Incident Response · Pr Workflow · Sonarqube
Style 1 skill
Style Direction

Auxiliary layers

6 active

How to start 03 steps

Start in 3 steps

entry flow
01

Install Alfred Dev

The script needs Claude CLI and Python 3.10+. It installs with --scope user. Then /reload-plugins and /alfred-dev:alfred.

02

Configure stack and team

Run /alfred-dev:ajustes to set autonomy, Lucius, and memory.

03

Enter through the right command

New repo: /alfred-dev:alfred. Existing repo: /alfred-dev:map-codebase and /alfred-dev:discuss.

Brownfield first: /alfred-dev:map-codebase and /alfred-dev:discuss. Greenfield: /alfred-dev:alfred.

Install, update, and uninstall

CLI-FIRST
Install on macOS Copy
curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/install.sh | bash

It downloads the script from the main branch, registers 686f6c61/alfred-dev as a --scope user marketplace, and installs alfred-dev@alfred-dev. The 0.7.0 script does not overwrite ~/.claude/skills or create /alfred.

Update /alfred-dev:update Compares semver with GitHub Releases and, if you accept, reruns the main installer.

FAQ

How do I install it?

macOS and Linux:

curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/install.sh | bash

Windows:

irm https://raw.githubusercontent.com/686f6c61/alfred-dev/main/install.ps1 | iex

You need Claude CLI on PATH, Python 3.10+, and ~/.claude. The script installs alfred-dev@alfred-dev with --scope user. Then /reload-plugins and /alfred-dev:alfred.

Does that curl already install 0.7.0?

Not necessarily. The command reads the GitHub main branch, not this landing.

When this page was built, main published unknown (unknown commands). This page describes 0.7.0.

If they differ, the one-liner installs whatever is on main. 0.6.1 creates the /alfred alias. 0.7.0 does not, and it does not overwrite ~/.claude/skills.

What does it need?

A recent Claude Code with plugins, skills, hooks, and MCP. Python 3.10 or newer. The installer looks for python3.13 … python3.10 if python3 is old.

The Python mcp package enables FastMCP; without it, the memory server still has a fallback. On Windows: PowerShell 5.1+ or bash on WSL.

Does it work on Windows?

Yes. Use install.ps1, or install.sh inside WSL.

Then /reload-plugins and /alfred-dev:alfred. If the inventory does not load, restart Claude Code.

How do I update or uninstall?

Update: /alfred-dev:update compares semver with GitHub Releases and, if you accept, reruns the main installer with --scope user. 0.7.0 does not recreate /alfred.

Uninstall:

curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/uninstall.sh | bash
irm https://raw.githubusercontent.com/686f6c61/alfred-dev/main/uninstall.ps1 | iex

That removes the plugin, marketplace, cache, and a leftover 0.6.1 /alfred alias. It does not delete the project .claude/.

Is there a /alfred alias?

Not in 0.7.0. The entry is /alfred-dev:alfred. The 0.7.0 installer does not write into ~/.claude/skills.

If you come from 0.6.1, the uninstaller deletes that alias only when the file is marked «Alfred Dev global alias».

Do I need to learn all 18 commands?

No. Write in plain language. prompt-route suggests the route (fix, quick, retomar, ship…).

SessionStart injects the briefing. If you want a slash, start with /alfred-dev:alfred.

When quick and when feature?

quick is a bounded change: two phases, tests and security, less ceremony.

feature if it crosses product, architecture, or several phases (up to 7, with Selina only when there is a frontend).

How do I pick up a session?

/alfred-dev:retomar or “pick up where we left off”. It reads .claude/alfred-handoff.json.

Before you stop: /alfred-dev:pause. Board state is in /alfred-dev:progress.

What are progress and uat?

progress summarizes kanban, blockers, UAT, and traceability. It replaced standup, blocked, in-progress, and validate as public slashes.

uat records human acceptance: pending, approved, or rejected. Automated tests do not close UAT.

Where is memory stored?

In .claude/alfred-memory.db inside the project (SQLite, WAL, FTS5, 0600). There are 15 MCP tools.

/alfred-dev:memory-ui opens a localhost GET viewer. It does not import git log. /alfred-dev:memory-ui stop or SessionEnd close it. Empty memory stays empty.

How many agents and skills are there?

10 agents: 8 core, Selina when there is a frontend, and Lucius on demand (/alfred-dev:ajustes).

11 flat skills. Side-effect ones (SonarQube, style, incident, PR) need an explicit invocation. 18 published /alfred-dev:* commands.

Is it aligned with the Anthropic SDK?

Yes. plugin.json lists the 18 commands, skills are auto-discovered, hooks use command + args, and MCP is official.

There is no global /alfred alias, no Ralph-style Stop hook, and no settings.json rewrite to install.

What does it cost, and what language does it use?

The plugin is MIT. You pay for your Claude Code session.

It answers in Spanish from Spain by default. Change that in /alfred-dev:ajustes.

What if a gate fails?

The flow stops and explains why.

Autopilot only auto-approves configured user gates. It does not skip tests, security, evidence, or the human deploy confirmation.

Can I contribute?

Yes. MIT. Issues and PRs at github.com/686f6c61/alfred-dev.

If you already use Claude Code, install Alfred Dev and enter the flow with context, memory, and a full team.

Independent plugin for teams that want to move from isolated prompts to an operational flow with state, traceability, and gates.

Installation 
 
The command is copied automatically when the browser allows it. Otherwise use the Copy button.
 
   
 
 Uninstall Alfred Dev  
 
 
 
Two clear paths
 
If you only want to remove Alfred Dev from Claude Code, use the script for your system. If the installation was left half-done or you want to review every trace, use the manual path.
 
 
 
 
 
macOS / Linux
  
 
curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/uninstall.sh | bash
 
If claude is available, it runs uninstall and marketplace remove with --scope user. Then it deletes cache/alfred-dev and marketplaces/alfred-dev, removes the 0.6.1 /alfred alias if present, and cleans the plugin entries in known_marketplaces.json, installed_plugins.json, and settings.json. It does not delete those JSON files.
 
 
 
 
Windows
  
 
irm https://raw.githubusercontent.com/686f6c61/alfred-dev/main/uninstall.ps1 | iex
 
Same sequence in PowerShell: native CLI if present, then cache, marketplace, leftover /alfred alias, and residual JSON entries. It does not touch the project .claude/.
 
 
 
 
 
Manual
 
 
 
 1. Try Claude Code native removal first 
 claude plugin uninstall alfred-dev@alfred-dev --scope user  
 claude plugin marketplace remove alfred-dev --scope user  
 
 
 2. If anything remains, review these paths 
     
  • ~/.claude/plugins/cache/alfred-dev/
  • ~/.claude/plugins/marketplaces/alfred-dev/
  • ~/.claude/skills/alfred/SKILL.md  (solo si es el alias de Alfred Dev)
  • ~/.claude/commands/alfred.md  (solo si es el shim de Alfred Dev)
    •  
 
 
 3. The script does not touch the project 
     
  • .claude/alfred-dev.local.md
  • .claude/alfred-dev-state.json
  • .claude/alfred-memory.db
  • .claude/alfred-handoff.json
  • .claude/alfred-uat.json
  • .claude/alfred-last-cierre.md
  • docs/project/ y docs/adr/
    •  
 
If you want to delete memory or docs for a specific repo, do it by hand inside that project. The uninstaller only cleans ~/.claude/.
 
 
 
 
The scripts end by asking you to restart Claude Code. /reload-plugins may be enough; if Alfred stays in the inventory, restart.
 
 
   
 
 Full changelog  
 
 
Each historical block describes that version. The current surface is 10 agents, 11 skills, and 18 commands.
 
 
 
v0.7.0
 2026-08-15 
 
 Added 
     
  • Aligned with the Claude Code SDK: commands, flat skills, exec-form hooks, and official MCP (FastMCP) when the mcp package is installed.
  • Speak without slashes: SessionStart injects the protocol and prompt-route.py suggests fix, quick, or retomar when you write in plain language.
  • Living project docs: index, architecture, compliance, threat model, and ADRs in the user repo, synced by phase.
  • Session close: SessionEnd writes .claude/alfred-last-cierre.md and stops Memory UI.
    •  
 
 
 Changed 
     
  • Public surface cut to 10 agents, 11 flat skills, 18 commands. Entry is /alfred-dev:alfred.
  • Public continuity: alfred, progress, and retomar. config becomes ajustes, verify becomes uat.
  • No Ralph stop-hook and no rewriting settings.json. Secret-guard covers Write, Edit, Bash, and MCP write tools.
  • Agent Teams only if the user already enabled it. Memory UI does not import Git history.
    •  
 
  
 
 
v0.6.1
 2026-06-22 
  
 Changed 
     
  • More resilient installers: Bash and PowerShell clear stale local Claude Code marketplace checkouts before reinstalling.
  • Normalized global updates: the flow re-registers the GitHub source, refreshes the alfred-dev marketplace, and keeps the plugin installed at user scope.
    •  
 
 
 Fixed 
     
  • Fixes the case where Claude Code reported Successfully installed plugin: alfred-dev@alfred-dev while the installed cache still resolved to an older version such as 0.5.2.
  • The /alfred alias is materialized again from the correct plugin root after updating from old versions or inherited local caches.
    •  
 
 
 
 
v0.6.0
 2026-06-19 
  
 Changed 
     
  • Agents loaded from the root: the 9 optional agents move into agents/ so Claude Code can discover all 19 plugin agents.
  • MCP compatible with the current CLI: alfred-memory is declared in .mcp.json with a portable launcher that uses CLAUDE_PLUGIN_ROOT when installed and cwd during local development.
  • Updated terminology: commands, agents, and operational docs replace obsolete Task references with Agent.
  • Human UI name: plugin.json and marketplace.json declare displayName: "Alfred Dev" so Claude Code shows Alfred Dev (alfred-dev) without changing the technical namespace.
  • 0.6.0 stabilization release: plugin.json is the canonical version source and the marketplace does not duplicate version.
  • The memory MCP server speaks modern JSONL stdio and still reads legacy Content-Length framing.
    •  
 
 
 Fixed 
     
  • Claude Code can now show the 19 agents in the plugin inventory.
  • Claude Code counts alfred-memory in the plugin inventory again.
  • claude mcp get plugin:alfred-dev:alfred-memory now connects to the real server.
    •  
 
 
 
 
v0.5.2
 2026-04-11 
 
 Added 
     
  • Full skills catalog published: plugin.json stops enumerating a partial sample and now exposes all 15 domains under skills/.
  • Stricter public surface contracts: the suite now validates the published catalog, canonical frontmatter, manual-only skills, and the absence of collisions with commands.
  • Selina gets a real guided flow: base system first, then typography and palette, and only then three comparable final proposals inside that family.
    •  
 
 
 Changed 
     
  • Heavier skills or those with clear side effects remain published, but are forced to manual activation with disable-model-invocation: true.
  • Help and public docs now group commands by actual value: core, advanced operations, and views/aliases.
  • Selina’s final proposals now respect the selected visual system instead of recolouring the same generic layout shell.
  • The landing no longer frames the catalog as an internal/partial sample and now reflects the 62 published skills in the release.
  • Version alignment to 0.5.2 across plugin, marketplace, installers, packages, docs, changelog, and landing.
    •  
 
 
 Fixed 
     
  • style-direction now declares canonical frontmatter instead of relying on implicit inference.
  • The public skill surface no longer depends on partial lists that drift from the real repository.
  • Selina’s visual companion still records the user choice when the local WebSocket handshake fails and the HTTP fallback has to take over.
    •  
 
 
 
 
v0.5.1
 2026-04-10 
 
 Added 
     
  • Canonical Selina catalog with 10 base design systems: core/selina_style_catalog.py gathers the free/contextual mode plus nine trend-led families so the visual phase starts from an explicit vocabulary.
  • Visual demo gallery: core/selina_style_demo.py and visual/scripts/write-style-demo-gallery.py generate a browsable catalog before the three final proposals are locked.
  • Palettes and type pairings per family: each design system declares colour modes, typography pairings and links to references or Google Fonts.
    •  
 
 
 Changed 
     
  • Selina is no longer framed as “three isolated styles”: it now works from 10 base design systems and narrows them down to three comparable proposals based on the PRD, audience, and stack.
  • Version aligned to 0.5.1 across plugin, marketplace, installers, packages, Memory MCP, session report, README, changelog, docs and landing.
  • The landing explains more faithfully how Selina enters the flow and what it really means to close a design system before touching frontend code.
    •  
 
 
 Fixed 
     
  • Update surface without drift: internal fallback points that still returned an older release now reflect the current version.
  • Release tests are less brittle: the suite no longer depends on thin Astro wrappers or hardcoded version paths when the manifest is the real source of truth.
    •  
 
 
 
 
v0.5.0
 2026-03-31 
 
 Added 
     
  • Lucius — The Technical Director: new optional agent that acts as an external technical second opinion. It invokes codex exec with an explicit read-only sandbox, uses the configured Codex CLI model and returns diagnosis + prescription per item.
  • /alfred-dev:lucius command: entry point for the audit. It accepts an optional target directory and scope (all, security, tests, architecture, performance).
  • Structured report per item: Lucius returns diagnosis + prescription + effort (S/M/L) + suggested implementer (Alfred or Codex) in four sections: Critical, Relevant, Opportunities and What's working well.
  • Prerequisite preflight: checks that codex is on the PATH and authenticated. If something is missing, it stops with clear install instructions.
  • Hard gate with no modifications: Lucius compares Git status before and after running Codex CLI in --sandbox read-only; if it detects differences, it reports them instead of hiding the problem.
  • Selina — The Stylist: new core agent (10th) that occupies phase 1b of the feature workflow and presents three style directions before component design starts.
  • Local visual server: zero-dependency HTTP + WebSocket server in visual/scripts/server.cjs with hot reload, per-project sessions and graceful shutdown.
  • Visual style skill: skills/estilo/style-direction/SKILL.md guides Selina to start the server, propose options, capture the selection and generate docs/style-direction.md.
  • Conditional visual_style phase: the orchestrator only enables it when config_loader.has_frontend(stack) detects a public UI.
  • _advance_skipping_phases helper: extracted orchestrator function that skips phases whose condition is not met and reduces cognitive complexity.
    •  
 
 
 Changed 
     
  • 19 agents total: the plugin moves from 18 to 19 agents (10 core + 9 optional) with Lucius included.
  • 26 commands: /alfred-dev:lucius joins the manifest and the public surface of the plugin.
  • Version aligned to 0.5.0 across plugin, marketplace, installers, packages, README, changelog, docs and landing.
  • Landing updated: Lucius card appears before Selina with a “New” badge, optional-agent use cases and counters updated to 19 agents and 26 commands.
    •  
 
 
 Fixed 
     
  • Native module imports in server.cjs: mandatory node: prefix (node:http, node:crypto, node:fs, node:path).
  • Number.parseInt instead of parseInt in server.cjs (SonarQube linting rule).
  • Reduced cognitive complexity of handleRequest: the /files/* block was extracted into serveStaticFile().
  • catch block without unused variable: catch (e) becomes catch {} in serveStaticFile.
  • Cognitive complexity in config_loader.py: _count_source_files and suggest_optional_agents were simplified by extracting reusable helpers.
  • SonarQube skill registered in plugin.json: the file existed but was missing from the plugin manifest.
  • Docker execution in subagents: scoped Bash(docker ...) entries let security-officer run the SonarQube workflow after /audit confirms Docker is operational or the user authorizes preparing it.
    •  
 
 
 
 
v0.4.7
 2026-03-31 
  
 Changed 
     
  • Hook JSON generation moves from bash heredoc interpolation to direct stdin emission via json.dumps, eliminating the entire error class.
  • Version aligned to 0.4.7 across plugin, marketplace, installers, packages, structured metadata, README, changelog, docs and landing.
    •  
 
 
 Fixed 
     
  • SessionStart hook fixed: the session context JSON output no longer truncates when content exceeds kernel ARG_MAX or contains special characters.
    •  
 
 
 
 
v0.4.6
 2026-03-23 
 
 Added 
     
  • New local Memory UI: /alfred-dev:memory-ui opens overview, timeline, decisions, commits, search and health directly on top of the project SQLite.
  • Memory UI now starts with useful data: map-codebase, discuss and quick seed progress, traceability, kanban and lightweight iterations naturally.
  • The UI imports recent Git commits when memory still has no linked commits and explains empty states better in temporary or non-repo workspaces.
  • Expanded E2E coverage for Memory UI, helper-first seeding and local server rendering.
    •  
 
 
 Changed 
     
  • Alfred now exposes 25 visible commands and adds memory-ui as a first-class public surface in the website, README, help and session-start.
  • This release removes internal planning docs from the published repo and aligns homepage, metadata and operational docs for 0.4.6.
    •  
 
  
 
 
v0.4.5
 2026-03-22 
 
 Added 
     
  • New PM layer for SonIA: /alfred-dev:standup, /alfred-dev:blocked, /alfred-dev:in-progress, /alfred-dev:validate and /alfred-dev:search.
  • SonIA Sync for GitHub through /alfred-dev:sync-github, while keeping docs/project and SQLite as the source of truth.
  • Expanded E2E coverage for PM helpers, board parsing and issue synchronization.
    •  
 
 
 Changed 
     
  • Alfred now exposes 24 commands and 13 visible hooks: continuity, operational PM, persistent memory and multi-agent workflows in one interface.
  • The website, README and docs now reflect SonIA as a CLI operational layer and the new GitHub collaboration surface.
    •  
 
  
 
 
v0.4.4
 2026-03-22 
 
 Added 
     
  • Operational continuity layer: new commands /alfred-dev:map-codebase, /alfred-dev:next, /alfred-dev:pause, /alfred-dev:resume, /alfred-dev:verify and /alfred-dev:progress.
  • New /alfred-dev:discuss command to refine ideas before building, with discovery.md and current.md artifacts.
  • New /alfred-dev:quick 2-phase workflow for small changes with tests and security review.
  • Shared memory configuration parser and new coverage for event FTS, purge + health, Git import with "|" and sync beyond 1000 decisions.
    •  
 
 
 Changed 
     
  • /alfred becomes a contextual router: it decides whether continuity, brownfield mapping, refinement or a multi-agent workflow should happen next.
  • SessionStart bootstraps local configuration and recommends the next step from the very first session.
  • The website now reflects the current model: 6 execution workflows, 18 commands and a visible operational layer.
  • Persistent memory stops producing false negatives: content-bearing events are searchable, purge cleans FTS, retention_days is read from project config and size_bytes includes WAL.
    •  
 
  
 
 
v0.4.2
 2026-03-14 
 
 Added 
     
  • Go test support in evidence guard: go test output is correctly detected as success.
  • Partial session reports: the stop-hook generates a report when a session is interrupted, not only when completed.
  • Autopilot mode and iterations in reports: reports show whether the session was autopilot and how many retries each phase had.
  • Evidence verification in markdown: explicit instruction to read alfred-evidence.json before advancing automatic gates.
  • Iterative loop documented in feature, fix and ship commands (max 5 retries per phase).
    •  
 
 
 Changed 
     
  • Stop-hook refactored into testable functions: should_block, build_block_message, handle_session_report.
  • Block message adapted for autopilot: does not ask for user confirmation but instructs to investigate the error.
  • Dynamic version in reports: template reads version from plugin.json.
  • Evidence cleanup between sessions to avoid cross-contamination.
    •  
 
 
 Fixed 
     
  • False positive in evidence guard: the failure detection pattern matched "0 failures" as a failure. Fixed to exclude zero.
  • Architecture gate mistyped: the architecture phase had gate "user" instead of "user+security", making security validation inoperative.
  • Divergent patterns: quality-gate.py had its own patterns that diverged from evidence_guard_lib.py. Unified to use a single source of truth.
  • Inconsistent autopilot key: commands looked for "mode: autopilot" but code wrote "autopilot: true". Fixed.
    •  
 
 
 
 
v0.4.1
 2026-03-13 
 
 Added 
     
  • Automatic initial setup: when using Alfred for the first time in a project, it asks whether you want interactive or autopilot mode. No manual steps required.
    •  
 
  
 Fixed 
     
  • Autopilot mode disconnected from actual flow: autopilot detection was not reaching the composition. Fixed so user gates are auto-approved when mode is autopilot.
    •  
 
 
 
 
v0.4.0
 2026-03-13 
 
 Added 
     
  • Evidence verification (evidence guard): hook that records each test execution as verifiable evidence. When an agent claims tests pass, the system checks they were actually run.
  • Session report on close: automatic summary in docs/alfred-reports/ with phases, test evidence, team and artifacts.
  • Iterative loop within phases: agents iterate up to 5 times within a phase until the gate is passed, enabling natural TDD cycles.
  • Autopilot mode: full execution without human interruption. User gates are auto-approved; automatic and security gates are evaluated normally.
    •  
 
 
 Changed 
     
  • 17 agent personalities rewritten with Alfred Pennyworth tone: impeccable service, subtle irony, technical precision.
  • Orchestrator extended with iterative loop functions (should_retry_phase, reset_phase_iterations) and autopilot (is_autopilot_gate_passable, run_flow_autopilot).
  • Stop-hook automatically generates session report when closing a completed session.
    •  
 
  
 
 
v0.3.9
 2026-03-13 
 
 Added 
     
  • Optional i18n-specialist agent for multilingual projects: automatic detection of i18n signals (i18n/, locales/, translations/ directories), integration in development and quality phases.
  • Automatic i18n detection in suggest_optional_agents(): analyzes i18n directories and configuration files in the project.
    •  
 
 
 Changed 
     
  • Optional agent selection redesigned: 2 multiSelect questions grouped by theme (technical + content/UX) instead of a long list, compatible with AskUserQuestion 4-option limit.
  • Product Owner reformulated: product phase questions are asked one at a time (one per turn) instead of in bulk, following the progressive refinement pattern from superpowers:brainstorming.
  • 8 optional agents (previously 7): added i18n-specialist to catalog, config, orchestrator, documentation, and tests.
    •  
 
  
 
 
v0.3.8
 2026-03-13 
 
 Added 
     
  • SQLite to native memory sync layer: decisions, iterations, and commits stored in alfred-memory.db are automatically projected as .md files in ~/.claude/projects//memory/ using native Claude Code format.
  • Hybrid synchronization: full regeneration on session start + incremental updates after each SQLite write.
  • Safe MEMORY.md management with delimited markers that preserve user manual content.
  • Automatic memory directory creation when Alfred loads for the first time.
  • New E2E testing skill (calidad/e2e-testing) for setting up Playwright or Cypress.
    •  
 
 
 Changed 
     
  • 60 skills reviewed and improved: enriched descriptions for better triggering, "What NOT to do" section in 51 skills, persistent memory integration in 10 skills, detect_stack reference in 9 skills.
  • 3 standalone protocols (incident-response, dependency-strategy, release-planning) reorganized into their logical categories (calidad/, seguridad/, devops/).
  • Overlaps between skills explicitly documented. Normative versions (GDPR, NIS2, CRA, OWASP, WCAG) added.
    •  
 
  
 
 
v0.3.7
 2026-03-12 
 
 Added 
     
  • SonIA -- Project Manager -- new transversal core agent. Decomposes the PRD into tasks, manages a kanban board in docs/project/kanban/ with 4 MD files (backlog, in-progress, done, blocked), maintains the traceability matrix (criterion -- task -- test -- doc) and generates progress reports per phase.
  • The Interpreter -- i18n Specialist -- new optional agent for internationalisation. i18n key audit, hardcoded string detection, per-locale format validation, skeleton generation for new languages. HARD-GATE: key completeness (N in base = N in all languages).
  • QA Engineer expanded -- new integration and E2E testing section with strategies for Playwright/Cypress, decision table for test types (unit, integration, E2E, regression) and selection criteria.
    •  
 
 
 Changed 
     
  • The Scribe (formerly The Translator) -- tech-writer rewritten as a core agent with dual activation: phase 3b (inline code documentation: headers, docstrings, context comments) and phase 5 (project documentation: API, architecture with Mermaid diagrams, guides, changelogs). Strict style guide: Castilian Spanish without Latinisms, anglicisms allowed, no emojis.
  • HARD-GATEs on 5 optional agents -- data-engineer (migration integrity), ux-reviewer (WCAG 2.1 level A), performance-engineer (performance thresholds), seo-specialist (minimum indexing requirements), github-manager (destructive operations require confirmation).
  • Team expanded to 17 agents -- 9 core (previously 8) + 8 optional (previously 7). All counts updated across web, README and manifest.
  • Agent colours unified -- QA Engineer from red to amber (conflict with security-officer), performance-engineer and copywriter aligned between frontmatter and agent body.
  • Persistent memory improved -- SQLite module optimisations, more efficient queries and better database management between sessions.
  • Capture hooks unified -- memory-capture.py and commit-capture.py merged into activity-capture.py, a single hook with internal dispatch by event type. From 11 to 10 hooks.
  • All agents reviewed -- frontmatter inconsistencies fixed, descriptions aligned with actual capabilities, personalities refined and integration chains updated.
    •  
 
  
 
 
v0.3.6
 2026-03-10 
   
 Fixed 
     
  • Core agents registered -- the core agents were missing from the plugin manifest, so Claude Code could not load their system prompts. All 15 agents (8 core + 7 optional) are now registered and operational.
  • Librarian MCP tools -- the librarian agent referenced 5 MCP tools with incorrect names. Fixed to match the real server tool names.
  • Empty dashboard on first session -- the data pipeline failed in cascade: config without memory, commits without iteration and empty queries. Fixed with auto-config creation, automatic iteration and global fallback.
  • Port conflict -- if another project was using the dashboard ports, it now detects the conflict and finds alternatives automatically.
    •  
 
 
 
 
v0.3.5
 2026-03-10 
  
 Changed 
     
  • SonarQube moved to security-officer -- the SonarQube analysis is now run by the security-officer instead of the qa-engineer during /alfred-dev:audit. When Docker is operational or authorized, it runs the scanner and integrates findings into its security report.
  • Imperative instructions -- the subagent receives explicit, sequential steps (read the skill, execute all 7 steps, integrate results) instead of a textual reference that could be ignored.
    •  
 
  
 
 
v0.3.4
 2026-03-03 
   
 Fixed 
     
  • Command nomenclature -- all web commands updated from /alfred X to /alfred-dev:X to reflect the actual Claude Code convention.
  • Stats corrected -- skills from 56 to 59, commands from 10 to 11, hooks from 7 to 11. Aligned with actual implementation.
  • Command /alfred-dev:gui visible -- added to the public commands table in both languages.
  • SonarQube integrated in audit -- the security-officer runs the SonarQube skill after the audit preflight confirms Docker is operational or the user authorizes preparing it.
  • Dashboard port file -- session-start.sh creates .claude/alfred-gui-port and verifies real server connection instead of relying on kill -0.
  • Optional agent colours -- the 5 agents without colour in their frontmatter now have assigned colours for the dashboard.
    •  
 
 
 
 
v0.3.3
 2026-02-24 
   
 Fixed 
     
  • SQLite initialization at startup -- the memory database is automatically created on each session if it does not exist. Removes the circular dependency that prevented the GUI server from starting on the first session.
  • GUI server always operational -- the dashboard starts from minute 1. The WebSocket is immediately available for the client.
  • Agents served via WebSocket -- the 15-agent catalogue is sent from the server in the init message, removing the hardcoded list from the dashboard.
  • Hooks resilient to updates -- test -f guards on all hooks for graceful degradation when the plugin directory has changed.
    •  
 
 
 
 
v0.3.2
 2026-02-23 
 
 Added 
     
  • Dynamic team composition -- 4-layer system (heuristic, reasoning, presentation, execution) that suggests optional agents based on the task description. The selection is ephemeral and does not modify persistent configuration.
  • run_flow() function -- entry point for flows with ephemeral session team. Validates structure, injects team and records error diagnostics.
  • TASK_KEYWORDS table -- map of 8 optional agents with contextual keywords and base weights for dynamic composition.
    •  
 
 
 Changed 
     
  • _KNOWN_OPTIONAL_AGENTS derived from TASK_KEYWORDS (single source of truth). 6 command skills updated. 326 tests.
    •  
 
 
 Fixed 
     
  • Whole-word matching -- match_task_keywords() uses word boundaries instead of substrings, eliminating false positives for short keywords.
  • Validation feedback -- the reason for team rejection is recorded in the session for downstream diagnostics.
  • Truncation warning -- task descriptions longer than 10,000 characters emit a warning instead of being silently truncated.
    •  
 
 
 
 
v0.3.1
 2026-02-23 
 
 Added 
     
  • Mobile support -- hamburger menu with sliding sidebar for narrow screens.
  • HTTP security headers -- X-Content-Type-Options, Cache-Control and Content-Security-Policy.
  • Dynamic injection -- version and WebSocket port injected from the server, no hardcoded values.
  • Pinned SVG icon -- replaced [*] with pin icon in timeline and decisions.
  • SEO audit -- canonical, og:image, FAQPage schema, hreflang, image dimensions (CLS).
    •  
 
  
 Fixed 
     
  • Robust WebSocket frame reading -- rewritten with readexactly() to eliminate disconnections from TCP fragmentation.
  • Cross-thread SQLite connection -- added check_same_thread=False to avoid errors in Python 3.12+.
  • get_full_state() consistency -- all queries use the same polling connection.
  • Pinned items polling -- pinned elements now propagate in real time.
  • Timestamp format -- automatic detection of epoch (s/ms) and ISO strings without timezone.
  • GUI action type validation -- explicit casts to prevent type injection.
  • WebSocket handshake buffer -- expanded to 8192 bytes.
  • WebSocket writer cleanup -- explicit socket close on server stop.
    •  
 
 
 
 
v0.3.0
 2026-02-22 
 
 Added 
     
  • Dashboard GUI (Alpha Phase) -- real-time web dashboard with 7 views: status, timeline, decisions, agents, memory, commits and pinned items. Launched with /alfred-dev:gui.
  • Monolithic Python server -- HTTP + manual WebSocket RFC 6455 + SQLite watcher. No external dependencies.
  • Bidirectional WebSocket protocol -- init, update, action and action_ack messages. Reconnection with exponential backoff.
  • Pinning system -- pinned items survive context compaction.
  • New SQLite tables -- gui_actions and pinned_items. Automatic migration to schema v3.
  • Automatic startup -- GUI server starts with each session and stops on close.
  • Fail-open principle: if the GUI fails, Alfred works the same. 297 tests.
    •  
 
 
 Changed 
     
  • README and documentation expanded with dashboard screenshots and WebSocket protocol guide.
    •  
 
  
 
 
v0.2.3
 2026-02-21 
 
 Added 
     
  • Persistent memory v2 -- schema migration, tags, status and relationships between decisions.
  • 5 new MCP tools -- total 15: update, link, health, export, import.
  • Search filters -- since, until, tags, status parameters.
  • Export/Import -- decisions to Markdown (ADR), import from Git and ADRs.
  • activity-capture.py hook -- unified capture hook (workflow events + commits).
  • memory-compact.py hook -- protects decisions during compaction.
  • Context injection by active iteration. ~268 tests.
    •  
 
 
 Changed 
     
  • The Librarian expanded: decision lifecycle, integrity, export/import.
    •  
 
  
 
 
v0.2.2
 2026-02-21 
 
 Added 
     
  • dangerous-command-guard.py hook -- blocks rm -rf /, force push, DROP DATABASE, fork bombs and more.
  • sensitive-read-guard.py hook -- warning when reading private keys, .env, credentials.
  • 4 new MCP tools -- total 10: stats, iterations, abandon.
  • 3 new skills -- incident-response, release-planning, dependency-strategy.
  • /alfred-dev:feature allows selecting start phase.
  • Version consistency test. 219 total tests.
    •  
 
  
 Fixed 
     
  • quality-gate.py -- position anchor for runners, re.IGNORECASE on failures.
  • MCP responses with isError: true for errors.
  • 8 technical debt issues: logging, encapsulation, recovery.
    •  
 
 
 
 
v0.2.1
 2026-02-21 
   
 Fixed 
     
  • Windows cache path -- install.ps1 and uninstall.ps1 aligned with Claude Code convention.
  • activity-capture.py -- diagnostics in silent except blocks.
  • session-start.sh -- specific catches instead of generic Exception.
    •  
 
 
 
 
v0.2.0
 2026-02-20 
 
 Added 
     
  • Persistent memory -- local SQLite per project with decisions, commits, iterations and events.
  • MCP server -- 6 stdio tools: search, record, query.
  • The Librarian -- optional agent for historical queries.
  • activity-capture.py hook -- automatic workflow event capture.
  • FTS5 search, secret sanitisation, 0600 permissions.
  • 114 tests (58 new for memory).
    •  
 
   
 
 
v0.1.5
 2026-02-20 
   
 Fixed 
     
  • Secret-guard fail-closed -- blocks when it cannot determine the target path.
  • Idempotent installer in clean environment (mkdir -p).
  • More reliable version detection in /alfred-dev:update.
    •  
 
 
 
 
v0.1.4
 2026-02-19 
 
 Added 
     
  • 6 optional agents -- data-engineer, ux-reviewer, performance, github, seo, copywriter.
  • 27 new skills across 6 domains. Total: 56 skills in 13 domains.
  • Windows support -- native install.ps1 and uninstall.ps1.
  • spelling-guard.py hook -- missing accents in Spanish.
  • Quality gates expanded: 8 to 18.
    •  
 
   
 
 
v0.1.2
 2026-02-18 
  
 Changed 
     
  • New personality -- friendly colleague with humour, all 8 agents with their own voice.
  • Full spelling correction across 68 files (RAE).
    •  
 
 
 Fixed 
     
  • Correct command prefix, robust update, explicit registration of all 10 commands.
    •  
 
 
 
 
v0.1.1
 2026-02-18 
   
 Fixed 
     
  • session-start.sh -- syntax error preventing context injection.
  • secret-guard.sh -- fail-closed policy restored.
  • stop-hook.py -- type validation for corrupt state.
    •  
 
 
 
 
v0.1.0
 2026-02-18 
 
 Added 
     
  • First public release.
  • 8 specialised agents, 5 workflows, 29 skills, 5 hooks.
  • Quality gates, GDPR/NIS2/CRA compliance, stack detection.
    •  
 
   
 
 
   
 
 
 Alfred Dev Origin 
  
 
  
 
 
What we wanted to build
 
We did not want another pretty prompt or a collection of characters performing theatre. We wanted a system that genuinely helps a developer: something that organizes work, detects what matters, keeps continuity between sessions, and pushes toward serious execution.
 
 
Why it is called Alfred
 
The name comes from Alfred Pennyworth, Batman’s figure who was always where he was needed. He was not the visible protagonist, but he was the one sustaining the operation with judgment, calm, and reliability. Resolute, precise, elegant in execution, and capable of saying things with dry irony when needed without losing professionalism.
 
 
What we wanted to bring from that reference
 
What mattered was that difficult mix: an assistant with personality but no theatrics; with style but no frivolity; with judgment of its own but in service of the work. Alfred Dev tries to capture exactly that: help you make better decisions, anticipate problems, and keep the bar high without turning the tool into a show.
 
 
How that becomes a plugin
 
That is why Alfred orchestrates agents, memory, quality gates, traceability, and continuity instead of merely answering prompts. The product ambition is simple to explain and difficult to execute: as a developer, you should feel that you finally have a serious, reliable assistant with real craft.
 
 
 
 
   
 
 
 Plugin technical vision System map 
  
 
  
 
 
What this project is
 
It turns AI-assisted development into a process governed by sequential phases, specialized agents, and control points that cannot be skipped without evidence.
 
     
  • Works with 10 agents and tightly bounded responsibilities.
  • Automates six main workflows: feature, fix, spike, ship, audit, and quick.
  • Detects the repo stack and adapts artifacts. Lucius is the only optional agent.
    •  
 
 
Operational summary for reconstruction
 
The visible surface is 18 published commands and 10 agents, but the real system lives behind that: Python core, 10 hooks, SQLite memory, and an orchestrator that never delegates state.
 
     
  • Agents are discovered from agents/. plugin.json lists the 18 commands.
  • Lucius is the only optional agent. Selina enters when there is a frontend.
  • Quality gates are hard: evidence-guard and quality-gate stop progress if real proof is missing.
  • Each phase can retry up to 5 times before escalation to the user.
    •  
 
 
Technology stack
 
The project operates over separated but coordinated ecosystems: Python for orchestration and memory, Astro for public documentation, and native Node.js for Selina visual server.
 
     
  • The core uses Python 3.10+ for orchestrator, config_loader, memory, continuity, and hooks.
  • The public website lives in static Astro with TypeScript and sitemap.
  • Selina uses native Node.js modules: http, crypto, fs, and path, with no external dependencies.
  • Development relies on pytest for Python and astro check for the website.
    •  
 
 
Layered architecture
 
Commands, agents, core, hooks, MCP, and visual server are separated. Commands do not call agents directly: they activate the orchestrator, and Alfred decides what enters and in what order.
 
     
  • Visible commands -> orchestrator.py -> agents and phases.
  • Hooks intercept SessionStart, SessionEnd, UserPromptSubmit, PreToolUse, and PostToolUse.
  • memory_server exposes MCP tools to query memory from any agent.
  • Agents do not talk to each other; everything goes through Alfred and session state.
    •  
 
 
Persistence and database
 
Persistent memory lives in .claude/alfred-memory.db. It is designed to be local, portable, and safe, not dependent on remote services or additional infrastructure.
 
     
  • Local SQLite with WAL mode and FTS5 search.
  • Persistence of decisions, commits, iterations, and events.
  • 0600 permissions and sanitization with 13 regex patterns for secrets.
  • Automatic schema migration and configurable purge with retention_days.
    •  
 
 
Business logic and quality gates
 
The system solves a very concrete problem: stopping AI-driven development from skipping critical phases and closing work without enough security, QA, documentation, or evidence.
 
     
  • Without recorded evidence, a claim like “tests pass” does not count.
  • Security Officer appears transversally in architecture, quality, and delivery.
  • Selina visual phase activates only when the stack has frontend surface.
  • User gates and automatic gates stay separated; autopilot never skips security or evidence.
    •  
 
 
Runtime and auxiliary components
 
Beyond the core, the system adds operational pieces that make the flow usable day to day: continuity, inspectable memory, optional GitHub sync, and a visual server with timeout.
 
     
  • Continuity keeps progress, pause, retomar, and handoff without losing phase.
  • Memory UI opens timeline, decisions, commits, and health over local SQLite.
  • GitHub Sync mirrors local state to issues when shared tracking is useful.
  • Selina visual server uses a 30-minute timeout and checks the parent process every 60 seconds.
    •  
 
 
Boot and reconstruction
 
You do not need complex infrastructure to rebuild or boot it, but you do need to respect the rules that make the system reliable.
 
     
  • Claude Code, Python 3.10+, and Node.js must be available in the environment.
  • SQLite memory is created when memory is enabled in /alfred-dev:ajustes.
  • map-codebase, discuss, and quick generate useful context so memory does not start empty.
  • The most expensive mistake would be breaking agent isolation or allowing another layer to replace the orchestrator as the source of truth.
    •  
 
 
 
 
   
 
 
 /alfred-dev:command Operational 
  
 
  
 
 
Core agents involved
 
 
 
 
Optional agents that may join
 
 
 
 
Active layers
 
 
 
 
What it really does
 
     
     
     
     
           
     
     
     Agent Core 
      
     
      
     
     
    How it enters the flow
     
       
       
       
      What it does
       
         
         
         
        What it doesn't do
         
           
           
           
           
                       
           
           
           Auxiliary layer Runtime 
            
           
           
           
           
          What it adds