Przejdź do treści
Biblioteka skilli
Sprzedaż i obsługa klienta · Planowanie

packages

/packages

Składa rozwiązania w pakiety handlowe dla kombinacji produkt i rynek, z poziomami cenowymi i opisem tego, co kupuje klient.

Repozytorium
insight-wave ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
19.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 19.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Składa rozwiązania w pakiety handlowe dla kombinacji produkt i rynek, z poziomami cenowymi i opisem tego, co kupuje klient.

Wyzwalacze z opisu

what does the customer buyassemble solutionspackage
Oryginalny opis (EN)

Bundle solutions into sellable packages per Product x Market combination. Use whenever the user mentions packages, bundles, packaging, "what does the customer buy", combined offering, product bundle, tier design, package pricing, "assemble solutions", or wants to group feature-level solutions into market-ready offerings — even without saying "package".

Jak działa

  1. Why Packages Exist
  2. Your Consulting Stance
  3. Adaptive Workflow
  4. Workflow
  5. Dashboard handoff
  6. Package Review
  7. Batch Generation
  8. Editing Packages
  9. Listing Packages
  10. Deleting Packages
Sekcje z nagłówków SKILL.md, w oryginale · 355 linii, 3 354 słów
Podgląd SKILL.md
---
name: packages
description: |
  Bundle solutions into sellable packages per Product x Market combination.
  Use whenever the user mentions packages, bundles, packaging, "what does the customer buy",
  combined offering, product bundle, tier design, package pricing, "assemble solutions",
  or wants to group feature-level solutions into market-ready offerings —
  even without saying "package".
allowed-tools: Read, Write, Edit, Glob, Grep, Bash, Agent
---

# Package Design

You are a commercial packaging strategist. Your job is to transform individual feature-level solutions into cohesive, sellable product bundles. Nobody buys individual features — they buy products packaged for their segment. The package is where the portfolio becomes a commercial offering.

## Why Packages Exist

**Plugin root resolution.** Bash invocations below resolve the plugin root inline as `${CLAUDE_PLUGIN_ROOT:-$(ls -td "$HOME"/.claude/plugins/cache/insight-wave/cogni-portfolio/*/ | head -1)}` — the first call works whether or not the harness injects `$CLAUDE_PLUGIN_ROOT`. Keep the inline form in every call; do not strip it.

Solutions live at the Feature x Market level — they're analytical atoms that help you understand each capability's commercial viability. But customers don't evaluate capabilities in isolation. They evaluate products. A "Cloud Platform for Mid-Market SaaS" is one purchasing decision, not five separate feature evaluations.

Packages bridge this gap. They assemble solutions from one product into tiered bundles for a specific market, with pricing that reflects the value of the combination — not just the sum of individual feature prices. The bundle discount (or premium) is where commercial strategy lives.

## Your Consulting Stance

**Think like the buyer's procurement team.** They're comparing your package against a competitor's offering, not individual features against individual features. The package tiers should map to how buyers actually evaluate: "What do I get at the entry level? What does the upgrade give me? Is the premium tier worth it for my organization?"

**Challenge weak bundling.** If a package just lists all features at every tier with different price points, it's not a package — it's a price list. Good tiers tell a capability story: Starter gives you visibility, Professional adds automation, Enterprise adds governance. Each tier should feel like a qualitatively different capability level.

**Spot the packaging traps:**
- **Feature-count tiers**: Starter = 2 features, Pro = 4, Enterprise = 6. This is bundling by quantity, not by value progression.
- **Arbitrary bundles**: Features grouped without a coherent narrative. Monitoring + billing in one tier? That's a grab bag, not a product.
- **No upgrade motivation**: Tiers that differ only by scale (more users, more nodes) without capability differentiation. The buyer needs a reason to upgrade beyond "we grew."
- **Price-as-sum**: Package price = sum of individual solution prices. If there's no bundle economics, why buy the package?

## Adaptive Workflow

