wizz-method 2.19.2 → 2.20.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "wizz-method",
-  "version": "2.19.2",
+  "version": "2.20.1",
   "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.**
 

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/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>
 
@@ -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 '';

package/tools/installer/core/installer.js

@@ -87,7 +87,10 @@ class Installer {
         await prompts.log.warn(`Warning: Could not check for legacy WIZZ entries: ${error.message}`);
       }
 
+      this._runtimeConfigValues = undefined;
       if (existingInstall.installed) {
+        // Antes de mexer em `_wizz/`: o sprint aberto e o layout que os hooks gravaram.
+        this._runtimeConfigValues = await moduleConfigWriter.captureRuntimeValues(realWizzDirCandidate);
         await this._removeDeselectedModules(existingInstall, config, paths, originalConfig._preserveModules || []);
         updateState = await this._prepareUpdateState(paths, config, existingInstall, officialModules);
         await this._removeDeselectedIdes(existingInstall, config, paths);
@@ -1412,7 +1415,10 @@ class Installer {
    * @param {Object} moduleConfigs - Collected configuration values
    */
   async generateModuleConfigs(wizzDir, moduleConfigs) {
-    return moduleConfigWriter.generateModuleConfigs(wizzDir, moduleConfigs, { trackFile: (p) => this.installedFiles.add(p) });
+    return moduleConfigWriter.generateModuleConfigs(wizzDir, moduleConfigs, {
+      trackFile: (p) => this.installedFiles.add(p),
+      runtimeValues: this._runtimeConfigValues,
+    });
   }
 
   /**

package/tools/installer/core/module-config-writer.js

@@ -10,14 +10,71 @@ const path = require('node:path');
 const fs = require('../fs-native');
 const { getProjectRoot } = require('../project-root');
 
+// Chaves que os hooks gravam no config.yaml em tempo de uso, não o installer:
+// `active_feature` (wizz-feature.js definir: o sprint aberto) e `layout`
+// (wizz-arrumar.js layout --gravar). O installer lê as respostas do
+// config.toml, onde elas não existem ou ficaram vazias, e regenerava o yaml do
+// zero: o update da 2.20.0 zerou o sprint aberto e o layout de todo projeto.
+const RUNTIME_KEYS = ['active_feature', 'layout'];
+
+const isEmpty = (value) => value === undefined || value === null || value === '';
+
+const NON_MODULE_DIRS = new Set(['_config', '_memory', 'memory', 'docs', 'scripts', 'custom', 'hooks']);
+
+/** Os valores de tempo de uso de um config.yaml (vazio se ausente ou ilegível). */
+async function readRuntimeValues(configPath, yaml) {
+  let previous;
+  try {
+    previous = yaml.parse(await fs.readFile(configPath, 'utf8'));
+  } catch {
+    return {};
+  }
+  if (!previous || typeof previous !== 'object' || Array.isArray(previous)) return {};
+  const kept = {};
+  for (const key of RUNTIME_KEYS) if (!isEmpty(previous[key])) kept[key] = previous[key];
+  return kept;
+}
+
+/**
+ * Lê os valores de tempo de uso de todo módulo instalado. O update chama ANTES
+ * de mexer em `_wizz/`: depois o yaml antigo já foi apagado junto com a pasta
+ * do módulo.
+ * @param {string} wizzDir
+ * @returns {Promise<Record<string, Record<string, unknown>>>} módulo → chave → valor
+ */
+async function captureRuntimeValues(wizzDir) {
+  const yaml = require('yaml');
+  const out = {};
+  let entries = [];
+  try {
+    entries = await fs.readdir(wizzDir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || NON_MODULE_DIRS.has(entry.name)) continue;
+    const values = await readRuntimeValues(path.join(wizzDir, entry.name, 'config.yaml'), yaml);
+    if (Object.keys(values).length > 0) out[entry.name] = values;
+  }
+  return out;
+}
+
+/** Resposta nova vence; o valor de tempo de uso só preenche o que ela deixaria vazio. */
+function withRuntimeValues(answered, previous = {}) {
+  const config = { ...answered };
+  for (const [key, value] of Object.entries(previous)) if (isEmpty(config[key])) config[key] = value;
+  return config;
+}
+
 /**
  * Generate clean config.yaml files for each installed module.
  * @param {string} wizzDir - WIZZ installation directory
  * @param {Object} moduleConfigs - Collected configuration values
  * @param {Object} deps - Injected dependencies
  * @param {(filePath: string) => void} deps.trackFile - Records a written file as installed
+ * @param {Record<string, Record<string, unknown>>} [deps.runtimeValues] - captureRuntimeValues() de antes do update
  */
-async function generateModuleConfigs(wizzDir, moduleConfigs, { trackFile }) {
+async function generateModuleConfigs(wizzDir, moduleConfigs, { trackFile, runtimeValues }) {
   const yaml = require('yaml');
 
   // Extract core config values to share with other modules
@@ -28,18 +85,18 @@ async function generateModuleConfigs(wizzDir, moduleConfigs, { trackFile }) {
   // 'hooks' (RT-C1, tools/hooks/* copied here by Installer#_installHooks) is
   // infra, not a module — without this exclusion this scanner treated it as
   // one and wrote a spurious _wizz/hooks/config.yaml.
-  const nonModuleDirs = new Set(['_config', '_memory', 'memory', 'docs', 'scripts', 'custom', 'hooks']);
-  const installedModules = entries.filter((entry) => entry.isDirectory() && !nonModuleDirs.has(entry.name)).map((entry) => entry.name);
+  const installedModules = entries.filter((entry) => entry.isDirectory() && !NON_MODULE_DIRS.has(entry.name)).map((entry) => entry.name);
 
   // Generate config.yaml for each installed module
   for (const moduleName of installedModules) {
     const modulePath = path.join(wizzDir, moduleName);
 
-    // Get module-specific config or use empty object if none
-    const config = moduleConfigs[moduleName] || {};
-
     if (await fs.pathExists(modulePath)) {
       const configPath = path.join(modulePath, 'config.yaml');
+      // Module-specific answers, plus what the hooks wrote since the last install
+      const answered = moduleConfigs[moduleName] || {};
+      const previous = runtimeValues?.[moduleName] ?? (await readRuntimeValues(configPath, yaml));
+      const config = withRuntimeValues(answered, previous);
 
       // Create header
       const packageJson = require(path.join(getProjectRoot(), 'package.json'));
@@ -110,4 +167,4 @@ async function generateModuleConfigs(wizzDir, moduleConfigs, { trackFile }) {
   }
 }
 
-module.exports = { generateModuleConfigs };
+module.exports = { generateModuleConfigs, captureRuntimeValues, RUNTIME_KEYS };