claudenv 1.3.0 → 1.3.2

package/scaffold/global/.claude/skills/claudenv/scaffold/.claude/skills/dynamic-workflows/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: dynamic-workflows
+description: |
+  Trigger when a task naturally decomposes into many independent sub-tasks
+  that benefit from deterministic multi-agent orchestration: reviewing or
+  migrating across many files, research over many sources, multi-dimension
+  audits, generate-N-then-judge, or "find all X" with verification. Use the
+  Workflow tool (agent()/parallel()/pipeline()). Also triggers on the word
+  "workflow"/"workflows" or an explicit ask to fan out / orchestrate
+  subagents. Do NOT trigger for single-file edits, strictly sequential work,
+  or anything one or two Agent calls already cover.
+---
+
+# Dynamic workflows
+
+Deterministic multi-agent orchestration via the built-in **Workflow** tool —
+a JavaScript script that fans work out across subagents (`agent()`),
+pipelines it (`pipeline()`), or barriers on it (`parallel()`). This skill
+decides *when* orchestration earns its cost and gives the minimal scaffold to
+launch one. The Workflow tool's own description carries the full API — lean on
+it; don't reproduce it here.
+
+## Mode detection (FIRST step every time)
+
+Check the system prompt for the marker `Dynamic-workflows mode (loop)`.
+
+- **Marker present** → LOOP mode. You are inside `claudenv loop`. Orchestrate
+  without pausing, but only for plan items that genuinely split into
+  independent sub-tasks, and keep fan-out narrow (see Cost discipline). The
+  goal is law — never pause to ask "запустить workflow?".
+- **Marker absent** → INTERACTIVE mode. Propose a one-line orchestration plan
+  (how many agents, what each does, pipeline vs parallel) and wait for the
+  user before launching.
+
+## When to orchestrate (triggers)
+
+Reach for a workflow when the work is *wide* — many items, each handled the
+same way, with little cross-talk:
+
+- **Review / audit** a diff across several dimensions (bugs, perf, security,
+  style), then adversarially verify each finding.
+- **Migrate / edit a pattern** across many files (worktree isolation per
+  agent when they mutate in parallel).
+- **Research** a question over many sources, then synthesize.
+- **Generate N independent attempts** (different angles), judge, synthesize
+  from the winner.
+- **"Find all X"** with a verification pass and loop-until-dry.
+
+## When NOT to orchestrate (anti-triggers)
+
+Stay single-threaded — a workflow is pure overhead here:
+
+- A single file, or a change that must happen in strict sequence.
+- Trivial edits, renames, formatting.
+- Anything one or two plain `Agent` calls already cover — prefer those.
+
+**Cost discipline.** Multi-agent fan-out costs roughly an order of magnitude
+more tokens than single-threaded work (~15×; see `claudenv-update-plan.md`).
+Single-threaded is the default. Orchestrate only when the width is real, and
+cap the number of concurrent agents to what the task needs.
+
+## How to launch (minimal scaffold)
+
+Every script starts with a pure-literal `meta`, then uses `pipeline()` as the
+default and `parallel()` only as a barrier when you genuinely need all
+prior-stage results at once. Pattern — review each dimension, verify each
+finding as soon as it lands:
+
+```js
+export const meta = {
+  name: 'review-diff',
+  description: 'Review the diff across dimensions and verify each finding',
+  phases: [{ title: 'Review' }, { title: 'Verify' }],
+}
+const DIMENSIONS = [
+  { key: 'bugs', prompt: 'Find correctness bugs in the diff…' },
+  { key: 'perf', prompt: 'Find performance regressions in the diff…' },
+]
+const results = await pipeline(
+  DIMENSIONS,
+  d => agent(d.prompt, { label: `review:${d.key}`, phase: 'Review', schema: FINDINGS }),
+  review => parallel(review.findings.map(f => () =>
+    agent(`Adversarially verify, default to refuted if unsure: ${f.title}`,
+      { label: `verify:${f.file}`, phase: 'Verify', schema: VERDICT })
+      .then(v => ({ ...f, verdict: v }))))
+)
+const confirmed = results.flat().filter(Boolean).filter(f => f.verdict?.isReal)
+return { confirmed }
+```
+
+Useful patterns (compose as the task needs): **adversarial-verify** (N
+skeptics per finding, kill on majority-refute), **loop-until-dry** (keep
+finding until K empty rounds), **judge panel** (N attempts → score →
+synthesize). Scale the agent count to the ask — a few for "quick check",
+more for "thorough audit".
+
+## Notes
+
+- `agent(prompt, { schema })` returns the validated object; without a schema
+  it returns the agent's final text.
+- Use `isolation: 'worktree'` only when agents mutate files in parallel and
+  would otherwise conflict — it is expensive.
+- In LOOP mode, if the Workflow tool's background completion does not resolve
+  under headless `claude -p`, fall back to plain parallel `Agent` calls for
+  the same fan-out — same spirit, no dependency on the background runtime.