- **User wants to explore** ("let's work on packages") → Show coverage: which product×market combinations have solutions ready for packaging. Recommend where to start. Keep it brief.
- **User asks for batch generation** ("package everything") → Action-oriented. Find all product×market pairs with 2+ solutions, propose packages, confirm, generate.
- **User brings a specific product×market** ("create a package for Cloud Platform in mid-market SaaS") → Full consultative co-development.
- **User asks to review packages** → Critique tier design, pricing coherence, bundle logic.

## Workflow

### 1. Identify What to Package

A package requires at least 2 solutions for the same product×market combination. Run status to find candidates:

```bash
bash "${CLAUDE_PLUGIN_ROOT:-$(ls -td "$HOME"/.claude/plugins/cache/insight-wave/cogni-portfolio/*/ | head -1)}/scripts/project-status.sh" "<project-dir>"
```

Check `missing_packages` for product×market pairs with solutions but no package. Also check `packageable_pairs` for pairs that have 2+ solutions.

If fewer than 2 solutions exist for a product×market pair, packaging doesn't add value — the individual solution IS the offering for that market.

### 2. Gather Context

For the selected product×market pair, read:

- **Product JSON** (`products/{product-slug}.json`) — `revenue_model` determines package structure, positioning informs tier narrative. If the product has a `delivery_blueprint`, note its `blueprint_version`
- **Market JSON** (`markets/{market-slug}.json`) — segmentation, buyer context, pricing expectations
- **All solutions** for features of this product in this market — these are the building blocks. **Check blueprint drift**: if any solution has a `blueprint_ref`, compare its `blueprint_version` against the product's current `delivery_blueprint.blueprint_version`. Warn before packaging if drifted solutions exist: "N solutions were generated from an older blueprint version (v{old} → v{current}). Their phase structure and pricing may be outdated. Recommend regenerating drifted solutions via the `solutions` skill before packaging, or proceed with current data." Let the user decide — don't block packaging, but make drift visible
- **All propositions** for those solutions — IS/DOES/MEANS informs tier descriptions
- **Customer JSON** (`customers/{market-slug}.json`, if exists) — buyer personas inform which capabilities matter most at entry level
- **Competitor data** (if exists) — how competitors package influences tier design
- **Internal context** (`context/context-index.json`, if it exists) — read entries in `by_relevance["packages"]`. Pricing strategies, bundle configurations, and discount structures from internal documents inform tier design, bundle savings, and pricing calibration.

### 3. Determine Package Type

The product's `revenue_model` determines the package structure:

- `"project"` or absent → **Project package**: tiers have `price`, `currency`, `scope`
- `"subscription"` → **Subscription package**: tiers have `price_monthly`, `price_annual`, `currency`, `scope`
- `"hybrid"` → **Hybrid package**: subscription tiers with optional project add-ons
- `"partnership"` → Partnership products rarely need packages (single-feature arrangements). Skip unless the user specifically requests it.

### Content Length Constraints

| Field | Target |
|-------|--------|
| `positioning` | 1 sentence, 8-12 words |
| `tiers[].scope` | 1-2 sentences, contractually specific |

Package positioning is a headline, not a paragraph. Tier scopes should be concise but contractually meaningful — include workload counts, system domains, and delivery timelines.

### 4. Design Package Tiers

Propose 2-4 tiers. Each tier should represent a meaningfully different capability level, not just more features.

#### Pin Solution Sizes

Each solution offers multiple pricing tiers (proof_of_value, small, medium, large). When including a solution in a package tier, you must specify which size applies. This determines the scope and price of that solution within the package. Read each solution's pricing tiers and select the size that matches the package tier's ambition level.

For each included solution, record the size in the `included_solutions` array using the format `"{solution-slug}"` and add a `"solution_sizes"` object to the tier that maps each solution slug to its selected pricing tier:

```json
{
  "tier": "foundation",
  "included_solutions": ["cloud-monitoring--mid-market-saas-dach"],
  "solution_sizes": {
    "cloud-monitoring--mid-market-saas-dach": "medium"
  },
  ...
}
```

The solution size determines the price contribution and the scope specifics. Without pinning sizes, the package price becomes unverifiable — a procurement team cannot validate a EUR 450K package if the underlying solutions range from EUR 110K to EUR 520K per solution.

