claudenv 1.2.4 → 1.3.0

package/bin/cli.js

@@ -10,9 +10,10 @@ import { generateDocs, writeDocs, installScaffold } from '../src/generator.js';
 import { validateClaudeMd, validateStructure, crossReferenceCheck } from '../src/validator.js';
 import { runExistingProjectFlow, runColdStartFlow, buildDefaultConfig } from '../src/prompts.js';
 import { installGlobal, uninstallGlobal } from '../src/installer.js';
-import { runLoop, rollback, checkClaudeCli } from '../src/loop.js';
+import { runLoop, rollback, checkClaudeCli, readLoopLog } from '../src/loop.js';
 import { generateAutonomyConfig, printSecuritySummary, getFullModeWarning } from '../src/autonomy.js';
 import { getProfile, listProfiles } from '../src/profiles.js';
+import { readReport, formatReport, formatEventLine, watchReport } from '../src/report.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgJson = JSON.parse(await readFile(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -131,6 +132,7 @@ program
   .option('-d, --dir <path>', 'Target project directory')
   .option('--allow-dirty', 'Allow running with uncommitted git changes')
   .option('--rollback', 'Undo all changes from the most recent loop run')
+  .option('--resume', 'Resume from last rate-limited iteration')
   .option('--unsafe', 'Remove default tool restrictions (allows rm -rf)')
   .option('--worktree', 'Run each iteration in an isolated git worktree')
   .option('--profile <name>', 'Autonomy profile: safe, moderate, full, ci')
@@ -141,6 +143,36 @@ program
       return;
     }
 
+    // --- Resume mode ---
+    if (opts.resume) {
+      const resumeCwd = opts.dir ? resolve(opts.dir) : process.cwd();
+      const prevLog = await readLoopLog(resumeCwd);
+      if (!prevLog || !prevLog.pausedAt) {
+        console.error('\n  No resumable loop found. Run a loop first or check .claude/loop-log.json.\n');
+        process.exit(1);
+      }
+      const saved = prevLog.options || {};
+      console.log(`\n  Resuming loop from iteration ${prevLog.pausedAt.iteration}`);
+      console.log(`  Goal: ${saved.goal || 'General improvement'}`);
+      console.log(`  Session: ${prevLog.pausedAt.sessionId || 'new'}\n`);
+
+      await runLoop({
+        iterations: opts.iterations || Infinity,
+        trust: saved.trust || false,
+        goal: saved.goal,
+        pause: false,
+        maxTurns: saved.maxTurns || 30,
+        model: opts.model || saved.model,
+        budget: saved.budget,
+        cwd: resumeCwd,
+        allowDirty: true,
+        worktree: saved.worktree || false,
+        startIteration: prevLog.pausedAt.iteration,
+        initialSessionId: prevLog.pausedAt.sessionId,
+      });
+      return;
+    }
+
     // --- Pre-flight: check Claude CLI ---
     const cli = checkClaudeCli();
     if (!cli.installed) {
@@ -176,6 +208,7 @@ program
         disallowedTools: profile.disallowedTools,
         maxTurns: profile.maxTurns,
         budget: profile.maxBudget,
+        model: profile.model,
       };
       console.log(`  Profile: ${profile.name} — ${profile.description}`);
     }
@@ -189,7 +222,8 @@ program
     if (opts.worktree) console.log(`  Worktree: enabled (each iteration in isolated worktree)`);
     if (opts.iterations) console.log(`  Max iterations: ${opts.iterations}`);
     if (opts.goal) console.log(`  Goal: ${opts.goal}`);
-    if (opts.model) console.log(`  Model: ${opts.model}`);
+    const model = opts.model || profileDefaults.model || undefined;
+    if (model) console.log(`  Model: ${model}`);
     if (opts.budget || profileDefaults.budget) console.log(`  Budget: $${opts.budget || profileDefaults.budget}/iteration`);
     if (opts.maxTurns || profileDefaults.maxTurns) console.log(`  Max turns: ${opts.maxTurns || profileDefaults.maxTurns}`);
 
@@ -199,7 +233,7 @@ program
       goal: opts.goal,
       pause,
       maxTurns: opts.maxTurns || profileDefaults.maxTurns || 30,
-      model: opts.model,
+      model,
       budget: opts.budget || profileDefaults.budget,
       cwd,
       allowDirty: opts.allowDirty || false,