package/scaffold/global/.claude/skills/harness/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: harness
+description: |
+  Trigger when the current task would be done far better with a capability you
+  don't yet have — a missing skill, connector, MCP server, browser automation,
+  or memory you should be using. Also triggers on "/harness", "подбери
+  инструменты", "what can you use here", "set yourself up for X", or when you
+  notice you're about to do by hand something a dedicated skill exists for. The
+  skill makes Claude self-aware of the claudenv harness and lets it EXTEND
+  itself: introspect (`claudenv capabilities`), find the right tool
+  (`claudenv skills search`), equip it (`claudenv skills add`), wire connectors
+  / MCP / memory, and bootstrap the kimi-webbridge browser. Do NOT trigger for
+  trivial edits that the current toolset already covers.
+---
+
+# harness — self-aware, self-extending setup
+
+claudenv is your harness: a CLI + a set of skills, connectors, memory layers and
+a browser bridge. This skill teaches you to **connect to claudenv, understand
+what it already gives you, find what's missing for the task at hand, and equip
+it** — autonomously, using claudenv's own commands. The goal is to pick the
+optimal harness for the work, not to do everything by hand.
+
+**Язык общения с пользователем — русский.** Команды и пути — как есть.
+
+## Mode detection (FIRST step every time)
+
+Check the system prompt for the marker `Harness mode (loop)`.
+
+- **Marker present → LOOP mode.** You are inside `claudenv loop`. Self-equip
+  without pausing, but **only with CURATED (★) skills** and known-safe bootstraps.
+  Never pause to ask "поставить скилл?". The goal is law.
+- **Marker absent → INTERACTIVE mode.** Propose what you'd equip in one short
+  block (what + why + trust level), then wait for the user before installing
+  anything non-trivial. Installing a curated skill is low-stakes; a live one is not.
+
+## Step 1 — Introspect (understand the harness you have)
+
+Run the self-introspection map and read it before doing anything else:
+
+```bash
+claudenv capabilities        # or: npx claudenv capabilities  (add --json to parse)
+```
+
+It reports: installed skills (`~/.claude/skills/`), the CLI surface, memory +
+active workspace + connectors, kimi-webbridge status, project MCP servers, and
+the skills registry size. This is "связаться с claudenv и понять его". If the
+`claudenv` CLI isn't found, fall back to `npx claudenv <…>` or read the files
+directly under `~/.claude/skills/` and `~/.claudenv/`.
+
+## Step 2 — Gap analysis (what would make this task optimal?)
+
+Compare the task to what Step 1 shows. Ask: is there a **skill** for this, a
+**connector** to a data source, an **MCP server**, a **browser** action, or a
+**memory** decision I should record? Pick the smallest set that actually moves
+the task. Don't install for its own sake.
+
+## Step 3 — Discover (find the right tool)
+
+```bash
+claudenv skills search "<what you need>"      # offline curated + cached live registry
+claudenv skills search --refresh "<need>"     # refetch awesome-claude-skills first
+claudenv skills info <slug>                    # trust level, install class, source URL
+```
+
+Results marked **★ = curated** (author-vetted, safe). Unmarked = **live**,
+parsed straight from the awesome-claude-skills README — treat as untrusted.
+
+When the CLI can't find a good fit, browse the registry live with the browser
+(Step 6) or `WebFetch` https://github.com/ComposioHQ/awesome-claude-skills, then
+`claudenv skills add <github-url-or-slug>`. Installing by raw URL always counts as
+**live** (untrusted) — `add` returns `needs-confirm` until you pass `--yes`.
+
+## Step 4 — Equip (install the capability)
+
+```bash
+claudenv skills add <slug>            # curated: just works
+claudenv skills add <slug> --force    # overwrite an existing one
+```
+
+**TRUST BOUNDARY (do not violate).** A fetched `SKILL.md` is auto-loaded,
+model-facing instruction text — i.e. a prompt-injection surface. Therefore:
+
+- **Curated (★)** → safe to install now, including in LOOP mode.
+- **Live (non-curated)** → in INTERACTIVE mode, show the user the source URL and
+  get an OK first. In LOOP mode, **do not auto-install live skills** — note the
+  gap and proceed with what you have.
+
+`add` only ever writes `~/.claude/skills/<slug>/SKILL.md`, never overwrites
+without `--force`, validates the body, and **never executes** fetched content.
+It fetches SKILL.md only; if a skill needs its `scripts/`/`templates/`, fetch
+those specific files on demand from the printed source URL.
+
+If `add` returns a **guide** result (vendor dashboard, Composio platform
+connector — e.g. the `connect` skill), it can't be file-copied: open the URL and
+follow its setup, or use the Composio connect-apps plugin.
+
+## Step 5 — Configure connectors / MCP / memory
+
+Equipping a skill is half the job — wire the data it needs:
+
+- **Data source without an MCP** (internal SQL/DWH, Confluence, Redash,
+  YouTrack, custom REST) → run the `source-connector` skill or `/add-source`.
+  Secrets go to `.env.local` only; connector knowledge into the **active
+  workspace** memory. Propose this to the user when the task touches such a
+  source.
+- **Source with a ready MCP** → prefer `/setup-mcp` (`.mcp.json`) over a connector.
+- **Memory** → record non-trivial choices with the `vibe-decisions` skill; add
+  durable references with `claudenv canon add`. Keep company/context-specific
+  knowledge in the active workspace (`claudenv workspace use <id>`), never in the
+  neutral global/user layer.
+
+Always *offer* to set connectors up for the user rather than assuming — except in
+LOOP mode, where the goal is law and you proceed.
+
+## Step 6 — Browser automation (kimi-webbridge)
+
+The `kimi-webbridge` skill drives the user's real browser (their logged-in
+sessions) — invaluable for live registry browsing, scraping, and any web task
+WebFetch can't reach. **Make it work even if it isn't installed yet:**
+
+```bash
+~/.kimi-webbridge/bin/kimi-webbridge status      # health check first
+claudenv skills add kimi-webbridge               # if absent: prints the bootstrap; --yes runs it
+claudenv skills add kimi-webbridge --yes         # installs via the official install.sh, starts the daemon
+~/.kimi-webbridge/bin/kimi-webbridge start       # if installed but stopped (idempotent)
+```
+
+If the daemon runs but `extension_connected` is false, tell the user to open
+their browser / install the Kimi WebBridge extension
+(https://www.kimi.com/features/webbridge). Full routing table:
+`~/.claude/skills/kimi-webbridge/references/operations.md`.
+
+## Step 7 — Confirm & remember
+
+After equipping, briefly tell the user what you added and why, and how to undo
+it (`rm -rf ~/.claude/skills/<slug>` / `claudenv skills list`). If the setup is
+durable and reusable, log it (vibe-decisions / canon / workspace memory) so the
+next session starts already equipped.
+
+## Anti-patterns
+
+- Installing skills "to be safe" without a task that needs them.
+- Auto-installing a live (non-curated) skill in LOOP mode, or without the user
+  in INTERACTIVE mode.
+- Putting secrets anywhere but `<project>/.env.local`.
+- Running a bootstrap `curl | bash` without surfacing the command first
+  (interactive) — `add` prints it and requires `--yes` to execute.

package/scaffold/global/.claude/skills/source-connector/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: source-connector
+description: |
+  Trigger when the user wants to connect to a data source that has no ready
+  MCP server - internal SQL/DWH behind VPN, corporate wiki (Confluence),
+  Redash, YouTrack, a custom REST API - or says "добавь источник",
+  "подключись к <система>", "/add-source". The skill interviews the user,
+  generates a working connector script, stores credentials in .env.local
+  (gitignored, never in memory), and caches connector knowledge (params +
+  provenance) in the ACTIVE workspace memory, isolated from other workspaces.
+  Do NOT trigger for sources that already have an MCP server (prefer MCP),
+  or for trivial local file reads.
+---
+
+# Source connector
+
+Создаёт коннектор к источнику данных без готового MCP: внутренний SQL/DWH,
+корпоративная вики, Redash, YouTrack, самописный REST. Опрашивает юзера,
+генерирует рабочий скрипт, кладёт секреты в `.env.local`, кэширует знание о
+коннекторе (параметры + provenance) в память АКТИВНОГО workspace.
+
+## Step 0 - Workspace resolution (FIRST, every time)
+
+Память изолирована по пространствам (workspaces). Прежде чем что-либо писать:
+
+1. Определи активный workspace:
+   - env `CLAUDENV_WORKSPACE`, иначе файл `~/.claudenv/active-workspace`.
+   - если есть `claudenv` CLI: `claudenv workspace show`.
+2. Если активного нет - предложи выбрать из `~/.claudenv/workspaces/` или создать
+   новый. НИКОГДА не подтягивай и не пиши в «глобальную» память доступы/коннекторы.
+3. Все записи коннектора пиши ТОЛЬКО в активный workspace:
+   `~/.claudenv/workspaces/<id>/memories/connectors/`.
+4. НИКОГДА не читай чужие workspaces - это барьер от ликов между компаниями.
+
+## Security invariants (нарушать нельзя)
+
+- **Секреты (пароли, токены, ключи) - только в `<project>/.env.local`** и только
+  значениями там. Убедись, что `.env.local` есть в `.gitignore` (добавь, если нет).
+- **В память коннектора - НИКОГДА значения секретов.** Только `secret_refs` -
+  имена переменных из `.env.local`.
+- **Не эхай секреты** в вывод/логи/коммиты.
+- Память активного workspace изолирована: не смешивай контекст разных компаний.
+
+## Trigger criteria
+
+Триггерь, если юзеру нужно регулярно/программно ходить в источник:
+- БД (MSSQL/Postgres/ClickHouse), DWH за VPN
+- корпоративная вики (Confluence), Redash, YouTrack, Grafana
+- самописный REST/GraphQL API
+
+НЕ триггерь:
+- если для источника есть MCP-сервер - предложи MCP (см. ниже)
+- разовое чтение локального файла
+- источник уже подключён (тогда это обновление, см. Step 6)
+
+## Step 1 - MCP vs connector
+
+Сначала проверь, нет ли готового MCP для источника (claudenv умеет настраивать MCP
+в `.mcp.json`). Если есть - предложи MCP-путь. Коннектор - для источников БЕЗ MCP.
+
+## Step 2 - Interview (спроси у юзера, кратко)
+
+Собери минимум для подключения:
+- тип источника (mssql / postgres / clickhouse / rest / confluence / redash / youtrack)
+- хост и порт, база/endpoint
+- метод аутентификации (sql login / domain / token / trusted)
+- что нужно достать (таблицы/эндпоинты) - для первого запроса
+- как зовутся переменные кред в `.env.local` (или предложи имена)
+
+Не выдумывай параметры - спрашивай. Если юзер уже дал часть (вики/git/переписка) -
+зафиксируй это в provenance.
+
+## Step 3 - Generate connector script
+
+Сгенерируй рабочий скрипт из шаблона (`templates/connector-*.ejs`):
+- MSSQL -> pymssql/pyodbc, строка `mssql+pymssql://{user}:{pwd}@{host}:{port}/{db}`
+  (СУЗ - логин без домена; экранируй пароль через urllib `quote_plus`).
+- REST -> requests + Bearer-токен из env.
+Скрипт читает креды из `.env.local` (через env), не хардкодит.
+
+## Step 4 - Secrets to .env.local
+
+- Запиши значения в `<project>/.env.local` (создай при отсутствии).
+- Проверь/добавь `.env.local` в `.gitignore`.
+- В память пойдут только имена этих переменных (`secret_refs`).
+
+## Step 5 - Write connector record (в активный workspace)
+
+Создай `~/.claudenv/workspaces/<id>/memories/connectors/<name>.md`:
+
+```markdown
+---
+name: <name>
+type: <mssql|rest|...>
+status: <draft|working|blocked>
+host: <host>
+database: <db|->
+port: <port|->
+auth: <sql|domain|token|trusted>
+secret_refs: {user: <ENV_VAR>, password: <ENV_VAR>}   # ИМЕНА, не значения
+connector_script: <path в проекте>
+provenance:                                            # откуда собрана инфа
+  - {source: <wiki|git|chat|docs>, ref: <url|путь>, note: <кратко>}
+verified_at: <YYYY-MM-DD|->
+updated_at: <YYYY-MM-DD>
+---
+
+Детали: как устроено подключение, что блокирует, как обновлять.
+```
+
+**Provenance обязателен** - фиксируй, откуда взял каждый факт (вики-страница, файл
+в git, сообщение в чате). Это позволяет потом перепроверить и обновить.
+
+## Step 6 - Test and iterate
+
+Протестируй подключение, если возможно. Зафиксируй `status` и `verified_at`.
+При ошибке - запиши симптом в запись (раздел деталей) и предложи следующий шаг.
+
+## Step 7 - Updating an existing connector
+
+Если коннектор уже есть в активном workspace:
+- найди запись, обнови `status`/`host`/`secret_refs`, допиши `provenance`,
+  обнови `updated_at`. Запись - единый источник правды по коннектору.
+
+## После создания
+
+Предложи дальнейшую автоматизацию через коннектор (регулярная выгрузка, отчёт,
+интеграция в пайплайн). Язык общения - русский.

package/src/bundled-catalog.js

@@ -0,0 +1,165 @@
+/**
+ * Curated catalog of high-value Claude skills, shipped with claudenv so that
+ * `claudenv skills search` / `add` work OFFLINE and so that the most useful
+ * entries carry a HARD, author-vetted install classification.
+ *
+ * Why a bundled catalog at all? The awesome-claude-skills registry is a plain
+ * markdown README with heterogeneous links (in-repo folders, external repos,
+ * vendor dashboards, Composio platform connectors). A fetched SKILL.md is
+ * auto-loaded, model-facing instruction text — so it is a prompt-injection
+ * surface. The trust boundary:
+ *
+ *   - CURATED (this file)        → vetted SOURCE url + install class (the bytes
+ *                                  are still fetched live at add-time, not
+ *                                  content-pinned) → the only entries allowed to
+ *                                  auto-equip, including inside `claudenv loop`.
+ *   - LIVE (parsed from README)  → untrusted → gated: installSkill returns
+ *                                  needs-confirm without confirmLive; the harness
+ *                                  skill / a human confirms before installing.
+ *
+ * `install` is the resolved class (see skills-registry.js):
+ *   repo-path | in-repo | repo-root | bootstrap | guide
+ *
+ * URLs and classes here were verified against live endpoints
+ * (raw.githubusercontent.com 200s) on 2026-06-08. If an upstream repo moves,
+ * `claudenv skills add` degrades to an honest "open the link" guide.
+ */
+
+const A = 'https://github.com/ComposioHQ/awesome-claude-skills/tree/master';
+
+export const BUNDLED_CATALOG = [
+  // --- Browser automation (bootstrap — not a copyable SKILL.md) ---
+  {
+    slug: 'kimi-webbridge',
+    name: 'Kimi WebBridge',
+    category: 'Browser & Web',
+    description:
+      "Control the user's real browser (their login sessions) via a local daemon — navigate, click, fill, snapshot, screenshot, network capture. Powerful automation for any website.",
+    url: 'https://www.kimi.com/features/webbridge',
+    install: 'bootstrap',
+    bootstrap: 'curl -fsSL https://cdn.kimi.com/webbridge/install.sh | bash',
+    status: () => '~/.kimi-webbridge/bin/kimi-webbridge status',
+  },
+
+  // --- Connectors & integration ---
+  {
+    slug: 'connect',
+    name: 'Connect',
+    category: 'Connectors & Integration',
+    description:
+      'Connect Claude to 1000+ apps via Composio — send emails, create issues, post messages, update databases. Take real actions across Gmail, Slack, GitHub, Notion, and more.',
+    url: `${A}/connect`,
+    install: 'repo-path',
+  },
+  {
+    slug: 'mcp-builder',
+    name: 'MCP Builder',
+    category: 'Connectors & Integration',
+    description: 'Scaffold and build Model Context Protocol (MCP) servers to expose new tools to Claude.',
+    url: `${A}/mcp-builder`,
+    install: 'repo-path',
+  },
+
+  // --- Meta: extend the harness itself ---
+  {
+    slug: 'skill-creator',
+    name: 'Skill Creator',
+    category: 'Meta & Self-extension',
+    description: 'Author new Claude skills — structure, frontmatter, scripts, and best practices. Use to forge a missing capability instead of installing one.',
+    url: `${A}/skill-creator`,
+    install: 'repo-path',
+  },
+
+  // --- Document processing (anthropics/skills, branch main) ---
+  {
+    slug: 'docx',
+    name: 'docx',
+    category: 'Document Processing',
+    description: 'Create, edit, and analyze Word documents with tracked changes, comments, and formatting.',
+    url: 'https://github.com/anthropics/skills/tree/main/skills/docx',
+    install: 'repo-path',
+  },
+  {
+    slug: 'pdf',
+    name: 'pdf',
+    category: 'Document Processing',
+    description: 'Extract text, tables, and metadata from PDFs; merge and annotate them.',
+    url: 'https://github.com/anthropics/skills/tree/main/skills/pdf',
+    install: 'repo-path',
+  },
+  {
+    slug: 'pptx',
+    name: 'pptx',
+    category: 'Document Processing',
+    description: 'Read, generate, and adjust PowerPoint slides, layouts, and templates.',
+    url: 'https://github.com/anthropics/skills/tree/main/skills/pptx',
+    install: 'repo-path',
+  },
+  {
+    slug: 'xlsx',
+    name: 'xlsx',
+    category: 'Document Processing',
+    description: 'Spreadsheet manipulation: formulas, charts, and data transformations.',
+    url: 'https://github.com/anthropics/skills/tree/main/skills/xlsx',
+    install: 'repo-path',
+  },
+
+  // --- Development workflow (obra/superpowers, branch main) ---
+  {
+    slug: 'test-driven-development',
+    name: 'Test-Driven Development',
+    category: 'Development & Code Tools',
+    description: 'Drive any feature or bugfix test-first, before writing implementation code.',
+    url: 'https://github.com/obra/superpowers/tree/main/skills/test-driven-development',
+    install: 'repo-path',
+  },
+  {
+    slug: 'root-cause-tracing',
+    name: 'Root-Cause Tracing',
+    category: 'Development & Code Tools',
+    description: 'Trace an error that surfaces deep in execution back to its original trigger.',
+    url: 'https://github.com/obra/superpowers/tree/main/skills/root-cause-tracing',
+    install: 'repo-path',
+  },
+  {
+    slug: 'using-git-worktrees',
+    name: 'Using Git Worktrees',
+    category: 'Development & Code Tools',
+    description: 'Create isolated git worktrees with smart directory selection and safety verification.',
+    url: 'https://github.com/obra/superpowers/blob/main/skills/using-git-worktrees/',
+    install: 'repo-path',
+  },
+  {
+    slug: 'changelog-generator',
+    name: 'Changelog Generator',
+    category: 'Development & Code Tools',
+    description: 'Transform git commits into customer-friendly release notes.',
+    url: `${A}/changelog-generator`,
+    install: 'repo-path',
+  },
+
+  // --- Data & analysis ---
+  {
+    slug: 'postgres',
+    name: 'postgres',
+    category: 'Data & Analysis',
+    description: 'Run safe, read-only SQL against PostgreSQL with multi-connection support and defense-in-depth.',
+    url: 'https://github.com/sanjay3290/ai-skills/tree/main/skills/postgres',
+    install: 'repo-path',
+  },
+  {
+    slug: 'brainstorming',
+    name: 'Brainstorming',
+    category: 'Productivity & Organization',
+    description: 'Turn rough ideas into fully-formed designs through structured questioning and alternative exploration.',
+    url: 'https://github.com/obra/superpowers/tree/main/skills/brainstorming',
+    install: 'repo-path',
+  },
+];
+
+/** Quick lookup of a curated entry by slug (case-insensitive). */
+export function findBundled(slug) {
+  if (!slug) return null;
+  const s = String(slug).toLowerCase();
+  return BUNDLED_CATALOG.find((e) => e.slug.toLowerCase() === s) || null;
+}