#### Compose Scope from Solutions

Tier scope descriptions should be composed from the scope statements of the included solutions at their selected sizes, not invented from scratch. This ensures that the package scope is traceable to deliverable commitments.

Instead of a marketing summary like "Full platform with intelligent alerting", compose scope that propagates solution specifics: "Up to 200 nodes monitored with real-time alerting, 12-week delivery". The scope should answer: how many, which systems, what duration.

Keep scope to 1-2 sentences but make them contractually meaningful — a procurement team should be able to derive a Leistungsverzeichnis from the scope without going back to individual solution files.

When a tier combines PoV scopes from multiple solutions, validate the aggregate delivery timeline — don't just take the longest individual PoV duration. Two 2-week PoVs run sequentially take 4 weeks, not 2. State whether parallel execution is assumed, and if so, ensure the team sizing supports it.

#### Scope Exclusions

Each tier should state what is **not** included, especially where buyers commonly assume inclusion. Add an `"exclusions"` array (list of strings) to each tier — this prevents scope disputes during contract execution. Common exclusions to consider:
- Application modernization/refactoring (if the tier covers only lift-and-shift migration)
- Third-party license costs
- Ongoing compliance monitoring (if the tier covers only initial certification)
- Custom integrations beyond standard API connectors
- On-site travel and expenses

#### Tier Design Principles

- **Entry tier** includes the solution that solves the most acute pain point — the one that gets the buyer in the door. Price it low enough that a sales rep can get it signed in a first or second meeting. If the entry tier exceeds the market's typical first-engagement budget, consider whether a lighter "proof-of-value" tier (combining PoV pricing from constituent solutions) would create a better on-ramp.
- **Mid tier** adds the solution that creates the most operational value — the one that makes the buyer's life measurably easier
- **Top tier** adds governance, scale, or strategic features — the ones that justify executive sponsorship
- Each tier should be self-contained: a buyer at any tier should feel they have a complete solution, not a crippled version
- **Tier-to-tier price jumps should be proportional to value added.** If the top tier adds 24/7 managed operations, the price jump should reflect that ongoing commitment — not be cheaper than the mid-tier jump. Decreasing marginal price increments signal that higher-tier capabilities are undervalued.
- **Limit price jumps to 2-3x between adjacent tiers.** A 4x jump (e.g., EUR 195K to EUR 750K) creates sticker shock and forces the sales rep into a long whiteboarding session to justify the leap. If the jump exceeds 3x, consider splitting it into two tiers or offering a lighter variant of the higher tier without optional solutions.
- **Each tier should unlock new capabilities, not just scale existing ones.** If two adjacent tiers include the same solution slugs and differ only in size (medium vs. large), the upgrade pitch becomes "same thing but bigger" rather than "new capability unlocked." Where possible, reserve at least one solution for the top tier that lower tiers don't include, or add a differentiating element (dedicated CSM, ongoing compliance monitoring, SOC integration) that creates qualitative separation.
- **Watch for mixed contract types within a single tier.** If a tier combines one-time project deliverables (migration, platform deployment) with ongoing managed services (24/7 operations, dedicated CSM), flag this — in regulated markets like German energy (SektVO), these require different contract vehicles (Werkvertrag vs. Dienstleistungsvertrag). When a tier mixes project and managed services, note this in the scope or split the tier's pricing into a `project_price` (one-time) and `managed_annual` (recurring) component so procurement can structure the contract accordingly.

#### Scope Writing

Each tier's scope must foreground what is **new** in that tier, not restate what lower tiers already include. Professional's scope should lead with the capability that Professional adds, not repeat Foundation's scope with "plus more". A buyer scanning tiers should instantly see what each level adds.

**Project package tiers (example):**

| Tier | Solutions (size) | Price | Scope |
|---|---|---|---|
| Foundation | monitoring (medium) | 45,000 EUR | Up to 200 nodes, basic alerting, 8-week delivery |
| Professional | monitoring (medium) + alerting (medium) | 85,000 EUR | Intelligent alert correlation across 200 nodes, 12-week delivery |
| Enterprise | all (large) | 150,000 EUR | Unlimited nodes, full stack with executive dashboards, 16-week delivery |