@@ -209,6 +243,40 @@ program
     });
   });
 
+// --- report ---
+program
+  .command('report')
+  .description('View work report from autonomous loop runs')
+  .option('-f, --follow', 'Live stream events (tail -f style)')
+  .option('--last <n>', 'Show last N events', parseInt)
+  .option('-d, --dir <path>', 'Project directory')
+  .action(async (opts) => {
+    const cwd = opts.dir ? resolve(opts.dir) : process.cwd();
+    const events = await readReport(cwd);
+
+    if (opts.follow) {
+      // Print existing events first
+      if (events.length > 0) {
+        const show = opts.last ? events.slice(-opts.last) : events;
+        process.stdout.write(formatReport(show));
+      }
+      console.log('  Watching for new events... (Ctrl+C to stop)\n');
+      await watchReport(cwd, (event) => {
+        process.stdout.write(formatEventLine(event));
+      });
+      return;
+    }
+
+    if (events.length === 0) {
+      console.log('\n  No work report found. Run `claudenv loop` first.\n');
+      return;
+    }
+
+    const show = opts.last ? events.slice(-opts.last) : events;
+    console.log();
+    process.stdout.write(formatReport(show));
+  });
+
 // --- autonomy ---
 program
   .command('autonomy')
@@ -220,6 +288,198 @@ program
   .option('--dry-run', 'Preview without writing')
   .action(runAutonomy);
 
