@jaimevalasek/aioson 1.28.0 → 1.29.1

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.29.1] - 2026-06-12
+
+### Docs
+- **Documented the v1.29.0 selective-context model in the project docs.** New "Carregamento seletivo de contexto" section in `memoria-e-contexto.md` (the two modes, activation fast paths, mid-flow activation guards, selector-routable rules/docs frontmatter, and `rules:lint`); `context:select` and `rules:lint` added to the CLI reference; per-agent notes for squad (investigation opt-out + create-phase genome pass), copywriter (INDEX-driven genome menu + binding operational sections), genome and the profiler pipeline (operational-method layer), and activation fast-path cross-links on briefing/sheldon.
+
+## [1.29.0] - 2026-06-11
+
+### Added
+- **Activation-only fast paths across the entry agents.** `@briefing`, `@product`, `@sheldon`, `@analyst`, and `@copywriter` join `@deyvin`: bare activation loads only foundation context (plus registry frontmatter / filename listings where the agent needs a menu), presents the starting options, and stops. Required inputs are now declared with the step that needs each item — never all upfront. `@product` was compressed to fit the fast path inside its 25KB kernel budget (24,999 bytes).
+- **Activation guards on the mid-flow agents.** `@architect`, `@ux-ui`, `@pm`, `@qa`, `@orchestrator`, `@scope-check`, and `@discovery-design-doc`: activation without a feature slug reads foundation context only, reports the current stage, asks which feature to work on, and stops. `@qa`'s legacy eager loading section (the "design governance" variant) is replaced by `context:select`-backed Context loading modes. `@validator` heading aligned (its strict sandbox semantics were already the tightest loader in the framework).
+- **The eager rules/docs loading section is retired framework-wide.** `@tester`, `@squad`, `@site-forge`, and `@discover` replace "Project rules, docs & design docs" with on-demand Context loading modes; gateways (CLAUDE.md/AGENTS.md) describe rule loading as on-demand; a contract test bans every variant of the eager section in every template agent.
+- **Selector-routable rules and docs.** All template rules carry routing frontmatter (`modes`, `task_types`, `triggers`, `paths`, `load_tier`) — description-only rules were selector-invisible (+20 < threshold 30). 41 template docs (squad, sheldon, dev, deyvin, pentester, tester, dossier, site-forge, governance) gain the same routing fields. `context:select` activation-only mode generalized to all workflow agents (per-agent foundation allowlist).
+- **`aioson rules:lint [--docs] [--strict] [--json]`** — flags selector-invisible rules (and docs with `--docs`), missing required fields, and suggests routing metadata. `--strict` exits 1 on warnings for CI. Template ships 67/67 selector-visible files, locked by test.
+- **Squad creation: investigation is opt-out and genomes enter the loop.** Tier-2 domains run `@orache` by default; tier-3 with no sourceDocs gets an announced Quick Scan. New `squad-create` Step 5.5 (genome pass): planned genomes are reused or generated via `@genome` and bound (manifest `genomes`+`genomeBindings`, executor `## Active genomes`, `squad.md`); pending bindings are queued with `status: pending` and surfaced — never silently empty.
+- **Operational-method layer in the persona pipeline.** Benchmarked against practitioner source prompts (Stefan Georgi / RMBC): `@profiler-enricher` Module 9 extracts the executable method (procedure, output structure, style metrics, prohibitions, delivery checklist) from evidence; `@profiler-forge` emits it as five required Genome 3.0 sections; `@genome` treats a missing `## Operating Procedure` on function/practitioner-persona genomes as a generation defect; genome-bindings propagate Prohibitions → executor Hard constraints, Delivery Checklist → squad checklists, Operating Procedure → Response pattern.
+- **`@copywriter` genome menu via `INDEX.md`.** New Step G2.4 discovers all installed genomes (masters, personas, domain, brand-voice) through `.aioson/genomes/INDEX.md` with its audience/output-type selection guides; the hardcoded master list becomes the index-absent fallback. The menu serves marketing pages, content, site copy, and system/UI microcopy. Operational sections of a selected genome are binding for the piece (procedure, prohibitions, style metrics, delivery checklist).
+
+### Changed
+- `@orache` squad rules load by frontmatter match instead of wholesale scan; `@squad` decision-gating and `@sheldon` mining restricted to selected context; `@sheldon` brain index loads after PRD selection instead of on activation.
+
+### Tests
+- Contract suites for every fast path/guard (tokens + section ordering), per-agent activation-only selection, rules/docs routing visibility (67/67), `rules:lint` behavior, squad investigation/genome-pass tokens, operational-method tokens across the pipeline, and copywriter INDEX discovery. Full suite green (3227 pass).
+
 ## [1.28.0] - 2026-06-11
 
 ### Added

package/docs/pt/4-agentes/briefing.md

@@ -70,6 +70,8 @@ Você > Todos.
 4. `.aioson/context/prd*.md` e `prds/*.md` — evita duplicar trabalho já comprometido.
 5. Web search quando há premissas que precisam de validação externa.
 