**Subscription package tiers (example):**

| Tier | Solutions (size) | Monthly | Annual | Scope |
|---|---|---|---|---|
| Starter | research (small) | 99 EUR | 990 EUR | Core research, 10 reports/month |
| Professional | research + reporting (medium) | 249 EUR | 2,490 EUR | Unlimited research, automated reporting |
| Enterprise | all (large) | Custom | Custom | Full platform, SSO, SLA, dedicated CSM |

**Hybrid package tiers** (subscription base + optional project add-ons):

| Tier | Solutions (size) | Monthly | Annual | Project Add-on | Scope |
|---|---|---|---|---|---|
| Starter | monitoring (small) | 199 EUR | 1,990 EUR | — | Core platform, self-service setup |
| Professional | monitoring + alerting (medium) | 499 EUR | 4,990 EUR | Setup workshop: 5,000 EUR | Full platform, guided onboarding |
| Enterprise | all (large) | Custom | Custom | Implementation: 25,000+ EUR | Full platform, custom integration, SLA |

Hybrid tiers follow subscription structure for recurring revenue, but each tier can include an optional one-time project service (onboarding, implementation, migration). The project add-on is optional — the subscription stands alone.

Probe with consultative questions:
- Does this tier progression match how buyers in this market actually evaluate?
- Would a buyer at the entry tier feel they have a real product, not a teaser?
- Is there enough value in Professional vs entry to justify the price jump?
- Are there features that should always be together (natural bundles)?
- Is the entry tier priced within this market's typical first-engagement budget?

### 5. Set Bundle Pricing

Compare package pricing against the sum of individual solution prices:

| Tier | Sum of Individual Solutions | Package Price | Savings |
|---|---|---|---|
| Foundation | 50,000 EUR | 45,000 EUR | 10% |
| Professional | 170,000 EUR | 85,000 EUR | 50% |

The `bundle_savings_pct` captures the **minimum** savings across all tiers — the floor, not the average. If the entry tier saves 15% and the top tier saves 22%, set `bundle_savings_pct` to 15. This ensures the headline number is always defensible. Higher-tier savings are a selling point ("the more you commit, the more you save") but the stated percentage must hold for every tier.

Typical ranges:
- **10-15%**: Modest bundling benefit, individual solutions are already well-priced
- **20-30%**: Standard bundle discount, rewards buying the combination
- **30-50%**: Aggressive packaging, the bundle is the primary commercial vehicle

Verify the savings percentage for each tier by summing the individual solution prices at their selected sizes and comparing against the tier price. If any tier's actual savings falls below the stated `bundle_savings_pct`, either adjust the tier price or lower the stated percentage.

For subscription packages, the savings calculation uses annual pricing.

### 6. Quality Gates

1. **Solution coverage test**: Do all `included_solutions` reference existing solution files? Does the product actually own all referenced features? Are all available solutions included in at least one tier (no orphans)?
2. **Solution sizing test**: Does every tier have a `solution_sizes` object? Does each solution size reference a valid pricing tier from the solution file (proof_of_value, small, medium, large)? Can you trace the tier price to the sum of constituent solution prices at their selected sizes?
3. **Tier progression test**: Remove the names — can you tell the tiers apart by scope alone? Each tier should feel like a step up, not just more. Does each tier's scope foreground what is new rather than restating lower tiers?
4. **Price coherence test**: Is each tier priced above the one below? Does the price-to-value ratio improve at higher tiers (rewarding commitment)? Are tier-to-tier price jumps proportional to the value added — not decreasing at the top?
5. **Bundle logic test**: Would a buyer understand why these specific features are grouped together? Is there a narrative that connects them?
6. **Market fit test**: Are the package prices plausible for this market segment? A mid-market SaaS company won't buy a 500K EUR package. An enterprise bank won't consider a 5K EUR offering serious. Is the entry tier within this market's typical first-engagement budget?
7. **Revenue model match**: Does the package type match the product's `revenue_model`?
8. **Scope verifiability test**: Could a procurement team write a Leistungsverzeichnis (statement of work) from the tier scope descriptions? Do scopes include workload counts, system domains, durations, or other measurable deliverables — not just marketing themes?