+// --- hook (internal entry point for Claude Code hooks) ---
+program
+  .command('hook')
+  .description('Internal: dispatch a Claude Code hook by name (decisions-logger, regen-index)')
+  .argument('<name>', 'Hook name')
+  .action(async (name) => {
+    const { dispatch } = await import('../src/hooks/dispatcher.js');
+    await dispatch(name);
+  });
+
+// =============================================
+// 1.3.0: memory / decisions / canon / doctor
+// =============================================
+
+// --- memory ---
+const memoryCmd = program.command('memory').description('Manage the global ~/.claudenv/memories/ layout');
+
+memoryCmd
+  .command('init')
+  .description('Create the ~/.claudenv/memories/ structure (idempotent)')
+  .action(async () => {
+    const { memoryInit } = await import('../src/memory.js');
+    const { created, skipped } = await memoryInit();
+    for (const p of created) console.log(`  + ${p}`);
+    for (const p of skipped) console.log(`  ~ ${p}`);
+    console.log(`\n  ${created.length} created, ${skipped.length} already present.`);
+  });
+
+memoryCmd
+  .command('index')
+  .description('Regenerate ~/.claudenv/memories/INDEX.md from current decisions and prefs')
+  .action(async () => {
+    const { memoryIndex } = await import('../src/memory.js');
+    const result = await memoryIndex();
+    console.log(`  INDEX.md regenerated → ${result.indexPath}`);
+    console.log(`  ${result.recentCount} recent of ${result.decisionCount} total decisions`);
+  });
+
+memoryCmd
+  .command('show')
+  .argument('<path>', 'Path relative to ~/.claudenv/memories/')
+  .description('Print a memory file to stdout')
+  .action(async (path) => {
+    const { memoryShow } = await import('../src/memory.js');
+    try {
+      process.stdout.write(await memoryShow(path));
+    } catch (err) {
+      console.error(err.message);
+      process.exit(2);
+    }
+  });
+
+memoryCmd
+  .command('edit')
+  .argument('<path>', 'Path relative to ~/.claudenv/memories/')
+  .description('Open a memory file in $EDITOR (vi by default)')
+  .action(async (path) => {
+    const { memoryEdit } = await import('../src/memory.js');
+    const result = await memoryEdit(path);
+    process.exit(result.exitCode);
+  });
+
+// --- decisions ---
+const decisionsCmd = program.command('decisions').description('List, show, or search logged vibe-decisions');
+
+decisionsCmd
+  .command('list')
+  .description('List recent decisions (newest first)')
+  .option('--scope <s>', 'global | project | all', 'all')
+  .option('--limit <n>', 'Max entries', '10')
+  .action(async (opts) => {
+    const { listDecisions, formatDecisionList } = await import('../src/decisions.js');
+    const limit = parseInt(opts.limit, 10) || 10;
+    const all = await listDecisions({ scope: opts.scope });
+    console.log(formatDecisionList(all.slice(0, limit)));
+  });
+
+decisionsCmd
+  .command('show')
+  .argument('<id>', 'Slug or substring of the decision')
+  .description('Show full details of one decision')
+  .action(async (id) => {
+    const { showDecision, formatDecisionDetail } = await import('../src/decisions.js');
+    try {
+      const d = await showDecision(id);
+      console.log(formatDecisionDetail(d));
+      console.log('\n---\n');
+      console.log(d.text);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(err.notFound ? 1 : 2);
+    }
+  });
+
+decisionsCmd
+  .command('search')
+  .argument('<query>', 'Substring to search topic/reason/chose')
+  .description('Search decisions')
+  .action(async (query) => {
+    const { searchDecisions, formatDecisionList } = await import('../src/decisions.js');
+    const hits = await searchDecisions(query);
+    console.log(formatDecisionList(hits));
+  });
+
+decisionsCmd
+  .command('archive')
+  .argument('<id>', 'Slug to archive')
+  .description('Move a decision into <scope-dir>/archive/')
+  .action(async (id) => {
+    const { archiveDecision } = await import('../src/decisions.js');
+    try {
+      const { from, to } = await archiveDecision(id);
+      console.log(`  archived: ${from} → ${to}`);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(2);
+    }
+  });
+
+// --- canon ---
+const canonCmd = program.command('canon').description('Personal canon of references (~/.claudenv/memories/canon/index.yaml)');
+
+canonCmd
+  .command('add')
+  .argument('<topic>', 'Topic slug')
+  .argument('<url>', 'URL to add')
+  .option('--why <reason>', 'Why this reference is in the canon')
+  .option('--title <title>', 'Title')
+  .option('--author <author>', 'Author or venue')
+  .action(async (topic, url, opts) => {
+    const { canonAdd } = await import('../src/canon.js');
+    try {
+      const res = await canonAdd({
+        topic,
+        url,
+        why: opts.why,
+        title: opts.title,
+        author: opts.author,
+      });
+      if (res.added) console.log(`  + ${topic}: ${res.entry.title || res.entry.url}`);
+      else console.log(`  ~ duplicate url in ${topic} — skipped`);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(2);
+    }
+  });
+
+canonCmd
+  .command('list')
+  .argument('[topic]', 'Optional topic filter')
+  .action(async (topic) => {
+    const { canonList, formatCanon } = await import('../src/canon.js');
+    const data = await canonList(topic);
+    console.log(formatCanon(data));
+  });
+
+canonCmd
+  .command('search')
+  .argument('<query>', 'Substring search')
+  .action(async (query) => {
+    const { canonSearch, formatCanon } = await import('../src/canon.js');
+    const data = await canonSearch(query);
+    console.log(formatCanon(data));
+  });
+
+canonCmd
+  .command('prune')
+  .option('--months <n>', 'Age threshold in months', '6')
+  .action(async (opts) => {
+    const { canonPrune } = await import('../src/canon.js');
+    const stale = await canonPrune(parseInt(opts.months, 10) || 6);
+    if (stale.length === 0) {
+      console.log('  No stale entries.');
+      return;
+    }
+    for (const { topic, entry, reason } of stale) {
+      const why = reason || `added ${entry.added}`;
+      console.log(`  ${topic}: ${entry.url} (${why})`);
+    }
+  });
+
+// --- doctor ---
+program
+  .command('doctor')
+  .description('Health-check the claudenv setup')
+  .action(async () => {
+    const { runDoctor } = await import('../src/doctor.js');
+    const { lines, hasFail } = await runDoctor();
+    for (const l of lines) console.log(l);
+    process.exit(hasFail ? 1 : 0);
+  });
+
 // =============================================
 // Install / Uninstall
 // =============================================
