wizz-method 2.19.1 → 2.20.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "wizz-method",
-  "version": "2.19.1",
+  "version": "2.20.0",
   "description": "Wizz Method: método de agência orientado por IA em PT-BR",
   "keywords": [
     "agile",

package/src/bmm-skills/1-analysis/wizz-agent-analyst/customize.toml

@@ -39,7 +39,7 @@ activation_steps_append = []
 # (the Wizz block imports project-context.md there once per session). Add
 # `file:{project-root}/**/project-context.md` here only to load it on every activation.
 persistent_facts = [
-  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a different subject switches (definir <new>), a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. Ask only when the request fits two open features. Full rule: wizz module _shared/organizacao.md.",
+  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a new subject goes into the open sprint (the active feature), sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. A question or conversation records nothing. Full rule: wizz module _shared/organizacao.md.",
 ]
 
 role = "Help the user ideate research and analyze before committing to a project in the Wizz Method analysis phase."

package/src/bmm-skills/1-analysis/wizz-set-feature/SKILL.md

@@ -27,7 +27,7 @@ Invoke this skill only for the explicit cases in "When this skill runs" below.
 3. **The request itself.** When 1 and 2 are both empty and the request is named work (a feature, a batch, a screen, a page, a campaign, a bug with a scope: "vamos fazer o painel de assinaturas"). Derive the slug from the subject, 2 to 4 words, and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE dispatching; say so in **one line**. Do not ask. This step is mandatory for the router and the maestro, not a nice-to-have: skipping it is how a project spends its whole life with an empty `active_feature`.
 4. **Nothing.** Only for work that is not named (a question, a conversation, a one-line tweak with no artifact). Artifacts go to the roots and memory carries no feature tag.
 
-**Switch or keep.** With a feature active, a request about a different subject switches (`definir <new>`; the previous one stays open until closed) and a continuation keeps it. **Close** when the delivery closes (deploy or acceptance): `wizz-feature.js verificar` must pass, then `wizz-feature.js encerrar --cerebro [--proxima <slug>]` marks the spec `no-ar`, clears or switches `active_feature`, and writes the Cérebro (state + one Sessions line; without a vault it prints the instruction instead).
+**The open sprint rules.** The active feature is the open sprint: every request goes into it until it is closed, with no new folder. A new subject goes into it, sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask the owner once: add to this sprint or open another. `definir <other>` with a sprint open is refused unless `--novo` (the owner's choice). **Close** when the delivery closes (deploy or acceptance): `wizz-feature.js verificar` must pass, then `wizz-feature.js encerrar --cerebro [--proxima <slug>]` marks the spec `no-ar`, moves the sprint's folders (and the root `sprint-status.yaml`) to `_arquivo/<slug>/`, clears or switches `active_feature`, and writes the Cérebro (state + one Sessions line; without a vault it prints the instruction instead).
 
 **Optional branch.** `feature_branches: auto` in `_wizz/bmm/config.yaml` makes `definir` (and the SessionStart hook) propose `git switch -c feat/<slug>` when you are on a trunk branch of a git repo. The default is `off`, for whoever works directly on `main`.
 
@@ -36,7 +36,7 @@ Invoke this skill only for the explicit cases in "When this skill runs" below.
 | Command | What it does |
 |---|---|
 | `resolver` | Active feature and its source (branch, config, none). |
-| `definir <slug or name>` | Normalizes, writes `active_feature`, creates both subfolders, prints one line. |
+| `definir <slug or name> [--novo]` | Normalizes, writes `active_feature`, creates both subfolders, prints one line. With another sprint open it refuses unless `--novo` (owner's choice). |
 | `artefato <tipo>` | Creates `<tipo>-<slug>.md` (spec, plano, auditoria, story, review, roteiro) in the right folder with valid frontmatter. |
 | `decidir "<texto>"` | Appends `D-NN` with the date to the feature's spec and to its `decisoes:` frontmatter. |
 | `status <status>` | Sets the spec's status: `rascunho`, `aprovado`, `implementado` or `no-ar` (it writes; to only read, use `resolver` or `listar`). |

package/src/bmm-skills/2-plan-workflows/wizz-agent-pm/customize.toml

@@ -39,7 +39,7 @@ activation_steps_append = []
 # (the Wizz block imports project-context.md there once per session). Add
 # `file:{project-root}/**/project-context.md` here only to load it on every activation.
 persistent_facts = [
-  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a different subject switches (definir <new>), a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. Ask only when the request fits two open features. Full rule: wizz module _shared/organizacao.md.",
+  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a new subject goes into the open sprint (the active feature), sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. A question or conversation records nothing. Full rule: wizz module _shared/organizacao.md.",
 ]
 
 role = "Translate product vision into a validated PRD, epics, and stories that development can execute during the Wizz Method planning phase."

package/src/bmm-skills/2-plan-workflows/wizz-agent-ux-designer/customize.toml

@@ -39,7 +39,7 @@ activation_steps_append = []
 # (the Wizz block imports project-context.md there once per session). Add
 # `file:{project-root}/**/project-context.md` here only to load it on every activation.
 persistent_facts = [
-  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a different subject switches (definir <new>), a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. Ask only when the request fits two open features. Full rule: wizz module _shared/organizacao.md.",
+  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a new subject goes into the open sprint (the active feature), sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. A question or conversation records nothing. Full rule: wizz module _shared/organizacao.md.",
 ]
 
 role = "Turn user needs and the PRD into UX design specifications that inform architecture and implementation during the Wizz Method planning phase."

package/src/bmm-skills/3-solutioning/wizz-agent-architect/customize.toml

@@ -39,7 +39,7 @@ activation_steps_append = []
 # (the Wizz block imports project-context.md there once per session). Add
 # `file:{project-root}/**/project-context.md` here only to load it on every activation.
 persistent_facts = [
-  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a different subject switches (definir <new>), a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. Ask only when the request fits two open features. Full rule: wizz module _shared/organizacao.md.",
+  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a new subject goes into the open sprint (the active feature), sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. A question or conversation records nothing. Full rule: wizz module _shared/organizacao.md.",
 ]
 
 role = "Convert the PRD and UX into technical architecture decisions that keep implementation on track during the Wizz Method solutioning phase."

package/src/bmm-skills/4-implementation/wizz-agent-dev/customize.toml

@@ -39,7 +39,7 @@ activation_steps_append = []
 # (the Wizz block imports project-context.md there once per session). Add
 # `file:{project-root}/**/project-context.md` here only to load it on every activation.
 persistent_facts = [
-  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a different subject switches (definir <new>), a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. Ask only when the request fits two open features. Full rule: wizz module _shared/organizacao.md.",
+  "FEATURE: the hooks already inject the active feature ('FEATURE ATIVA: <slug>' or 'Feature: <slug>') or 'nenhuma ativa'. Named work with no active feature: derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE writing anything, announcing it in ONE line (never ask for the slug); a new subject goes into the open sprint (the active feature), sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it; a brief's `feature:` field wins. Create artifacts with `wizz-feature.js artefato <tipo>` so they land as <tipo>-<slug>.md in {planning_artifacts}/{active_feature}/ or {implementation_artifacts}/{active_feature}/ with valid frontmatter; project-wide artifacts (architecture, context) stay at the root. Owner decisions go in with `wizz-feature.js decidir`. Memory saved in this session carries the same slug as its theme. A question or conversation records nothing. Full rule: wizz module _shared/organizacao.md.",
   "When implementing against a library or framework, consult Context7 for current docs, APIs, and version-specific syntax before relying on training data or web search: call resolve-library-id with the library name, then query-docs with the returned /org/project id and a specific question. If Context7 is unavailable, tell the user once that they can enable it with `npx ctx7 setup`, then fall back to web research.",
 ]
 

package/src/core-skills/_shared/handoff-protocol.md

@@ -12,7 +12,8 @@ and pass along only the skill's entrypoint and the references actually needed
 - area skill: canonical name of the persona to invoke via `Skill` (e.g. `wizz-growth`). Not a `subagent_type`: to isolate the task, pick an available native executor (`wizz-exec-*`) and instruct it to load that skill before working. The absence of an executor doesn't block invoking the skill in the current session.
 - feature: the active feature slug, resolved BEFORE the handoff (in a Wizz
   project: `node _wizz/hooks/wizz-feature.js resolver`; named work with no
-  feature gets one with `definir <slug from the request>`, without asking).
+  feature gets one with `definir <slug from the request>`, without asking;
+  with a feature active, it is the open sprint and new work goes into it).
   `feature: nenhuma` is valid only for work that is not named (a question, a
   conversation). Receiver rule: a brief WITHOUT this field is resolved by the
   receiver itself with the same steps before it writes anything; it never

package/src/modules/wizz/_shared/organizacao.md

@@ -7,27 +7,34 @@ Every step below is a **command**, not a memory exercise. The commands live in t
 - `F` = `node _wizz/hooks/wizz-feature.js`
 - `A` = `node _wizz/hooks/wizz-arrumar.js`
 
-`F` subcommands: `resolver` (active feature and its source), `definir <slug>`, `artefato <tipo>`, `decidir "<texto>"`, `status <status>` (sets the spec status), `verificar`, `encerrar`, `listar` (features with a folder and each spec's status). `resolver` and `listar` only read. The `wizz-set-feature` skill is just the manual override over `F definir` (rename, switch or clear on the owner's explicit request); nobody invokes it for the normal flow.
+`F` subcommands: `resolver` (active feature and its source), `definir <slug> [--novo]`, `artefato <tipo>`, `decidir "<texto>"`, `status <status>` (sets the spec status), `verificar`, `encerrar` (closes and archives the sprint), `listar` (open sprints, plus a count of the archived ones). `resolver` and `listar` only read. The `wizz-set-feature` skill is just the manual override over `F definir` (rename, switch or clear on the owner's explicit request); nobody invokes it for the normal flow.
 
-## 1. Feature before dispatch
+## 1. The open sprint rules
 
-The SessionStart and UserPromptSubmit hooks already tell you the state (`FEATURE ATIVA: <slug>`, `Feature: <slug>` or `nenhuma ativa`). Before you dispatch anything or write any artifact:
+**The active feature is the open sprint.** One sprint is open at a time, and every piece of work goes into it until it is closed. A new subject does **not** create a new feature or a new folder on its own: dozens of half-used folders is how the Lucrare ended up with 13 features (owner's decision, 2026-10-15).
 
-1. **Named work and no active feature** (a feature, a batch, a screen, a page, a campaign, a bug with a scope) → derive the slug from the **subject** of the request, 2 to 4 words in kebab-case, never from the verb ("vamos fazer o painel de assinaturas" → painel-assinaturas). Run `F definir <slug>` and tell the owner in **one line**. Never ask for a slug that comes out of the request.
-2. **Active feature, same subject or continuation** ("agora ajusta o filtro do painel") → keep it. Write nothing.
-3. **Active feature, different subject** → `F definir <new-slug>`. The previous one stays open until it is closed; say the switch in the same single line.
-4. **Not named work** (a question, conversation, a trivial one-line tweak that produces no artifact) → do nothing.
-5. **Real ambiguity** (the request fits two open features, see `F listar`) → the only case where you ask, once, offering the open features as options.
-6. **Feature branch** (`feat/<slug>`) → the branch already is the feature; when the config disagrees, `F definir <branch-slug>`.
+The SessionStart and UserPromptSubmit hooks already tell you the state (`FEATURE ATIVA: <slug>`, `Sprint aberto: <slug>` or `nenhuma ativa`). Before you dispatch anything or write any artifact:
+
+1. **Work and no open sprint** (a feature, a batch, a screen, a page, a campaign, a bug with a scope) → derive the slug from the **subject** of the request, 2 to 4 words in kebab-case, never from the verb ("vamos fazer o painel de assinaturas" → painel-assinaturas). Run `F definir <slug>` and tell the owner in **one line**. Never ask for a slug that comes out of the request.
+2. **Open sprint, same subject or continuation** ("agora ajusta o filtro do painel") → keep it. Write nothing.
+3. **Open sprint, new subject that fits its goal** (same product, same objective) → it goes into the open sprint, sized by the work. No `definir`, no new folder, one line to the owner:
+   - **small** (a colour, a text, one adjustment, no planning) → just do it; no story;
+   - **medium** (several steps, needs testing and review) → a story in the open sprint;
+   - **large** (a new objective inside the same product) → an epic with its stories.
+4. **Open sprint, new subject that clearly does not fit** (a separate objective, another product) → the only case where you ask, **once**: "add to `<slug>` or open a new sprint?". Only after the owner chooses a new one: `F definir <new-slug> --novo`. Without `--novo`, `definir` refuses while a sprint is open.
+5. **Not work** (a question, conversation, a trivial one-line tweak that produces no artifact) → do nothing.
+6. **Feature branch** (`feat/<slug>`) → the branch already is the sprint; when the config disagrees, `F definir <branch-slug> --novo`.
 7. **`feature_branches: auto`** in the config and you are on a trunk branch → propose `git switch -c feat/<slug>` in one line. With `off` (the default, for whoever works on `main`) say nothing about branches.
 
+**Closing archives.** `F encerrar` moves the sprint's two folders to `_arquivo/<slug>/` inside each artifact folder, together with the root `{implementation_artifacts}/sprint-status.yaml`, so the next sprint starts clean. `F listar` shows the open sprints and one line with the number of archived ones. The archive is history, not trash: when a request needs a past decision, spec or retro ("how did we solve the Meta sync?"), search `_arquivo/` of both artifact folders (and the Cérebro, which points to it) before saying it does not exist.
+
 **Handoff:** every brief carries `feature: <slug>` (or `feature: nenhuma` for work that is not named). A receiver without that field resolves it itself with the steps above before writing anything; it never writes an artifact without a resolved feature.
 
 ## 2. Artifacts in the right place
 
 - Create planning and implementation artifacts with `F artefato <tipo>` (`spec`, `plano`, `auditoria`, `story`, `review`, `roteiro`). It writes `<tipo>-<slug>.md` under `{planning_artifacts}/{feature}/` or `{implementation_artifacts}/{feature}/` (the `roteiro` goes to `{project_knowledge}/`), with the frontmatter already valid: `feature`, `status` (`rascunho|aprovado|implementado|no-ar`), `atualizado_em` (`YYYY-MM-DD`), `decisoes` (`[D-..]`).
 - Project-wide artifacts (architecture, project context) stay at the root of the artifact folders.
-- The `wizz-artifact-guard.js` hook warns after a Write that lands outside the active feature's folder or without a feature, and after a Write or Edit that leaves the frontmatter broken. **Fix it at once** (move the file, run `F definir`, fix the frontmatter); never leave the warning for later.
+- The `wizz-artifact-guard.js` hook warns after a Write that lands outside the active feature's folder or without a feature, and after a Write or Edit that leaves the frontmatter broken. **Fix it at once** (move the file into the open sprint's folder, fix the frontmatter; run `F definir` only when no sprint is open); never leave the warning for later.
 
 ## 3. Project root organized from the start
 

package/src/modules/wizz/agents/wizz-maestro/SKILL.md

@@ -69,7 +69,7 @@ If the user already stated the intent, **classify and dispatch directly** (see R
 
 ## Feature and organization (before routing, every time)
 
-Before you route, dispatch or write anything, resolve the feature with the steps in [organizacao.md](../../_shared/organizacao.md) section 1: named work with no active feature → `node _wizz/hooks/wizz-feature.js definir <slug from the request>` and **one line** to the owner (never ask for the slug); a different subject switches (`definir <new>`), a continuation keeps it. With no `layout:` in the config, propose and record it (`node _wizz/hooks/wizz-arrumar.js layout`, then `layout --gravar`) in the same single line. Every brief you hand over carries `feature:`.
+Before you route, dispatch or write anything, resolve the feature with the steps in [organizacao.md](../../_shared/organizacao.md) section 1: named work with no active feature → `node _wizz/hooks/wizz-feature.js definir <slug from the request>` and **one line** to the owner (never ask for the slug); the active feature is the open sprint: a new subject goes into it, sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it. With no `layout:` in the config, propose and record it (`node _wizz/hooks/wizz-arrumar.js layout`, then `layout --gravar`) in the same single line. Every brief you hand over carries `feature:`.
 
 While the sequence runs you keep the **documentation duty** (section 4 of the same file) without being asked: scope approved → spec with acceptance criteria; each owner decision → `wizz-feature.js decidir`; implementation done → the spec's `## Implementação`; going live → roteiro with rollback in `{project_knowledge}/`. Closing a feature's delivery runs the checklist (`wizz-feature.js verificar`, section 5): **you do not close the sequence with a pending item.**
 
@@ -107,7 +107,7 @@ In short: **the menu chooses the agent, the registry chooses the skill(s) and th
 
 Inside the 1-area branch, three shortcuts **demote on their own**, before counting any factor: a **question with a single definable answer**, a **single delivery**, and the **diagnosis of one specific mechanism** all go to the area agent. "How do I improve / reduce X" is not that question — it has no single answer. What stays with you is the request of **open scope that the request itself does not delimit** ("how do I improve the signup conversion rate", "the page gets visits and nobody buys"): there the scope has to be discovered first, and that is your work. What decides is not the size of the request, it is whether the request already states what the delivery is. **Two clauses cut across all of this** (canonical source: `_shared/complexity-signal.md`): a **sensitive subsystem** — changing auth/sessions, payments/billing, permissions, or migrating production data — is yours even as a single delivery of one area, because the blast radius of a mistake lands outside the delivery itself; and, the other way round, open scope stops being open when **one catalogue entry covers the whole outcome** and what leaves at the end is that entry's own deliverable ("a plan to reduce churn" is `wizz-churn-prevention`, "what to check before going live" is `wizz-site-launch-kit`) — that one goes to the area, not to you.
 
-**Changing the product's code is `dev`, even when the subject is visual** — the delivery is a commit. Ask which artifact leaves at the end: a file in the repo → dev; a decision, a spec or a piece of art → the area that owns it. **Exception: new or rebuilt screens.** When the request asks to BUILD screens in code (a new app, page, dashboard or panel, or a whole screen rebuilt in the product), the visual decision has not been made yet, so `designer` comes first and the sequence is design → dev: the designer runs its research gate (`wizz-design-needs` → `wizz-ui-component-curator` / `wizz-premium-landing-ui-researcher`) before any screen is coded. A generic design skill from outside the registry (e.g. the frontend-design plugin) never stands in for that gate. A tweak to an existing screen (a price, a label, a spacing) stays dev, and redesigning a section with no build asked for (a hero, a card) stays designer.
+**Changing the product's code is `dev`, even when the subject is visual** — the delivery is a commit. Ask which artifact leaves at the end: a file in the repo → dev; a decision, a spec or a piece of art → the area that owns it. **Exception: new or rebuilt screens.** When the request asks to BUILD screens in code (a new app, page, dashboard or panel, or a whole screen rebuilt in the product), the visual decision has not been made yet, so `designer` comes first and the sequence is design → dev: the designer runs its research gate (`wizz-design-needs` → `wizz-ui-component-curator` / `wizz-premium-landing-ui-researcher`) before any screen is coded. A generic design skill from outside the registry (e.g. the frontend-design plugin) never stands in for that gate. A tweak to an existing screen (a price, a label, a spacing) stays dev, and so does building one component in code ("create a card component", a button, a modal): the delivery is a file in the repo. Redesigning a section with no build asked for ("redesign the hero") or choosing which component fits ("find a card that matches our style") stays designer.
 
 **What `rel` drags counts as an extra area when the related capability shapes the SAME deliverable.** Ask of each edge: would the thing being handed over be incomplete without this? A sales page without the offer and the conversion structure is half a page (same artifact → escalates); a text post does not become a video job because of a `before: [get-brolls]` edge (different artifact → does not). `pairs_with` alone never escalates.
 

package/src/modules/wizz/agents/wizz-maestro/customize.toml

@@ -23,7 +23,7 @@ include = [
 
 persistent_facts = [
   "Chaining mode: AUTOMATIC. I announce the full sequence at the start and run the agents in order, without stopping between them. I only pause for a business decision that belongs to the user or an irreversible risk (deploy, delete, spending).",
-  "Organization duty (before dispatch, without being asked): named work with no active feature -> `node _wizz/hooks/wizz-feature.js definir <slug from the request>` and one line; different subject -> definir <new>; continuation -> keep. Every handoff carries `feature:`. Scope approved -> spec with acceptance criteria; owner decision -> `decidir`; implemented -> Implementação section; live -> roteiro + rollback; closing -> `verificar` must pass before `encerrar`. I never close a sequence with a pending item. Details in _shared/organizacao.md.",
+  "Organization duty (before dispatch, without being asked): named work with no active feature -> `node _wizz/hooks/wizz-feature.js definir <slug from the request>` and one line; new subject -> enters the open sprint while it fits (small tweak: just do it; multi-step: story; new objective: epic); does not fit -> ask once: add here or open another (`definir <new> --novo` only after the owner chooses); question or conversation -> nothing. Every handoff carries `feature:`. Scope approved -> spec with acceptance criteria; owner decision -> `decidir`; implemented -> Implementação section; live -> roteiro + rollback; closing -> `verificar` must pass before `encerrar`. I never close a sequence with a pending item. Details in _shared/organizacao.md.",
   "Planning gate: on an EXECUTION request where the 'needs planning' factor = YES and there's no matching PRD/story/brief, I ask once whether to create the artifact first (recommended) or skip it; once the gate is resolved, the chain proceeds automatically. Details in _shared/planning-gate.md.",
   "I speak easy {communication_language}, short sentences, no jargon. I summarize as if explaining to a client.",
   "Full details of the Wizz layer are in _shared/ (communication-rules.md, encerramento.md, token-economy.md, cerebro.md) at the root of the wizz module.",

package/src/skills-lib/_shared/complexity-signal.md

@@ -35,7 +35,7 @@ Written as bare labels, the 3 factors above were true of almost any request, and
 
 **And the counterpart has one exception: a single entry already delimits the scope.** If the whole outcome being asked for fits the `when:` of ONE catalogue entry, and what leaves at the end is that entry's own deliverable — a plan, a recommendation, an audit — then the scope is not open, the catalogue delimited it, and the request goes to that entry's area. "A plan to reduce churn" is `wizz-churn-prevention`; "I want ChatGPT and Perplexity to cite us" is `wizz-ai-seo`; "what to check before going live" is `wizz-site-launch-kit`. It stops being the exception the moment delivering the outcome means changing what other areas own: "improve the signup conversion rate" ends up in copy, UI and code, so it comes back to the maestro through the area clause. Ask which single entry would deliver it whole — if it takes two, the scope really is open. (Owner's decision, 2026-09-18.)
 
-**Changing the product's code is `dev`, even when the subject is visual.** "Adjust the secondary button's colour", "fix the mobile spacing": the delivery is a commit, so it is the dev area — `designer` decides what the look should be, it does not ship the change. Ask which artifact leaves at the end: a file in the repo → dev; a decision, a spec or a piece of art → the area that owns it. **Exception: new or rebuilt screens.** When the request asks to BUILD screens in code (a new app, page, dashboard or panel, or a whole screen rebuilt in the product), the visual decision has not been made yet, so `designer` comes first and the sequence is design → dev (2 areas → maestro): the designer runs its research gate before any screen is coded. A tweak to an existing screen (a price, a label, a spacing) stays dev, and redesigning a section with no build asked for (a hero, a card) stays designer.
+**Changing the product's code is `dev`, even when the subject is visual.** "Adjust the secondary button's colour", "fix the mobile spacing": the delivery is a commit, so it is the dev area — `designer` decides what the look should be, it does not ship the change. Ask which artifact leaves at the end: a file in the repo → dev; a decision, a spec or a piece of art → the area that owns it. **Exception: new or rebuilt screens.** When the request asks to BUILD screens in code (a new app, page, dashboard or panel, or a whole screen rebuilt in the product), the visual decision has not been made yet, so `designer` comes first and the sequence is design → dev (2 areas → maestro): the designer runs its research gate before any screen is coded. A tweak to an existing screen (a price, a label, a spacing) stays dev, and so does building one component in code ("create a card component", a button, a modal): the delivery is a file in the repo. Redesigning a section with no build asked for ("redesign the hero") or choosing which component fits ("find a card that matches our style") stays designer.
 
 **What `rel` drags counts as an extra area when the related capability shapes the SAME deliverable.** Writing the copy of a sales page without the offer and without the conversion structure delivers half a page: offer, copy and conversion are the same artifact, so that is 2 areas → maestro. What does NOT count is an adjacent capability that would produce a **different** artifact: a plain text post for LinkedIn does not need video capture just because the social content skill declares `before: [get-brolls]` — the b-roll would be another deliverable, not part of this one. `pairs_with` alone never escalates: it is neighbourhood, not dependency. The question to ask about each edge is "would the thing I am about to hand over be incomplete without this?", not "is this related?".
 

package/src/skills-lib/wizz-router/SKILL.md

@@ -12,7 +12,8 @@ Invoke this skill BEFORE acting on non-trivial requests (feature, bug, design, m
 
 **Single exception:** 1-line edits (typo, rename) and pure conversation. **Objective criterion (TRIVIALITY GATE):** a request touching ≤1 file, ~≤10 lines, no new behavior, a known type of change → execute directly, without triggering the router/maestro.
 
-**Outside Plan Mode:** list candidates via `AskUserQuestion` and wait for confirmation BEFORE firing. Never auto-fire outside Plan Mode.
+**Outside Plan Mode, outside a Wizz project (section B):** list candidates via `AskUserQuestion` and wait for confirmation BEFORE firing. Never auto-fire there.
+**Inside a Wizz project (section A):** do NOT ask to confirm the dispatch. Resolve the feature, then hand off at once; the only questions you may ask are the ambiguous-referent gate below and, with a sprint open, "add to this sprint or open another" when the new subject does not fit it.
 **Inside Plan Mode:** auto-fire every relevant one to enrich the plan.
 </EXTREMELY-IMPORTANT>
 
@@ -74,7 +75,7 @@ This gate does NOT fire for an open-scope request. "My site is bad, sort it out"
 
 **And the counterpart has one exception: a single entry already delimits the scope.** If the whole outcome being asked for fits the `when:` of ONE catalogue entry, and what leaves at the end is that entry's own deliverable — a plan, a recommendation, an audit — then the scope is not open, the catalogue delimited it, and the request goes to that entry's area. "A plan to reduce churn" is `wizz-churn-prevention`; "I want ChatGPT and Perplexity to cite us" is `wizz-ai-seo`; "what to check before going live" is `wizz-site-launch-kit`. It stops being the exception the moment delivering the outcome means changing what other areas own: "improve the signup conversion rate" ends up in copy, UI and code, so it comes back to the maestro through the area clause. Ask which single entry would deliver it whole — if it takes two, the scope really is open. (Owner's decision, 2026-09-18.)
 
-**Changing the product's code is `dev`, even when the subject is visual.** "Adjust the secondary button's colour", "fix the mobile spacing": the delivery is a commit, so it is the dev area — `designer` decides what the look should be, it does not ship the change. Ask which artifact leaves at the end: a file in the repo → dev; a decision, a spec or a piece of art → the area that owns it. **Exception: new or rebuilt screens.** When the request asks to BUILD screens in code (a new app, page, dashboard or panel, or a whole screen rebuilt in the product), the visual decision has not been made yet, so `designer` comes first and the sequence is design → dev (2 areas → maestro): the designer runs its research gate before any screen is coded. A tweak to an existing screen (a price, a label, a spacing) stays dev, and redesigning a section with no build asked for (a hero, a card) stays designer.
+**Changing the product's code is `dev`, even when the subject is visual.** "Adjust the secondary button's colour", "fix the mobile spacing": the delivery is a commit, so it is the dev area — `designer` decides what the look should be, it does not ship the change. Ask which artifact leaves at the end: a file in the repo → dev; a decision, a spec or a piece of art → the area that owns it. **Exception: new or rebuilt screens.** When the request asks to BUILD screens in code (a new app, page, dashboard or panel, or a whole screen rebuilt in the product), the visual decision has not been made yet, so `designer` comes first and the sequence is design → dev (2 areas → maestro): the designer runs its research gate before any screen is coded. A tweak to an existing screen (a price, a label, a spacing) stays dev, and so does building one component in code ("create a card component", a button, a modal): the delivery is a file in the repo. Redesigning a section with no build asked for ("redesign the hero") or choosing which component fits ("find a card that matches our style") stays designer.
 
 **The area count includes what `rel` drags, when the related capability shapes the SAME deliverable.** Before deciding "1 area", look at the `rel` of the entry that matched, and ask of each edge: **would the thing I am about to hand over be incomplete without this?** — not "is this related?". Writing the copy of a sales page without the offer and without the conversion structure delivers half a page: offer, copy and conversion are the same artifact, so that is 2 areas, hence maestro. What does NOT count is an adjacent capability that would produce a **different** artifact: a plain text post for LinkedIn does not need video capture just because `wizz-social-content` declares `before: [get-brolls]` — the b-roll would be another deliverable, not part of this one. `pairs_with` alone never escalates: it is neighbourhood, not dependency. Every edge is reciprocal by construction (the schema validator rejects one-way edges), so the relation shows up whichever side the user enters from. Resolve id → area via the `ids:` map in `{project-root}/_wizz/_config/registry/index.yaml`; outside a Wizz project, via `skills-registry.yaml` itself.
 
@@ -89,7 +90,7 @@ This gate does NOT fire for an open-scope request. "My site is bad, sort it out"
 - *1 area, but 2+ factors → maestro:* `m06` ("infra refactor: database, APIs, deploy, monitoring"): 1 area (dev), but multi-step + needs planning + high-risk architecture → `wizz-maestro` even without crossing areas.
 - *2+ areas, each part light → still maestro (clause 1):* e.g. "adjust the secondary button's color AND change one word in the CTA": each isolated change is trivial, but it crosses 2 areas (designer + copy) in the same request, so it falls under clause 1 and goes to the maestro even without heavy multi-step work. The current dataset has no equivalent case (`m01`-`m12` always combine 2+ areas with high complexity); it's the calibration gap flagged by finding M1.
 
-**Feature before delegating (mandatory, verifiable):** named work (a feature, a batch, a screen, a page, a campaign, a bug with a scope) with no active feature → derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE handing off, with one line to the owner and no question; a different subject from the active feature → `definir <new>`; a continuation keeps it; a question or conversation writes nothing. Full rule in the wizz module's `_shared/organizacao.md`, section 1.
+**Feature before delegating (mandatory, verifiable):** named work (a feature, a batch, a screen, a page, a campaign, a bug with a scope) with no active feature → derive the slug from the request's subject and run `node _wizz/hooks/wizz-feature.js definir <slug>` BEFORE handing off, with one line to the owner and no question; with a feature active, it is the open sprint and the work goes into it: a new subject goes into it, sized by the work (a small tweak is just done, no story; a multi-step change becomes a story; a new objective becomes an epic), while it fits the sprint's goal; only if it does not fit, ask ONCE: add to this sprint or open another (`definir <new> --novo` only after the owner chooses); a continuation keeps it; a question or conversation writes nothing. Full rule in the wizz module's `_shared/organizacao.md`, section 1.
 
 When delegating (to the maestro or to the area agent), state the brief in the format of the [shared handoff protocol](../../core-skills/_shared/handoff-protocol.md): `feature: <slug>` (or `feature: nenhuma`), `origem: wizz-router` (anti-loop — whoever receives it never sends the same request back to you), a cerebro summary if one has already been consulted, decisions already made, and the relevant section of the skill. Also include the **verdict on the 4 factors** — especially `precisa planejar: sim/não` — so the receiver can apply the Planning Gate (wizz module, `_shared/planning-gate.md`) without re-deriving it: with the planning factor set to YES and no corresponding PRD/story/brief, the receiver asks once whether to create the artifact before executing; once the gate is resolved, the chain proceeds automatically.
 

package/tools/hooks/session-rules.js

@@ -87,8 +87,8 @@ function wizzReminders(state) {
   const out = [];
   if (!state.slug) {
     out.push(
-      `NENHUMA FEATURE ATIVA: o primeiro pedido nomeado (feature, lote, tela, bug com escopo) define uma. ` +
-        `Antes de despachar, derive o slug do pedido e grave: ${HOOK_CMD} definir <slug>. Sem perguntar; uma linha de confirmação.`,
+      `NENHUMA FEATURE ATIVA (nenhum sprint aberto): o primeiro pedido de trabalho (feature, lote, tela, bug com escopo) abre um. ` +
+        `Antes de despachar, derive o slug do pedido e grave: ${HOOK_CMD} definir <slug>. Sem perguntar; uma linha de confirmação. Pergunta ou conversa não abre nada.`,
     );
   } else if (state.featureBranches === 'auto' && state.git.isRepo && state.onTrunk) {
     out.push(
@@ -120,7 +120,7 @@ function buildFeatureContext(cwd) {
 
   if (active) {
     parts.push(
-      `FEATURE ATIVA: ${active}` + (fromBranch ? ' (derivada do branch git).' : ' (do config).'),
+      `FEATURE ATIVA: ${active}` + (fromBranch ? ' (sprint aberto, derivado do branch git).' : ' (sprint aberto, do config).'),
       'Use como contexto sem perguntar nada:',
       state.isWizz
         ? `artefatos de planejamento e implementação vão para as subpastas ${active}/ com nome <tipo>-<slug>.md (${HOOK_CMD} artefato <tipo>);`
@@ -133,7 +133,7 @@ function buildFeatureContext(cwd) {
       );
     }
     parts.push(
-      'NÃO peça confirmação de feature. Pedido de OUTRO assunto troca a feature (definir <novo>); continuação mantém. Pergunte só se houver ambiguidade real entre duas features abertas.',
+      'NÃO peça confirmação de feature. O sprint aberto manda: todo trabalho entra nele até ser encerrado, sem pasta nova. Assunto novo que cabe no objetivo do sprint entra pelo tamanho: ajuste pequeno só faz (sem story), vários passos vira story, objetivo novo vira épico; avise em uma linha. Histórico de sprints fechados fica em _arquivo/ das pastas de artefato: procure lá quando precisar. Só se NÃO couber, pergunte UMA vez: adicionar neste sprint ou abrir outro (definir <novo> --novo, só com a escolha do dono). Pergunta ou conversa não grava nada.',
     );
   }
   if (state.isWizz) parts.push(...wizzReminders(state));

package/tools/hooks/wizz-artifact-guard.js

@@ -87,15 +87,16 @@ function artifactWarning(file, content, state, { frontmatterOnly = false } = {})
           `Grave a feature a partir do pedido (node ${HOOK_CMD}/wizz-feature.js definir <slug>) e mova o arquivo para a subpasta dela.`,
       );
     }
-  } else if (!frontmatterOnly && slug && parts[0] !== slug) {
+  } else if (!frontmatterOnly && slug && parts[0] !== slug && parts[0] !== lib.ARCHIVE_DIR) {
     msgs.push(
-      `ARTEFATO EM OUTRA FEATURE: ${relFile} está em "${parts[0]}", mas a ativa é "${slug}". ` +
-        `Se o trabalho é de "${slug}", mova; se o assunto mudou, troque a feature (wizz-feature.js definir ${parts[0]}).`,
+      `ARTEFATO EM OUTRO SPRINT: ${relFile} está em "${parts[0]}", mas o sprint aberto é "${slug}". ` +
+        `Trabalho novo entra no sprint aberto: mova para ${path.relative(state.root, path.join(base, slug, name))}. Abrir outro sprint só com a escolha do dono (wizz-feature.js definir <slug> --novo).`,
     );
   }
 
   if (type) {
-    const problems = lib.frontmatterProblems(content, parts.length > 1 ? parts[0] : slug);
+    const owner = parts[0] === lib.ARCHIVE_DIR ? parts[1] : parts[0];
+    const problems = lib.frontmatterProblems(content, parts.length > 1 ? owner : slug);
     if (problems.length > 0) msgs.push(`FRONTMATTER de ${relFile}: ${problems.join('; ')}.`);
   }
   return msgs.join(' ');

package/tools/hooks/wizz-cerebro-lib.js

@@ -213,7 +213,11 @@ function recordClose({ root, slug, status, projeto }) {
 
     const date = lib.today();
     const dirs = lib.artifactDirs(root);
-    const spec = path.join(dirs.planning, slug, `spec-${slug}.md`);
+    // O `encerrar` arquiva o sprint antes de chamar aqui: procura nas duas casas.
+    const spec =
+      [path.join(dirs.planning, lib.ARCHIVE_DIR, slug), path.join(dirs.planning, slug)]
+        .map((d) => path.join(d, `spec-${slug}.md`))
+        .find((f) => fs.existsSync(f)) || path.join(dirs.planning, slug, `spec-${slug}.md`);
     const specText = fs.existsSync(spec) ? fs.readFileSync(spec, 'utf8') : '';
     const specRel = path.relative(root, spec);
     const resumo = implementationSummary(specText);

package/tools/hooks/wizz-feature-lib.js

@@ -41,6 +41,9 @@ const PROJECT_WIDE = /^(architecture|arquitetura|project-context|contexto|sprint
 
 const CONFIG_REL = path.join('_wizz', 'bmm', 'config.yaml');
 
+// Arquivo morto dos sprints fechados, dentro de cada pasta de artefato.
+const ARCHIVE_DIR = '_arquivo';
+
 /**
  * Normaliza texto livre para slug kebab-case: o mesmo formato que a skill
  * `wizz-set-feature` grava, para branch e config nunca divergirem.
@@ -384,12 +387,48 @@ function sectionContent(text, title) {
     .trim();
 }
 
+// Link markdown relativo: `](alvo)` ou `](alvo#ancora)`, sem esquema nem âncora pura.
+const MD_LINK = /\]\((?!(?:[a-z][\w+.-]*:|#|\/))([^)\s#?]+)([^)\s]*)\)/gi;
+
+/**
+ * Reescreve os links markdown relativos de um arquivo que mudou de pasta.
+ * Cada alvo é resolvido a partir da pasta ANTIGA, passa por `mapAbs` (o alvo
+ * também pode ter sido movido) e volta relativo à pasta NOVA. Sem mudança
+ * devolve o mesmo texto; link quebrado (alvo inexistente) fica intocado.
+ * @param {string} text
+ * @param {string} oldDir - pasta antiga do arquivo (absoluta)
+ * @param {string} newDir - pasta nova do arquivo (absoluta)
+ * @param {(abs: string) => string} [mapAbs] - caminho atual de um alvo movido
+ * @returns {string}
+ */
+function rebaseMarkdownLinks(text, oldDir, newDir, mapAbs = (p) => p) {
+  return String(text).replaceAll(MD_LINK, (whole, target, rest) => {
+    let decoded;
+    try {
+      decoded = decodeURI(target);
+    } catch {
+      return whole;
+    }
+    const original = path.resolve(oldDir, decoded);
+    const abs = mapAbs(original);
+    // Link que já não apontava para nada fica como está: reescrever inventaria outro caminho.
+    if (!fs.existsSync(original) && !fs.existsSync(abs)) return whole;
+    const next = path.relative(newDir, abs).split(path.sep).join('/') || '.';
+    if (next === decoded) return whole;
+    // Mantém o estilo do link: cru fica cru; com acento cru, só o espaço é codificado.
+    let encoded = next;
+    if (target !== decoded) encoded = /[\u0080-\uFFFF]/.test(target) ? next.replaceAll(' ', '%20') : encodeURI(next);
+    return `](${encoded}${rest})`;
+  });
+}
+
 module.exports = {
   TRUNK,
   ARTIFACT_TYPES,
   STATUS,
   PROJECT_WIDE,
   CONFIG_REL,
+  ARCHIVE_DIR,
   toSlug,
   today,
   findUp,
@@ -411,4 +450,5 @@ module.exports = {
   frontmatterProblems,
   artifactTypeOf,
   sectionContent,
+  rebaseMarkdownLinks,
 };

package/tools/hooks/wizz-feature.js

@@ -7,16 +7,20 @@
 // Spider: a regra "derive do pedido" dependia de memória do agente).
 //
 //   resolver                 feature ativa e de onde veio (branch > config > nada)
-//   definir <slug|texto>     grava active_feature e cria as subpastas (sem perguntar)
+//   definir <slug|texto>     abre o sprint: grava active_feature e cria as subpastas
+//                            (sem perguntar). Com sprint aberto e outro slug, recusa:
+//                            o trabalho novo entra no sprint aberto; abrir outro só
+//                            com a escolha do dono (--novo)
 //   artefato <tipo>          cria <tipo>-<slug>.md com frontmatter no lugar certo
 //   decidir "<texto>"        registra D-NN na spec da feature, na hora da decisão
 //   status <status>          rascunho|aprovado|implementado|no-ar na spec
 //   verificar                checklist de fechamento (exit 1 se houver pendência)
-//   encerrar                 status final na spec, limpa/troca active_feature
+//   encerrar                 status final na spec, arquiva o sprint em _arquivo/
+//                            (com o sprint-status.yaml da raiz), limpa/troca active_feature
 //                            (recusa com pendência do checklist, salvo --forcar);
 //                            com --cerebro grava Estado + linha de Sessões no
 //                            projetos/<projeto>.md do Cérebro (--projeto <nome>)
-//   listar                   features com pasta e o status de cada spec
+//   listar                   sprints abertos e arquivados, com o status de cada spec
 //
 // Opções: --json (saída para máquina), --cwd <dir>, --feature <slug>.
 // Fail-open: fora de projeto Wizz, avisa e sai com 0 sem escrever nada.
@@ -143,6 +147,16 @@ function cmdDefinir(state, opts) {
   if (!slug) return { ok: false, code: 2, line: 'Uso: definir <slug ou nome da feature>. Nada foi gravado.' };
   const { root } = state;
   const previous = state.fromConfig;
+  // O sprint aberto manda: assunto novo entra nele. Abrir outro sprint com um
+  // aberto é escolha do dono, nunca do agente (pastas demais na Lucrare, 2026-10-15).
+  if (previous && previous !== slug && !opts.novo) {
+    return {
+      ok: false,
+      code: 1,
+      data: { feature: previous, recusado: slug },
+      line: `Sprint aberto: ${previous}. O pedido novo entra nele pelo tamanho (ajuste pequeno só faz; vários passos, story; objetivo novo, épico). Se não couber, pergunte ao dono uma vez: adicionar em ${previous} ou abrir sprint novo? Só com a escolha dele: definir ${slug} --novo. Nada foi gravado.`,
+    };
+  }
   lib.writeConfigValue(root, 'active_feature', slug);
   const dirs = lib.artifactDirs(root);
   for (const d of [dirs.planning, dirs.implementation]) fs.mkdirSync(path.join(d, slug), { recursive: true });
@@ -150,7 +164,8 @@ function cmdDefinir(state, opts) {
   const parts = [
     `Feature: ${slug}. Artefatos em ${rel(root, path.join(dirs.planning, slug))}/ e ${rel(root, path.join(dirs.implementation, slug))}/.`,
   ];
-  if (previous && previous !== slug) parts.push(`Troca: ${previous} → ${slug} (${previous} segue aberta até ser encerrada).`);
+  if (previous && previous !== slug)
+    parts.push(`Sprint novo a pedido do dono: ${previous} → ${slug} (${previous} segue aberto até ser encerrado).`);
   if (state.fromBranch && state.fromBranch !== slug)
     parts.push(
       `Atenção: o branch ${state.git.branch} aponta para ${state.fromBranch} e ganha do config. Troque de branch se ${slug} é outro trabalho.`,
@@ -246,6 +261,72 @@ function looseArtifacts(root, dirs) {
   return out;
 }
 
+/** Move `src` para `dest`, mesclando quando `dest` já existe (sprint reaberto e fechado de novo). */
+function moveInto(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.renameSync(src, dest);
+    return;
+  }
+  for (const name of fs.readdirSync(src)) moveInto(path.join(src, name), path.join(dest, name));
+  fs.rmdirSync(src);
+}
+
+function markdownFiles(dir) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.flatMap((e) => {
+    const abs = path.join(dir, e.name);
+    if (e.isDirectory()) return markdownFiles(abs);
+    return e.isFile() && e.name.endsWith('.md') ? [abs] : [];
+  });
+}
+
+/**
+ * Sprint fechado vai para o arquivo morto: as duas pastas da feature descem
+ * para `_arquivo/<slug>/`, e o `sprint-status.yaml` da raiz de implementação
+ * (o do sprint aberto) vai junto, para o próximo sprint começar limpo.
+ * @returns {{planning: string, implementation: string, sprintStatus: string}}
+ */
+function archiveSprint(root, slug) {
+  const dirs = lib.artifactDirs(root);
+  const out = {};
+  const moves = [dirs.planning, dirs.implementation].map((base) => ({
+    src: path.join(base, slug),
+    dest: path.join(base, lib.ARCHIVE_DIR, slug),
+  }));
+  const mapAbs = (abs) => {
+    const hit = moves.find((m) => abs === m.src || abs.startsWith(m.src + path.sep));
+    return hit ? hit.dest + abs.slice(hit.src.length) : abs;
+  };
+  // Links relativos (`../`) descem um nível junto com o arquivo: reescreve antes de mover.
+  for (const { src, dest } of moves) {
+    for (const file of markdownFiles(src)) {
+      const text = fs.readFileSync(file, 'utf8');
+      const next = lib.rebaseMarkdownLinks(text, path.dirname(file), path.dirname(mapAbs(file)), mapAbs);
+      if (next !== text) fs.writeFileSync(file, next);
+    }
+    if (fs.existsSync(src)) moveInto(src, dest);
+  }
+  out.planning = moves[0].dest;
+  out.implementation = moves[1].dest;
+  const status = path.join(dirs.implementation, 'sprint-status.yaml');
+  out.sprintStatus = '';
+  if (fs.existsSync(status)) {
+    const dest = path.join(out.implementation, 'sprint-status.yaml');
+    fs.mkdirSync(out.implementation, { recursive: true });
+    if (!fs.existsSync(dest)) {
+      fs.renameSync(status, dest);
+      out.sprintStatus = dest;
+    }
+  }
+  return out;
+}
+
 /**
  * Checklist de fechamento. Itens mecânicos são checados; os de julgamento
  * (Cérebro, memória) voltam como "confirmar" para o agente responder.
@@ -329,15 +410,18 @@ function cmdEncerrar(state, opts) {
       line: `Não encerrei ${slug}: ${pend.map((p) => p.item + (p.detalhe ? ` (${p.detalhe})` : '')).join('; ')}. Resolva e rode de novo (ou --forcar se o dono aceitar a pendência).`,
     };
   }
-  const file = setSpecStatus(state, slug, status);
+  setSpecStatus(state, slug, status);
+  const archived = archiveSprint(state.root, slug);
+  const file = path.join(archived.planning, `spec-${slug}.md`);
   const next = lib.toSlug(typeof opts.proxima === 'string' ? opts.proxima : '');
   if (state.fromConfig === slug || !state.fromConfig) lib.writeConfigValue(state.root, 'active_feature', next);
   if (next) {
     const dirs = lib.artifactDirs(state.root);
     for (const d of [dirs.planning, dirs.implementation]) fs.mkdirSync(path.join(d, next), { recursive: true });
   }
-  const parts = [`Feature ${slug} encerrada (${status}) em ${lib.today()}. Spec: ${rel(state.root, file)}.`];
-  parts.push(next ? `Feature ativa agora: ${next}.` : 'Nenhuma feature ativa agora.');
+  const parts = [`Sprint ${slug} encerrado (${status}) em ${lib.today()} e arquivado. Spec: ${rel(state.root, file)}.`];
+  if (archived.sprintStatus) parts.push(`sprint-status.yaml arquivado junto: o próximo sprint começa limpo.`);
+  parts.push(next ? `Sprint aberto agora: ${next}.` : 'Nenhum sprint aberto agora: o próximo pedido de trabalho abre um.');
   if (state.fromBranch === slug) parts.push(`O branch ${state.git.branch} ainda aponta para ${slug}: volte ao tronco ou troque de branch.`);
   const memo = opts.cerebro ? cerebroClose(state, slug, status, opts) : null;
   if (memo && memo.gravado) parts.push(`Cérebro atualizado: ${memo.arquivo} (Estado + linha em Sessões).`);
@@ -346,31 +430,49 @@ function cmdEncerrar(state, opts) {
     parts.push(`Registre no Cérebro: Estado do projeto + linha na tabela Sessões (${slug}: ${status} em ${lib.today()}).`);
   }
   if (pend.length > 0) parts.push(`Pendências: ${pend.map((p) => p.item).join('; ')}.`);
-  const data = { feature: slug, status, proxima: next, pendencias: pend.map((p) => p.item) };
+  const data = {
+    feature: slug,
+    status,
+    proxima: next,
+    pendencias: pend.map((p) => p.item),
+    arquivo: rel(state.root, archived.planning),
+  };
   if (memo) data.cerebro = memo;
   return { ok: true, data, line: parts.join(' ') };
 }
 
-function cmdListar(state) {
-  const dirs = lib.artifactDirs(state.root);
-  let names = [];
+function sprintDirs(base) {
   try {
-    names = fs
-      .readdirSync(dirs.planning, { withFileTypes: true })
-      .filter((e) => e.isDirectory())
+    return fs
+      .readdirSync(base, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && e.name !== lib.ARCHIVE_DIR)
       .map((e) => e.name);
   } catch {
-    // sem pasta de planejamento: nenhuma feature
+    return [];
   }
-  const features = names.map((slug) => {
-    const spec = artifactPath(state.root, 'spec', slug, dirs);
-    const status = fs.existsSync(spec) ? lib.parseFrontmatter(fs.readFileSync(spec, 'utf8')).data.status || '?' : 'sem spec';
-    return { feature: slug, status, ativa: slug === state.slug };
-  });
-  const line =
-    features.length === 0
-      ? 'Nenhuma feature com pasta ainda.'
-      : features.map((f) => `${f.ativa ? '*' : ' '} ${f.feature} (${f.status})`).join('\n');
+}
+
+function cmdListar(state) {
+  const dirs = lib.artifactDirs(state.root);
+  const statusOf = (folder, slug) => {
+    const spec = path.join(folder, slug, `spec-${slug}.md`);
+    return fs.existsSync(spec) ? lib.parseFrontmatter(fs.readFileSync(spec, 'utf8')).data.status || '?' : 'sem spec';
+  };
+  const archive = path.join(dirs.planning, lib.ARCHIVE_DIR);
+  const features = [
+    ...sprintDirs(dirs.planning).map((slug) => ({
+      feature: slug,
+      status: statusOf(dirs.planning, slug),
+      ativa: slug === state.slug,
+      arquivada: false,
+    })),
+    ...sprintDirs(archive).map((slug) => ({ feature: slug, status: statusOf(archive, slug), ativa: false, arquivada: true })),
+  ];
+  const abertas = features.filter((f) => !f.arquivada);
+  const arquivadas = features.length - abertas.length;
+  const lines = abertas.map((f) => `${f.ativa ? '*' : ' '} ${f.feature} (${f.status})`);
+  if (arquivadas > 0) lines.push(`  + ${arquivadas} sprint(s) fechado(s) em ${rel(state.root, archive)}/`);
+  const line = features.length === 0 ? 'Nenhum sprint com pasta ainda.' : lines.join('\n');
   return { ok: true, data: { features }, line };
 }
 

package/tools/hooks/wizz-router-enforce.js

@@ -161,9 +161,9 @@ function featureLine(wizzRoot) {
     const state = lib.resolveFeature(wizzRoot);
     const cmd = 'node _wizz/hooks/wizz-feature.js';
     if (!state.slug) {
-      return ` Feature: nenhuma ativa. Pedido nomeado → ANTES de despachar \`${cmd} definir <slug do pedido>\` (sem perguntar); handoff leva \`feature:\`.`;
+      return ` Feature: nenhuma ativa (nenhum sprint aberto). Pedido de trabalho → ANTES de despachar \`${cmd} definir <slug do pedido>\` (sem perguntar); pergunta/conversa não abre; handoff leva \`feature:\`.`;
     }
-    return ` Feature: ${state.slug}. Outro assunto → \`${cmd} definir <novo>\`; continuação mantém; entrega fechada → \`${cmd} encerrar\`. Handoff leva \`feature: ${state.slug}\`.`;
+    return ` Feature: ${state.slug} (sprint aberto). Todo trabalho entra nele (assunto novo que cabe: ajuste pequeno só faz, vários passos vira story, objetivo novo vira épico); não cabe → pergunte 1 vez: adicionar ou abrir outro (\`definir <novo> --novo\` só com o dono); entrega fechada → \`${cmd} encerrar\`. Handoff leva \`feature: ${state.slug}\`.`;
   } catch (error) {
     debug('router-enforce', 'featureLine', error);
     return '';