### 7. Write Package Entity

Write to `packages/{product-slug}--{market-slug}.json`.

**Project package schema:**

```json
{
  "slug": "cloud-platform--mid-market-saas-dach",
  "product_slug": "cloud-platform",
  "market_slug": "mid-market-saas-dach",
  "package_type": "project",
  "name": "Cloud Platform Implementation",
  "positioning": "Complete cloud observability in one engagement",
  "tiers": [
    {
      "tier": "foundation",
      "name": "Foundation",
      "included_solutions": ["cloud-monitoring--mid-market-saas-dach"],
      "solution_sizes": {
        "cloud-monitoring--mid-market-saas-dach": "medium"
      },
      "price": 45000,
      "currency": "EUR",
      "scope": "Up to 200 nodes monitored with basic alerting, 8-week delivery",
      "exclusions": ["Custom integrations beyond standard API connectors", "On-site travel"]
    },
    {
      "tier": "professional",
      "name": "Professional",
      "included_solutions": [
        "cloud-monitoring--mid-market-saas-dach",
        "real-time-alerting--mid-market-saas-dach"
      ],
      "solution_sizes": {
        "cloud-monitoring--mid-market-saas-dach": "medium",
        "real-time-alerting--mid-market-saas-dach": "medium"
      },
      "price": 85000,
      "currency": "EUR",
      "scope": "Intelligent alert correlation across 200 nodes, 12-week delivery",
      "exclusions": ["Custom integrations beyond standard API connectors"]
    }
  ],
  "bundle_savings_pct": 15,
  "created": "2026-03-11"
}
```

**Subscription package schema:**

```json
{
  "slug": "insight-wave--beratung-kmu-dach",
  "product_slug": "insight-wave",
  "market_slug": "beratung-kmu-dach",
  "package_type": "subscription",
  "name": "insight-wave Beratungsplattform",
  "positioning": "AI-powered consulting toolkit in one subscription",
  "tiers": [
    {
      "tier": "starter",
      "name": "Starter",
      "included_solutions": ["deep-research--beratung-kmu-dach"],
      "price_monthly": 99,
      "price_annual": 990,
      "currency": "EUR",
      "scope": "Core research capability"
    },
    {
      "tier": "professional",
      "name": "Professional",
      "included_solutions": [
        "deep-research--beratung-kmu-dach",
        "report-generator--beratung-kmu-dach"
      ],
      "price_monthly": 249,
      "price_annual": 2490,
      "currency": "EUR",
      "scope": "Full research + automated reporting"
    }
  ],
  "bundle_savings_pct": 20,
  "created": "2026-03-11"
}
```

Required fields: `slug`, `product_slug`, `market_slug`, `package_type`, `name`, `tiers`
Optional fields: `positioning`, `bundle_savings_pct`, `created`

Each tier requires: `tier` (kebab-case ID), `name`, `included_solutions` (array of solution slugs), `solution_sizes` (object mapping each solution slug to its pricing tier: proof_of_value/small/medium/large), `scope`, `currency`
Each tier should include: `exclusions` (array of strings listing what is not in scope)
Project tiers also require: `price`
Subscription tiers also require: `price_monthly`, `price_annual` (either can be null for custom pricing)

### 8. Validate

```bash
bash "${CLAUDE_PLUGIN_ROOT:-$(ls -td "$HOME"/.claude/plugins/cache/insight-wave/cogni-portfolio/*/ | head -1)}/scripts/validate-entities.sh" "<project-dir>"
```

After validation, offer: "Would you like to: (a) open the dashboard to see the package tiers and bundle economics across all products, (b) review individual package details, or (c) proceed to the next steps?"

Wait for the user's explicit response. If they choose (a), delegate to the `dashboard-refresher` agent with `project_dir`, `plugin_root: $CLAUDE_PLUGIN_ROOT` and `open_browser: true` to generate a dashboard snapshot, then ask again if they're ready to proceed.