@@ -247,7 +507,8 @@ async function runInstall(opts) {
   console.log(`
   Done! Now open Claude Code in any project and type:
 
-    /claudenv
+    /claudenv    — Set up project documentation
+    /autonomy   — Manage autonomy profiles
 
   Claude will analyze your project and generate documentation.
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudenv",
-  "version": "1.2.4",
+  "version": "1.3.0",
   "description": "One command to integrate Claude Code into any project — installs /claudenv command for AI-powered documentation generation",
   "type": "module",
   "bin": {

package/scaffold/.claude/memories/README.md

@@ -0,0 +1,44 @@
+# Project memories
+
+This directory holds **project-scoped** memory for `vibe-decisions` and related skills. Cross-project memory lives in `~/.claudenv/memories/`.
+
+## Layout
+
+```
+.claude/memories/
+├── project.md           # стек, конвенции, важные urls — заполняешь вручную
+├── decisions/           # project-specific tech decisions (committed to repo)
+│   └── 2026-05-27-auth-jwt.md
+└── README.md            # this file
+```
+
+## When goes here vs `~/.claudenv/memories/`
+
+- **Здесь (project)**: выбор специфичен этому проекту — внутренний сервис, формат API, deployment target, project-only convention
+- **В `~/.claudenv/memories/decisions/` (global)**: универсальный tech-выбор — какая БД, какой algo, который применим в любом проекте
+
+Skill `vibe-decisions` решает scope автоматически по полю `scope: global|project` в frontmatter. По умолчанию `global` если непонятно.
+
+## project.md шаблон
+
+Создай этот файл вручную (claudenv не генерит автоматически):
+
+```markdown
+# <project-name>
+
+- **Stack:** Python 3.12, FastAPI, Postgres, Redis
+- **Tests:** `pytest -m "not slow"` локально; CI запускает всё
+- **Package manager:** uv (NOT pip, NOT poetry)
+- **Линтеры:** ruff + mypy strict
+- **Deploy:** GitHub Actions → ArgoCD → k8s
+- **Внутренние ADR:** `docs/adr/`
+- **Слаг для decisions/:** `<project-slug>`
+```
+
+`vibe-decisions` читает project.md перед каждым нетривиальным выбором.
+
+## Commit policy
+
+- `project.md` — committed
+- `decisions/*.md` — committed (это shared с командой)
+- Никаких secrets (production endpoints, API keys, internal hostnames) — для них используй `~/.claudenv/memories/` с глобальным scope (выйдет за пределы repo)

package/scaffold/global/.claude/commands/autonomy.md

@@ -0,0 +1,90 @@
+---
+description: Manage autonomy profiles — switch between safe/moderate/full/ci or view current status
+allowed-tools: Bash, Read, Glob, Grep
+argument-hint: <status|safe|moderate|full|ci> [--dry-run]
+---
+
+# Autonomy Profile Manager
+
+Manage Claude Code autonomy profiles directly from within a session.
+
+## Instructions
+
+Parse `$ARGUMENTS` and execute the matching action below.
+
+### 1. Determine the action
+
+- If `$ARGUMENTS` is empty or `status` → go to **Status**
+- If `$ARGUMENTS` starts with `safe`, `moderate`, `full`, or `ci` → go to **Switch Profile**
+- Otherwise → go to **Usage Help**
+
+### 2. Status
+
+Show the current autonomy configuration:
+
+1. Check if `.claude/hooks/pre-tool-use.sh` exists in the current project directory.
+   - If it exists, read the first 5 lines to find the `# Profile:` comment header and report the active profile name.
+   - If it doesn't exist, report "No autonomy profile configured for this project."
+2. Check if `.claude/settings.json` exists. If so, read it and summarize the permissions (allowedTools, disallowedTools counts).
+3. List available profiles: `safe`, `moderate`, `full`, `ci`.
+
+### 3. Switch Profile
+
+The target profile is the first word of `$ARGUMENTS`. Check for `--dry-run` flag in the remaining arguments.
+
+**If the profile is `full`:**
+Before proceeding, display this warning:
+
+```
+⚠️  FULL AUTONOMY MODE — UNRESTRICTED ACCESS
+
+This profile grants Claude Code complete access including:
+• All file system operations (read, write, delete)
+• Credential files (~/.ssh, ~/.aws, ~/.gnupg, ~/.kube, etc.)
+• All git operations including force push
+• No permission prompts (--dangerously-skip-permissions)
+
+Safety net: audit logging + hard blocks on rm -rf / and force push to main
+```
+
+Ask the user to confirm before proceeding. If they decline, abort.
+
+**Apply the profile:**
+
+Build the command:
+```
+claudenv autonomy --profile <name> --yes --overwrite
+```
+
+If `--dry-run` is present in `$ARGUMENTS`, append `--dry-run` to the command.
+
+Run the command via Bash. If the command fails with "command not found", tell the user:
+
+```
+claudenv is not on PATH. Install it with:
+  npm install -g claudenv
+```
+
+After successful execution, show the output and confirm the profile was applied.
+
+### 4. Usage Help
+
+Display:
+```
+Usage: /autonomy <action> [options]
+
+Actions:
+  status              Show current autonomy profile and permissions
+  safe                Switch to safe profile (read-only + limited bash)
+  moderate            Switch to moderate profile (read/write + controlled bash)
+  full                Switch to full profile (unrestricted — requires confirmation)
+  ci                  Switch to CI profile (optimized for CI/CD pipelines)
+
+Options:
+  --dry-run           Preview generated files without writing them
+
+Examples:
+  /autonomy status
+  /autonomy moderate
+  /autonomy full --dry-run
+```

package/scaffold/global/.claude/commands/canon.md

@@ -0,0 +1,33 @@
+---
+description: Показать или добавить ссылки в личный канон (~/.claudenv/memories/canon/index.yaml)
+allowed-tools: Bash(claudenv:*), Read
+argument-hint: [list [<topic>]|search <query>|add <topic> <url> --why "<reason>"]
+---
+
+# /canon — Личный канон ссылок
+
+Wrapper над `claudenv canon` CLI.
+
+## Routing
+
+Разбери `$ARGUMENTS`:
+
+- пусто или `list` → `claudenv canon list`
+- `list <topic>` → `claudenv canon list <topic>`
+- `search <query>` → `claudenv canon search "<query>"`
+- `add <topic> <url> --why "<reason>"` → `claudenv canon add <topic> <url> --why "<reason>"`
+- иначе если выглядит как topic slug → `claudenv canon list <slug>`
+- иначе → `claudenv canon search "$ARGUMENTS"`
+
+## Output
+
+Печатай stdout как есть. На non-zero exit code покажи stderr и подскажи usage.
+
+## Когда канон пуст
+
+Если `claudenv canon list` ничего не вернул:
+
+```
+Канон пока пуст. Добавь первые записи когда будешь делать /deeper —
+после deep dive предложу `claudenv canon add <topic> <url> --why "..."`.
+```

package/scaffold/global/.claude/commands/decisions.md

@@ -0,0 +1,29 @@
+---
+description: Показать или найти принятые vibe-decisions (последние N, по slug, или по поисковому запросу)
+allowed-tools: Bash(claudenv:*), Read
+argument-hint: [list|show <id>|search <query>] [--limit N] [--scope global|project|all]
+---
+
+# /decisions — Список и поиск принятых решений
+
+Wrapper над `claudenv decisions` CLI. Запускается из Bash, результат показывается пользователю как есть.
+
+## Routing
+
+Разбери `$ARGUMENTS`:
+
+- пусто или `list` → `claudenv decisions list --limit 10`
+- `list --limit N` → `claudenv decisions list --limit N`
+- `list --scope <s>` → `claudenv decisions list --scope <s>`
+- `show <id>` → `claudenv decisions show <id>`
+- `search <query>` → `claudenv decisions search "<query>"`
+- иначе если выглядит как id или slug → `claudenv decisions show "$ARGUMENTS"`
+- иначе → `claudenv decisions search "$ARGUMENTS"`
+
+## Output
+
+Печатай stdout команды без редактирования. Если команда вернула non-zero exit code — покажи stderr пользователю и предложи `claudenv decisions list` для проверки доступных id.
+
+## Если `claudenv` не на PATH
+
+Подскажи: `npm i -g claudenv` или `npx claudenv decisions list`.

package/scaffold/global/.claude/commands/deeper.md

@@ -0,0 +1,55 @@
+---
+description: Развернуть последнее принятое решение в подробное объяснение (deep dive — концепт, варианты, канон)
+allowed-tools: Read, Glob, Grep, WebSearch, WebFetch, Bash(claudenv:*), Bash(ls:*), Write, Edit
+argument-hint: [topic-or-decision-id]
+---
+
+# /deeper — Подробное объяснение последнего решения
+
+Развернуть последнее (или указанное в `$ARGUMENTS`) принятое vibe-decision в полный формат.
+
+## Step 1 — Find the target decision
+
+If `$ARGUMENTS` is empty:
+
+1. Run `claudenv decisions list --limit 1` (Bash) — get the most recent decision id
+2. Run `claudenv decisions show <id>` to load its frontmatter
+
+If `$ARGUMENTS` is a topic slug or id:
+
+1. Run `claudenv decisions show $ARGUMENTS` to load it
+2. If not found — fall back to `claudenv decisions search "$ARGUMENTS"` and pick the top match
+
+If nothing matches:
+
+```
+Не нашёл недавнего решения. Сначала сделай нетривиальный выбор — vibe-decisions залогирует его. Потом вызови /deeper.
+```
+
+Stop here.
+
+## Step 2 — Expand into the deep dive format
+
+Follow `~/.claude/skills/vibe-decisions/deep-dive-template.md` exactly:
+
+1. **Концептуально** (3-5 lines) — what it is, what problem it solves, name 1-2 alternatives
+2. **Как работает** (5-10 lines, optional code sketch) — simplified model + key invariants
+3. **2-3 варианта реализации** — for each: code sketch + when-suits / when-doesn't
+4. **Канон** — 2-4 references, **first** from `~/.claudenv/memories/canon/index.yaml` by topic; if no match, WebSearch and propose `claudenv canon add` afterward
+
+## Step 3 — Update the decision file
+
+Edit the original decision file to set:
+
+```yaml
+deep_dive_done: yes
+sources_consulted: [<urls and canon ids you cited>]
+```
+
+Preserve the `__VIBE_DECISION__` marker on the last line.
+
+## Style
+
+- User's language
+- Concrete to the actual task, not generic textbook
+- If a sketch is shorter than prose — use the sketch

package/scaffold/global/.claude/commands/just-code.md

@@ -0,0 +1,26 @@
+---
+description: Подавить vibe-decisions overview на следующий ответ — просто пиши код без brief overview
+allowed-tools: 
+argument-hint: 
+---
+
+# /just-code — Подавить vibe overview одноразово
+
+Эффект на ОДИН следующий ответ:
+
+- vibe-decisions skill НЕ выдаёт brief overview / auto-log block
+- Просто пишет код для текущей задачи
+- Decision файл НЕ создаётся для этого ответа
+- На ответ после следующего поведение возвращается к дефолту
+
+## В AUTO-LOG mode (loop)
+
+В loop эта команда фактически no-op для большинства случаев — auto-log не паузит, а просто логирует. `/just-code` пропускает логирование на один шаг. Это полезно когда выбор тривиален но vibe-decisions всё равно зажёгся.
+
+## В INTERACTIVE mode
+
+Пропускает паузу на следующем шаге. Используй когда явно знаешь что хочешь, без нужды в overview.
+
+## После использования
+
+Не нужно ничего откатывать — действие истекает само через один turn. Если хочешь надолго отключить vibe-decisions — отредактируй его SKILL.md trigger criteria.

package/scaffold/global/.claude/commands/why.md

@@ -0,0 +1,33 @@
+---
+description: Объяснить технологию или подход в контексте текущей задачи — без принятия решения и без записи в decisions/
+allowed-tools: Read, Glob, Grep, WebSearch, WebFetch, Bash(claudenv:*)
+argument-hint: <technology-or-question>
+---
+
+# /why — Краткое объяснение
+
+Объяснить `$ARGUMENTS` в контексте текущей задачи. Не вызывает vibe-decisions, не пишет в `~/.claudenv/memories/decisions/`.
+
+## Step 1 — Check canon first
+
+Run `claudenv canon search "$ARGUMENTS"` (Bash). If matches found — упомяни их как primary references.
+
+## Step 2 — Brief explanation (3-5 lines)
+
+Структура:
+
+- **Что это:** 1 строка
+- **Когда используется:** 1-2 строки
+- **Когда не подходит:** 1 строка
+- **Ссылки (опционально):** канон или WebSearch если канон пуст
+
+## Не делать
+
+- Не выводи vibe-decisions overview format (это explainer, не decision)
+- Не пиши файл в decisions/
+- Если пользователь после `/why` начинает реальный выбор технологии — тогда уже триггерится vibe-decisions skill
+
+## Style
+
+- User's language
+- Краткость > полнота. Для полноты есть `/deeper` после реального decision.