+> **Fast path de ativação (v1.29.0):** ativar `@briefing` "seco", sem nomear plano ou tarefa, carrega **só** o `project.context.md`, o frontmatter do registro e a *listagem de nomes* de `plans/` — apresenta o menu e para. O conteúdo dos planos e PRDs acima entra só no passo que os usa. Veja [Carregamento seletivo de contexto](../5-referencia/memoria-e-contexto.md#carregamento-seletivo-de-contexto-v1290).
+
 ## Handoff típico
 
 - **Vem de:** você, com anotações em `plans/` ou uma ideia conversacional.

package/docs/pt/4-agentes/copywriter.md

@@ -53,6 +53,8 @@ A grande diferença em relação a um "prompt de copy genérico" é que ele tem
 
 ## Selecionar a mente do copywriter (genomes)
 
+> **Menu via INDEX (v1.29.0):** a descoberta de genomes agora lê o `.aioson/genomes/INDEX.md` — o registro de **todos** os genomes instalados (mestres, personas, domínio, brand-voice), com guias de seleção por audiência e por tipo de output. O menu aparece quando você pergunta "quais genomes tenho", na ativação seca, ou quando mais de um genome serve para a peça. Vale para qualquer entrega: páginas de marketing, conteúdo, copy de site e **microcopy de sistema** (botões, empty states, onboarding, mensagens de erro). Quando o genome escolhido tem seções operacionais (geradas pelo pipeline de persona — `## Operating Procedure`, `## Prohibitions`, `## Style Metrics`, `## Delivery Checklist`), elas são **vinculantes** para a peça: o procedimento dirige o fluxo, as proibições viram hard constraints e o checklist roda na validação final.
+
 Quando há múltiplos genomes de mestres instalados, o `@copywriter` pergunta qual perspectiva aplicar. **8 mestres disponíveis** organizados em 2 hemisférios:
 
 ### Mestres universais (US, em inglês — adaptam-se ao idioma do projeto)

package/docs/pt/4-agentes/genome.md

@@ -105,6 +105,7 @@ aioson system:publish --type=genome --slug=<slug>
 ## Detalhes recentes
 
 - **Genome 4.0 (2026):** novos campos `anchor_prompt`, `relations`, `hexaco_h`, e `trait_interactions` — o genome passou a modelar como traços interagem entre si, não apenas listá-los isoladamente
+- **Camada de método operacional (v1.29.0):** genomes de função e de persona-praticante agora carregam **o que a pessoa FAZ**, não só quem ela é. Cinco seções obrigatórias — `## Operating Procedure` (o método em passos executáveis, ex: RMBC), `## Output Structure`, `## Style Metrics`, `## Prohibitions`, `## Delivery Checklist` — extraídas das evidências pelo pipeline de persona. Um genome de praticante sem `## Operating Procedure` simula opiniões, não trabalho, e é tratado como defeito de geração. Ao vincular num squad, essas seções se propagam: proibições viram hard constraints do executor, o checklist vira checklist do squad, e o procedimento dirige o padrão de resposta.
 
 ---
 

package/docs/pt/4-agentes/profiler-enricher.md

@@ -71,6 +71,8 @@ Você > proceed
 └── enriched-profile.md      ← saída desta etapa
 ```
 
+> **Método operacional (v1.29.0):** além do perfil psicométrico (DISC, Big Five, etc.), o enricher extrai das evidências o **método executável** da pessoa — procedimento em passos, estrutura de output, métricas de estilo, proibições e checklist de entrega (a seção `## Operational Method` do perfil). É o que faz o genome simular *o que a pessoa faz*, não só suas opiniões. Quando a fonte não documenta um método passo a passo, ele é reconstruído e marcado `inferred` — nunca inventado.
+
 ---
 
 ## Como ele lê seu projeto

package/docs/pt/4-agentes/profiler-forge.md

@@ -71,6 +71,8 @@ Você > 3
 .aioson/genomes/{slug}-advisor.md        ← advisor como prompt utilizável
 ```
 
+> **Seções operacionais (v1.29.0):** o forge emite o método capturado pelo enricher como cinco seções obrigatórias no genome — `## Operating Procedure`, `## Output Structure`, `## Style Metrics`, `## Prohibitions`, `## Delivery Checklist`. Um genome de persona-praticante sem `## Operating Procedure` é tratado como defeito de geração. Veja [genome.md](./genome.md) para como essas seções se propagam ao vincular num squad.
+
 ---
 
 ## Como ele lê seu projeto

package/docs/pt/4-agentes/sheldon.md

@@ -80,6 +80,8 @@ O `@sheldon` decide entre **enriquecer in-place** ou **criar plano faseado** dep
 5. `.aioson/briefings/{slug}/briefings.md` — se `briefing_source` está no PRD.
 6. `plans/*.md` e `prds/*.md` — fontes de pesquisa pré-produção do usuário.
 
+> **Fast path de ativação (v1.29.0):** ativar `@sheldon` "seco", sem PRD/slug, carrega **só** o `project.context.md`, a listagem de nomes dos `prd*.md` e a tabela `features.md` — apresenta a lista de PRDs para seleção e para. O conteúdo do PRD e o índice de brains entram só depois da escolha do alvo. Veja [Carregamento seletivo de contexto](../5-referencia/memoria-e-contexto.md#carregamento-seletivo-de-contexto-v1290).
+
 ## Handoff típico
 
 - **Vem de:** `@product` (PRD gerado) — pode ser ativado N vezes antes de ir adiante.

package/docs/pt/4-agentes/squad.md

@@ -93,16 +93,16 @@ Antes de criar, o `@squad` lê:
 
 ## Comandos CLI relacionados
 
-```bash
-# Criar squad via CLI
-aioson squad:scaffold . --slug=<slug> --name="Meu Squad" --mode=mixed
-
-# Diagnosticar squad existente
-aioson squad:doctor . --squad=<slug>
-
-# Publicar no aioson.com
-aioson system:publish --type=squad --slug=<slug>
-```
+```bash
+# Criar squad via CLI
+aioson squad:scaffold . --slug=<slug> --name="Meu Squad" --mode=mixed
+
+# Diagnosticar squad existente
+aioson squad:doctor . --squad=<slug>
+
+# Publicar no aioson.com
+aioson system:publish --type=squad --slug=<slug>
+```
 
 ---
 
@@ -117,6 +117,8 @@ aioson system:publish --type=squad --slug=<slug>
 
 - **domain breadth (Mai/2026):** executores que antes recusavam pedidos adjacentes ao seu escopo agora respondem com mais amplitude contextual
 - **squad refresh:** `@squad refresh <slug>` atualiza um squad existente com nova investigação sem recriar do zero
+- **investigação opt-out (v1.29.0):** a investigação de domínio com `@orache` agora roda **por padrão** — completa para domínios regulados/especializados, Quick Scan (1–2 rodadas) para domínios comuns sem fontes. É o que aterra os executores em frameworks/vocabulário reais em vez de priors do modelo (a causa nº1 de executor raso). O `@squad` anuncia o scan em vez de perguntar; diga "pula" para dispensar.
+- **genome pass na criação (v1.29.0):** os genomes planejados por executor são gerados e vinculados **durante** a criação do squad — não mais como passo manual depois. Um squad de domínio especializado nunca sai com `## Active genomes` vazio: ou vincula o genome, ou entrega o comando `@genome` exato pendente no resumo da criação. Para re-aterrar executores rasos de squads antigos, rode `@squad refresh <slug>`.
 
 ---
 

package/docs/pt/5-referencia/comandos-cli.md

@@ -150,6 +150,8 @@
 | `skill:list` | Lista skills instaladas em `.aioson/installed-skills/` | Quando quer saber quais skills estão ativas |
 | `skill:remove` | Remove skill instalada e limpa diretórios de ferramentas | Quando uma skill não é mais necessária |
 | `compress:agents` | Comprime arquivos de instrução dos agentes para reduzir consumo de tokens por sessão. Modo estrutural (gratuito) ou semântico via LLM (`--llm`). Salva backup automático em `.original.md`. Aceita `--agent`, `--rules`, `--dry-run`, `--restore`. | Quando quer reduzir custo de API sem alterar nenhuma lógica. Veja [compress:agents](./compress-agents.md) |
+| `context:select` | Seleciona sob demanda só as regras/docs/design-docs relevantes para a tarefa atual, por agente e modo (`--mode=planning\|executing`). Aceita `--agent`, `--task`, `--paths`, `--feature`, `--json`. | É o motor por trás dos *fast paths* e *activation guards* — os agentes o invocam para carregar só o que a task exige. Veja [Memória e Contexto](./memoria-e-contexto.md) |
+| `rules:lint` | Acusa regras (e docs, com `--docs`) "invisíveis ao seletor" — sem `task_types`/`triggers`/`paths` e sem `load_tier: always`, que o `context:select` nunca carregaria sob demanda. Aceita `--docs`, `--strict` (sai com código 1 em CI), `--json`. | Depois de criar/editar regras ou docs em `.aioson/rules/` ou `.aioson/docs/` — confirma que o seletor consegue roteá-los. Veja [Memória e Contexto](./memoria-e-contexto.md) |
 | `design-hybrid:options` | Abre um seletor visual com setas + espaço para montar um preset temporário de variações de design | Quando quer alimentar a `design-hybrid-forge` com direções mais extravagantes, clássicas, animadas ou com CSS avançado. Usa o locale do projeto automaticamente e aceita `--locale` como override; com `--advanced` libera um 3º modificador. Veja [design-hybrid-forge](../4-agentes/design-hybrid-forge.md) |
 
 ### Cloud

package/docs/pt/5-referencia/memoria-e-contexto.md

@@ -260,6 +260,66 @@ Quando a zona é `warning` ou `critical`, um evento é automaticamente registrad
 
 ---
 
+## Carregamento seletivo de contexto (v1.29.0+)
+
+As 3 camadas acima resolvem *onde* a memória mora. Esta seção resolve um problema diferente: *quando* cada arquivo entra na janela de contexto. Antes, ativar um agente carregava de tudo — regras, docs, design-docs, specs — logo de cara, mesmo que a tarefa não precisasse. A partir da v1.29.0 isso é seletivo: o agente carrega só o que a task atual exige, e o resto entra sob demanda.
+
+### Os dois modos
+
+Todo agente que mexe com contexto opera em dois modos explícitos, via `context:select`:
+
+| Modo | Quando | O que carrega |
+|---|---|---|
+| **PLANNING** | Inspecionar status, listar fontes, decidir o próximo passo | Só fundação + frontmatter; nunca pastas inteiras de regras/docs |
+| **EXECUTING** | Antes de escrever/editar um artefato ou código | Só as regras/docs/design-docs selecionados para os arquivos em questão |
+
+```bash
+aioson context:select . --agent=dev --mode=planning  --task="<tarefa>" --paths="<arquivos conhecidos>"
+aioson context:select . --agent=dev --mode=executing --task="<tarefa>" --paths="<arquivos a tocar>"
+```
+
+A saída traz a linha **Boundary**: *"carregue só os arquivos selecionados até a task, o modo, a feature ou os paths mudarem"*. Ou seja: quando o assunto muda no meio da conversa, o agente roda o seletor de novo com a task nova — não fica preso ao que carregou na entrada.
+
+### Fast path de ativação (agentes de entrada)
+
+Ativar um agente "seco" — `@briefing`, `@product`, `@sheldon`, `@analyst`, `@copywriter` (e `@deyvin`) sem nomear feature/tarefa — carrega **só o contexto de fundação** (`project.context.md` + `project-pulse.md`, mais o registro/listagem que o agente precisa para o menu), apresenta as opções de início e para. Nada de PRDs, dossiers, regras ou skills antes de você dizer o que fazer.
+
+### Guarda de ativação (agentes de meio de fluxo)
+
+`@architect`, `@ux-ui`, `@pm`, `@qa`, `@orchestrator`, `@scope-check` e `@discovery-design-doc` ganharam uma **guarda de ativação**: ativados sem slug de feature, leem só a fundação, reportam o estágio atual do workflow, perguntam qual feature trabalhar e param. Os artefatos pesados (specs, requirements, arquitetura) entram só na etapa que os usa.
+
+### Regras e docs roteáveis pelo seletor
+
+Para o `context:select` conseguir escolher uma regra ou doc, o arquivo precisa de **frontmatter de roteamento** — senão ele é "invisível ao seletor" e nunca é carregado sob demanda:
+
+```yaml
+---
+description: "..."
+agents: [dev, qa]          # quem pode carregar
+modes: [planning, executing]
+task_types: [payment, billing]
+triggers: [money, pricing, checkout]   # palavras/frases batidas contra a task
+paths: [src/billing/**]                # globs batidos contra os arquivos tocados
+load_tier: trigger                     # trigger (padrão) | always | justified
+---
+```
+
+Uma regra só com `description` (sem `task_types`/`triggers`/`paths` e sem `load_tier: always`) pontua abaixo do corte e o seletor nunca a carrega. Para auditar isso:
+
+```bash
+aioson rules:lint .            # acusa regras invisíveis ao seletor
+aioson rules:lint . --docs     # inclui .aioson/docs/ na varredura
+aioson rules:lint . --strict   # sai com código 1 se houver avisos (para CI)
+```
+
+> **Depois de `aioson update` em um projeto:** rode `aioson rules:lint . --docs`. Ele aponta exatamente quais regras/docs locais seus ficaram sem metadata de roteamento e precisam de `triggers`/`task_types`/`paths` para o seletor enxergá-los.
+
+### Por que isso reduz tokens
+
+Lazy-loading rende ~10x mais que comprimir prosa: deixar de carregar PRDs/dossiers/regras inteiros na ativação economiza ~10–25k tokens por sessão, contra ~1k de uma compressão de texto. Os dois se somam — o [`compress:agents`](./compress-agents.md) enxuga o arquivo do agente; o carregamento seletivo evita puxar arquivos que a task nem usa.
+
+---
+
 ## Onde tudo vive
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaimevalasek/aioson",
-  "version": "1.28.0",
+  "version": "1.29.1",
   "description": "AI operating framework for hyper-personalized software.",
   "keywords": [
     "ai",

package/src/cli.js

@@ -14,6 +14,7 @@ const { runAgentsList, runAgentPrompt } = require('./commands/agents');
 const { runContextValidate } = require('./commands/context-validate');
 const { runContextPack } = require('./commands/context-pack');
 const { runContextSelect } = require('./commands/context-select');
+const { runRulesLint } = require('./commands/rules-lint');
 const { runContextLoad } = require('./commands/context-load');
 const { runChainAudit } = require('./commands/chain-audit');
 const { runMemorySearch } = require('./commands/memory-search');
@@ -257,6 +258,8 @@ const JSON_SUPPORTED_COMMANDS = new Set([
   'context-pack',
   'context:select',
   'context-select',
+  'rules:lint',
+  'rules-lint',
   'context:load',
   'context-load',
   'chain:audit',
@@ -1105,6 +1108,8 @@ async function main() {
       result = await runContextPack({ args, options, logger: commandLogger, t });
     } else if (command === 'context:select' || command === 'context-select') {
       result = await runContextSelect({ args, options, logger: commandLogger, t });
+    } else if (command === 'rules:lint' || command === 'rules-lint') {
+      result = await runRulesLint({ args, options, logger: commandLogger, t });
     } else if (command === 'context:load' || command === 'context-load') {
       result = await runContextLoad({ args, options, logger: commandLogger, t });
     } else if (command === 'chain:audit' || command === 'chain-audit') {

package/src/commands/rules-lint.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { parseFrontmatter } = require('../preflight-engine');
+
+const ROUTING_FIELDS = ['task_types', 'triggers', 'paths', 'globs'];
+
+function hasValue(raw) {
+  if (raw === undefined || raw === null) return false;
+  const value = String(raw).trim();
+  return value !== '' && value !== '[]';
+}
+
+function lintRule(relPath, frontmatter) {
+  const warnings = [];
+  const isRule = relPath.startsWith('.aioson/rules/');
+
+  if (isRule && !hasValue(frontmatter.name)) warnings.push('missing required field: name');
+  if (!hasValue(frontmatter.description)) warnings.push('missing required field: description');
+
+  const loadTier = String(frontmatter.load_tier || 'trigger').trim().toLowerCase();
+  const routing = ROUTING_FIELDS.filter((field) => hasValue(frontmatter[field]));
+
+  if (loadTier !== 'always' && routing.length === 0) {
+    warnings.push(
+      'selector-invisible: no task_types, triggers, or paths — context:select can never score this rule above the load threshold, so agents will not load it on demand. Add routing metadata or set load_tier: always.'
+    );
+  }
+
+  return {
+    path: relPath,
+    name: String(frontmatter.name || path.basename(relPath, '.md')),
+    load_tier: loadTier,
+    agents: hasValue(frontmatter.agents) ? String(frontmatter.agents) : 'all',
+    routing,
+    warnings,
+    ok: warnings.length === 0
+  };
+}
+
+async function collectMarkdownFiles(absDir, relDir, recursive) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(absDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.toLowerCase() === 'readme.md') continue;
+    const absChild = path.join(absDir, entry.name);
+    const relChild = `${relDir}/${entry.name}`;
+    if (entry.isDirectory()) {
+      if (recursive) files.push(...await collectMarkdownFiles(absChild, relChild, recursive));
+      continue;
+    }
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+    files.push({ abs: absChild, rel: relChild });
+  }
+  return files;
+}
+
+async function runRulesLint({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const relDir = '.aioson/rules';
+
+  const files = await collectMarkdownFiles(path.join(targetDir, '.aioson', 'rules'), relDir, false);
+  if (options.docs) {
+    files.push(...await collectMarkdownFiles(path.join(targetDir, '.aioson', 'docs'), '.aioson/docs', true));
+  }
+
+  if (files.length === 0) {
+    const result = { ok: true, dir: relDir, rules: [], total: 0, warnings: 0 };
+    if (options.json) return result;
+    logger.log(`No rule${options.docs ? '/doc' : ''} files found under ${relDir}${options.docs ? ' or .aioson/docs' : ''} — nothing to lint.`);
+    return result;
+  }
+
+  const rules = [];
+  for (const file of files) {
+    const content = await fs.readFile(file.abs, 'utf8');
+    rules.push(lintRule(file.rel, parseFrontmatter(content)));
+  }
+
+  const warningsCount = rules.reduce((sum, rule) => sum + rule.warnings.length, 0);
+  const result = {
+    ok: !(options.strict && warningsCount > 0),
+    dir: relDir,
+    rules,
+    total: rules.length,
+    warnings: warningsCount
+  };
+  if (options.strict && warningsCount > 0) result.exitCode = 1;
+  if (options.json) return result;
+
+  logger.log(`Rules lint for ${relDir} (${rules.length} rule${rules.length === 1 ? '' : 's'})`);
+  for (const rule of rules) {
+    if (rule.ok) {
+      const routing = rule.load_tier === 'always' ? 'load_tier: always' : `routing: ${rule.routing.join(', ')}`;
+      logger.log(`OK   ${rule.name} [agents: ${rule.agents}] ${routing}`);
+    } else {
+      logger.log(`WARN ${rule.name}`);
+      for (const warning of rule.warnings) logger.log(`     - ${warning}`);
+    }
+  }
+  const clean = rules.filter((rule) => rule.ok).length;
+  logger.log(`Summary: ${clean}/${rules.length} ok, ${warningsCount} warning${warningsCount === 1 ? '' : 's'}.`);
+  if (warningsCount > 0) {
+    logger.log('Tip: add task_types/triggers/paths frontmatter so context:select can load the rule on demand (see .aioson/rules/README.md).');
+  }
+
+  return result;
+}
+
+module.exports = { runRulesLint };

package/src/context-selector.js

@@ -29,10 +29,31 @@ const FOUNDATION_CONTEXT_BASENAMES = new Set([
   'memory-index.md'
 ]);
 
-const ACTIVATION_ONLY_CONTEXT_PATHS = new Set([
+const FOUNDATION_ACTIVATION_PATHS = new Set([
   '.aioson/context/project.context.md',
-  '.aioson/context/project-pulse.md',
-  '.aioson/context/dev-state.md'
+  '.aioson/context/project-pulse.md'
+]);
+
+const FOUNDATION_ACTIVATION_AGENTS = [
+  'briefing',
+  'product',
+  'sheldon',
+  'analyst',
+  'architect',
+  'ux-ui',
+  'pm',
+  'qa',
+  'orchestrator',
+  'scope-check',
+  'discovery-design-doc'
+];
+
+const ACTIVATION_ONLY_CONTEXT_PATHS_BY_AGENT = new Map([
+  [
+    'deyvin',
+    new Set([...FOUNDATION_ACTIVATION_PATHS, '.aioson/context/dev-state.md'])
+  ],
+  ...FOUNDATION_ACTIVATION_AGENTS.map((agent) => [agent, FOUNDATION_ACTIVATION_PATHS])
 ]);
 
 const UNIVERSAL_ALWAYS_CONTEXT_BASENAMES = new Set([
@@ -66,7 +87,7 @@ function normalizeFeaturePointer(value) {
 }
 
 function isActivationOnlyTask(agent, mode, task) {
-  if (agent !== 'deyvin' || mode !== 'planning') return false;
+  if (!ACTIVATION_ONLY_CONTEXT_PATHS_BY_AGENT.has(agent) || mode !== 'planning') return false;
   const normalized = normalizeToken(task);
   if (!normalized) return true;
   return (
@@ -272,7 +293,10 @@ function scoreCandidate(candidate, context) {
   const base = path.basename(candidate.path);
 
   if (!appliesToAgent(candidate.frontmatter, context.agent)) return null;
-  if (context.activationOnly && !ACTIVATION_ONLY_CONTEXT_PATHS.has(candidate.path)) return null;
+  if (context.activationOnly) {
+    const allowedActivationPaths = ACTIVATION_ONLY_CONTEXT_PATHS_BY_AGENT.get(context.agent);
+    if (!allowedActivationPaths || !allowedActivationPaths.has(candidate.path)) return null;
+  }
 
   if (candidate.modes.length > 0 && !candidate.modes.map(normalizeToken).includes(context.mode)) {
     return null;

package/template/.aioson/agents/analyst.md

@@ -2,34 +2,46 @@
 
 > **LANGUAGE BOUNDARY:** Agent instructions are canonical in English. All user-facing communication must follow `interaction_language` from project context. If it is absent, fall back to `conversation_language`.
 
-## Context loading modes
-
-Use two explicit modes so analysis starts from evidence without bulk-loading rules, docs, or memories.
-
-- **PLANNING** — inspect workflow status, project context, feature/frontmatter, dossier index, research cache summaries, and `context:select` output. Do not load full `.aioson/rules/`, `.aioson/docs/`, `.aioson/design-docs/`, or bootstrap folders.
-- **EXECUTING** — before writing `discovery.md`, `requirements-{slug}.md`, or `spec-{slug}.md`, run `context:select --mode=executing` and load only the selected rules/docs/design governance plus the source artifacts needed for the current output.
-
-Project rules and governance are active only when selected by frontmatter metadata, path match, task trigger, or an explicit reference from an already loaded artifact. Loaded rules override this file.
+## Activation-only fast path
+
+Evaluate this immediately after reading this file and before loading any other context, doc, or skill.
+
+If the user only activates `@analyst` without naming a feature, PRD, or concrete analysis task:
+
+1. When the CLI is available, run `aioson workflow:status .` and `aioson context:select . --agent=analyst --mode=planning --task="agent activation without concrete task" --paths=""`.
+2. Load only: `project.context.md` and a filename listing of `.aioson/context/prd*.md` / `requirements-*.md` (names only — no contents).
+3. Report the current stage, ask which feature or discovery scope to analyze, and stop.
+
+Do NOT load on activation: PRD/requirements contents, `discovery.md`, `spec*.md`, dossiers, scan artifacts, bootstrap files, or skills (including `aioson-spec-driven`). Run the full tool-first preflight only after a concrete task or feature is named.
+
+## Context loading modes
+
+Use two explicit modes so analysis starts from evidence without bulk-loading rules, docs, or memories.
+
+- **PLANNING** — inspect workflow status, project context, feature/frontmatter, dossier index, research cache summaries, and `context:select` output. Do not load full `.aioson/rules/`, `.aioson/docs/`, `.aioson/design-docs/`, or bootstrap folders.
+- **EXECUTING** — before writing `discovery.md`, `requirements-{slug}.md`, or `spec-{slug}.md`, run `context:select --mode=executing` and load only the selected rules/docs/design governance plus the source artifacts needed for the current output.
+
+Project rules and governance are active only when selected by frontmatter metadata, path match, task trigger, or an explicit reference from an already loaded artifact. Loaded rules override this file.
 
 ## Mission
 Discover requirements deeply and produce implementation-ready artifacts. For new projects: `discovery.md`. For new features: `requirements-{slug}.md` + `spec-{slug}.md`.
 
-## Bootstrap context
-
-Do not read `.aioson/context/bootstrap/` wholesale. Let `context:select --mode=planning` choose `what-is.md` or `what-it-does.md` only when the current analysis needs system identity, existing features, business rules, or constraints. Never load `current-state-archive.md` at activation.
+## Bootstrap context
+
+Do not read `.aioson/context/bootstrap/` wholesale. Let `context:select --mode=planning` choose `what-is.md` or `what-it-does.md` only when the current analysis needs system identity, existing features, business rules, or constraints. Never load `current-state-archive.md` at activation.
 
 ## Tool-first session preflight
 
 Before any manual checks, run these commands if the `aioson` CLI is available:
 
-```bash
-aioson workflow:status .          # confirm current stage and what is expected
-aioson context:validate .         # validate project.context.md; detects brownfield state
-aioson context:select . --agent=analyst --mode=planning --task="<task>" --paths="<known source files>"
-aioson preflight:context . --agent=analyst --mode=planning --task="<task>" --paths="<known source files>"
-aioson preflight . --agent=analyst --feature={slug}    # readiness/status only; do not treat it as permission to load every listed rule
-aioson classify .                                       # auto-detect project classification (MICRO/SMALL/MEDIUM) for cross-reference
-```
+```bash
+aioson workflow:status .          # confirm current stage and what is expected
+aioson context:validate .         # validate project.context.md; detects brownfield state
+aioson context:select . --agent=analyst --mode=planning --task="<task>" --paths="<known source files>"
+aioson preflight:context . --agent=analyst --mode=planning --task="<task>" --paths="<known source files>"
+aioson preflight . --agent=analyst --feature={slug}    # readiness/status only; do not treat it as permission to load every listed rule
+aioson classify .                                       # auto-detect project classification (MICRO/SMALL/MEDIUM) for cross-reference
+```
 
 For feature mode with existing requirements, run before the synchronization gate:
 ```bash
@@ -63,11 +75,11 @@ If the CLI is not available, compare modification dates manually:
 
 Check the following before doing anything else:
 
-**Feature mode** — a `prd-{slug}.md` file exists in `.aioson/context/`:
-- Read `prd-{slug}.md` to understand the feature scope.
-- Read only selected `design-doc*`, `readiness*`, `discovery.md`, or `spec.md` when `context:select` or a dossier/PRD reference says they are needed for the current feature.
-- Run the **Feature discovery** process below (lighter, feature-scoped).
-- Output: `requirements-{slug}.md` + `spec-{slug}.md`.
+**Feature mode** — a `prd-{slug}.md` file exists in `.aioson/context/`:
+- Read `prd-{slug}.md` to understand the feature scope.
+- Read only selected `design-doc*`, `readiness*`, `discovery.md`, or `spec.md` when `context:select` or a dossier/PRD reference says they are needed for the current feature.
+- Run the **Feature discovery** process below (lighter, feature-scoped).
+- Output: `requirements-{slug}.md` + `spec-{slug}.md`.
 
 **Project mode** — no `prd-{slug}.md`, only `prd.md` or nothing:
 - Run the full 3-phase project discovery below.
@@ -96,6 +108,9 @@ aioson dossier:add-finding . --slug={slug} --agent=analyst --section="Agent Trai
 Full templates: `.aioson/docs/dossier/agent-templates.md`
 
 ## Required input
+
+Load each item at the step that needs it — never all upfront (see **Activation-only fast path**):
+
 - `.aioson/context/project.context.md` (always)
 - `.aioson/context/prd-{slug}.md` (feature mode)
 - `.aioson/context/design-doc.md` + `readiness.md` (if present)
@@ -256,16 +271,16 @@ For each new or modified entity, produce field-level detail (same format as Phas
 ### Output contract — feature mode
 
 **`requirements-{slug}.md`** — implementation spec for the feature:
-1. Feature summary (1–2 lines from prd-{slug}.md)
-2. Requirement IDs (`REQ-{slug}-01...`) with source references
-3. Acceptance criteria IDs (`AC-{slug}-01...`) mapped to requirement IDs
-4. New entities and fields (full table format)
-5. Changes to existing entities
-6. Relationships (with existing entities from discovery.md when loaded)
-7. Migration additions (ordered)
-8. Business rules
-9. Edge cases
-10. Out of scope for this feature
+1. Feature summary (1–2 lines from prd-{slug}.md)
+2. Requirement IDs (`REQ-{slug}-01...`) with source references
+3. Acceptance criteria IDs (`AC-{slug}-01...`) mapped to requirement IDs
+4. New entities and fields (full table format)
+5. Changes to existing entities
+6. Relationships (with existing entities from discovery.md when loaded)
+7. Migration additions (ordered)
+8. Business rules
+9. Edge cases
+10. Out of scope for this feature
 
 **`spec-{slug}.md`** — feature memory skeleton (will be enriched by @dev):
 
@@ -331,6 +346,7 @@ Generate `.aioson/context/discovery.md` with the following sections:
 12. **Out of scope** — explicitly excluded from the MVP
 
 ## Hard constraints
+- On bare activation, follow the **Activation-only fast path**.
 - Use `interaction_language` (fallback: `conversation_language`) from project context for all interaction and output.
 - Keep output actionable for `@architect` (project mode) or `@dev` (feature mode) without requiring re-discovery.
 - Do not finalize any output file with missing or assumed fields.
@@ -339,7 +355,7 @@ Generate `.aioson/context/discovery.md` with the following sections:
 
 ## Dev handoff producer
 
-Before the final `agent:epilogue`/`agent:done` call, when the next agent in the workflow is `@dev`, produce `dev-state.md` so the next `/aioson:agent:dev` session auto-resumes on cold start instead of pinging the user for context:
+Before the final `agent:epilogue`/`agent:done` call, when the next agent in the workflow is `@dev`, produce `dev-state.md` so the next `/aioson:agent:dev` session auto-resumes on cold start instead of pinging the user for context:
 
 ```bash
 aioson dev:state:write . --feature={slug} --phase=1 \
@@ -347,9 +363,9 @@ aioson dev:state:write . --feature={slug} --phase=1 \
   --context=spec,requirements
 ```
 
-`--context` accepts canonical tokens (`prd`, `requirements`, `spec`, `architecture`, `impl-plan`, `sheldon`, `design-doc`, `readiness`, `ui-spec`, `dossier`, `simple-plan`), max 4 entries total; missing files emit a warning and are skipped. Always include the artifacts @dev will need to start the first slice — typically `spec` + `requirements` for SMALL features. Idempotent: re-running with the same args does not duplicate state.
-
-If any workflow stage remains before `@dev` (`@scope-check`, `@architect`, `@discovery-design-doc`, or `@pm`), do not guess the final implementation package here. The last pre-dev stage writes the final `dev-state.md`; `@analyst` only produces it for direct-to-dev shortcuts.
+`--context` accepts canonical tokens (`prd`, `requirements`, `spec`, `architecture`, `impl-plan`, `sheldon`, `design-doc`, `readiness`, `ui-spec`, `dossier`, `simple-plan`), max 4 entries total; missing files emit a warning and are skipped. Always include the artifacts @dev will need to start the first slice — typically `spec` + `requirements` for SMALL features. Idempotent: re-running with the same args does not duplicate state.
+
+If any workflow stage remains before `@dev` (`@scope-check`, `@architect`, `@discovery-design-doc`, or `@pm`), do not guess the final implementation package here. The last pre-dev stage writes the final `dev-state.md`; `@analyst` only produces it for direct-to-dev shortcuts.
 
 **Handoff message:**
 ```
@@ -383,6 +399,6 @@ aioson runtime:emit . --agent=analyst --type=milestone --summary="Spec skeleton
 
 At session end, register:
 ```bash
-aioson gate:approve . --feature={slug} --gate=A 2>/dev/null || true
-aioson agent:epilogue . --agent=analyst --feature={slug} --summary="Discovery <slug>: <N> entities, <N> rules" --action="Discovery completed: {N} entities, {N} rules" --next="<next agent recommendation>" --gate="Gate A: approved" 2>/dev/null || aioson agent:done . --agent=analyst --summary="Discovery <slug>: <N> entities, <N> rules" 2>/dev/null || true
-```
+aioson gate:approve . --feature={slug} --gate=A 2>/dev/null || true
+aioson agent:epilogue . --agent=analyst --feature={slug} --summary="Discovery <slug>: <N> entities, <N> rules" --action="Discovery completed: {N} entities, {N} rules" --next="<next agent recommendation>" --gate="Gate A: approved" 2>/dev/null || aioson agent:done . --agent=analyst --summary="Discovery <slug>: <N> entities, <N> rules" 2>/dev/null || true
+```