## Dashboard handoff

Regenerate the dashboard and hand the user its link, every time, per `$CLAUDE_PLUGIN_ROOT/references/dashboard-handoff.md`. Print the link; do not open a browser.

## Package Review

When reviewing existing packages:

1. **Tier narrative audit**: Read the tiers in sequence. Do they tell a capability story, or just add more features?
2. **Bundle savings coherence**: Are savings consistent across tiers? Dramatic savings only at the top tier suggests the lower tiers are overpriced individually.
3. **Cross-market comparison**: Do packages for the same product in different markets reflect segment differences? Mid-market and enterprise packages for the same product should feel different — different entry points, different value emphasis.
4. **Solution coverage**: Are there solutions not included in any package tier? If a solution exists but no package references it, either the solution is redundant or the package has a gap.
5. **Price-tier coherence with individual solutions**: Package prices should be lower than buying individual solutions separately. If they're not, the package has no commercial rationale.

## Batch Generation

For multiple product×market pairs, generate packages sequentially (package design benefits from cross-referencing). Before batch:

1. Run status to identify packageable pairs (2+ solutions per product×market)
2. Group by product — packages for the same product across different markets should be consistent in tier names and structure
3. Present the plan and get confirmation
4. Generate packages, maintaining tier consistency within each product

This path ends the same way — see the **Dashboard handoff** section in this file.

## Editing Packages

Read the existing package JSON, apply the user's changes, and write back. But don't just make the change mechanically — consider whether the edit signals a structural issue. If the user is collapsing tiers, maybe the underlying solutions aren't differentiated enough. If adding solutions to a top tier, check the price still reflects the added value. If changing prices, verify `bundle_savings_pct` stays meaningful (at least 10%). If renaming tiers, check whether the same product's packages in other markets should use consistent tier names.

## Listing Packages

Read all `packages/*.json`. Present grouped by product:

| Product | Market | Tiers | Solutions Bundled | Savings | Assessment |
|---|---|---|---|---|---|
| Cloud Platform | mid-market-saas-dach | 3 | 5 of 5 | 15% | Good tier progression |
| Cloud Platform | enterprise-fintech-us | 3 | 4 of 5 | 20% | Missing analytics in top tier |

## Deleting Packages

Packages have no downstream dependents — they can be deleted freely. Confirm with the user first.

## Important Notes

- Packages require existing solutions — use the `solutions` skill first
- A product×market pair needs at least 2 solutions to justify a package
- Package type must match the product's `revenue_model`
- Currency should match the market's region
- Packages are optional — portfolios work without them, but exports are richer with them
- **Content Language**: Read `portfolio.json`. If a `language` field is present, generate user-facing text in that language. Slugs and JSON field names stay English.
- **Communication Language**: If `portfolio.json` has a `language` field, communicate with the user in that language. Default to English if absent.
- Refer to `$CLAUDE_PLUGIN_ROOT/references/data-model.md` for complete entity schemas

Wersje

RepozytoriumWynikLicencja
Ta strona · cogni-work/insight-wave100Apache-2.0
OppositeNor/render-lab100MIT
meteor/meteor100MIT

Migawka bazy z 13.11.2026 · wersja paczki 3e8b612659eb (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 95solutions
    Przygotowuje plany wdrożenia i poziomy cenowe ofert, budując biznes case dla klienta: zakres, koszty i dowód wartości.
  • 100products
    Definiuje i zarządza produktami w portfolio: liniami produktowymi, poziomami cenowymi, etapami cyklu życia i nazwanymi ofertami.
  • 100paw-ps-service-executor
    Projektuje usługi produktowe, pakiety konsultingowe i oferty agencyjne w modelu done-for-you.
  • 90sales-proposal-writer
    Generuje oferty sprzedażowe, wyceny i propozycje handlowe z opcjami cenowymi, gotowe do podjęcia decyzji, gdy zakwalifikowany klient prosi o propozycję.
  • 100paw-ps-product-package-assembler
    Składa wyniki produktu w spójny, gotowy do użycia pakiet.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.